PageRenderTime 97ms CodeModel.GetById 35ms RepoModel.GetById 1ms app.codeStats 0ms

/src/scenegraph/svg_attributes.c

https://github.com/svettom/gpac-1
C | 6443 lines | 5960 code | 325 blank | 158 comment | 1469 complexity | a2132d966357a269fa240b28914370a7 MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0
  1. /*
  2. * GPAC Multimedia Framework
  3. *
  4. * Authors: Cyril Concolato - Jean le Feuvre - Jean-Claude Moissinac
  5. * Copyright (c) 2005-200X ENST
  6. * All rights reserved
  7. *
  8. * This file is part of GPAC / SVG Loader module
  9. *
  10. * GPAC is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU Lesser General Public License as published by
  12. * the Free Software Foundation; either version 2, or (at your option)
  13. * any later version.
  14. *
  15. * GPAC is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU Lesser General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU Lesser General Public
  21. * License along with this library; see the file COPYING. If not, write to
  22. * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23. *
  24. */
  25. #include <gpac/base_coding.h>
  26. #include <gpac/events.h>
  27. #include <gpac/nodes_svg.h>
  28. #ifndef GPAC_DISABLE_SVG
  29. #include <gpac/internal/scenegraph_dev.h>
  30. #define DUMP_COORDINATES 1
  31. static const struct dom_event_def {u32 event; const char *name; u32 category; } defined_dom_events [] =
  32. {
  33. { GF_EVENT_ABORT, "abort", GF_DOM_EVENT_DOM },
  34. { GF_EVENT_ERROR, "error", GF_DOM_EVENT_DOM },
  35. { GF_EVENT_LOAD, "load", GF_DOM_EVENT_DOM },
  36. { GF_EVENT_UNLOAD, "unload", GF_DOM_EVENT_DOM },
  37. /*focus - we differentiate from UI/key events to avoid browing focus if no listener is on place*/
  38. { GF_EVENT_FOCUSIN, "DOMFocusIn", GF_DOM_EVENT_FOCUS },
  39. { GF_EVENT_FOCUSIN, "focusin", GF_DOM_EVENT_FOCUS },
  40. { GF_EVENT_FOCUSOUT, "DOMFocusOut", GF_DOM_EVENT_FOCUS },
  41. { GF_EVENT_FOCUSOUT, "focusout", GF_DOM_EVENT_FOCUS },
  42. { GF_EVENT_CHANGE, "change", GF_DOM_EVENT_FOCUS },
  43. { GF_EVENT_FOCUS, "focus", GF_DOM_EVENT_FOCUS },
  44. { GF_EVENT_BLUR, "blur", GF_DOM_EVENT_FOCUS },
  45. /*key events*/
  46. { GF_EVENT_KEYDOWN, "keydown", GF_DOM_EVENT_KEY },
  47. { GF_EVENT_KEYDOWN, "accesskey", GF_DOM_EVENT_KEY },
  48. { GF_EVENT_KEYDOWN, "keypress", GF_DOM_EVENT_KEY },
  49. { GF_EVENT_KEYUP, "keyup", GF_DOM_EVENT_KEY },
  50. { GF_EVENT_LONGKEYPRESS, "longaccesskey", GF_DOM_EVENT_KEY },
  51. { GF_EVENT_CLICK, "click", GF_DOM_EVENT_MOUSE },
  52. { GF_EVENT_DBLCLICK, "dblclick", GF_DOM_EVENT_MOUSE },
  53. { GF_EVENT_MOUSEDOWN, "mousedown", GF_DOM_EVENT_MOUSE },
  54. { GF_EVENT_MOUSEMOVE, "mousemove", GF_DOM_EVENT_MOUSE },
  55. { GF_EVENT_MOUSEOUT, "mouseout", GF_DOM_EVENT_MOUSE },
  56. { GF_EVENT_MOUSEOVER, "mouseover", GF_DOM_EVENT_MOUSE },
  57. { GF_EVENT_MOUSEUP, "mouseup", GF_DOM_EVENT_MOUSE },
  58. { GF_EVENT_MOUSEWHEEL, "wheel", GF_DOM_EVENT_MOUSE },
  59. { GF_EVENT_MOUSEWHEEL, "SVGMousewheel", GF_DOM_EVENT_MOUSE },
  60. /*activate is not a basic DOM but a MOUSE and KEY event*/
  61. { GF_EVENT_ACTIVATE, "activate", GF_DOM_EVENT_MOUSE | GF_DOM_EVENT_KEY },
  62. { GF_EVENT_ACTIVATE, "DOMActivate", GF_DOM_EVENT_MOUSE | GF_DOM_EVENT_KEY },
  63. /*text events*/
  64. { GF_EVENT_TEXTINPUT, "textInput", GF_DOM_EVENT_TEXT },
  65. { GF_EVENT_TEXTSELECT, "select", GF_DOM_EVENT_TEXT },
  66. /*SMIL events*/
  67. { GF_EVENT_BEGIN, "begin", GF_DOM_EVENT_FAKE },
  68. { GF_EVENT_BEGIN_EVENT, "beginEvent", GF_DOM_EVENT_SMIL },
  69. { GF_EVENT_END, "end", GF_DOM_EVENT_FAKE },
  70. { GF_EVENT_END_EVENT, "endEvent", GF_DOM_EVENT_SMIL },
  71. { GF_EVENT_REPEAT, "repeat", GF_DOM_EVENT_FAKE },
  72. { GF_EVENT_REPEAT_EVENT, "repeatEvent", GF_DOM_EVENT_SMIL },
  73. /*all SVG/HTML/... UI events*/
  74. { GF_EVENT_RESIZE, "resize", GF_DOM_EVENT_UI },
  75. { GF_EVENT_SCROLL, "scroll", GF_DOM_EVENT_UI },
  76. { GF_EVENT_ZOOM, "zoom", GF_DOM_EVENT_UI },
  77. { GF_EVENT_LOAD, "SVGLoad", GF_DOM_EVENT_DOM },
  78. { GF_EVENT_RESIZE, "SVGResize", GF_DOM_EVENT_UI },
  79. { GF_EVENT_SCROLL, "SVGScroll", GF_DOM_EVENT_UI },
  80. { GF_EVENT_ZOOM, "SVGZoom", GF_DOM_EVENT_UI },
  81. /*mutation events and DCCI*/
  82. { GF_EVENT_TREE_MODIFIED, "DOMSubtreeModified", GF_DOM_EVENT_MUTATION },
  83. { GF_EVENT_NODE_INSERTED, "DOMNodeInserted", GF_DOM_EVENT_MUTATION },
  84. { GF_EVENT_NODE_REMOVED, "DOMNodeRemoved", GF_DOM_EVENT_MUTATION },
  85. { GF_EVENT_NODE_REMOVED_DOC, "DOMNodeRemovedFromDocument", GF_DOM_EVENT_MUTATION },
  86. { GF_EVENT_NODE_INSERTED_DOC, "DOMNodeInsertedIntoDocument", GF_DOM_EVENT_MUTATION },
  87. { GF_EVENT_ATTR_MODIFIED, "DOMAttrModified", GF_DOM_EVENT_MUTATION },
  88. { GF_EVENT_CHAR_DATA_MODIFIED, "DOMCharacterDataModified", GF_DOM_EVENT_MUTATION },
  89. { GF_EVENT_NODE_NAME_CHANGED, "DOMElementNameChanged", GF_DOM_EVENT_MUTATION },
  90. { GF_EVENT_ATTR_NAME_CHANGED, "DOMAttributeNameChanged", GF_DOM_EVENT_MUTATION },
  91. { GF_EVENT_DCCI_PROP_CHANGE, "DCCI-prop-change", GF_DOM_EVENT_MUTATION },
  92. /*LASeR events - some events are attached to other categorues*/
  93. { GF_EVENT_ACTIVATED, "activatedEvent", GF_DOM_EVENT_LASER },
  94. { GF_EVENT_DEACTIVATED, "deactivatedEvent", GF_DOM_EVENT_LASER },
  95. { GF_EVENT_EXECUTION_TIME, "executionTime", GF_DOM_EVENT_FAKE },
  96. { GF_EVENT_PAUSE, "pause", GF_DOM_EVENT_SMIL },
  97. { GF_EVENT_PAUSED_EVENT, "pausedEvent", GF_DOM_EVENT_SMIL },
  98. { GF_EVENT_PLAY, "play", GF_DOM_EVENT_SMIL },
  99. { GF_EVENT_RESUME_EVENT, "resumedEvent", GF_DOM_EVENT_SMIL },
  100. { GF_EVENT_REPEAT_KEY, "repeatKey", GF_DOM_EVENT_KEY },
  101. { GF_EVENT_SHORT_ACCESSKEY, "shortAccessKey", GF_DOM_EVENT_KEY },
  102. /*LASeR unofficial events*/
  103. { GF_EVENT_BATTERY, "battery", GF_DOM_EVENT_LASER },
  104. { GF_EVENT_CPU, "cpu", GF_DOM_EVENT_LASER },
  105. /*MediaAccess events*/
  106. #if 0
  107. { GF_EVENT_MEDIA_BEGIN_SESSION_SETUP, "BeginSessionSetup", GF_DOM_EVENT_MEDIA_ACCESS },
  108. { GF_EVENT_MEDIA_END_SESSION_SETUP, "EndSessionSetup", GF_DOM_EVENT_MEDIA_ACCESS },
  109. { GF_EVENT_MEDIA_DATA_REQUEST, "DataRequest", GF_DOM_EVENT_MEDIA_ACCESS },
  110. { GF_EVENT_MEDIA_PLAYABLE, "Playable", GF_DOM_EVENT_MEDIA_ACCESS },
  111. { GF_EVENT_MEDIA_NOT_PLAYABLE, "NotPlayable", GF_DOM_EVENT_MEDIA_ACCESS },
  112. { GF_EVENT_MEDIA_DATA_PROGRESS, "DataReceptionProgress", GF_DOM_EVENT_MEDIA_ACCESS },
  113. { GF_EVENT_MEDIA_END_OF_DATA, "EndOfDataReception", GF_DOM_EVENT_MEDIA_ACCESS },
  114. { GF_EVENT_MEDIA_STOP, "Stop", GF_DOM_EVENT_MEDIA_ACCESS },
  115. { GF_EVENT_MEDIA_ERROR, "Error", GF_DOM_EVENT_MEDIA_ACCESS },
  116. #endif
  117. { GF_EVENT_MEDIA_SETUP_BEGIN, "setupbegin", GF_DOM_EVENT_MEDIA},
  118. { GF_EVENT_MEDIA_SETUP_DONE, "setupdone", GF_DOM_EVENT_MEDIA},
  119. { GF_EVENT_MEDIA_LOAD_START, "loadstart", GF_DOM_EVENT_MEDIA },
  120. { GF_EVENT_MEDIA_LOAD_DONE, "loaddone", GF_DOM_EVENT_MEDIA },
  121. { GF_EVENT_MEDIA_PROGRESS, "progress", GF_DOM_EVENT_MEDIA },
  122. { GF_EVENT_MEDIA_SUSPEND, "suspend", GF_DOM_EVENT_MEDIA },
  123. { GF_EVENT_ABORT, "abort", GF_DOM_EVENT_MEDIA },
  124. { GF_EVENT_ERROR, "error", GF_DOM_EVENT_MEDIA },
  125. { GF_EVENT_MEDIA_EMPTIED, "emptied", GF_DOM_EVENT_MEDIA },
  126. { GF_EVENT_MEDIA_STALLED, "stalled", GF_DOM_EVENT_MEDIA },
  127. { GF_EVENT_MEDIA_LOADED_METADATA, "loadedmetadata", GF_DOM_EVENT_MEDIA },
  128. { GF_EVENT_MEDIA_LODADED_DATA, "loadeddata", GF_DOM_EVENT_MEDIA },
  129. { GF_EVENT_MEDIA_CANPLAY, "canplay", GF_DOM_EVENT_MEDIA },
  130. { GF_EVENT_MEDIA_CANPLAYTHROUGH, "canplaythrough", GF_DOM_EVENT_MEDIA },
  131. { GF_EVENT_MEDIA_PLAYING, "playing", GF_DOM_EVENT_MEDIA },
  132. { GF_EVENT_MEDIA_WAITING, "waiting", GF_DOM_EVENT_MEDIA },
  133. { GF_EVENT_MEDIA_SEEKING, "seeking", GF_DOM_EVENT_MEDIA },
  134. { GF_EVENT_MEDIA_SEEKED, "seeked", GF_DOM_EVENT_MEDIA },
  135. { GF_EVENT_MEDIA_ENDED, "ended", GF_DOM_EVENT_MEDIA },
  136. { GF_EVENT_MEDIA_DURATION_CHANGED, "durationchanged", GF_DOM_EVENT_MEDIA },
  137. { GF_EVENT_MEDIA_TIME_UPDATE, "timeupdate", GF_DOM_EVENT_MEDIA },
  138. { GF_EVENT_PLAY, "play", GF_DOM_EVENT_MEDIA },
  139. { GF_EVENT_PAUSE, "pause", GF_DOM_EVENT_MEDIA },
  140. { GF_EVENT_MEDIA_RATECHANGE, "ratechange", GF_DOM_EVENT_MEDIA },
  141. { GF_EVENT_MEDIA_VOLUME_CHANGED, "volumechange", GF_DOM_EVENT_MEDIA },
  142. /*GPAC internals*/
  143. { GF_EVENT_SCENE_ATTACHED, "gpac_scene_attached", GF_DOM_EVENT_DOM },
  144. { GF_EVENT_VP_RESIZE, "gpac_vp_changed", GF_DOM_EVENT_DOM },
  145. };
  146. GF_EXPORT
  147. u32 gf_dom_event_type_by_name(const char *name)
  148. {
  149. u32 i, count;
  150. count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);
  151. if (!name) return GF_EVENT_UNKNOWN;
  152. if ((name[0]=='o') && (name[1]=='n')) name += 2;
  153. for (i=0;i<count;i++) {
  154. if (!strcmp(name, defined_dom_events[i].name))
  155. return defined_dom_events[i].event;
  156. }
  157. return GF_EVENT_UNKNOWN;
  158. }
  159. const char *gf_dom_event_get_name(u32 type)
  160. {
  161. u32 i, count;
  162. count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);
  163. for (i=0;i<count;i++) {
  164. if (defined_dom_events[i].event == type)
  165. return defined_dom_events[i].name;
  166. }
  167. return "unknown";
  168. }
  169. u32 gf_dom_event_get_category(u32 type)
  170. {
  171. u32 i, count;
  172. count = sizeof(defined_dom_events) / sizeof(struct dom_event_def);
  173. for (i=0;i<count;i++) {
  174. if (defined_dom_events[i].event == type)
  175. return defined_dom_events[i].category;
  176. }
  177. return 0;
  178. }
  179. static const struct predef_keyid {u32 key_code; const char *name; } predefined_key_identifiers[] =
  180. {
  181. { GF_KEY_ACCEPT, "Accept" },
  182. { GF_KEY_AGAIN, "Again" },
  183. { GF_KEY_ALLCANDIDATES, "AllCandidates" },
  184. { GF_KEY_ALPHANUM, "Alphanumeric" },
  185. { GF_KEY_ALT, "Alt" },
  186. { GF_KEY_ALTGRAPH, "AltGraph" },
  187. { GF_KEY_APPS, "Apps" },
  188. { GF_KEY_ATTN, "Attn" },
  189. { GF_KEY_BROWSERBACK, "BrowserBack" },
  190. { GF_KEY_BROWSERFAVORITES, "BrowserFavorites" },
  191. { GF_KEY_BROWSERFORWARD, "BrowserForward" },
  192. { GF_KEY_BROWSERHOME, "BrowserHome" },
  193. { GF_KEY_BROWSERREFRESH, "BrowserRefresh" },
  194. { GF_KEY_BROWSERSEARCH, "BrowserSearch" },
  195. { GF_KEY_BROWSERSTOP, "BrowserStop" },
  196. { GF_KEY_CAPSLOCK, "CapsLock" },
  197. { GF_KEY_CLEAR, "Clear" },
  198. { GF_KEY_CODEINPUT, "CodeInput" },
  199. { GF_KEY_COMPOSE, "Compose" },
  200. { GF_KEY_CONTROL, "Control" },
  201. { GF_KEY_CRSEL, "Crsel" },
  202. { GF_KEY_CONVERT, "Convert" },
  203. { GF_KEY_COPY, "Copy" },
  204. { GF_KEY_CUT, "Cut" },
  205. { GF_KEY_DOWN, "Down" },
  206. { GF_KEY_END, "End" },
  207. { GF_KEY_ENTER, "Enter" },
  208. { GF_KEY_ERASEEOF, "EraseEof" },
  209. { GF_KEY_EXECUTE, "Execute" },
  210. { GF_KEY_EXSEL, "Exsel" },
  211. { GF_KEY_F1, "F1" },
  212. { GF_KEY_F2, "F2" },
  213. { GF_KEY_F3, "F3" },
  214. { GF_KEY_F4, "F4" },
  215. { GF_KEY_F5, "F5" },
  216. { GF_KEY_F6, "F6" },
  217. { GF_KEY_F7, "F7" },
  218. { GF_KEY_F8, "F8" },
  219. { GF_KEY_F9, "F9" },
  220. { GF_KEY_F10, "F10" },
  221. { GF_KEY_F11, "F11" },
  222. { GF_KEY_F12, "F12" },
  223. { GF_KEY_F13, "F13" },
  224. { GF_KEY_F14, "F14" },
  225. { GF_KEY_F15, "F15" },
  226. { GF_KEY_F16, "F16" },
  227. { GF_KEY_F17, "F17" },
  228. { GF_KEY_F18, "F18" },
  229. { GF_KEY_F19, "F19" },
  230. { GF_KEY_F20, "F20" },
  231. { GF_KEY_F21, "F21" },
  232. { GF_KEY_F22, "F22" },
  233. { GF_KEY_F23, "F23" },
  234. { GF_KEY_F24, "F24" },
  235. { GF_KEY_FINALMODE, "FinalMode" },
  236. { GF_KEY_FIND, "Find" },
  237. { GF_KEY_FULLWIDTH, "FullWidth" },
  238. { GF_KEY_HALFWIDTH, "HalfWidth" },
  239. { GF_KEY_HANGULMODE, "HangulMode" },
  240. { GF_KEY_HANJAMODE, "HanjaMode" },
  241. { GF_KEY_HELP, "Help" },
  242. { GF_KEY_HIRAGANA, "Hiragana" },
  243. { GF_KEY_HOME, "Home" },
  244. { GF_KEY_INSERT, "Insert" },
  245. { GF_KEY_JAPANESEHIRAGANA, "JapaneseHiragana" },
  246. { GF_KEY_JAPANESEKATAKANA, "JapaneseKatakana" },
  247. { GF_KEY_JAPANESEROMAJI, "JapaneseRomaji" },
  248. { GF_KEY_JUNJAMODE, "JunjaMode" },
  249. { GF_KEY_KANAMODE, "KanaMode" },
  250. { GF_KEY_KANJIMODE, "KanjiMode" },
  251. { GF_KEY_KATAKANA, "Katakana" },
  252. { GF_KEY_LAUNCHAPPLICATION1, "LaunchApplication1" },
  253. { GF_KEY_LAUNCHAPPLICATION2, "LaunchApplication2" },
  254. { GF_KEY_LAUNCHMAIL, "LaunchMail" },
  255. { GF_KEY_LEFT, "Left" },
  256. { GF_KEY_META, "Meta" },
  257. { GF_KEY_MEDIANEXTTRACK, "MediaNextTrack" },
  258. { GF_KEY_MEDIAPLAYPAUSE, "MediaPlayPause" },
  259. { GF_KEY_MEDIAPREVIOUSTRACK, "MediaPreviousTrack" },
  260. { GF_KEY_MEDIASTOP, "MediaStop" },
  261. { GF_KEY_MODECHANGE, "ModeChange" },
  262. { GF_KEY_NONCONVERT, "Nonconvert" },
  263. { GF_KEY_NUMLOCK, "NumLock" },
  264. { GF_KEY_PAGEDOWN, "PageDown" },
  265. { GF_KEY_PAGEUP, "PageUp" },
  266. { GF_KEY_PASTE, "Paste" },
  267. { GF_KEY_PAUSE, "Pause" },
  268. { GF_KEY_PLAY, "Play" },
  269. { GF_KEY_PREVIOUSCANDIDATE, "PreviousCandidate" },
  270. { GF_KEY_PRINTSCREEN, "PrintScreen" },
  271. { GF_KEY_PROCESS, "Process" },
  272. { GF_KEY_PROPS, "Props" },
  273. { GF_KEY_RIGHT, "Right" },
  274. { GF_KEY_ROMANCHARACTERS, "RomanCharacters" },
  275. { GF_KEY_SCROLL, "Scroll" },
  276. { GF_KEY_SELECT, "Select" },
  277. { GF_KEY_SELECTMEDIA, "SelectMedia" },
  278. { GF_KEY_SHIFT, "Shift" },
  279. { GF_KEY_STOP, "Stop" },
  280. { GF_KEY_UP, "Up" },
  281. { GF_KEY_UNDO, "Undo" },
  282. { GF_KEY_VOLUMEDOWN, "VolumeDown" },
  283. { GF_KEY_VOLUMEMUTE, "VolumeMute" },
  284. { GF_KEY_VOLUMEUP, "VolumeUp" },
  285. { GF_KEY_WIN, "Win" },
  286. { GF_KEY_ZOOM, "Zoom" },
  287. { GF_KEY_BACKSPACE, "U+0008" },
  288. { GF_KEY_TAB, "U+0009" },
  289. { GF_KEY_CANCEL, "U+0018" },
  290. { GF_KEY_ESCAPE, "U+001B" },
  291. { GF_KEY_SPACE, "U+0020" },
  292. { GF_KEY_EXCLAMATION, "U+0021" },
  293. { GF_KEY_QUOTATION, "U+0022" },
  294. { GF_KEY_NUMBER, "U+0023" },
  295. { GF_KEY_DOLLAR, "U+0024" },
  296. { GF_KEY_AMPERSAND, "U+0026" },
  297. { GF_KEY_APOSTROPHE, "U+0027" },
  298. { GF_KEY_LEFTPARENTHESIS, "U+0028" },
  299. { GF_KEY_RIGHTPARENTHESIS, "U+0029" },
  300. { GF_KEY_STAR, "U+002A" },
  301. { GF_KEY_PLUS, "U+002B" },
  302. { GF_KEY_COMMA, "U+002C" },
  303. { GF_KEY_HYPHEN, "U+002D" },
  304. { GF_KEY_FULLSTOP, "U+002E" },
  305. { GF_KEY_SLASH, "U+002F" },
  306. { GF_KEY_0, "U+0030" },
  307. { GF_KEY_1, "U+0031" },
  308. { GF_KEY_2, "U+0032" },
  309. { GF_KEY_3, "U+0033" },
  310. { GF_KEY_4, "U+0034" },
  311. { GF_KEY_5, "U+0035" },
  312. { GF_KEY_6, "U+0036" },
  313. { GF_KEY_7, "U+0037" },
  314. { GF_KEY_8, "U+0038" },
  315. { GF_KEY_9, "U+0039" },
  316. { GF_KEY_COLON, "U+003A" },
  317. { GF_KEY_SEMICOLON, "U+003B" },
  318. { GF_KEY_LESSTHAN, "U+003C" },
  319. { GF_KEY_EQUALS, "U+003D" },
  320. { GF_KEY_GREATERTHAN, "U+003E" },
  321. { GF_KEY_QUESTION, "U+003F" },
  322. { GF_KEY_AT, "U+0040" },
  323. { GF_KEY_A, "U+0041" },
  324. { GF_KEY_B, "U+0042" },
  325. { GF_KEY_C, "U+0043" },
  326. { GF_KEY_D, "U+0044" },
  327. { GF_KEY_E, "U+0045" },
  328. { GF_KEY_F, "U+0046" },
  329. { GF_KEY_G, "U+0047" },
  330. { GF_KEY_H, "U+0048" },
  331. { GF_KEY_I, "U+0049" },
  332. { GF_KEY_J, "U+004A" },
  333. { GF_KEY_K, "U+004B" },
  334. { GF_KEY_L, "U+004C" },
  335. { GF_KEY_M, "U+004D" },
  336. { GF_KEY_N, "U+004E" },
  337. { GF_KEY_O, "U+004F" },
  338. { GF_KEY_P, "U+0050" },
  339. { GF_KEY_Q, "U+0051" },
  340. { GF_KEY_R, "U+0052" },
  341. { GF_KEY_S, "U+0053" },
  342. { GF_KEY_T, "U+0054" },
  343. { GF_KEY_U, "U+0055" },
  344. { GF_KEY_V, "U+0056" },
  345. { GF_KEY_W, "U+0057" },
  346. { GF_KEY_X, "U+0058" },
  347. { GF_KEY_Y, "U+0059" },
  348. { GF_KEY_Z, "U+005A" },
  349. { GF_KEY_LEFTSQUAREBRACKET, "U+005B" },
  350. { GF_KEY_BACKSLASH, "U+005C" },
  351. { GF_KEY_RIGHTSQUAREBRACKET, "U+005D" },
  352. { GF_KEY_CIRCUM, "U+005E" },
  353. { GF_KEY_UNDERSCORE, "U+005F" },
  354. { GF_KEY_GRAVEACCENT, "U+0060" },
  355. { GF_KEY_LEFTCURLYBRACKET, "U+007B" },
  356. { GF_KEY_PIPE, "U+007C" },
  357. { GF_KEY_RIGHTCURLYBRACKET, "U+007D" },
  358. { GF_KEY_DEL, "U+007F" },
  359. { GF_KEY_INVERTEXCLAMATION, "U+00A1" },
  360. { GF_KEY_DEADGRAVE, "U+0300" },
  361. { GF_KEY_DEADEACUTE, "U+0301" },
  362. { GF_KEY_DEADCIRCUM, "U+0302" },
  363. { GF_KEY_DEADTILDE, "U+0303" },
  364. { GF_KEY_DEADMACRON, "U+0304" },
  365. { GF_KEY_DEADBREVE, "U+0306" },
  366. { GF_KEY_DEADABOVEDOT, "U+0307" },
  367. { GF_KEY_DEADDIARESIS, "U+0308" },
  368. { GF_KEY_DEADRINGABOVE, "U+030A" },
  369. { GF_KEY_DEADDOUBLEACUTE, "U+030B" },
  370. { GF_KEY_DEADCARON, "U+030C" },
  371. { GF_KEY_DEADCEDILLA, "U+0327" },
  372. { GF_KEY_DEADOGONEK, "U+0328" },
  373. { GF_KEY_DEADIOTA, "U+0345" },
  374. { GF_KEY_EURO, "U+20AC" },
  375. { GF_KEY_DEADVOICESOUND, "U+3099" },
  376. { GF_KEY_DEADSEMIVOICESOUND, "U+309A" },
  377. { GF_KEY_CHANNELUP, "ChannelUp" },
  378. { GF_KEY_CHANNELDOWN, "ChannelDown" },
  379. { GF_KEY_TEXT, "Text" },
  380. { GF_KEY_INFO, "Info" },
  381. { GF_KEY_EPG, "EPG" },
  382. { GF_KEY_RECORD, "Record" },
  383. { GF_KEY_BEGINPAGE, "BeginPage" }
  384. };
  385. GF_EXPORT
  386. const char *gf_dom_get_key_name(u32 key_identifier)
  387. {
  388. u32 count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);
  389. if (!key_identifier || count<=key_identifier) return "Unknown";
  390. return predefined_key_identifiers[key_identifier-1].name;
  391. }
  392. u32 gf_dom_get_key_type(char *key_name)
  393. {
  394. if (strlen(key_name) == 1) {
  395. char c[2];
  396. c[0] = key_name[0];
  397. c[1] = 0;
  398. strupr(c);
  399. if (c[0] >= 'A' && c[0] <= 'Z')
  400. return (GF_KEY_A + (c[0] - 'A') );
  401. if (c[0] >= '0' && c[0] <= '9')
  402. return ( GF_KEY_0 + (c[0] - '0') );
  403. switch (c[0]) {
  404. case '@': return GF_KEY_AT;
  405. case '*': return GF_KEY_STAR;
  406. case '#': return GF_KEY_NUMBER;
  407. case ' ': return GF_KEY_SPACE;
  408. case '!': return GF_KEY_EXCLAMATION;
  409. case '"': return GF_KEY_QUOTATION;
  410. case '$': return GF_KEY_DOLLAR;
  411. case '&': return GF_KEY_AMPERSAND;
  412. case '\'': return GF_KEY_APOSTROPHE;
  413. case '(': return GF_KEY_LEFTPARENTHESIS;
  414. case ')': return GF_KEY_RIGHTPARENTHESIS;
  415. case '+': return GF_KEY_PLUS;
  416. case ',': return GF_KEY_COMMA;
  417. case '-': return GF_KEY_HYPHEN;
  418. case '.': return GF_KEY_FULLSTOP;
  419. case '/': return GF_KEY_SLASH;
  420. case ':': return GF_KEY_COLON;
  421. case ';': return GF_KEY_SEMICOLON;
  422. case '<': return GF_KEY_LESSTHAN;
  423. case '=': return GF_KEY_EQUALS;
  424. case '>': return GF_KEY_GREATERTHAN;
  425. case '?': return GF_KEY_QUESTION;
  426. case '[': return GF_KEY_LEFTSQUAREBRACKET;
  427. case '\\': return GF_KEY_BACKSLASH;
  428. case ']': return GF_KEY_RIGHTSQUAREBRACKET;
  429. case '^': return GF_KEY_CIRCUM;
  430. case '_': return GF_KEY_UNDERSCORE;
  431. case '`': return GF_KEY_GRAVEACCENT;
  432. case '{': return GF_KEY_LEFTCURLYBRACKET;
  433. case '|': return GF_KEY_PIPE;
  434. case '}': return GF_KEY_RIGHTCURLYBRACKET;
  435. case 'Ä„': return GF_KEY_INVERTEXCLAMATION;
  436. default: return GF_KEY_UNIDENTIFIED;
  437. }
  438. } else {
  439. u32 i, count;
  440. count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);
  441. for (i=0; i<count; i++) {
  442. if (!stricmp(key_name, predefined_key_identifiers[i].name)) {
  443. return predefined_key_identifiers[i].key_code;
  444. }
  445. }
  446. return GF_KEY_UNIDENTIFIED;
  447. }
  448. }
  449. /* Basic SVG datatype parsing functions */
  450. static const struct predef_col { const char *name; u8 r; u8 g; u8 b; } predefined_colors[] =
  451. {
  452. {"aliceblue",240, 248, 255},
  453. {"antiquewhite",250, 235, 215},
  454. {"aqua", 0, 255, 255},
  455. {"aquamarine",127, 255, 212},
  456. {"azure",240, 255, 255},
  457. {"beige",245, 245, 220},
  458. {"bisque",255, 228, 196},
  459. {"black", 0, 0, 0},
  460. {"blanchedalmond",255, 235, 205},
  461. {"blue", 0, 0, 255},
  462. {"blueviolet",138, 43, 226},
  463. {"brown",165, 42, 42},
  464. {"burlywood",222, 184, 135},
  465. {"cadetblue", 95, 158, 160},
  466. {"chartreuse",127, 255, 0},
  467. {"chocolate",210, 105, 30},
  468. {"coral",255, 127, 80},
  469. {"lightpink",255, 182, 193},
  470. {"lightsalmon",255, 160, 122},
  471. {"lightseagreen", 32, 178, 170},
  472. {"lightskyblue",135, 206, 250},
  473. {"lightslategray",119, 136, 153},
  474. {"lightslategrey",119, 136, 153},
  475. {"lightsteelblue",176, 196, 222},
  476. {"lightyellow",255, 255, 224},
  477. {"lime", 0, 255, 0},
  478. {"limegreen", 50, 205, 50},
  479. {"linen",250, 240, 230},
  480. {"magenta",255, 0, 255},
  481. {"maroon",128, 0, 0},
  482. {"mediumaquamarine",102, 205, 170},
  483. {"mediumblue", 0, 0, 205},
  484. {"mediumorchid",186, 85, 211},
  485. {"cornflowerblue",100, 149, 237},
  486. {"cornsilk",255, 248, 220},
  487. {"crimson",220, 20, 60},
  488. {"cyan", 0, 255, 255},
  489. {"darkblue", 0, 0, 139},
  490. {"darkcyan", 0, 139, 139},
  491. {"darkgoldenrod",184, 134, 11},
  492. {"darkgray",169, 169, 169},
  493. {"darkgreen", 0, 100, 0},
  494. {"darkgrey",169, 169, 169},
  495. {"darkkhaki",189, 183, 107},
  496. {"darkmagenta",139, 0, 139},
  497. {"darkolivegreen", 85, 107, 47},
  498. {"darkorange",255, 140, 0},
  499. {"darkorchid",153, 50, 204},
  500. {"darkred",139, 0, 0},
  501. {"darksalmon",233, 150, 122},
  502. {"darkseagreen",143, 188, 143},
  503. {"darkslateblue", 72, 61, 139},
  504. {"darkslategray", 47, 79, 79},
  505. {"darkslategrey", 47, 79, 79},
  506. {"darkturquoise", 0, 206, 209},
  507. {"darkviolet",148, 0, 211},
  508. {"deeppink",255, 20, 147},
  509. {"deepskyblue", 0, 191, 255},
  510. {"dimgray",105, 105, 105},
  511. {"dimgrey",105, 105, 105},
  512. {"dodgerblue", 30, 144, 255},
  513. {"firebrick",178, 34, 34},
  514. {"floralwhite",255, 250, 240},
  515. {"forestgreen", 34, 139, 34},
  516. {"fuchsia",255, 0, 255},
  517. {"gainsboro",220, 220, 220},
  518. {"ghostwhite",248, 248, 255},
  519. {"gold",255, 215, 0},
  520. {"goldenrod",218, 165, 32},
  521. {"gray",128, 128, 128},
  522. {"grey",128, 128, 128},
  523. {"green", 0, 128, 0},
  524. {"greenyellow",173, 255, 47},
  525. {"honeydew",240, 255, 240},
  526. {"hotpink",255, 105, 180},
  527. {"indianred",205, 92, 92},
  528. {"indigo", 75, 0, 130},
  529. {"ivory",255, 255, 240},
  530. {"khaki",240, 230, 140},
  531. {"lavender",230, 230, 25},
  532. {"lavenderblush",255, 240, 245},
  533. {"mediumpurple",147, 112, 219},
  534. {"mediumseagreen", 60, 179, 113},
  535. {"mediumslateblue",123, 104, 238},
  536. {"mediumspringgreen", 0, 250, 154},
  537. {"mediumturquoise", 72, 209, 204},
  538. {"mediumvioletred",199, 21, 133},
  539. {"midnightblue", 25, 25, 112},
  540. {"mintcream",245, 255, 250},
  541. {"mistyrose",255, 228, 225},
  542. {"moccasin",255, 228, 181},
  543. {"navajowhite",255, 222, 173},
  544. {"navy", 0, 0, 128},
  545. {"oldlace",253, 245, 230},
  546. {"olive",128, 128, 0},
  547. {"olivedrab",107, 142, 35},
  548. {"orange",255, 165, 0},
  549. {"orangered",255, 69, 0},
  550. {"orchid",218, 112, 214},
  551. {"palegoldenrod",238, 232, 170},
  552. {"palegreen",152, 251, 152},
  553. {"paleturquoise",175, 238, 238},
  554. {"palevioletred",219, 112, 147},
  555. {"papayawhip",255, 239, 213},
  556. {"peachpuff",255, 218, 185},
  557. {"peru",205, 133, 63},
  558. {"pink",255, 192, 203},
  559. {"plum",221, 160, 221},
  560. {"powderblue",176, 224, 230},
  561. {"purple",128, 0, 128},
  562. {"red",255, 0, 0},
  563. {"rosybrown",188, 143, 143},
  564. {"royalblue", 65, 105, 225},
  565. {"saddlebrown",139, 69, 19},
  566. {"salmon",250, 128, 114},
  567. {"sandybrown",244, 164, 96},
  568. {"seagreen", 46, 139, 87},
  569. {"seashell",255, 245, 238},
  570. {"sienna",160, 82, 45},
  571. {"silver",192, 192, 192},
  572. {"skyblue",135, 206, 235},
  573. {"slateblue",106, 90, 205},
  574. {"slategray",112, 128, 144},
  575. {"slategrey",112, 128, 144},
  576. {"snow",255, 250, 250},
  577. {"springgreen", 0, 255, 127},
  578. {"steelblue", 70, 130, 180},
  579. {"tan",210, 180, 140},
  580. {"teal", 0, 128, 128},
  581. {"lawngreen",124, 252, 0},
  582. {"lemonchiffon",255, 250, 205},
  583. {"lightblue",173, 216, 230},
  584. {"lightcoral",240, 128, 128},
  585. {"lightcyan",224, 255, 255},
  586. {"lightgoldenrodyellow",250, 250, 210},
  587. {"lightgray",211, 211, 211},
  588. {"lightgreen",144, 238, 144},
  589. {"lightgrey",211, 211, 211},
  590. {"thistle",216, 191, 216},
  591. {"tomato",255, 99, 71},
  592. {"turquoise", 64, 224, 208},
  593. {"violet",238, 130, 238},
  594. {"wheat",245, 222, 179},
  595. {"white",255, 255, 255},
  596. {"whitesmoke",245, 245, 245},
  597. {"yellow",255, 255, 0},
  598. {"yellowgreen",154, 205, 50}
  599. };
  600. /* Basic SVG datatype parsing functions */
  601. static const struct sys_col { const char *name; u8 type; } system_colors[] =
  602. {
  603. {"ActiveBorder", SVG_COLOR_ACTIVE_BORDER},
  604. {"ActiveCaption", SVG_COLOR_ACTIVE_CAPTION},
  605. {"AppWorkspace", SVG_COLOR_APP_WORKSPACE},
  606. {"Background", SVG_COLOR_BACKGROUND},
  607. {"ButtonFace", SVG_COLOR_BUTTON_FACE},
  608. {"ButtonHighlight", SVG_COLOR_BUTTON_HIGHLIGHT},
  609. {"ButtonShadow", SVG_COLOR_BUTTON_SHADOW},
  610. {"ButtonText", SVG_COLOR_BUTTON_TEXT},
  611. {"CaptionText", SVG_COLOR_CAPTION_TEXT},
  612. {"GrayText", SVG_COLOR_GRAY_TEXT},
  613. {"Highlight", SVG_COLOR_HIGHLIGHT},
  614. {"HighlightText", SVG_COLOR_HIGHLIGHT_TEXT},
  615. {"InactiveBorder", SVG_COLOR_INACTIVE_BORDER},
  616. {"InactiveCaption", SVG_COLOR_INACTIVE_CAPTION},
  617. {"InactiveCaptionText", SVG_COLOR_INACTIVE_CAPTION_TEXT},
  618. {"InfoBackground", SVG_COLOR_INFO_BACKGROUND},
  619. {"InfoText", SVG_COLOR_INFO_TEXT},
  620. {"Menu", SVG_COLOR_MENU},
  621. {"MenuText", SVG_COLOR_MENU_TEXT},
  622. {"Scrollbar", SVG_COLOR_SCROLLBAR},
  623. {"ThreeDDarkShadow", SVG_COLOR_3D_DARK_SHADOW},
  624. {"ThreeDFace", SVG_COLOR_3D_FACE},
  625. {"ThreeDHighlight", SVG_COLOR_3D_HIGHLIGHT},
  626. {"ThreeDLightShadow", SVG_COLOR_3D_LIGHT_SHADOW},
  627. {"ThreeDShadow", SVG_COLOR_3D_SHADOW},
  628. {"Window", SVG_COLOR_WINDOW},
  629. {"WindowFrame", SVG_COLOR_WINDOW_FRAME},
  630. {"WindowText", SVG_COLOR_WINDOW_TEXT},
  631. };
  632. /* parses an color from a named color HTML or CSS 2 */
  633. static void svg_parse_named_color(SVG_Color *col, char *attribute_content)
  634. {
  635. u32 i, count;
  636. count = sizeof(predefined_colors) / sizeof(struct predef_col);
  637. for (i=0; i<count; i++) {
  638. if (!strcmp(attribute_content, predefined_colors[i].name)) {
  639. col->red = INT2FIX(predefined_colors[i].r) / 255;
  640. col->green = INT2FIX(predefined_colors[i].g) / 255;
  641. col->blue = INT2FIX(predefined_colors[i].b) / 255;
  642. col->type = SVG_COLOR_RGBCOLOR;
  643. return;
  644. }
  645. }
  646. count = sizeof(system_colors) / sizeof(struct sys_col);
  647. for (i=0; i<count; i++) {
  648. if (!strcmp(attribute_content, system_colors[i].name)) {
  649. col->type = system_colors[i].type;
  650. return;
  651. }
  652. }
  653. }
  654. const char *gf_svg_get_system_paint_server_name(u32 paint_type)
  655. {
  656. u32 i, count;
  657. count = sizeof(system_colors) / sizeof(struct sys_col);
  658. for (i=0; i<count; i++) {
  659. if (paint_type == system_colors[i].type) return system_colors[i].name;
  660. }
  661. return "undefined";
  662. }
  663. u32 gf_svg_get_system_paint_server_type(const char *name)
  664. {
  665. u32 i, count;
  666. count = sizeof(system_colors) / sizeof(struct sys_col);
  667. for (i=0; i<count; i++) {
  668. if (!strcmp(name, system_colors[i].name)) return system_colors[i].type;
  669. }
  670. return 0;
  671. }
  672. /* Reads an SVG Color
  673. either #RRGGBB, #RGB, rgb(r,g,b) in [0,255] , colorname, or 'r g b' in [0,1]
  674. ignores any space, comma, semi-column before and any space after
  675. TODO:
  676. transform the char into char and duplicate the input, instead of modifying it
  677. be more robust to errors in color description ex rgb(0 0 0)
  678. */
  679. static void svg_parse_color(SVG_Color *col, char *attribute_content)
  680. {
  681. char *str = attribute_content;
  682. while (str[strlen(attribute_content)-1] == ' ') str[strlen(attribute_content)-1] = 0;
  683. while (*str != 0 && (*str == ' ' || *str == ',' || *str == ';')) str++;
  684. if (!strcmp(str, "currentColor")) {
  685. col->type = SVG_COLOR_CURRENTCOLOR;
  686. return;
  687. } else if (!strcmp(str, "inherit")) {
  688. col->type = SVG_COLOR_INHERIT;
  689. return;
  690. } else if (str[0]=='#') {
  691. u32 val;
  692. sscanf(str+1, "%x", &val);
  693. if (strlen(str) == 7) {
  694. col->red = INT2FIX((val>>16) & 0xFF) / 255;
  695. col->green = INT2FIX((val>>8) & 0xFF) / 255;
  696. col->blue = INT2FIX(val & 0xFF) / 255;
  697. } else {
  698. col->red = INT2FIX((val>>8) & 0xF) / 15;
  699. col->green = INT2FIX((val>>4) & 0xF) / 15;
  700. col->blue = INT2FIX(val & 0xF) / 15;
  701. }
  702. col->type = SVG_COLOR_RGBCOLOR;
  703. } else if (strstr(str, "rgb(") || strstr(str, "RGB(")) {
  704. Float _val;
  705. u8 is_percentage= 0;
  706. if (strstr(str, "%")) is_percentage = 1;
  707. str = strstr(str, "(");
  708. str++;
  709. sscanf(str, "%f", &_val); col->red = FLT2FIX(_val);
  710. str = strstr(str, ",");
  711. if (!str) {
  712. /* space separated colors/percentages are not allowed neither in SVG 1.1 nor in SVG T1.2 */
  713. col->red = col->green = col->blue = 0;
  714. return;
  715. }
  716. str++;
  717. sscanf(str, "%f", &_val); col->green = FLT2FIX(_val);
  718. str = strstr(str, ",");
  719. if (!str) {
  720. /* space separated colors/percentages are not allowed neither in SVG 1.1 nor in SVG T1.2 */
  721. col->red = col->green = col->blue = 0;
  722. return;
  723. }
  724. str++;
  725. sscanf(str, "%f", &_val); col->blue = FLT2FIX(_val);
  726. if (is_percentage) {
  727. col->red /= 100;
  728. col->green /= 100;
  729. col->blue /= 100;
  730. } else {
  731. col->red /= 255;
  732. col->green /= 255;
  733. col->blue /= 255;
  734. }
  735. col->type = SVG_COLOR_RGBCOLOR;
  736. } else if ((str[0] >= 'a' && str[0] <= 'z')
  737. || (str[0] >= 'A' && str[0] <= 'Z')) {
  738. svg_parse_named_color(col, str);
  739. } else {
  740. Float _r, _g, _b;
  741. sscanf(str, "%f %f %f", &_r, &_g, &_b);
  742. col->red = FLT2FIX(_r);
  743. col->green = FLT2FIX(_g);
  744. col->blue = FLT2FIX(_b);
  745. col->type = SVG_COLOR_RGBCOLOR;
  746. }
  747. }
  748. /*
  749. Reads a number (i.e. without unit) according to the CSS syntax (same as SVG paths and transforms)
  750. trims any space, comma, semi-column before or after (TODO: fix this)
  751. reads an optional + or -
  752. then reads a digit between 0 and 9
  753. optionally followed by an '.' and digits between 0 and 9
  754. optionally followed by e or E and digits between 0 and 9
  755. Returns the number of chars read in d
  756. */
  757. static u32 svg_parse_number(char *d, Fixed *f, Bool is_angle)
  758. {
  759. u32 nb_digit_before = 0;
  760. u32 nb_digit_after = 0;
  761. Bool has_fractional = 0;
  762. Bool is_negative = 0;
  763. Float _val = 0;
  764. u32 i = 0;
  765. /* warning the comma and semicolumn should not be there when parsing a number in a path */
  766. while ((d[i] != 0) && strchr(" ,;\r\n\t", d[i])) i++;
  767. if (!d[i]) {
  768. GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Parsing] Parsing number with empty string or only spaces: %s\n", d));
  769. return 0;
  770. }
  771. if (d[i] == '+') {
  772. i++;
  773. } else if (d[i] == '-') {
  774. is_negative = 1;
  775. i++;
  776. }
  777. /* Warning: this is not normal, should be detected somehow by checking the BNF */
  778. /* if ((d[i]=='N') && (d[i+1]=='a') && (d[i+2]=='N')) {
  779. i+= 3;
  780. _val = 0;
  781. goto end;
  782. }*/
  783. /* read the digit-sequence token of the BNF */
  784. while (d[i] >= '0' && d[i] <= '9' && d[i] != 0) {
  785. _val = _val*10 + (d[i]-'0');
  786. nb_digit_before++;
  787. i++;
  788. }
  789. if (d[i] == '.') {
  790. has_fractional = 1;
  791. i++;
  792. while (d[i] >= '0' && d[i] <= '9' && d[i] != 0) {
  793. _val = _val*10 + (d[i]-'0');
  794. nb_digit_after++;
  795. i++;
  796. }
  797. if (nb_digit_after) {
  798. _val /= (Float)pow(10,nb_digit_after);
  799. } else if (nb_digit_before == 0) {
  800. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing number (expecting digits before or after a '.': %s\n", d));
  801. return 0;
  802. } else {
  803. /* dangling '.' without digits after. This is allowed by the BNF */
  804. }
  805. }
  806. if ((nb_digit_before == 0) && (has_fractional == 0)) {
  807. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing number (expecting digits):%s\n", d));
  808. return 0;
  809. }
  810. /* reading the exponent */
  811. if (d[i] == 'e' || d[i] == 'E') {
  812. Bool neg_exp = 0;
  813. u32 nb_exp_digits = 0;
  814. s32 exp = 0;
  815. i++;
  816. if (d[i] == '+') i++;
  817. else if (d[i] == '-') {
  818. i++;
  819. neg_exp=1;
  820. }
  821. while (d[i] >= '0' && d[i] <= '9' && d[i] != 0) {
  822. exp = exp*10 + (d[i]-'0');
  823. nb_exp_digits++;
  824. i++;
  825. }
  826. if (nb_exp_digits) {
  827. _val *= (Float)pow(10, neg_exp ? -exp : exp);
  828. } else {
  829. 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));
  830. return 0;
  831. }
  832. }
  833. /* We can now produce the final number */
  834. if (is_negative) _val *= -1;
  835. if (is_angle) {
  836. _val/=180;
  837. (*f) = gf_mulfix(FLT2FIX(_val), GF_PI);
  838. } else {
  839. (*f) = FLT2FIX(_val);
  840. }
  841. /* warning the comma and semicolumn should not be there when parsing a path number */
  842. while (d[i] != 0 && (d[i] == ' ' || d[i] == ',' || d[i] == ';')) i++;
  843. return i;
  844. }
  845. /*
  846. Parse an Offset Value, i.e +/- Clock Value
  847. */
  848. static GF_Err svg_parse_clock_value(char *d, Double *clock_value)
  849. {
  850. char *tmp;
  851. s32 sign = 1;
  852. if (!d) return GF_BAD_PARAM;
  853. if (!d[0]) return GF_BAD_PARAM;
  854. if (d[0] == '+') d++;
  855. else if (d[0] == '-') { sign = -1; d++; }
  856. if (!d[0]) return GF_BAD_PARAM;
  857. /* According to SVG, the following are invalid syntaxes (see animate-elem-225-t.svg)
  858. '+-2s'
  859. '1++s' even though sscanf returns the right values
  860. */
  861. if (strchr(d, '+') || strchr(d, '-')) return GF_BAD_PARAM;
  862. /* No embedded white space is allowed in clock values,
  863. although leading and trailing white space characters will be ignored.*/
  864. while (*d == ' ') d++;
  865. if ((tmp = strchr(d, ':'))) {
  866. /* Full or Partial Clock value */
  867. tmp++;
  868. if ((tmp = strchr(tmp, ':'))) {
  869. /* Full Clock value : hh:mm:ss(.frac) */
  870. u32 hours;
  871. u32 minutes;
  872. Float seconds;
  873. if (sscanf(d, "%u:%u:%f", &hours, &minutes, &seconds) < 3) return GF_BAD_PARAM;
  874. *clock_value = hours*3600 + minutes*60 + seconds;
  875. } else {
  876. /* Partial Clock value : mm:ss(.frac) */
  877. s32 minutes;
  878. Float seconds;
  879. if (sscanf(d, "%d:%f", &minutes, &seconds) < 2) return GF_BAD_PARAM;
  880. *clock_value = minutes*60 + seconds;
  881. }
  882. } else if ((tmp = strstr(d, "h"))) {
  883. Float f;
  884. if (sscanf(d, "%fh", &f) == 0) return GF_BAD_PARAM;
  885. *clock_value = 3600*f;
  886. } else if (strstr(d, "min")) {
  887. Float f;
  888. if (sscanf(d, "%fmin", &f) == 0) return GF_BAD_PARAM;
  889. *clock_value = 60*f;
  890. } else if ((tmp = strstr(d, "ms"))) {
  891. Float f;
  892. if (sscanf(d, "%fms", &f) == 0) return GF_BAD_PARAM;
  893. *clock_value = f/1000;
  894. } else if (strchr(d, 's')) {
  895. Float f;
  896. if (sscanf(d, "%fs", &f) == 0) return GF_BAD_PARAM;
  897. *clock_value = f;
  898. } else {
  899. Float f;
  900. if (sscanf(d, "%f", &f) == 0) return GF_BAD_PARAM;
  901. *clock_value = f;
  902. }
  903. *clock_value *= sign;
  904. return GF_OK;
  905. }
  906. /* Parses one SVG time value:
  907. indefinite,
  908. element_id.event_name
  909. wallclock,
  910. accessKey,
  911. events,
  912. clock value.
  913. */
  914. static GF_Err smil_parse_time(GF_Node *elt, SMIL_Time *v, char *d)
  915. {
  916. GF_Err e = GF_OK;
  917. char *tmp;
  918. /* Offset Values */
  919. if ((d[0] >= '0' && d[0] <= '9') || d[0] == '+' || d[0] == '-'){
  920. v->type = GF_SMIL_TIME_CLOCK;
  921. return svg_parse_clock_value(d, &(v->clock));
  922. }
  923. /* Indefinite Values */
  924. else if (!strcmp(d, "indefinite")) {
  925. v->type = GF_SMIL_TIME_INDEFINITE;
  926. return GF_OK;
  927. }
  928. /* Wallclock Values */
  929. else if ((tmp = strstr(d, "wallclock("))) {
  930. u32 year, month, day;
  931. u32 hours, minutes;
  932. u32 nhours, nminutes;
  933. Float seconds;
  934. char *tmp1, *tmp2;
  935. v->type = GF_SMIL_TIME_WALLCLOCK;
  936. tmp += 10;
  937. if ((tmp1 = strchr(tmp, 'T')) ) {
  938. /* From tmp to wallStartTime, we parse a date */
  939. sscanf(tmp, "%u-%u-%dT", &year, &month, &day);
  940. tmp1++;
  941. tmp = tmp1;
  942. }
  943. if ((tmp1 = strchr(tmp, ':')) ) {
  944. if ((tmp2 = strchr(tmp1, ':')) ) {
  945. /* HHMMSS */
  946. sscanf(tmp, "%u:%u:%f", &hours, &minutes, &seconds);
  947. } else {
  948. /* HHMM */
  949. sscanf(tmp, "%u:%u", &hours, &minutes);
  950. }
  951. }
  952. if (strchr(tmp, 'Z')) {
  953. return GF_OK;
  954. } else {
  955. if ( (tmp1 = strchr(tmp, '+')) ) {
  956. sscanf(tmp1, "%u:%u", &nhours, &nminutes);
  957. } else if ( (tmp1 = strchr(tmp, '-')) ) {
  958. sscanf(tmp1, "%u:%u", &nhours, &nminutes);
  959. }
  960. }
  961. return GF_OK;
  962. }
  963. /* AccessKey Values */
  964. else if ((tmp = strstr(d, "accessKey("))) {
  965. char *sep;
  966. v->type = GF_SMIL_TIME_EVENT;
  967. v->event.type = GF_EVENT_KEYDOWN;
  968. v->element = elt->sgprivate->scenegraph->RootNode;
  969. tmp+=10;
  970. sep = strchr(d, ')');
  971. sep[0] = 0;
  972. v->event.parameter = gf_dom_get_key_type(tmp);
  973. sep++;
  974. if ((tmp = strchr(sep, '+')) || (tmp = strchr(sep, '-'))) {
  975. char c = *tmp;
  976. tmp++;
  977. e = svg_parse_clock_value(tmp, &(v->clock));
  978. if (c == '-') v->clock *= -1;
  979. }
  980. return e;
  981. }
  982. else {
  983. Bool had_param = 0;
  984. char *tmp2;
  985. v->type = GF_SMIL_TIME_EVENT;
  986. if ((tmp = strchr(d, '.'))) {
  987. tmp[0] = 0;
  988. if (strlen(d) == 0) {
  989. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] expecting an id before '.' in SMIL Time .%s\n", tmp+1));
  990. return GF_BAD_PARAM;
  991. }
  992. v->element_id = gf_strdup(d);
  993. tmp[0] = '.';
  994. tmp++;
  995. } else {
  996. tmp = d;
  997. }
  998. if ((tmp2 = strchr(tmp, '('))) {
  999. tmp2[0] = 0;
  1000. v->event.type = gf_dom_event_type_by_name(tmp);
  1001. tmp2[0] = '(';
  1002. tmp2++;
  1003. had_param = 1;
  1004. v->event.parameter = atoi(tmp2);
  1005. tmp = strchr(tmp2, ')');
  1006. if (!tmp) {
  1007. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] expecting ')' in SMIL Time %s\n", d));
  1008. return GF_BAD_PARAM;
  1009. }
  1010. tmp++;
  1011. }
  1012. if ((tmp2 = strchr(tmp, '+')) || (tmp2 = strchr(tmp, '-'))) {
  1013. char c = *tmp2;
  1014. char *tmp3 = tmp2;
  1015. tmp2[0] = 0;
  1016. tmp3--;
  1017. while (*tmp3==' ') { *tmp3=0; tmp3--; }
  1018. if (v->event.type == 0) v->event.type = gf_dom_event_type_by_name(tmp);
  1019. if (!had_param && (v->event.type == GF_EVENT_REPEAT || v->event.type == GF_EVENT_REPEAT_EVENT))
  1020. v->event.parameter = 1;
  1021. tmp2[0] = c;
  1022. tmp2++;
  1023. e = svg_parse_clock_value(tmp2, &(v->clock));
  1024. if (c == '-') v->clock *= -1;
  1025. return e;
  1026. } else {
  1027. if (v->event.type == 0) v->event.type = gf_dom_event_type_by_name(tmp);
  1028. if (!had_param && (v->event.type == GF_EVENT_REPEAT || v->event.type == GF_EVENT_REPEAT_EVENT))
  1029. v->event.parameter = 1;
  1030. }
  1031. }
  1032. return GF_OK;
  1033. }
  1034. /* Parses a list of SVG transformations and collapses them in the given matrix */
  1035. Bool gf_svg_parse_transformlist(GF_Matrix2D *mat, char *attribute_content)
  1036. {
  1037. GF_Matrix2D tmp;
  1038. char *str;
  1039. u32 read_chars;
  1040. u32 i;
  1041. gf_mx2d_init(*mat);
  1042. str = attribute_content;
  1043. i = 0;
  1044. while (str[i] != 0) {
  1045. while (str[i] == ' ') i++;
  1046. if (str[i] == ',') i++;
  1047. while (str[i] == ' ') i++;
  1048. if (strstr(str+i, "scale")==str+i) {
  1049. i += 5;
  1050. while(str[i] == ' ') i++;
  1051. if (str[i] == '(') {
  1052. Fixed sx, sy;
  1053. i++;
  1054. read_chars = svg_parse_number(&(str[i]), &sx, 0);
  1055. if (!read_chars) {
  1056. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading sx component in scale: %s\n", attribute_content));
  1057. return 0;
  1058. }
  1059. i += read_chars;
  1060. if (str[i] == ')') {
  1061. sy = sx;
  1062. } else {
  1063. read_chars = svg_parse_number(&(str[i]), &sy, 0);
  1064. if (!read_chars) {
  1065. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading sy component in scale: %s\n", attribute_content));
  1066. return 0;
  1067. }
  1068. i += read_chars;
  1069. }
  1070. gf_mx2d_init(tmp);
  1071. gf_mx2d_add_scale(&tmp, sx, sy);
  1072. gf_mx2d_add_matrix(&tmp, mat);
  1073. gf_mx2d_copy(*mat, tmp);
  1074. while(str[i] == ' ') i++;
  1075. if (str[i] == ')') i++;
  1076. else {
  1077. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1078. return 0;
  1079. }
  1080. } else {
  1081. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
  1082. return 0;
  1083. }
  1084. } else if (strstr(str+i, "translate")==str+i) {
  1085. i += 9;
  1086. while(str[i] == ' ') i++;
  1087. if (str[i] == '(') {
  1088. Fixed tx, ty;
  1089. i++;
  1090. read_chars = svg_parse_number(&(str[i]), &tx, 0);
  1091. if (!read_chars) {
  1092. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading tx component in translate: %s\n", attribute_content));
  1093. return 0;
  1094. }
  1095. i += read_chars;
  1096. if (str[i] == ')') {
  1097. ty = 0;
  1098. } else {
  1099. read_chars = svg_parse_number(&(str[i]), &ty, 0);
  1100. if (!read_chars) {
  1101. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading ty component in translate: %s\n", attribute_content));
  1102. return 0;
  1103. }
  1104. i += read_chars;
  1105. }
  1106. gf_mx2d_init(tmp);
  1107. gf_mx2d_add_translation(&tmp, tx, ty);
  1108. gf_mx2d_add_matrix(&tmp, mat);
  1109. gf_mx2d_copy(*mat, tmp);
  1110. while(str[i] == ' ') i++;
  1111. if (str[i] == ')') i++;
  1112. else {
  1113. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1114. return 0;
  1115. }
  1116. } else {
  1117. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
  1118. return 0;
  1119. }
  1120. } else if (strstr(str+i, "rotate")==str+i) {
  1121. i += 6;
  1122. while(str[i] == ' ') i++;
  1123. if (str[i] == '(') {
  1124. Fixed angle, cx, cy;
  1125. i++;
  1126. read_chars = svg_parse_number(&(str[i]), &angle, 1);
  1127. if (!read_chars) {
  1128. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading angle component in rotate: %s\n", attribute_content));
  1129. return 0;
  1130. }
  1131. i += read_chars;
  1132. if (str[i] == ')') {
  1133. cx = cy = 0;
  1134. } else {
  1135. read_chars = svg_parse_number(&(str[i]), &cx, 0);
  1136. if (!read_chars) {
  1137. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading cx component in rotate: %s\n", attribute_content));
  1138. return 0;
  1139. }
  1140. i += read_chars;
  1141. read_chars = svg_parse_number(&(str[i]), &cy, 0);
  1142. if (!read_chars) {
  1143. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading cy component in rotate: %s\n", attribute_content));
  1144. return 0;
  1145. }
  1146. i += read_chars;
  1147. }
  1148. gf_mx2d_init(tmp);
  1149. gf_mx2d_add_rotation(&tmp, cx, cy, angle);
  1150. gf_mx2d_add_matrix(&tmp, mat);
  1151. gf_mx2d_copy(*mat, tmp);
  1152. while(str[i] == ' ') i++;
  1153. if (str[i] == ')') i++;
  1154. else {
  1155. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1156. return 0;
  1157. }
  1158. } else {
  1159. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
  1160. return 0;
  1161. }
  1162. } else if (strstr(str+i, "skewX")==str+i) {
  1163. i += 5;
  1164. while(str[i] == ' ') i++;
  1165. if (str[i] == '(') {
  1166. Fixed angle;
  1167. i++;
  1168. read_chars = svg_parse_number(&(str[i]), &angle, 1);
  1169. if (!read_chars) {
  1170. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading angle in skewX: %s\n", attribute_content));
  1171. return 0;
  1172. }
  1173. i += read_chars;
  1174. gf_mx2d_init(tmp);
  1175. gf_mx2d_add_skew_x(&tmp, angle);
  1176. gf_mx2d_add_matrix(&tmp, mat);
  1177. gf_mx2d_copy(*mat, tmp);
  1178. while(str[i] == ' ') i++;
  1179. if (str[i] == ')') i++;
  1180. else {
  1181. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1182. return 0;
  1183. }
  1184. } else {
  1185. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
  1186. return 0;
  1187. }
  1188. } else if (strstr(str+i, "skewY")==str+i) {
  1189. i += 5;
  1190. while(str[i] == ' ') i++;
  1191. if (str[i] == '(') {
  1192. Fixed angle;
  1193. i++;
  1194. read_chars = svg_parse_number(&(str[i]), &angle, 1);
  1195. if (!read_chars) {
  1196. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading angle component in skewY: %s\n", attribute_content));
  1197. return 0;
  1198. }
  1199. i += read_chars;
  1200. gf_mx2d_init(tmp);
  1201. gf_mx2d_add_skew_y(&tmp, angle);
  1202. gf_mx2d_add_matrix(&tmp, mat);
  1203. gf_mx2d_copy(*mat, tmp);
  1204. while(str[i] == ' ') i++;
  1205. if (str[i] == ')') i++;
  1206. else {
  1207. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1208. return 0;
  1209. }
  1210. } else {
  1211. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
  1212. return 0;
  1213. }
  1214. } else if (strstr(str+i, "matrix")==str+i) {
  1215. i+=6;
  1216. while(str[i] == ' ') i++;
  1217. if (str[i] == '(') {
  1218. i++;
  1219. read_chars = svg_parse_number(&(str[i]), &(tmp.m[0]), 0);
  1220. if (!read_chars) {
  1221. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient a in matrix: %s\n", attribute_content));
  1222. return 0;
  1223. }
  1224. i += read_chars;
  1225. read_chars = svg_parse_number(&(str[i]), &(tmp.m[3]), 0);
  1226. if (!read_chars) {
  1227. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient b in matrix: %s\n", attribute_content));
  1228. return 0;
  1229. }
  1230. i += read_chars;
  1231. read_chars = svg_parse_number(&(str[i]), &(tmp.m[1]), 0);
  1232. if (!read_chars) {
  1233. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient c in matrix: %s\n", attribute_content));
  1234. return 0;
  1235. }
  1236. i += read_chars;
  1237. read_chars = svg_parse_number(&(str[i]), &(tmp.m[4]), 0);
  1238. if (!read_chars) {
  1239. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient d in matrix: %s\n", attribute_content));
  1240. return 0;
  1241. }
  1242. i += read_chars;
  1243. read_chars = svg_parse_number(&(str[i]), &(tmp.m[2]), 0);
  1244. if (!read_chars) {
  1245. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient e in matrix: %s\n", attribute_content));
  1246. return 0;
  1247. }
  1248. i += read_chars;
  1249. read_chars = svg_parse_number(&(str[i]), &(tmp.m[5]), 0);
  1250. if (!read_chars) {
  1251. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient f in matrix: %s\n", attribute_content));
  1252. return 0;
  1253. }
  1254. i += read_chars;
  1255. gf_mx2d_add_matrix(&tmp, mat);
  1256. gf_mx2d_copy(*mat, tmp);
  1257. while(str[i] == ' ') i++;
  1258. if (str[i] == ')') i++;
  1259. else {
  1260. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1261. return 0;
  1262. }
  1263. } else {
  1264. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in transform attribute: %s\n", attribute_content));
  1265. return 0;
  1266. }
  1267. } else {
  1268. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Unrecognized transofrm type in attribute %s\n", attribute_content));
  1269. return 0;
  1270. }
  1271. /*for svgView parsing*/
  1272. if (str[i] == ')') i++;
  1273. }
  1274. return 1;
  1275. }
  1276. /* Parses an SVG transform attribute and collapses all in the given matrix */
  1277. static Bool svg_parse_transform(SVG_Transform *t, char *attribute_content)
  1278. {
  1279. char *str;
  1280. u32 i;
  1281. u32 read_chars;
  1282. str = attribute_content;
  1283. i = 0;
  1284. if ((str = strstr(attribute_content, "ref"))) {
  1285. t->is_ref = 1;
  1286. gf_mx2d_init(t->mat);
  1287. str+=2;
  1288. while (str[i] == ' ') i++;
  1289. if (str[i] == '(') {
  1290. i++;
  1291. while (str[i] == ' ') i++;
  1292. if (str[i] == 's' && str[i+1] == 'v' && str[i+2] == 'g') {
  1293. i+=3;
  1294. while (str[i] == ' ') i++;
  1295. if (str[i] == ',') {
  1296. i++;
  1297. } else if (str[i] == ')') {
  1298. i++;
  1299. return GF_OK;
  1300. }
  1301. read_chars = svg_parse_number(&(str[i]), &(t->mat.m[2]), 0);
  1302. if (!read_chars) {
  1303. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient tx in ref transform: %s\n", attribute_content));
  1304. return GF_BAD_PARAM;
  1305. }
  1306. i += read_chars;
  1307. read_chars = svg_parse_number(&(str[i]), &(t->mat.m[5]), 0);
  1308. if (!read_chars) {
  1309. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error reading coefficient ty in ref transform: %s\n", attribute_content));
  1310. return GF_BAD_PARAM;
  1311. }
  1312. i += read_chars;
  1313. } else {
  1314. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Unsupported syntax for ref transform attribute"));
  1315. }
  1316. while (str[i] == ' ') i++;
  1317. if (str[i] == ')') i++;
  1318. else {
  1319. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing closing parenthesis in transform attribute: %s\n", attribute_content));
  1320. }
  1321. return GF_OK;
  1322. } else {
  1323. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Missing opening parenthesis in ref transform attribute: %s\n", attribute_content));
  1324. return GF_BAD_PARAM;
  1325. }
  1326. } else {
  1327. read_chars = gf_svg_parse_transformlist(&t->mat, attribute_content);
  1328. if (!read_chars) {
  1329. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error parsing transform list: %s\n", attribute_content));
  1330. return GF_BAD_PARAM;
  1331. }
  1332. }
  1333. return GF_OK;
  1334. }
  1335. #undef REMOVE_ALLOC
  1336. #if USE_GF_PATH
  1337. //#define PARSE_PATH_ONLY
  1338. static void svg_parse_path(SVG_PathData *path, char *attribute_content)
  1339. {
  1340. char *d = attribute_content;
  1341. /* used to detect end of BNF production:
  1342. "The processing of the BNF must consume as much of a given BNF production as possible,
  1343. stopping at the point when a character is encountered which no longer satisfies the production." */
  1344. u32 read_chars = 0;
  1345. /* Point used to start a new subpath when the previous subpath is closed */
  1346. SVG_Point prev_m_pt;
  1347. /* Point used to convert relative 'lower-case commands' into absolute */
  1348. SVG_Point rel_ref_pt;
  1349. /* Points used to convert S, T commands into C, Q */
  1350. SVG_Point orig, ct_orig, ct_end, end;
  1351. /* Used by elliptical arcs */
  1352. Fixed x_axis_rotation, large_arc_flag, sweep_flag;
  1353. char c, prev_c;
  1354. u32 i;
  1355. if (*d == 0) return;
  1356. i = 0;
  1357. prev_c = 'M';
  1358. 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;
  1359. while(1) {
  1360. while ( (d[i]==' ') || (d[i] =='\t') || (d[i] =='\r') || (d[i] =='\n') ) i++;
  1361. c = d[i];
  1362. if (! c) break;
  1363. next_command:
  1364. switch (c) {
  1365. case 'm':
  1366. case 'M':
  1367. i++;
  1368. read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
  1369. if (!read_chars) return;
  1370. i += read_chars;
  1371. read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
  1372. if (!read_chars) return;
  1373. i += read_chars;
  1374. if (c == 'm') {
  1375. orig.x += rel_ref_pt.x;
  1376. orig.y += rel_ref_pt.y;
  1377. }
  1378. #ifndef PARSE_PATH_ONLY
  1379. gf_path_add_move_to(path, orig.x, orig.y);
  1380. #endif
  1381. rel_ref_pt = orig;
  1382. prev_m_pt = orig;
  1383. /*provision for nextCurveTo when no curve is specified:
  1384. "If there is no previous command or if the previous command was not an C, c, S or s,
  1385. assume the first control point is coincident with the current point.
  1386. */
  1387. ct_orig = orig;
  1388. prev_c = c;
  1389. break;
  1390. case 'L':
  1391. case 'l':
  1392. i++;
  1393. read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
  1394. if (!read_chars) return;
  1395. i += read_chars;
  1396. read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
  1397. if (!read_chars) return;
  1398. i += read_chars;
  1399. if (c == 'l') {
  1400. orig.x += rel_ref_pt.x;
  1401. orig.y += rel_ref_pt.y;
  1402. }
  1403. #ifndef PARSE_PATH_ONLY
  1404. gf_path_add_line_to(path, orig.x, orig.y);
  1405. #endif
  1406. rel_ref_pt = orig;
  1407. orig = end;
  1408. /*cf above*/
  1409. ct_orig = orig;
  1410. prev_c = c;
  1411. break;
  1412. case 'H':
  1413. case 'h':
  1414. i++;
  1415. read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
  1416. if (!read_chars) return;
  1417. i += read_chars;
  1418. if (c == 'h') {
  1419. orig.x += rel_ref_pt.x;
  1420. }
  1421. orig.y = rel_ref_pt.y;
  1422. #ifndef PARSE_PATH_ONLY
  1423. gf_path_add_line_to(path, orig.x, orig.y);
  1424. #endif
  1425. rel_ref_pt.x = orig.x;
  1426. orig = end;
  1427. /*cf above*/
  1428. ct_orig = orig;
  1429. prev_c = c;
  1430. break;
  1431. case 'V':
  1432. case 'v':
  1433. i++;
  1434. read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
  1435. if (!read_chars) return;
  1436. i += read_chars;
  1437. if (c == 'v') {
  1438. orig.y += rel_ref_pt.y;
  1439. }
  1440. orig.x = rel_ref_pt.x;
  1441. #ifndef PARSE_PATH_ONLY
  1442. gf_path_add_line_to(path, orig.x, orig.y);
  1443. #endif
  1444. rel_ref_pt.y = orig.y;
  1445. orig = end;
  1446. /*cf above*/
  1447. ct_orig = orig;
  1448. prev_c = c;
  1449. break;
  1450. case 'C':
  1451. case 'c':
  1452. i++;
  1453. read_chars = svg_parse_number(&(d[i]), &(ct_orig.x), 0);
  1454. if (!read_chars) return;
  1455. i += read_chars;
  1456. read_chars = svg_parse_number(&(d[i]), &(ct_orig.y), 0);
  1457. if (!read_chars) return;
  1458. i += read_chars;
  1459. if (c == 'c') {
  1460. ct_orig.x += rel_ref_pt.x;
  1461. ct_orig.y += rel_ref_pt.y;
  1462. }
  1463. read_chars = svg_parse_number(&(d[i]), &(ct_end.x), 0);
  1464. if (!read_chars) return;
  1465. i += read_chars;
  1466. read_chars = svg_parse_number(&(d[i]), &(ct_end.y), 0);
  1467. if (!read_chars) return;
  1468. i += read_chars;
  1469. if (c == 'c') {
  1470. ct_end.x += rel_ref_pt.x;
  1471. ct_end.y += rel_ref_pt.y;
  1472. }
  1473. read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
  1474. if (!read_chars) return;
  1475. i += read_chars;
  1476. read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
  1477. if (!read_chars) return;
  1478. i += read_chars;
  1479. if (c == 'c') {
  1480. end.x += rel_ref_pt.x;
  1481. end.y += rel_ref_pt.y;
  1482. }
  1483. #ifndef PARSE_PATH_ONLY
  1484. gf_path_add_cubic_to(path, ct_orig.x, ct_orig.y, ct_end.x, ct_end.y, end.x, end.y);
  1485. #endif
  1486. rel_ref_pt = end;
  1487. ct_orig = ct_end;
  1488. orig = end;
  1489. prev_c = c;
  1490. break;
  1491. case 'S':
  1492. case 's':
  1493. i++;
  1494. ct_orig.x = 2*orig.x - ct_orig.x;
  1495. ct_orig.y = 2*orig.y - ct_orig.y;
  1496. read_chars = svg_parse_number(&(d[i]), &(ct_end.x), 0);
  1497. if (!read_chars) return;
  1498. i += read_chars;
  1499. read_chars = svg_parse_number(&(d[i]), &(ct_end.y), 0);
  1500. if (!read_chars) return;
  1501. i += read_chars;
  1502. if (c == 's') {
  1503. ct_end.x += rel_ref_pt.x;
  1504. ct_end.y += rel_ref_pt.y;
  1505. }
  1506. read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
  1507. if (!read_chars) return;
  1508. i += read_chars;
  1509. read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
  1510. if (!read_chars) return;
  1511. i += read_chars;
  1512. if (c == 's') {
  1513. end.x += rel_ref_pt.x;
  1514. end.y += rel_ref_pt.y;
  1515. }
  1516. #ifndef PARSE_PATH_ONLY
  1517. gf_path_add_cubic_to(path, ct_orig.x, ct_orig.y, ct_end.x, ct_end.y, end.x, end.y);
  1518. #endif
  1519. rel_ref_pt = end;
  1520. ct_orig = ct_end;
  1521. orig = end;
  1522. prev_c = c;
  1523. break;
  1524. case 'Q':
  1525. case 'q':
  1526. i++;
  1527. read_chars = svg_parse_number(&(d[i]), &(ct_orig.x), 0);
  1528. if (!read_chars) return;
  1529. i += read_chars;
  1530. read_chars = svg_parse_number(&(d[i]), &(ct_orig.y), 0);
  1531. if (!read_chars) return;
  1532. i += read_chars;
  1533. if (c == 'q') {
  1534. ct_orig.x += rel_ref_pt.x;
  1535. ct_orig.y += rel_ref_pt.y;
  1536. }
  1537. read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
  1538. if (!read_chars) return;
  1539. i += read_chars;
  1540. read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
  1541. if (!read_chars) return;
  1542. i += read_chars;
  1543. if (c == 'q') {
  1544. end.x += rel_ref_pt.x;
  1545. end.y += rel_ref_pt.y;
  1546. }
  1547. #ifndef PARSE_PATH_ONLY
  1548. gf_path_add_quadratic_to(path, ct_orig.x, ct_orig.y, end.x, end.y);
  1549. #endif
  1550. rel_ref_pt = end;
  1551. orig = end;
  1552. prev_c = c;
  1553. break;
  1554. case 'T':
  1555. case 't':
  1556. i++;
  1557. ct_orig.x = 2*orig.x - ct_orig.x;
  1558. ct_orig.y = 2*orig.y - ct_orig.y;
  1559. read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
  1560. if (!read_chars) return;
  1561. i += read_chars;
  1562. read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
  1563. if (!read_chars) return;
  1564. i += read_chars;
  1565. if (c == 't') {
  1566. end.x += rel_ref_pt.x;
  1567. end.y += rel_ref_pt.y;
  1568. }
  1569. #ifndef PARSE_PATH_ONLY
  1570. gf_path_add_quadratic_to(path, ct_orig.x, ct_orig.y, end.x, end.y);
  1571. #endif
  1572. rel_ref_pt = end;
  1573. orig = end;
  1574. prev_c = c;
  1575. break;
  1576. case 'A':
  1577. case 'a':
  1578. i++;
  1579. read_chars = svg_parse_number(&(d[i]), &(orig.x), 0);
  1580. if (!read_chars) return;
  1581. i += read_chars;
  1582. read_chars = svg_parse_number(&(d[i]), &(orig.y), 0);
  1583. if (!read_chars) return;
  1584. i += read_chars;
  1585. read_chars = svg_parse_number(&(d[i]), &(x_axis_rotation), 0);
  1586. if (!read_chars) return;
  1587. i += read_chars;
  1588. read_chars = svg_parse_number(&(d[i]), &(large_arc_flag), 0);
  1589. if (!read_chars) return;
  1590. i += read_chars;
  1591. read_chars = svg_parse_number(&(d[i]), &(sweep_flag), 0);
  1592. if (!read_chars) return;
  1593. i += read_chars;
  1594. read_chars = svg_parse_number(&(d[i]), &(end.x), 0);
  1595. if (!read_chars) return;
  1596. i += read_chars;
  1597. read_chars = svg_parse_number(&(d[i]), &(end.y), 0);
  1598. if (!read_chars) return;
  1599. i += read_chars;
  1600. if (c == 'a') {
  1601. end.x += rel_ref_pt.x;
  1602. end.y += rel_ref_pt.y;
  1603. }
  1604. #ifndef PARSE_PATH_ONLY
  1605. 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));
  1606. #endif
  1607. rel_ref_pt = end;
  1608. ct_orig = end;
  1609. prev_c = c;
  1610. break;
  1611. case 'Z':
  1612. case 'z':
  1613. i++;
  1614. #ifndef PARSE_PATH_ONLY
  1615. gf_path_close(path);
  1616. #endif
  1617. prev_c = c;
  1618. rel_ref_pt = prev_m_pt;
  1619. break;
  1620. default:
  1621. i--;
  1622. switch (prev_c) {
  1623. case 'M':
  1624. c = 'L';
  1625. break;
  1626. case 'm':
  1627. c = 'l';
  1628. break;
  1629. default:
  1630. c = prev_c;
  1631. }
  1632. goto next_command;
  1633. }
  1634. }
  1635. }
  1636. #else
  1637. /* TODO: Change the function to handle elliptical arcs, requires changing data structure */
  1638. static void svg_parse_path(SVG_PathData *d_attribute, char *attribute_content)
  1639. {
  1640. GF_List *d_commands = d_attribute->commands;
  1641. GF_List *d_points = d_attribute->points;
  1642. char *d = attribute_content;
  1643. if (strlen(d)) {
  1644. SVG_Point *pt, cur_pt, prev_m_pt;
  1645. u8 *command;
  1646. u32 i, k;
  1647. char c, prev_c = 'M';
  1648. #ifdef REMOVE_ALLOC
  1649. GF_SAFEALLOC(pt, SVG_Point)
  1650. #endif
  1651. i = 0;
  1652. cur_pt.x = cur_pt.y = 0;
  1653. prev_m_pt.x = prev_m_pt.y = 0;
  1654. while(1) {
  1655. while ( (d[i]==' ') || (d[i] =='\t') ) i++;
  1656. c = d[i];
  1657. if (! c) break;
  1658. next_command:
  1659. switch (c) {
  1660. case 'm':
  1661. case 'M':
  1662. i++;
  1663. #ifndef REMOVE_ALLOC
  1664. GF_SAFEALLOC(command, u8)
  1665. gf_list_add(d_commands, command);
  1666. *command = SVG_PATHCOMMAND_M;
  1667. GF_SAFEALLOC(pt, SVG_Point)
  1668. gf_list_add(d_points, pt);
  1669. #endif
  1670. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1671. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1672. if (c == 'm') {
  1673. pt->x += cur_pt.x;
  1674. pt->y += cur_pt.y;
  1675. }
  1676. cur_pt.x = pt->x;
  1677. cur_pt.y = pt->y;
  1678. prev_m_pt = cur_pt;
  1679. prev_c = c;
  1680. break;
  1681. case 'L':
  1682. case 'l':
  1683. i++;
  1684. #ifndef REMOVE_ALLOC
  1685. GF_SAFEALLOC(command, u8)
  1686. gf_list_add(d_commands, command);
  1687. *command = SVG_PATHCOMMAND_L;
  1688. GF_SAFEALLOC(pt, SVG_Point)
  1689. gf_list_add(d_points, pt);
  1690. #endif
  1691. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1692. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1693. if (c == 'l') {
  1694. pt->x += cur_pt.x;
  1695. pt->y += cur_pt.y;
  1696. }
  1697. cur_pt.x = pt->x;
  1698. cur_pt.y = pt->y;
  1699. prev_c = c;
  1700. break;
  1701. case 'H':
  1702. case 'h':
  1703. i++;
  1704. #ifndef REMOVE_ALLOC
  1705. GF_SAFEALLOC(command, u8)
  1706. gf_list_add(d_commands, command);
  1707. *command = SVG_PATHCOMMAND_L;
  1708. GF_SAFEALLOC(pt, SVG_Point)
  1709. gf_list_add(d_points, pt);
  1710. #endif
  1711. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1712. if (c == 'h') {
  1713. pt->x += cur_pt.x;
  1714. }
  1715. pt->y = cur_pt.y;
  1716. cur_pt.x = pt->x;
  1717. prev_c = c;
  1718. break;
  1719. case 'V':
  1720. case 'v':
  1721. i++;
  1722. #ifndef REMOVE_ALLOC
  1723. GF_SAFEALLOC(command, u8)
  1724. gf_list_add(d_commands, command);
  1725. *command = SVG_PATHCOMMAND_L;
  1726. GF_SAFEALLOC(pt, SVG_Point)
  1727. gf_list_add(d_points, pt);
  1728. #endif
  1729. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1730. if (c == 'v') {
  1731. pt->y += cur_pt.y;
  1732. }
  1733. pt->x = cur_pt.x;
  1734. cur_pt.y = pt->y;
  1735. prev_c = c;
  1736. break;
  1737. case 'C':
  1738. case 'c':
  1739. i++;
  1740. #ifndef REMOVE_ALLOC
  1741. GF_SAFEALLOC(command, u8)
  1742. gf_list_add(d_commands, command);
  1743. *command = SVG_PATHCOMMAND_C;
  1744. #endif
  1745. for (k=0; k<3; k++) {
  1746. #ifndef REMOVE_ALLOC
  1747. GF_SAFEALLOC(pt, SVG_Point)
  1748. gf_list_add(d_points, pt);
  1749. #endif
  1750. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1751. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1752. if (c == 'c') {
  1753. pt->x += cur_pt.x;
  1754. pt->y += cur_pt.y;
  1755. }
  1756. }
  1757. cur_pt.x = pt->x;
  1758. cur_pt.y = pt->y;
  1759. prev_c = c;
  1760. break;
  1761. case 'S':
  1762. case 's':
  1763. i++;
  1764. #ifndef REMOVE_ALLOC
  1765. GF_SAFEALLOC(command, u8)
  1766. gf_list_add(d_commands, command);
  1767. *command = SVG_PATHCOMMAND_S;
  1768. #endif
  1769. for (k=0; k<2; k++) {
  1770. #ifndef REMOVE_ALLOC
  1771. GF_SAFEALLOC(pt, SVG_Point)
  1772. gf_list_add(d_points, pt);
  1773. #endif
  1774. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1775. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1776. if (c == 's') {
  1777. pt->x += cur_pt.x;
  1778. pt->y += cur_pt.y;
  1779. }
  1780. }
  1781. cur_pt.x = pt->x;
  1782. cur_pt.y = pt->y;
  1783. prev_c = c;
  1784. break;
  1785. case 'Q':
  1786. case 'q':
  1787. i++;
  1788. #ifndef REMOVE_ALLOC
  1789. GF_SAFEALLOC(command, u8)
  1790. gf_list_add(d_commands, command);
  1791. *command = SVG_PATHCOMMAND_Q;
  1792. #endif
  1793. for (k=0; k<2; k++) {
  1794. #ifndef REMOVE_ALLOC
  1795. GF_SAFEALLOC(pt, SVG_Point)
  1796. gf_list_add(d_points, pt);
  1797. #endif
  1798. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1799. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1800. if (c == 'q') {
  1801. pt->x += cur_pt.x;
  1802. pt->y += cur_pt.y;
  1803. }
  1804. }
  1805. cur_pt.x = pt->x;
  1806. cur_pt.y = pt->y;
  1807. prev_c = c;
  1808. break;
  1809. case 'T':
  1810. case 't':
  1811. i++;
  1812. #ifndef REMOVE_ALLOC
  1813. GF_SAFEALLOC(command, u8)
  1814. gf_list_add(d_commands, command);
  1815. *command = SVG_PATHCOMMAND_T;
  1816. GF_SAFEALLOC(pt, SVG_Point)
  1817. gf_list_add(d_points, pt);
  1818. #endif
  1819. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1820. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1821. if (c == 't') {
  1822. pt->x += cur_pt.x;
  1823. pt->y += cur_pt.y;
  1824. }
  1825. cur_pt.x = pt->x;
  1826. cur_pt.y = pt->y;
  1827. prev_c = c;
  1828. break;
  1829. case 'A':
  1830. case 'a':
  1831. {
  1832. Fixed tmp;
  1833. i++;
  1834. #ifndef REMOVE_ALLOC
  1835. GF_SAFEALLOC(command, u8)
  1836. gf_list_add(d_commands, command);
  1837. *command = SVG_PATHCOMMAND_A;
  1838. GF_SAFEALLOC(pt, SVG_Point)
  1839. gf_list_add(d_points, pt);
  1840. #endif
  1841. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1842. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1843. i += svg_parse_number(&(d[i]), &(tmp), 0);
  1844. i += svg_parse_number(&(d[i]), &(tmp), 0);
  1845. i += svg_parse_number(&(d[i]), &(tmp), 0);
  1846. #ifndef REMOVE_ALLOC
  1847. GF_SAFEALLOC(pt, SVG_Point)
  1848. gf_list_add(d_points, pt);
  1849. #endif
  1850. i += svg_parse_number(&(d[i]), &(pt->x), 0);
  1851. i += svg_parse_number(&(d[i]), &(pt->y), 0);
  1852. if (c == 'a') {
  1853. pt->x += cur_pt.x;
  1854. pt->y += cur_pt.y;
  1855. }
  1856. cur_pt.x = pt->x;
  1857. cur_pt.y = pt->y;
  1858. }
  1859. prev_c = c;
  1860. break;
  1861. case 'Z':
  1862. case 'z':
  1863. i++;
  1864. #ifndef REMOVE_ALLOC
  1865. GF_SAFEALLOC(command, u8)
  1866. gf_list_add(d_commands, command);
  1867. *command = SVG_PATHCOMMAND_Z;
  1868. #endif
  1869. prev_c = c;
  1870. cur_pt = prev_m_pt;
  1871. break;
  1872. default:
  1873. i--;
  1874. switch (prev_c) {
  1875. case 'M':
  1876. c = 'L';
  1877. break;
  1878. case 'm':
  1879. c = 'l';
  1880. break;
  1881. default:
  1882. c = prev_c;
  1883. }
  1884. goto next_command;
  1885. }
  1886. }
  1887. }
  1888. }
  1889. #endif
  1890. static void svg_parse_iri(GF_Node *elt, XMLRI *iri, char *attribute_content)
  1891. {
  1892. if (iri->string) {
  1893. gf_free(iri->string);
  1894. iri->string = NULL;
  1895. }
  1896. /* TODO: Handle xpointer(id()) syntax */
  1897. if (attribute_content[0] == '#') {
  1898. iri->string = gf_strdup(attribute_content);
  1899. iri->target = gf_sg_find_node_by_name(elt->sgprivate->scenegraph, attribute_content + 1);
  1900. if (!iri->target) {
  1901. iri->type = XMLRI_STRING;
  1902. } else {
  1903. iri->type = XMLRI_ELEMENTID;
  1904. gf_node_register_iri(elt->sgprivate->scenegraph, iri);
  1905. }
  1906. } else {
  1907. iri->type = XMLRI_STRING;
  1908. iri->string = gf_strdup(attribute_content);
  1909. }
  1910. }
  1911. static void svg_parse_idref(GF_Node *elt, XML_IDREF *iri, char *attribute_content)
  1912. {
  1913. iri->type = XMLRI_ELEMENTID;
  1914. iri->target = gf_sg_find_node_by_name(elt->sgprivate->scenegraph, attribute_content);
  1915. if (!iri->target) {
  1916. iri->string = gf_strdup(attribute_content);
  1917. } else {
  1918. gf_node_register_iri(elt->sgprivate->scenegraph, iri);
  1919. }
  1920. }
  1921. /* Parses a paint attribute: none, inherit or color */
  1922. static void svg_parse_paint(GF_Node *n, SVG_Paint *paint, char *attribute_content)
  1923. {
  1924. if (!strcmp(attribute_content, "none")) {
  1925. paint->type = SVG_PAINT_NONE;
  1926. } else if (!strcmp(attribute_content, "inherit")) {
  1927. paint->type = SVG_PAINT_INHERIT;
  1928. } else if (!strncmp(attribute_content, "url(", 4) ) {
  1929. char *ext = strrchr(attribute_content, ')');
  1930. paint->type = SVG_PAINT_URI;
  1931. if (ext) ext[0] = 0;
  1932. svg_parse_iri(n, &paint->iri, attribute_content+4);
  1933. if (ext) ext[0] = ')';
  1934. } else {
  1935. paint->type = SVG_PAINT_COLOR;
  1936. svg_parse_color(&paint->color, attribute_content);
  1937. }
  1938. }
  1939. /* Parses a length which is a number with a unit */
  1940. static u32 svg_parse_length(SVG_Number *number, char *value_string, Bool clamp0to1)
  1941. {
  1942. char c = '\0';
  1943. char *unit = NULL;
  1944. u32 len = 0;
  1945. u32 unit_pos = 0;
  1946. u32 unit_len = 0;
  1947. u32 read_chars;
  1948. if (!strcmp(value_string, "inherit")) {
  1949. number->type = SVG_NUMBER_INHERIT;
  1950. return 7;
  1951. } else if (!strcmp(value_string, "auto")) {
  1952. number->type = SVG_NUMBER_AUTO;
  1953. return 4;
  1954. } else if (!strcmp(value_string, "auto-reverse")) {
  1955. number->type = SVG_NUMBER_AUTO_REVERSE;
  1956. return 12;
  1957. } else if ((unit = strstr(value_string, "%")) ) {
  1958. number->type = SVG_NUMBER_PERCENTAGE;
  1959. unit_len = 1;
  1960. } else if ((unit = strstr(value_string, "em"))) {
  1961. number->type = SVG_NUMBER_EMS;
  1962. } else if ((unit = strstr(value_string, "ex"))) {
  1963. number->type = SVG_NUMBER_EXS;
  1964. } else if ((unit = strstr(value_string, "px"))) {
  1965. number->type = SVG_NUMBER_PX;
  1966. } else if ((unit = strstr(value_string, "cm"))) {
  1967. number->type = SVG_NUMBER_CM;
  1968. } else if ((unit = strstr(value_string, "mm"))) {
  1969. number->type = SVG_NUMBER_MM;
  1970. } else if ((unit = strstr(value_string, "in"))) {
  1971. number->type = SVG_NUMBER_IN;
  1972. } else if ((unit = strstr(value_string, "pt"))) {
  1973. number->type = SVG_NUMBER_PT;
  1974. } else if ((unit = strstr(value_string, "pc"))) {
  1975. number->type = SVG_NUMBER_PC;
  1976. } else {
  1977. number->type = SVG_NUMBER_VALUE;
  1978. }
  1979. if (unit) {
  1980. if (!unit_len) unit_len = 2;
  1981. unit_pos = unit - value_string;
  1982. /* setting the first unit character to 0 for the svg_parse_number method to finish */
  1983. c = value_string[unit_pos];
  1984. value_string[unit_pos] = 0;
  1985. }
  1986. read_chars = svg_parse_number(value_string, &(number->value), 0);
  1987. if (unit) {
  1988. value_string[unit_pos] = c;
  1989. }
  1990. if (!read_chars) {
  1991. GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error in parsing: %s\n", value_string));
  1992. len = 0;
  1993. } else {
  1994. len = unit_len + read_chars;
  1995. }
  1996. if (clamp0to1) number->value = MAX(0, MIN(1, number->value));
  1997. return len;
  1998. }
  1999. static void svg_parse_visibility(SVG_Visibility *value, char *value_string)
  2000. {
  2001. if (!strcmp(value_string, "inherit")) {
  2002. *value = SVG_VISIBILITY_INHERIT;
  2003. } else if (!strcmp(value_string, "visible")) {
  2004. *value = SVG_VISIBILITY_VISIBLE;
  2005. } else if (!strcmp(value_string, "hidden")) {
  2006. *value = SVG_VISIBILITY_HIDDEN;
  2007. } else if (!strcmp(value_string, "collapse")) {
  2008. *value = SVG_VISIBILITY_COLLAPSE;
  2009. }
  2010. }
  2011. static void svg_parse_display(SVG_Display *value, char *value_string)
  2012. {
  2013. if (!strcmp(value_string, "inherit")) {
  2014. *value = SVG_DISPLAY_INHERIT;
  2015. } else if (!strcmp(value_string, "none")) {
  2016. *value = SVG_DISPLAY_NONE;
  2017. } else if (!strcmp(value_string, "inline")) {
  2018. *value = SVG_DISPLAY_INLINE;
  2019. } else if (!strcmp(value_string, "block")) {
  2020. *value = SVG_DISPLAY_BLOCK;
  2021. } else if (!strcmp(value_string, "list-item")) {
  2022. *value = SVG_DISPLAY_LIST_ITEM;
  2023. } else if (!strcmp(value_string, "run-in")) {
  2024. *value = SVG_DISPLAY_RUN_IN;
  2025. } else if (!strcmp(value_string, "compact")) {
  2026. *value = SVG_DISPLAY_COMPACT;
  2027. } else if (!strcmp(value_string, "marker")) {
  2028. *value = SVG_DISPLAY_MARKER;
  2029. } else if (!strcmp(value_string, "table")) {
  2030. *value = SVG_DISPLAY_TABLE;
  2031. } else if (!strcmp(value_string, "inline-table")) {
  2032. *value = SVG_DISPLAY_INLINE_TABLE;
  2033. } else if (!strcmp(value_string, "table-row-group")) {
  2034. *value = SVG_DISPLAY_TABLE_ROW_GROUP;
  2035. } else if (!strcmp(value_string, "table-header-group")) {
  2036. *value = SVG_DISPLAY_TABLE_HEADER_GROUP;
  2037. } else if (!strcmp(value_string, "table-footer-group")) {
  2038. *value = SVG_DISPLAY_TABLE_FOOTER_GROUP;
  2039. } else if (!strcmp(value_string, "table-row")) {
  2040. *value = SVG_DISPLAY_TABLE_ROW;
  2041. } else if (!strcmp(value_string, "table-column-group")) {
  2042. *value = SVG_DISPLAY_TABLE_COLUMN_GROUP;
  2043. } else if (!strcmp(value_string, "table-column")) {
  2044. *value = SVG_DISPLAY_TABLE_COLUMN;
  2045. } else if (!strcmp(value_string, "table-cell")) {
  2046. *value = SVG_DISPLAY_TABLE_CELL;
  2047. } else if (!strcmp(value_string, "table-caption")) {
  2048. *value = SVG_DISPLAY_TABLE_CAPTION;
  2049. }
  2050. }
  2051. static void svg_parse_displayalign(SVG_DisplayAlign *value, char *value_string)
  2052. {
  2053. if (!strcmp(value_string, "inherit")) {
  2054. *value = SVG_DISPLAYALIGN_INHERIT;
  2055. } else if (!strcmp(value_string, "auto")) {
  2056. *value = SVG_DISPLAYALIGN_AUTO;
  2057. } else if (!strcmp(value_string, "before")) {
  2058. *value = SVG_DISPLAYALIGN_BEFORE;
  2059. } else if (!strcmp(value_string, "center")) {
  2060. *value = SVG_DISPLAYALIGN_CENTER;
  2061. } else if (!strcmp(value_string, "after")) {
  2062. *value = SVG_DISPLAYALIGN_AFTER;
  2063. }
  2064. }
  2065. static void svg_parse_textalign(SVG_TextAlign *value, char *value_string)
  2066. {
  2067. if (!strcmp(value_string, "inherit")) {
  2068. *value = SVG_TEXTALIGN_INHERIT;
  2069. } else if (!strcmp(value_string, "start")) {
  2070. *value = SVG_TEXTALIGN_START;
  2071. } else if (!strcmp(value_string, "center")) {
  2072. *value = SVG_TEXTALIGN_CENTER;
  2073. } else if (!strcmp(value_string, "end")) {
  2074. *value = SVG_TEXTALIGN_END;
  2075. }
  2076. }
  2077. static void svg_parse_pointerevents(SVG_PointerEvents *value, char *value_string)
  2078. {
  2079. if (!strcmp(value_string, "inherit")) {
  2080. *value = SVG_POINTEREVENTS_INHERIT;
  2081. } else if (!strcmp(value_string, "visiblePainted")) {
  2082. *value = SVG_POINTEREVENTS_VISIBLEPAINTED;
  2083. } else if (!strcmp(value_string, "visibleFill")) {
  2084. *value = SVG_POINTEREVENTS_VISIBLEFILL;
  2085. } else if (!strcmp(value_string, "visibleStroke")) {
  2086. *value = SVG_POINTEREVENTS_VISIBLESTROKE;
  2087. } else if (!strcmp(value_string, "visible")) {
  2088. *value = SVG_POINTEREVENTS_VISIBLE;
  2089. } else if (!strcmp(value_string, "painted")) {
  2090. *value = SVG_POINTEREVENTS_PAINTED;
  2091. } else if (!strcmp(value_string, "fill")) {
  2092. *value = SVG_POINTEREVENTS_FILL;
  2093. } else if (!strcmp(value_string, "stroke")) {
  2094. *value = SVG_POINTEREVENTS_STROKE;
  2095. } else if (!strcmp(value_string, "all")) {
  2096. *value = SVG_POINTEREVENTS_ALL;
  2097. } else if (!strcmp(value_string, "boundingBox")) {
  2098. *value = SVG_POINTEREVENTS_BOUNDINGBOX;
  2099. } else if (!strcmp(value_string, "none")) {
  2100. *value = SVG_POINTEREVENTS_NONE;
  2101. }
  2102. }
  2103. static void svg_parse_renderinghint(SVG_RenderingHint *value, char *value_string)
  2104. {
  2105. if (!strcmp(value_string, "inherit")) {
  2106. *value = SVG_RENDERINGHINT_INHERIT;
  2107. } else if (!strcmp(value_string, "auto")) {
  2108. *value = SVG_RENDERINGHINT_AUTO;
  2109. } else if (!strcmp(value_string, "optimizeQuality")) {
  2110. *value = SVG_RENDERINGHINT_OPTIMIZEQUALITY;
  2111. } else if (!strcmp(value_string, "optimizeSpeed")) {
  2112. *value = SVG_RENDERINGHINT_OPTIMIZESPEED;
  2113. } else if (!strcmp(value_string, "optimizeLegibility")) {
  2114. *value = SVG_RENDERINGHINT_OPTIMIZELEGIBILITY;
  2115. } else if (!strcmp(value_string, "crispEdges")) {
  2116. *value = SVG_RENDERINGHINT_CRISPEDGES;
  2117. } else if (!strcmp(value_string, "geometricPrecision")) {
  2118. *value = SVG_RENDERINGHINT_GEOMETRICPRECISION;
  2119. }
  2120. }
  2121. static void svg_parse_vectoreffect(SVG_VectorEffect *value, char *value_string)
  2122. {
  2123. if (!strcmp(value_string, "inherit")) {
  2124. *value = SVG_VECTOREFFECT_INHERIT;
  2125. } else if (!strcmp(value_string, "none")) {
  2126. *value = SVG_VECTOREFFECT_NONE;
  2127. } else if (!strcmp(value_string, "non-scaling-stroke")) {
  2128. *value = SVG_VECTOREFFECT_NONSCALINGSTROKE;
  2129. }
  2130. }
  2131. static void svg_parse_playbackorder(SVG_VectorEffect *value, char *value_string)
  2132. {
  2133. if (!strcmp(value_string, "forwardOnly")) {
  2134. *value = SVG_PLAYBACKORDER_FORWARDONLY;
  2135. } else if (!strcmp(value_string, "all")) {
  2136. *value = SVG_PLAYBACKORDER_ALL;
  2137. }
  2138. }
  2139. static void svg_parse_timelinebegin(SVG_TimelineBegin *value, char *value_string)
  2140. {
  2141. if (!strcmp(value_string, "onStart")) {
  2142. *value = SVG_TIMELINEBEGIN_ONSTART;
  2143. } else if (!strcmp(value_string, "onLoad")) {
  2144. *value = SVG_TIMELINEBEGIN_ONLOAD;
  2145. }
  2146. }
  2147. static void svg_parse_xmlspace(XML_Space *value, char *value_string)
  2148. {
  2149. if (!strcmp(value_string, "default")) {
  2150. *value = XML_SPACE_DEFAULT;
  2151. } else if (!strcmp(value_string, "preserve")) {
  2152. *value = XML_SPACE_PRESERVE;
  2153. }
  2154. }
  2155. static void svg_parse_xmlev_propagate(XMLEV_Propagate *value, char *value_string)
  2156. {
  2157. if (!strcmp(value_string, "continue")) {
  2158. *value = XMLEVENT_PROPAGATE_CONTINUE;
  2159. } else if (!strcmp(value_string, "stop")) {
  2160. *value = XMLEVENT_PROPAGATE_STOP;
  2161. }
  2162. }
  2163. static void svg_parse_xmlev_defaultAction(XMLEV_DefaultAction *value, char *value_string)
  2164. {
  2165. if (!strcmp(value_string, "cancel")) {
  2166. *value = XMLEVENT_DEFAULTACTION_CANCEL;
  2167. } else if (!strcmp(value_string, "perform")) {
  2168. *value = XMLEVENT_DEFAULTACTION_PERFORM;
  2169. }
  2170. }
  2171. static void svg_parse_xmlev_phase(XMLEV_Phase *value, char *value_string)
  2172. {
  2173. if (!strcmp(value_string, "default")) {
  2174. *value = XMLEVENT_PHASE_DEFAULT;
  2175. } else if (!strcmp(value_string, "capture")) {
  2176. *value = XMLEVENT_PHASE_CAPTURE;
  2177. }
  2178. }
  2179. static void svg_parse_overflow(SVG_Overflow *value, char *value_string)
  2180. {
  2181. if (!strcmp(value_string, "inherit")) {
  2182. *value = SVG_OVERFLOW_INHERIT;
  2183. } else if (!strcmp(value_string, "visible")) {
  2184. *value = SVG_OVERFLOW_VISIBLE;
  2185. } else if (!strcmp(value_string, "hidden")) {
  2186. *value = SVG_OVERFLOW_HIDDEN;
  2187. } else if (!strcmp(value_string, "scroll")) {
  2188. *value = SVG_OVERFLOW_SCROLL;
  2189. } else if (!strcmp(value_string, "auto")) {
  2190. *value = SVG_OVERFLOW_AUTO;
  2191. }
  2192. }
  2193. static void svg_parse_textanchor(SVG_TextAnchor *value, char *value_string)
  2194. {
  2195. if (!strcmp(value_string, "inherit")) {
  2196. *value = SVG_TEXTANCHOR_INHERIT;
  2197. } else if (!strcmp(value_string, "start")) {
  2198. *value = SVG_TEXTANCHOR_START;
  2199. } else if (!strcmp(value_string, "middle")) {
  2200. *value = SVG_TEXTANCHOR_MIDDLE;
  2201. } else if (!strcmp(value_string, "end")) {
  2202. *value = SVG_TEXTANCHOR_END;
  2203. }
  2204. }
  2205. static void svg_parse_clipfillrule(SVG_FillRule *value, char *value_string)
  2206. {
  2207. if (!strcmp(value_string, "inherit")) {
  2208. *value = SVG_FILLRULE_INHERIT;
  2209. } else if (!strcmp(value_string, "nonzero")) {
  2210. *value = SVG_FILLRULE_NONZERO;
  2211. } else if (!strcmp(value_string, "evenodd")) {
  2212. *value = SVG_FILLRULE_EVENODD;
  2213. }
  2214. }
  2215. static void svg_parse_strokelinejoin(SVG_StrokeLineJoin *value, char *value_string)
  2216. {
  2217. if (!strcmp(value_string, "inherit")) {
  2218. *value = SVG_STROKELINEJOIN_INHERIT;
  2219. } else if (!strcmp(value_string, "miter")) {
  2220. *value = SVG_STROKELINEJOIN_MITER;
  2221. } else if (!strcmp(value_string, "round")) {
  2222. *value = SVG_STROKELINEJOIN_ROUND;
  2223. } else if (!strcmp(value_string, "bevel")) {
  2224. *value = SVG_STROKELINEJOIN_BEVEL;
  2225. }
  2226. }
  2227. static void svg_parse_strokelinecap(SVG_StrokeLineCap *value, char *value_string)
  2228. {
  2229. if (!strcmp(value_string, "inherit")) {
  2230. *value = SVG_STROKELINECAP_INHERIT;
  2231. } else if (!strcmp(value_string, "butt")) {
  2232. *value = SVG_STROKELINECAP_BUTT;
  2233. } else if (!strcmp(value_string, "round")) {
  2234. *value = SVG_STROKELINECAP_ROUND;
  2235. } else if (!strcmp(value_string, "square")) {
  2236. *value = SVG_STROKELINECAP_SQUARE;
  2237. }
  2238. }
  2239. static void svg_parse_fontfamily(SVG_FontFamily *value, char *value_string)
  2240. {
  2241. if (!strcmp(value_string, "inherit")) {
  2242. value->type = SVG_FONTFAMILY_INHERIT;
  2243. } else {
  2244. value->type = SVG_FONTFAMILY_VALUE;
  2245. value->value = gf_strdup(value_string);
  2246. }
  2247. }
  2248. static void svg_parse_fontstyle(SVG_FontStyle *value, char *value_string)
  2249. {
  2250. if (!strcmp(value_string, "inherit")) {
  2251. *value = SVG_FONTSTYLE_INHERIT;
  2252. } else if (!strcmp(value_string, "normal")) {
  2253. *value = SVG_FONTSTYLE_NORMAL;
  2254. } else if (!strcmp(value_string, "italic")) {
  2255. *value = SVG_FONTSTYLE_ITALIC;
  2256. } else if (!strcmp(value_string, "oblique")) {
  2257. *value = SVG_FONTSTYLE_OBLIQUE;
  2258. }
  2259. }
  2260. static void svg_parse_fontweight(SVG_FontWeight *value, char *value_string)
  2261. {
  2262. if (!strcmp(value_string, "inherit")) {
  2263. *value = SVG_FONTWEIGHT_INHERIT;
  2264. } else if (!strcmp(value_string, "normal")) {
  2265. *value = SVG_FONTWEIGHT_NORMAL;
  2266. } else if (!strcmp(value_string, "bold")) {
  2267. *value = SVG_FONTWEIGHT_BOLD;
  2268. } else if (!strcmp(value_string, "bolder")) {
  2269. *value = SVG_FONTWEIGHT_BOLDER;
  2270. } else if (!strcmp(value_string, "lighter")) {
  2271. *value = SVG_FONTWEIGHT_LIGHTER;
  2272. } else if (!strcmp(value_string, "100")) {
  2273. *value = SVG_FONTWEIGHT_100;
  2274. } else if (!strcmp(value_string, "200")) {
  2275. *value = SVG_FONTWEIGHT_200;
  2276. } else if (!strcmp(value_string, "300")) {
  2277. *value = SVG_FONTWEIGHT_300;
  2278. } else if (!strcmp(value_string, "400")) {
  2279. *value = SVG_FONTWEIGHT_400;
  2280. } else if (!strcmp(value_string, "500")) {
  2281. *value = SVG_FONTWEIGHT_500;
  2282. } else if (!strcmp(value_string, "600")) {
  2283. *value = SVG_FONTWEIGHT_600;
  2284. } else if (!strcmp(value_string, "700")) {
  2285. *value = SVG_FONTWEIGHT_700;
  2286. } else if (!strcmp(value_string, "800")) {
  2287. *value = SVG_FONTWEIGHT_800;
  2288. } else if (!strcmp(value_string, "900")) {
  2289. *value = SVG_FONTWEIGHT_900;
  2290. }
  2291. }
  2292. static void svg_parse_fontvariant(SVG_FontVariant *value, char *value_string)
  2293. {
  2294. if (!strcmp(value_string, "inherit")) {
  2295. *value = SVG_FONTVARIANT_INHERIT;
  2296. } else if (!strcmp(value_string, "normal")) {
  2297. *value = SVG_FONTVARIANT_NORMAL;
  2298. } else if (!strcmp(value_string, "small-caps")) {
  2299. *value = SVG_FONTVARIANT_SMALLCAPS;
  2300. }
  2301. }
  2302. static void svg_parse_boolean(SVG_Boolean *value, char *value_string)
  2303. {
  2304. /*simple for text editable*/
  2305. if (!strcmp(value_string, "1") || !strcmp(value_string, "true") || !strcmp(value_string, "simple"))
  2306. *value = 1;
  2307. else
  2308. *value = 0;
  2309. }
  2310. static void smil_parse_time_list(GF_Node *e, GF_List *values, char *begin_or_end_list)
  2311. {
  2312. SMIL_Time *value;
  2313. char value_string[500];
  2314. char *str = begin_or_end_list, *tmp;
  2315. u32 len;
  2316. /* get rid of leading spaces */
  2317. while (*str == ' ') str++;
  2318. while (1) {
  2319. tmp = strchr(str, ';');
  2320. if (tmp) len = tmp-str;
  2321. else len = strlen(str);
  2322. memcpy(value_string, str, len);
  2323. while (value_string[len - 1] == ' ' && len > 0) len--;
  2324. value_string[len] = 0;
  2325. GF_SAFEALLOC(value, SMIL_Time)
  2326. gf_list_add(values, value);
  2327. if (smil_parse_time(e, value, value_string) != GF_OK) goto err;
  2328. if (!tmp) break;
  2329. str = tmp + 1;
  2330. while (*str == ' ') str++;
  2331. }
  2332. /* sorting timing values */
  2333. if (gf_list_count(values) > 1) {
  2334. SMIL_Time *v, *sv;
  2335. GF_List *sorted = gf_list_new();
  2336. u32 i, count;
  2337. u8 added = 0;
  2338. do {
  2339. v = (SMIL_Time*)gf_list_get(values, 0);
  2340. gf_list_rem(values, 0);
  2341. added = 0;
  2342. count = gf_list_count(sorted);
  2343. for (i=0; i<count; i++) {
  2344. sv = (SMIL_Time*)gf_list_get(sorted, i);
  2345. if (v->type >= GF_SMIL_TIME_EVENT) {
  2346. /* unresolved or indefinite so add at the end of the sorted list */
  2347. gf_list_add(sorted, v);
  2348. added = 1;
  2349. break;
  2350. } else {
  2351. if (sv->type >= GF_SMIL_TIME_EVENT) {
  2352. gf_list_insert(sorted, v, i);
  2353. added = 1;
  2354. break;
  2355. } else {
  2356. if (v->clock <= sv->clock) {
  2357. gf_list_insert(sorted, v, i);
  2358. added = 1;
  2359. break;
  2360. }
  2361. }
  2362. }
  2363. }
  2364. if (!added) gf_list_add(sorted, v);
  2365. } while (gf_list_count(values) > 0);
  2366. count = gf_list_count(sorted);
  2367. for (i = 0; i < count; i++) {
  2368. gf_list_add(values, gf_list_get(sorted, i));
  2369. }
  2370. gf_list_del(sorted);
  2371. }
  2372. return;
  2373. err:
  2374. /* See SVG spec:
  2375. "If the 'begin' attribute is
  2376. syntactically invalid, in the list itself or in any of the individual
  2377. list values, it is equivalent to a single 'begin' value of 'indefinite'."*/
  2378. len = gf_list_count(values);
  2379. while (len) {
  2380. SMIL_Time *v = (SMIL_Time*)gf_list_get(values, 0);
  2381. if (v->element_id) gf_free(v->element_id);
  2382. gf_list_rem(values, 0);
  2383. gf_free(v);
  2384. len--;
  2385. }
  2386. GF_SAFEALLOC(value, SMIL_Time)
  2387. gf_list_add(values, value);
  2388. switch (e->sgprivate->tag) {
  2389. case TAG_SVG_discard:
  2390. value->type = GF_SMIL_TIME_CLOCK;
  2391. value->clock = 0;
  2392. break;
  2393. default:
  2394. value->type = GF_SMIL_TIME_INDEFINITE;
  2395. break;
  2396. }
  2397. return;
  2398. }
  2399. static void smil_parse_attributeType(SMIL_AttributeType *value, char *value_string)
  2400. {
  2401. if (!strcmp(value_string, "auto")) {
  2402. *value = SMIL_ATTRIBUTETYPE_AUTO;
  2403. } else if (!strcmp(value_string, "XML")) {
  2404. *value = SMIL_ATTRIBUTETYPE_XML;
  2405. } else if (!strcmp(value_string, "CSS")) {
  2406. *value = SMIL_ATTRIBUTETYPE_CSS;
  2407. }
  2408. }
  2409. static void smil_parse_min_max_dur_repeatdur(SMIL_Duration *value, char *value_string)
  2410. {
  2411. if (!strcmp(value_string, "indefinite")) {
  2412. value->type = SMIL_DURATION_INDEFINITE;
  2413. } else if (!strcmp(value_string, "media")) {
  2414. value->type = SMIL_DURATION_MEDIA;
  2415. } else {
  2416. Double ftime;
  2417. if ((svg_parse_clock_value(value_string, &ftime) == GF_OK) && (ftime >= 0)) {
  2418. value->clock_value = ftime;
  2419. value->type = SMIL_DURATION_DEFINED;
  2420. } else {
  2421. /* WARNING: Should this attribute in error be removed ? */
  2422. value->type = SMIL_DURATION_INDEFINITE;
  2423. }
  2424. }
  2425. }
  2426. static void smil_parse_repeatcount(SMIL_RepeatCount *value, char *value_string)
  2427. {
  2428. if (!strcmp(value_string, "indefinite")) {
  2429. value->type = SMIL_REPEATCOUNT_INDEFINITE;
  2430. } else {
  2431. Float _val;
  2432. sscanf(value_string, "%f", &_val);
  2433. value->type = SMIL_REPEATCOUNT_DEFINED;
  2434. value->count = FLT2FIX(_val);
  2435. }
  2436. }
  2437. static void smil_parse_fill(SMIL_Fill *value, char *value_string)
  2438. {
  2439. if (!strcmp(value_string, "freeze")) {
  2440. *value = SMIL_FILL_FREEZE;
  2441. } else if (!strcmp(value_string, "remove")) {
  2442. *value = SMIL_FILL_REMOVE;
  2443. }
  2444. }
  2445. static void smil_parse_restart(SMIL_Restart *value, char *value_string)
  2446. {
  2447. if (!strcmp(value_string, "always")) {
  2448. *value = SMIL_RESTART_ALWAYS;
  2449. } else if (!strcmp(value_string, "whenNotActive")) {
  2450. *value = SMIL_RESTART_WHENNOTACTIVE;
  2451. } else if (!strcmp(value_string, "never")) {
  2452. *value = SMIL_RESTART_NEVER;
  2453. }
  2454. }
  2455. static void smil_parse_calcmode(SMIL_CalcMode *value, char *value_string)
  2456. {
  2457. if (!strcmp(value_string, "discrete")) {
  2458. *value = SMIL_CALCMODE_DISCRETE;
  2459. } else if (!strcmp(value_string, "linear")) {
  2460. *value = SMIL_CALCMODE_LINEAR;
  2461. } else if (!strcmp(value_string, "paced")) {
  2462. *value = SMIL_CALCMODE_PACED;
  2463. } else if (!strcmp(value_string, "spline")) {
  2464. *value = SMIL_CALCMODE_SPLINE;
  2465. }
  2466. }
  2467. static void smil_parse_additive(SMIL_Additive *value, char *value_string)
  2468. {
  2469. if (!strcmp(value_string, "replace")) {
  2470. *value = SMIL_ADDITIVE_REPLACE;
  2471. } else if (!strcmp(value_string, "sum")) {
  2472. *value = SMIL_ADDITIVE_SUM;
  2473. }
  2474. }
  2475. static void smil_parse_accumulate(SMIL_Accumulate *value, char *value_string)
  2476. {
  2477. if (!strcmp(value_string, "none")) {
  2478. *value = SMIL_ACCUMULATE_NONE;
  2479. } else if (!strcmp(value_string, "sum")) {
  2480. *value = SMIL_ACCUMULATE_SUM;
  2481. }
  2482. }
  2483. static void smil_parse_syncBehaviorOrDefault(SMIL_SyncBehavior *value, char *value_string)
  2484. {
  2485. if (!strcmp(value_string, "inherit")) {
  2486. *value = SMIL_SYNCBEHAVIOR_INHERIT;
  2487. } else if (!strcmp(value_string, "default")) {
  2488. *value = SMIL_SYNCBEHAVIOR_DEFAULT;
  2489. } else if (!strcmp(value_string, "locked")) {
  2490. *value = SMIL_SYNCBEHAVIOR_LOCKED;
  2491. } else if (!strcmp(value_string, "canSlip")) {
  2492. *value = SMIL_SYNCBEHAVIOR_CANSLIP;
  2493. } else if (!strcmp(value_string, "independent")) {
  2494. *value = SMIL_SYNCBEHAVIOR_INDEPENDENT;
  2495. }
  2496. }
  2497. static void smil_parse_syncToleranceOrDefault(SMIL_SyncTolerance *value, char *value_string)
  2498. {
  2499. if (!strcmp(value_string, "inherit")) {
  2500. value->type = SMIL_SYNCTOLERANCE_INHERIT;
  2501. } else if (!strcmp(value_string, "default")) {
  2502. value->type = SMIL_SYNCTOLERANCE_DEFAULT;
  2503. } else {
  2504. value->type = SMIL_SYNCBEHAVIOR_LOCKED;
  2505. svg_parse_clock_value(value_string, &(value->value));
  2506. }
  2507. }
  2508. static void svg_parse_viewbox(SVG_ViewBox *value, char *value_string)
  2509. {
  2510. u32 read_chars;
  2511. char *str = value_string;
  2512. if (!strcmp(str, "none")) {
  2513. value->is_set = 0;
  2514. } else {
  2515. u32 i = 0;
  2516. value->is_set = 1;
  2517. read_chars = svg_parse_number(&(str[i]), &(value->x), 0);
  2518. if (!read_chars) return;
  2519. i += read_chars;
  2520. read_chars = svg_parse_number(&(str[i]), &(value->y), 0);
  2521. if (!read_chars) return;
  2522. i += read_chars;
  2523. read_chars = svg_parse_number(&(str[i]), &(value->width), 0);
  2524. if (!read_chars) return;
  2525. i += read_chars;
  2526. read_chars = svg_parse_number(&(str[i]), &(value->height), 0);
  2527. if (!read_chars) return;
  2528. i += read_chars;
  2529. }
  2530. }
  2531. /* Parses a list of coordinates or a list of lengths (in SVG, length and coordinate is the same type )*/
  2532. static void svg_parse_coordinates(GF_List *values, char *value_string)
  2533. {
  2534. SVG_Coordinate *c;
  2535. u32 i = 0;
  2536. char *str = value_string;
  2537. u32 len = strlen(str);
  2538. while (gf_list_count(values)) {
  2539. c = (SVG_Coordinate*)gf_list_get(values, 0);
  2540. gf_list_rem(values, 0);
  2541. gf_free(c);
  2542. }
  2543. while (i < len) {
  2544. u32 sub;
  2545. GF_SAFEALLOC(c, SVG_Coordinate)
  2546. sub = svg_parse_length(c, &(str[i]), 0);
  2547. if (!sub) {
  2548. gf_free(c);
  2549. return;
  2550. }
  2551. i+=sub;
  2552. gf_list_add(values, c);
  2553. }
  2554. }
  2555. /* Parse a point as a pair of number without units */
  2556. u32 svg_parse_point(SVG_Point *p, char *value_string)
  2557. {
  2558. u32 i = 0, j = 0;
  2559. i = svg_parse_number(&(value_string[i]), &(p->x), 0);
  2560. /* TODO: handle cases where a point has an invalid syntax */
  2561. j = svg_parse_number(&(value_string[i]), &(p->y), 0);
  2562. /* we need to detect an odd number of coordinates in polygon points list
  2563. cf. http://www.w3.org/TR/SVGMobile12/shapes.html#PolygonElement
  2564. see svg_parse_points */
  2565. if (j == 0) return 0;
  2566. else return i+j;
  2567. }
  2568. static u32 svg_parse_point_into_matrix(GF_Matrix2D *p, char *value_string)
  2569. {
  2570. u32 i = 0, j = 0;
  2571. gf_mx2d_init(*p);
  2572. i = svg_parse_number(&(value_string[i]), &(p->m[2]), 0);
  2573. if (i == 0) return 0;
  2574. j = svg_parse_number(&(value_string[i]), &(p->m[5]), 0);
  2575. if (j == 0) return 0;
  2576. return i+j;
  2577. }
  2578. /* Parses the points attribute of a polygon or polyline element */
  2579. static void svg_parse_points(GF_List *values, char *value_string)
  2580. {
  2581. u32 i = 0, j;
  2582. char *str = value_string;
  2583. u32 len = strlen(str);
  2584. while (i < len) {
  2585. SVG_Point *p;
  2586. GF_SAFEALLOC(p, SVG_Point)
  2587. j = svg_parse_point(p, &str[i]);
  2588. if (j == 0) {
  2589. /* cf. http://www.w3.org/TR/SVGMobile12/shapes.html#PolygonElement
  2590. If an odd number of coordinates is provided, then the element
  2591. is treated as if the attribute had not been specified.*/
  2592. while (gf_list_count(values)) {
  2593. p = (SVG_Point *)gf_list_get(values, 0);
  2594. gf_free(p);
  2595. gf_list_rem(values, 0);
  2596. }
  2597. return;
  2598. }
  2599. i += j;
  2600. gf_list_add(values, p);
  2601. }
  2602. }
  2603. /* Parses a list of numbers */
  2604. static void svg_parse_numbers(GF_List *values, char *value_string, Bool is_angle)
  2605. {
  2606. u32 read_chars;
  2607. u32 i = 0;
  2608. char *str = value_string;
  2609. u32 len = strlen(str);
  2610. while (i < len) {
  2611. Fixed *f;
  2612. GF_SAFEALLOC(f, Fixed)
  2613. read_chars = svg_parse_number(&(str[i]), f, is_angle);
  2614. if (!read_chars) {
  2615. gf_free(f);
  2616. return;
  2617. }
  2618. i += read_chars;
  2619. gf_list_add(values, f);
  2620. }
  2621. }
  2622. static void svg_string_list_add(GF_List *values, char *string, u32 string_type)
  2623. {
  2624. XMLRI *iri;
  2625. switch (string_type) {
  2626. case 1:
  2627. iri = (XMLRI*)gf_malloc(sizeof(XMLRI));
  2628. iri->type = XMLRI_STRING;
  2629. iri->string = gf_strdup(string);
  2630. gf_list_add(values, iri);
  2631. break;
  2632. default:
  2633. gf_list_add(values, gf_strdup(string));
  2634. break;
  2635. }
  2636. }
  2637. static void svg_parse_strings(GF_List *values, char *value_string, u32 string_type)
  2638. {
  2639. char *next, *sep = value_string;
  2640. while (gf_list_count(values)) {
  2641. next = (char*)gf_list_last(values);
  2642. gf_list_rem_last(values);
  2643. gf_free(next);
  2644. }
  2645. while (1) {
  2646. while (sep && sep[0]==' ') sep++;
  2647. if (!sep) break;
  2648. next = sep+1;
  2649. while (next[0]) {
  2650. if (strchr(" ;,", next[0])) break;
  2651. next++;
  2652. }
  2653. if (!next[0]) {
  2654. svg_string_list_add(values, sep, string_type);
  2655. break;
  2656. }
  2657. next[0]=0;
  2658. svg_string_list_add(values, sep, string_type);
  2659. next[0]=';';
  2660. sep = next+1;
  2661. while (strchr(" ,;", sep[0])) sep++;
  2662. }
  2663. }
  2664. static void svg_parse_strokedasharray(SVG_StrokeDashArray *value, char *value_string)
  2665. {
  2666. u32 read_chars;
  2667. if (!strcmp(value_string, "none")) {
  2668. value->type = SVG_STROKEDASHARRAY_NONE;
  2669. } else if (!strcmp(value_string, "inherit")) {
  2670. value->type = SVG_STROKEDASHARRAY_INHERIT;
  2671. } else {
  2672. UnitArray *vals = &(value->array);
  2673. GF_List *values = gf_list_new();
  2674. u32 i = 0;
  2675. u32 len = strlen(value_string);
  2676. char *str = value_string;
  2677. while (i < len) {
  2678. SVG_Length *f;
  2679. GF_SAFEALLOC(f, SVG_Length)
  2680. read_chars = svg_parse_length(f, &(str[i]), 0);
  2681. if (!read_chars) {
  2682. gf_free(f);
  2683. return;
  2684. }
  2685. i += read_chars;
  2686. gf_list_add(values, f);
  2687. }
  2688. vals->count = gf_list_count(values);
  2689. vals->units = (u8 *) gf_malloc(sizeof(u8)*vals->count);
  2690. vals->vals = (Fixed *) gf_malloc(sizeof(Fixed)*vals->count);
  2691. for (i = 0; i < vals->count; i++) {
  2692. SVG_Length *f = (SVG_Length *)gf_list_get(values, i);
  2693. vals->vals[i] = f->value;
  2694. vals->units[i] = f->type;
  2695. gf_free(f);
  2696. }
  2697. gf_list_del(values);
  2698. value->type = SVG_STROKEDASHARRAY_ARRAY;
  2699. }
  2700. }
  2701. static void svg_parse_zoomandpan(SVG_ZoomAndPan *value, char *value_string)
  2702. {
  2703. if (!strcmp(value_string, "disable")) {
  2704. *value = SVG_ZOOMANDPAN_DISABLE;
  2705. } else if (!strcmp(value_string, "magnify")) {
  2706. *value = SVG_ZOOMANDPAN_MAGNIFY;
  2707. }
  2708. }
  2709. static void svg_parse_preserveaspectratio(SVG_PreserveAspectRatio *par, char *attribute_content)
  2710. {
  2711. char *content = attribute_content;
  2712. while (*content == ' ') content++;
  2713. if (strstr(content, "defer")) {
  2714. par->defer = 1;
  2715. content += 4;
  2716. } else {
  2717. content = attribute_content;
  2718. }
  2719. while (*content == ' ') content++;
  2720. if (strstr(content, "none")) {
  2721. par->align = SVG_PRESERVEASPECTRATIO_NONE;
  2722. content+=4;
  2723. } else if (strstr(content, "xMinYMin")) {
  2724. par->align = SVG_PRESERVEASPECTRATIO_XMINYMIN;
  2725. content+=8;
  2726. } else if (strstr(content, "xMidYMin")) {
  2727. par->align = SVG_PRESERVEASPECTRATIO_XMIDYMIN;
  2728. content+=8;
  2729. } else if (strstr(content, "xMaxYMin")) {
  2730. par->align = SVG_PRESERVEASPECTRATIO_XMAXYMIN;
  2731. content+=8;
  2732. } else if (strstr(content, "xMinYMid")) {
  2733. par->align = SVG_PRESERVEASPECTRATIO_XMINYMID;
  2734. content+=8;
  2735. } else if (strstr(content, "xMidYMid")) {
  2736. par->align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
  2737. content+=8;
  2738. } else if (strstr(content, "xMaxYMid")) {
  2739. par->align = SVG_PRESERVEASPECTRATIO_XMAXYMID;
  2740. content+=8;
  2741. } else if (strstr(content, "xMinYMax")) {
  2742. par->align = SVG_PRESERVEASPECTRATIO_XMINYMAX;
  2743. content+=8;
  2744. } else if (strstr(content, "xMidYMax")) {
  2745. par->align = SVG_PRESERVEASPECTRATIO_XMIDYMAX;
  2746. content+=8;
  2747. } else if (strstr(content, "xMaxYMax")) {
  2748. par->align = SVG_PRESERVEASPECTRATIO_XMAXYMAX;
  2749. content+=8;
  2750. }
  2751. while (*content == ' ') content++;
  2752. if (*content == 0) return;
  2753. if (strstr(content, "meet")) {
  2754. par->meetOrSlice = SVG_MEETORSLICE_MEET;
  2755. } else if (strstr(content, "slice")) {
  2756. par->meetOrSlice = SVG_MEETORSLICE_SLICE;
  2757. }
  2758. }
  2759. static void svg_parse_animatetransform_type(SVG_TransformType *anim_transform_type, char *attribute_content)
  2760. {
  2761. *anim_transform_type = SVG_TRANSFORM_MATRIX;
  2762. if (!strcmp(attribute_content, "scale")) {
  2763. *anim_transform_type = SVG_TRANSFORM_SCALE;
  2764. } else if (!strcmp(attribute_content, "rotate")) {
  2765. *anim_transform_type = SVG_TRANSFORM_ROTATE;
  2766. } else if (!strcmp(attribute_content, "translate")) {
  2767. *anim_transform_type = SVG_TRANSFORM_TRANSLATE;
  2768. } else if (!strcmp(attribute_content, "skewX")) {
  2769. *anim_transform_type = SVG_TRANSFORM_SKEWX;
  2770. } else if (!strcmp(attribute_content, "skewY")) {
  2771. *anim_transform_type = SVG_TRANSFORM_SKEWY;
  2772. }
  2773. }
  2774. static void svg_parse_focushighlight(SVG_FocusHighlight *fh, char *attribute_content)
  2775. {
  2776. if (!strcmp(attribute_content, "auto")) {
  2777. *fh = SVG_FOCUSHIGHLIGHT_AUTO;
  2778. } else if (!strcmp(attribute_content, "none")) {
  2779. *fh = SVG_FOCUSHIGHLIGHT_NONE;
  2780. }
  2781. }
  2782. static void svg_parse_focusable(SVG_Focusable *f, char *attribute_content)
  2783. {
  2784. if (!strcmp(attribute_content, "true")) {
  2785. *f = SVG_FOCUSABLE_TRUE;
  2786. } else if (!strcmp(attribute_content, "false")) {
  2787. *f = SVG_FOCUSABLE_FALSE;
  2788. } else {
  2789. *f = SVG_FOCUSABLE_AUTO;
  2790. }
  2791. }
  2792. static void svg_parse_initialvisibility(SVG_InitialVisibility *iv, char *attribute_content)
  2793. {
  2794. if (!strcmp(attribute_content, "whenStarted")) {
  2795. *iv = SVG_INITIALVISIBILTY_WHENSTARTED;
  2796. } else if (!strcmp(attribute_content, "always")) {
  2797. *iv = SVG_INITIALVISIBILTY_ALWAYS;
  2798. }
  2799. }
  2800. static void svg_parse_overlay(SVG_Overlay *o, char *attribute_content)
  2801. {
  2802. if (!strcmp(attribute_content, "none")) {
  2803. *o = SVG_OVERLAY_NONE;
  2804. } else if (!strcmp(attribute_content, "top")) {
  2805. *o = SVG_OVERLAY_TOP;
  2806. }
  2807. }
  2808. static void svg_parse_transformbehavior(SVG_TransformBehavior *tb, char *attribute_content)
  2809. {
  2810. if (!strcmp(attribute_content, "geometric")) {
  2811. *tb = SVG_TRANSFORMBEHAVIOR_GEOMETRIC;
  2812. } else if (!strcmp(attribute_content, "pinned")) {
  2813. *tb = SVG_TRANSFORMBEHAVIOR_PINNED;
  2814. } else if (!strcmp(attribute_content, "pinned90")) {
  2815. *tb = SVG_TRANSFORMBEHAVIOR_PINNED90;
  2816. } else if (!strcmp(attribute_content, "pinned180")) {
  2817. *tb = SVG_TRANSFORMBEHAVIOR_PINNED180;
  2818. } else if (!strcmp(attribute_content, "pinned270")) {
  2819. *tb = SVG_TRANSFORMBEHAVIOR_PINNED270;
  2820. }
  2821. }
  2822. static void svg_parse_focus(GF_Node *e, SVG_Focus *o, char *attribute_content)
  2823. {
  2824. if (o->target.string) gf_free(o->target.string);
  2825. o->target.string = NULL;
  2826. o->target.target = NULL;
  2827. if (!strcmp(attribute_content, "self")) o->type = SVG_FOCUS_SELF;
  2828. else if (!strcmp(attribute_content, "auto")) o->type = SVG_FOCUS_AUTO;
  2829. else if (!strnicmp(attribute_content, "url(", 4)) {
  2830. char *sep = strrchr(attribute_content, ')');
  2831. if (sep) sep[0] = 0;
  2832. o->type = SVG_FOCUS_IRI;
  2833. svg_parse_iri(e, &o->target, attribute_content+4);
  2834. if (sep) sep[0] = ')';
  2835. }
  2836. }
  2837. /* end of Basic SVG datatype parsing functions */
  2838. void svg_parse_one_anim_value(GF_Node *n, SMIL_AnimateValue *anim_value, char *attribute_content, u8 anim_value_type)
  2839. {
  2840. GF_FieldInfo info;
  2841. info.fieldType = anim_value_type;
  2842. info.far_ptr = gf_svg_create_attribute_value(anim_value_type);
  2843. if (info.far_ptr) gf_svg_parse_attribute(n, &info, attribute_content, 0);
  2844. anim_value->value = info.far_ptr;
  2845. anim_value->type = anim_value_type;
  2846. }
  2847. void svg_parse_anim_values(GF_Node *n, SMIL_AnimateValues *anim_values, char *anim_values_string, u8 anim_value_type)
  2848. {
  2849. u32 i = 0;
  2850. char *str;
  2851. s32 psemi = -1;
  2852. GF_FieldInfo info;
  2853. info.fieldType = anim_value_type;
  2854. anim_values->type = anim_value_type;
  2855. str = anim_values_string;
  2856. while (1) {
  2857. if (str[i] == ';' || str[i] == 0) {
  2858. u32 single_value_len = 0;
  2859. char c;
  2860. single_value_len = i - (psemi+1);
  2861. c = str [ (psemi+1) + single_value_len];
  2862. str [ (psemi+1) + single_value_len] = 0;
  2863. info.far_ptr = gf_svg_create_attribute_value(anim_value_type);
  2864. if (info.far_ptr) {
  2865. gf_svg_parse_attribute(n, &info, str + (psemi+1), anim_value_type);
  2866. gf_list_add(anim_values->values, info.far_ptr);
  2867. }
  2868. str [ (psemi+1) + single_value_len] = c;
  2869. psemi = i;
  2870. if (!str[i]) return;
  2871. }
  2872. i++;
  2873. }
  2874. }
  2875. GF_Err laser_parse_choice(LASeR_Choice *choice, char *attribute_content)
  2876. {
  2877. if (!strcmp(attribute_content, "none")) {
  2878. choice->type = LASeR_CHOICE_NONE;
  2879. } else if (!strcmp(attribute_content, "all")) {
  2880. choice->type = LASeR_CHOICE_ALL;
  2881. } else {
  2882. choice->type = LASeR_CHOICE_N;
  2883. choice->choice_index = atoi(attribute_content);
  2884. }
  2885. return GF_OK;
  2886. }
  2887. GF_Err laser_parse_size(LASeR_Size *size, char *attribute_content)
  2888. {
  2889. char *str = attribute_content;
  2890. u32 i = 0;
  2891. i+=svg_parse_number(&(str[i]), &(size->width), 0);
  2892. i+=svg_parse_number(&(str[i]), &(size->height), 0);
  2893. return GF_OK;
  2894. }
  2895. GF_Err gf_svg_parse_element_id(GF_Node *n, const char *nodename, Bool warning_if_defined)
  2896. {
  2897. GF_SceneGraph *sg = gf_node_get_graph((GF_Node *)n);
  2898. u32 id = gf_sg_get_max_node_id(sg) + 1;
  2899. gf_node_set_id(n, id, nodename);
  2900. return GF_OK;
  2901. }
  2902. /* Parse an SVG attribute */
  2903. GF_EXPORT
  2904. GF_Err gf_svg_parse_attribute(GF_Node *n, GF_FieldInfo *info, char *attribute_content, u8 anim_value_type)
  2905. {
  2906. /* for all attributes, except strings, apply some sort of white space normalization*/
  2907. if (info->fieldType != DOM_String_datatype && strlen(attribute_content)) {
  2908. u32 i, len;
  2909. /*remove spaces at the begining*/
  2910. while (attribute_content[0] && (strchr("\r\n\t ", attribute_content[0])))
  2911. attribute_content++;
  2912. /*change all special chars in spaces*/
  2913. i=0;
  2914. len = strlen(attribute_content);
  2915. while (i<len) {
  2916. if (strchr("\r\n\t", attribute_content[i]))
  2917. attribute_content[i] = ' ';
  2918. i++;
  2919. }
  2920. /*remove spaces in the end*/
  2921. while (len && attribute_content[len-1]==' ') {
  2922. attribute_content[len-1] = 0;
  2923. len--;
  2924. }
  2925. }
  2926. switch (info->fieldType) {
  2927. case SVG_Boolean_datatype:
  2928. svg_parse_boolean((SVG_Boolean *)info->far_ptr, attribute_content);
  2929. break;
  2930. case SVG_Color_datatype:
  2931. svg_parse_color((SVG_Color *)info->far_ptr, attribute_content);
  2932. break;
  2933. case SVG_Paint_datatype:
  2934. svg_parse_paint(n, (SVG_Paint *)info->far_ptr, attribute_content);
  2935. break;
  2936. /* beginning of keyword type parsing */
  2937. case SVG_FillRule_datatype:
  2938. svg_parse_clipfillrule((SVG_FillRule *)info->far_ptr, attribute_content);
  2939. break;
  2940. case SVG_StrokeLineJoin_datatype:
  2941. svg_parse_strokelinejoin((SVG_StrokeLineJoin *)info->far_ptr, attribute_content);
  2942. break;
  2943. case SVG_StrokeLineCap_datatype:
  2944. svg_parse_strokelinecap((SVG_StrokeLineCap *)info->far_ptr, attribute_content);
  2945. break;
  2946. case SVG_FontStyle_datatype:
  2947. svg_parse_fontstyle((SVG_FontStyle *)info->far_ptr, attribute_content);
  2948. break;
  2949. case SVG_FontWeight_datatype:
  2950. svg_parse_fontweight((SVG_FontWeight *)info->far_ptr, attribute_content);
  2951. break;
  2952. case SVG_FontVariant_datatype:
  2953. svg_parse_fontvariant((SVG_FontVariant *)info->far_ptr, attribute_content);
  2954. break;
  2955. case SVG_TextAnchor_datatype:
  2956. svg_parse_textanchor((SVG_TextAnchor *)info->far_ptr, attribute_content);
  2957. break;
  2958. case SVG_Display_datatype:
  2959. svg_parse_display((SVG_Display *)info->far_ptr, attribute_content);
  2960. break;
  2961. case SVG_Visibility_datatype:
  2962. svg_parse_visibility((SVG_Visibility *)info->far_ptr, attribute_content);
  2963. break;
  2964. case SVG_Overflow_datatype:
  2965. svg_parse_overflow((SVG_Overflow *)info->far_ptr, attribute_content);
  2966. break;
  2967. case SVG_ZoomAndPan_datatype:
  2968. svg_parse_zoomandpan((SVG_ZoomAndPan *)info->far_ptr, attribute_content);
  2969. break;
  2970. case SVG_DisplayAlign_datatype:
  2971. svg_parse_displayalign((SVG_DisplayAlign *)info->far_ptr, attribute_content);
  2972. break;
  2973. case SVG_TextAlign_datatype:
  2974. svg_parse_textalign((SVG_TextAlign *)info->far_ptr, attribute_content);
  2975. break;
  2976. case SVG_PointerEvents_datatype:
  2977. svg_parse_pointerevents((SVG_PointerEvents *)info->far_ptr, attribute_content);
  2978. break;
  2979. case SVG_RenderingHint_datatype:
  2980. svg_parse_renderinghint((SVG_RenderingHint *)info->far_ptr, attribute_content);
  2981. break;
  2982. case SVG_VectorEffect_datatype:
  2983. svg_parse_vectoreffect((SVG_VectorEffect *)info->far_ptr, attribute_content);
  2984. break;
  2985. case SVG_PlaybackOrder_datatype:
  2986. svg_parse_playbackorder((SVG_PlaybackOrder *)info->far_ptr, attribute_content);
  2987. break;
  2988. case SVG_TimelineBegin_datatype:
  2989. svg_parse_timelinebegin((SVG_TimelineBegin *)info->far_ptr, attribute_content);
  2990. break;
  2991. case XML_Space_datatype:
  2992. svg_parse_xmlspace((XML_Space *)info->far_ptr, attribute_content);
  2993. break;
  2994. case XMLEV_Propagate_datatype:
  2995. svg_parse_xmlev_propagate((XMLEV_Propagate *)info->far_ptr, attribute_content);
  2996. break;
  2997. case XMLEV_DefaultAction_datatype:
  2998. svg_parse_xmlev_defaultAction((XMLEV_DefaultAction *)info->far_ptr, attribute_content);
  2999. break;
  3000. case XMLEV_Phase_datatype:
  3001. svg_parse_xmlev_phase((XMLEV_Phase *)info->far_ptr, attribute_content);
  3002. break;
  3003. case SMIL_SyncBehavior_datatype:
  3004. smil_parse_syncBehaviorOrDefault((SMIL_SyncBehavior *)info->far_ptr, attribute_content);
  3005. break;
  3006. case SMIL_SyncTolerance_datatype:
  3007. smil_parse_syncToleranceOrDefault((SMIL_SyncTolerance *)info->far_ptr, attribute_content);
  3008. break;
  3009. case SMIL_AttributeType_datatype:
  3010. smil_parse_attributeType((SMIL_AttributeType *)info->far_ptr, attribute_content);
  3011. break;
  3012. case SMIL_CalcMode_datatype:
  3013. smil_parse_calcmode((SMIL_CalcMode *)info->far_ptr, attribute_content);
  3014. break;
  3015. case SMIL_Additive_datatype:
  3016. smil_parse_additive((SMIL_CalcMode *)info->far_ptr, attribute_content);
  3017. break;
  3018. case SMIL_Accumulate_datatype:
  3019. smil_parse_accumulate((SMIL_Accumulate *)info->far_ptr, attribute_content);
  3020. break;
  3021. case SMIL_Restart_datatype:
  3022. smil_parse_restart((SMIL_Restart *)info->far_ptr, attribute_content);
  3023. break;
  3024. case SMIL_Fill_datatype:
  3025. smil_parse_fill((SMIL_Fill *)info->far_ptr, attribute_content);
  3026. break;
  3027. case SVG_GradientUnit_datatype:
  3028. *((SVG_GradientUnit *)info->far_ptr) = !strcmp(attribute_content, "userSpaceOnUse") ? SVG_GRADIENTUNITS_USER : SVG_GRADIENTUNITS_OBJECT;
  3029. break;
  3030. case SVG_FocusHighlight_datatype:
  3031. svg_parse_focushighlight((SVG_FocusHighlight*)info->far_ptr, attribute_content);
  3032. break;
  3033. case SVG_Focusable_datatype:
  3034. svg_parse_focusable((SVG_Focusable*)info->far_ptr, attribute_content);
  3035. break;
  3036. case SVG_InitialVisibility_datatype:
  3037. svg_parse_initialvisibility((SVG_InitialVisibility*)info->far_ptr, attribute_content);
  3038. break;
  3039. case SVG_Overlay_datatype:
  3040. svg_parse_overlay((SVG_Overlay*)info->far_ptr, attribute_content);
  3041. break;
  3042. case SVG_TransformBehavior_datatype:
  3043. svg_parse_transformbehavior((SVG_TransformBehavior*)info->far_ptr, attribute_content);
  3044. break;
  3045. case SVG_SpreadMethod_datatype:
  3046. if (!strcmp(attribute_content, "reflect")) *(u8*)info->far_ptr = SVG_SPREAD_REFLECT;
  3047. else if (!strcmp(attribute_content, "repeat")) *(u8*)info->far_ptr = SVG_SPREAD_REPEAT;
  3048. else *(u8*)info->far_ptr = SVG_SPREAD_PAD;
  3049. break;
  3050. case SVG_Filter_TransferType_datatype:
  3051. if (!strcmp(attribute_content, "table")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_TABLE;
  3052. else if (!strcmp(attribute_content, "discrete")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_DISCRETE;
  3053. else if (!strcmp(attribute_content, "linear")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_LINEAR;
  3054. else if (!strcmp(attribute_content, "gamma")) *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_GAMMA;
  3055. else *(u8*)info->far_ptr = SVG_FILTER_TRANSFER_IDENTITY;
  3056. break;
  3057. /* end of keyword type parsing */
  3058. /* keyword | numbers (with possibly units) */
  3059. case SVG_Length_datatype:
  3060. case SVG_Coordinate_datatype:
  3061. case SVG_FontSize_datatype:
  3062. case SVG_Rotate_datatype:
  3063. case SVG_Number_datatype:
  3064. svg_parse_length((SVG_Number*)info->far_ptr, attribute_content, 0);
  3065. break;
  3066. case SMIL_AnimateValue_datatype:
  3067. svg_parse_one_anim_value(n, (SMIL_AnimateValue*)info->far_ptr, attribute_content, anim_value_type);
  3068. break;
  3069. case SMIL_AnimateValues_datatype:
  3070. svg_parse_anim_values(n, (SMIL_AnimateValues*)info->far_ptr, attribute_content, anim_value_type);
  3071. break;
  3072. case XMLRI_datatype:
  3073. svg_parse_iri(n, (XMLRI*)info->far_ptr, attribute_content);
  3074. break;
  3075. case XML_IDREF_datatype:
  3076. svg_parse_idref(n, (XMLRI*)info->far_ptr, attribute_content);
  3077. break;
  3078. case SMIL_AttributeName_datatype:
  3079. ((SMIL_AttributeName *)info->far_ptr)->name = gf_strdup(attribute_content);
  3080. break;
  3081. case SMIL_Times_datatype:
  3082. smil_parse_time_list(n, *(GF_List **)info->far_ptr, attribute_content);
  3083. break;
  3084. case SMIL_Duration_datatype:
  3085. smil_parse_min_max_dur_repeatdur((SMIL_Duration*)info->far_ptr, attribute_content);
  3086. break;
  3087. case SMIL_RepeatCount_datatype:
  3088. smil_parse_repeatcount((SMIL_RepeatCount*)info->far_ptr, attribute_content);
  3089. break;
  3090. case SVG_PathData_datatype:
  3091. svg_parse_path((SVG_PathData*)info->far_ptr, attribute_content);
  3092. break;
  3093. case SVG_Points_datatype:
  3094. svg_parse_points(*(GF_List **)(info->far_ptr), attribute_content);
  3095. break;
  3096. case SMIL_KeyTimes_datatype:
  3097. case SMIL_KeyPoints_datatype:
  3098. case SMIL_KeySplines_datatype:
  3099. case SVG_Numbers_datatype:
  3100. svg_parse_numbers(*(GF_List **)(info->far_ptr), attribute_content, 0);
  3101. break;
  3102. case SVG_Coordinates_datatype:
  3103. svg_parse_coordinates(*(GF_List **)(info->far_ptr), attribute_content);
  3104. break;
  3105. case SVG_ViewBox_datatype:
  3106. svg_parse_viewbox((SVG_ViewBox*)info->far_ptr, attribute_content);
  3107. break;
  3108. case SVG_StrokeDashArray_datatype:
  3109. svg_parse_strokedasharray((SVG_StrokeDashArray*)info->far_ptr, attribute_content);
  3110. break;
  3111. case SVG_FontFamily_datatype:
  3112. svg_parse_fontfamily((SVG_FontFamily*)info->far_ptr, attribute_content);
  3113. break;
  3114. case SVG_Motion_datatype:
  3115. svg_parse_point_into_matrix((GF_Matrix2D*)info->far_ptr, attribute_content);
  3116. break;
  3117. case SVG_Transform_datatype:
  3118. svg_parse_transform((SVG_Transform*)info->far_ptr, attribute_content);
  3119. break;
  3120. case SVG_Transform_Translate_datatype:
  3121. {
  3122. u32 i = 0;
  3123. SVG_Point *p = (SVG_Point *)info->far_ptr;;
  3124. i+=svg_parse_number(&(attribute_content[i]), &(p->x), 0);
  3125. if (attribute_content[i] == 0) {
  3126. p->y = 0;
  3127. } else {
  3128. i+=svg_parse_number(&(attribute_content[i]), &(p->y), 0);
  3129. }
  3130. }
  3131. break;
  3132. case SVG_Transform_Scale_datatype:
  3133. {
  3134. u32 i = 0;
  3135. SVG_Point *p = (SVG_Point *)info->far_ptr;;
  3136. i+=svg_parse_number(&(attribute_content[i]), &(p->x), 0);
  3137. if (attribute_content[i] == 0) {
  3138. p->y = p->x;
  3139. } else {
  3140. i+=svg_parse_number(&(attribute_content[i]), &(p->y), 0);
  3141. }
  3142. }
  3143. break;
  3144. case SVG_Transform_SkewX_datatype:
  3145. case SVG_Transform_SkewY_datatype:
  3146. {
  3147. Fixed *p = (Fixed *)info->far_ptr;
  3148. svg_parse_number(attribute_content, p, 1);
  3149. }
  3150. break;
  3151. case SVG_Transform_Rotate_datatype:
  3152. {
  3153. u32 i = 0;
  3154. SVG_Point_Angle *p = (SVG_Point_Angle *)info->far_ptr;;
  3155. i+=svg_parse_number(&(attribute_content[i]), &(p->angle), 1);
  3156. if (attribute_content[i] == 0) {
  3157. p->y = p->x = 0;
  3158. } else {
  3159. i+=svg_parse_number(&(attribute_content[i]), &(p->x), 0);
  3160. i+=svg_parse_number(&(attribute_content[i]), &(p->y), 0);
  3161. }
  3162. }
  3163. break;
  3164. case SVG_PreserveAspectRatio_datatype:
  3165. svg_parse_preserveaspectratio((SVG_PreserveAspectRatio*)info->far_ptr, attribute_content);
  3166. break;
  3167. case SVG_TransformType_datatype:
  3168. svg_parse_animatetransform_type((SVG_TransformType*)info->far_ptr, attribute_content);
  3169. break;
  3170. case SVG_ID_datatype:
  3171. case DOM_String_datatype:
  3172. case SVG_ContentType_datatype:
  3173. case SVG_LanguageID_datatype:
  3174. if (*(SVG_String *)info->far_ptr) gf_free(*(SVG_String *)info->far_ptr);
  3175. *(SVG_String *)info->far_ptr = gf_strdup(attribute_content);
  3176. break;
  3177. case DOM_StringList_datatype:
  3178. svg_parse_strings(*(GF_List **)info->far_ptr, attribute_content, 0);
  3179. break;
  3180. case XMLRI_List_datatype:
  3181. svg_parse_strings(*(GF_List **)info->far_ptr, attribute_content, 1);
  3182. break;
  3183. case XMLEV_Event_datatype:
  3184. {
  3185. XMLEV_Event *xml_ev = (XMLEV_Event *)info->far_ptr;
  3186. char *sep = strchr(attribute_content, '(');
  3187. if (sep) {
  3188. sep[0] = 0;
  3189. xml_ev->type = gf_dom_event_type_by_name(attribute_content);
  3190. sep[0] = '(';
  3191. if ((xml_ev->type == GF_EVENT_REPEAT) || (xml_ev->type == GF_EVENT_REPEAT_EVENT)) {
  3192. char _v;
  3193. sscanf(sep, "(%c)", &_v);
  3194. xml_ev->parameter = _v;
  3195. } else { /* key events ... */
  3196. char *sep2 = strchr(attribute_content, ')');
  3197. sep2[0] = 0;
  3198. xml_ev->parameter = gf_dom_get_key_type(sep+1);
  3199. sep2[0] = ')';
  3200. }
  3201. } else {
  3202. xml_ev->parameter = 0;
  3203. xml_ev->type = gf_dom_event_type_by_name(attribute_content);
  3204. }
  3205. }
  3206. break;
  3207. case SVG_Focus_datatype:
  3208. svg_parse_focus(n, (SVG_Focus*)info->far_ptr, attribute_content);
  3209. break;
  3210. case LASeR_Choice_datatype:
  3211. laser_parse_choice((LASeR_Choice*)info->far_ptr, attribute_content);
  3212. break;
  3213. case LASeR_Size_datatype:
  3214. laser_parse_size((LASeR_Size*)info->far_ptr, attribute_content);
  3215. break;
  3216. case SVG_Clock_datatype:
  3217. svg_parse_clock_value(attribute_content, (SVG_Clock*)info->far_ptr);
  3218. break;
  3219. case SVG_Unknown_datatype:
  3220. if (*(SVG_String *)info->far_ptr) gf_free(*(SVG_String *)info->far_ptr);
  3221. *(SVG_String *)info->far_ptr = gf_strdup(attribute_content);
  3222. break;
  3223. default:
  3224. 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)));
  3225. break;
  3226. }
  3227. return GF_OK;
  3228. }
  3229. void svg_parse_one_style(GF_Node *n, char *one_style)
  3230. {
  3231. GF_FieldInfo info;
  3232. char *c, sep;
  3233. u32 attributeNameLen;
  3234. while (*one_style == ' ') one_style++;
  3235. c = strchr(one_style, ':');
  3236. if (!c) return;
  3237. attributeNameLen = (c - one_style);
  3238. sep = one_style[attributeNameLen];
  3239. one_style[attributeNameLen] = 0;
  3240. while (strchr("\r\n\t ", one_style[0]))
  3241. one_style++;
  3242. if (!gf_node_get_field_by_name(n, one_style, &info)) {
  3243. c++;
  3244. gf_svg_parse_attribute(n, &info, c, 0);
  3245. } else {
  3246. 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)));
  3247. }
  3248. one_style[attributeNameLen] = sep;
  3249. }
  3250. void gf_svg_parse_style(GF_Node *n, char *style)
  3251. {
  3252. u32 i = 0;
  3253. char *str = style;
  3254. s32 psemi = -1;
  3255. while (1) {
  3256. if (str[i] == ';' || str[i] == 0) {
  3257. u32 single_value_len = 0;
  3258. single_value_len = i - (psemi+1);
  3259. if (single_value_len) {
  3260. char c = str[psemi+1 + single_value_len];
  3261. str[psemi+1 + single_value_len] = 0;
  3262. svg_parse_one_style(n, str + psemi+1);
  3263. str[psemi+1 + single_value_len] = c;
  3264. psemi = i;
  3265. }
  3266. if (!str[i]) return;
  3267. }
  3268. i++;
  3269. }
  3270. }
  3271. GF_EXPORT
  3272. void *gf_svg_create_attribute_value(u32 attribute_type)
  3273. {
  3274. switch (attribute_type) {
  3275. case SVG_Boolean_datatype:
  3276. {
  3277. SVG_Boolean *b;
  3278. GF_SAFEALLOC(b, SVG_Boolean)
  3279. return b;
  3280. }
  3281. break;
  3282. case SVG_Color_datatype:
  3283. {
  3284. SVG_Color *color;
  3285. GF_SAFEALLOC(color, SVG_Color)
  3286. return color;
  3287. }
  3288. break;
  3289. case SVG_Paint_datatype:
  3290. {
  3291. SVG_Paint *paint;
  3292. GF_SAFEALLOC(paint, SVG_Paint)
  3293. return paint;
  3294. }
  3295. break;
  3296. /* keyword types */
  3297. case SVG_FillRule_datatype:
  3298. case SVG_StrokeLineJoin_datatype:
  3299. case SVG_StrokeLineCap_datatype:
  3300. case SVG_FontStyle_datatype:
  3301. case SVG_FontWeight_datatype:
  3302. case SVG_FontVariant_datatype:
  3303. case SVG_TextAnchor_datatype:
  3304. case SVG_Display_datatype:
  3305. case SVG_Visibility_datatype:
  3306. case SVG_Overflow_datatype:
  3307. case SVG_ZoomAndPan_datatype:
  3308. case SVG_DisplayAlign_datatype:
  3309. case SVG_TextAlign_datatype:
  3310. case SVG_PointerEvents_datatype:
  3311. case SVG_RenderingHint_datatype:
  3312. case SVG_VectorEffect_datatype:
  3313. case SVG_PlaybackOrder_datatype:
  3314. case SVG_TimelineBegin_datatype:
  3315. case XML_Space_datatype:
  3316. case XMLEV_Propagate_datatype:
  3317. case XMLEV_DefaultAction_datatype:
  3318. case XMLEV_Phase_datatype:
  3319. case SMIL_SyncBehavior_datatype:
  3320. case SMIL_AttributeType_datatype:
  3321. case SMIL_CalcMode_datatype:
  3322. case SMIL_Additive_datatype:
  3323. case SMIL_Accumulate_datatype:
  3324. case SMIL_Restart_datatype:
  3325. case SMIL_Fill_datatype:
  3326. case SVG_TransformType_datatype:
  3327. case SVG_FocusHighlight_datatype:
  3328. case SVG_InitialVisibility_datatype:
  3329. case SVG_GradientUnit_datatype:
  3330. case SVG_Overlay_datatype:
  3331. case SVG_TransformBehavior_datatype:
  3332. case SVG_SpreadMethod_datatype:
  3333. case SVG_Focusable_datatype:
  3334. case SVG_Filter_TransferType_datatype:
  3335. {
  3336. u8 *keyword;
  3337. GF_SAFEALLOC(keyword, u8)
  3338. return keyword;
  3339. }
  3340. break;
  3341. case SMIL_SyncTolerance_datatype:
  3342. {
  3343. SMIL_SyncTolerance *st;
  3344. GF_SAFEALLOC(st, SMIL_SyncTolerance)
  3345. return st;
  3346. }
  3347. break;
  3348. /* inheritable floats */
  3349. case SVG_FontSize_datatype:
  3350. case SVG_Length_datatype:
  3351. case SVG_Coordinate_datatype:
  3352. case SVG_Rotate_datatype:
  3353. case SVG_Number_datatype:
  3354. {
  3355. SVG_Number *number;
  3356. GF_SAFEALLOC(number, SVG_Number)
  3357. return number;
  3358. }
  3359. break;
  3360. case SVG_StrokeDashArray_datatype:
  3361. {
  3362. SVG_StrokeDashArray *array;
  3363. GF_SAFEALLOC(array, SVG_StrokeDashArray)
  3364. return array;
  3365. }
  3366. break;
  3367. case SVG_Motion_datatype:
  3368. {
  3369. GF_Matrix2D *p;
  3370. GF_SAFEALLOC(p, GF_Matrix2D)
  3371. gf_mx2d_init(*p);
  3372. return p;
  3373. }
  3374. break;
  3375. case SVG_Transform_datatype:
  3376. {
  3377. SVG_Transform *p;
  3378. GF_SAFEALLOC(p, SVG_Transform)
  3379. gf_mx2d_init(p->mat);
  3380. return p;
  3381. }
  3382. break;
  3383. case SVG_Transform_Translate_datatype:
  3384. case SVG_Transform_Scale_datatype:
  3385. {
  3386. SVG_Point *p;
  3387. GF_SAFEALLOC(p, SVG_Point)
  3388. return p;
  3389. }
  3390. break;
  3391. case SVG_Transform_SkewX_datatype:
  3392. case SVG_Transform_SkewY_datatype:
  3393. {
  3394. Fixed *p;
  3395. GF_SAFEALLOC(p, Fixed)
  3396. return p;
  3397. }
  3398. break;
  3399. case SVG_Transform_Rotate_datatype:
  3400. {
  3401. SVG_Point_Angle *p;
  3402. GF_SAFEALLOC(p, SVG_Point_Angle)
  3403. return p;
  3404. }
  3405. break;
  3406. case SVG_ViewBox_datatype:
  3407. {
  3408. SVG_ViewBox *viewbox;
  3409. GF_SAFEALLOC(viewbox, SVG_ViewBox)
  3410. return viewbox;
  3411. }
  3412. break;
  3413. case XMLRI_datatype:
  3414. case XML_IDREF_datatype:
  3415. {
  3416. XMLRI *iri;
  3417. GF_SAFEALLOC(iri, XMLRI)
  3418. return iri;
  3419. }
  3420. break;
  3421. case SVG_FontFamily_datatype:
  3422. {
  3423. SVG_FontFamily *fontfamily;
  3424. GF_SAFEALLOC(fontfamily, SVG_FontFamily)
  3425. return fontfamily;
  3426. }
  3427. break;
  3428. case DOM_String_datatype:
  3429. case SVG_ContentType_datatype:
  3430. case SVG_LanguageID_datatype:
  3431. case SVG_ID_datatype:
  3432. {
  3433. SVG_String *string;
  3434. GF_SAFEALLOC(string, SVG_String)
  3435. return string;
  3436. }
  3437. break;
  3438. case DOM_StringList_datatype:
  3439. case XMLRI_List_datatype:
  3440. case SVG_Points_datatype:
  3441. case SVG_Coordinates_datatype:
  3442. case SMIL_Times_datatype:
  3443. case SMIL_KeySplines_datatype:
  3444. case SMIL_KeyTimes_datatype:
  3445. case SMIL_KeyPoints_datatype:
  3446. case SVG_Numbers_datatype:
  3447. {
  3448. ListOfXXX *list;
  3449. GF_SAFEALLOC(list, ListOfXXX)
  3450. *list = gf_list_new();
  3451. return list;
  3452. }
  3453. break;
  3454. case SVG_PreserveAspectRatio_datatype:
  3455. {
  3456. SVG_PreserveAspectRatio *par;
  3457. GF_SAFEALLOC(par, SVG_PreserveAspectRatio)
  3458. return par;
  3459. }
  3460. break;
  3461. case SVG_PathData_datatype:
  3462. {
  3463. SVG_PathData *path;
  3464. GF_SAFEALLOC(path, SVG_PathData);
  3465. #if USE_GF_PATH
  3466. gf_path_reset(path);
  3467. path->fineness = FIX_ONE;
  3468. #else
  3469. path->commands = gf_list_new();
  3470. path->points = gf_list_new();
  3471. #endif
  3472. return path;
  3473. }
  3474. break;
  3475. case LASeR_Choice_datatype:
  3476. {
  3477. LASeR_Choice *ch;
  3478. GF_SAFEALLOC(ch, LASeR_Choice)
  3479. return ch;
  3480. }
  3481. case SVG_Focus_datatype:
  3482. {
  3483. SVG_Focus *foc;
  3484. GF_SAFEALLOC(foc, SVG_Focus)
  3485. return foc;
  3486. }
  3487. case SMIL_AttributeName_datatype:
  3488. {
  3489. SMIL_AttributeName *an;
  3490. GF_SAFEALLOC(an, SMIL_AttributeName)
  3491. return an;
  3492. }
  3493. case SMIL_RepeatCount_datatype:
  3494. {
  3495. SMIL_RepeatCount *rc;
  3496. GF_SAFEALLOC(rc, SMIL_RepeatCount)
  3497. return rc;
  3498. }
  3499. case SMIL_Duration_datatype:
  3500. {
  3501. SMIL_Duration *sd;
  3502. GF_SAFEALLOC(sd, SMIL_Duration)
  3503. return sd;
  3504. }
  3505. case SMIL_AnimateValue_datatype:
  3506. {
  3507. SMIL_AnimateValue *av;
  3508. GF_SAFEALLOC(av, SMIL_AnimateValue)
  3509. return av;
  3510. }
  3511. break;
  3512. case SMIL_AnimateValues_datatype:
  3513. {
  3514. SMIL_AnimateValues *av;
  3515. GF_SAFEALLOC(av, SMIL_AnimateValues)
  3516. av->values = gf_list_new();
  3517. return av;
  3518. }
  3519. break;
  3520. case SVG_Clock_datatype:
  3521. {
  3522. SVG_Clock *ck;
  3523. GF_SAFEALLOC(ck, SVG_Clock)
  3524. return ck;
  3525. }
  3526. break;
  3527. case XMLEV_Event_datatype:
  3528. {
  3529. XMLEV_Event *e;
  3530. GF_SAFEALLOC(e, XMLEV_Event);
  3531. return e;
  3532. }
  3533. break;
  3534. case LASeR_Size_datatype:
  3535. {
  3536. LASeR_Size *s;
  3537. GF_SAFEALLOC(s, LASeR_Size);
  3538. return s;
  3539. }
  3540. break;
  3541. case 0:
  3542. {
  3543. SVG_String *string;
  3544. GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Attributes] Unspecified attribute type - defaulting to string.\n"));
  3545. GF_SAFEALLOC(string, SVG_String);
  3546. return string;
  3547. }
  3548. default:
  3549. 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)));
  3550. break;
  3551. }
  3552. return NULL;
  3553. }
  3554. static char *svg_dump_color(SVG_Color *col)
  3555. {
  3556. char *res;
  3557. if (col->type == SVG_COLOR_CURRENTCOLOR) return gf_strdup("currentColor");
  3558. else if (col->type == SVG_COLOR_INHERIT) return gf_strdup("inherit");
  3559. else if (col->type !=SVG_COLOR_RGBCOLOR) {
  3560. u32 i, count;
  3561. count = sizeof(system_colors) / sizeof(struct sys_col);
  3562. for (i=0; i<count; i++) {
  3563. if (col->type == system_colors[i].type) {
  3564. return gf_strdup(system_colors[i].name);
  3565. }
  3566. }
  3567. } else {
  3568. u32 i, count = sizeof(predefined_colors) / sizeof(struct predef_col);
  3569. u32 r, g, b;
  3570. r = FIX2INT(255*col->red);
  3571. g = FIX2INT(255*col->green);
  3572. b = FIX2INT(255*col->blue);
  3573. for (i=0; i<count; i++) {
  3574. if (
  3575. (r == predefined_colors[i].r)
  3576. && (g == predefined_colors[i].g)
  3577. && (b == predefined_colors[i].b)
  3578. ) {
  3579. return gf_strdup(predefined_colors[i].name);
  3580. }
  3581. }
  3582. res = gf_malloc(sizeof(char)*8);
  3583. sprintf(res, "#%02X%02X%02X", r, g, b);
  3584. /*compress it...*/
  3585. if ( (res[1]==res[2]) && (res[3]==res[4]) && (res[5]==res[6]) )
  3586. sprintf(res, "#%c%c%c", res[1], res[3], res[5]);
  3587. return res;
  3588. }
  3589. return NULL;
  3590. }
  3591. static char *svg_dump_number(SVG_Number *l)
  3592. {
  3593. char tmp[100];
  3594. if (l->type==SVG_NUMBER_INHERIT) return gf_strdup("inherit");
  3595. else if (l->type == SVG_NUMBER_AUTO) return gf_strdup("auto");
  3596. else if (l->type == SVG_NUMBER_AUTO_REVERSE) return gf_strdup("auto-reverse");
  3597. else {
  3598. sprintf(tmp, "%g", FIX2FLT(l->value) );
  3599. if (l->type == SVG_NUMBER_PERCENTAGE) strcat(tmp, "%");
  3600. else if (l->type == SVG_NUMBER_EMS) strcat(tmp, "em");
  3601. else if (l->type == SVG_NUMBER_EXS) strcat(tmp, "ex");
  3602. else if (l->type == SVG_NUMBER_PX) strcat(tmp, "px");
  3603. else if (l->type == SVG_NUMBER_CM) strcat(tmp, "cm");
  3604. else if (l->type == SVG_NUMBER_MM) strcat(tmp, "mm");
  3605. else if (l->type == SVG_NUMBER_IN) strcat(tmp, "in");
  3606. else if (l->type == SVG_NUMBER_PT) strcat(tmp, "pt");
  3607. else if (l->type == SVG_NUMBER_PC) strcat(tmp, "pc");
  3608. return gf_strdup(tmp);
  3609. }
  3610. }
  3611. static char *svg_dump_iri(XMLRI*iri)
  3612. {
  3613. if (iri->type == XMLRI_ELEMENTID) {
  3614. const char *name;
  3615. char *res;
  3616. name = gf_node_get_name((GF_Node *)iri->target);
  3617. if (name) {
  3618. res = gf_malloc(sizeof(char)*(strlen(name)+2));
  3619. sprintf(res, "#%s", name);
  3620. } else if (iri->target) {
  3621. res = gf_malloc(sizeof(char)*32);
  3622. sprintf(res, "#N%d", gf_node_get_id((GF_Node *)iri->target) - 1);
  3623. } else {
  3624. res = gf_strdup("");
  3625. }
  3626. return res;
  3627. }
  3628. else if ((iri->type == XMLRI_STRING) && iri->string)
  3629. return gf_strdup(iri->string);
  3630. else
  3631. return gf_strdup("");
  3632. }
  3633. static char *svg_dump_idref(XMLRI*iri)
  3634. {
  3635. const char *name;
  3636. if (iri->target) {
  3637. name = gf_node_get_name((GF_Node *)iri->target);
  3638. if (name) return gf_strdup(name);
  3639. else {
  3640. char tmp[50];
  3641. sprintf(tmp, "N%d", gf_node_get_id((GF_Node *)iri->target) - 1);
  3642. return gf_strdup(tmp);
  3643. }
  3644. }
  3645. if (iri->string) return gf_strdup(iri->string);
  3646. return gf_strdup("");
  3647. }
  3648. #if USE_GF_PATH
  3649. static char *svg_dump_path(SVG_PathData *path)
  3650. {
  3651. char szT[1000];
  3652. GF_Point2D *pt, last_pt, *ct1, *ct2, *end;
  3653. u32 i, *contour;
  3654. char *res = gf_malloc(sizeof(char));
  3655. res[0] = 0;
  3656. contour = path->contours;
  3657. last_pt.x = last_pt.y = 0;
  3658. for (i=0; i<path->n_points; ) {
  3659. szT[0] = 0;
  3660. switch (path->tags[i]) {
  3661. case GF_PATH_CURVE_ON:
  3662. case GF_PATH_CLOSE:
  3663. pt = &path->points[i];
  3664. if (!i || (*contour == i-1) ) {
  3665. sprintf(szT, "M%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y));
  3666. if (i) contour++;
  3667. } else if (path->tags[i]==GF_PATH_CLOSE) {
  3668. sprintf(szT, "z");
  3669. } else {
  3670. if (i && (last_pt.x==pt->x)) sprintf(szT, "V%g", FIX2FLT(pt->y));
  3671. else if (i && (last_pt.y==pt->y)) sprintf(szT, "H%g", FIX2FLT(pt->x));
  3672. else sprintf(szT, "L%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y));
  3673. }
  3674. last_pt = *pt;
  3675. i++;
  3676. break;
  3677. case GF_PATH_CURVE_CONIC:
  3678. ct1 = &path->points[i];
  3679. end = &path->points[i+1];
  3680. sprintf(szT, "Q%g %g %g %g", FIX2FLT(ct1->x), FIX2FLT(ct1->y), FIX2FLT(end->x), FIX2FLT(end->y));
  3681. last_pt = *end;
  3682. if (path->tags[i+2]==GF_PATH_CLOSE) {
  3683. strcat(szT, "z");
  3684. }
  3685. i+=2;
  3686. break;
  3687. case GF_PATH_CURVE_CUBIC:
  3688. ct1 = &path->points[i];
  3689. ct2 = &path->points[i+1];
  3690. end = &path->points[i+2];
  3691. 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));
  3692. last_pt = *end;
  3693. if (path->tags[i+2]==GF_PATH_CLOSE) {
  3694. strcat(szT, "z");
  3695. }
  3696. i+=3;
  3697. break;
  3698. }
  3699. if (szT[0]) {
  3700. res = gf_realloc(res, sizeof(char)*(strlen(szT)+strlen(res)+1));
  3701. strcat(res, szT);
  3702. }
  3703. }
  3704. return res;
  3705. }
  3706. #else
  3707. static void svg_dump_point(SVG_Point *pt, char *attValue)
  3708. {
  3709. if (pt) sprintf(attValue, "%g %g ", FIX2FLT(pt->x), FIX2FLT(pt->y) );
  3710. }
  3711. static void svg_dump_path(SVG_PathData *path, char *attValue)
  3712. {
  3713. char szT[1000];
  3714. u32 i, pt_i, count;
  3715. count = gf_list_count(path->commands);
  3716. pt_i = 0;
  3717. strcpy(attValue, "");
  3718. for (i = 0; i < count; i++) {
  3719. u8 command = *(u8 *)gf_list_get(path->commands, i);
  3720. switch(command) {
  3721. case SVG_PATHCOMMAND_M:
  3722. strcat(attValue, "M");
  3723. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3724. strcat(attValue, szT);
  3725. pt_i++;
  3726. break;
  3727. case SVG_PATHCOMMAND_L:
  3728. strcat(attValue, "L");
  3729. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3730. strcat(attValue, szT);
  3731. pt_i++;
  3732. break;
  3733. case SVG_PATHCOMMAND_C:
  3734. strcat(attValue, "C");
  3735. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3736. strcat(attValue, szT);
  3737. pt_i++;
  3738. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3739. strcat(attValue, szT);
  3740. pt_i++;
  3741. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3742. strcat(attValue, szT);
  3743. pt_i++;
  3744. break;
  3745. case SVG_PATHCOMMAND_S:
  3746. strcat(attValue, "S");
  3747. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3748. strcat(attValue, szT);
  3749. pt_i++;
  3750. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3751. strcat(attValue, szT);
  3752. pt_i++;
  3753. break;
  3754. case SVG_PATHCOMMAND_Q:
  3755. strcat(attValue, "Q");
  3756. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3757. strcat(attValue, szT);
  3758. pt_i++;
  3759. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3760. strcat(attValue, szT);
  3761. pt_i++;
  3762. break;
  3763. case SVG_PATHCOMMAND_T:
  3764. strcat(attValue, "T");
  3765. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3766. strcat(attValue, szT);
  3767. pt_i++;
  3768. break;
  3769. case SVG_PATHCOMMAND_A:
  3770. strcat(attValue, "A");
  3771. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3772. strcat(attValue, szT);
  3773. pt_i++;
  3774. strcat(attValue, "0 0 0 ");
  3775. svg_dump_point((SVG_Point*)gf_list_get(path->points, pt_i), szT);
  3776. strcat(attValue, szT);
  3777. pt_i++;
  3778. break;
  3779. case SVG_PATHCOMMAND_Z:
  3780. strcat(attValue, "Z");
  3781. break;
  3782. default:
  3783. GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] unknown path command %d\n", command));
  3784. break;
  3785. }
  3786. }
  3787. }
  3788. #endif
  3789. static void svg_dump_access_key(XMLEV_Event *evt, char *attValue)
  3790. {
  3791. u32 i, count;
  3792. strcpy(attValue, "accessKey(");
  3793. count = sizeof(predefined_key_identifiers) / sizeof(struct predef_keyid);
  3794. for (i=0; i<count; i++) {
  3795. if (evt->parameter == predefined_key_identifiers[i].key_code) {
  3796. strcat(attValue, predefined_key_identifiers[i].name);
  3797. break;
  3798. }
  3799. }
  3800. /* OLD LASeR CODE
  3801. switch (evt->parameter) {
  3802. case 0: strcat(attValue, "UP"); break;
  3803. case 1: strcat(attValue, "DOWN"); break;
  3804. case 2: strcat(attValue, "LEFT"); break;
  3805. case 3: strcat(attValue, "RIGHT"); break;
  3806. case 4: strcat(attValue, "FIRE"); break;
  3807. case 5: strcat(attValue, "NO_KEY"); break;
  3808. case 6: strcat(attValue, "ANY_KEY"); break;
  3809. case 7: strcat(attValue, "SOFT_KEY_1"); break;
  3810. case 8: strcat(attValue, "SOFT_KEY_2"); break;
  3811. case 35: strcat(attValue, "#"); break;
  3812. case 42: strcat(attValue, "*"); break;
  3813. case 48: strcat(attValue, "0"); break;
  3814. case 49: strcat(attValue, "1"); break;
  3815. case 50: strcat(attValue, "2"); break;
  3816. case 51: strcat(attValue, "3"); break;
  3817. case 52: strcat(attValue, "4"); break;
  3818. case 53: strcat(attValue, "5"); break;
  3819. case 54: strcat(attValue, "6"); break;
  3820. case 55: strcat(attValue, "7"); break;
  3821. case 56: strcat(attValue, "8"); break;
  3822. case 57: strcat(attValue, "9"); break;
  3823. */
  3824. strcat(attValue, ")");
  3825. }
  3826. static char *gf_svg_dump_matrix(GF_Matrix2D *matrix)
  3827. {
  3828. char attValue[1024];
  3829. attValue[0]=0;
  3830. /*try to do a simple decomposition...*/
  3831. if (!matrix->m[1] && !matrix->m[3]) {
  3832. if (matrix->m[2] != 0 || matrix->m[5] != 0) sprintf(attValue, "translate(%g,%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]) );
  3833. if ((matrix->m[0]!=FIX_ONE) || (matrix->m[4]!=FIX_ONE)) {
  3834. char szT[1024];
  3835. if ((matrix->m[0]==-FIX_ONE) && (matrix->m[4]==-FIX_ONE)) {
  3836. strcpy(szT, " rotate(180)");
  3837. } else {
  3838. sprintf(szT, " scale(%g,%g)", FIX2FLT(matrix->m[0]), FIX2FLT(matrix->m[4]) );
  3839. }
  3840. strcat(attValue, szT);
  3841. }
  3842. } else if (matrix->m[1] == - matrix->m[3]) {
  3843. Fixed angle = gf_asin(matrix->m[3]);
  3844. Fixed cos_a = gf_cos(angle);
  3845. if (ABS(cos_a)>FIX_EPSILON) {
  3846. Fixed sx, sy;
  3847. sx = gf_divfix(matrix->m[0], cos_a);
  3848. sy = gf_divfix(matrix->m[4], cos_a);
  3849. angle = gf_divfix(180*angle, GF_PI);
  3850. if ((sx==sy) && ( ABS(FIX_ONE - ABS(sx) ) < FIX_ONE/100)) {
  3851. if (matrix->m[2] != 0 || matrix->m[5] != 0)
  3852. sprintf(attValue, "translate(%g,%g) rotate(%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]), FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
  3853. else
  3854. sprintf(attValue, "rotate(%g)", FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
  3855. } else {
  3856. if (matrix->m[2] != 0 || matrix->m[5] != 0)
  3857. 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) ) );
  3858. else
  3859. sprintf(attValue, "scale(%g,%g) rotate(%g)", FIX2FLT(sx), FIX2FLT(sy), FIX2FLT(gf_divfix(angle*180, GF_PI) ) );
  3860. }
  3861. } else {
  3862. Fixed a = angle;
  3863. if (a<0) a += GF_2PI;
  3864. if (matrix->m[2] != 0 || matrix->m[5] != 0)
  3865. sprintf(attValue, "translate(%g,%g) rotate(%g)", FIX2FLT(matrix->m[2]), FIX2FLT(matrix->m[5]), FIX2FLT(gf_divfix(a*180, GF_PI) ) );
  3866. else
  3867. sprintf(attValue, "rotate(%g)", FIX2FLT(gf_divfix(a*180, GF_PI) ) );
  3868. }
  3869. }
  3870. /*default*/
  3871. if (!strlen(attValue))
  3872. 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]) );
  3873. return gf_strdup(attValue);
  3874. }
  3875. char *gf_svg_dump_attribute(GF_Node *elt, GF_FieldInfo *info)
  3876. {
  3877. char tmp[1024];
  3878. u8 intVal;
  3879. if (!info->far_ptr) return gf_strdup("");
  3880. intVal = *(u8 *)info->far_ptr;
  3881. switch (info->fieldType) {
  3882. case SVG_Boolean_datatype:
  3883. return gf_strdup( *(SVG_Boolean *)info->far_ptr ? "true" : "false");
  3884. case SVG_Color_datatype:
  3885. return svg_dump_color((SVG_Color *)info->far_ptr);
  3886. case SVG_Paint_datatype:
  3887. {
  3888. SVG_Paint *paint = (SVG_Paint *)info->far_ptr;
  3889. if (paint->type == SVG_PAINT_NONE) return gf_strdup("none");
  3890. else if (paint->type == SVG_PAINT_INHERIT) return gf_strdup("inherit");
  3891. else if (paint->type == SVG_PAINT_URI) {
  3892. char *tmp = svg_dump_iri(&paint->iri);
  3893. char *res = gf_malloc(sizeof(char)*(strlen(tmp)+6));
  3894. sprintf(res, "url(%s)", tmp);
  3895. gf_free(tmp);
  3896. return res;
  3897. } else {
  3898. return svg_dump_color(&paint->color);
  3899. }
  3900. }
  3901. break;
  3902. /* beginning of keyword type parsing */
  3903. case SVG_FillRule_datatype:
  3904. if (intVal == SVG_FILLRULE_INHERIT) return gf_strdup("inherit");
  3905. else if (intVal == SVG_FILLRULE_NONZERO) return gf_strdup("nonzero");
  3906. else return gf_strdup("evenodd");
  3907. break;
  3908. case SVG_StrokeLineJoin_datatype:
  3909. if (intVal==SVG_STROKELINEJOIN_INHERIT) return gf_strdup("inherit");
  3910. else if (intVal==SVG_STROKELINEJOIN_MITER) return gf_strdup("miter");
  3911. else if (intVal==SVG_STROKELINEJOIN_ROUND) return gf_strdup("round");
  3912. else if (intVal==SVG_STROKELINEJOIN_BEVEL) return gf_strdup("bevel");
  3913. break;
  3914. case SVG_StrokeLineCap_datatype:
  3915. if (intVal==SVG_STROKELINECAP_INHERIT) return gf_strdup("inherit");
  3916. else if (intVal==SVG_STROKELINECAP_BUTT) return gf_strdup("butt");
  3917. else if (intVal==SVG_STROKELINECAP_ROUND) return gf_strdup("round");
  3918. else if (intVal==SVG_STROKELINECAP_SQUARE) return gf_strdup("square");
  3919. break;
  3920. case SVG_FontStyle_datatype:
  3921. if (intVal==SVG_FONTSTYLE_INHERIT) return gf_strdup("inherit");
  3922. else if (intVal==SVG_FONTSTYLE_NORMAL) return gf_strdup("normal");
  3923. else if (intVal==SVG_FONTSTYLE_ITALIC) return gf_strdup("italic");
  3924. else if (intVal==SVG_FONTSTYLE_OBLIQUE) return gf_strdup("oblique");
  3925. break;
  3926. case SVG_FontWeight_datatype:
  3927. if (intVal==SVG_FONTWEIGHT_INHERIT) return gf_strdup("inherit");
  3928. else if (intVal==SVG_FONTWEIGHT_NORMAL) return gf_strdup("normal");
  3929. else if (intVal==SVG_FONTWEIGHT_BOLD) return gf_strdup("bold");
  3930. else if (intVal==SVG_FONTWEIGHT_BOLDER) return gf_strdup("bolder");
  3931. else if (intVal==SVG_FONTWEIGHT_LIGHTER) return gf_strdup("lighter");
  3932. else if (intVal==SVG_FONTWEIGHT_100) return gf_strdup("100");
  3933. else if (intVal==SVG_FONTWEIGHT_200) return gf_strdup("200");
  3934. else if (intVal==SVG_FONTWEIGHT_300) return gf_strdup("300");
  3935. else if (intVal==SVG_FONTWEIGHT_400) return gf_strdup("400");
  3936. else if (intVal==SVG_FONTWEIGHT_500) return gf_strdup("500");
  3937. else if (intVal==SVG_FONTWEIGHT_600) return gf_strdup("600");
  3938. else if (intVal==SVG_FONTWEIGHT_700) return gf_strdup("700");
  3939. else if (intVal==SVG_FONTWEIGHT_800) return gf_strdup("800");
  3940. else if (intVal==SVG_FONTWEIGHT_900) return gf_strdup("900");
  3941. break;
  3942. case SVG_FontVariant_datatype:
  3943. if (intVal==SVG_FONTVARIANT_INHERIT) return gf_strdup("inherit");
  3944. else if (intVal==SVG_FONTVARIANT_NORMAL) return gf_strdup("normal");
  3945. else if (intVal==SVG_FONTVARIANT_SMALLCAPS) return gf_strdup("small-caps");
  3946. break;
  3947. case SVG_TextAnchor_datatype:
  3948. if (intVal==SVG_TEXTANCHOR_INHERIT) return gf_strdup("inherit");
  3949. else if (intVal==SVG_TEXTANCHOR_START) return gf_strdup("start");
  3950. else if (intVal==SVG_TEXTANCHOR_MIDDLE) return gf_strdup("middle");
  3951. else if (intVal==SVG_TEXTANCHOR_END) return gf_strdup("end");
  3952. break;
  3953. case SVG_Display_datatype:
  3954. if (intVal==SVG_DISPLAY_INHERIT) return gf_strdup("inherit");
  3955. else if (intVal==SVG_DISPLAY_NONE) return gf_strdup("none");
  3956. else if (intVal==SVG_DISPLAY_INLINE) return gf_strdup("inline");
  3957. else if (intVal==SVG_DISPLAY_BLOCK) return gf_strdup("block");
  3958. else if (intVal==SVG_DISPLAY_LIST_ITEM) return gf_strdup("list-item");
  3959. else if (intVal==SVG_DISPLAY_RUN_IN) return gf_strdup("run-in");
  3960. else if (intVal==SVG_DISPLAY_COMPACT) return gf_strdup("compact");
  3961. else if (intVal==SVG_DISPLAY_MARKER) return gf_strdup("marker");
  3962. else if (intVal==SVG_DISPLAY_TABLE) return gf_strdup("table");
  3963. else if (intVal==SVG_DISPLAY_INLINE_TABLE) return gf_strdup("inline-table");
  3964. else if (intVal==SVG_DISPLAY_TABLE_ROW_GROUP) return gf_strdup("table-row-group");
  3965. else if (intVal==SVG_DISPLAY_TABLE_HEADER_GROUP) return gf_strdup("table-header-group");
  3966. else if (intVal==SVG_DISPLAY_TABLE_FOOTER_GROUP) return gf_strdup("table-footer-group");
  3967. else if (intVal==SVG_DISPLAY_TABLE_ROW) return gf_strdup("table-row");
  3968. else if (intVal==SVG_DISPLAY_TABLE_COLUMN_GROUP) return gf_strdup("table-column-group");
  3969. else if (intVal==SVG_DISPLAY_TABLE_COLUMN) return gf_strdup("table-column");
  3970. else if (intVal==SVG_DISPLAY_TABLE_CELL) return gf_strdup("table-cell");
  3971. else if (intVal==SVG_DISPLAY_TABLE_CAPTION) return gf_strdup("table-caption");
  3972. break;
  3973. case SVG_Visibility_datatype:
  3974. if (intVal==SVG_VISIBILITY_INHERIT) return gf_strdup("inherit");
  3975. else if (intVal==SVG_VISIBILITY_VISIBLE) return gf_strdup("visible");
  3976. else if (intVal==SVG_VISIBILITY_HIDDEN) return gf_strdup("hidden");
  3977. else if (intVal==SVG_VISIBILITY_COLLAPSE) return gf_strdup("collapse");
  3978. break;
  3979. case SVG_Overflow_datatype:
  3980. if (intVal==SVG_OVERFLOW_INHERIT) return gf_strdup("inherit");
  3981. else if (intVal==SVG_OVERFLOW_VISIBLE) return gf_strdup("visible");
  3982. else if (intVal==SVG_OVERFLOW_HIDDEN) return gf_strdup("hidden");
  3983. else if (intVal==SVG_OVERFLOW_SCROLL) return gf_strdup("scroll");
  3984. else if (intVal==SVG_OVERFLOW_AUTO) return gf_strdup("auto");
  3985. break;
  3986. case SVG_ZoomAndPan_datatype:
  3987. if (intVal==SVG_ZOOMANDPAN_DISABLE) return gf_strdup("disable");
  3988. else return gf_strdup("magnify");
  3989. break;
  3990. case SVG_DisplayAlign_datatype:
  3991. if (intVal==SVG_DISPLAYALIGN_INHERIT) return gf_strdup("inherit");
  3992. else if (intVal==SVG_DISPLAYALIGN_AUTO) return gf_strdup("auto");
  3993. else if (intVal==SVG_DISPLAYALIGN_BEFORE) return gf_strdup("before");
  3994. else if (intVal==SVG_DISPLAYALIGN_CENTER) return gf_strdup("center");
  3995. else if (intVal==SVG_DISPLAYALIGN_AFTER) return gf_strdup("after");
  3996. break;
  3997. case SVG_TextAlign_datatype:
  3998. if (intVal==SVG_TEXTALIGN_INHERIT) return gf_strdup("inherit");
  3999. else if (intVal==SVG_TEXTALIGN_START) return gf_strdup("start");
  4000. else if (intVal==SVG_TEXTALIGN_CENTER) return gf_strdup("center");
  4001. else if (intVal==SVG_TEXTALIGN_END) return gf_strdup("end");
  4002. break;
  4003. case SVG_PointerEvents_datatype:
  4004. if (intVal==SVG_POINTEREVENTS_INHERIT) return gf_strdup("inherit");
  4005. else if (intVal==SVG_POINTEREVENTS_VISIBLEPAINTED) return gf_strdup("visiblePainted");
  4006. else if (intVal==SVG_POINTEREVENTS_VISIBLEFILL) return gf_strdup("visibleFill");
  4007. else if (intVal==SVG_POINTEREVENTS_VISIBLESTROKE) return gf_strdup("visibleStroke");
  4008. else if (intVal==SVG_POINTEREVENTS_VISIBLE) return gf_strdup("visible");
  4009. else if (intVal==SVG_POINTEREVENTS_PAINTED) return gf_strdup("painted");
  4010. else if (intVal==SVG_POINTEREVENTS_FILL) return gf_strdup("fill");
  4011. else if (intVal==SVG_POINTEREVENTS_STROKE) return gf_strdup("stroke");
  4012. else if (intVal==SVG_POINTEREVENTS_ALL) return gf_strdup("all");
  4013. else if (intVal==SVG_POINTEREVENTS_NONE) return gf_strdup("none");
  4014. else if (intVal==SVG_POINTEREVENTS_BOUNDINGBOX) return gf_strdup("boundingBox");
  4015. break;
  4016. case SVG_RenderingHint_datatype:
  4017. if (intVal==SVG_RENDERINGHINT_INHERIT) return gf_strdup("inherit");
  4018. else if (intVal==SVG_RENDERINGHINT_AUTO) return gf_strdup("auto");
  4019. else if (intVal==SVG_RENDERINGHINT_OPTIMIZEQUALITY) return gf_strdup("optimizeQuality");
  4020. else if (intVal==SVG_RENDERINGHINT_OPTIMIZESPEED) return gf_strdup("optimizeSpeed");
  4021. else if (intVal==SVG_RENDERINGHINT_OPTIMIZELEGIBILITY) return gf_strdup("optimizeLegibility");
  4022. else if (intVal==SVG_RENDERINGHINT_CRISPEDGES) return gf_strdup("crispEdges");
  4023. else if (intVal==SVG_RENDERINGHINT_GEOMETRICPRECISION) return gf_strdup("geometricPrecision");
  4024. break;
  4025. case SVG_VectorEffect_datatype:
  4026. if (intVal==SVG_VECTOREFFECT_INHERIT) return gf_strdup("inherit");
  4027. else if (intVal==SVG_VECTOREFFECT_NONE) return gf_strdup("none");
  4028. else if (intVal==SVG_VECTOREFFECT_NONSCALINGSTROKE) return gf_strdup("non-scaling-stroke");
  4029. break;
  4030. case SVG_PlaybackOrder_datatype:
  4031. if (intVal== SVG_PLAYBACKORDER_FORWARDONLY) return gf_strdup("forwardOnly");
  4032. else if (intVal== SVG_PLAYBACKORDER_ALL) return gf_strdup("all");
  4033. break;
  4034. case SVG_TimelineBegin_datatype:
  4035. if (intVal== SVG_TIMELINEBEGIN_ONSTART) return gf_strdup("onStart");
  4036. else if (intVal== SVG_TIMELINEBEGIN_ONLOAD) return gf_strdup("onLoad");
  4037. break;
  4038. case XML_Space_datatype:
  4039. if (intVal==XML_SPACE_DEFAULT) return gf_strdup("default");
  4040. else if (intVal==XML_SPACE_PRESERVE) return gf_strdup("preserve");
  4041. break;
  4042. case XMLEV_Propagate_datatype:
  4043. if (intVal==XMLEVENT_PROPAGATE_CONTINUE) return gf_strdup("continue");
  4044. else if (intVal==XMLEVENT_PROPAGATE_STOP) return gf_strdup("stop");
  4045. break;
  4046. case XMLEV_DefaultAction_datatype:
  4047. if (intVal==XMLEVENT_DEFAULTACTION_CANCEL) return gf_strdup("cancel");
  4048. else if (intVal==XMLEVENT_DEFAULTACTION_PERFORM) return gf_strdup("perform");
  4049. break;
  4050. case XMLEV_Phase_datatype:
  4051. if (intVal==XMLEVENT_PHASE_DEFAULT) return gf_strdup("default");
  4052. else if (intVal==XMLEVENT_PHASE_CAPTURE) return gf_strdup("capture");
  4053. break;
  4054. case SMIL_SyncBehavior_datatype:
  4055. if (intVal==SMIL_SYNCBEHAVIOR_INHERIT) return gf_strdup("inherit");
  4056. else if (intVal==SMIL_SYNCBEHAVIOR_DEFAULT) return gf_strdup("default");
  4057. else if (intVal==SMIL_SYNCBEHAVIOR_LOCKED) return gf_strdup("locked");
  4058. else if (intVal==SMIL_SYNCBEHAVIOR_CANSLIP) return gf_strdup("canSlip");
  4059. else if (intVal==SMIL_SYNCBEHAVIOR_INDEPENDENT) return gf_strdup("independent");
  4060. break;
  4061. case SMIL_SyncTolerance_datatype:
  4062. if (((SMIL_SyncTolerance*)info->far_ptr)->type==SMIL_SYNCTOLERANCE_INHERIT) return gf_strdup("inherit");
  4063. else if (((SMIL_SyncTolerance*)info->far_ptr)->type==SMIL_SYNCTOLERANCE_DEFAULT) return gf_strdup("default");
  4064. else if (((SMIL_SyncTolerance*)info->far_ptr)->type==SMIL_SYNCBEHAVIOR_LOCKED) {
  4065. sprintf(tmp, "%g", ((SMIL_SyncTolerance*)info->far_ptr)->value);
  4066. return gf_strdup(tmp);
  4067. }
  4068. break;
  4069. case SMIL_AttributeType_datatype:
  4070. if (intVal==SMIL_ATTRIBUTETYPE_AUTO) return gf_strdup("auto");
  4071. else if (intVal==SMIL_ATTRIBUTETYPE_XML) return gf_strdup("XML");
  4072. else if (intVal==SMIL_ATTRIBUTETYPE_CSS) return gf_strdup("CSS");
  4073. break;
  4074. case SMIL_CalcMode_datatype:
  4075. if (intVal==SMIL_CALCMODE_DISCRETE) return gf_strdup("discrete");
  4076. else if (intVal==SMIL_CALCMODE_LINEAR) return gf_strdup("linear");
  4077. else if (intVal==SMIL_CALCMODE_PACED) return gf_strdup("paced");
  4078. else if (intVal==SMIL_CALCMODE_SPLINE) return gf_strdup("spline");
  4079. break;
  4080. case SMIL_Additive_datatype:
  4081. if (intVal==SMIL_ADDITIVE_REPLACE) return gf_strdup("replace");
  4082. else if (intVal==SMIL_ADDITIVE_SUM) return gf_strdup("sum");
  4083. break;
  4084. case SMIL_Accumulate_datatype:
  4085. if (intVal==SMIL_ACCUMULATE_NONE) return gf_strdup("none");
  4086. else if (intVal==SMIL_ACCUMULATE_SUM) return gf_strdup("sum");
  4087. break;
  4088. case SMIL_Restart_datatype:
  4089. if (intVal==SMIL_RESTART_ALWAYS) return gf_strdup("always");
  4090. else if (intVal==SMIL_RESTART_WHENNOTACTIVE) return gf_strdup("whenNotActive");
  4091. else if (intVal==SMIL_RESTART_NEVER) return gf_strdup("never");
  4092. break;
  4093. case SMIL_Fill_datatype:
  4094. if (intVal==SMIL_FILL_FREEZE) return gf_strdup("freeze");
  4095. else if (intVal==SMIL_FILL_REMOVE) return gf_strdup("remove");
  4096. break;
  4097. case SVG_GradientUnit_datatype:
  4098. if (intVal==SVG_GRADIENTUNITS_USER) return gf_strdup("userSpaceOnUse");
  4099. else if (intVal==SVG_GRADIENTUNITS_OBJECT) return gf_strdup("objectBoundingBox");
  4100. break;
  4101. case SVG_InitialVisibility_datatype:
  4102. if (intVal==SVG_INITIALVISIBILTY_WHENSTARTED) return gf_strdup("whenStarted");
  4103. else if (intVal==SVG_INITIALVISIBILTY_ALWAYS) return gf_strdup("always");
  4104. break;
  4105. case SVG_FocusHighlight_datatype:
  4106. if (intVal==SVG_FOCUSHIGHLIGHT_AUTO) return gf_strdup("auto");
  4107. else if (intVal==SVG_FOCUSHIGHLIGHT_NONE) return gf_strdup("none");
  4108. break;
  4109. case SVG_Overlay_datatype:
  4110. if (intVal==SVG_OVERLAY_NONE) return gf_strdup("none");
  4111. else if (intVal==SVG_OVERLAY_TOP) return gf_strdup("top");
  4112. break;
  4113. case SVG_TransformBehavior_datatype:
  4114. if (intVal==SVG_TRANSFORMBEHAVIOR_GEOMETRIC) return gf_strdup("geometric");
  4115. else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED) return gf_strdup("pinned");
  4116. else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED90) return gf_strdup("pinned90");
  4117. else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED180) return gf_strdup("pinned180");
  4118. else if (intVal==SVG_TRANSFORMBEHAVIOR_PINNED270) return gf_strdup("pinned270");
  4119. break;
  4120. case SVG_SpreadMethod_datatype:
  4121. if (intVal==SVG_SPREAD_REFLECT) return gf_strdup("reflect");
  4122. else if (intVal==SVG_SPREAD_REFLECT) return gf_strdup("repeat");
  4123. else return gf_strdup("pad");
  4124. break;
  4125. case SVG_Filter_TransferType_datatype:
  4126. if (intVal==SVG_FILTER_TRANSFER_TABLE) return gf_strdup("table");
  4127. else if (intVal==SVG_FILTER_TRANSFER_DISCRETE) return gf_strdup("discrete");
  4128. else if (intVal==SVG_FILTER_TRANSFER_LINEAR) return gf_strdup("linear");
  4129. else if (intVal==SVG_FILTER_TRANSFER_GAMMA) return gf_strdup("gamma");
  4130. else return gf_strdup("identity");
  4131. break;
  4132. case LASeR_Choice_datatype:
  4133. if (intVal==LASeR_CHOICE_ALL) return gf_strdup("all");
  4134. else if (intVal==LASeR_CHOICE_NONE) return gf_strdup("none");
  4135. else if (intVal==LASeR_CHOICE_N) {
  4136. sprintf(tmp, "%d", ((LASeR_Choice *)info->far_ptr)->choice_index);
  4137. return gf_strdup(tmp);
  4138. }
  4139. break;
  4140. case LASeR_Size_datatype:
  4141. sprintf(tmp, "%g %g", FIX2FLT(((LASeR_Size *)info->far_ptr)->width), FIX2FLT(((LASeR_Size *)info->far_ptr)->height));
  4142. return gf_strdup(tmp);
  4143. /* end of keyword type parsing */
  4144. /* inheritable floats */
  4145. case SVG_FontSize_datatype:
  4146. case SVG_Length_datatype:
  4147. case SVG_Coordinate_datatype:
  4148. case SVG_Rotate_datatype:
  4149. case SVG_Number_datatype:
  4150. #if DUMP_COORDINATES
  4151. return svg_dump_number((SVG_Number *)info->far_ptr);
  4152. #endif
  4153. case XMLRI_datatype:
  4154. return svg_dump_iri((XMLRI*)info->far_ptr);
  4155. case XML_IDREF_datatype:
  4156. return svg_dump_idref((XMLRI*)info->far_ptr);
  4157. case XMLRI_List_datatype:
  4158. {
  4159. GF_List *l = *(GF_List **)info->far_ptr;
  4160. u32 i, count = gf_list_count(l);
  4161. char *attVal = gf_malloc(sizeof(char));
  4162. attVal[0] = 0;
  4163. for (i=0; i<count; i++) {
  4164. u32 len;
  4165. char *szT;
  4166. XMLRI *iri = (XMLRI *)gf_list_get(l, i);
  4167. szT = svg_dump_iri(iri);
  4168. len = strlen(szT);
  4169. if (len) {
  4170. attVal = gf_realloc(attVal, sizeof(char)*(len+strlen(attVal)+ (i ? 2 : 1) ));
  4171. if (i) strcat(attVal, " ");
  4172. strcat(attVal, szT);
  4173. }
  4174. gf_free(szT);
  4175. }
  4176. return attVal;
  4177. }
  4178. break;
  4179. case SVG_PathData_datatype:
  4180. #if DUMP_COORDINATES
  4181. return svg_dump_path((SVG_PathData *)info->far_ptr);
  4182. #endif
  4183. break;
  4184. case SVG_Points_datatype:
  4185. {
  4186. #if DUMP_COORDINATES
  4187. GF_List *l = *(GF_List **) info->far_ptr;
  4188. u32 i = 0;
  4189. u32 count = gf_list_count(l);
  4190. char *attVal = gf_malloc(sizeof(char));
  4191. attVal[0] = 0;
  4192. for (i=0; i<count; i++) {
  4193. char szT[200];
  4194. SVG_Point *p = (SVG_Point *)gf_list_get(l, i);
  4195. sprintf(szT, "%g %g", FIX2FLT(p->x), FIX2FLT(p->y));
  4196. attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
  4197. if (i) strcat(attVal, " ");
  4198. strcat(attVal, szT);
  4199. }
  4200. return attVal;
  4201. #endif
  4202. }
  4203. break;
  4204. case SMIL_KeyTimes_datatype:
  4205. case SMIL_KeyPoints_datatype:
  4206. case SMIL_KeySplines_datatype:
  4207. {
  4208. GF_List *l = *(GF_List **) info->far_ptr;
  4209. u32 i = 0;
  4210. u32 count = gf_list_count(l);
  4211. char *attVal = gf_malloc(sizeof(char));
  4212. attVal[0] = 0;
  4213. for (i=0; i<count; i++) {
  4214. char szT[1000];
  4215. Fixed *p = (Fixed *)gf_list_get(l, i);
  4216. sprintf(szT, "%g", FIX2FLT(*p));
  4217. attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
  4218. if (i) strcat(attVal, " ");
  4219. strcat(attVal, szT);
  4220. }
  4221. return attVal;
  4222. }
  4223. break;
  4224. case SVG_Coordinates_datatype:
  4225. {
  4226. #if DUMP_COORDINATES
  4227. GF_List *l = *(GF_List **) info->far_ptr;
  4228. u32 i = 0;
  4229. u32 count = gf_list_count(l);
  4230. char *attVal = gf_malloc(sizeof(char));
  4231. attVal[0]=0;
  4232. for (i=0; i<count; i++) {
  4233. char *szT;
  4234. SVG_Coordinate *p = (SVG_Coordinate *)gf_list_get(l, i);
  4235. szT = svg_dump_number((SVG_Length *)p);
  4236. attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
  4237. if (i) strcat(attVal, " ");
  4238. strcat(attVal, szT);
  4239. gf_free(szT);
  4240. }
  4241. return attVal;
  4242. #endif
  4243. }
  4244. break;
  4245. case SVG_ViewBox_datatype:
  4246. {
  4247. SVG_ViewBox *v = (SVG_ViewBox *)info->far_ptr;
  4248. if (v->is_set) {
  4249. sprintf(tmp, "%g %g %g %g", FIX2FLT(v->x), FIX2FLT(v->y), FIX2FLT(v->width), FIX2FLT(v->height) );
  4250. return gf_strdup(tmp);
  4251. } else
  4252. return gf_strdup("none");
  4253. }
  4254. break;
  4255. case SVG_StrokeDashArray_datatype:
  4256. {
  4257. SVG_StrokeDashArray *p = (SVG_StrokeDashArray *)info->far_ptr;
  4258. if (p->type==SVG_STROKEDASHARRAY_NONE) return gf_strdup("none");
  4259. else if (p->type==SVG_STROKEDASHARRAY_INHERIT) return gf_strdup("inherit");
  4260. else if (p->type==SVG_STROKEDASHARRAY_ARRAY) {
  4261. u32 i = 0;
  4262. char *attVal = gf_malloc(sizeof(char));
  4263. attVal[0] = 0;
  4264. for (i=0; i<p->array.count; i++) {
  4265. char *szT;
  4266. SVG_Length l;
  4267. l.type = p->array.units[i];
  4268. l.value = p->array.vals[i];
  4269. szT = svg_dump_number(&l);
  4270. attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
  4271. if (i) strcat(attVal, " ");
  4272. strcat(attVal, szT);
  4273. }
  4274. return attVal;
  4275. }
  4276. }
  4277. break;
  4278. case SVG_FontFamily_datatype:
  4279. {
  4280. SVG_FontFamily *f = (SVG_FontFamily *)info->far_ptr;
  4281. return gf_strdup( (f->type==SVG_FONTFAMILY_INHERIT) ? "inherit" : (const char *) f->value);
  4282. }
  4283. case SVG_PreserveAspectRatio_datatype:
  4284. {
  4285. SVG_PreserveAspectRatio *par = (SVG_PreserveAspectRatio *)info->far_ptr;
  4286. tmp[0] = 0;
  4287. if (par->defer) strcat(tmp, "defer ");
  4288. if (par->align == SVG_PRESERVEASPECTRATIO_NONE) strcat(tmp, "none");
  4289. else if (par->align == SVG_PRESERVEASPECTRATIO_XMINYMIN) strcat(tmp, "xMinYMin");
  4290. else if (par->align == SVG_PRESERVEASPECTRATIO_XMIDYMIN) strcat(tmp, "xMidYMin");
  4291. else if (par->align == SVG_PRESERVEASPECTRATIO_XMAXYMIN) strcat(tmp, "xMaxYMin");
  4292. else if (par->align == SVG_PRESERVEASPECTRATIO_XMINYMID) strcat(tmp, "xMinYMid");
  4293. else if (par->align == SVG_PRESERVEASPECTRATIO_XMIDYMID) strcat(tmp, "xMidYMid");
  4294. else if (par->align == SVG_PRESERVEASPECTRATIO_XMAXYMID) strcat(tmp, "xMaxYMid");
  4295. else if (par->align == SVG_PRESERVEASPECTRATIO_XMINYMAX) strcat(tmp, "xMinYMax");
  4296. else if (par->align == SVG_PRESERVEASPECTRATIO_XMIDYMAX) strcat(tmp, "xMidYMax");
  4297. else if (par->align == SVG_PRESERVEASPECTRATIO_XMAXYMAX) strcat(tmp, "xMaxYMax");
  4298. if (par->meetOrSlice== SVG_MEETORSLICE_SLICE) strcat(tmp, " slice");
  4299. return gf_strdup(tmp);
  4300. }
  4301. case SVG_Clock_datatype:
  4302. sprintf(tmp, "%g", * (SVG_Clock *)info->far_ptr );
  4303. return gf_strdup(tmp);
  4304. case SVG_ID_datatype:
  4305. case SVG_LanguageID_datatype:
  4306. case SVG_GradientOffset_datatype:
  4307. case DOM_String_datatype:
  4308. case SVG_ContentType_datatype:
  4309. if (*(SVG_String *)info->far_ptr)
  4310. return gf_strdup( *(SVG_String *)info->far_ptr );
  4311. break;
  4312. case SVG_Focus_datatype:
  4313. {
  4314. SVG_Focus *foc = (SVG_Focus *)info->far_ptr;
  4315. if (foc->type==SVG_FOCUS_SELF) return gf_strdup("self");
  4316. else if (foc->type==SVG_FOCUS_AUTO) return gf_strdup("auto");
  4317. else {
  4318. sprintf(tmp, "#%s", foc->target.string);
  4319. return gf_strdup(tmp);
  4320. }
  4321. }
  4322. break;
  4323. case SVG_Focusable_datatype:
  4324. {
  4325. SVG_Focusable *f = (SVG_Focusable *)info->far_ptr;
  4326. if (*f == SVG_FOCUSABLE_TRUE) return gf_strdup("true");
  4327. else if (*f == SVG_FOCUSABLE_FALSE) return gf_strdup("false");
  4328. else return gf_strdup("auto");
  4329. }
  4330. case DOM_StringList_datatype:
  4331. {
  4332. GF_List *l1 = *(GF_List **) info->far_ptr;
  4333. u32 i = 0;
  4334. u32 count = gf_list_count(l1);
  4335. char *attVal = gf_malloc(sizeof(char));
  4336. attVal[0] = 0;
  4337. for (i=0; i<count; i++) {
  4338. char *p1 = (char *)gf_list_get(l1, i);
  4339. attVal = gf_realloc(attVal, sizeof(char)*(strlen(p1)+strlen(attVal)+ (i ? 2 : 1) ));
  4340. if (i) strcat(attVal, " ");
  4341. strcat(attVal, p1);
  4342. }
  4343. return attVal;
  4344. }
  4345. case SVG_Numbers_datatype:
  4346. {
  4347. #if DUMP_COORDINATES
  4348. GF_List *l1 = *(GF_List **) info->far_ptr;
  4349. u32 i = 0;
  4350. u32 count = gf_list_count(l1);
  4351. char *attVal = gf_malloc(sizeof(char));
  4352. attVal[0]=0;
  4353. for (i=0; i<count; i++) {
  4354. char *szT;
  4355. SVG_Number *p = (SVG_Number *)gf_list_get(l1, i);
  4356. szT = svg_dump_number(p);
  4357. attVal = gf_realloc(attVal, sizeof(char)*(strlen(szT)+strlen(attVal)+ (i ? 2 : 1) ));
  4358. if (i) strcat(attVal, " ");
  4359. strcat(attVal, szT);
  4360. gf_free(szT);
  4361. }
  4362. return attVal;
  4363. #endif
  4364. }
  4365. break;
  4366. case SVG_Motion_datatype:
  4367. {
  4368. #if DUMP_COORDINATES
  4369. GF_Matrix2D *m = (GF_Matrix2D *)info->far_ptr;
  4370. sprintf(tmp, "%g %g", FIX2FLT(m->m[2]), FIX2FLT(m->m[5]));
  4371. return gf_strdup(tmp);
  4372. #endif
  4373. }
  4374. break;
  4375. case SVG_Transform_datatype:
  4376. {
  4377. SVG_Transform *t= (SVG_Transform *)info->far_ptr;
  4378. if (t->is_ref) {
  4379. sprintf(tmp, "ref(svg,%g,%g)", FIX2FLT(t->mat.m[2]), FIX2FLT(t->mat.m[5]) );
  4380. return gf_strdup(tmp);
  4381. } else {
  4382. return gf_svg_dump_matrix(&t->mat);
  4383. }
  4384. }
  4385. break;
  4386. case SVG_Transform_Translate_datatype:
  4387. {
  4388. SVG_Point *pt = (SVG_Point *)info->far_ptr;
  4389. #if DUMP_COORDINATES
  4390. sprintf(tmp, "%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y) );
  4391. return gf_strdup(tmp);
  4392. #endif
  4393. }
  4394. break;
  4395. case SVG_Transform_Scale_datatype:
  4396. {
  4397. SVG_Point *pt = (SVG_Point *)info->far_ptr;
  4398. #if DUMP_COORDINATES
  4399. if (pt->x == pt->y) {
  4400. sprintf(tmp, "%g", FIX2FLT(pt->x));
  4401. } else {
  4402. sprintf(tmp, "%g %g", FIX2FLT(pt->x), FIX2FLT(pt->y) );
  4403. }
  4404. return gf_strdup(tmp);
  4405. #endif
  4406. }
  4407. break;
  4408. case SVG_Transform_SkewX_datatype:
  4409. case SVG_Transform_SkewY_datatype:
  4410. {
  4411. Fixed *f = (Fixed *)info->far_ptr;
  4412. #if DUMP_COORDINATES
  4413. sprintf(tmp, "%g", FIX2FLT( 180 * gf_divfix(*f, GF_PI) ));
  4414. return gf_strdup(tmp);
  4415. #endif
  4416. }
  4417. break;
  4418. case SVG_Transform_Rotate_datatype:
  4419. {
  4420. SVG_Point_Angle *pt = (SVG_Point_Angle *)info->far_ptr;
  4421. #if DUMP_COORDINATES
  4422. if (pt->x || pt->y) {
  4423. sprintf(tmp, "%g %g %g", FIX2FLT( 180 * gf_divfix(pt->angle, GF_PI) ), FIX2FLT(pt->x), FIX2FLT(pt->y) );
  4424. } else {
  4425. sprintf(tmp, "%g", FIX2FLT(gf_divfix(180 * pt->angle, GF_PI) ));
  4426. }
  4427. return gf_strdup(tmp);
  4428. #endif
  4429. }
  4430. break;
  4431. case SMIL_AttributeName_datatype:
  4432. {
  4433. SMIL_AttributeName *att_name = (SMIL_AttributeName *) info->far_ptr;
  4434. if (att_name->name)
  4435. return gf_strdup(att_name->name);
  4436. if (att_name->tag)
  4437. return gf_strdup( gf_svg_get_attribute_name(elt, att_name->tag) );
  4438. }
  4439. break;
  4440. case SMIL_Times_datatype:
  4441. {
  4442. u32 i, count;
  4443. GF_Node *par = gf_node_get_parent((GF_Node *)elt, 0);
  4444. GF_List *l = *(GF_List **) info->far_ptr;
  4445. char *attVal = gf_malloc(sizeof(char));
  4446. attVal[0] = 0;
  4447. count = gf_list_count(l);
  4448. for (i=0; i<count; i++) {
  4449. char szBuf[1000];
  4450. SMIL_Time *t = (SMIL_Time *)gf_list_get(l, i);
  4451. szBuf[0] = 0;
  4452. if (t->type == GF_SMIL_TIME_CLOCK) {
  4453. sprintf(szBuf, "%gs", t->clock);
  4454. } else if (t->type==GF_SMIL_TIME_INDEFINITE) {
  4455. strcpy(szBuf, "indefinite");
  4456. } else if (t->type==GF_SMIL_TIME_WALLCLOCK) {
  4457. u32 h, m, s;
  4458. /*TODO - day month and year*/
  4459. h = (u32) t->clock * 3600;
  4460. m = (u32) (t->clock * 60 - 60*h);
  4461. s = (u32) (t->clock - 3600*h - 60*m);
  4462. sprintf(szBuf, "wallclock(%d:%d:%d)", h, m, s);
  4463. }
  4464. else if (t->type==GF_SMIL_TIME_EVENT) {
  4465. if (t->event.type == GF_EVENT_KEYDOWN) {
  4466. svg_dump_access_key(&t->event, szBuf);
  4467. } else {
  4468. if (t->element_id) {
  4469. strcpy(szBuf, t->element_id);
  4470. strcat(szBuf, ".");
  4471. } else if (t->element && (t->element!=par) && gf_node_get_id(t->element) ) {
  4472. const char *name = gf_node_get_name(t->element);
  4473. if (name) {
  4474. strcpy(szBuf, name);
  4475. } else {
  4476. sprintf(szBuf, "N%d", gf_node_get_id(t->element)-1 );
  4477. }
  4478. strcat(szBuf, ".");
  4479. }
  4480. strcat(szBuf, gf_dom_event_get_name(t->event.type));
  4481. }
  4482. if (t->clock) {
  4483. char szCk[40];
  4484. sprintf(szCk, "+%gs", t->clock);
  4485. strcat(szBuf, szCk);
  4486. }
  4487. }
  4488. if (szBuf[0]) {
  4489. attVal = gf_realloc(attVal, sizeof(char)*(strlen(attVal)+strlen(szBuf)+ (i ? 2 : 1) ));
  4490. if ( strlen(attVal) ) strcat(attVal, ";");
  4491. strcat(attVal, szBuf);
  4492. }
  4493. }
  4494. return attVal;
  4495. }
  4496. break;
  4497. case SMIL_Duration_datatype:
  4498. {
  4499. SMIL_Duration *dur = (SMIL_Duration *)info->far_ptr;
  4500. if (dur->type == SMIL_DURATION_INDEFINITE) return gf_strdup("indefinite");
  4501. else if (dur->type == SMIL_DURATION_MEDIA) return gf_strdup("media");
  4502. else if (dur->type == SMIL_DURATION_DEFINED) {
  4503. sprintf(tmp, "%gs", dur->clock_value);
  4504. return gf_strdup(tmp);
  4505. } else {
  4506. GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] smil duration not assigned\n"));
  4507. }
  4508. }
  4509. break;
  4510. case SMIL_RepeatCount_datatype:
  4511. {
  4512. SMIL_RepeatCount *rep = (SMIL_RepeatCount *)info->far_ptr;
  4513. if (rep->type == SMIL_REPEATCOUNT_INDEFINITE) return gf_strdup("indefinite");
  4514. else if (rep->type == SMIL_REPEATCOUNT_DEFINED) {
  4515. sprintf(tmp, "%g", FIX2FLT(rep->count) );
  4516. return gf_strdup(tmp);
  4517. }
  4518. else {
  4519. GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[SVG Dumping] smil repeat count not assigned\n"));
  4520. }
  4521. }
  4522. break;
  4523. case SVG_TransformType_datatype:
  4524. {
  4525. SVG_TransformType tr = *(SVG_TransformType *)info->far_ptr;
  4526. if (tr == SVG_TRANSFORM_MATRIX) return gf_strdup("matrix");
  4527. else if (tr == SVG_TRANSFORM_SCALE) return gf_strdup("scale");
  4528. else if (tr == SVG_TRANSFORM_ROTATE) return gf_strdup("rotate");
  4529. else if (tr == SVG_TRANSFORM_TRANSLATE) return gf_strdup("translate");
  4530. else if (tr == SVG_TRANSFORM_SKEWX) return gf_strdup("skewX");
  4531. else if (tr == SVG_TRANSFORM_SKEWY) return gf_strdup("skewY");
  4532. }
  4533. break;
  4534. case SMIL_AnimateValue_datatype:
  4535. {
  4536. GF_FieldInfo a_fi;
  4537. SMIL_AnimateValue*av = (SMIL_AnimateValue*)info->far_ptr;
  4538. a_fi.fieldIndex = 0;
  4539. a_fi.fieldType = av->type;
  4540. a_fi.name = info->name;
  4541. a_fi.far_ptr = av->value;
  4542. return gf_svg_dump_attribute(elt, &a_fi);
  4543. }
  4544. break;
  4545. case SMIL_AnimateValues_datatype:
  4546. {
  4547. GF_FieldInfo a_fi;
  4548. u32 i, count;
  4549. SMIL_AnimateValues *av = (SMIL_AnimateValues*)info->far_ptr;
  4550. char *attVal = gf_malloc(sizeof(char));
  4551. attVal[0] = 0;
  4552. if (av->type) {
  4553. count = gf_list_count(av->values);
  4554. a_fi.fieldIndex = 0;
  4555. a_fi.fieldType = av->type;
  4556. a_fi.name = info->name;
  4557. for (i=0; i<count; i++) {
  4558. char *szBuf;
  4559. a_fi.far_ptr = gf_list_get(av->values, i);
  4560. szBuf = gf_svg_dump_attribute(elt, &a_fi);
  4561. attVal = gf_realloc(attVal, sizeof(char)*(strlen(attVal)+strlen(szBuf)+ (i ? 2 : 1) ));
  4562. if (i) strcat(attVal, ";");
  4563. strcat(attVal, szBuf);
  4564. gf_free(szBuf);
  4565. }
  4566. }
  4567. return attVal;
  4568. }
  4569. case XMLEV_Event_datatype:
  4570. {
  4571. XMLEV_Event *d = (XMLEV_Event *)info->far_ptr;
  4572. if (d->parameter) {
  4573. svg_dump_access_key(d, tmp);
  4574. } else {
  4575. strcpy(tmp, gf_dom_event_get_name(d->type));
  4576. }
  4577. return gf_strdup(tmp);
  4578. }
  4579. default:
  4580. 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)));
  4581. break;
  4582. }
  4583. return gf_strdup("");
  4584. }
  4585. char *gf_svg_dump_attribute_indexed(GF_Node *elt, GF_FieldInfo *info)
  4586. {
  4587. char tmp[1024];
  4588. switch (info->fieldType) {
  4589. case SVG_PointerEvents_datatype:
  4590. break;
  4591. case XMLRI_List_datatype:
  4592. return gf_strdup( (char *) info->far_ptr);
  4593. case SVG_Points_datatype:
  4594. {
  4595. #if DUMP_COORDINATES
  4596. SVG_Point *p = (SVG_Point *)info->far_ptr;
  4597. sprintf(tmp, "%g %g", FIX2FLT(p->x), FIX2FLT(p->y));
  4598. return gf_strdup(tmp);
  4599. #endif
  4600. }
  4601. break;
  4602. case SMIL_KeyPoints_datatype:
  4603. case SMIL_KeyTimes_datatype:
  4604. case SMIL_KeySplines_datatype:
  4605. {
  4606. Fixed *p = (Fixed *)info->far_ptr;
  4607. sprintf(tmp, "%g", FIX2FLT(*p));
  4608. return gf_strdup(tmp);
  4609. }
  4610. break;
  4611. case SVG_Coordinates_datatype:
  4612. #if DUMP_COORDINATES
  4613. return svg_dump_number((SVG_Length *) (SVG_Coordinate *)info->far_ptr);
  4614. #endif
  4615. break;
  4616. case SVG_ViewBox_datatype:
  4617. {
  4618. Fixed *v = (Fixed *)info->far_ptr;
  4619. sprintf(tmp, "%g", FIX2FLT(*v));
  4620. return gf_strdup(tmp);
  4621. }
  4622. break;
  4623. case SVG_StrokeDashArray_datatype:
  4624. {
  4625. /*TODO: fix this: should be an SVG_Length*/
  4626. Fixed *p = (Fixed *)info->far_ptr;
  4627. sprintf(tmp, "%g", FIX2FLT(*p));
  4628. return gf_strdup(tmp);
  4629. }
  4630. break;
  4631. case SMIL_Times_datatype:
  4632. {
  4633. SMIL_Time *t = (SMIL_Time *)info->far_ptr;
  4634. if (t->type == GF_SMIL_TIME_CLOCK) {
  4635. sprintf(tmp, "%gs", t->clock);
  4636. } else if (t->type==GF_SMIL_TIME_INDEFINITE) {
  4637. strcpy(tmp, "indefinite");
  4638. } else if (t->type==GF_SMIL_TIME_WALLCLOCK) {
  4639. u32 h, m, s;
  4640. /*TODO - day month and year*/
  4641. h = (u32) t->clock * 3600;
  4642. m = (u32) (t->clock * 60 - 60*h);
  4643. s = (u32) (t->clock - 3600*h - 60*m);
  4644. sprintf(tmp, "wallclock(%d:%d:%d)", h, m, s);
  4645. }
  4646. else if (t->type==GF_SMIL_TIME_EVENT) {
  4647. GF_Node *par = gf_node_get_parent((GF_Node *)elt, 0);
  4648. if (t->event.type == GF_EVENT_KEYDOWN) {
  4649. svg_dump_access_key(&t->event, tmp);
  4650. } else {
  4651. strcpy(tmp, "");
  4652. if (t->element_id) {
  4653. strcat(tmp, t->element_id);
  4654. strcat(tmp, ".");
  4655. } else if (t->element && (t->element!=par) && gf_node_get_id(t->element) ) {
  4656. const char *name = gf_node_get_name(t->element);
  4657. if (name) {
  4658. strcat(tmp, name);
  4659. } else {
  4660. sprintf(tmp, "N%d", gf_node_get_id(t->element)-1 );
  4661. }
  4662. strcat(tmp, ".");
  4663. }
  4664. strcat(tmp, gf_dom_event_get_name(t->event.type));
  4665. }
  4666. if (t->clock) {
  4667. char szBuf[100];
  4668. sprintf(szBuf, "+%gs", t->clock);
  4669. strcat(tmp, szBuf);
  4670. }
  4671. }
  4672. return gf_strdup(tmp);
  4673. }
  4674. default:
  4675. 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)));
  4676. break;
  4677. }
  4678. return gf_strdup("");
  4679. }
  4680. static Bool svg_viewbox_equal(SVG_ViewBox *v1, SVG_ViewBox *v2)
  4681. {
  4682. if (v1->is_set != v2->is_set) return 0;
  4683. if (!v1->is_set)
  4684. return 1;
  4685. else {
  4686. if ( (v1->x == v2->x) && (v1->y == v2->y) && (v1->width == v2->width) && (v1->height == v2->height) )
  4687. return 1;
  4688. else
  4689. return 0;
  4690. }
  4691. }
  4692. static Bool svg_colors_equal(SVG_Color *c1, SVG_Color *c2)
  4693. {
  4694. if (c1->type != c2->type) return 0;
  4695. if (c1->red != c2->red) return 0;
  4696. if (c1->green != c2->green) return 0;
  4697. if (c1->blue != c2->blue) return 0;
  4698. return 1;
  4699. }
  4700. static Bool svg_numbers_equal(SVG_Length *l1, SVG_Length *l2)
  4701. {
  4702. if (l1->type!=l2->type) return 0;
  4703. if (l1->type >= SVG_NUMBER_INHERIT) return 1;
  4704. return (l1->value==l2->value) ? 1 : 0;
  4705. }
  4706. static Bool svg_iris_equal(XMLRI*iri1, XMLRI*iri2)
  4707. {
  4708. u32 type1, type2;
  4709. type1 = iri1->type;
  4710. type2 = iri2->type;
  4711. /*ignore undef hrefs, these are internall ones*/
  4712. if ((iri1->type == XMLRI_ELEMENTID) && iri1->target) {
  4713. if (!gf_node_get_id((GF_Node *)iri1->target)) type1 = 0;
  4714. }
  4715. if ((iri2->type == XMLRI_ELEMENTID) && iri2->target) {
  4716. if (!gf_node_get_id((GF_Node *)iri2->target)) type2 = 0;
  4717. }
  4718. if (type1 != type2) return 0;
  4719. if ((type1 == XMLRI_ELEMENTID) && (iri1->target == iri2->target) ) return 1;
  4720. if (iri1->string && iri2->string && !strcmp(iri1->string, iri2->string)) return 1;
  4721. if (!iri1->string && !iri2->string) return 1;
  4722. return 0;
  4723. }
  4724. static Bool svg_matrices_equal(GF_Matrix2D *m1, GF_Matrix2D *m2)
  4725. {
  4726. if (m1->m[0] != m2->m[0]) return 0;
  4727. if (m1->m[1] != m2->m[1]) return 0;
  4728. if (m1->m[2] != m2->m[2]) return 0;
  4729. if (m1->m[3] != m2->m[3]) return 0;
  4730. if (m1->m[4] != m2->m[4]) return 0;
  4731. if (m1->m[5] != m2->m[5]) return 0;
  4732. return 1;
  4733. }
  4734. Bool gf_svg_attributes_equal(GF_FieldInfo *f1, GF_FieldInfo *f2)
  4735. {
  4736. u32 v1, v2;
  4737. if (f1->fieldType!=f2->fieldType) return 0;
  4738. if (f1->far_ptr && !f2->far_ptr) return 0;
  4739. if (f2->far_ptr && !f1->far_ptr) return 0;
  4740. if (!f1->far_ptr) return 1;
  4741. v1 = *(u8 *)f1->far_ptr;
  4742. v2 = *(u8 *)f2->far_ptr;
  4743. switch (f1->fieldType) {
  4744. case SVG_Boolean_datatype:
  4745. case SVG_FillRule_datatype:
  4746. case SVG_StrokeLineJoin_datatype:
  4747. case SVG_StrokeLineCap_datatype:
  4748. case SVG_FontStyle_datatype:
  4749. case SVG_FontWeight_datatype:
  4750. case SVG_FontVariant_datatype:
  4751. case SVG_TextAnchor_datatype:
  4752. case SVG_Display_datatype:
  4753. case SVG_Visibility_datatype:
  4754. case SVG_GradientUnit_datatype:
  4755. case SVG_PreserveAspectRatio_datatype:
  4756. case XML_Space_datatype:
  4757. case XMLEV_Propagate_datatype:
  4758. case XMLEV_DefaultAction_datatype:
  4759. case XMLEV_Phase_datatype:
  4760. case SMIL_SyncBehavior_datatype:
  4761. case SMIL_AttributeType_datatype:
  4762. case SMIL_CalcMode_datatype:
  4763. case SMIL_Additive_datatype:
  4764. case SMIL_Accumulate_datatype:
  4765. case SMIL_Restart_datatype:
  4766. case SMIL_Fill_datatype:
  4767. case SVG_Overflow_datatype:
  4768. case SVG_ZoomAndPan_datatype:
  4769. case SVG_DisplayAlign_datatype:
  4770. case SVG_TextAlign_datatype:
  4771. case SVG_PointerEvents_datatype:
  4772. case SVG_RenderingHint_datatype:
  4773. case SVG_VectorEffect_datatype:
  4774. case SVG_PlaybackOrder_datatype:
  4775. case SVG_TimelineBegin_datatype:
  4776. case SVG_FocusHighlight_datatype:
  4777. case SVG_TransformType_datatype:
  4778. case SVG_Overlay_datatype:
  4779. case SVG_TransformBehavior_datatype:
  4780. case SVG_SpreadMethod_datatype:
  4781. case SVG_InitialVisibility_datatype:
  4782. case LASeR_Choice_datatype:
  4783. return (v1==v2) ? 1 : 0;
  4784. case SVG_Color_datatype:
  4785. return svg_colors_equal((SVG_Color *)f1->far_ptr, (SVG_Color *)f2->far_ptr);
  4786. case SMIL_SyncTolerance_datatype:
  4787. {
  4788. SMIL_SyncTolerance *st1 = (SMIL_SyncTolerance*)f1->far_ptr;
  4789. SMIL_SyncTolerance *st2 = (SMIL_SyncTolerance*)f2->far_ptr;
  4790. if (st1->type!=st2->type) return 0;
  4791. if ((st1->type==SMIL_SYNCTOLERANCE_VALUE) && (st1->value!=st2->value)) return 0;
  4792. return 1;
  4793. }
  4794. case SVG_Paint_datatype:
  4795. {
  4796. SVG_Paint *p1 = (SVG_Paint *)f1->far_ptr;
  4797. SVG_Paint *p2 = (SVG_Paint *)f2->far_ptr;
  4798. if (p1->type != p2->type) return 0;
  4799. if (p1->type==SVG_PAINT_COLOR) return svg_colors_equal(&p1->color, &p2->color);
  4800. else if (p1->type==SVG_PAINT_URI) return svg_iris_equal(&p1->iri, &p2->iri);
  4801. return 1;
  4802. }
  4803. break;
  4804. case SVG_FontSize_datatype:
  4805. case SVG_Length_datatype:
  4806. case SVG_Coordinate_datatype:
  4807. case SVG_Rotate_datatype:
  4808. case SVG_Number_datatype:
  4809. return svg_numbers_equal((SVG_Number *)f1->far_ptr, (SVG_Number *)f2->far_ptr);
  4810. case XMLRI_datatype:
  4811. return svg_iris_equal((XMLRI*)f1->far_ptr, (XMLRI*)f2->far_ptr);
  4812. case XMLRI_List_datatype:
  4813. {
  4814. GF_List *l1 = *(GF_List **)f1->far_ptr;
  4815. GF_List *l2 = *(GF_List **)f2->far_ptr;
  4816. u32 i, count = gf_list_count(l1);
  4817. if (gf_list_count(l2)!=count) return 0;
  4818. for (i=0; i<count; i++) {
  4819. if (!svg_iris_equal((XMLRI*)gf_list_get(l1, i), (XMLRI*)gf_list_get(l2, i) )) return 0;
  4820. }
  4821. return 1;
  4822. }
  4823. case SVG_PathData_datatype:
  4824. {
  4825. SVG_PathData *d1 = (SVG_PathData *)f1->far_ptr;
  4826. SVG_PathData *d2 = (SVG_PathData *)f2->far_ptr;
  4827. u32 i;
  4828. /*FIXME - be less lazy..*/
  4829. #if USE_GF_PATH
  4830. if (d1->n_points != d2->n_points) return 0;
  4831. if (d1->n_contours != d2->n_contours) return 0;
  4832. for (i=0; i<d1->n_points; i++) {
  4833. if (d1->points[i].x != d2->points[i].x) return 0;
  4834. if (d1->points[i].y != d2->points[i].y) return 0;
  4835. }
  4836. for (i=0; i<d1->n_points; i++) {
  4837. if (d1->tags[i] != d2->tags[i]) return 0;
  4838. }
  4839. for (i=0; i<d1->n_contours; i++) {
  4840. if (d1->contours[i] != d2->contours[i]) return 0;
  4841. }
  4842. return 1;
  4843. #else
  4844. if (!gf_list_count(d1->commands) && !gf_list_count(d2->commands)) return 1;
  4845. #endif
  4846. return 0;
  4847. }
  4848. case SVG_Points_datatype:
  4849. {
  4850. GF_List *l1 = *(GF_List **) f1->far_ptr;
  4851. GF_List *l2 = *(GF_List **) f2->far_ptr;
  4852. u32 i = 0;
  4853. u32 count = gf_list_count(l1);
  4854. if (gf_list_count(l2)!=count) return 0;
  4855. for (i=0; i<count; i++) {
  4856. SVG_Point *p1 = (SVG_Point *)gf_list_get(l1, i);
  4857. SVG_Point *p2 = (SVG_Point *)gf_list_get(l2, i);
  4858. if (p1->x != p2->x) return 0;
  4859. if (p1->y != p2->y) return 0;
  4860. }
  4861. return 1;
  4862. }
  4863. case SMIL_KeyTimes_datatype:
  4864. case SMIL_KeyPoints_datatype:
  4865. case SMIL_KeySplines_datatype:
  4866. {
  4867. GF_List *l1 = *(GF_List **) f1->far_ptr;
  4868. GF_List *l2 = *(GF_List **) f2->far_ptr;
  4869. u32 i = 0;
  4870. u32 count = gf_list_count(l1);
  4871. if (gf_list_count(l2)!=count) return 0;
  4872. for (i=0; i<count; i++) {
  4873. Fixed *p1 = (Fixed *)gf_list_get(l1, i);
  4874. Fixed *p2 = (Fixed *)gf_list_get(l2, i);
  4875. if (*p1 != *p2) return 0;
  4876. }
  4877. return 1;
  4878. }
  4879. case SVG_Coordinates_datatype:
  4880. {
  4881. GF_List *l1 = *(GF_List **) f1->far_ptr;
  4882. GF_List *l2 = *(GF_List **) f2->far_ptr;
  4883. u32 i = 0;
  4884. u32 count = gf_list_count(l1);
  4885. if (gf_list_count(l2) != count) return 0;
  4886. for (i=0; i<count; i++) {
  4887. SVG_Coordinate *p1 = (SVG_Coordinate *)gf_list_get(l1, i);
  4888. SVG_Coordinate *p2 = (SVG_Coordinate *)gf_list_get(l2, i);
  4889. if (!svg_numbers_equal(p1, p2)) return 0;
  4890. }
  4891. return 1;
  4892. }
  4893. case SVG_ViewBox_datatype:
  4894. {
  4895. SVG_ViewBox *v1 = (SVG_ViewBox *)f1->far_ptr;
  4896. SVG_ViewBox *v2 = (SVG_ViewBox *)f2->far_ptr;
  4897. return svg_viewbox_equal(v1, v2);
  4898. }
  4899. case SVG_StrokeDashArray_datatype:
  4900. {
  4901. SVG_StrokeDashArray *p1 = (SVG_StrokeDashArray *)f1->far_ptr;
  4902. SVG_StrokeDashArray *p2 = (SVG_StrokeDashArray *)f2->far_ptr;
  4903. if (p1->type!=p2->type) return 0;
  4904. if (p1->type==SVG_STROKEDASHARRAY_ARRAY) {
  4905. u32 i = 0;
  4906. if (p1->array.count != p2->array.count) return 0;
  4907. for (i=0; i<p1->array.count; i++) {
  4908. if (p1->array.units[i] != p2->array.units[i]) return 0;
  4909. if (p1->array.vals[i] != p2->array.vals[i]) return 0;
  4910. }
  4911. }
  4912. return 1;
  4913. }
  4914. case SVG_FontFamily_datatype:
  4915. {
  4916. SVG_FontFamily *ff1 = (SVG_FontFamily *)f1->far_ptr;
  4917. SVG_FontFamily *ff2 = (SVG_FontFamily *)f2->far_ptr;
  4918. if (ff1->type!=ff2->type) return 0;
  4919. if (ff1->type==SVG_FONTFAMILY_INHERIT) return 1;
  4920. return (ff1->value && ff2->value && !strcmp(ff1->value, ff2->value)) ? 1 : 0;
  4921. }
  4922. case SVG_Clock_datatype:
  4923. return (* (SVG_Clock *)f1->far_ptr == * (SVG_Clock *)f2->far_ptr) ? 1 : 0;
  4924. /* required for animateMotion */
  4925. case SVG_Motion_datatype:
  4926. return svg_matrices_equal((GF_Matrix2D*)f1->far_ptr, (GF_Matrix2D*)f2->far_ptr);
  4927. case SVG_Transform_datatype:
  4928. {
  4929. SVG_Transform *t1 = (SVG_Transform *)f1->far_ptr;
  4930. SVG_Transform *t2 = (SVG_Transform *)f2->far_ptr;
  4931. if (t1->is_ref == t2->is_ref)
  4932. return svg_matrices_equal(&t1->mat, &t2->mat);
  4933. else
  4934. return 0;
  4935. }
  4936. case SVG_Transform_Translate_datatype:
  4937. case SVG_Transform_Scale_datatype:
  4938. {
  4939. SVG_Point *p1 = (SVG_Point *)f1->far_ptr;
  4940. SVG_Point *p2 = (SVG_Point *)f2->far_ptr;
  4941. if (p1->x != p2->x) return 0;
  4942. if (p1->y != p2->y) return 0;
  4943. return 1;
  4944. }
  4945. case SVG_Transform_SkewX_datatype:
  4946. case SVG_Transform_SkewY_datatype:
  4947. {
  4948. Fixed *p1 = (Fixed *)f1->far_ptr;
  4949. Fixed *p2 = (Fixed *)f2->far_ptr;
  4950. return (*p1 == *p2);
  4951. }
  4952. case SVG_Transform_Rotate_datatype:
  4953. {
  4954. SVG_Point_Angle *p1 = (SVG_Point_Angle *)f1->far_ptr;
  4955. SVG_Point_Angle *p2 = (SVG_Point_Angle *)f2->far_ptr;
  4956. if (p1->x != p2->x) return 0;
  4957. if (p1->y != p2->y) return 0;
  4958. if (p1->angle != p2->angle) return 0;
  4959. return 1;
  4960. }
  4961. case SVG_ID_datatype:
  4962. case SVG_LanguageID_datatype:
  4963. case SVG_GradientOffset_datatype:
  4964. case DOM_String_datatype:
  4965. case SVG_ContentType_datatype:
  4966. {
  4967. char *str1 = *(SVG_String *)f1->far_ptr;
  4968. char *str2 = *(SVG_String *)f2->far_ptr;
  4969. if (!str1 && !str2) return 1;
  4970. return (str1 && str2 && !strcmp(str1, str2)) ? 1 : 0;
  4971. }
  4972. case SVG_Focus_datatype:
  4973. {
  4974. SVG_Focus *foc1 = (SVG_Focus *) f1->far_ptr;
  4975. SVG_Focus *foc2 = (SVG_Focus *)f2->far_ptr;
  4976. if (foc1->type!=foc2->type) return 0;
  4977. if (foc1->type != SVG_FOCUS_IRI) return 1;
  4978. return (foc1->target.string && foc2->target.string && !strcmp(foc1->target.string, foc2->target.string)) ? 1 : 0;
  4979. }
  4980. break;
  4981. case DOM_StringList_datatype:
  4982. {
  4983. GF_List *l1 = *(GF_List **) f1->far_ptr;
  4984. GF_List *l2 = *(GF_List **) f2->far_ptr;
  4985. u32 i = 0;
  4986. u32 count = gf_list_count(l1);
  4987. if (gf_list_count(l2) != count) return 0;
  4988. for (i=0; i<count; i++) {
  4989. char *p1 = (char *)gf_list_get(l1, i);
  4990. char *p2 = (char *)gf_list_get(l2, i);
  4991. if (strcmp(p1, p2)) return 0;
  4992. }
  4993. return 1;
  4994. }
  4995. case SVG_Numbers_datatype:
  4996. {
  4997. GF_List *l1 = *(GF_List **) f1->far_ptr;
  4998. GF_List *l2 = *(GF_List **) f2->far_ptr;
  4999. u32 i = 0;
  5000. u32 count = gf_list_count(l1);
  5001. if (gf_list_count(l2) != count) return 0;
  5002. for (i=0; i<count; i++) {
  5003. SVG_Number *p1 = (SVG_Number *)gf_list_get(l1, i);
  5004. SVG_Number *p2 = (SVG_Number *)gf_list_get(l2, i);
  5005. if (!svg_numbers_equal(p1, p2)) return 0;
  5006. }
  5007. return 1;
  5008. }
  5009. case SMIL_Times_datatype:
  5010. {
  5011. GF_List *l1 = *(GF_List **) f1->far_ptr;
  5012. GF_List *l2 = *(GF_List **) f2->far_ptr;
  5013. u32 i = 0;
  5014. u32 count = gf_list_count(l1);
  5015. if (gf_list_count(l2) != count) return 0;
  5016. for (i=0; i<count; i++) {
  5017. SMIL_Time *p1 = (SMIL_Time *)gf_list_get(l1, i);
  5018. SMIL_Time *p2 = (SMIL_Time *)gf_list_get(l2, i);
  5019. if (p1->type != p2->type) return 0;
  5020. if (p1->clock != p2->clock) return 0;
  5021. if (p1->type==GF_SMIL_TIME_EVENT) {
  5022. if (p1->event.type != p2->event.type) return 0;
  5023. if (p1->event.parameter != p2->event.parameter) return 0;
  5024. }
  5025. }
  5026. return 1;
  5027. }
  5028. case SMIL_Duration_datatype:
  5029. {
  5030. SMIL_Duration *d1 = (SMIL_Duration *)f1->far_ptr;
  5031. SMIL_Duration *d2 = (SMIL_Duration *)f2->far_ptr;
  5032. if (d1->type != d2->type) return 0;
  5033. if (d1->clock_value != d2->clock_value) return 0;
  5034. return 1;
  5035. }
  5036. case SMIL_RepeatCount_datatype:
  5037. {
  5038. SMIL_RepeatCount *d1 = (SMIL_RepeatCount *)f1->far_ptr;
  5039. SMIL_RepeatCount *d2 = (SMIL_RepeatCount *)f2->far_ptr;
  5040. if (d1->type != d2->type) return 0;
  5041. if (d1->count != d2->count) return 0;
  5042. return 1;
  5043. }
  5044. case SMIL_AttributeName_datatype:
  5045. {
  5046. SMIL_AttributeName *att1 = (SMIL_AttributeName *) f1->far_ptr;
  5047. SMIL_AttributeName *att2 = (SMIL_AttributeName *) f2->far_ptr;
  5048. /*TODO check me...*/
  5049. if (att2->field_ptr == att1->field_ptr) return 1;
  5050. return 0;
  5051. }
  5052. case SMIL_AnimateValue_datatype:
  5053. {
  5054. SMIL_AnimateValue *av1 = (SMIL_AnimateValue*)f1->far_ptr;
  5055. SMIL_AnimateValue *av2 = (SMIL_AnimateValue*)f2->far_ptr;
  5056. if (av1->value != av2->value) return 0;
  5057. return 1;
  5058. }
  5059. break;
  5060. case SMIL_AnimateValues_datatype:
  5061. {
  5062. u32 count;
  5063. SMIL_AnimateValues *av1 = (SMIL_AnimateValues*)f1->far_ptr;
  5064. SMIL_AnimateValues *av2 = (SMIL_AnimateValues*)f2->far_ptr;
  5065. if (av1->type != av2->type) return 0;
  5066. if ( (count = gf_list_count(av1->values) ) != gf_list_count(av1->values)) return 0;
  5067. return count ? 0 : 1;
  5068. }
  5069. case XMLEV_Event_datatype:
  5070. {
  5071. XMLEV_Event *d1 = (XMLEV_Event *)f1->far_ptr;
  5072. XMLEV_Event *d2 = (XMLEV_Event *)f2->far_ptr;
  5073. if (d1->type != d2->type) return 0;
  5074. if (d1->parameter != d2->parameter) return 0;
  5075. return 1;
  5076. }
  5077. case LASeR_Size_datatype:
  5078. {
  5079. LASeR_Size *sz1 = (LASeR_Size *)f1->far_ptr;
  5080. LASeR_Size *sz2 = (LASeR_Size *)f2->far_ptr;
  5081. if (sz1->width != sz2->width) return 0;
  5082. if (sz1->height != sz2->height) return 0;
  5083. return 1;
  5084. }
  5085. default:
  5086. 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)));
  5087. return 0;
  5088. }
  5089. }
  5090. static void svg_color_clamp(SVG_Color *a)
  5091. {
  5092. a->red = MAX(0, MIN(FIX_ONE, a->red));
  5093. a->green = MAX(0, MIN(FIX_ONE, a->green));
  5094. a->blue = MAX(0, MIN(FIX_ONE, a->blue));
  5095. }
  5096. static GF_Err svg_color_muladd(Fixed alpha, SVG_Color *a, Fixed beta, SVG_Color *b, SVG_Color *c, Bool clamp)
  5097. {
  5098. if (a->type != SVG_COLOR_RGBCOLOR || b->type != SVG_COLOR_RGBCOLOR) {
  5099. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] only RGB colors are additive\n"));
  5100. return GF_BAD_PARAM;
  5101. }
  5102. c->type = SVG_COLOR_RGBCOLOR;
  5103. c->red = gf_mulfix(alpha, a->red) + gf_mulfix(beta, b->red);
  5104. c->green = gf_mulfix(alpha, a->green) + gf_mulfix(beta, b->green);
  5105. c->blue = gf_mulfix(alpha, a->blue) + gf_mulfix(beta, b->blue);
  5106. if (clamp) svg_color_clamp(c);
  5107. return GF_OK;
  5108. }
  5109. static GF_Err svg_number_muladd(Fixed alpha, SVG_Number *a, Fixed beta, SVG_Number *b, SVG_Number *c)
  5110. {
  5111. if (a->type != b->type) {
  5112. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] cannot add lengths of mismatching types\n"));
  5113. return GF_BAD_PARAM;
  5114. }
  5115. if (a->type == SVG_NUMBER_INHERIT || a->type == SVG_NUMBER_AUTO) {
  5116. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] cannot add lengths\n"));
  5117. return GF_BAD_PARAM;
  5118. }
  5119. c->value = gf_mulfix(alpha, a->value) + gf_mulfix(beta, b->value);
  5120. return GF_OK;
  5121. }
  5122. static GF_Err svg_viewbox_muladd(Fixed alpha, SVG_ViewBox *a, Fixed beta, SVG_ViewBox *b, SVG_ViewBox *c)
  5123. {
  5124. c->is_set = 1;
  5125. c->x = gf_mulfix(alpha, a->x) + gf_mulfix(beta, b->x);
  5126. c->y = gf_mulfix(alpha, a->y) + gf_mulfix(beta, b->y);
  5127. c->width = gf_mulfix(alpha, a->width) + gf_mulfix(beta, b->width);
  5128. c->height= gf_mulfix(alpha, a->height) + gf_mulfix(beta, b->height);
  5129. return GF_OK;
  5130. }
  5131. static GF_Err svg_point_muladd(Fixed alpha, SVG_Point *pta, Fixed beta, SVG_Point *ptb, SVG_Point *ptc)
  5132. {
  5133. ptc->x = gf_mulfix(alpha, pta->x) + gf_mulfix(beta, ptb->x);
  5134. ptc->y = gf_mulfix(alpha, pta->y) + gf_mulfix(beta, ptb->y);
  5135. return GF_OK;
  5136. }
  5137. static GF_Err svg_point_angle_muladd(Fixed alpha, SVG_Point_Angle *pta, Fixed beta, SVG_Point_Angle *ptb, SVG_Point_Angle *ptc)
  5138. {
  5139. ptc->x = gf_mulfix(alpha, pta->x) + gf_mulfix(beta, ptb->x);
  5140. ptc->y = gf_mulfix(alpha, pta->y) + gf_mulfix(beta, ptb->y);
  5141. ptc->angle = gf_mulfix(alpha, pta->angle) + gf_mulfix(beta, ptb->angle);
  5142. return GF_OK;
  5143. }
  5144. static GF_Err svg_points_muladd(Fixed alpha, SVG_Points *a, Fixed beta, SVG_Points *b, SVG_Points *c)
  5145. {
  5146. u32 a_count = gf_list_count(*a);
  5147. u32 i;
  5148. if (a_count != gf_list_count(*b)) return GF_BAD_PARAM;
  5149. while (gf_list_count(*c)) {
  5150. SVG_Point *ptc = (SVG_Point *)gf_list_get(*c, 0);
  5151. gf_list_rem(*c, 0);
  5152. gf_free(ptc);
  5153. }
  5154. for (i = 0; i < a_count; i ++) {
  5155. SVG_Point *ptc;
  5156. SVG_Point *pta = (SVG_Point *)gf_list_get(*a, i);
  5157. SVG_Point *ptb = (SVG_Point *)gf_list_get(*b, i);
  5158. GF_SAFEALLOC(ptc, SVG_Point)
  5159. svg_point_muladd(alpha, pta, beta, ptb, ptc);
  5160. gf_list_add(*c, ptc);
  5161. }
  5162. return GF_OK;
  5163. }
  5164. static GF_Err svg_points_copy(SVG_Points *a, SVG_Points *b)
  5165. {
  5166. u32 i, count;
  5167. count = gf_list_count(*a);
  5168. for (i = 0; i < count; i++) {
  5169. SVG_Point *pt = (SVG_Point *)gf_list_get(*a, i);
  5170. gf_free(pt);
  5171. }
  5172. gf_list_reset(*a);
  5173. count = gf_list_count(*b);
  5174. for (i = 0; i < count; i ++) {
  5175. SVG_Point *ptb = (SVG_Point *)gf_list_get(*b, i);
  5176. SVG_Point *pta;
  5177. GF_SAFEALLOC(pta, SVG_Point)
  5178. *pta = *ptb;
  5179. gf_list_add(*a, pta);
  5180. }
  5181. return GF_OK;
  5182. }
  5183. static GF_Err svg_numbers_muladd(Fixed alpha, SVG_Numbers *a, Fixed beta, SVG_Numbers *b, SVG_Numbers *c)
  5184. {
  5185. u32 a_count = gf_list_count(*a);
  5186. u32 i;
  5187. if (a_count != gf_list_count(*b)) return GF_BAD_PARAM;
  5188. gf_list_reset(*c);
  5189. for (i = 0; i < a_count; i ++) {
  5190. SVG_Number *nc;
  5191. SVG_Number *na = (SVG_Number *)gf_list_get(*a, i);
  5192. SVG_Number *nb = (SVG_Number *)gf_list_get(*b, i);
  5193. GF_SAFEALLOC(nc, SVG_Number)
  5194. svg_number_muladd(alpha, na, beta, nb, nc);
  5195. gf_list_add(*c, nc);
  5196. }
  5197. return GF_OK;
  5198. }
  5199. static GF_Err svg_numbers_copy(SVG_Numbers *a, SVG_Numbers *b)
  5200. {
  5201. u32 i, count;
  5202. count = gf_list_count(*a);
  5203. for (i = 0; i < count; i++) {
  5204. SVG_Coordinate *c = (SVG_Coordinate *)gf_list_get(*a, i);
  5205. gf_free(c);
  5206. }
  5207. gf_list_reset(*a);
  5208. count = gf_list_count(*b);
  5209. for (i = 0; i < count; i ++) {
  5210. SVG_Number *na;
  5211. GF_SAFEALLOC(na, SVG_Number)
  5212. *na = *(SVG_Number *)gf_list_get(*b, i);
  5213. gf_list_add(*a, na);
  5214. }
  5215. return GF_OK;
  5216. }
  5217. #if USE_GF_PATH
  5218. static GF_Err svg_path_copy(SVG_PathData *a, SVG_PathData *b)
  5219. {
  5220. if (a->contours) gf_free(a->contours);
  5221. if (a->points) gf_free(a->points);
  5222. if (a->tags) gf_free(a->tags);
  5223. a->contours = (u32 *)gf_malloc(sizeof(u32)*b->n_contours);
  5224. a->points = (GF_Point2D *) gf_malloc(sizeof(GF_Point2D)*b->n_points);
  5225. a->tags = (u8 *) gf_malloc(sizeof(u8)*b->n_points);
  5226. memcpy(a->contours, b->contours, sizeof(u32)*b->n_contours);
  5227. a->n_contours = b->n_contours;
  5228. memcpy(a->points, b->points, sizeof(GF_Point2D)*b->n_points);
  5229. memcpy(a->tags, b->tags, sizeof(u8)*b->n_points);
  5230. a->n_alloc_points = a->n_points = b->n_points;
  5231. a->flags = b->flags;
  5232. a->bbox = b->bbox;
  5233. a->fineness = b->fineness;
  5234. return GF_OK;
  5235. }
  5236. #else
  5237. static GF_Err svg_path_copy(SVG_PathData *a, SVG_PathData *b)
  5238. {
  5239. u32 i, count;
  5240. count = gf_list_count(a->commands);
  5241. for (i = 0; i < count; i++) {
  5242. u8 *command = (u8 *)gf_list_get(a->commands, i);
  5243. gf_free(command);
  5244. }
  5245. gf_list_reset(a->commands);
  5246. count = gf_list_count(a->points);
  5247. for (i = 0; i < count; i++) {
  5248. SVG_Point *pt = (SVG_Point *)gf_list_get(a->points, i);
  5249. gf_free(pt);
  5250. }
  5251. gf_list_reset(a->points);
  5252. count = gf_list_count(b->commands);
  5253. for (i = 0; i < count; i ++) {
  5254. u8 *nc = (u8 *)gf_malloc(sizeof(u8));
  5255. *nc = *(u8*)gf_list_get(b->commands, i);
  5256. gf_list_add(a->commands, nc);
  5257. }
  5258. count = gf_list_count(b->points);
  5259. for (i = 0; i < count; i ++) {
  5260. SVG_Point *pta;
  5261. GF_SAFEALLOC(pta, SVG_Point)
  5262. *pta = *(SVG_Point *)gf_list_get(b->points, i);
  5263. gf_list_add(a->points, pta);
  5264. }
  5265. return GF_OK;
  5266. }
  5267. #endif
  5268. #if USE_GF_PATH
  5269. static GF_Err svg_path_muladd(Fixed alpha, SVG_PathData *a, Fixed beta, SVG_PathData *b, SVG_PathData *c)
  5270. {
  5271. u32 i;
  5272. if (a->n_points != b->n_points) return GF_BAD_PARAM;
  5273. gf_path_reset(c);
  5274. svg_path_copy(c, a);
  5275. for (i=0; i<a->n_points; i++) {
  5276. svg_point_muladd(alpha, (SVG_Point *) &a->points[i], beta, (SVG_Point *) &b->points[i], (SVG_Point *) &c->points[i]);
  5277. }
  5278. c->flags |= GF_PATH_BBOX_DIRTY;
  5279. c->flags &= ~GF_PATH_FLATTENED;
  5280. return GF_OK;
  5281. }
  5282. #else
  5283. static GF_Err svg_path_muladd(Fixed alpha, SVG_PathData *a, Fixed beta, SVG_PathData *b, SVG_PathData *c)
  5284. {
  5285. u32 i, ccount, pcount;
  5286. ccount = gf_list_count(a->commands);
  5287. pcount = gf_list_count(a->points);
  5288. if (pcount != gf_list_count(b->points)) return GF_BAD_PARAM;
  5289. #if 0
  5290. if (ccount != gf_list_count(b->commands)) return GF_BAD_PARAM;
  5291. for (i = 0; i < ccount; i++) {
  5292. u8 *ac = gf_list_get(a->commands, i);
  5293. u8 *bc = gf_list_get(b->commands, i);
  5294. if (*ac != *bc) return GF_BAD_PARAM;
  5295. }
  5296. #endif
  5297. while (gf_list_count(c->commands)) {
  5298. u8 *command = (u8 *)gf_list_last(c->commands);
  5299. gf_free(command);
  5300. gf_list_rem_last(c->commands);
  5301. }
  5302. while (gf_list_count(c->points)) {
  5303. SVG_Point *pt = (SVG_Point *)gf_list_last(c->points);
  5304. gf_free(pt);
  5305. gf_list_rem_last(c->points);
  5306. }
  5307. for (i = 0; i < ccount; i++) {
  5308. u8 *nc = (u8 *)gf_malloc(sizeof(u8));
  5309. *nc = *(u8*)gf_list_get(a->commands, i);
  5310. gf_list_add(c->commands, nc);
  5311. }
  5312. for (i = 0; i < pcount; i++) {
  5313. SVG_Point *pta = (SVG_Point *)gf_list_get(a->points, i);
  5314. SVG_Point *ptb = (SVG_Point *)gf_list_get(b->points, i);
  5315. SVG_Point *ptc;
  5316. GF_SAFEALLOC(ptc, SVG_Point)
  5317. svg_point_muladd(alpha, pta, beta, ptb, ptc);
  5318. gf_list_add(c->points, ptc);
  5319. }
  5320. return GF_OK;
  5321. }
  5322. #endif
  5323. static GF_Err svg_dasharray_muladd(Fixed alpha, SVG_StrokeDashArray *a, Fixed beta, SVG_StrokeDashArray *b, SVG_StrokeDashArray *c)
  5324. {
  5325. u32 i;
  5326. if (a->type != b->type) return GF_BAD_PARAM;
  5327. if (a->array.count != b->array.count) return GF_BAD_PARAM;
  5328. c->type = a->type;
  5329. c->array.count = a->array.count;
  5330. c->array.vals = (Fixed *) gf_malloc(sizeof(Fixed)*c->array.count);
  5331. for (i = 0; i < c->array.count; i++) {
  5332. /* TODO: convert units if needed */
  5333. c->array.units[i] = a->array.units[i];
  5334. c->array.vals[i] = gf_mulfix(alpha, a->array.vals[i]) + gf_mulfix(beta, b->array.vals[i]);
  5335. }
  5336. return GF_OK;
  5337. }
  5338. static GF_Err svg_dasharray_copy(SVG_StrokeDashArray *a, SVG_StrokeDashArray *b)
  5339. {
  5340. a->type = b->type;
  5341. a->array.count = b->array.count;
  5342. a->array.units = (u8*)gf_malloc(sizeof(u8)*a->array.count);
  5343. memcpy(a->array.units, b->array.units, sizeof(u8)*a->array.count);
  5344. a->array.vals = (Fixed*)gf_malloc(sizeof(Fixed)*a->array.count);
  5345. memcpy(a->array.vals, b->array.vals, sizeof(Fixed)*a->array.count);
  5346. return GF_OK;
  5347. }
  5348. static GF_Err svg_matrix_muladd(Fixed alpha, GF_Matrix2D *a, Fixed beta, GF_Matrix2D *b, GF_Matrix2D *c)
  5349. {
  5350. /*
  5351. if ((alpha == beta) && (alpha == FIX_ONE) ) {
  5352. GF_Matrix2D tmp;
  5353. gf_mx2d_copy(tmp, *b);
  5354. gf_mx2d_add_matrix(&tmp, a);
  5355. gf_mx2d_copy(*c, tmp);
  5356. } else */
  5357. if (alpha <= FIX_ONE) {
  5358. /* This case should happen only when using animateMotion and accumulation
  5359. see animate-elem-202-t.svg
  5360. we only add and multiply the translation component; */
  5361. /*
  5362. c->m[0] = gf_mulfix(alpha, a->m[0]) + gf_mulfix(beta, b->m[0]);
  5363. c->m[1] = gf_mulfix(alpha, a->m[1]) + gf_mulfix(beta, b->m[1]);
  5364. c->m[2] = gf_mulfix(alpha, a->m[2]) + gf_mulfix(beta, b->m[2]);
  5365. c->m[3] = gf_mulfix(alpha, a->m[3]) + gf_mulfix(beta, b->m[3]);
  5366. */
  5367. c->m[0] = a->m[0];
  5368. c->m[1] = a->m[1];
  5369. c->m[2] = gf_mulfix(alpha, a->m[2]) + gf_mulfix(beta, b->m[2]);
  5370. c->m[3] = a->m[3];
  5371. c->m[4] = a->m[4];
  5372. c->m[5] = gf_mulfix(alpha, a->m[5]) + gf_mulfix(beta, b->m[5]);
  5373. } else {
  5374. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5375. return GF_BAD_PARAM;
  5376. }
  5377. return GF_OK;
  5378. }
  5379. static GF_Err laser_size_muladd(Fixed alpha, LASeR_Size *sza, Fixed beta, LASeR_Size *szb, LASeR_Size *szc)
  5380. {
  5381. szc->width = gf_mulfix(alpha, sza->width) + gf_mulfix(beta, szb->width);
  5382. szc->height = gf_mulfix(alpha, sza->height) + gf_mulfix(beta, szb->height);
  5383. return GF_OK;
  5384. }
  5385. /* c = alpha * a + beta * b */
  5386. GF_Err gf_svg_attributes_muladd(Fixed alpha, GF_FieldInfo *a,
  5387. Fixed beta, GF_FieldInfo *b,
  5388. GF_FieldInfo *c,
  5389. Bool clamp)
  5390. {
  5391. if (!a->far_ptr || !b->far_ptr || !c->far_ptr) return GF_BAD_PARAM;
  5392. if (a->fieldType != b->fieldType) {
  5393. if (a->fieldType != SVG_Transform_datatype &&
  5394. a->fieldType != SVG_Transform_Scale_datatype &&
  5395. a->fieldType != SVG_Transform_Translate_datatype &&
  5396. a->fieldType != SVG_Transform_Rotate_datatype &&
  5397. a->fieldType != SVG_Transform_SkewX_datatype &&
  5398. a->fieldType != SVG_Transform_SkewY_datatype &&
  5399. a->fieldType != SVG_Motion_datatype)
  5400. return GF_BAD_PARAM;
  5401. }
  5402. /* by default a and c are of the same type, except for matrix related types */
  5403. c->fieldType = a->fieldType;
  5404. switch (a->fieldType) {
  5405. /* Numeric types */
  5406. case SVG_Color_datatype:
  5407. return svg_color_muladd(alpha, (SVG_Color*)a->far_ptr, beta, (SVG_Color*)b->far_ptr, (SVG_Color*)c->far_ptr, clamp);
  5408. case SVG_Paint_datatype:
  5409. {
  5410. SVG_Paint *pa = (SVG_Paint *)a->far_ptr;
  5411. SVG_Paint *pb = (SVG_Paint *)b->far_ptr;
  5412. SVG_Paint *pc = (SVG_Paint *)c->far_ptr;
  5413. if (pa->type != pb->type || pa->type != SVG_PAINT_COLOR || pb->type != SVG_PAINT_COLOR) {
  5414. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] only color paints are additive\n"));
  5415. return GF_BAD_PARAM;
  5416. }
  5417. pc->type = SVG_PAINT_COLOR;
  5418. return svg_color_muladd(alpha, &pa->color, beta, &pb->color, &pc->color, clamp);
  5419. }
  5420. case SVG_Number_datatype:
  5421. case SVG_Length_datatype:
  5422. case SVG_Coordinate_datatype:
  5423. case SVG_FontSize_datatype:
  5424. return svg_number_muladd(alpha, (SVG_Number*)a->far_ptr, beta, (SVG_Number*)b->far_ptr, (SVG_Number*)c->far_ptr);
  5425. case SVG_ViewBox_datatype:
  5426. return svg_viewbox_muladd(alpha, (SVG_ViewBox*)a->far_ptr, beta, (SVG_ViewBox*)b->far_ptr, (SVG_ViewBox*)c->far_ptr);
  5427. case SVG_Points_datatype:
  5428. return svg_points_muladd(alpha, (GF_List **)a->far_ptr, beta, (GF_List **)b->far_ptr, (GF_List **)c->far_ptr);
  5429. case SVG_Numbers_datatype:
  5430. case SVG_Coordinates_datatype:
  5431. return svg_numbers_muladd(alpha, (GF_List **)a->far_ptr, beta, (GF_List **)b->far_ptr, (GF_List **)c->far_ptr);
  5432. case SVG_PathData_datatype:
  5433. return svg_path_muladd(alpha, (SVG_PathData*)a->far_ptr, beta, (SVG_PathData*)b->far_ptr, (SVG_PathData*)c->far_ptr);
  5434. case SVG_StrokeDashArray_datatype:
  5435. return svg_dasharray_muladd(alpha, (SVG_StrokeDashArray*)a->far_ptr, beta, (SVG_StrokeDashArray*)b->far_ptr, (SVG_StrokeDashArray*)c->far_ptr);
  5436. case SVG_Motion_datatype:
  5437. return svg_matrix_muladd(alpha, (GF_Matrix2D*)a->far_ptr, beta, (GF_Matrix2D*)b->far_ptr, (GF_Matrix2D*)c->far_ptr);
  5438. case SVG_Transform_datatype:
  5439. if (b->fieldType == SVG_Transform_datatype) {
  5440. SVG_Transform *ta = (SVG_Transform *)a->far_ptr;
  5441. SVG_Transform *tb = (SVG_Transform *)b->far_ptr;
  5442. SVG_Transform *tc = (SVG_Transform *)c->far_ptr;
  5443. if (ta->is_ref == tb->is_ref) {
  5444. return svg_matrix_muladd(alpha, &ta->mat, beta, &tb->mat, &tc->mat);
  5445. } else {
  5446. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5447. return GF_NOT_SUPPORTED;
  5448. }
  5449. } else {
  5450. /* a and c are matrices but b is not */
  5451. GF_Matrix2D tmp;
  5452. /*TOCHECK what is this test*/
  5453. /*
  5454. if (alpha != FIX_ONE) {
  5455. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5456. return GF_NOT_SUPPORTED;
  5457. }
  5458. */
  5459. gf_mx2d_init(tmp);
  5460. switch (b->fieldType) {
  5461. case SVG_Transform_Translate_datatype:
  5462. gf_mx2d_add_translation(&tmp, gf_mulfix(((SVG_Point *)b->far_ptr)->x, beta), gf_mulfix(((SVG_Point *)b->far_ptr)->y, beta));
  5463. break;
  5464. case SVG_Transform_Scale_datatype:
  5465. gf_mx2d_add_scale(&tmp, gf_mulfix(((SVG_Point *)b->far_ptr)->x, beta), gf_mulfix(((SVG_Point *)b->far_ptr)->y, beta));
  5466. break;
  5467. case SVG_Transform_Rotate_datatype:
  5468. 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));
  5469. break;
  5470. case SVG_Transform_SkewX_datatype:
  5471. gf_mx2d_add_skew_x(&tmp, gf_mulfix(*(Fixed*)b->far_ptr, beta));
  5472. break;
  5473. case SVG_Transform_SkewY_datatype:
  5474. gf_mx2d_add_skew_y(&tmp, gf_mulfix(*(Fixed*)b->far_ptr, beta));
  5475. break;
  5476. default:
  5477. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] copy of attributes %s not supported\n", a->name));
  5478. return GF_NOT_SUPPORTED;
  5479. }
  5480. gf_mx2d_add_matrix(&tmp, &((SVG_Transform*)a->far_ptr)->mat);
  5481. gf_mx2d_copy(((SVG_Transform*)c->far_ptr)->mat, tmp);
  5482. return GF_OK;
  5483. }
  5484. case SVG_Transform_Translate_datatype:
  5485. if (b->fieldType == SVG_Transform_Translate_datatype) {
  5486. return svg_point_muladd(alpha, (SVG_Point*)a->far_ptr, beta, (SVG_Point*)b->far_ptr, (SVG_Point*)c->far_ptr);
  5487. } else {
  5488. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5489. return GF_NOT_SUPPORTED;
  5490. }
  5491. case SVG_Transform_Scale_datatype:
  5492. if (b->fieldType == SVG_Transform_Scale_datatype) {
  5493. if (alpha == FIX_ONE && beta == FIX_ONE) {
  5494. /* addition of matrices which represent scales is equivalent
  5495. to multiplication of scale coefficients, we assume this only happens if
  5496. alpha and beta are set to one */
  5497. ((SVG_Point*)c->far_ptr)->x = gf_mulfix(((SVG_Point*)a->far_ptr)->x,((SVG_Point*)b->far_ptr)->x);
  5498. ((SVG_Point*)c->far_ptr)->y = gf_mulfix(((SVG_Point*)a->far_ptr)->y,((SVG_Point*)b->far_ptr)->y);
  5499. return GF_OK;
  5500. } else {
  5501. return svg_point_muladd(alpha, (SVG_Point*)a->far_ptr, beta, (SVG_Point*)b->far_ptr, (SVG_Point*)c->far_ptr);
  5502. }
  5503. } else {
  5504. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5505. return GF_NOT_SUPPORTED;
  5506. }
  5507. case SVG_Transform_Rotate_datatype:
  5508. if (b->fieldType == SVG_Transform_Rotate_datatype) {
  5509. 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);
  5510. } else {
  5511. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5512. return GF_NOT_SUPPORTED;
  5513. }
  5514. case SVG_Transform_SkewX_datatype:
  5515. if (b->fieldType == SVG_Transform_SkewX_datatype) {
  5516. *(Fixed*)c->far_ptr = gf_mulfix(alpha, *(Fixed*)a->far_ptr) + gf_mulfix(beta, *(Fixed*)b->far_ptr);
  5517. return GF_OK;
  5518. } else {
  5519. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5520. return GF_NOT_SUPPORTED;
  5521. }
  5522. case SVG_Transform_SkewY_datatype:
  5523. if (b->fieldType == SVG_Transform_SkewY_datatype) {
  5524. *(Fixed*)c->far_ptr = gf_mulfix(alpha, *(Fixed*)a->far_ptr) + gf_mulfix(beta, *(Fixed*)b->far_ptr);
  5525. return GF_OK;
  5526. } else {
  5527. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] matrix operations not supported\n"));
  5528. return GF_NOT_SUPPORTED;
  5529. }
  5530. case DOM_String_datatype:
  5531. {
  5532. u32 len;
  5533. char *res;
  5534. SVG_String *s_a = (SVG_String *)a->far_ptr;
  5535. SVG_String *s_b = (SVG_String *)b->far_ptr;
  5536. u32 len_a = strlen(*s_a);
  5537. u32 len_b = strlen(*s_b);
  5538. len_a = FIX2INT(alpha * len_a);
  5539. len_b = FIX2INT(beta * len_b);
  5540. len = len_a + len_b + 1;
  5541. res = (char*)gf_malloc(sizeof(char) * len);
  5542. memcpy(res, *s_a, len_a);
  5543. memcpy(res+len_a, *s_b, len_b);
  5544. res[len-1] = 0;
  5545. s_a = (SVG_String*)c->far_ptr;
  5546. if (*s_a) gf_free(*s_a);
  5547. *s_a = res;
  5548. }
  5549. break;
  5550. case LASeR_Size_datatype:
  5551. laser_size_muladd(alpha, (LASeR_Size*)a->far_ptr, beta, (LASeR_Size*)b->far_ptr, (LASeR_Size*)c->far_ptr);
  5552. break;
  5553. /* Keyword types */
  5554. case SVG_Boolean_datatype:
  5555. case SVG_FillRule_datatype:
  5556. case SVG_StrokeLineJoin_datatype:
  5557. case SVG_StrokeLineCap_datatype:
  5558. case SVG_FontStyle_datatype:
  5559. case SVG_FontWeight_datatype:
  5560. case SVG_FontVariant_datatype:
  5561. case SVG_TextAnchor_datatype:
  5562. case SVG_Display_datatype:
  5563. case SVG_Visibility_datatype:
  5564. case SVG_GradientUnit_datatype:
  5565. case SVG_PreserveAspectRatio_datatype:
  5566. case XML_Space_datatype:
  5567. case XMLEV_Propagate_datatype:
  5568. case XMLEV_DefaultAction_datatype:
  5569. case XMLEV_Phase_datatype:
  5570. case SMIL_SyncBehavior_datatype:
  5571. case SMIL_SyncTolerance_datatype:
  5572. case SMIL_AttributeType_datatype:
  5573. case SMIL_CalcMode_datatype:
  5574. case SMIL_Additive_datatype:
  5575. case SMIL_Accumulate_datatype:
  5576. case SMIL_Restart_datatype:
  5577. case SMIL_Fill_datatype:
  5578. case SVG_Overflow_datatype:
  5579. case SVG_ZoomAndPan_datatype:
  5580. case SVG_DisplayAlign_datatype:
  5581. case SVG_TextAlign_datatype:
  5582. case SVG_PointerEvents_datatype:
  5583. case SVG_RenderingHint_datatype:
  5584. case SVG_VectorEffect_datatype:
  5585. case SVG_PlaybackOrder_datatype:
  5586. case SVG_TimelineBegin_datatype:
  5587. case SVG_SpreadMethod_datatype:
  5588. case SVG_TransformType_datatype:
  5589. /* Unsupported types */
  5590. case SVG_ContentType_datatype:
  5591. case SVG_LanguageID_datatype:
  5592. case SVG_FontFamily_datatype:
  5593. case XMLRI_datatype:
  5594. case XMLRI_List_datatype:
  5595. case DOM_StringList_datatype:
  5596. case SVG_Clock_datatype:
  5597. case SVG_Focus_datatype:
  5598. case SVG_ID_datatype:
  5599. case SVG_GradientOffset_datatype:
  5600. case SMIL_KeyTimes_datatype:
  5601. case SMIL_KeyPoints_datatype:
  5602. case SMIL_KeySplines_datatype:
  5603. case SMIL_AnimateValue_datatype:
  5604. case SMIL_AnimateValues_datatype:
  5605. case SMIL_AttributeName_datatype:
  5606. case SMIL_Times_datatype:
  5607. case SMIL_Duration_datatype:
  5608. case SMIL_RepeatCount_datatype:
  5609. default:
  5610. 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)));
  5611. return GF_NOT_SUPPORTED;
  5612. }
  5613. return GF_OK;
  5614. }
  5615. /* *a = *b, copy by value */
  5616. GF_EXPORT
  5617. GF_Err gf_svg_attributes_copy(GF_FieldInfo *a, GF_FieldInfo *b, Bool clamp)
  5618. {
  5619. if (!a->far_ptr || !b->far_ptr) return GF_BAD_PARAM;
  5620. switch (a->fieldType) {
  5621. /* Numeric types */
  5622. case SVG_Color_datatype:
  5623. *((SVG_Color *)a->far_ptr) = *((SVG_Color *)b->far_ptr);
  5624. if (clamp) svg_color_clamp((SVG_Color *)a->far_ptr);
  5625. break;
  5626. case SVG_Paint_datatype:
  5627. {
  5628. SVG_Paint *pa = (SVG_Paint *)a->far_ptr;
  5629. SVG_Paint *pb = (SVG_Paint *)b->far_ptr;
  5630. pa->type = pb->type;
  5631. if (pb->type == SVG_PAINT_URI) {
  5632. GF_FieldInfo tmp_a, tmp_b;
  5633. tmp_a.fieldType = tmp_b.fieldType = XMLRI_datatype;
  5634. tmp_a.far_ptr = &pa->iri;
  5635. tmp_b.far_ptr = &pb->iri;
  5636. gf_svg_attributes_copy(&tmp_a, &tmp_b, 0);
  5637. } else {
  5638. pa->color = pb->color;
  5639. }
  5640. return GF_OK;
  5641. }
  5642. break;
  5643. case SVG_Number_datatype:
  5644. case SVG_Length_datatype:
  5645. case SVG_Coordinate_datatype:
  5646. case SVG_FontSize_datatype:
  5647. *((SVG_Number *)a->far_ptr) = *((SVG_Number *)b->far_ptr);
  5648. break;
  5649. case SVG_ViewBox_datatype:
  5650. *((SVG_ViewBox *)a->far_ptr) = *((SVG_ViewBox *)b->far_ptr);
  5651. break;
  5652. case SVG_Points_datatype:
  5653. return svg_points_copy((GF_List**)a->far_ptr, (GF_List**)b->far_ptr);
  5654. case SVG_Numbers_datatype:
  5655. case SVG_Coordinates_datatype:
  5656. return svg_numbers_copy((GF_List**)a->far_ptr, (GF_List**)b->far_ptr);
  5657. case SVG_PathData_datatype:
  5658. return svg_path_copy((SVG_PathData*)a->far_ptr, (SVG_PathData*)b->far_ptr);
  5659. case SVG_StrokeDashArray_datatype:
  5660. return svg_dasharray_copy((SVG_StrokeDashArray*)a->far_ptr, (SVG_StrokeDashArray*)b->far_ptr);
  5661. case SVG_Motion_datatype:
  5662. gf_mx2d_copy(*(GF_Matrix2D *)a->far_ptr, *(GF_Matrix2D *)b->far_ptr);
  5663. return GF_OK;
  5664. case SVG_Transform_datatype:
  5665. switch (b->fieldType) {
  5666. case SVG_Transform_Translate_datatype:
  5667. gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
  5668. gf_mx2d_add_translation(&((SVG_Transform *)a->far_ptr)->mat, ((SVG_Point*)b->far_ptr)->x, ((SVG_Point*)b->far_ptr)->y);
  5669. break;
  5670. case SVG_Transform_Scale_datatype:
  5671. gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
  5672. gf_mx2d_add_scale(&((SVG_Transform *)a->far_ptr)->mat, ((SVG_Point*)b->far_ptr)->x, ((SVG_Point*)b->far_ptr)->y);
  5673. break;
  5674. case SVG_Transform_Rotate_datatype:
  5675. gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
  5676. 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);
  5677. break;
  5678. case SVG_Transform_SkewX_datatype:
  5679. gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
  5680. gf_mx2d_add_skew_x(&((SVG_Transform *)a->far_ptr)->mat, *(Fixed *)b->far_ptr);
  5681. break;
  5682. case SVG_Transform_SkewY_datatype:
  5683. gf_mx2d_init(((SVG_Transform *)a->far_ptr)->mat);
  5684. gf_mx2d_add_skew_y(&((SVG_Transform *)a->far_ptr)->mat, *(Fixed *)b->far_ptr);
  5685. break;
  5686. case SVG_Transform_datatype:
  5687. gf_mx2d_copy(((SVG_Transform *)a->far_ptr)->mat, ((SVG_Transform *)b->far_ptr)->mat);
  5688. break;
  5689. default:
  5690. GF_LOG(GF_LOG_ERROR, GF_LOG_INTERACT, ("[SVG Attributes] forbidden type of transform\n"));
  5691. return GF_NOT_SUPPORTED;
  5692. }
  5693. return GF_OK;
  5694. /* Keyword types */
  5695. case SVG_Boolean_datatype:
  5696. case SVG_FillRule_datatype:
  5697. case SVG_StrokeLineJoin_datatype:
  5698. case SVG_StrokeLineCap_datatype:
  5699. case SVG_FontStyle_datatype:
  5700. case SVG_FontWeight_datatype:
  5701. case SVG_FontVariant_datatype:
  5702. case SVG_TextAnchor_datatype:
  5703. case SVG_Display_datatype:
  5704. case SVG_Visibility_datatype:
  5705. case SVG_GradientUnit_datatype:
  5706. case SVG_PreserveAspectRatio_datatype:
  5707. case XML_Space_datatype:
  5708. case XMLEV_Propagate_datatype:
  5709. case XMLEV_DefaultAction_datatype:
  5710. case XMLEV_Phase_datatype:
  5711. case SMIL_SyncBehavior_datatype:
  5712. case SMIL_AttributeType_datatype:
  5713. case SMIL_CalcMode_datatype:
  5714. case SMIL_Additive_datatype:
  5715. case SMIL_Accumulate_datatype:
  5716. case SMIL_Restart_datatype:
  5717. case SMIL_Fill_datatype:
  5718. case SVG_Overflow_datatype:
  5719. case SVG_ZoomAndPan_datatype:
  5720. case SVG_DisplayAlign_datatype:
  5721. case SVG_TextAlign_datatype:
  5722. case SVG_PointerEvents_datatype:
  5723. case SVG_RenderingHint_datatype:
  5724. case SVG_VectorEffect_datatype:
  5725. case SVG_PlaybackOrder_datatype:
  5726. case SVG_TimelineBegin_datatype:
  5727. case SVG_TransformType_datatype:
  5728. case SVG_Focusable_datatype:
  5729. case SVG_FocusHighlight_datatype:
  5730. *(u8 *)a->far_ptr = *(u8 *)b->far_ptr;
  5731. return GF_OK;
  5732. case SMIL_SyncTolerance_datatype:
  5733. *(SMIL_SyncTolerance*)a->far_ptr = *(SMIL_SyncTolerance*)b->far_ptr;
  5734. return GF_OK;
  5735. /* Other types */
  5736. case SVG_ID_datatype:
  5737. case SVG_LanguageID_datatype:
  5738. case SVG_ContentType_datatype:
  5739. case DOM_String_datatype:
  5740. if (* (SVG_String *)a->far_ptr) gf_free(* (SVG_String *)a->far_ptr);
  5741. * (SVG_String *)a->far_ptr = gf_strdup(*(SVG_String *)b->far_ptr);
  5742. return GF_OK;
  5743. case SVG_FontFamily_datatype:
  5744. ((SVG_FontFamily *)a->far_ptr)->type = ((SVG_FontFamily *)b->far_ptr)->type;
  5745. if ( ((SVG_FontFamily *)a->far_ptr)->value) gf_free( ((SVG_FontFamily *)a->far_ptr)->value );
  5746. ((SVG_FontFamily *)a->far_ptr)->value = (((SVG_FontFamily *)b->far_ptr)->value ? gf_strdup(((SVG_FontFamily *)b->far_ptr)->value) : NULL );
  5747. return GF_OK;
  5748. case XMLRI_datatype:
  5749. case XML_IDREF_datatype:
  5750. ((XMLRI *)a->far_ptr)->type = ((XMLRI *)b->far_ptr)->type;
  5751. if (((XMLRI *)a->far_ptr)->string) gf_free(((XMLRI *)a->far_ptr)->string);
  5752. if (((XMLRI *)b->far_ptr)->string) {
  5753. ((XMLRI *)a->far_ptr)->string = gf_strdup(((XMLRI *)b->far_ptr)->string);
  5754. } else {
  5755. ((XMLRI *)a->far_ptr)->string = gf_strdup("");
  5756. }
  5757. ((XMLRI *)a->far_ptr)->target = ((XMLRI *)b->far_ptr)->target;
  5758. if (((XMLRI *)a->far_ptr)->type == XMLRI_ELEMENTID) {
  5759. GF_Node *n = (GF_Node *) ((XMLRI *)b->far_ptr)->target;
  5760. /*TODO Check if assigning IRI from # scenegraph can happen*/
  5761. if (n) gf_node_register_iri(gf_node_get_graph(n), (XMLRI*)a->far_ptr);
  5762. }
  5763. return GF_OK;
  5764. case SVG_Focus_datatype:
  5765. {
  5766. ((SVG_Focus *)a->far_ptr)->type = ((SVG_Focus *)b->far_ptr)->type;
  5767. if ( ((SVG_Focus *)b->far_ptr)->target.string)
  5768. ((SVG_Focus *)a->far_ptr)->target.string = gf_strdup( ((SVG_Focus *)b->far_ptr)->target.string);
  5769. }
  5770. return GF_OK;
  5771. case SMIL_Times_datatype:
  5772. {
  5773. u32 i, count;
  5774. GF_List *dst = *(GF_List **)a->far_ptr;
  5775. GF_List *src = *(GF_List **)b->far_ptr;
  5776. while (gf_list_count(dst)) {
  5777. SMIL_Time *t = gf_list_get(dst, 0);
  5778. gf_list_rem(dst, 0);
  5779. gf_free(t);
  5780. }
  5781. count = gf_list_count(src);
  5782. for (i=0;i<count;i++) {
  5783. SMIL_Time *t2;
  5784. SMIL_Time *t = gf_list_get(src, i);
  5785. t2 = (SMIL_Time*)gf_malloc(sizeof(SMIL_Time));
  5786. memcpy(t2, t, sizeof(SMIL_Time));
  5787. gf_list_add(dst, t2);
  5788. }
  5789. }
  5790. return GF_OK;
  5791. case SMIL_AttributeName_datatype:
  5792. {
  5793. SMIL_AttributeName *saa = (SMIL_AttributeName *)a->far_ptr;
  5794. SMIL_AttributeName *sab = (SMIL_AttributeName *)b->far_ptr;
  5795. saa->tag = sab->tag;
  5796. saa->type = sab->type;
  5797. saa->name = sab->name ? gf_strdup(sab->name) : NULL;
  5798. }
  5799. break;
  5800. case SMIL_Duration_datatype:
  5801. {
  5802. SMIL_Duration *da = (SMIL_Duration*)a->far_ptr;
  5803. SMIL_Duration *db = (SMIL_Duration*)b->far_ptr;
  5804. da->type = db->type;
  5805. da->clock_value = db->clock_value;
  5806. }
  5807. break;
  5808. case SMIL_AnimateValue_datatype:
  5809. {
  5810. SMIL_AnimateValue *sa = (SMIL_AnimateValue*)a->far_ptr;
  5811. SMIL_AnimateValue *sb = (SMIL_AnimateValue*)b->far_ptr;
  5812. sa->type = sb->type;
  5813. if (sb->value) {
  5814. GF_FieldInfo ava, avb;
  5815. sa->value = gf_svg_create_attribute_value(sa->type);
  5816. ava.fieldIndex = avb.fieldIndex = 0;
  5817. ava.fieldType = avb.fieldType = sb->type;
  5818. ava.far_ptr = sa->value;
  5819. avb.far_ptr = sb->value;
  5820. gf_svg_attributes_copy(&ava, &avb, 0);
  5821. }
  5822. }
  5823. break;
  5824. /* Unsupported types */
  5825. case XMLRI_List_datatype:
  5826. case DOM_StringList_datatype:
  5827. case SVG_GradientOffset_datatype:
  5828. case SVG_Clock_datatype:
  5829. case SMIL_KeyTimes_datatype:
  5830. case SMIL_KeyPoints_datatype:
  5831. case SMIL_KeySplines_datatype:
  5832. case SMIL_AnimateValues_datatype:
  5833. case SMIL_RepeatCount_datatype:
  5834. default:
  5835. 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)));
  5836. return GF_OK;
  5837. }
  5838. return GF_OK;
  5839. }
  5840. /* c = a + b */
  5841. GF_Err gf_svg_attributes_add(GF_FieldInfo *a, GF_FieldInfo *b, GF_FieldInfo *c, Bool clamp)
  5842. {
  5843. return gf_svg_attributes_muladd(FIX_ONE, a, FIX_ONE, b, c, clamp);
  5844. }
  5845. Bool gf_svg_attribute_is_interpolatable(u32 type)
  5846. {
  5847. switch (type) {
  5848. /* additive types which can really be interpolated */
  5849. case SVG_Color_datatype:
  5850. case SVG_Paint_datatype:
  5851. case SVG_Number_datatype:
  5852. case SVG_Length_datatype:
  5853. case SVG_Coordinate_datatype:
  5854. case SVG_FontSize_datatype:
  5855. case SVG_ViewBox_datatype:
  5856. case SVG_Points_datatype:
  5857. case SVG_Numbers_datatype:
  5858. case SVG_Coordinates_datatype:
  5859. case SVG_PathData_datatype:
  5860. case SVG_Motion_datatype:
  5861. case SVG_Transform_datatype:
  5862. case SVG_Transform_Translate_datatype:
  5863. case SVG_Transform_Scale_datatype:
  5864. case SVG_Transform_Rotate_datatype:
  5865. case SVG_Transform_SkewX_datatype:
  5866. case SVG_Transform_SkewY_datatype:
  5867. case LASeR_Size_datatype:
  5868. return 1;
  5869. }
  5870. return 0;
  5871. }
  5872. GF_Err gf_svg_attributes_interpolate(GF_FieldInfo *a, GF_FieldInfo *b, GF_FieldInfo *c, Fixed coef, Bool clamp)
  5873. {
  5874. if (!a->far_ptr || !b->far_ptr || !c->far_ptr) return GF_BAD_PARAM;
  5875. c->fieldType = a->fieldType;
  5876. switch (a->fieldType) {
  5877. /* additive types which can really be interpolated */
  5878. case SVG_Color_datatype:
  5879. case SVG_Paint_datatype:
  5880. case SVG_Number_datatype:
  5881. case SVG_Length_datatype:
  5882. case SVG_Coordinate_datatype:
  5883. case SVG_FontSize_datatype:
  5884. case SVG_ViewBox_datatype:
  5885. case SVG_Points_datatype:
  5886. case SVG_Numbers_datatype:
  5887. case SVG_Coordinates_datatype:
  5888. case SVG_PathData_datatype:
  5889. case SVG_Motion_datatype:
  5890. case SVG_Transform_datatype:
  5891. case SVG_Transform_Translate_datatype:
  5892. case SVG_Transform_Scale_datatype:
  5893. case SVG_Transform_Rotate_datatype:
  5894. case SVG_Transform_SkewX_datatype:
  5895. case SVG_Transform_SkewY_datatype:
  5896. case LASeR_Size_datatype:
  5897. return gf_svg_attributes_muladd(FIX_ONE-coef, a, coef, b, c, clamp);
  5898. /* discrete types: interpolation is the selection of one of the 2 values
  5899. using the coeff and a the 0.5 threshold */
  5900. /* Keyword types */
  5901. case SVG_Boolean_datatype:
  5902. case SVG_FillRule_datatype:
  5903. case SVG_StrokeLineJoin_datatype:
  5904. case SVG_StrokeLineCap_datatype:
  5905. case SVG_FontStyle_datatype:
  5906. case SVG_FontWeight_datatype:
  5907. case SVG_FontVariant_datatype:
  5908. case SVG_TextAnchor_datatype:
  5909. case SVG_Display_datatype:
  5910. case SVG_Visibility_datatype:
  5911. case SVG_GradientUnit_datatype:
  5912. case SVG_PreserveAspectRatio_datatype:
  5913. case SVG_TransformType_datatype:
  5914. case XML_Space_datatype:
  5915. case XMLEV_Propagate_datatype:
  5916. case XMLEV_DefaultAction_datatype:
  5917. case XMLEV_Phase_datatype:
  5918. case SMIL_SyncBehavior_datatype:
  5919. case SMIL_SyncTolerance_datatype:
  5920. case SMIL_AttributeType_datatype:
  5921. case SMIL_CalcMode_datatype:
  5922. case SMIL_Additive_datatype:
  5923. case SMIL_Accumulate_datatype:
  5924. case SMIL_Restart_datatype:
  5925. case SMIL_Fill_datatype:
  5926. case SVG_Overflow_datatype:
  5927. case SVG_ZoomAndPan_datatype:
  5928. case SVG_DisplayAlign_datatype:
  5929. case SVG_TextAlign_datatype:
  5930. case SVG_PointerEvents_datatype:
  5931. case SVG_RenderingHint_datatype:
  5932. case SVG_VectorEffect_datatype:
  5933. case SVG_PlaybackOrder_datatype:
  5934. case SVG_TimelineBegin_datatype:
  5935. /* Other non keyword types but which can still be discretely interpolated */
  5936. case DOM_String_datatype:
  5937. case SVG_ContentType_datatype:
  5938. case SVG_LanguageID_datatype:
  5939. case SVG_FontFamily_datatype:
  5940. case XMLRI_datatype:
  5941. case XMLRI_List_datatype:
  5942. case DOM_StringList_datatype:
  5943. case SVG_Clock_datatype:
  5944. case SVG_ID_datatype:
  5945. case SVG_GradientOffset_datatype:
  5946. case LASeR_Choice_datatype:
  5947. if (coef < FIX_ONE/2) {
  5948. gf_svg_attributes_copy(c, a, clamp);
  5949. } else {
  5950. gf_svg_attributes_copy(c, b, clamp);
  5951. }
  5952. return GF_OK;
  5953. /* Unsupported types */
  5954. case SMIL_KeyTimes_datatype:
  5955. case SMIL_KeyPoints_datatype:
  5956. case SMIL_KeySplines_datatype:
  5957. case SMIL_AnimateValue_datatype:
  5958. case SMIL_AnimateValues_datatype:
  5959. case SMIL_AttributeName_datatype:
  5960. case SMIL_Times_datatype:
  5961. case SMIL_Duration_datatype:
  5962. case SMIL_RepeatCount_datatype:
  5963. default:
  5964. 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)));
  5965. return GF_OK;
  5966. }
  5967. return GF_OK;
  5968. }
  5969. Bool gf_svg_is_current_color(GF_FieldInfo *a)
  5970. {
  5971. switch (a->fieldType) {
  5972. case SVG_Color_datatype:
  5973. return (((SVG_Color *)a->far_ptr)->type == SVG_COLOR_CURRENTCOLOR);
  5974. break;
  5975. case SVG_Paint_datatype:
  5976. if ( ((SVG_Paint *)a->far_ptr)->type == SVG_PAINT_COLOR) {
  5977. return (((SVG_Paint *)a->far_ptr)->color.type == SVG_COLOR_CURRENTCOLOR);
  5978. } else {
  5979. return 0;
  5980. }
  5981. break;
  5982. }
  5983. return 0;
  5984. }
  5985. char *gf_svg_attribute_type_to_string(u32 att_type)
  5986. {
  5987. switch (att_type) {
  5988. case SVG_FillRule_datatype: return "FillRule";
  5989. case SVG_StrokeLineJoin_datatype: return "StrokeLineJoin";
  5990. case SVG_StrokeLineCap_datatype: return "StrokeLineCap";
  5991. case SVG_FontStyle_datatype: return "FontStyle";
  5992. case SVG_FontWeight_datatype: return "FontWeight";
  5993. case SVG_FontVariant_datatype: return "FontVariant";
  5994. case SVG_TextAnchor_datatype: return "TextAnchor";
  5995. case SVG_TransformType_datatype: return "TransformType";
  5996. case SVG_Display_datatype: return "Display";
  5997. case SVG_Visibility_datatype: return "Visibility";
  5998. case SVG_Overflow_datatype: return "Overflow";
  5999. case SVG_ZoomAndPan_datatype: return "ZoomAndPan";
  6000. case SVG_DisplayAlign_datatype: return "DisplayAlign";
  6001. case SVG_PointerEvents_datatype: return "PointerEvents";
  6002. case SVG_RenderingHint_datatype: return "RenderingHint";
  6003. case SVG_VectorEffect_datatype: return "VectorEffect";
  6004. case SVG_PlaybackOrder_datatype: return "PlaybackOrder";
  6005. case SVG_TimelineBegin_datatype: return "TimelineBegin";
  6006. case XML_Space_datatype: return "XML_Space";
  6007. case XMLEV_Propagate_datatype: return "XMLEV_Propagate";
  6008. case XMLEV_DefaultAction_datatype: return "XMLEV_DefaultAction";
  6009. case XMLEV_Phase_datatype: return "XMLEV_Phase";
  6010. case SMIL_SyncBehavior_datatype: return "SMIL_SyncBehavior";
  6011. case SMIL_SyncTolerance_datatype: return "SMIL_SyncTolerance";
  6012. case SMIL_AttributeType_datatype: return "SMIL_AttributeType";
  6013. case SMIL_CalcMode_datatype: return "SMIL_CalcMode";
  6014. case SMIL_Additive_datatype: return "SMIL_Additive";
  6015. case SMIL_Accumulate_datatype: return "SMIL_Accumulate";
  6016. case SMIL_Restart_datatype: return "SMIL_Restart";
  6017. case SMIL_Fill_datatype: return "SMIL_Fill";
  6018. case SVG_GradientUnit_datatype: return "GradientUnit";
  6019. case SVG_InitialVisibility_datatype:return "InitialVisibility";
  6020. case SVG_FocusHighlight_datatype: return "FocusHighlight";
  6021. case SVG_Overlay_datatype: return "Overlay";
  6022. case SVG_TransformBehavior_datatype:return "TransformBehavior";
  6023. case SVG_SpreadMethod_datatype: return "SpreadMethod";
  6024. case SVG_TextAlign_datatype: return "TextAlign";
  6025. case SVG_Number_datatype: return "Number";
  6026. case SVG_FontSize_datatype: return "FontSize";
  6027. case SVG_Length_datatype: return "Length";
  6028. case SVG_Coordinate_datatype: return "Coordinate";
  6029. case SVG_Rotate_datatype: return "Rotate";
  6030. case SVG_Numbers_datatype: return "Numbers";
  6031. case SVG_Points_datatype: return "Points";
  6032. case SVG_Coordinates_datatype: return "Coordinates";
  6033. case DOM_StringList_datatype: return "StringList";
  6034. case XMLRI_List_datatype: return "ListOfIRI";
  6035. case SMIL_KeyTimes_datatype: return "SMIL_KeyTimes";
  6036. case SMIL_KeySplines_datatype: return "SMIL_KeySplines";
  6037. case SMIL_KeyPoints_datatype: return "SMIL_KeyPoints";
  6038. case SMIL_Times_datatype: return "SMIL_Times";
  6039. case SMIL_AnimateValue_datatype: return "SMIL_AnimateValue";
  6040. case SMIL_AnimateValues_datatype: return "SMIL_AnimateValues";
  6041. case SMIL_Duration_datatype: return "SMIL_Duration";
  6042. case SMIL_RepeatCount_datatype: return "SMIL_RepeatCount";
  6043. case SMIL_AttributeName_datatype: return "SMIL_AttributeName";
  6044. case SVG_Boolean_datatype: return "Boolean";
  6045. case SVG_Color_datatype: return "Color";
  6046. case SVG_Paint_datatype: return "Paint";
  6047. case SVG_PathData_datatype: return "PathData";
  6048. case SVG_FontFamily_datatype: return "FontFamily";
  6049. case SVG_ID_datatype: return "ID";
  6050. case XMLRI_datatype: return "IRI";
  6051. case XML_IDREF_datatype: return "IDREF";
  6052. case SVG_StrokeDashArray_datatype: return "StrokeDashArray";
  6053. case SVG_PreserveAspectRatio_datatype:return "PreserveAspectRatio";
  6054. case SVG_ViewBox_datatype: return "ViewBox";
  6055. case SVG_GradientOffset_datatype: return "GradientOffset";
  6056. case SVG_Focus_datatype : return "Focus";
  6057. case SVG_Clock_datatype : return "Clock";
  6058. case DOM_String_datatype : return "String";
  6059. case SVG_ContentType_datatype: return "ContentType";
  6060. case SVG_LanguageID_datatype: return "LanguageID";
  6061. case XMLEV_Event_datatype: return "XMLEV_Event";
  6062. case SVG_Motion_datatype: return "Motion";
  6063. case SVG_Transform_datatype: return "Transform";
  6064. case SVG_Transform_Translate_datatype:return "Translate";
  6065. case SVG_Transform_Scale_datatype: return "Scale";
  6066. case SVG_Transform_SkewX_datatype: return "SkewX";
  6067. case SVG_Transform_SkewY_datatype: return "SkewY";
  6068. case SVG_Transform_Rotate_datatype: return "Rotate";
  6069. case LASeR_Choice_datatype: return "LASeR_Choice";
  6070. case LASeR_Size_datatype: return "LASeR_Size";
  6071. default: return "UnknownType";
  6072. }
  6073. }
  6074. #endif /*GPAC_DISABLE_SVG*/