File: | home/maarten/src/libreoffice/core/include/tools/ref.hxx |
Warning: | line 84, column 13 Use of memory after it is freed |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | ||||
2 | #include <com/sun/star/xml/sax/FastParser.hpp> | |||
3 | #include <com/sun/star/lang/XInitialization.hpp> | |||
4 | #include "ooxml/OOXMLFactory.hxx" | |||
5 | #include "ooxml/OOXMLFastHelper.hxx" | |||
6 | #include "ooxml/OOXMLStreamImpl.hxx" | |||
7 | ||||
8 | #include "OOXMLFactory_dml-stylesheet.hxx" | |||
9 | #include "OOXMLFactory_dml-styleDefaults.hxx" | |||
10 | #include "OOXMLFactory_dml-shape3DLighting.hxx" | |||
11 | #include "OOXMLFactory_dml-shape3DScene.hxx" | |||
12 | #include "OOXMLFactory_dml-shape3DStyles.hxx" | |||
13 | #include "OOXMLFactory_dml-shape3DCamera.hxx" | |||
14 | #include "OOXMLFactory_dml-baseStylesheet.hxx" | |||
15 | #include "OOXMLFactory_dml-textCharacter.hxx" | |||
16 | #include "OOXMLFactory_dml-shapeEffects.hxx" | |||
17 | #include "OOXMLFactory_dml-shapeLineProperties.hxx" | |||
18 | #include "OOXMLFactory_dml-shapeProperties.hxx" | |||
19 | #include "OOXMLFactory_dml-baseTypes.hxx" | |||
20 | #include "OOXMLFactory_dml-documentProperties.hxx" | |||
21 | #include "OOXMLFactory_dml-graphicalObject.hxx" | |||
22 | #include "OOXMLFactory_wp14.hxx" | |||
23 | #include "OOXMLFactory_w14.hxx" | |||
24 | #include "OOXMLFactory_a14.hxx" | |||
25 | #include "OOXMLFactory_dml-shapeGeometry.hxx" | |||
26 | #include "OOXMLFactory_dml-wordprocessingDrawing.hxx" | |||
27 | #include "OOXMLFactory_sml-customXmlMappings.hxx" | |||
28 | #include "OOXMLFactory_shared-math.hxx" | |||
29 | #include "OOXMLFactory_shared-relationshipReference.hxx" | |||
30 | #include "OOXMLFactory_dml-chartDrawing.hxx" | |||
31 | #include "OOXMLFactory_vml-main.hxx" | |||
32 | #include "OOXMLFactory_vml-officeDrawing.hxx" | |||
33 | #include "OOXMLFactory_vml-wordprocessingDrawing.hxx" | |||
34 | #include "OOXMLFactory_wml.hxx" | |||
35 | namespace writerfilter { | |||
36 | namespace ooxml { | |||
37 | ||||
38 | using namespace com::sun::star; | |||
39 | ||||
40 | /// @cond GENERATED | |||
41 | ||||
42 | uno::Reference<xml::sax::XFastContextHandler> OOXMLFactory::createFastChildContextFromFactory | |||
43 | (OOXMLFastContextHandler* pHandler, OOXMLFactory_ns::Pointer_t pFactory, Token_t Element) | |||
44 | { | |||
45 | uno::Reference <xml::sax::XFastContextHandler> aResult; | |||
46 | const Id nDefine = pHandler->getDefine(); | |||
47 | ||||
48 | if (pFactory.get() != NULL__null) | |||
| ||||
49 | { | |||
50 | ResourceType nResource; | |||
51 | Id nElementId; | |||
52 | if (pFactory->getElementId(nDefine, Element, nResource, nElementId)) | |||
53 | { | |||
54 | const Id nId = pFactory->getResourceId(nDefine, Element); | |||
55 | ||||
56 | switch (nResource) | |||
57 | { | |||
58 | case ResourceType::Table: | |||
59 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerTable>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
60 | break; | |||
61 | case ResourceType::Properties: | |||
62 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerProperties>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
63 | break; | |||
64 | case ResourceType::Stream: | |||
65 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerStream>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
66 | break; | |||
67 | case ResourceType::Value: | |||
68 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerValue>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
69 | break; | |||
70 | case ResourceType::Shape: | |||
71 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerShape>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
72 | break; | |||
73 | case ResourceType::XNote: | |||
74 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerXNote>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
75 | break; | |||
76 | case ResourceType::TextTableCell: | |||
77 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerTextTableCell>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
78 | break; | |||
79 | case ResourceType::TextTableRow: | |||
80 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerTextTableRow>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
81 | break; | |||
82 | case ResourceType::TextTable: | |||
83 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerTextTable>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
84 | break; | |||
85 | case ResourceType::PropertyTable: | |||
86 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerPropertyTable>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
87 | break; | |||
88 | case ResourceType::Math: | |||
89 | aResult.set(OOXMLFastHelper<OOXMLFastContextHandlerMath>::createAndSetParentAndDefine(pHandler, Element, nId, nElementId)); | |||
90 | break; | |||
91 | case ResourceType::Any: | |||
92 | aResult.set(createFastChildContextFromStart(pHandler, Element)); | |||
93 | break; | |||
94 | default: | |||
95 | break; | |||
96 | } | |||
97 | ||||
98 | } | |||
99 | } | |||
100 | ||||
101 | return aResult; | |||
102 | } | |||
103 | ||||
104 | OOXMLFactory_ns::Pointer_t OOXMLFactory::getFactoryForNamespace(Id nId) | |||
105 | { | |||
106 | OOXMLFactory_ns::Pointer_t pResult; | |||
107 | ||||
108 | switch (oox::getNamespace(nId)) | |||
109 | { | |||
110 | case NN_dml_stylesheet: | |||
111 | pResult = OOXMLFactory_dml_stylesheet::getInstance(); | |||
112 | break; | |||
113 | case NN_dml_styleDefaults: | |||
114 | pResult = OOXMLFactory_dml_styleDefaults::getInstance(); | |||
115 | break; | |||
116 | case NN_dml_shape3DLighting: | |||
117 | pResult = OOXMLFactory_dml_shape3DLighting::getInstance(); | |||
118 | break; | |||
119 | case NN_dml_shape3DScene: | |||
120 | pResult = OOXMLFactory_dml_shape3DScene::getInstance(); | |||
121 | break; | |||
122 | case NN_dml_shape3DStyles: | |||
123 | pResult = OOXMLFactory_dml_shape3DStyles::getInstance(); | |||
124 | break; | |||
125 | case NN_dml_shape3DCamera: | |||
126 | pResult = OOXMLFactory_dml_shape3DCamera::getInstance(); | |||
127 | break; | |||
128 | case NN_dml_baseStylesheet: | |||
129 | pResult = OOXMLFactory_dml_baseStylesheet::getInstance(); | |||
130 | break; | |||
131 | case NN_dml_textCharacter: | |||
132 | pResult = OOXMLFactory_dml_textCharacter::getInstance(); | |||
133 | break; | |||
134 | case NN_dml_shapeEffects: | |||
135 | pResult = OOXMLFactory_dml_shapeEffects::getInstance(); | |||
136 | break; | |||
137 | case NN_dml_shapeLineProperties: | |||
138 | pResult = OOXMLFactory_dml_shapeLineProperties::getInstance(); | |||
139 | break; | |||
140 | case NN_dml_shapeProperties: | |||
141 | pResult = OOXMLFactory_dml_shapeProperties::getInstance(); | |||
142 | break; | |||
143 | case NN_dml_baseTypes: | |||
144 | pResult = OOXMLFactory_dml_baseTypes::getInstance(); | |||
145 | break; | |||
146 | case NN_dml_documentProperties: | |||
147 | pResult = OOXMLFactory_dml_documentProperties::getInstance(); | |||
148 | break; | |||
149 | case NN_dml_graphicalObject: | |||
150 | pResult = OOXMLFactory_dml_graphicalObject::getInstance(); | |||
151 | break; | |||
152 | case NN_wp14: | |||
153 | pResult = OOXMLFactory_wp14::getInstance(); | |||
154 | break; | |||
155 | case NN_w14: | |||
156 | pResult = OOXMLFactory_w14::getInstance(); | |||
157 | break; | |||
158 | case NN_a14: | |||
159 | pResult = OOXMLFactory_a14::getInstance(); | |||
160 | break; | |||
161 | case NN_dml_shapeGeometry: | |||
162 | pResult = OOXMLFactory_dml_shapeGeometry::getInstance(); | |||
163 | break; | |||
164 | case NN_dml_wordprocessingDrawing: | |||
165 | pResult = OOXMLFactory_dml_wordprocessingDrawing::getInstance(); | |||
166 | break; | |||
167 | case NN_sml_customXmlMappings: | |||
168 | pResult = OOXMLFactory_sml_customXmlMappings::getInstance(); | |||
169 | break; | |||
170 | case NN_shared_math: | |||
171 | pResult = OOXMLFactory_shared_math::getInstance(); | |||
172 | break; | |||
173 | case NN_shared_relationshipReference: | |||
174 | pResult = OOXMLFactory_shared_relationshipReference::getInstance(); | |||
175 | break; | |||
176 | case NN_dml_chartDrawing: | |||
177 | pResult = OOXMLFactory_dml_chartDrawing::getInstance(); | |||
178 | break; | |||
179 | case NN_vml_main: | |||
180 | pResult = OOXMLFactory_vml_main::getInstance(); | |||
181 | break; | |||
182 | case NN_vml_officeDrawing: | |||
183 | pResult = OOXMLFactory_vml_officeDrawing::getInstance(); | |||
184 | break; | |||
185 | case NN_vml_wordprocessingDrawing: | |||
186 | pResult = OOXMLFactory_vml_wordprocessingDrawing::getInstance(); | |||
187 | break; | |||
188 | case NN_wml: | |||
189 | pResult = OOXMLFactory_wml::getInstance(); | |||
190 | break; | |||
191 | default: | |||
192 | break; | |||
193 | } | |||
194 | ||||
195 | return pResult; | |||
196 | } | |||
197 | ||||
198 | uno::Reference<xml::sax::XFastContextHandler> OOXMLFactory::createFastChildContextFromStart | |||
199 | (OOXMLFastContextHandler* pHandler, Token_t Element) | |||
200 | { | |||
201 | uno::Reference<xml::sax::XFastContextHandler> aResult; | |||
202 | OOXMLFactory_ns::Pointer_t pFactory; | |||
203 | ||||
204 | ||||
205 | if (!aResult.is()) | |||
206 | { | |||
207 | pFactory = getFactoryForNamespace(NN_dml_stylesheet); | |||
208 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
209 | } | |||
210 | if (!aResult.is()) | |||
211 | { | |||
212 | pFactory = getFactoryForNamespace(NN_dml_styleDefaults); | |||
213 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
214 | } | |||
215 | if (!aResult.is()) | |||
216 | { | |||
217 | pFactory = getFactoryForNamespace(NN_dml_shape3DLighting); | |||
218 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
219 | } | |||
220 | if (!aResult.is()) | |||
221 | { | |||
222 | pFactory = getFactoryForNamespace(NN_dml_shape3DScene); | |||
223 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
224 | } | |||
225 | if (!aResult.is()) | |||
226 | { | |||
227 | pFactory = getFactoryForNamespace(NN_dml_shape3DStyles); | |||
228 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
229 | } | |||
230 | if (!aResult.is()) | |||
231 | { | |||
232 | pFactory = getFactoryForNamespace(NN_dml_shape3DCamera); | |||
233 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
234 | } | |||
235 | if (!aResult.is()) | |||
236 | { | |||
237 | pFactory = getFactoryForNamespace(NN_dml_baseStylesheet); | |||
238 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
239 | } | |||
240 | if (!aResult.is()) | |||
241 | { | |||
242 | pFactory = getFactoryForNamespace(NN_dml_textCharacter); | |||
243 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
244 | } | |||
245 | if (!aResult.is()) | |||
246 | { | |||
247 | pFactory = getFactoryForNamespace(NN_dml_shapeEffects); | |||
248 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
249 | } | |||
250 | if (!aResult.is()) | |||
251 | { | |||
252 | pFactory = getFactoryForNamespace(NN_dml_shapeLineProperties); | |||
253 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
254 | } | |||
255 | if (!aResult.is()) | |||
256 | { | |||
257 | pFactory = getFactoryForNamespace(NN_dml_shapeProperties); | |||
258 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
259 | } | |||
260 | if (!aResult.is()) | |||
261 | { | |||
262 | pFactory = getFactoryForNamespace(NN_dml_baseTypes); | |||
263 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
264 | } | |||
265 | if (!aResult.is()) | |||
266 | { | |||
267 | pFactory = getFactoryForNamespace(NN_dml_documentProperties); | |||
268 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
269 | } | |||
270 | if (!aResult.is()) | |||
271 | { | |||
272 | pFactory = getFactoryForNamespace(NN_dml_graphicalObject); | |||
273 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
274 | } | |||
275 | if (!aResult.is()) | |||
276 | { | |||
277 | pFactory = getFactoryForNamespace(NN_wp14); | |||
278 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
279 | } | |||
280 | if (!aResult.is()) | |||
281 | { | |||
282 | pFactory = getFactoryForNamespace(NN_w14); | |||
283 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
284 | } | |||
285 | if (!aResult.is()) | |||
286 | { | |||
287 | pFactory = getFactoryForNamespace(NN_a14); | |||
288 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
289 | } | |||
290 | if (!aResult.is()) | |||
291 | { | |||
292 | pFactory = getFactoryForNamespace(NN_dml_shapeGeometry); | |||
293 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
294 | } | |||
295 | if (!aResult.is()) | |||
296 | { | |||
297 | pFactory = getFactoryForNamespace(NN_dml_wordprocessingDrawing); | |||
298 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
299 | } | |||
300 | if (!aResult.is()) | |||
301 | { | |||
302 | pFactory = getFactoryForNamespace(NN_sml_customXmlMappings); | |||
303 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
304 | } | |||
305 | if (!aResult.is()) | |||
306 | { | |||
307 | pFactory = getFactoryForNamespace(NN_shared_math); | |||
308 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
309 | } | |||
310 | if (!aResult.is()) | |||
311 | { | |||
312 | pFactory = getFactoryForNamespace(NN_shared_relationshipReference); | |||
313 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
314 | } | |||
315 | if (!aResult.is()) | |||
316 | { | |||
317 | pFactory = getFactoryForNamespace(NN_dml_chartDrawing); | |||
318 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
319 | } | |||
320 | if (!aResult.is()) | |||
321 | { | |||
322 | pFactory = getFactoryForNamespace(NN_vml_main); | |||
323 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
324 | } | |||
325 | if (!aResult.is()) | |||
326 | { | |||
327 | pFactory = getFactoryForNamespace(NN_vml_officeDrawing); | |||
328 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
329 | } | |||
330 | if (!aResult.is()) | |||
331 | { | |||
332 | pFactory = getFactoryForNamespace(NN_vml_wordprocessingDrawing); | |||
333 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
334 | } | |||
335 | if (!aResult.is()) | |||
336 | { | |||
337 | pFactory = getFactoryForNamespace(NN_wml); | |||
338 | aResult.set(createFastChildContextFromFactory(pHandler, pFactory, Element)); | |||
339 | } | |||
340 | ||||
341 | return aResult; | |||
342 | } | |||
343 | ||||
344 | ||||
345 | std::string fastTokenToId(sal_uInt32 nToken) | |||
346 | { | |||
347 | std::string sResult; | |||
348 | #ifdef DBG_UTIL | |||
349 | ||||
350 | switch (oox::getNamespace(nToken)) | |||
351 | { | |||
352 | case oox::NMSP_a14: | |||
353 | sResult += "a14:"; | |||
354 | break; | |||
355 | case oox::NMSP_ax: | |||
356 | sResult += "ax:"; | |||
357 | break; | |||
358 | case oox::NMSP_c15: | |||
359 | sResult += "c15:"; | |||
360 | break; | |||
361 | case oox::NMSP_dc: | |||
362 | sResult += "dc:"; | |||
363 | break; | |||
364 | case oox::NMSP_dcTerms: | |||
365 | sResult += "dcTerms:"; | |||
366 | break; | |||
367 | case oox::NMSP_dcmiType: | |||
368 | sResult += "dcmiType:"; | |||
369 | break; | |||
370 | case oox::NMSP_dml: | |||
371 | sResult += "dml:"; | |||
372 | break; | |||
373 | case oox::NMSP_dmlChart: | |||
374 | sResult += "dmlChart:"; | |||
375 | break; | |||
376 | case oox::NMSP_dmlChartDr: | |||
377 | sResult += "dmlChartDr:"; | |||
378 | break; | |||
379 | case oox::NMSP_dmlDiagram: | |||
380 | sResult += "dmlDiagram:"; | |||
381 | break; | |||
382 | case oox::NMSP_dmlLockedCanvas: | |||
383 | sResult += "dmlLockedCanvas:"; | |||
384 | break; | |||
385 | case oox::NMSP_dmlPicture: | |||
386 | sResult += "dmlPicture:"; | |||
387 | break; | |||
388 | case oox::NMSP_dmlSpreadDr: | |||
389 | sResult += "dmlSpreadDr:"; | |||
390 | break; | |||
391 | case oox::NMSP_dmlWordDr: | |||
392 | sResult += "dmlWordDr:"; | |||
393 | break; | |||
394 | case oox::NMSP_doc: | |||
395 | sResult += "doc:"; | |||
396 | break; | |||
397 | case oox::NMSP_dsp: | |||
398 | sResult += "dsp:"; | |||
399 | break; | |||
400 | case oox::NMSP_loext: | |||
401 | sResult += "loext:"; | |||
402 | break; | |||
403 | case oox::NMSP_mce: | |||
404 | sResult += "mce:"; | |||
405 | break; | |||
406 | case oox::NMSP_mceTest: | |||
407 | sResult += "mceTest:"; | |||
408 | break; | |||
409 | case oox::NMSP_officeCustomPr: | |||
410 | sResult += "officeCustomPr:"; | |||
411 | break; | |||
412 | case oox::NMSP_officeDocPropsVT: | |||
413 | sResult += "officeDocPropsVT:"; | |||
414 | break; | |||
415 | case oox::NMSP_officeExtPr: | |||
416 | sResult += "officeExtPr:"; | |||
417 | break; | |||
418 | case oox::NMSP_officeMath: | |||
419 | sResult += "officeMath:"; | |||
420 | break; | |||
421 | case oox::NMSP_officeRel: | |||
422 | sResult += "officeRel:"; | |||
423 | break; | |||
424 | case oox::NMSP_officeRelTheme: | |||
425 | sResult += "officeRelTheme:"; | |||
426 | break; | |||
427 | case oox::NMSP_p14: | |||
428 | sResult += "p14:"; | |||
429 | break; | |||
430 | case oox::NMSP_p15: | |||
431 | sResult += "p15:"; | |||
432 | break; | |||
433 | case oox::NMSP_packageContentTypes: | |||
434 | sResult += "packageContentTypes:"; | |||
435 | break; | |||
436 | case oox::NMSP_packageMetaCorePr: | |||
437 | sResult += "packageMetaCorePr:"; | |||
438 | break; | |||
439 | case oox::NMSP_packageRel: | |||
440 | sResult += "packageRel:"; | |||
441 | break; | |||
442 | case oox::NMSP_ppt: | |||
443 | sResult += "ppt:"; | |||
444 | break; | |||
445 | case oox::NMSP_schema: | |||
446 | sResult += "schema:"; | |||
447 | break; | |||
448 | case oox::NMSP_vml: | |||
449 | sResult += "vml:"; | |||
450 | break; | |||
451 | case oox::NMSP_vmlExcel: | |||
452 | sResult += "vmlExcel:"; | |||
453 | break; | |||
454 | case oox::NMSP_vmlOffice: | |||
455 | sResult += "vmlOffice:"; | |||
456 | break; | |||
457 | case oox::NMSP_vmlPowerpoint: | |||
458 | sResult += "vmlPowerpoint:"; | |||
459 | break; | |||
460 | case oox::NMSP_vmlWord: | |||
461 | sResult += "vmlWord:"; | |||
462 | break; | |||
463 | case oox::NMSP_w14: | |||
464 | sResult += "w14:"; | |||
465 | break; | |||
466 | case oox::NMSP_wp14: | |||
467 | sResult += "wp14:"; | |||
468 | break; | |||
469 | case oox::NMSP_wpg: | |||
470 | sResult += "wpg:"; | |||
471 | break; | |||
472 | case oox::NMSP_wps: | |||
473 | sResult += "wps:"; | |||
474 | break; | |||
475 | case oox::NMSP_x12ac: | |||
476 | sResult += "x12ac:"; | |||
477 | break; | |||
478 | case oox::NMSP_xls: | |||
479 | sResult += "xls:"; | |||
480 | break; | |||
481 | case oox::NMSP_xls14Lst: | |||
482 | sResult += "xls14Lst:"; | |||
483 | break; | |||
484 | case oox::NMSP_xm: | |||
485 | sResult += "xm:"; | |||
486 | break; | |||
487 | case oox::NMSP_xml: | |||
488 | sResult += "xml:"; | |||
489 | break; | |||
490 | case oox::NMSP_xsi: | |||
491 | sResult += "xsi:"; | |||
492 | break; | |||
493 | } | |||
494 | ||||
495 | switch (nToken & 0xffff) | |||
496 | { | |||
497 | case oox::XML_extLst: | |||
498 | sResult += "extLst"; | |||
499 | break; | |||
500 | case oox::XML_bg1: | |||
501 | sResult += "bg1"; | |||
502 | break; | |||
503 | case oox::XML_tx1: | |||
504 | sResult += "tx1"; | |||
505 | break; | |||
506 | case oox::XML_bg2: | |||
507 | sResult += "bg2"; | |||
508 | break; | |||
509 | case oox::XML_tx2: | |||
510 | sResult += "tx2"; | |||
511 | break; | |||
512 | case oox::XML_accent1: | |||
513 | sResult += "accent1"; | |||
514 | break; | |||
515 | case oox::XML_accent2: | |||
516 | sResult += "accent2"; | |||
517 | break; | |||
518 | case oox::XML_accent3: | |||
519 | sResult += "accent3"; | |||
520 | break; | |||
521 | case oox::XML_accent4: | |||
522 | sResult += "accent4"; | |||
523 | break; | |||
524 | case oox::XML_accent5: | |||
525 | sResult += "accent5"; | |||
526 | break; | |||
527 | case oox::XML_accent6: | |||
528 | sResult += "accent6"; | |||
529 | break; | |||
530 | case oox::XML_hlink: | |||
531 | sResult += "hlink"; | |||
532 | break; | |||
533 | case oox::XML_folHlink: | |||
534 | sResult += "folHlink"; | |||
535 | break; | |||
536 | case oox::XML_masterClrMapping: | |||
537 | sResult += "masterClrMapping"; | |||
538 | break; | |||
539 | case oox::XML_overrideClrMapping: | |||
540 | sResult += "overrideClrMapping"; | |||
541 | break; | |||
542 | case oox::XML_clrScheme: | |||
543 | sResult += "clrScheme"; | |||
544 | break; | |||
545 | case oox::XML_clrMap: | |||
546 | sResult += "clrMap"; | |||
547 | break; | |||
548 | case oox::XML_extraClrScheme: | |||
549 | sResult += "extraClrScheme"; | |||
550 | break; | |||
551 | case oox::XML_themeElements: | |||
552 | sResult += "themeElements"; | |||
553 | break; | |||
554 | case oox::XML_objectDefaults: | |||
555 | sResult += "objectDefaults"; | |||
556 | break; | |||
557 | case oox::XML_extraClrSchemeLst: | |||
558 | sResult += "extraClrSchemeLst"; | |||
559 | break; | |||
560 | case oox::XML_custClrLst: | |||
561 | sResult += "custClrLst"; | |||
562 | break; | |||
563 | case oox::XML_name: | |||
564 | sResult += "name"; | |||
565 | break; | |||
566 | case oox::XML_fontScheme: | |||
567 | sResult += "fontScheme"; | |||
568 | break; | |||
569 | case oox::XML_fmtScheme: | |||
570 | sResult += "fmtScheme"; | |||
571 | break; | |||
572 | case oox::XML_id: | |||
573 | sResult += "id"; | |||
574 | break; | |||
575 | case oox::XML_theme: | |||
576 | sResult += "theme"; | |||
577 | break; | |||
578 | case oox::XML_themeOverride: | |||
579 | sResult += "themeOverride"; | |||
580 | break; | |||
581 | case oox::XML_themeManager: | |||
582 | sResult += "themeManager"; | |||
583 | break; | |||
584 | case oox::XML_hlinkClick: | |||
585 | sResult += "hlinkClick"; | |||
586 | break; | |||
587 | case oox::XML_spPr: | |||
588 | sResult += "spPr"; | |||
589 | break; | |||
590 | case oox::XML_spDef: | |||
591 | sResult += "spDef"; | |||
592 | break; | |||
593 | case oox::XML_lnDef: | |||
594 | sResult += "lnDef"; | |||
595 | break; | |||
596 | case oox::XML_txDef: | |||
597 | sResult += "txDef"; | |||
598 | break; | |||
599 | case oox::XML_rot: | |||
600 | sResult += "rot"; | |||
601 | break; | |||
602 | case oox::XML_rig: | |||
603 | sResult += "rig"; | |||
604 | break; | |||
605 | case oox::XML_dir: | |||
606 | sResult += "dir"; | |||
607 | break; | |||
608 | case oox::XML_camera: | |||
609 | sResult += "camera"; | |||
610 | break; | |||
611 | case oox::XML_lightRig: | |||
612 | sResult += "lightRig"; | |||
613 | break; | |||
614 | case oox::XML_w: | |||
615 | sResult += "w"; | |||
616 | break; | |||
617 | case oox::XML_h: | |||
618 | sResult += "h"; | |||
619 | break; | |||
620 | case oox::XML_prst: | |||
621 | sResult += "prst"; | |||
622 | break; | |||
623 | case oox::XML_bevelT: | |||
624 | sResult += "bevelT"; | |||
625 | break; | |||
626 | case oox::XML_bevelB: | |||
627 | sResult += "bevelB"; | |||
628 | break; | |||
629 | case oox::XML_extrusionClr: | |||
630 | sResult += "extrusionClr"; | |||
631 | break; | |||
632 | case oox::XML_contourClr: | |||
633 | sResult += "contourClr"; | |||
634 | break; | |||
635 | case oox::XML_z: | |||
636 | sResult += "z"; | |||
637 | break; | |||
638 | case oox::XML_extrusionH: | |||
639 | sResult += "extrusionH"; | |||
640 | break; | |||
641 | case oox::XML_contourW: | |||
642 | sResult += "contourW"; | |||
643 | break; | |||
644 | case oox::XML_prstMaterial: | |||
645 | sResult += "prstMaterial"; | |||
646 | break; | |||
647 | case oox::XML_sp3d: | |||
648 | sResult += "sp3d"; | |||
649 | break; | |||
650 | case oox::XML_flatTx: | |||
651 | sResult += "flatTx"; | |||
652 | break; | |||
653 | case oox::XML_fov: | |||
654 | sResult += "fov"; | |||
655 | break; | |||
656 | case oox::XML_zoom: | |||
657 | sResult += "zoom"; | |||
658 | break; | |||
659 | case oox::XML_dk1: | |||
660 | sResult += "dk1"; | |||
661 | break; | |||
662 | case oox::XML_lt1: | |||
663 | sResult += "lt1"; | |||
664 | break; | |||
665 | case oox::XML_dk2: | |||
666 | sResult += "dk2"; | |||
667 | break; | |||
668 | case oox::XML_lt2: | |||
669 | sResult += "lt2"; | |||
670 | break; | |||
671 | case oox::XML_script: | |||
672 | sResult += "script"; | |||
673 | break; | |||
674 | case oox::XML_typeface: | |||
675 | sResult += "typeface"; | |||
676 | break; | |||
677 | case oox::XML_custClr: | |||
678 | sResult += "custClr"; | |||
679 | break; | |||
680 | case oox::XML_latin: | |||
681 | sResult += "latin"; | |||
682 | break; | |||
683 | case oox::XML_ea: | |||
684 | sResult += "ea"; | |||
685 | break; | |||
686 | case oox::XML_cs: | |||
687 | sResult += "cs"; | |||
688 | break; | |||
689 | case oox::XML_font: | |||
690 | sResult += "font"; | |||
691 | break; | |||
692 | case oox::XML_scene3d: | |||
693 | sResult += "scene3d"; | |||
694 | break; | |||
695 | case oox::XML_majorFont: | |||
696 | sResult += "majorFont"; | |||
697 | break; | |||
698 | case oox::XML_minorFont: | |||
699 | sResult += "minorFont"; | |||
700 | break; | |||
701 | case oox::XML_ln: | |||
702 | sResult += "ln"; | |||
703 | break; | |||
704 | case oox::XML_effectStyle: | |||
705 | sResult += "effectStyle"; | |||
706 | break; | |||
707 | case oox::XML_fillStyleLst: | |||
708 | sResult += "fillStyleLst"; | |||
709 | break; | |||
710 | case oox::XML_lnStyleLst: | |||
711 | sResult += "lnStyleLst"; | |||
712 | break; | |||
713 | case oox::XML_effectStyleLst: | |||
714 | sResult += "effectStyleLst"; | |||
715 | break; | |||
716 | case oox::XML_bgFillStyleLst: | |||
717 | sResult += "bgFillStyleLst"; | |||
718 | break; | |||
719 | case oox::XML_panose: | |||
720 | sResult += "panose"; | |||
721 | break; | |||
722 | case oox::XML_pitchFamily: | |||
723 | sResult += "pitchFamily"; | |||
724 | break; | |||
725 | case oox::XML_charset: | |||
726 | sResult += "charset"; | |||
727 | break; | |||
728 | case oox::XML_uLnTx: | |||
729 | sResult += "uLnTx"; | |||
730 | break; | |||
731 | case oox::XML_uLn: | |||
732 | sResult += "uLn"; | |||
733 | break; | |||
734 | case oox::XML_uFillTx: | |||
735 | sResult += "uFillTx"; | |||
736 | break; | |||
737 | case oox::XML_uFill: | |||
738 | sResult += "uFill"; | |||
739 | break; | |||
740 | case oox::XML_highlight: | |||
741 | sResult += "highlight"; | |||
742 | break; | |||
743 | case oox::XML_sym: | |||
744 | sResult += "sym"; | |||
745 | break; | |||
746 | case oox::XML_hlinkMouseOver: | |||
747 | sResult += "hlinkMouseOver"; | |||
748 | break; | |||
749 | case oox::XML_kumimoji: | |||
750 | sResult += "kumimoji"; | |||
751 | break; | |||
752 | case oox::XML_lang: | |||
753 | sResult += "lang"; | |||
754 | break; | |||
755 | case oox::XML_altLang: | |||
756 | sResult += "altLang"; | |||
757 | break; | |||
758 | case oox::XML_sz: | |||
759 | sResult += "sz"; | |||
760 | break; | |||
761 | case oox::XML_b: | |||
762 | sResult += "b"; | |||
763 | break; | |||
764 | case oox::XML_i: | |||
765 | sResult += "i"; | |||
766 | break; | |||
767 | case oox::XML_u: | |||
768 | sResult += "u"; | |||
769 | break; | |||
770 | case oox::XML_strike: | |||
771 | sResult += "strike"; | |||
772 | break; | |||
773 | case oox::XML_kern: | |||
774 | sResult += "kern"; | |||
775 | break; | |||
776 | case oox::XML_cap: | |||
777 | sResult += "cap"; | |||
778 | break; | |||
779 | case oox::XML_spc: | |||
780 | sResult += "spc"; | |||
781 | break; | |||
782 | case oox::XML_normalizeH: | |||
783 | sResult += "normalizeH"; | |||
784 | break; | |||
785 | case oox::XML_baseline: | |||
786 | sResult += "baseline"; | |||
787 | break; | |||
788 | case oox::XML_noProof: | |||
789 | sResult += "noProof"; | |||
790 | break; | |||
791 | case oox::XML_dirty: | |||
792 | sResult += "dirty"; | |||
793 | break; | |||
794 | case oox::XML_err: | |||
795 | sResult += "err"; | |||
796 | break; | |||
797 | case oox::XML_smtClean: | |||
798 | sResult += "smtClean"; | |||
799 | break; | |||
800 | case oox::XML_smtId: | |||
801 | sResult += "smtId"; | |||
802 | break; | |||
803 | case oox::XML_bmk: | |||
804 | sResult += "bmk"; | |||
805 | break; | |||
806 | case oox::XML_thresh: | |||
807 | sResult += "thresh"; | |||
808 | break; | |||
809 | case oox::XML_amt: | |||
810 | sResult += "amt"; | |||
811 | break; | |||
812 | case oox::XML_rad: | |||
813 | sResult += "rad"; | |||
814 | break; | |||
815 | case oox::XML_a: | |||
816 | sResult += "a"; | |||
817 | break; | |||
818 | case oox::XML_grow: | |||
819 | sResult += "grow"; | |||
820 | break; | |||
821 | case oox::XML_clrFrom: | |||
822 | sResult += "clrFrom"; | |||
823 | break; | |||
824 | case oox::XML_clrTo: | |||
825 | sResult += "clrTo"; | |||
826 | break; | |||
827 | case oox::XML_useA: | |||
828 | sResult += "useA"; | |||
829 | break; | |||
830 | case oox::XML_hue: | |||
831 | sResult += "hue"; | |||
832 | break; | |||
833 | case oox::XML_sat: | |||
834 | sResult += "sat"; | |||
835 | break; | |||
836 | case oox::XML_lum: | |||
837 | sResult += "lum"; | |||
838 | break; | |||
839 | case oox::XML_blurRad: | |||
840 | sResult += "blurRad"; | |||
841 | break; | |||
842 | case oox::XML_dist: | |||
843 | sResult += "dist"; | |||
844 | break; | |||
845 | case oox::XML_bright: | |||
846 | sResult += "bright"; | |||
847 | break; | |||
848 | case oox::XML_contrast: | |||
849 | sResult += "contrast"; | |||
850 | break; | |||
851 | case oox::XML_sx: | |||
852 | sResult += "sx"; | |||
853 | break; | |||
854 | case oox::XML_sy: | |||
855 | sResult += "sy"; | |||
856 | break; | |||
857 | case oox::XML_kx: | |||
858 | sResult += "kx"; | |||
859 | break; | |||
860 | case oox::XML_ky: | |||
861 | sResult += "ky"; | |||
862 | break; | |||
863 | case oox::XML_algn: | |||
864 | sResult += "algn"; | |||
865 | break; | |||
866 | case oox::XML_rotWithShape: | |||
867 | sResult += "rotWithShape"; | |||
868 | break; | |||
869 | case oox::XML_stA: | |||
870 | sResult += "stA"; | |||
871 | break; | |||
872 | case oox::XML_stPos: | |||
873 | sResult += "stPos"; | |||
874 | break; | |||
875 | case oox::XML_endA: | |||
876 | sResult += "endA"; | |||
877 | break; | |||
878 | case oox::XML_endPos: | |||
879 | sResult += "endPos"; | |||
880 | break; | |||
881 | case oox::XML_fadeDir: | |||
882 | sResult += "fadeDir"; | |||
883 | break; | |||
884 | case oox::XML_tx: | |||
885 | sResult += "tx"; | |||
886 | break; | |||
887 | case oox::XML_ty: | |||
888 | sResult += "ty"; | |||
889 | break; | |||
890 | case oox::XML_ang: | |||
891 | sResult += "ang"; | |||
892 | break; | |||
893 | case oox::XML_scaled: | |||
894 | sResult += "scaled"; | |||
895 | break; | |||
896 | case oox::XML_fillToRect: | |||
897 | sResult += "fillToRect"; | |||
898 | break; | |||
899 | case oox::XML_path: | |||
900 | sResult += "path"; | |||
901 | break; | |||
902 | case oox::XML_lin: | |||
903 | sResult += "lin"; | |||
904 | break; | |||
905 | case oox::XML_pos: | |||
906 | sResult += "pos"; | |||
907 | break; | |||
908 | case oox::XML_gs: | |||
909 | sResult += "gs"; | |||
910 | break; | |||
911 | case oox::XML_gsLst: | |||
912 | sResult += "gsLst"; | |||
913 | break; | |||
914 | case oox::XML_tileRect: | |||
915 | sResult += "tileRect"; | |||
916 | break; | |||
917 | case oox::XML_flip: | |||
918 | sResult += "flip"; | |||
919 | break; | |||
920 | case oox::XML_fillRect: | |||
921 | sResult += "fillRect"; | |||
922 | break; | |||
923 | case oox::XML_tile: | |||
924 | sResult += "tile"; | |||
925 | break; | |||
926 | case oox::XML_stretch: | |||
927 | sResult += "stretch"; | |||
928 | break; | |||
929 | case oox::XML_alphaBiLevel: | |||
930 | sResult += "alphaBiLevel"; | |||
931 | break; | |||
932 | case oox::XML_alphaCeiling: | |||
933 | sResult += "alphaCeiling"; | |||
934 | break; | |||
935 | case oox::XML_alphaFloor: | |||
936 | sResult += "alphaFloor"; | |||
937 | break; | |||
938 | case oox::XML_alphaInv: | |||
939 | sResult += "alphaInv"; | |||
940 | break; | |||
941 | case oox::XML_alphaMod: | |||
942 | sResult += "alphaMod"; | |||
943 | break; | |||
944 | case oox::XML_alphaModFix: | |||
945 | sResult += "alphaModFix"; | |||
946 | break; | |||
947 | case oox::XML_alphaRepl: | |||
948 | sResult += "alphaRepl"; | |||
949 | break; | |||
950 | case oox::XML_biLevel: | |||
951 | sResult += "biLevel"; | |||
952 | break; | |||
953 | case oox::XML_blur: | |||
954 | sResult += "blur"; | |||
955 | break; | |||
956 | case oox::XML_clrChange: | |||
957 | sResult += "clrChange"; | |||
958 | break; | |||
959 | case oox::XML_clrRepl: | |||
960 | sResult += "clrRepl"; | |||
961 | break; | |||
962 | case oox::XML_duotone: | |||
963 | sResult += "duotone"; | |||
964 | break; | |||
965 | case oox::XML_fillOverlay: | |||
966 | sResult += "fillOverlay"; | |||
967 | break; | |||
968 | case oox::XML_grayscl: | |||
969 | sResult += "grayscl"; | |||
970 | break; | |||
971 | case oox::XML_hsl: | |||
972 | sResult += "hsl"; | |||
973 | break; | |||
974 | case oox::XML_tint: | |||
975 | sResult += "tint"; | |||
976 | break; | |||
977 | case oox::XML_cstate: | |||
978 | sResult += "cstate"; | |||
979 | break; | |||
980 | case oox::XML_blip: | |||
981 | sResult += "blip"; | |||
982 | break; | |||
983 | case oox::XML_srcRect: | |||
984 | sResult += "srcRect"; | |||
985 | break; | |||
986 | case oox::XML_dpi: | |||
987 | sResult += "dpi"; | |||
988 | break; | |||
989 | case oox::XML_fgClr: | |||
990 | sResult += "fgClr"; | |||
991 | break; | |||
992 | case oox::XML_bgClr: | |||
993 | sResult += "bgClr"; | |||
994 | break; | |||
995 | case oox::XML_noFill: | |||
996 | sResult += "noFill"; | |||
997 | break; | |||
998 | case oox::XML_solidFill: | |||
999 | sResult += "solidFill"; | |||
1000 | break; | |||
1001 | case oox::XML_gradFill: | |||
1002 | sResult += "gradFill"; | |||
1003 | break; | |||
1004 | case oox::XML_blipFill: | |||
1005 | sResult += "blipFill"; | |||
1006 | break; | |||
1007 | case oox::XML_pattFill: | |||
1008 | sResult += "pattFill"; | |||
1009 | break; | |||
1010 | case oox::XML_grpFill: | |||
1011 | sResult += "grpFill"; | |||
1012 | break; | |||
1013 | case oox::XML_blend: | |||
1014 | sResult += "blend"; | |||
1015 | break; | |||
1016 | case oox::XML_ref: | |||
1017 | sResult += "ref"; | |||
1018 | break; | |||
1019 | case oox::XML_cont: | |||
1020 | sResult += "cont"; | |||
1021 | break; | |||
1022 | case oox::XML_effect: | |||
1023 | sResult += "effect"; | |||
1024 | break; | |||
1025 | case oox::XML_alphaOutset: | |||
1026 | sResult += "alphaOutset"; | |||
1027 | break; | |||
1028 | case oox::XML_fill: | |||
1029 | sResult += "fill"; | |||
1030 | break; | |||
1031 | case oox::XML_glow: | |||
1032 | sResult += "glow"; | |||
1033 | break; | |||
1034 | case oox::XML_innerShdw: | |||
1035 | sResult += "innerShdw"; | |||
1036 | break; | |||
1037 | case oox::XML_outerShdw: | |||
1038 | sResult += "outerShdw"; | |||
1039 | break; | |||
1040 | case oox::XML_prstShdw: | |||
1041 | sResult += "prstShdw"; | |||
1042 | break; | |||
1043 | case oox::XML_reflection: | |||
1044 | sResult += "reflection"; | |||
1045 | break; | |||
1046 | case oox::XML_relOff: | |||
1047 | sResult += "relOff"; | |||
1048 | break; | |||
1049 | case oox::XML_softEdge: | |||
1050 | sResult += "softEdge"; | |||
1051 | break; | |||
1052 | case oox::XML_xfrm: | |||
1053 | sResult += "xfrm"; | |||
1054 | break; | |||
1055 | case oox::XML_type: | |||
1056 | sResult += "type"; | |||
1057 | break; | |||
1058 | case oox::XML_effectLst: | |||
1059 | sResult += "effectLst"; | |||
1060 | break; | |||
1061 | case oox::XML_effectDag: | |||
1062 | sResult += "effectDag"; | |||
1063 | break; | |||
1064 | case oox::XML_len: | |||
1065 | sResult += "len"; | |||
1066 | break; | |||
1067 | case oox::XML_lim: | |||
1068 | sResult += "lim"; | |||
1069 | break; | |||
1070 | case oox::XML_round: | |||
1071 | sResult += "round"; | |||
1072 | break; | |||
1073 | case oox::XML_bevel: | |||
1074 | sResult += "bevel"; | |||
1075 | break; | |||
1076 | case oox::XML_miter: | |||
1077 | sResult += "miter"; | |||
1078 | break; | |||
1079 | case oox::XML_val: | |||
1080 | sResult += "val"; | |||
1081 | break; | |||
1082 | case oox::XML_d: | |||
1083 | sResult += "d"; | |||
1084 | break; | |||
1085 | case oox::XML_sp: | |||
1086 | sResult += "sp"; | |||
1087 | break; | |||
1088 | case oox::XML_ds: | |||
1089 | sResult += "ds"; | |||
1090 | break; | |||
1091 | case oox::XML_prstDash: | |||
1092 | sResult += "prstDash"; | |||
1093 | break; | |||
1094 | case oox::XML_custDash: | |||
1095 | sResult += "custDash"; | |||
1096 | break; | |||
1097 | case oox::XML_headEnd: | |||
1098 | sResult += "headEnd"; | |||
1099 | break; | |||
1100 | case oox::XML_tailEnd: | |||
1101 | sResult += "tailEnd"; | |||
1102 | break; | |||
1103 | case oox::XML_cmpd: | |||
1104 | sResult += "cmpd"; | |||
1105 | break; | |||
1106 | case oox::XML_bwMode: | |||
1107 | sResult += "bwMode"; | |||
1108 | break; | |||
1109 | case oox::XML_uri: | |||
1110 | sResult += "uri"; | |||
1111 | break; | |||
1112 | case oox::XML_n: | |||
1113 | sResult += "n"; | |||
1114 | break; | |||
1115 | case oox::XML_x: | |||
1116 | sResult += "x"; | |||
1117 | break; | |||
1118 | case oox::XML_y: | |||
1119 | sResult += "y"; | |||
1120 | break; | |||
1121 | case oox::XML_cx: | |||
1122 | sResult += "cx"; | |||
1123 | break; | |||
1124 | case oox::XML_cy: | |||
1125 | sResult += "cy"; | |||
1126 | break; | |||
1127 | case oox::XML_shade: | |||
1128 | sResult += "shade"; | |||
1129 | break; | |||
1130 | case oox::XML_comp: | |||
1131 | sResult += "comp"; | |||
1132 | break; | |||
1133 | case oox::XML_inv: | |||
1134 | sResult += "inv"; | |||
1135 | break; | |||
1136 | case oox::XML_gray: | |||
1137 | sResult += "gray"; | |||
1138 | break; | |||
1139 | case oox::XML_alpha: | |||
1140 | sResult += "alpha"; | |||
1141 | break; | |||
1142 | case oox::XML_alphaOff: | |||
1143 | sResult += "alphaOff"; | |||
1144 | break; | |||
1145 | case oox::XML_hueOff: | |||
1146 | sResult += "hueOff"; | |||
1147 | break; | |||
1148 | case oox::XML_hueMod: | |||
1149 | sResult += "hueMod"; | |||
1150 | break; | |||
1151 | case oox::XML_satOff: | |||
1152 | sResult += "satOff"; | |||
1153 | break; | |||
1154 | case oox::XML_satMod: | |||
1155 | sResult += "satMod"; | |||
1156 | break; | |||
1157 | case oox::XML_lumOff: | |||
1158 | sResult += "lumOff"; | |||
1159 | break; | |||
1160 | case oox::XML_lumMod: | |||
1161 | sResult += "lumMod"; | |||
1162 | break; | |||
1163 | case oox::XML_red: | |||
1164 | sResult += "red"; | |||
1165 | break; | |||
1166 | case oox::XML_redOff: | |||
1167 | sResult += "redOff"; | |||
1168 | break; | |||
1169 | case oox::XML_redMod: | |||
1170 | sResult += "redMod"; | |||
1171 | break; | |||
1172 | case oox::XML_green: | |||
1173 | sResult += "green"; | |||
1174 | break; | |||
1175 | case oox::XML_greenOff: | |||
1176 | sResult += "greenOff"; | |||
1177 | break; | |||
1178 | case oox::XML_greenMod: | |||
1179 | sResult += "greenMod"; | |||
1180 | break; | |||
1181 | case oox::XML_blue: | |||
1182 | sResult += "blue"; | |||
1183 | break; | |||
1184 | case oox::XML_blueOff: | |||
1185 | sResult += "blueOff"; | |||
1186 | break; | |||
1187 | case oox::XML_blueMod: | |||
1188 | sResult += "blueMod"; | |||
1189 | break; | |||
1190 | case oox::XML_gamma: | |||
1191 | sResult += "gamma"; | |||
1192 | break; | |||
1193 | case oox::XML_invGamma: | |||
1194 | sResult += "invGamma"; | |||
1195 | break; | |||
1196 | case oox::XML_r: | |||
1197 | sResult += "r"; | |||
1198 | break; | |||
1199 | case oox::XML_g: | |||
1200 | sResult += "g"; | |||
1201 | break; | |||
1202 | case oox::XML_lastClr: | |||
1203 | sResult += "lastClr"; | |||
1204 | break; | |||
1205 | case oox::XML_ext: | |||
1206 | sResult += "ext"; | |||
1207 | break; | |||
1208 | case oox::XML_off: | |||
1209 | sResult += "off"; | |||
1210 | break; | |||
1211 | case oox::XML_flipH: | |||
1212 | sResult += "flipH"; | |||
1213 | break; | |||
1214 | case oox::XML_flipV: | |||
1215 | sResult += "flipV"; | |||
1216 | break; | |||
1217 | case oox::XML_chOff: | |||
1218 | sResult += "chOff"; | |||
1219 | break; | |||
1220 | case oox::XML_chExt: | |||
1221 | sResult += "chExt"; | |||
1222 | break; | |||
1223 | case oox::XML_dx: | |||
1224 | sResult += "dx"; | |||
1225 | break; | |||
1226 | case oox::XML_dy: | |||
1227 | sResult += "dy"; | |||
1228 | break; | |||
1229 | case oox::XML_dz: | |||
1230 | sResult += "dz"; | |||
1231 | break; | |||
1232 | case oox::XML_lat: | |||
1233 | sResult += "lat"; | |||
1234 | break; | |||
1235 | case oox::XML_lon: | |||
1236 | sResult += "lon"; | |||
1237 | break; | |||
1238 | case oox::XML_rev: | |||
1239 | sResult += "rev"; | |||
1240 | break; | |||
1241 | case oox::XML_l: | |||
1242 | sResult += "l"; | |||
1243 | break; | |||
1244 | case oox::XML_t: | |||
1245 | sResult += "t"; | |||
1246 | break; | |||
1247 | case oox::XML_scrgbClr: | |||
1248 | sResult += "scrgbClr"; | |||
1249 | break; | |||
1250 | case oox::XML_srgbClr: | |||
1251 | sResult += "srgbClr"; | |||
1252 | break; | |||
1253 | case oox::XML_hslClr: | |||
1254 | sResult += "hslClr"; | |||
1255 | break; | |||
1256 | case oox::XML_sysClr: | |||
1257 | sResult += "sysClr"; | |||
1258 | break; | |||
1259 | case oox::XML_schemeClr: | |||
1260 | sResult += "schemeClr"; | |||
1261 | break; | |||
1262 | case oox::XML_prstClr: | |||
1263 | sResult += "prstClr"; | |||
1264 | break; | |||
1265 | case oox::XML_embed: | |||
1266 | sResult += "embed"; | |||
1267 | break; | |||
1268 | case oox::XML_link: | |||
1269 | sResult += "link"; | |||
1270 | break; | |||
1271 | case oox::XML_builtIn: | |||
1272 | sResult += "builtIn"; | |||
1273 | break; | |||
1274 | case oox::XML_snd: | |||
1275 | sResult += "snd"; | |||
1276 | break; | |||
1277 | case oox::XML_invalidUrl: | |||
1278 | sResult += "invalidUrl"; | |||
1279 | break; | |||
1280 | case oox::XML_action: | |||
1281 | sResult += "action"; | |||
1282 | break; | |||
1283 | case oox::XML_tgtFrame: | |||
1284 | sResult += "tgtFrame"; | |||
1285 | break; | |||
1286 | case oox::XML_tooltip: | |||
1287 | sResult += "tooltip"; | |||
1288 | break; | |||
1289 | case oox::XML_history: | |||
1290 | sResult += "history"; | |||
1291 | break; | |||
1292 | case oox::XML_highlightClick: | |||
1293 | sResult += "highlightClick"; | |||
1294 | break; | |||
1295 | case oox::XML_endSnd: | |||
1296 | sResult += "endSnd"; | |||
1297 | break; | |||
1298 | case oox::XML_noGrp: | |||
1299 | sResult += "noGrp"; | |||
1300 | break; | |||
1301 | case oox::XML_noSelect: | |||
1302 | sResult += "noSelect"; | |||
1303 | break; | |||
1304 | case oox::XML_noRot: | |||
1305 | sResult += "noRot"; | |||
1306 | break; | |||
1307 | case oox::XML_noChangeAspect: | |||
1308 | sResult += "noChangeAspect"; | |||
1309 | break; | |||
1310 | case oox::XML_noMove: | |||
1311 | sResult += "noMove"; | |||
1312 | break; | |||
1313 | case oox::XML_noResize: | |||
1314 | sResult += "noResize"; | |||
1315 | break; | |||
1316 | case oox::XML_noEditPoints: | |||
1317 | sResult += "noEditPoints"; | |||
1318 | break; | |||
1319 | case oox::XML_noAdjustHandles: | |||
1320 | sResult += "noAdjustHandles"; | |||
1321 | break; | |||
1322 | case oox::XML_noChangeArrowheads: | |||
1323 | sResult += "noChangeArrowheads"; | |||
1324 | break; | |||
1325 | case oox::XML_noChangeShapeType: | |||
1326 | sResult += "noChangeShapeType"; | |||
1327 | break; | |||
1328 | case oox::XML_noTextEdit: | |||
1329 | sResult += "noTextEdit"; | |||
1330 | break; | |||
1331 | case oox::XML_noCrop: | |||
1332 | sResult += "noCrop"; | |||
1333 | break; | |||
1334 | case oox::XML_noUngrp: | |||
1335 | sResult += "noUngrp"; | |||
1336 | break; | |||
1337 | case oox::XML_noDrilldown: | |||
1338 | sResult += "noDrilldown"; | |||
1339 | break; | |||
1340 | case oox::XML_hlinkHover: | |||
1341 | sResult += "hlinkHover"; | |||
1342 | break; | |||
1343 | case oox::XML_descr: | |||
1344 | sResult += "descr"; | |||
1345 | break; | |||
1346 | case oox::XML_hidden: | |||
1347 | sResult += "hidden"; | |||
1348 | break; | |||
1349 | case oox::XML_title: | |||
1350 | sResult += "title"; | |||
1351 | break; | |||
1352 | case oox::XML_spLocks: | |||
1353 | sResult += "spLocks"; | |||
1354 | break; | |||
1355 | case oox::XML_txBox: | |||
1356 | sResult += "txBox"; | |||
1357 | break; | |||
1358 | case oox::XML_cxnSpLocks: | |||
1359 | sResult += "cxnSpLocks"; | |||
1360 | break; | |||
1361 | case oox::XML_stCxn: | |||
1362 | sResult += "stCxn"; | |||
1363 | break; | |||
1364 | case oox::XML_endCxn: | |||
1365 | sResult += "endCxn"; | |||
1366 | break; | |||
1367 | case oox::XML_picLocks: | |||
1368 | sResult += "picLocks"; | |||
1369 | break; | |||
1370 | case oox::XML_preferRelativeResize: | |||
1371 | sResult += "preferRelativeResize"; | |||
1372 | break; | |||
1373 | case oox::XML_grpSpLocks: | |||
1374 | sResult += "grpSpLocks"; | |||
1375 | break; | |||
1376 | case oox::XML_graphicFrameLocks: | |||
1377 | sResult += "graphicFrameLocks"; | |||
1378 | break; | |||
1379 | case oox::XML_graphicData: | |||
1380 | sResult += "graphicData"; | |||
1381 | break; | |||
1382 | case oox::XML_graphic: | |||
1383 | sResult += "graphic"; | |||
1384 | break; | |||
1385 | case oox::XML_pctWidth: | |||
1386 | sResult += "pctWidth"; | |||
1387 | break; | |||
1388 | case oox::XML_relativeFrom: | |||
1389 | sResult += "relativeFrom"; | |||
1390 | break; | |||
1391 | case oox::XML_pctHeight: | |||
1392 | sResult += "pctHeight"; | |||
1393 | break; | |||
1394 | case oox::XML_sizeRelH: | |||
1395 | sResult += "sizeRelH"; | |||
1396 | break; | |||
1397 | case oox::XML_sizeRelV: | |||
1398 | sResult += "sizeRelV"; | |||
1399 | break; | |||
1400 | case oox::XML_styleSet: | |||
1401 | sResult += "styleSet"; | |||
1402 | break; | |||
1403 | case oox::XML_shadow: | |||
1404 | sResult += "shadow"; | |||
1405 | break; | |||
1406 | case oox::XML_textOutline: | |||
1407 | sResult += "textOutline"; | |||
1408 | break; | |||
1409 | case oox::XML_textFill: | |||
1410 | sResult += "textFill"; | |||
1411 | break; | |||
1412 | case oox::XML_props3d: | |||
1413 | sResult += "props3d"; | |||
1414 | break; | |||
1415 | case oox::XML_ligatures: | |||
1416 | sResult += "ligatures"; | |||
1417 | break; | |||
1418 | case oox::XML_numForm: | |||
1419 | sResult += "numForm"; | |||
1420 | break; | |||
1421 | case oox::XML_numSpacing: | |||
1422 | sResult += "numSpacing"; | |||
1423 | break; | |||
1424 | case oox::XML_stylisticSets: | |||
1425 | sResult += "stylisticSets"; | |||
1426 | break; | |||
1427 | case oox::XML_cntxtAlts: | |||
1428 | sResult += "cntxtAlts"; | |||
1429 | break; | |||
1430 | case oox::XML_checked: | |||
1431 | sResult += "checked"; | |||
1432 | break; | |||
1433 | case oox::XML_checkedState: | |||
1434 | sResult += "checkedState"; | |||
1435 | break; | |||
1436 | case oox::XML_uncheckedState: | |||
1437 | sResult += "uncheckedState"; | |||
1438 | break; | |||
1439 | case oox::XML_visible: | |||
1440 | sResult += "visible"; | |||
1441 | break; | |||
1442 | case oox::XML_trans: | |||
1443 | sResult += "trans"; | |||
1444 | break; | |||
1445 | case oox::XML_crackSpacing: | |||
1446 | sResult += "crackSpacing"; | |||
1447 | break; | |||
1448 | case oox::XML_pressure: | |||
1449 | sResult += "pressure"; | |||
1450 | break; | |||
1451 | case oox::XML_numberOfShades: | |||
1452 | sResult += "numberOfShades"; | |||
1453 | break; | |||
1454 | case oox::XML_grainSize: | |||
1455 | sResult += "grainSize"; | |||
1456 | break; | |||
1457 | case oox::XML_scaling: | |||
1458 | sResult += "scaling"; | |||
1459 | break; | |||
1460 | case oox::XML_intensity: | |||
1461 | sResult += "intensity"; | |||
1462 | break; | |||
1463 | case oox::XML_smoothness: | |||
1464 | sResult += "smoothness"; | |||
1465 | break; | |||
1466 | case oox::XML_gridSize: | |||
1467 | sResult += "gridSize"; | |||
1468 | break; | |||
1469 | case oox::XML_pencilSize: | |||
1470 | sResult += "pencilSize"; | |||
1471 | break; | |||
1472 | case oox::XML_size: | |||
1473 | sResult += "size"; | |||
1474 | break; | |||
1475 | case oox::XML_brushSize: | |||
1476 | sResult += "brushSize"; | |||
1477 | break; | |||
1478 | case oox::XML_detail: | |||
1479 | sResult += "detail"; | |||
1480 | break; | |||
1481 | case oox::XML_colorTemp: | |||
1482 | sResult += "colorTemp"; | |||
1483 | break; | |||
1484 | case oox::XML_amount: | |||
1485 | sResult += "amount"; | |||
1486 | break; | |||
1487 | case oox::XML_artisticBlur: | |||
1488 | sResult += "artisticBlur"; | |||
1489 | break; | |||
1490 | case oox::XML_artisticCement: | |||
1491 | sResult += "artisticCement"; | |||
1492 | break; | |||
1493 | case oox::XML_artisticChalkSketch: | |||
1494 | sResult += "artisticChalkSketch"; | |||
1495 | break; | |||
1496 | case oox::XML_artisticCrisscrossEtching: | |||
1497 | sResult += "artisticCrisscrossEtching"; | |||
1498 | break; | |||
1499 | case oox::XML_artisticCutout: | |||
1500 | sResult += "artisticCutout"; | |||
1501 | break; | |||
1502 | case oox::XML_artisticFilmGrain: | |||
1503 | sResult += "artisticFilmGrain"; | |||
1504 | break; | |||
1505 | case oox::XML_artisticGlass: | |||
1506 | sResult += "artisticGlass"; | |||
1507 | break; | |||
1508 | case oox::XML_artisticGlowDiffused: | |||
1509 | sResult += "artisticGlowDiffused"; | |||
1510 | break; | |||
1511 | case oox::XML_artisticGlowEdges: | |||
1512 | sResult += "artisticGlowEdges"; | |||
1513 | break; | |||
1514 | case oox::XML_artisticLightScreen: | |||
1515 | sResult += "artisticLightScreen"; | |||
1516 | break; | |||
1517 | case oox::XML_artisticLineDrawing: | |||
1518 | sResult += "artisticLineDrawing"; | |||
1519 | break; | |||
1520 | case oox::XML_artisticMarker: | |||
1521 | sResult += "artisticMarker"; | |||
1522 | break; | |||
1523 | case oox::XML_artisticMosiaicBubbles: | |||
1524 | sResult += "artisticMosiaicBubbles"; | |||
1525 | break; | |||
1526 | case oox::XML_artisticPaintStrokes: | |||
1527 | sResult += "artisticPaintStrokes"; | |||
1528 | break; | |||
1529 | case oox::XML_artisticPaintBrush: | |||
1530 | sResult += "artisticPaintBrush"; | |||
1531 | break; | |||
1532 | case oox::XML_artisticPastelsSmooth: | |||
1533 | sResult += "artisticPastelsSmooth"; | |||
1534 | break; | |||
1535 | case oox::XML_artisticPencilGrayscale: | |||
1536 | sResult += "artisticPencilGrayscale"; | |||
1537 | break; | |||
1538 | case oox::XML_artisticPencilSketch: | |||
1539 | sResult += "artisticPencilSketch"; | |||
1540 | break; | |||
1541 | case oox::XML_artisticPhotocopy: | |||
1542 | sResult += "artisticPhotocopy"; | |||
1543 | break; | |||
1544 | case oox::XML_artisticPlasticWrap: | |||
1545 | sResult += "artisticPlasticWrap"; | |||
1546 | break; | |||
1547 | case oox::XML_artisticTexturizer: | |||
1548 | sResult += "artisticTexturizer"; | |||
1549 | break; | |||
1550 | case oox::XML_artisticWatercolorSponge: | |||
1551 | sResult += "artisticWatercolorSponge"; | |||
1552 | break; | |||
1553 | case oox::XML_brightnessContrast: | |||
1554 | sResult += "brightnessContrast"; | |||
1555 | break; | |||
1556 | case oox::XML_colorTemperature: | |||
1557 | sResult += "colorTemperature"; | |||
1558 | break; | |||
1559 | case oox::XML_saturation: | |||
1560 | sResult += "saturation"; | |||
1561 | break; | |||
1562 | case oox::XML_sharpenSoften: | |||
1563 | sResult += "sharpenSoften"; | |||
1564 | break; | |||
1565 | case oox::XML_imgEffect: | |||
1566 | sResult += "imgEffect"; | |||
1567 | break; | |||
1568 | case oox::XML_imgLayer: | |||
1569 | sResult += "imgLayer"; | |||
1570 | break; | |||
1571 | case oox::XML_fmla: | |||
1572 | sResult += "fmla"; | |||
1573 | break; | |||
1574 | case oox::XML_gd: | |||
1575 | sResult += "gd"; | |||
1576 | break; | |||
1577 | case oox::XML_gdRefX: | |||
1578 | sResult += "gdRefX"; | |||
1579 | break; | |||
1580 | case oox::XML_minX: | |||
1581 | sResult += "minX"; | |||
1582 | break; | |||
1583 | case oox::XML_maxX: | |||
1584 | sResult += "maxX"; | |||
1585 | break; | |||
1586 | case oox::XML_gdRefY: | |||
1587 | sResult += "gdRefY"; | |||
1588 | break; | |||
1589 | case oox::XML_minY: | |||
1590 | sResult += "minY"; | |||
1591 | break; | |||
1592 | case oox::XML_maxY: | |||
1593 | sResult += "maxY"; | |||
1594 | break; | |||
1595 | case oox::XML_gdRefR: | |||
1596 | sResult += "gdRefR"; | |||
1597 | break; | |||
1598 | case oox::XML_minR: | |||
1599 | sResult += "minR"; | |||
1600 | break; | |||
1601 | case oox::XML_maxR: | |||
1602 | sResult += "maxR"; | |||
1603 | break; | |||
1604 | case oox::XML_gdRefAng: | |||
1605 | sResult += "gdRefAng"; | |||
1606 | break; | |||
1607 | case oox::XML_minAng: | |||
1608 | sResult += "minAng"; | |||
1609 | break; | |||
1610 | case oox::XML_maxAng: | |||
1611 | sResult += "maxAng"; | |||
1612 | break; | |||
1613 | case oox::XML_ahXY: | |||
1614 | sResult += "ahXY"; | |||
1615 | break; | |||
1616 | case oox::XML_ahPolar: | |||
1617 | sResult += "ahPolar"; | |||
1618 | break; | |||
1619 | case oox::XML_cxn: | |||
1620 | sResult += "cxn"; | |||
1621 | break; | |||
1622 | case oox::XML_idx: | |||
1623 | sResult += "idx"; | |||
1624 | break; | |||
1625 | case oox::XML_pt: | |||
1626 | sResult += "pt"; | |||
1627 | break; | |||
1628 | case oox::XML_wR: | |||
1629 | sResult += "wR"; | |||
1630 | break; | |||
1631 | case oox::XML_hR: | |||
1632 | sResult += "hR"; | |||
1633 | break; | |||
1634 | case oox::XML_stAng: | |||
1635 | sResult += "stAng"; | |||
1636 | break; | |||
1637 | case oox::XML_swAng: | |||
1638 | sResult += "swAng"; | |||
1639 | break; | |||
1640 | case oox::XML_close: | |||
1641 | sResult += "close"; | |||
1642 | break; | |||
1643 | case oox::XML_moveTo: | |||
1644 | sResult += "moveTo"; | |||
1645 | break; | |||
1646 | case oox::XML_lnTo: | |||
1647 | sResult += "lnTo"; | |||
1648 | break; | |||
1649 | case oox::XML_arcTo: | |||
1650 | sResult += "arcTo"; | |||
1651 | break; | |||
1652 | case oox::XML_quadBezTo: | |||
1653 | sResult += "quadBezTo"; | |||
1654 | break; | |||
1655 | case oox::XML_cubicBezTo: | |||
1656 | sResult += "cubicBezTo"; | |||
1657 | break; | |||
1658 | case oox::XML_stroke: | |||
1659 | sResult += "stroke"; | |||
1660 | break; | |||
1661 | case oox::XML_extrusionOk: | |||
1662 | sResult += "extrusionOk"; | |||
1663 | break; | |||
1664 | case oox::XML_avLst: | |||
1665 | sResult += "avLst"; | |||
1666 | break; | |||
1667 | case oox::XML_gdLst: | |||
1668 | sResult += "gdLst"; | |||
1669 | break; | |||
1670 | case oox::XML_ahLst: | |||
1671 | sResult += "ahLst"; | |||
1672 | break; | |||
1673 | case oox::XML_cxnLst: | |||
1674 | sResult += "cxnLst"; | |||
1675 | break; | |||
1676 | case oox::XML_rect: | |||
1677 | sResult += "rect"; | |||
1678 | break; | |||
1679 | case oox::XML_pathLst: | |||
1680 | sResult += "pathLst"; | |||
1681 | break; | |||
1682 | case oox::XML_custGeom: | |||
1683 | sResult += "custGeom"; | |||
1684 | break; | |||
1685 | case oox::XML_prstGeom: | |||
1686 | sResult += "prstGeom"; | |||
1687 | break; | |||
1688 | case oox::XML_prstTxWarp: | |||
1689 | sResult += "prstTxWarp"; | |||
1690 | break; | |||
1691 | case oox::XML_extent: | |||
1692 | sResult += "extent"; | |||
1693 | break; | |||
1694 | case oox::XML_effectExtent: | |||
1695 | sResult += "effectExtent"; | |||
1696 | break; | |||
1697 | case oox::XML_docPr: | |||
1698 | sResult += "docPr"; | |||
1699 | break; | |||
1700 | case oox::XML_cNvGraphicFramePr: | |||
1701 | sResult += "cNvGraphicFramePr"; | |||
1702 | break; | |||
1703 | case oox::XML_distT: | |||
1704 | sResult += "distT"; | |||
1705 | break; | |||
1706 | case oox::XML_distB: | |||
1707 | sResult += "distB"; | |||
1708 | break; | |||
1709 | case oox::XML_distL: | |||
1710 | sResult += "distL"; | |||
1711 | break; | |||
1712 | case oox::XML_distR: | |||
1713 | sResult += "distR"; | |||
1714 | break; | |||
1715 | case oox::XML_anchorId: | |||
1716 | sResult += "anchorId"; | |||
1717 | break; | |||
1718 | case oox::XML_start: | |||
1719 | sResult += "start"; | |||
1720 | break; | |||
1721 | case oox::XML_lineTo: | |||
1722 | sResult += "lineTo"; | |||
1723 | break; | |||
1724 | case oox::XML_edited: | |||
1725 | sResult += "edited"; | |||
1726 | break; | |||
1727 | case oox::XML_wrapText: | |||
1728 | sResult += "wrapText"; | |||
1729 | break; | |||
1730 | case oox::XML_wrapPolygon: | |||
1731 | sResult += "wrapPolygon"; | |||
1732 | break; | |||
1733 | case oox::XML_wrapNone: | |||
1734 | sResult += "wrapNone"; | |||
1735 | break; | |||
1736 | case oox::XML_wrapSquare: | |||
1737 | sResult += "wrapSquare"; | |||
1738 | break; | |||
1739 | case oox::XML_wrapTight: | |||
1740 | sResult += "wrapTight"; | |||
1741 | break; | |||
1742 | case oox::XML_wrapThrough: | |||
1743 | sResult += "wrapThrough"; | |||
1744 | break; | |||
1745 | case oox::XML_wrapTopAndBottom: | |||
1746 | sResult += "wrapTopAndBottom"; | |||
1747 | break; | |||
1748 | case oox::XML_align: | |||
1749 | sResult += "align"; | |||
1750 | break; | |||
1751 | case oox::XML_posOffset: | |||
1752 | sResult += "posOffset"; | |||
1753 | break; | |||
1754 | case oox::XML_simplePos: | |||
1755 | sResult += "simplePos"; | |||
1756 | break; | |||
1757 | case oox::XML_positionH: | |||
1758 | sResult += "positionH"; | |||
1759 | break; | |||
1760 | case oox::XML_positionV: | |||
1761 | sResult += "positionV"; | |||
1762 | break; | |||
1763 | case oox::XML_relativeHeight: | |||
1764 | sResult += "relativeHeight"; | |||
1765 | break; | |||
1766 | case oox::XML_behindDoc: | |||
1767 | sResult += "behindDoc"; | |||
1768 | break; | |||
1769 | case oox::XML_locked: | |||
1770 | sResult += "locked"; | |||
1771 | break; | |||
1772 | case oox::XML_layoutInCell: | |||
1773 | sResult += "layoutInCell"; | |||
1774 | break; | |||
1775 | case oox::XML_allowOverlap: | |||
1776 | sResult += "allowOverlap"; | |||
1777 | break; | |||
1778 | case oox::XML_inline: | |||
1779 | sResult += "inline"; | |||
1780 | break; | |||
1781 | case oox::XML_anchor: | |||
1782 | sResult += "anchor"; | |||
1783 | break; | |||
1784 | case oox::XML_manifestLocation: | |||
1785 | sResult += "manifestLocation"; | |||
1786 | break; | |||
1787 | case oox::XML_schemaLocation: | |||
1788 | sResult += "schemaLocation"; | |||
1789 | break; | |||
1790 | case oox::XML_schema: | |||
1791 | sResult += "schema"; | |||
1792 | break; | |||
1793 | case oox::XML_schemaLibrary: | |||
1794 | sResult += "schemaLibrary"; | |||
1795 | break; | |||
1796 | case oox::XML_alnAt: | |||
1797 | sResult += "alnAt"; | |||
1798 | break; | |||
1799 | case oox::XML_scr: | |||
1800 | sResult += "scr"; | |||
1801 | break; | |||
1802 | case oox::XML_sty: | |||
1803 | sResult += "sty"; | |||
1804 | break; | |||
1805 | case oox::XML_lit: | |||
1806 | sResult += "lit"; | |||
1807 | break; | |||
1808 | case oox::XML_nor: | |||
1809 | sResult += "nor"; | |||
1810 | break; | |||
1811 | case oox::XML_brk: | |||
1812 | sResult += "brk"; | |||
1813 | break; | |||
1814 | case oox::XML_aln: | |||
1815 | sResult += "aln"; | |||
1816 | break; | |||
1817 | case oox::XML_space: | |||
1818 | sResult += "space"; | |||
1819 | break; | |||
1820 | case oox::XML_rPr: | |||
1821 | sResult += "rPr"; | |||
1822 | break; | |||
1823 | case oox::XML_chr: | |||
1824 | sResult += "chr"; | |||
1825 | break; | |||
1826 | case oox::XML_ctrlPr: | |||
1827 | sResult += "ctrlPr"; | |||
1828 | break; | |||
1829 | case oox::XML_accPr: | |||
1830 | sResult += "accPr"; | |||
1831 | break; | |||
1832 | case oox::XML_e: | |||
1833 | sResult += "e"; | |||
1834 | break; | |||
1835 | case oox::XML_barPr: | |||
1836 | sResult += "barPr"; | |||
1837 | break; | |||
1838 | case oox::XML_opEmu: | |||
1839 | sResult += "opEmu"; | |||
1840 | break; | |||
1841 | case oox::XML_noBreak: | |||
1842 | sResult += "noBreak"; | |||
1843 | break; | |||
1844 | case oox::XML_diff: | |||
1845 | sResult += "diff"; | |||
1846 | break; | |||
1847 | case oox::XML_boxPr: | |||
1848 | sResult += "boxPr"; | |||
1849 | break; | |||
1850 | case oox::XML_hideTop: | |||
1851 | sResult += "hideTop"; | |||
1852 | break; | |||
1853 | case oox::XML_hideBot: | |||
1854 | sResult += "hideBot"; | |||
1855 | break; | |||
1856 | case oox::XML_hideLeft: | |||
1857 | sResult += "hideLeft"; | |||
1858 | break; | |||
1859 | case oox::XML_hideRight: | |||
1860 | sResult += "hideRight"; | |||
1861 | break; | |||
1862 | case oox::XML_strikeH: | |||
1863 | sResult += "strikeH"; | |||
1864 | break; | |||
1865 | case oox::XML_strikeV: | |||
1866 | sResult += "strikeV"; | |||
1867 | break; | |||
1868 | case oox::XML_strikeBLTR: | |||
1869 | sResult += "strikeBLTR"; | |||
1870 | break; | |||
1871 | case oox::XML_strikeTLBR: | |||
1872 | sResult += "strikeTLBR"; | |||
1873 | break; | |||
1874 | case oox::XML_borderBoxPr: | |||
1875 | sResult += "borderBoxPr"; | |||
1876 | break; | |||
1877 | case oox::XML_begChr: | |||
1878 | sResult += "begChr"; | |||
1879 | break; | |||
1880 | case oox::XML_sepChr: | |||
1881 | sResult += "sepChr"; | |||
1882 | break; | |||
1883 | case oox::XML_endChr: | |||
1884 | sResult += "endChr"; | |||
1885 | break; | |||
1886 | case oox::XML_shp: | |||
1887 | sResult += "shp"; | |||
1888 | break; | |||
1889 | case oox::XML_dPr: | |||
1890 | sResult += "dPr"; | |||
1891 | break; | |||
1892 | case oox::XML_baseJc: | |||
1893 | sResult += "baseJc"; | |||
1894 | break; | |||
1895 | case oox::XML_maxDist: | |||
1896 | sResult += "maxDist"; | |||
1897 | break; | |||
1898 | case oox::XML_objDist: | |||
1899 | sResult += "objDist"; | |||
1900 | break; | |||
1901 | case oox::XML_rSpRule: | |||
1902 | sResult += "rSpRule"; | |||
1903 | break; | |||
1904 | case oox::XML_rSp: | |||
1905 | sResult += "rSp"; | |||
1906 | break; | |||
1907 | case oox::XML_eqArrPr: | |||
1908 | sResult += "eqArrPr"; | |||
1909 | break; | |||
1910 | case oox::XML_fPr: | |||
1911 | sResult += "fPr"; | |||
1912 | break; | |||
1913 | case oox::XML_num: | |||
1914 | sResult += "num"; | |||
1915 | break; | |||
1916 | case oox::XML_den: | |||
1917 | sResult += "den"; | |||
1918 | break; | |||
1919 | case oox::XML_funcPr: | |||
1920 | sResult += "funcPr"; | |||
1921 | break; | |||
1922 | case oox::XML_fName: | |||
1923 | sResult += "fName"; | |||
1924 | break; | |||
1925 | case oox::XML_vertJc: | |||
1926 | sResult += "vertJc"; | |||
1927 | break; | |||
1928 | case oox::XML_groupChrPr: | |||
1929 | sResult += "groupChrPr"; | |||
1930 | break; | |||
1931 | case oox::XML_limLowPr: | |||
1932 | sResult += "limLowPr"; | |||
1933 | break; | |||
1934 | case oox::XML_limUppPr: | |||
1935 | sResult += "limUppPr"; | |||
1936 | break; | |||
1937 | case oox::XML_count: | |||
1938 | sResult += "count"; | |||
1939 | break; | |||
1940 | case oox::XML_mcJc: | |||
1941 | sResult += "mcJc"; | |||
1942 | break; | |||
1943 | case oox::XML_mcPr: | |||
1944 | sResult += "mcPr"; | |||
1945 | break; | |||
1946 | case oox::XML_mc: | |||
1947 | sResult += "mc"; | |||
1948 | break; | |||
1949 | case oox::XML_plcHide: | |||
1950 | sResult += "plcHide"; | |||
1951 | break; | |||
1952 | case oox::XML_cGpRule: | |||
1953 | sResult += "cGpRule"; | |||
1954 | break; | |||
1955 | case oox::XML_cSp: | |||
1956 | sResult += "cSp"; | |||
1957 | break; | |||
1958 | case oox::XML_cGp: | |||
1959 | sResult += "cGp"; | |||
1960 | break; | |||
1961 | case oox::XML_mcs: | |||
1962 | sResult += "mcs"; | |||
1963 | break; | |||
1964 | case oox::XML_mPr: | |||
1965 | sResult += "mPr"; | |||
1966 | break; | |||
1967 | case oox::XML_mr: | |||
1968 | sResult += "mr"; | |||
1969 | break; | |||
1970 | case oox::XML_limLoc: | |||
1971 | sResult += "limLoc"; | |||
1972 | break; | |||
1973 | case oox::XML_subHide: | |||
1974 | sResult += "subHide"; | |||
1975 | break; | |||
1976 | case oox::XML_supHide: | |||
1977 | sResult += "supHide"; | |||
1978 | break; | |||
1979 | case oox::XML_naryPr: | |||
1980 | sResult += "naryPr"; | |||
1981 | break; | |||
1982 | case oox::XML_sub: | |||
1983 | sResult += "sub"; | |||
1984 | break; | |||
1985 | case oox::XML_sup: | |||
1986 | sResult += "sup"; | |||
1987 | break; | |||
1988 | case oox::XML_show: | |||
1989 | sResult += "show"; | |||
1990 | break; | |||
1991 | case oox::XML_zeroWid: | |||
1992 | sResult += "zeroWid"; | |||
1993 | break; | |||
1994 | case oox::XML_zeroAsc: | |||
1995 | sResult += "zeroAsc"; | |||
1996 | break; | |||
1997 | case oox::XML_zeroDesc: | |||
1998 | sResult += "zeroDesc"; | |||
1999 | break; | |||
2000 | case oox::XML_transp: | |||
2001 | sResult += "transp"; | |||
2002 | break; | |||
2003 | case oox::XML_phantPr: | |||
2004 | sResult += "phantPr"; | |||
2005 | break; | |||
2006 | case oox::XML_degHide: | |||
2007 | sResult += "degHide"; | |||
2008 | break; | |||
2009 | case oox::XML_radPr: | |||
2010 | sResult += "radPr"; | |||
2011 | break; | |||
2012 | case oox::XML_deg: | |||
2013 | sResult += "deg"; | |||
2014 | break; | |||
2015 | case oox::XML_sPrePr: | |||
2016 | sResult += "sPrePr"; | |||
2017 | break; | |||
2018 | case oox::XML_sSubPr: | |||
2019 | sResult += "sSubPr"; | |||
2020 | break; | |||
2021 | case oox::XML_alnScr: | |||
2022 | sResult += "alnScr"; | |||
2023 | break; | |||
2024 | case oox::XML_sSubSupPr: | |||
2025 | sResult += "sSubSupPr"; | |||
2026 | break; | |||
2027 | case oox::XML_sSupPr: | |||
2028 | sResult += "sSupPr"; | |||
2029 | break; | |||
2030 | case oox::XML_acc: | |||
2031 | sResult += "acc"; | |||
2032 | break; | |||
2033 | case oox::XML_bar: | |||
2034 | sResult += "bar"; | |||
2035 | break; | |||
2036 | case oox::XML_box: | |||
2037 | sResult += "box"; | |||
2038 | break; | |||
2039 | case oox::XML_borderBox: | |||
2040 | sResult += "borderBox"; | |||
2041 | break; | |||
2042 | case oox::XML_eqArr: | |||
2043 | sResult += "eqArr"; | |||
2044 | break; | |||
2045 | case oox::XML_f: | |||
2046 | sResult += "f"; | |||
2047 | break; | |||
2048 | case oox::XML_func: | |||
2049 | sResult += "func"; | |||
2050 | break; | |||
2051 | case oox::XML_groupChr: | |||
2052 | sResult += "groupChr"; | |||
2053 | break; | |||
2054 | case oox::XML_limLow: | |||
2055 | sResult += "limLow"; | |||
2056 | break; | |||
2057 | case oox::XML_limUpp: | |||
2058 | sResult += "limUpp"; | |||
2059 | break; | |||
2060 | case oox::XML_m: | |||
2061 | sResult += "m"; | |||
2062 | break; | |||
2063 | case oox::XML_nary: | |||
2064 | sResult += "nary"; | |||
2065 | break; | |||
2066 | case oox::XML_phant: | |||
2067 | sResult += "phant"; | |||
2068 | break; | |||
2069 | case oox::XML_sPre: | |||
2070 | sResult += "sPre"; | |||
2071 | break; | |||
2072 | case oox::XML_sSub: | |||
2073 | sResult += "sSub"; | |||
2074 | break; | |||
2075 | case oox::XML_sSubSup: | |||
2076 | sResult += "sSubSup"; | |||
2077 | break; | |||
2078 | case oox::XML_sSup: | |||
2079 | sResult += "sSup"; | |||
2080 | break; | |||
2081 | case oox::XML_argSz: | |||
2082 | sResult += "argSz"; | |||
2083 | break; | |||
2084 | case oox::XML_argPr: | |||
2085 | sResult += "argPr"; | |||
2086 | break; | |||
2087 | case oox::XML_jc: | |||
2088 | sResult += "jc"; | |||
2089 | break; | |||
2090 | case oox::XML_mathFont: | |||
2091 | sResult += "mathFont"; | |||
2092 | break; | |||
2093 | case oox::XML_brkBin: | |||
2094 | sResult += "brkBin"; | |||
2095 | break; | |||
2096 | case oox::XML_brkBinSub: | |||
2097 | sResult += "brkBinSub"; | |||
2098 | break; | |||
2099 | case oox::XML_smallFrac: | |||
2100 | sResult += "smallFrac"; | |||
2101 | break; | |||
2102 | case oox::XML_dispDef: | |||
2103 | sResult += "dispDef"; | |||
2104 | break; | |||
2105 | case oox::XML_lMargin: | |||
2106 | sResult += "lMargin"; | |||
2107 | break; | |||
2108 | case oox::XML_rMargin: | |||
2109 | sResult += "rMargin"; | |||
2110 | break; | |||
2111 | case oox::XML_defJc: | |||
2112 | sResult += "defJc"; | |||
2113 | break; | |||
2114 | case oox::XML_preSp: | |||
2115 | sResult += "preSp"; | |||
2116 | break; | |||
2117 | case oox::XML_postSp: | |||
2118 | sResult += "postSp"; | |||
2119 | break; | |||
2120 | case oox::XML_interSp: | |||
2121 | sResult += "interSp"; | |||
2122 | break; | |||
2123 | case oox::XML_intraSp: | |||
2124 | sResult += "intraSp"; | |||
2125 | break; | |||
2126 | case oox::XML_wrapIndent: | |||
2127 | sResult += "wrapIndent"; | |||
2128 | break; | |||
2129 | case oox::XML_wrapRight: | |||
2130 | sResult += "wrapRight"; | |||
2131 | break; | |||
2132 | case oox::XML_intLim: | |||
2133 | sResult += "intLim"; | |||
2134 | break; | |||
2135 | case oox::XML_naryLim: | |||
2136 | sResult += "naryLim"; | |||
2137 | break; | |||
2138 | case oox::XML_mathPr: | |||
2139 | sResult += "mathPr"; | |||
2140 | break; | |||
2141 | case oox::XML_oMathParaPr: | |||
2142 | sResult += "oMathParaPr"; | |||
2143 | break; | |||
2144 | case oox::XML_oMath: | |||
2145 | sResult += "oMath"; | |||
2146 | break; | |||
2147 | case oox::XML_oMathPara: | |||
2148 | sResult += "oMathPara"; | |||
2149 | break; | |||
2150 | case oox::XML_dm: | |||
2151 | sResult += "dm"; | |||
2152 | break; | |||
2153 | case oox::XML_lo: | |||
2154 | sResult += "lo"; | |||
2155 | break; | |||
2156 | case oox::XML_qs: | |||
2157 | sResult += "qs"; | |||
2158 | break; | |||
2159 | case oox::XML_pict: | |||
2160 | sResult += "pict"; | |||
2161 | break; | |||
2162 | case oox::XML_href: | |||
2163 | sResult += "href"; | |||
2164 | break; | |||
2165 | case oox::XML_cNvPr: | |||
2166 | sResult += "cNvPr"; | |||
2167 | break; | |||
2168 | case oox::XML_cNvPicPr: | |||
2169 | sResult += "cNvPicPr"; | |||
2170 | break; | |||
2171 | case oox::XML_nvPicPr: | |||
2172 | sResult += "nvPicPr"; | |||
2173 | break; | |||
2174 | case oox::XML_pic: | |||
2175 | sResult += "pic"; | |||
2176 | break; | |||
2177 | case oox::XML_relIds: | |||
2178 | sResult += "relIds"; | |||
2179 | break; | |||
2180 | case oox::XML_nvGrpSpPr: | |||
2181 | sResult += "nvGrpSpPr"; | |||
2182 | break; | |||
2183 | case oox::XML_grpSpPr: | |||
2184 | sResult += "grpSpPr"; | |||
2185 | break; | |||
2186 | case oox::XML_lockedCanvas: | |||
2187 | sResult += "lockedCanvas"; | |||
2188 | break; | |||
2189 | case oox::XML_chart: | |||
2190 | sResult += "chart"; | |||
2191 | break; | |||
2192 | case oox::XML_cNvSpPr: | |||
2193 | sResult += "cNvSpPr"; | |||
2194 | break; | |||
2195 | case oox::XML_wsp: | |||
2196 | sResult += "wsp"; | |||
2197 | break; | |||
2198 | case oox::XML_cNvGrpSpPr: | |||
2199 | sResult += "cNvGrpSpPr"; | |||
2200 | break; | |||
2201 | case oox::XML_wgp: | |||
2202 | sResult += "wgp"; | |||
2203 | break; | |||
2204 | case oox::XML_style: | |||
2205 | sResult += "style"; | |||
2206 | break; | |||
2207 | case oox::XML_adj: | |||
2208 | sResult += "adj"; | |||
2209 | break; | |||
2210 | case oox::XML_filled: | |||
2211 | sResult += "filled"; | |||
2212 | break; | |||
2213 | case oox::XML_fillcolor: | |||
2214 | sResult += "fillcolor"; | |||
2215 | break; | |||
2216 | case oox::XML_chromakey: | |||
2217 | sResult += "chromakey"; | |||
2218 | break; | |||
2219 | case oox::XML_target: | |||
2220 | sResult += "target"; | |||
2221 | break; | |||
2222 | case oox::XML_class: | |||
2223 | sResult += "class"; | |||
2224 | break; | |||
2225 | case oox::XML_alt: | |||
2226 | sResult += "alt"; | |||
2227 | break; | |||
2228 | case oox::XML_coordsize: | |||
2229 | sResult += "coordsize"; | |||
2230 | break; | |||
2231 | case oox::XML_coordorigin: | |||
2232 | sResult += "coordorigin"; | |||
2233 | break; | |||
2234 | case oox::XML_wrapcoords: | |||
2235 | sResult += "wrapcoords"; | |||
2236 | break; | |||
2237 | case oox::XML_print: | |||
2238 | sResult += "print"; | |||
2239 | break; | |||
2240 | case oox::XML_opacity: | |||
2241 | sResult += "opacity"; | |||
2242 | break; | |||
2243 | case oox::XML_stroked: | |||
2244 | sResult += "stroked"; | |||
2245 | break; | |||
2246 | case oox::XML_strokecolor: | |||
2247 | sResult += "strokecolor"; | |||
2248 | break; | |||
2249 | case oox::XML_strokeweight: | |||
2250 | sResult += "strokeweight"; | |||
2251 | break; | |||
2252 | case oox::XML_insetpen: | |||
2253 | sResult += "insetpen"; | |||
2254 | break; | |||
2255 | case oox::XML_spid: | |||
2256 | sResult += "spid"; | |||
2257 | break; | |||
2258 | case oox::XML_oned: | |||
2259 | sResult += "oned"; | |||
2260 | break; | |||
2261 | case oox::XML_regroupid: | |||
2262 | sResult += "regroupid"; | |||
2263 | break; | |||
2264 | case oox::XML_doubleclicknotify: | |||
2265 | sResult += "doubleclicknotify"; | |||
2266 | break; | |||
2267 | case oox::XML_button: | |||
2268 | sResult += "button"; | |||
2269 | break; | |||
2270 | case oox::XML_userhidden: | |||
2271 | sResult += "userhidden"; | |||
2272 | break; | |||
2273 | case oox::XML_bullet: | |||
2274 | sResult += "bullet"; | |||
2275 | break; | |||
2276 | case oox::XML_hr: | |||
2277 | sResult += "hr"; | |||
2278 | break; | |||
2279 | case oox::XML_hrstd: | |||
2280 | sResult += "hrstd"; | |||
2281 | break; | |||
2282 | case oox::XML_hrnoshade: | |||
2283 | sResult += "hrnoshade"; | |||
2284 | break; | |||
2285 | case oox::XML_hrpct: | |||
2286 | sResult += "hrpct"; | |||
2287 | break; | |||
2288 | case oox::XML_hralign: | |||
2289 | sResult += "hralign"; | |||
2290 | break; | |||
2291 | case oox::XML_allowincell: | |||
2292 | sResult += "allowincell"; | |||
2293 | break; | |||
2294 | case oox::XML_allowoverlap: | |||
2295 | sResult += "allowoverlap"; | |||
2296 | break; | |||
2297 | case oox::XML_userdrawn: | |||
2298 | sResult += "userdrawn"; | |||
2299 | break; | |||
2300 | case oox::XML_bordertopcolor: | |||
2301 | sResult += "bordertopcolor"; | |||
2302 | break; | |||
2303 | case oox::XML_borderleftcolor: | |||
2304 | sResult += "borderleftcolor"; | |||
2305 | break; | |||
2306 | case oox::XML_borderbottomcolor: | |||
2307 | sResult += "borderbottomcolor"; | |||
2308 | break; | |||
2309 | case oox::XML_borderrightcolor: | |||
2310 | sResult += "borderrightcolor"; | |||
2311 | break; | |||
2312 | case oox::XML_dgmlayout: | |||
2313 | sResult += "dgmlayout"; | |||
2314 | break; | |||
2315 | case oox::XML_dgmnodekind: | |||
2316 | sResult += "dgmnodekind"; | |||
2317 | break; | |||
2318 | case oox::XML_dgmlayoutmru: | |||
2319 | sResult += "dgmlayoutmru"; | |||
2320 | break; | |||
2321 | case oox::XML_insetmode: | |||
2322 | sResult += "insetmode"; | |||
2323 | break; | |||
2324 | case oox::XML_spt: | |||
2325 | sResult += "spt"; | |||
2326 | break; | |||
2327 | case oox::XML_connectortype: | |||
2328 | sResult += "connectortype"; | |||
2329 | break; | |||
2330 | case oox::XML_bwmode: | |||
2331 | sResult += "bwmode"; | |||
2332 | break; | |||
2333 | case oox::XML_bwpure: | |||
2334 | sResult += "bwpure"; | |||
2335 | break; | |||
2336 | case oox::XML_bwnormal: | |||
2337 | sResult += "bwnormal"; | |||
2338 | break; | |||
2339 | case oox::XML_forcedash: | |||
2340 | sResult += "forcedash"; | |||
2341 | break; | |||
2342 | case oox::XML_oleicon: | |||
2343 | sResult += "oleicon"; | |||
2344 | break; | |||
2345 | case oox::XML_ole: | |||
2346 | sResult += "ole"; | |||
2347 | break; | |||
2348 | case oox::XML_preferrelative: | |||
2349 | sResult += "preferrelative"; | |||
2350 | break; | |||
2351 | case oox::XML_cliptowrap: | |||
2352 | sResult += "cliptowrap"; | |||
2353 | break; | |||
2354 | case oox::XML_clip: | |||
2355 | sResult += "clip"; | |||
2356 | break; | |||
2357 | case oox::XML_src: | |||
2358 | sResult += "src"; | |||
2359 | break; | |||
2360 | case oox::XML_cropleft: | |||
2361 | sResult += "cropleft"; | |||
2362 | break; | |||
2363 | case oox::XML_croptop: | |||
2364 | sResult += "croptop"; | |||
2365 | break; | |||
2366 | case oox::XML_cropright: | |||
2367 | sResult += "cropright"; | |||
2368 | break; | |||
2369 | case oox::XML_cropbottom: | |||
2370 | sResult += "cropbottom"; | |||
2371 | break; | |||
2372 | case oox::XML_gain: | |||
2373 | sResult += "gain"; | |||
2374 | break; | |||
2375 | case oox::XML_blacklevel: | |||
2376 | sResult += "blacklevel"; | |||
2377 | break; | |||
2378 | case oox::XML_grayscale: | |||
2379 | sResult += "grayscale"; | |||
2380 | break; | |||
2381 | case oox::XML_bilevel: | |||
2382 | sResult += "bilevel"; | |||
2383 | break; | |||
2384 | case oox::XML_on: | |||
2385 | sResult += "on"; | |||
2386 | break; | |||
2387 | case oox::XML_weight: | |||
2388 | sResult += "weight"; | |||
2389 | break; | |||
2390 | case oox::XML_color: | |||
2391 | sResult += "color"; | |||
2392 | break; | |||
2393 | case oox::XML_linestyle: | |||
2394 | sResult += "linestyle"; | |||
2395 | break; | |||
2396 | case oox::XML_miterlimit: | |||
2397 | sResult += "miterlimit"; | |||
2398 | break; | |||
2399 | case oox::XML_joinstyle: | |||
2400 | sResult += "joinstyle"; | |||
2401 | break; | |||
2402 | case oox::XML_endcap: | |||
2403 | sResult += "endcap"; | |||
2404 | break; | |||
2405 | case oox::XML_dashstyle: | |||
2406 | sResult += "dashstyle"; | |||
2407 | break; | |||
2408 | case oox::XML_filltype: | |||
2409 | sResult += "filltype"; | |||
2410 | break; | |||
2411 | case oox::XML_imageaspect: | |||
2412 | sResult += "imageaspect"; | |||
2413 | break; | |||
2414 | case oox::XML_imagesize: | |||
2415 | sResult += "imagesize"; | |||
2416 | break; | |||
2417 | case oox::XML_imagealignshape: | |||
2418 | sResult += "imagealignshape"; | |||
2419 | break; | |||
2420 | case oox::XML_color2: | |||
2421 | sResult += "color2"; | |||
2422 | break; | |||
2423 | case oox::XML_startarrow: | |||
2424 | sResult += "startarrow"; | |||
2425 | break; | |||
2426 | case oox::XML_startarrowwidth: | |||
2427 | sResult += "startarrowwidth"; | |||
2428 | break; | |||
2429 | case oox::XML_startarrowlength: | |||
2430 | sResult += "startarrowlength"; | |||
2431 | break; | |||
2432 | case oox::XML_endarrow: | |||
2433 | sResult += "endarrow"; | |||
2434 | break; | |||
2435 | case oox::XML_endarrowwidth: | |||
2436 | sResult += "endarrowwidth"; | |||
2437 | break; | |||
2438 | case oox::XML_endarrowlength: | |||
2439 | sResult += "endarrowlength"; | |||
2440 | break; | |||
2441 | case oox::XML_althref: | |||
2442 | sResult += "althref"; | |||
2443 | break; | |||
2444 | case oox::XML_relid: | |||
2445 | sResult += "relid"; | |||
2446 | break; | |||
2447 | case oox::XML_skew: | |||
2448 | sResult += "skew"; | |||
2449 | break; | |||
2450 | case oox::XML_extrusion: | |||
2451 | sResult += "extrusion"; | |||
2452 | break; | |||
2453 | case oox::XML_callout: | |||
2454 | sResult += "callout"; | |||
2455 | break; | |||
2456 | case oox::XML_lock: | |||
2457 | sResult += "lock"; | |||
2458 | break; | |||
2459 | case oox::XML_clippath: | |||
2460 | sResult += "clippath"; | |||
2461 | break; | |||
2462 | case oox::XML_signatureline: | |||
2463 | sResult += "signatureline"; | |||
2464 | break; | |||
2465 | case oox::XML_wrap: | |||
2466 | sResult += "wrap"; | |||
2467 | break; | |||
2468 | case oox::XML_anchorlock: | |||
2469 | sResult += "anchorlock"; | |||
2470 | break; | |||
2471 | case oox::XML_bordertop: | |||
2472 | sResult += "bordertop"; | |||
2473 | break; | |||
2474 | case oox::XML_borderbottom: | |||
2475 | sResult += "borderbottom"; | |||
2476 | break; | |||
2477 | case oox::XML_borderleft: | |||
2478 | sResult += "borderleft"; | |||
2479 | break; | |||
2480 | case oox::XML_borderright: | |||
2481 | sResult += "borderright"; | |||
2482 | break; | |||
2483 | case oox::XML_ClientData: | |||
2484 | sResult += "ClientData"; | |||
2485 | break; | |||
2486 | case oox::XML_textdata: | |||
2487 | sResult += "textdata"; | |||
2488 | break; | |||
2489 | case oox::XML_shape: | |||
2490 | sResult += "shape"; | |||
2491 | break; | |||
2492 | case oox::XML_shapetype: | |||
2493 | sResult += "shapetype"; | |||
2494 | break; | |||
2495 | case oox::XML_group: | |||
2496 | sResult += "group"; | |||
2497 | break; | |||
2498 | case oox::XML_background: | |||
2499 | sResult += "background"; | |||
2500 | break; | |||
2501 | case oox::XML_ink: | |||
2502 | sResult += "ink"; | |||
2503 | break; | |||
2504 | case oox::XML_iscomment: | |||
2505 | sResult += "iscomment"; | |||
2506 | break; | |||
2507 | case oox::XML_gfxdata: | |||
2508 | sResult += "gfxdata"; | |||
2509 | break; | |||
2510 | case oox::XML_equationxml: | |||
2511 | sResult += "equationxml"; | |||
2512 | break; | |||
2513 | case oox::XML_complex: | |||
2514 | sResult += "complex"; | |||
2515 | break; | |||
2516 | case oox::XML_master: | |||
2517 | sResult += "master"; | |||
2518 | break; | |||
2519 | case oox::XML_diagram: | |||
2520 | sResult += "diagram"; | |||
2521 | break; | |||
2522 | case oox::XML_editas: | |||
2523 | sResult += "editas"; | |||
2524 | break; | |||
2525 | case oox::XML_tableproperties: | |||
2526 | sResult += "tableproperties"; | |||
2527 | break; | |||
2528 | case oox::XML_tablelimits: | |||
2529 | sResult += "tablelimits"; | |||
2530 | break; | |||
2531 | case oox::XML_targetscreensize: | |||
2532 | sResult += "targetscreensize"; | |||
2533 | break; | |||
2534 | case oox::XML_formulas: | |||
2535 | sResult += "formulas"; | |||
2536 | break; | |||
2537 | case oox::XML_handles: | |||
2538 | sResult += "handles"; | |||
2539 | break; | |||
2540 | case oox::XML_imagedata: | |||
2541 | sResult += "imagedata"; | |||
2542 | break; | |||
2543 | case oox::XML_textbox: | |||
2544 | sResult += "textbox"; | |||
2545 | break; | |||
2546 | case oox::XML_textpath: | |||
2547 | sResult += "textpath"; | |||
2548 | break; | |||
2549 | case oox::XML_origin: | |||
2550 | sResult += "origin"; | |||
2551 | break; | |||
2552 | case oox::XML_position: | |||
2553 | sResult += "position"; | |||
2554 | break; | |||
2555 | case oox::XML_aspect: | |||
2556 | sResult += "aspect"; | |||
2557 | break; | |||
2558 | case oox::XML_colors: | |||
2559 | sResult += "colors"; | |||
2560 | break; | |||
2561 | case oox::XML_angle: | |||
2562 | sResult += "angle"; | |||
2563 | break; | |||
2564 | case oox::XML_alignshape: | |||
2565 | sResult += "alignshape"; | |||
2566 | break; | |||
2567 | case oox::XML_focus: | |||
2568 | sResult += "focus"; | |||
2569 | break; | |||
2570 | case oox::XML_focussize: | |||
2571 | sResult += "focussize"; | |||
2572 | break; | |||
2573 | case oox::XML_focusposition: | |||
2574 | sResult += "focusposition"; | |||
2575 | break; | |||
2576 | case oox::XML_method: | |||
2577 | sResult += "method"; | |||
2578 | break; | |||
2579 | case oox::XML_detectmouseclick: | |||
2580 | sResult += "detectmouseclick"; | |||
2581 | break; | |||
2582 | case oox::XML_opacity2: | |||
2583 | sResult += "opacity2"; | |||
2584 | break; | |||
2585 | case oox::XML_recolor: | |||
2586 | sResult += "recolor"; | |||
2587 | break; | |||
2588 | case oox::XML_rotate: | |||
2589 | sResult += "rotate"; | |||
2590 | break; | |||
2591 | case oox::XML_eqn: | |||
2592 | sResult += "eqn"; | |||
2593 | break; | |||
2594 | case oox::XML_polar: | |||
2595 | sResult += "polar"; | |||
2596 | break; | |||
2597 | case oox::XML_map: | |||
2598 | sResult += "map"; | |||
2599 | break; | |||
2600 | case oox::XML_invx: | |||
2601 | sResult += "invx"; | |||
2602 | break; | |||
2603 | case oox::XML_invy: | |||
2604 | sResult += "invy"; | |||
2605 | break; | |||
2606 | case oox::XML_switch: | |||
2607 | sResult += "switch"; | |||
2608 | break; | |||
2609 | case oox::XML_xrange: | |||
2610 | sResult += "xrange"; | |||
2611 | break; | |||
2612 | case oox::XML_yrange: | |||
2613 | sResult += "yrange"; | |||
2614 | break; | |||
2615 | case oox::XML_radiusrange: | |||
2616 | sResult += "radiusrange"; | |||
2617 | break; | |||
2618 | case oox::XML_embosscolor: | |||
2619 | sResult += "embosscolor"; | |||
2620 | break; | |||
2621 | case oox::XML_recolortarget: | |||
2622 | sResult += "recolortarget"; | |||
2623 | break; | |||
2624 | case oox::XML_oleid: | |||
2625 | sResult += "oleid"; | |||
2626 | break; | |||
2627 | case oox::XML_movie: | |||
2628 | sResult += "movie"; | |||
2629 | break; | |||
2630 | case oox::XML_v: | |||
2631 | sResult += "v"; | |||
2632 | break; | |||
2633 | case oox::XML_limo: | |||
2634 | sResult += "limo"; | |||
2635 | break; | |||
2636 | case oox::XML_textboxrect: | |||
2637 | sResult += "textboxrect"; | |||
2638 | break; | |||
2639 | case oox::XML_fillok: | |||
2640 | sResult += "fillok"; | |||
2641 | break; | |||
2642 | case oox::XML_strokeok: | |||
2643 | sResult += "strokeok"; | |||
2644 | break; | |||
2645 | case oox::XML_shadowok: | |||
2646 | sResult += "shadowok"; | |||
2647 | break; | |||
2648 | case oox::XML_arrowok: | |||
2649 | sResult += "arrowok"; | |||
2650 | break; | |||
2651 | case oox::XML_gradientshapeok: | |||
2652 | sResult += "gradientshapeok"; | |||
2653 | break; | |||
2654 | case oox::XML_textpathok: | |||
2655 | sResult += "textpathok"; | |||
2656 | break; | |||
2657 | case oox::XML_insetpenok: | |||
2658 | sResult += "insetpenok"; | |||
2659 | break; | |||
2660 | case oox::XML_connecttype: | |||
2661 | sResult += "connecttype"; | |||
2662 | break; | |||
2663 | case oox::XML_connectlocs: | |||
2664 | sResult += "connectlocs"; | |||
2665 | break; | |||
2666 | case oox::XML_connectangles: | |||
2667 | sResult += "connectangles"; | |||
2668 | break; | |||
2669 | case oox::XML_extrusionok: | |||
2670 | sResult += "extrusionok"; | |||
2671 | break; | |||
2672 | case oox::XML_obscured: | |||
2673 | sResult += "obscured"; | |||
2674 | break; | |||
2675 | case oox::XML_offset: | |||
2676 | sResult += "offset"; | |||
2677 | break; | |||
2678 | case oox::XML_offset2: | |||
2679 | sResult += "offset2"; | |||
2680 | break; | |||
2681 | case oox::XML_matrix: | |||
2682 | sResult += "matrix"; | |||
2683 | break; | |||
2684 | case oox::XML_left: | |||
2685 | sResult += "left"; | |||
2686 | break; | |||
2687 | case oox::XML_top: | |||
2688 | sResult += "top"; | |||
2689 | break; | |||
2690 | case oox::XML_right: | |||
2691 | sResult += "right"; | |||
2692 | break; | |||
2693 | case oox::XML_bottom: | |||
2694 | sResult += "bottom"; | |||
2695 | break; | |||
2696 | case oox::XML_column: | |||
2697 | sResult += "column"; | |||
2698 | break; | |||
2699 | case oox::XML_txbxContent: | |||
2700 | sResult += "txbxContent"; | |||
2701 | break; | |||
2702 | case oox::XML_inset: | |||
2703 | sResult += "inset"; | |||
2704 | break; | |||
2705 | case oox::XML_singleclick: | |||
2706 | sResult += "singleclick"; | |||
2707 | break; | |||
2708 | case oox::XML_fitshape: | |||
2709 | sResult += "fitshape"; | |||
2710 | break; | |||
2711 | case oox::XML_fitpath: | |||
2712 | sResult += "fitpath"; | |||
2713 | break; | |||
2714 | case oox::XML_trim: | |||
2715 | sResult += "trim"; | |||
2716 | break; | |||
2717 | case oox::XML_xscale: | |||
2718 | sResult += "xscale"; | |||
2719 | break; | |||
2720 | case oox::XML_string: | |||
2721 | sResult += "string"; | |||
2722 | break; | |||
2723 | case oox::XML_arc: | |||
2724 | sResult += "arc"; | |||
2725 | break; | |||
2726 | case oox::XML_curve: | |||
2727 | sResult += "curve"; | |||
2728 | break; | |||
2729 | case oox::XML_image: | |||
2730 | sResult += "image"; | |||
2731 | break; | |||
2732 | case oox::XML_line: | |||
2733 | sResult += "line"; | |||
2734 | break; | |||
2735 | case oox::XML_oval: | |||
2736 | sResult += "oval"; | |||
2737 | break; | |||
2738 | case oox::XML_polyline: | |||
2739 | sResult += "polyline"; | |||
2740 | break; | |||
2741 | case oox::XML_roundrect: | |||
2742 | sResult += "roundrect"; | |||
2743 | break; | |||
2744 | case oox::XML_startAngle: | |||
2745 | sResult += "startAngle"; | |||
2746 | break; | |||
2747 | case oox::XML_endAngle: | |||
2748 | sResult += "endAngle"; | |||
2749 | break; | |||
2750 | case oox::XML_from: | |||
2751 | sResult += "from"; | |||
2752 | break; | |||
2753 | case oox::XML_control1: | |||
2754 | sResult += "control1"; | |||
2755 | break; | |||
2756 | case oox::XML_control2: | |||
2757 | sResult += "control2"; | |||
2758 | break; | |||
2759 | case oox::XML_to: | |||
2760 | sResult += "to"; | |||
2761 | break; | |||
2762 | case oox::XML_points: | |||
2763 | sResult += "points"; | |||
2764 | break; | |||
2765 | case oox::XML_arcsize: | |||
2766 | sResult += "arcsize"; | |||
2767 | break; | |||
2768 | case oox::XML_shapedefaults: | |||
2769 | sResult += "shapedefaults"; | |||
2770 | break; | |||
2771 | case oox::XML_shapelayout: | |||
2772 | sResult += "shapelayout"; | |||
2773 | break; | |||
2774 | case oox::XML_colormru: | |||
2775 | sResult += "colormru"; | |||
2776 | break; | |||
2777 | case oox::XML_colormenu: | |||
2778 | sResult += "colormenu"; | |||
2779 | break; | |||
2780 | case oox::XML_spidmax: | |||
2781 | sResult += "spidmax"; | |||
2782 | break; | |||
2783 | case oox::XML_annotation: | |||
2784 | sResult += "annotation"; | |||
2785 | break; | |||
2786 | case oox::XML_issignatureline: | |||
2787 | sResult += "issignatureline"; | |||
2788 | break; | |||
2789 | case oox::XML_provid: | |||
2790 | sResult += "provid"; | |||
2791 | break; | |||
2792 | case oox::XML_signinginstructionsset: | |||
2793 | sResult += "signinginstructionsset"; | |||
2794 | break; | |||
2795 | case oox::XML_allowcomments: | |||
2796 | sResult += "allowcomments"; | |||
2797 | break; | |||
2798 | case oox::XML_showsigndate: | |||
2799 | sResult += "showsigndate"; | |||
2800 | break; | |||
2801 | case oox::XML_suggestedsigner: | |||
2802 | sResult += "suggestedsigner"; | |||
2803 | break; | |||
2804 | case oox::XML_suggestedsigner2: | |||
2805 | sResult += "suggestedsigner2"; | |||
2806 | break; | |||
2807 | case oox::XML_suggestedsigneremail: | |||
2808 | sResult += "suggestedsigneremail"; | |||
2809 | break; | |||
2810 | case oox::XML_signinginstructions: | |||
2811 | sResult += "signinginstructions"; | |||
2812 | break; | |||
2813 | case oox::XML_addlxml: | |||
2814 | sResult += "addlxml"; | |||
2815 | break; | |||
2816 | case oox::XML_sigprovurl: | |||
2817 | sResult += "sigprovurl"; | |||
2818 | break; | |||
2819 | case oox::XML_idmap: | |||
2820 | sResult += "idmap"; | |||
2821 | break; | |||
2822 | case oox::XML_regrouptable: | |||
2823 | sResult += "regrouptable"; | |||
2824 | break; | |||
2825 | case oox::XML_rules: | |||
2826 | sResult += "rules"; | |||
2827 | break; | |||
2828 | case oox::XML_data: | |||
2829 | sResult += "data"; | |||
2830 | break; | |||
2831 | case oox::XML_entry: | |||
2832 | sResult += "entry"; | |||
2833 | break; | |||
2834 | case oox::XML_new: | |||
2835 | sResult += "new"; | |||
2836 | break; | |||
2837 | case oox::XML_old: | |||
2838 | sResult += "old"; | |||
2839 | break; | |||
2840 | case oox::XML_proxy: | |||
2841 | sResult += "proxy"; | |||
2842 | break; | |||
2843 | case oox::XML_how: | |||
2844 | sResult += "how"; | |||
2845 | break; | |||
2846 | case oox::XML_idref: | |||
2847 | sResult += "idref"; | |||
2848 | break; | |||
2849 | case oox::XML_end: | |||
2850 | sResult += "end"; | |||
2851 | break; | |||
2852 | case oox::XML_connectloc: | |||
2853 | sResult += "connectloc"; | |||
2854 | break; | |||
2855 | case oox::XML_relationtable: | |||
2856 | sResult += "relationtable"; | |||
2857 | break; | |||
2858 | case oox::XML_dgmstyle: | |||
2859 | sResult += "dgmstyle"; | |||
2860 | break; | |||
2861 | case oox::XML_autoformat: | |||
2862 | sResult += "autoformat"; | |||
2863 | break; | |||
2864 | case oox::XML_reverse: | |||
2865 | sResult += "reverse"; | |||
2866 | break; | |||
2867 | case oox::XML_autolayout: | |||
2868 | sResult += "autolayout"; | |||
2869 | break; | |||
2870 | case oox::XML_dgmscalex: | |||
2871 | sResult += "dgmscalex"; | |||
2872 | break; | |||
2873 | case oox::XML_dgmscaley: | |||
2874 | sResult += "dgmscaley"; | |||
2875 | break; | |||
2876 | case oox::XML_dgmfontsize: | |||
2877 | sResult += "dgmfontsize"; | |||
2878 | break; | |||
2879 | case oox::XML_constrainbounds: | |||
2880 | sResult += "constrainbounds"; | |||
2881 | break; | |||
2882 | case oox::XML_dgmbasetextscale: | |||
2883 | sResult += "dgmbasetextscale"; | |||
2884 | break; | |||
2885 | case oox::XML_rel: | |||
2886 | sResult += "rel"; | |||
2887 | break; | |||
2888 | case oox::XML_idsrc: | |||
2889 | sResult += "idsrc"; | |||
2890 | break; | |||
2891 | case oox::XML_iddest: | |||
2892 | sResult += "iddest"; | |||
2893 | break; | |||
2894 | case oox::XML_idcntr: | |||
2895 | sResult += "idcntr"; | |||
2896 | break; | |||
2897 | case oox::XML_shadowcolor: | |||
2898 | sResult += "shadowcolor"; | |||
2899 | break; | |||
2900 | case oox::XML_extrusioncolor: | |||
2901 | sResult += "extrusioncolor"; | |||
2902 | break; | |||
2903 | case oox::XML_OLEObject: | |||
2904 | sResult += "OLEObject"; | |||
2905 | break; | |||
2906 | case oox::XML_render: | |||
2907 | sResult += "render"; | |||
2908 | break; | |||
2909 | case oox::XML_viewpointorigin: | |||
2910 | sResult += "viewpointorigin"; | |||
2911 | break; | |||
2912 | case oox::XML_viewpoint: | |||
2913 | sResult += "viewpoint"; | |||
2914 | break; | |||
2915 | case oox::XML_plane: | |||
2916 | sResult += "plane"; | |||
2917 | break; | |||
2918 | case oox::XML_skewangle: | |||
2919 | sResult += "skewangle"; | |||
2920 | break; | |||
2921 | case oox::XML_skewamt: | |||
2922 | sResult += "skewamt"; | |||
2923 | break; | |||
2924 | case oox::XML_foredepth: | |||
2925 | sResult += "foredepth"; | |||
2926 | break; | |||
2927 | case oox::XML_backdepth: | |||
2928 | sResult += "backdepth"; | |||
2929 | break; | |||
2930 | case oox::XML_orientation: | |||
2931 | sResult += "orientation"; | |||
2932 | break; | |||
2933 | case oox::XML_orientationangle: | |||
2934 | sResult += "orientationangle"; | |||
2935 | break; | |||
2936 | case oox::XML_lockrotationcenter: | |||
2937 | sResult += "lockrotationcenter"; | |||
2938 | break; | |||
2939 | case oox::XML_autorotationcenter: | |||
2940 | sResult += "autorotationcenter"; | |||
2941 | break; | |||
2942 | case oox::XML_rotationcenter: | |||
2943 | sResult += "rotationcenter"; | |||
2944 | break; | |||
2945 | case oox::XML_rotationangle: | |||
2946 | sResult += "rotationangle"; | |||
2947 | break; | |||
2948 | case oox::XML_colormode: | |||
2949 | sResult += "colormode"; | |||
2950 | break; | |||
2951 | case oox::XML_shininess: | |||
2952 | sResult += "shininess"; | |||
2953 | break; | |||
2954 | case oox::XML_specularity: | |||
2955 | sResult += "specularity"; | |||
2956 | break; | |||
2957 | case oox::XML_diffusity: | |||
2958 | sResult += "diffusity"; | |||
2959 | break; | |||
2960 | case oox::XML_metal: | |||
2961 | sResult += "metal"; | |||
2962 | break; | |||
2963 | case oox::XML_edge: | |||
2964 | sResult += "edge"; | |||
2965 | break; | |||
2966 | case oox::XML_facet: | |||
2967 | sResult += "facet"; | |||
2968 | break; | |||
2969 | case oox::XML_lightface: | |||
2970 | sResult += "lightface"; | |||
2971 | break; | |||
2972 | case oox::XML_brightness: | |||
2973 | sResult += "brightness"; | |||
2974 | break; | |||
2975 | case oox::XML_lightposition: | |||
2976 | sResult += "lightposition"; | |||
2977 | break; | |||
2978 | case oox::XML_lightlevel: | |||
2979 | sResult += "lightlevel"; | |||
2980 | break; | |||
2981 | case oox::XML_lightharsh: | |||
2982 | sResult += "lightharsh"; | |||
2983 | break; | |||
2984 | case oox::XML_lightposition2: | |||
2985 | sResult += "lightposition2"; | |||
2986 | break; | |||
2987 | case oox::XML_lightlevel2: | |||
2988 | sResult += "lightlevel2"; | |||
2989 | break; | |||
2990 | case oox::XML_lightharsh2: | |||
2991 | sResult += "lightharsh2"; | |||
2992 | break; | |||
2993 | case oox::XML_gap: | |||
2994 | sResult += "gap"; | |||
2995 | break; | |||
2996 | case oox::XML_dropauto: | |||
2997 | sResult += "dropauto"; | |||
2998 | break; | |||
2999 | case oox::XML_drop: | |||
3000 | sResult += "drop"; | |||
3001 | break; | |||
3002 | case oox::XML_distance: | |||
3003 | sResult += "distance"; | |||
3004 | break; | |||
3005 | case oox::XML_lengthspecified: | |||
3006 | sResult += "lengthspecified"; | |||
3007 | break; | |||
3008 | case oox::XML_length: | |||
3009 | sResult += "length"; | |||
3010 | break; | |||
3011 | case oox::XML_accentbar: | |||
3012 | sResult += "accentbar"; | |||
3013 | break; | |||
3014 | case oox::XML_textborder: | |||
3015 | sResult += "textborder"; | |||
3016 | break; | |||
3017 | case oox::XML_minusx: | |||
3018 | sResult += "minusx"; | |||
3019 | break; | |||
3020 | case oox::XML_minusy: | |||
3021 | sResult += "minusy"; | |||
3022 | break; | |||
3023 | case oox::XML_selection: | |||
3024 | sResult += "selection"; | |||
3025 | break; | |||
3026 | case oox::XML_grouping: | |||
3027 | sResult += "grouping"; | |||
3028 | break; | |||
3029 | case oox::XML_ungrouping: | |||
3030 | sResult += "ungrouping"; | |||
3031 | break; | |||
3032 | case oox::XML_rotation: | |||
3033 | sResult += "rotation"; | |||
3034 | break; | |||
3035 | case oox::XML_cropping: | |||
3036 | sResult += "cropping"; | |||
3037 | break; | |||
3038 | case oox::XML_verticies: | |||
3039 | sResult += "verticies"; | |||
3040 | break; | |||
3041 | case oox::XML_adjusthandles: | |||
3042 | sResult += "adjusthandles"; | |||
3043 | break; | |||
3044 | case oox::XML_text: | |||
3045 | sResult += "text"; | |||
3046 | break; | |||
3047 | case oox::XML_aspectratio: | |||
3048 | sResult += "aspectratio"; | |||
3049 | break; | |||
3050 | case oox::XML_LinkType: | |||
3051 | sResult += "LinkType"; | |||
3052 | break; | |||
3053 | case oox::XML_LockedField: | |||
3054 | sResult += "LockedField"; | |||
3055 | break; | |||
3056 | case oox::XML_FieldCodes: | |||
3057 | sResult += "FieldCodes"; | |||
3058 | break; | |||
3059 | case oox::XML_Type: | |||
3060 | sResult += "Type"; | |||
3061 | break; | |||
3062 | case oox::XML_ProgID: | |||
3063 | sResult += "ProgID"; | |||
3064 | break; | |||
3065 | case oox::XML_ShapeID: | |||
3066 | sResult += "ShapeID"; | |||
3067 | break; | |||
3068 | case oox::XML_DrawAspect: | |||
3069 | sResult += "DrawAspect"; | |||
3070 | break; | |||
3071 | case oox::XML_ObjectID: | |||
3072 | sResult += "ObjectID"; | |||
3073 | break; | |||
3074 | case oox::XML_UpdateMode: | |||
3075 | sResult += "UpdateMode"; | |||
3076 | break; | |||
3077 | case oox::XML_width: | |||
3078 | sResult += "width"; | |||
3079 | break; | |||
3080 | case oox::XML_side: | |||
3081 | sResult += "side"; | |||
3082 | break; | |||
3083 | case oox::XML_anchorx: | |||
3084 | sResult += "anchorx"; | |||
3085 | break; | |||
3086 | case oox::XML_anchory: | |||
3087 | sResult += "anchory"; | |||
3088 | break; | |||
3089 | case oox::XML_themeColor: | |||
3090 | sResult += "themeColor"; | |||
3091 | break; | |||
3092 | case oox::XML_themeTint: | |||
3093 | sResult += "themeTint"; | |||
3094 | break; | |||
3095 | case oox::XML_themeShade: | |||
3096 | sResult += "themeShade"; | |||
3097 | break; | |||
3098 | case oox::XML_frame: | |||
3099 | sResult += "frame"; | |||
3100 | break; | |||
3101 | case oox::XML_themeFill: | |||
3102 | sResult += "themeFill"; | |||
3103 | break; | |||
3104 | case oox::XML_themeFillTint: | |||
3105 | sResult += "themeFillTint"; | |||
3106 | break; | |||
3107 | case oox::XML_themeFillShade: | |||
3108 | sResult += "themeFillShade"; | |||
3109 | break; | |||
3110 | case oox::XML_eastAsia: | |||
3111 | sResult += "eastAsia"; | |||
3112 | break; | |||
3113 | case oox::XML_bidi: | |||
3114 | sResult += "bidi"; | |||
3115 | break; | |||
3116 | case oox::XML_combine: | |||
3117 | sResult += "combine"; | |||
3118 | break; | |||
3119 | case oox::XML_combineBrackets: | |||
3120 | sResult += "combineBrackets"; | |||
3121 | break; | |||
3122 | case oox::XML_vert: | |||
3123 | sResult += "vert"; | |||
3124 | break; | |||
3125 | case oox::XML_vertCompress: | |||
3126 | sResult += "vertCompress"; | |||
3127 | break; | |||
3128 | case oox::XML_dropCap: | |||
3129 | sResult += "dropCap"; | |||
3130 | break; | |||
3131 | case oox::XML_lines: | |||
3132 | sResult += "lines"; | |||
3133 | break; | |||
3134 | case oox::XML_vSpace: | |||
3135 | sResult += "vSpace"; | |||
3136 | break; | |||
3137 | case oox::XML_hSpace: | |||
3138 | sResult += "hSpace"; | |||
3139 | break; | |||
3140 | case oox::XML_hAnchor: | |||
3141 | sResult += "hAnchor"; | |||
3142 | break; | |||
3143 | case oox::XML_vAnchor: | |||
3144 | sResult += "vAnchor"; | |||
3145 | break; | |||
3146 | case oox::XML_xAlign: | |||
3147 | sResult += "xAlign"; | |||
3148 | break; | |||
3149 | case oox::XML_yAlign: | |||
3150 | sResult += "yAlign"; | |||
3151 | break; | |||
3152 | case oox::XML_hRule: | |||
3153 | sResult += "hRule"; | |||
3154 | break; | |||
3155 | case oox::XML_anchorLock: | |||
3156 | sResult += "anchorLock"; | |||
3157 | break; | |||
3158 | case oox::XML_leader: | |||
3159 | sResult += "leader"; | |||
3160 | break; | |||
3161 | case oox::XML_before: | |||
3162 | sResult += "before"; | |||
3163 | break; | |||
3164 | case oox::XML_beforeLines: | |||
3165 | sResult += "beforeLines"; | |||
3166 | break; | |||
3167 | case oox::XML_beforeAutospacing: | |||
3168 | sResult += "beforeAutospacing"; | |||
3169 | break; | |||
3170 | case oox::XML_after: | |||
3171 | sResult += "after"; | |||
3172 | break; | |||
3173 | case oox::XML_afterLines: | |||
3174 | sResult += "afterLines"; | |||
3175 | break; | |||
3176 | case oox::XML_afterAutospacing: | |||
3177 | sResult += "afterAutospacing"; | |||
3178 | break; | |||
3179 | case oox::XML_lineRule: | |||
3180 | sResult += "lineRule"; | |||
3181 | break; | |||
3182 | case oox::XML_endChars: | |||
3183 | sResult += "endChars"; | |||
3184 | break; | |||
3185 | case oox::XML_startChars: | |||
3186 | sResult += "startChars"; | |||
3187 | break; | |||
3188 | case oox::XML_leftChars: | |||
3189 | sResult += "leftChars"; | |||
3190 | break; | |||
3191 | case oox::XML_rightChars: | |||
3192 | sResult += "rightChars"; | |||
3193 | break; | |||
3194 | case oox::XML_hanging: | |||
3195 | sResult += "hanging"; | |||
3196 | break; | |||
3197 | case oox::XML_hangingChars: | |||
3198 | sResult += "hangingChars"; | |||
3199 | break; | |||
3200 | case oox::XML_firstLine: | |||
3201 | sResult += "firstLine"; | |||
3202 | break; | |||
3203 | case oox::XML_firstLineChars: | |||
3204 | sResult += "firstLineChars"; | |||
3205 | break; | |||
3206 | case oox::XML_percent: | |||
3207 | sResult += "percent"; | |||
3208 | break; | |||
3209 | case oox::XML_vendorID: | |||
3210 | sResult += "vendorID"; | |||
3211 | break; | |||
3212 | case oox::XML_dllVersion: | |||
3213 | sResult += "dllVersion"; | |||
3214 | break; | |||
3215 | case oox::XML_nlCheck: | |||
3216 | sResult += "nlCheck"; | |||
3217 | break; | |||
3218 | case oox::XML_checkStyle: | |||
3219 | sResult += "checkStyle"; | |||
3220 | break; | |||
3221 | case oox::XML_appName: | |||
3222 | sResult += "appName"; | |||
3223 | break; | |||
3224 | case oox::XML_spelling: | |||
3225 | sResult += "spelling"; | |||
3226 | break; | |||
3227 | case oox::XML_grammar: | |||
3228 | sResult += "grammar"; | |||
3229 | break; | |||
3230 | case oox::XML_cryptProviderType: | |||
3231 | sResult += "cryptProviderType"; | |||
3232 | break; | |||
3233 | case oox::XML_cryptAlgorithmClass: | |||
3234 | sResult += "cryptAlgorithmClass"; | |||
3235 | break; | |||
3236 | case oox::XML_cryptAlgorithmType: | |||
3237 | sResult += "cryptAlgorithmType"; | |||
3238 | break; | |||
3239 | case oox::XML_cryptAlgorithmSid: | |||
3240 | sResult += "cryptAlgorithmSid"; | |||
3241 | break; | |||
3242 | case oox::XML_cryptSpinCount: | |||
3243 | sResult += "cryptSpinCount"; | |||
3244 | break; | |||
3245 | case oox::XML_cryptProvider: | |||
3246 | sResult += "cryptProvider"; | |||
3247 | break; | |||
3248 | case oox::XML_algIdExt: | |||
3249 | sResult += "algIdExt"; | |||
3250 | break; | |||
3251 | case oox::XML_algIdExtSource: | |||
3252 | sResult += "algIdExtSource"; | |||
3253 | break; | |||
3254 | case oox::XML_cryptProviderTypeExt: | |||
3255 | sResult += "cryptProviderTypeExt"; | |||
3256 | break; | |||
3257 | case oox::XML_cryptProviderTypeExtSource: | |||
3258 | sResult += "cryptProviderTypeExtSource"; | |||
3259 | break; | |||
3260 | case oox::XML_hash: | |||
3261 | sResult += "hash"; | |||
3262 | break; | |||
3263 | case oox::XML_salt: | |||
3264 | sResult += "salt"; | |||
3265 | break; | |||
3266 | case oox::XML_edit: | |||
3267 | sResult += "edit"; | |||
3268 | break; | |||
3269 | case oox::XML_formatting: | |||
3270 | sResult += "formatting"; | |||
3271 | break; | |||
3272 | case oox::XML_enforcement: | |||
3273 | sResult += "enforcement"; | |||
3274 | break; | |||
3275 | case oox::XML_markup: | |||
3276 | sResult += "markup"; | |||
3277 | break; | |||
3278 | case oox::XML_comments: | |||
3279 | sResult += "comments"; | |||
3280 | break; | |||
3281 | case oox::XML_insDel: | |||
3282 | sResult += "insDel"; | |||
3283 | break; | |||
3284 | case oox::XML_inkAnnotations: | |||
3285 | sResult += "inkAnnotations"; | |||
3286 | break; | |||
3287 | case oox::XML_author: | |||
3288 | sResult += "author"; | |||
3289 | break; | |||
3290 | case oox::XML_date: | |||
3291 | sResult += "date"; | |||
3292 | break; | |||
3293 | case oox::XML_vMerge: | |||
3294 | sResult += "vMerge"; | |||
3295 | break; | |||
3296 | case oox::XML_vMergeOrig: | |||
3297 | sResult += "vMergeOrig"; | |||
3298 | break; | |||
3299 | case oox::XML_displacedByCustomXml: | |||
3300 | sResult += "displacedByCustomXml"; | |||
3301 | break; | |||
3302 | case oox::XML_colFirst: | |||
3303 | sResult += "colFirst"; | |||
3304 | break; | |||
3305 | case oox::XML_colLast: | |||
3306 | sResult += "colLast"; | |||
3307 | break; | |||
3308 | case oox::XML_initials: | |||
3309 | sResult += "initials"; | |||
3310 | break; | |||
3311 | case oox::XML_ed: | |||
3312 | sResult += "ed"; | |||
3313 | break; | |||
3314 | case oox::XML_edGrp: | |||
3315 | sResult += "edGrp"; | |||
3316 | break; | |||
3317 | case oox::XML_original: | |||
3318 | sResult += "original"; | |||
3319 | break; | |||
3320 | case oox::XML_tblPrEx: | |||
3321 | sResult += "tblPrEx"; | |||
3322 | break; | |||
3323 | case oox::XML_tcPr: | |||
3324 | sResult += "tcPr"; | |||
3325 | break; | |||
3326 | case oox::XML_trPr: | |||
3327 | sResult += "trPr"; | |||
3328 | break; | |||
3329 | case oox::XML_tblGrid: | |||
3330 | sResult += "tblGrid"; | |||
3331 | break; | |||
3332 | case oox::XML_tblPr: | |||
3333 | sResult += "tblPr"; | |||
3334 | break; | |||
3335 | case oox::XML_sectPr: | |||
3336 | sResult += "sectPr"; | |||
3337 | break; | |||
3338 | case oox::XML_pPr: | |||
3339 | sResult += "pPr"; | |||
3340 | break; | |||
3341 | case oox::XML_cellIns: | |||
3342 | sResult += "cellIns"; | |||
3343 | break; | |||
3344 | case oox::XML_cellDel: | |||
3345 | sResult += "cellDel"; | |||
3346 | break; | |||
3347 | case oox::XML_cellMerge: | |||
3348 | sResult += "cellMerge"; | |||
3349 | break; | |||
3350 | case oox::XML_bookmarkStart: | |||
3351 | sResult += "bookmarkStart"; | |||
3352 | break; | |||
3353 | case oox::XML_bookmarkEnd: | |||
3354 | sResult += "bookmarkEnd"; | |||
3355 | break; | |||
3356 | case oox::XML_permStart: | |||
3357 | sResult += "permStart"; | |||
3358 | break; | |||
3359 | case oox::XML_permEnd: | |||
3360 | sResult += "permEnd"; | |||
3361 | break; | |||
3362 | case oox::XML_moveFromRangeStart: | |||
3363 | sResult += "moveFromRangeStart"; | |||
3364 | break; | |||
3365 | case oox::XML_moveFromRangeEnd: | |||
3366 | sResult += "moveFromRangeEnd"; | |||
3367 | break; | |||
3368 | case oox::XML_moveToRangeStart: | |||
3369 | sResult += "moveToRangeStart"; | |||
3370 | break; | |||
3371 | case oox::XML_moveToRangeEnd: | |||
3372 | sResult += "moveToRangeEnd"; | |||
3373 | break; | |||
3374 | case oox::XML_commentRangeStart: | |||
3375 | sResult += "commentRangeStart"; | |||
3376 | break; | |||
3377 | case oox::XML_commentRangeEnd: | |||
3378 | sResult += "commentRangeEnd"; | |||
3379 | break; | |||
3380 | case oox::XML_customXmlInsRangeStart: | |||
3381 | sResult += "customXmlInsRangeStart"; | |||
3382 | break; | |||
3383 | case oox::XML_customXmlInsRangeEnd: | |||
3384 | sResult += "customXmlInsRangeEnd"; | |||
3385 | break; | |||
3386 | case oox::XML_customXmlDelRangeStart: | |||
3387 | sResult += "customXmlDelRangeStart"; | |||
3388 | break; | |||
3389 | case oox::XML_customXmlDelRangeEnd: | |||
3390 | sResult += "customXmlDelRangeEnd"; | |||
3391 | break; | |||
3392 | case oox::XML_customXmlMoveFromRangeStart: | |||
3393 | sResult += "customXmlMoveFromRangeStart"; | |||
3394 | break; | |||
3395 | case oox::XML_customXmlMoveFromRangeEnd: | |||
3396 | sResult += "customXmlMoveFromRangeEnd"; | |||
3397 | break; | |||
3398 | case oox::XML_customXmlMoveToRangeStart: | |||
3399 | sResult += "customXmlMoveToRangeStart"; | |||
3400 | break; | |||
3401 | case oox::XML_customXmlMoveToRangeEnd: | |||
3402 | sResult += "customXmlMoveToRangeEnd"; | |||
3403 | break; | |||
3404 | case oox::XML_ilvl: | |||
3405 | sResult += "ilvl"; | |||
3406 | break; | |||
3407 | case oox::XML_numId: | |||
3408 | sResult += "numId"; | |||
3409 | break; | |||
3410 | case oox::XML_numberingChange: | |||
3411 | sResult += "numberingChange"; | |||
3412 | break; | |||
3413 | case oox::XML_ins: | |||
3414 | sResult += "ins"; | |||
3415 | break; | |||
3416 | case oox::XML_between: | |||
3417 | sResult += "between"; | |||
3418 | break; | |||
3419 | case oox::XML_tab: | |||
3420 | sResult += "tab"; | |||
3421 | break; | |||
3422 | case oox::XML_pStyle: | |||
3423 | sResult += "pStyle"; | |||
3424 | break; | |||
3425 | case oox::XML_keepNext: | |||
3426 | sResult += "keepNext"; | |||
3427 | break; | |||
3428 | case oox::XML_keepLines: | |||
3429 | sResult += "keepLines"; | |||
3430 | break; | |||
3431 | case oox::XML_pageBreakBefore: | |||
3432 | sResult += "pageBreakBefore"; | |||
3433 | break; | |||
3434 | case oox::XML_framePr: | |||
3435 | sResult += "framePr"; | |||
3436 | break; | |||
3437 | case oox::XML_widowControl: | |||
3438 | sResult += "widowControl"; | |||
3439 | break; | |||
3440 | case oox::XML_numPr: | |||
3441 | sResult += "numPr"; | |||
3442 | break; | |||
3443 | case oox::XML_suppressLineNumbers: | |||
3444 | sResult += "suppressLineNumbers"; | |||
3445 | break; | |||
3446 | case oox::XML_pBdr: | |||
3447 | sResult += "pBdr"; | |||
3448 | break; | |||
3449 | case oox::XML_shd: | |||
3450 | sResult += "shd"; | |||
3451 | break; | |||
3452 | case oox::XML_tabs: | |||
3453 | sResult += "tabs"; | |||
3454 | break; | |||
3455 | case oox::XML_suppressAutoHyphens: | |||
3456 | sResult += "suppressAutoHyphens"; | |||
3457 | break; | |||
3458 | case oox::XML_kinsoku: | |||
3459 | sResult += "kinsoku"; | |||
3460 | break; | |||
3461 | case oox::XML_wordWrap: | |||
3462 | sResult += "wordWrap"; | |||
3463 | break; | |||
3464 | case oox::XML_overflowPunct: | |||
3465 | sResult += "overflowPunct"; | |||
3466 | break; | |||
3467 | case oox::XML_topLinePunct: | |||
3468 | sResult += "topLinePunct"; | |||
3469 | break; | |||
3470 | case oox::XML_autoSpaceDE: | |||
3471 | sResult += "autoSpaceDE"; | |||
3472 | break; | |||
3473 | case oox::XML_autoSpaceDN: | |||
3474 | sResult += "autoSpaceDN"; | |||
3475 | break; | |||
3476 | case oox::XML_adjustRightInd: | |||
3477 | sResult += "adjustRightInd"; | |||
3478 | break; | |||
3479 | case oox::XML_snapToGrid: | |||
3480 | sResult += "snapToGrid"; | |||
3481 | break; | |||
3482 | case oox::XML_spacing: | |||
3483 | sResult += "spacing"; | |||
3484 | break; | |||
3485 | case oox::XML_ind: | |||
3486 | sResult += "ind"; | |||
3487 | break; | |||
3488 | case oox::XML_contextualSpacing: | |||
3489 | sResult += "contextualSpacing"; | |||
3490 | break; | |||
3491 | case oox::XML_mirrorIndents: | |||
3492 | sResult += "mirrorIndents"; | |||
3493 | break; | |||
3494 | case oox::XML_suppressOverlap: | |||
3495 | sResult += "suppressOverlap"; | |||
3496 | break; | |||
3497 | case oox::XML_textDirection: | |||
3498 | sResult += "textDirection"; | |||
3499 | break; | |||
3500 | case oox::XML_textAlignment: | |||
3501 | sResult += "textAlignment"; | |||
3502 | break; | |||
3503 | case oox::XML_textboxTightWrap: | |||
3504 | sResult += "textboxTightWrap"; | |||
3505 | break; | |||
3506 | case oox::XML_outlineLvl: | |||
3507 | sResult += "outlineLvl"; | |||
3508 | break; | |||
3509 | case oox::XML_divId: | |||
3510 | sResult += "divId"; | |||
3511 | break; | |||
3512 | case oox::XML_cnfStyle: | |||
3513 | sResult += "cnfStyle"; | |||
3514 | break; | |||
3515 | case oox::XML_pPrChange: | |||
3516 | sResult += "pPrChange"; | |||
3517 | break; | |||
3518 | case oox::XML_dxaOrig: | |||
3519 | sResult += "dxaOrig"; | |||
3520 | break; | |||
3521 | case oox::XML_dyaOrig: | |||
3522 | sResult += "dyaOrig"; | |||
3523 | break; | |||
3524 | case oox::XML_fldData: | |||
3525 | sResult += "fldData"; | |||
3526 | break; | |||
3527 | case oox::XML_instr: | |||
3528 | sResult += "instr"; | |||
3529 | break; | |||
3530 | case oox::XML_fldLock: | |||
3531 | sResult += "fldLock"; | |||
3532 | break; | |||
3533 | case oox::XML_ffData: | |||
3534 | sResult += "ffData"; | |||
3535 | break; | |||
3536 | case oox::XML_fldCharType: | |||
3537 | sResult += "fldCharType"; | |||
3538 | break; | |||
3539 | case oox::XML_docLocation: | |||
3540 | sResult += "docLocation"; | |||
3541 | break; | |||
3542 | case oox::XML_enabled: | |||
3543 | sResult += "enabled"; | |||
3544 | break; | |||
3545 | case oox::XML_calcOnExit: | |||
3546 | sResult += "calcOnExit"; | |||
3547 | break; | |||
3548 | case oox::XML_entryMacro: | |||
3549 | sResult += "entryMacro"; | |||
3550 | break; | |||
3551 | case oox::XML_exitMacro: | |||
3552 | sResult += "exitMacro"; | |||
3553 | break; | |||
3554 | case oox::XML_helpText: | |||
3555 | sResult += "helpText"; | |||
3556 | break; | |||
3557 | case oox::XML_statusText: | |||
3558 | sResult += "statusText"; | |||
3559 | break; | |||
3560 | case oox::XML_checkBox: | |||
3561 | sResult += "checkBox"; | |||
3562 | break; | |||
3563 | case oox::XML_ddList: | |||
3564 | sResult += "ddList"; | |||
3565 | break; | |||
3566 | case oox::XML_textInput: | |||
3567 | sResult += "textInput"; | |||
3568 | break; | |||
3569 | case oox::XML_sizeAuto: | |||
3570 | sResult += "sizeAuto"; | |||
3571 | break; | |||
3572 | case oox::XML_default: | |||
3573 | sResult += "default"; | |||
3574 | break; | |||
3575 | case oox::XML_result: | |||
3576 | sResult += "result"; | |||
3577 | break; | |||
3578 | case oox::XML_listEntry: | |||
3579 | sResult += "listEntry"; | |||
3580 | break; | |||
3581 | case oox::XML_maxLength: | |||
3582 | sResult += "maxLength"; | |||
3583 | break; | |||
3584 | case oox::XML_format: | |||
3585 | sResult += "format"; | |||
3586 | break; | |||
3587 | case oox::XML_first: | |||
3588 | sResult += "first"; | |||
3589 | break; | |||
3590 | case oox::XML_other: | |||
3591 | sResult += "other"; | |||
3592 | break; | |||
3593 | case oox::XML_orient: | |||
3594 | sResult += "orient"; | |||
3595 | break; | |||
3596 | case oox::XML_code: | |||
3597 | sResult += "code"; | |||
3598 | break; | |||
3599 | case oox::XML_header: | |||
3600 | sResult += "header"; | |||
3601 | break; | |||
3602 | case oox::XML_footer: | |||
3603 | sResult += "footer"; | |||
3604 | break; | |||
3605 | case oox::XML_gutter: | |||
3606 | sResult += "gutter"; | |||
3607 | break; | |||
3608 | case oox::XML_zOrder: | |||
3609 | sResult += "zOrder"; | |||
3610 | break; | |||
3611 | case oox::XML_display: | |||
3612 | sResult += "display"; | |||
3613 | break; | |||
3614 | case oox::XML_offsetFrom: | |||
3615 | sResult += "offsetFrom"; | |||
3616 | break; | |||
3617 | case oox::XML_countBy: | |||
3618 | sResult += "countBy"; | |||
3619 | break; | |||
3620 | case oox::XML_restart: | |||
3621 | sResult += "restart"; | |||
3622 | break; | |||
3623 | case oox::XML_fmt: | |||
3624 | sResult += "fmt"; | |||
3625 | break; | |||
3626 | case oox::XML_chapStyle: | |||
3627 | sResult += "chapStyle"; | |||
3628 | break; | |||
3629 | case oox::XML_chapSep: | |||
3630 | sResult += "chapSep"; | |||
3631 | break; | |||
3632 | case oox::XML_col: | |||
3633 | sResult += "col"; | |||
3634 | break; | |||
3635 | case oox::XML_equalWidth: | |||
3636 | sResult += "equalWidth"; | |||
3637 | break; | |||
3638 | case oox::XML_sep: | |||
3639 | sResult += "sep"; | |||
3640 | break; | |||
3641 | case oox::XML_linePitch: | |||
3642 | sResult += "linePitch"; | |||
3643 | break; | |||
3644 | case oox::XML_charSpace: | |||
3645 | sResult += "charSpace"; | |||
3646 | break; | |||
3647 | case oox::XML_headerReference: | |||
3648 | sResult += "headerReference"; | |||
3649 | break; | |||
3650 | case oox::XML_footerReference: | |||
3651 | sResult += "footerReference"; | |||
3652 | break; | |||
3653 | case oox::XML_footnotePr: | |||
3654 | sResult += "footnotePr"; | |||
3655 | break; | |||
3656 | case oox::XML_endnotePr: | |||
3657 | sResult += "endnotePr"; | |||
3658 | break; | |||
3659 | case oox::XML_pgSz: | |||
3660 | sResult += "pgSz"; | |||
3661 | break; | |||
3662 | case oox::XML_pgMar: | |||
3663 | sResult += "pgMar"; | |||
3664 | break; | |||
3665 | case oox::XML_paperSrc: | |||
3666 | sResult += "paperSrc"; | |||
3667 | break; | |||
3668 | case oox::XML_pgBorders: | |||
3669 | sResult += "pgBorders"; | |||
3670 | break; | |||
3671 | case oox::XML_lnNumType: | |||
3672 | sResult += "lnNumType"; | |||
3673 | break; | |||
3674 | case oox::XML_pgNumType: | |||
3675 | sResult += "pgNumType"; | |||
3676 | break; | |||
3677 | case oox::XML_cols: | |||
3678 | sResult += "cols"; | |||
3679 | break; | |||
3680 | case oox::XML_formProt: | |||
3681 | sResult += "formProt"; | |||
3682 | break; | |||
3683 | case oox::XML_vAlign: | |||
3684 | sResult += "vAlign"; | |||
3685 | break; | |||
3686 | case oox::XML_noEndnote: | |||
3687 | sResult += "noEndnote"; | |||
3688 | break; | |||
3689 | case oox::XML_titlePg: | |||
3690 | sResult += "titlePg"; | |||
3691 | break; | |||
3692 | case oox::XML_rtlGutter: | |||
3693 | sResult += "rtlGutter"; | |||
3694 | break; | |||
3695 | case oox::XML_docGrid: | |||
3696 | sResult += "docGrid"; | |||
3697 | break; | |||
3698 | case oox::XML_printerSettings: | |||
3699 | sResult += "printerSettings"; | |||
3700 | break; | |||
3701 | case oox::XML_rsidRPr: | |||
3702 | sResult += "rsidRPr"; | |||
3703 | break; | |||
3704 | case oox::XML_rsidDel: | |||
3705 | sResult += "rsidDel"; | |||
3706 | break; | |||
3707 | case oox::XML_rsidR: | |||
3708 | sResult += "rsidR"; | |||
3709 | break; | |||
3710 | case oox::XML_rsidSect: | |||
3711 | sResult += "rsidSect"; | |||
3712 | break; | |||
3713 | case oox::XML_sectPrChange: | |||
3714 | sResult += "sectPrChange"; | |||
3715 | break; | |||
3716 | case oox::XML_clear: | |||
3717 | sResult += "clear"; | |||
3718 | break; | |||
3719 | case oox::XML_alignment: | |||
3720 | sResult += "alignment"; | |||
3721 | break; | |||
3722 | case oox::XML_relativeTo: | |||
3723 | sResult += "relativeTo"; | |||
3724 | break; | |||
3725 | case oox::XML_char: | |||
3726 | sResult += "char"; | |||
3727 | break; | |||
3728 | case oox::XML_br: | |||
3729 | sResult += "br"; | |||
3730 | break; | |||
3731 | case oox::XML_delText: | |||
3732 | sResult += "delText"; | |||
3733 | break; | |||
3734 | case oox::XML_instrText: | |||
3735 | sResult += "instrText"; | |||
3736 | break; | |||
3737 | case oox::XML_delInstrText: | |||
3738 | sResult += "delInstrText"; | |||
3739 | break; | |||
3740 | case oox::XML_noBreakHyphen: | |||
3741 | sResult += "noBreakHyphen"; | |||
3742 | break; | |||
3743 | case oox::XML_softHyphen: | |||
3744 | sResult += "softHyphen"; | |||
3745 | break; | |||
3746 | case oox::XML_dayShort: | |||
3747 | sResult += "dayShort"; | |||
3748 | break; | |||
3749 | case oox::XML_monthShort: | |||
3750 | sResult += "monthShort"; | |||
3751 | break; | |||
3752 | case oox::XML_yearShort: | |||
3753 | sResult += "yearShort"; | |||
3754 | break; | |||
3755 | case oox::XML_dayLong: | |||
3756 | sResult += "dayLong"; | |||
3757 | break; | |||
3758 | case oox::XML_monthLong: | |||
3759 | sResult += "monthLong"; | |||
3760 | break; | |||
3761 | case oox::XML_yearLong: | |||
3762 | sResult += "yearLong"; | |||
3763 | break; | |||
3764 | case oox::XML_annotationRef: | |||
3765 | sResult += "annotationRef"; | |||
3766 | break; | |||
3767 | case oox::XML_footnoteRef: | |||
3768 | sResult += "footnoteRef"; | |||
3769 | break; | |||
3770 | case oox::XML_endnoteRef: | |||
3771 | sResult += "endnoteRef"; | |||
3772 | break; | |||
3773 | case oox::XML_separator: | |||
3774 | sResult += "separator"; | |||
3775 | break; | |||
3776 | case oox::XML_continuationSeparator: | |||
3777 | sResult += "continuationSeparator"; | |||
3778 | break; | |||
3779 | case oox::XML_pgNum: | |||
3780 | sResult += "pgNum"; | |||
3781 | break; | |||
3782 | case oox::XML_cr: | |||
3783 | sResult += "cr"; | |||
3784 | break; | |||
3785 | case oox::XML_object: | |||
3786 | sResult += "object"; | |||
3787 | break; | |||
3788 | case oox::XML_fldChar: | |||
3789 | sResult += "fldChar"; | |||
3790 | break; | |||
3791 | case oox::XML_ruby: | |||
3792 | sResult += "ruby"; | |||
3793 | break; | |||
3794 | case oox::XML_footnoteReference: | |||
3795 | sResult += "footnoteReference"; | |||
3796 | break; | |||
3797 | case oox::XML_endnoteReference: | |||
3798 | sResult += "endnoteReference"; | |||
3799 | break; | |||
3800 | case oox::XML_commentReference: | |||
3801 | sResult += "commentReference"; | |||
3802 | break; | |||
3803 | case oox::XML_drawing: | |||
3804 | sResult += "drawing"; | |||
3805 | break; | |||
3806 | case oox::XML_ptab: | |||
3807 | sResult += "ptab"; | |||
3808 | break; | |||
3809 | case oox::XML_lastRenderedPageBreak: | |||
3810 | sResult += "lastRenderedPageBreak"; | |||
3811 | break; | |||
3812 | case oox::XML_hint: | |||
3813 | sResult += "hint"; | |||
3814 | break; | |||
3815 | case oox::XML_ascii: | |||
3816 | sResult += "ascii"; | |||
3817 | break; | |||
3818 | case oox::XML_hAnsi: | |||
3819 | sResult += "hAnsi"; | |||
3820 | break; | |||
3821 | case oox::XML_asciiTheme: | |||
3822 | sResult += "asciiTheme"; | |||
3823 | break; | |||
3824 | case oox::XML_hAnsiTheme: | |||
3825 | sResult += "hAnsiTheme"; | |||
3826 | break; | |||
3827 | case oox::XML_eastAsiaTheme: | |||
3828 | sResult += "eastAsiaTheme"; | |||
3829 | break; | |||
3830 | case oox::XML_cstheme: | |||
3831 | sResult += "cstheme"; | |||
3832 | break; | |||
3833 | case oox::XML_rStyle: | |||
3834 | sResult += "rStyle"; | |||
3835 | break; | |||
3836 | case oox::XML_rFonts: | |||
3837 | sResult += "rFonts"; | |||
3838 | break; | |||
3839 | case oox::XML_bCs: | |||
3840 | sResult += "bCs"; | |||
3841 | break; | |||
3842 | case oox::XML_iCs: | |||
3843 | sResult += "iCs"; | |||
3844 | break; | |||
3845 | case oox::XML_caps: | |||
3846 | sResult += "caps"; | |||
3847 | break; | |||
3848 | case oox::XML_smallCaps: | |||
3849 | sResult += "smallCaps"; | |||
3850 | break; | |||
3851 | case oox::XML_dstrike: | |||
3852 | sResult += "dstrike"; | |||
3853 | break; | |||
3854 | case oox::XML_outline: | |||
3855 | sResult += "outline"; | |||
3856 | break; | |||
3857 | case oox::XML_emboss: | |||
3858 | sResult += "emboss"; | |||
3859 | break; | |||
3860 | case oox::XML_imprint: | |||
3861 | sResult += "imprint"; | |||
3862 | break; | |||
3863 | case oox::XML_vanish: | |||
3864 | sResult += "vanish"; | |||
3865 | break; | |||
3866 | case oox::XML_webHidden: | |||
3867 | sResult += "webHidden"; | |||
3868 | break; | |||
3869 | case oox::XML_szCs: | |||
3870 | sResult += "szCs"; | |||
3871 | break; | |||
3872 | case oox::XML_bdr: | |||
3873 | sResult += "bdr"; | |||
3874 | break; | |||
3875 | case oox::XML_fitText: | |||
3876 | sResult += "fitText"; | |||
3877 | break; | |||
3878 | case oox::XML_vertAlign: | |||
3879 | sResult += "vertAlign"; | |||
3880 | break; | |||
3881 | case oox::XML_rtl: | |||
3882 | sResult += "rtl"; | |||
3883 | break; | |||
3884 | case oox::XML_em: | |||
3885 | sResult += "em"; | |||
3886 | break; | |||
3887 | case oox::XML_eastAsianLayout: | |||
3888 | sResult += "eastAsianLayout"; | |||
3889 | break; | |||
3890 | case oox::XML_specVanish: | |||
3891 | sResult += "specVanish"; | |||
3892 | break; | |||
3893 | case oox::XML_rPrChange: | |||
3894 | sResult += "rPrChange"; | |||
3895 | break; | |||
3896 | case oox::XML_del: | |||
3897 | sResult += "del"; | |||
3898 | break; | |||
3899 | case oox::XML_moveFrom: | |||
3900 | sResult += "moveFrom"; | |||
3901 | break; | |||
3902 | case oox::XML_altChunkPr: | |||
3903 | sResult += "altChunkPr"; | |||
3904 | break; | |||
3905 | case oox::XML_matchSrc: | |||
3906 | sResult += "matchSrc"; | |||
3907 | break; | |||
3908 | case oox::XML_rubyAlign: | |||
3909 | sResult += "rubyAlign"; | |||
3910 | break; | |||
3911 | case oox::XML_hps: | |||
3912 | sResult += "hps"; | |||
3913 | break; | |||
3914 | case oox::XML_hpsRaise: | |||
3915 | sResult += "hpsRaise"; | |||
3916 | break; | |||
3917 | case oox::XML_hpsBaseText: | |||
3918 | sResult += "hpsBaseText"; | |||
3919 | break; | |||
3920 | case oox::XML_lid: | |||
3921 | sResult += "lid"; | |||
3922 | break; | |||
3923 | case oox::XML_rubyPr: | |||
3924 | sResult += "rubyPr"; | |||
3925 | break; | |||
3926 | case oox::XML_rt: | |||
3927 | sResult += "rt"; | |||
3928 | break; | |||
3929 | case oox::XML_rubyBase: | |||
3930 | sResult += "rubyBase"; | |||
3931 | break; | |||
3932 | case oox::XML_displayText: | |||
3933 | sResult += "displayText"; | |||
3934 | break; | |||
3935 | case oox::XML_value: | |||
3936 | sResult += "value"; | |||
3937 | break; | |||
3938 | case oox::XML_dateFormat: | |||
3939 | sResult += "dateFormat"; | |||
3940 | break; | |||
3941 | case oox::XML_storeMappedDataAs: | |||
3942 | sResult += "storeMappedDataAs"; | |||
3943 | break; | |||
3944 | case oox::XML_calendar: | |||
3945 | sResult += "calendar"; | |||
3946 | break; | |||
3947 | case oox::XML_fullDate: | |||
3948 | sResult += "fullDate"; | |||
3949 | break; | |||
3950 | case oox::XML_docPartGallery: | |||
3951 | sResult += "docPartGallery"; | |||
3952 | break; | |||
3953 | case oox::XML_docPartCategory: | |||
3954 | sResult += "docPartCategory"; | |||
3955 | break; | |||
3956 | case oox::XML_docPartUnique: | |||
3957 | sResult += "docPartUnique"; | |||
3958 | break; | |||
3959 | case oox::XML_listItem: | |||
3960 | sResult += "listItem"; | |||
3961 | break; | |||
3962 | case oox::XML_lastValue: | |||
3963 | sResult += "lastValue"; | |||
3964 | break; | |||
3965 | case oox::XML_docPart: | |||
3966 | sResult += "docPart"; | |||
3967 | break; | |||
3968 | case oox::XML_multiLine: | |||
3969 | sResult += "multiLine"; | |||
3970 | break; | |||
3971 | case oox::XML_prefixMappings: | |||
3972 | sResult += "prefixMappings"; | |||
3973 | break; | |||
3974 | case oox::XML_xpath: | |||
3975 | sResult += "xpath"; | |||
3976 | break; | |||
3977 | case oox::XML_storeItemID: | |||
3978 | sResult += "storeItemID"; | |||
3979 | break; | |||
3980 | case oox::XML_alias: | |||
3981 | sResult += "alias"; | |||
3982 | break; | |||
3983 | case oox::XML_placeholder: | |||
3984 | sResult += "placeholder"; | |||
3985 | break; | |||
3986 | case oox::XML_showingPlcHdr: | |||
3987 | sResult += "showingPlcHdr"; | |||
3988 | break; | |||
3989 | case oox::XML_dataBinding: | |||
3990 | sResult += "dataBinding"; | |||
3991 | break; | |||
3992 | case oox::XML_temporary: | |||
3993 | sResult += "temporary"; | |||
3994 | break; | |||
3995 | case oox::XML_tag: | |||
3996 | sResult += "tag"; | |||
3997 | break; | |||
3998 | case oox::XML_equation: | |||
3999 | sResult += "equation"; | |||
4000 | break; | |||
4001 | case oox::XML_comboBox: | |||
4002 | sResult += "comboBox"; | |||
4003 | break; | |||
4004 | case oox::XML_checkbox: | |||
4005 | sResult += "checkbox"; | |||
4006 | break; | |||
4007 | case oox::XML_docPartObj: | |||
4008 | sResult += "docPartObj"; | |||
4009 | break; | |||
4010 | case oox::XML_docPartList: | |||
4011 | sResult += "docPartList"; | |||
4012 | break; | |||
4013 | case oox::XML_dropDownList: | |||
4014 | sResult += "dropDownList"; | |||
4015 | break; | |||
4016 | case oox::XML_picture: | |||
4017 | sResult += "picture"; | |||
4018 | break; | |||
4019 | case oox::XML_richText: | |||
4020 | sResult += "richText"; | |||
4021 | break; | |||
4022 | case oox::XML_citation: | |||
4023 | sResult += "citation"; | |||
4024 | break; | |||
4025 | case oox::XML_bibliography: | |||
4026 | sResult += "bibliography"; | |||
4027 | break; | |||
4028 | case oox::XML_customXml: | |||
4029 | sResult += "customXml"; | |||
4030 | break; | |||
4031 | case oox::XML_smartTag: | |||
4032 | sResult += "smartTag"; | |||
4033 | break; | |||
4034 | case oox::XML_sdt: | |||
4035 | sResult += "sdt"; | |||
4036 | break; | |||
4037 | case oox::XML_p: | |||
4038 | sResult += "p"; | |||
4039 | break; | |||
4040 | case oox::XML_tbl: | |||
4041 | sResult += "tbl"; | |||
4042 | break; | |||
4043 | case oox::XML_tr: | |||
4044 | sResult += "tr"; | |||
4045 | break; | |||
4046 | case oox::XML_tc: | |||
4047 | sResult += "tc"; | |||
4048 | break; | |||
4049 | case oox::XML_sdtPr: | |||
4050 | sResult += "sdtPr"; | |||
4051 | break; | |||
4052 | case oox::XML_sdtEndPr: | |||
4053 | sResult += "sdtEndPr"; | |||
4054 | break; | |||
4055 | case oox::XML_sdtContent: | |||
4056 | sResult += "sdtContent"; | |||
4057 | break; | |||
4058 | case oox::XML_customXmlPr: | |||
4059 | sResult += "customXmlPr"; | |||
4060 | break; | |||
4061 | case oox::XML_element: | |||
4062 | sResult += "element"; | |||
4063 | break; | |||
4064 | case oox::XML_smartTagPr: | |||
4065 | sResult += "smartTagPr"; | |||
4066 | break; | |||
4067 | case oox::XML_attr: | |||
4068 | sResult += "attr"; | |||
4069 | break; | |||
4070 | case oox::XML_fldSimple: | |||
4071 | sResult += "fldSimple"; | |||
4072 | break; | |||
4073 | case oox::XML_hyperlink: | |||
4074 | sResult += "hyperlink"; | |||
4075 | break; | |||
4076 | case oox::XML_subDoc: | |||
4077 | sResult += "subDoc"; | |||
4078 | break; | |||
4079 | case oox::XML_rsidP: | |||
4080 | sResult += "rsidP"; | |||
4081 | break; | |||
4082 | case oox::XML_rsidRDefault: | |||
4083 | sResult += "rsidRDefault"; | |||
4084 | break; | |||
4085 | case oox::XML_gridCol: | |||
4086 | sResult += "gridCol"; | |||
4087 | break; | |||
4088 | case oox::XML_tblGridChange: | |||
4089 | sResult += "tblGridChange"; | |||
4090 | break; | |||
4091 | case oox::XML_insideH: | |||
4092 | sResult += "insideH"; | |||
4093 | break; | |||
4094 | case oox::XML_insideV: | |||
4095 | sResult += "insideV"; | |||
4096 | break; | |||
4097 | case oox::XML_tl2br: | |||
4098 | sResult += "tl2br"; | |||
4099 | break; | |||
4100 | case oox::XML_tr2bl: | |||
4101 | sResult += "tr2bl"; | |||
4102 | break; | |||
4103 | case oox::XML_tcW: | |||
4104 | sResult += "tcW"; | |||
4105 | break; | |||
4106 | case oox::XML_gridSpan: | |||
4107 | sResult += "gridSpan"; | |||
4108 | break; | |||
4109 | case oox::XML_hMerge: | |||
4110 | sResult += "hMerge"; | |||
4111 | break; | |||
4112 | case oox::XML_tcBorders: | |||
4113 | sResult += "tcBorders"; | |||
4114 | break; | |||
4115 | case oox::XML_noWrap: | |||
4116 | sResult += "noWrap"; | |||
4117 | break; | |||
4118 | case oox::XML_tcMar: | |||
4119 | sResult += "tcMar"; | |||
4120 | break; | |||
4121 | case oox::XML_tcFitText: | |||
4122 | sResult += "tcFitText"; | |||
4123 | break; | |||
4124 | case oox::XML_hideMark: | |||
4125 | sResult += "hideMark"; | |||
4126 | break; | |||
4127 | case oox::XML_tcPrChange: | |||
4128 | sResult += "tcPrChange"; | |||
4129 | break; | |||
4130 | case oox::XML_firstRow: | |||
4131 | sResult += "firstRow"; | |||
4132 | break; | |||
4133 | case oox::XML_lastRow: | |||
4134 | sResult += "lastRow"; | |||
4135 | break; | |||
4136 | case oox::XML_firstColumn: | |||
4137 | sResult += "firstColumn"; | |||
4138 | break; | |||
4139 | case oox::XML_lastColumn: | |||
4140 | sResult += "lastColumn"; | |||
4141 | break; | |||
4142 | case oox::XML_oddVBand: | |||
4143 | sResult += "oddVBand"; | |||
4144 | break; | |||
4145 | case oox::XML_evenVBand: | |||
4146 | sResult += "evenVBand"; | |||
4147 | break; | |||
4148 | case oox::XML_oddHBand: | |||
4149 | sResult += "oddHBand"; | |||
4150 | break; | |||
4151 | case oox::XML_evenHBand: | |||
4152 | sResult += "evenHBand"; | |||
4153 | break; | |||
4154 | case oox::XML_firstRowFirstColumn: | |||
4155 | sResult += "firstRowFirstColumn"; | |||
4156 | break; | |||
4157 | case oox::XML_firstRowLastColumn: | |||
4158 | sResult += "firstRowLastColumn"; | |||
4159 | break; | |||
4160 | case oox::XML_lastRowFirstColumn: | |||
4161 | sResult += "lastRowFirstColumn"; | |||
4162 | break; | |||
4163 | case oox::XML_lastRowLastColumn: | |||
4164 | sResult += "lastRowLastColumn"; | |||
4165 | break; | |||
4166 | case oox::XML_gridBefore: | |||
4167 | sResult += "gridBefore"; | |||
4168 | break; | |||
4169 | case oox::XML_gridAfter: | |||
4170 | sResult += "gridAfter"; | |||
4171 | break; | |||
4172 | case oox::XML_wBefore: | |||
4173 | sResult += "wBefore"; | |||
4174 | break; | |||
4175 | case oox::XML_wAfter: | |||
4176 | sResult += "wAfter"; | |||
4177 | break; | |||
4178 | case oox::XML_cantSplit: | |||
4179 | sResult += "cantSplit"; | |||
4180 | break; | |||
4181 | case oox::XML_trHeight: | |||
4182 | sResult += "trHeight"; | |||
4183 | break; | |||
4184 | case oox::XML_tblHeader: | |||
4185 | sResult += "tblHeader"; | |||
4186 | break; | |||
4187 | case oox::XML_tblCellSpacing: | |||
4188 | sResult += "tblCellSpacing"; | |||
4189 | break; | |||
4190 | case oox::XML_trPrChange: | |||
4191 | sResult += "trPrChange"; | |||
4192 | break; | |||
4193 | case oox::XML_rsidTr: | |||
4194 | sResult += "rsidTr"; | |||
4195 | break; | |||
4196 | case oox::XML_leftFromText: | |||
4197 | sResult += "leftFromText"; | |||
4198 | break; | |||
4199 | case oox::XML_rightFromText: | |||
4200 | sResult += "rightFromText"; | |||
4201 | break; | |||
4202 | case oox::XML_topFromText: | |||
4203 | sResult += "topFromText"; | |||
4204 | break; | |||
4205 | case oox::XML_bottomFromText: | |||
4206 | sResult += "bottomFromText"; | |||
4207 | break; | |||
4208 | case oox::XML_vertAnchor: | |||
4209 | sResult += "vertAnchor"; | |||
4210 | break; | |||
4211 | case oox::XML_horzAnchor: | |||
4212 | sResult += "horzAnchor"; | |||
4213 | break; | |||
4214 | case oox::XML_tblpXSpec: | |||
4215 | sResult += "tblpXSpec"; | |||
4216 | break; | |||
4217 | case oox::XML_tblpX: | |||
4218 | sResult += "tblpX"; | |||
4219 | break; | |||
4220 | case oox::XML_tblpYSpec: | |||
4221 | sResult += "tblpYSpec"; | |||
4222 | break; | |||
4223 | case oox::XML_tblpY: | |||
4224 | sResult += "tblpY"; | |||
4225 | break; | |||
4226 | case oox::XML_tblStyle: | |||
4227 | sResult += "tblStyle"; | |||
4228 | break; | |||
4229 | case oox::XML_tblpPr: | |||
4230 | sResult += "tblpPr"; | |||
4231 | break; | |||
4232 | case oox::XML_tblOverlap: | |||
4233 | sResult += "tblOverlap"; | |||
4234 | break; | |||
4235 | case oox::XML_bidiVisual: | |||
4236 | sResult += "bidiVisual"; | |||
4237 | break; | |||
4238 | case oox::XML_tblStyleRowBandSize: | |||
4239 | sResult += "tblStyleRowBandSize"; | |||
4240 | break; | |||
4241 | case oox::XML_tblStyleColBandSize: | |||
4242 | sResult += "tblStyleColBandSize"; | |||
4243 | break; | |||
4244 | case oox::XML_tblW: | |||
4245 | sResult += "tblW"; | |||
4246 | break; | |||
4247 | case oox::XML_tblInd: | |||
4248 | sResult += "tblInd"; | |||
4249 | break; | |||
4250 | case oox::XML_tblBorders: | |||
4251 | sResult += "tblBorders"; | |||
4252 | break; | |||
4253 | case oox::XML_tblLayout: | |||
4254 | sResult += "tblLayout"; | |||
4255 | break; | |||
4256 | case oox::XML_tblCellMar: | |||
4257 | sResult += "tblCellMar"; | |||
4258 | break; | |||
4259 | case oox::XML_tblLook: | |||
4260 | sResult += "tblLook"; | |||
4261 | break; | |||
4262 | case oox::XML_tblCaption: | |||
4263 | sResult += "tblCaption"; | |||
4264 | break; | |||
4265 | case oox::XML_tblDescription: | |||
4266 | sResult += "tblDescription"; | |||
4267 | break; | |||
4268 | case oox::XML_tblPrChange: | |||
4269 | sResult += "tblPrChange"; | |||
4270 | break; | |||
4271 | case oox::XML_tblPrExChange: | |||
4272 | sResult += "tblPrExChange"; | |||
4273 | break; | |||
4274 | case oox::XML_noHBand: | |||
4275 | sResult += "noHBand"; | |||
4276 | break; | |||
4277 | case oox::XML_noVBand: | |||
4278 | sResult += "noVBand"; | |||
4279 | break; | |||
4280 | case oox::XML_customMarkFollows: | |||
4281 | sResult += "customMarkFollows"; | |||
4282 | break; | |||
4283 | case oox::XML_numStart: | |||
4284 | sResult += "numStart"; | |||
4285 | break; | |||
4286 | case oox::XML_numRestart: | |||
4287 | sResult += "numRestart"; | |||
4288 | break; | |||
4289 | case oox::XML_numFmt: | |||
4290 | sResult += "numFmt"; | |||
4291 | break; | |||
4292 | case oox::XML_footnote: | |||
4293 | sResult += "footnote"; | |||
4294 | break; | |||
4295 | case oox::XML_endnote: | |||
4296 | sResult += "endnote"; | |||
4297 | break; | |||
4298 | case oox::XML_active: | |||
4299 | sResult += "active"; | |||
4300 | break; | |||
4301 | case oox::XML_uniqueTag: | |||
4302 | sResult += "uniqueTag"; | |||
4303 | break; | |||
4304 | case oox::XML_recipientData: | |||
4305 | sResult += "recipientData"; | |||
4306 | break; | |||
4307 | case oox::XML_recipients: | |||
4308 | sResult += "recipients"; | |||
4309 | break; | |||
4310 | case oox::XML_mappedName: | |||
4311 | sResult += "mappedName"; | |||
4312 | break; | |||
4313 | case oox::XML_dynamicAddress: | |||
4314 | sResult += "dynamicAddress"; | |||
4315 | break; | |||
4316 | case oox::XML_udl: | |||
4317 | sResult += "udl"; | |||
4318 | break; | |||
4319 | case oox::XML_table: | |||
4320 | sResult += "table"; | |||
4321 | break; | |||
4322 | case oox::XML_colDelim: | |||
4323 | sResult += "colDelim"; | |||
4324 | break; | |||
4325 | case oox::XML_fHdr: | |||
4326 | sResult += "fHdr"; | |||
4327 | break; | |||
4328 | case oox::XML_fieldMapData: | |||
4329 | sResult += "fieldMapData"; | |||
4330 | break; | |||
4331 | case oox::XML_mainDocumentType: | |||
4332 | sResult += "mainDocumentType"; | |||
4333 | break; | |||
4334 | case oox::XML_linkToQuery: | |||
4335 | sResult += "linkToQuery"; | |||
4336 | break; | |||
4337 | case oox::XML_dataType: | |||
4338 | sResult += "dataType"; | |||
4339 | break; | |||
4340 | case oox::XML_connectString: | |||
4341 | sResult += "connectString"; | |||
4342 | break; | |||
4343 | case oox::XML_query: | |||
4344 | sResult += "query"; | |||
4345 | break; | |||
4346 | case oox::XML_dataSource: | |||
4347 | sResult += "dataSource"; | |||
4348 | break; | |||
4349 | case oox::XML_headerSource: | |||
4350 | sResult += "headerSource"; | |||
4351 | break; | |||
4352 | case oox::XML_doNotSuppressBlankLines: | |||
4353 | sResult += "doNotSuppressBlankLines"; | |||
4354 | break; | |||
4355 | case oox::XML_destination: | |||
4356 | sResult += "destination"; | |||
4357 | break; | |||
4358 | case oox::XML_addressFieldName: | |||
4359 | sResult += "addressFieldName"; | |||
4360 | break; | |||
4361 | case oox::XML_mailSubject: | |||
4362 | sResult += "mailSubject"; | |||
4363 | break; | |||
4364 | case oox::XML_mailAsAttachment: | |||
4365 | sResult += "mailAsAttachment"; | |||
4366 | break; | |||
4367 | case oox::XML_viewMergedData: | |||
4368 | sResult += "viewMergedData"; | |||
4369 | break; | |||
4370 | case oox::XML_activeRecord: | |||
4371 | sResult += "activeRecord"; | |||
4372 | break; | |||
4373 | case oox::XML_checkErrors: | |||
4374 | sResult += "checkErrors"; | |||
4375 | break; | |||
4376 | case oox::XML_odso: | |||
4377 | sResult += "odso"; | |||
4378 | break; | |||
4379 | case oox::XML_useSingleBorderforContiguousCells: | |||
4380 | sResult += "useSingleBorderforContiguousCells"; | |||
4381 | break; | |||
4382 | case oox::XML_wpJustification: | |||
4383 | sResult += "wpJustification"; | |||
4384 | break; | |||
4385 | case oox::XML_noTabHangInd: | |||
4386 | sResult += "noTabHangInd"; | |||
4387 | break; | |||
4388 | case oox::XML_noLeading: | |||
4389 | sResult += "noLeading"; | |||
4390 | break; | |||
4391 | case oox::XML_spaceForUL: | |||
4392 | sResult += "spaceForUL"; | |||
4393 | break; | |||
4394 | case oox::XML_noColumnBalance: | |||
4395 | sResult += "noColumnBalance"; | |||
4396 | break; | |||
4397 | case oox::XML_balanceSingleByteDoubleByteWidth: | |||
4398 | sResult += "balanceSingleByteDoubleByteWidth"; | |||
4399 | break; | |||
4400 | case oox::XML_noExtraLineSpacing: | |||
4401 | sResult += "noExtraLineSpacing"; | |||
4402 | break; | |||
4403 | case oox::XML_doNotLeaveBackslashAlone: | |||
4404 | sResult += "doNotLeaveBackslashAlone"; | |||
4405 | break; | |||
4406 | case oox::XML_ulTrailSpace: | |||
4407 | sResult += "ulTrailSpace"; | |||
4408 | break; | |||
4409 | case oox::XML_doNotExpandShiftReturn: | |||
4410 | sResult += "doNotExpandShiftReturn"; | |||
4411 | break; | |||
4412 | case oox::XML_spacingInWholePoints: | |||
4413 | sResult += "spacingInWholePoints"; | |||
4414 | break; | |||
4415 | case oox::XML_lineWrapLikeWord6: | |||
4416 | sResult += "lineWrapLikeWord6"; | |||
4417 | break; | |||
4418 | case oox::XML_printBodyTextBeforeHeader: | |||
4419 | sResult += "printBodyTextBeforeHeader"; | |||
4420 | break; | |||
4421 | case oox::XML_printColBlack: | |||
4422 | sResult += "printColBlack"; | |||
4423 | break; | |||
4424 | case oox::XML_wpSpaceWidth: | |||
4425 | sResult += "wpSpaceWidth"; | |||
4426 | break; | |||
4427 | case oox::XML_showBreaksInFrames: | |||
4428 | sResult += "showBreaksInFrames"; | |||
4429 | break; | |||
4430 | case oox::XML_subFontBySize: | |||
4431 | sResult += "subFontBySize"; | |||
4432 | break; | |||
4433 | case oox::XML_suppressBottomSpacing: | |||
4434 | sResult += "suppressBottomSpacing"; | |||
4435 | break; | |||
4436 | case oox::XML_suppressTopSpacing: | |||
4437 | sResult += "suppressTopSpacing"; | |||
4438 | break; | |||
4439 | case oox::XML_suppressSpacingAtTopOfPage: | |||
4440 | sResult += "suppressSpacingAtTopOfPage"; | |||
4441 | break; | |||
4442 | case oox::XML_suppressTopSpacingWP: | |||
4443 | sResult += "suppressTopSpacingWP"; | |||
4444 | break; | |||
4445 | case oox::XML_suppressSpBfAfterPgBrk: | |||
4446 | sResult += "suppressSpBfAfterPgBrk"; | |||
4447 | break; | |||
4448 | case oox::XML_swapBordersFacingPages: | |||
4449 | sResult += "swapBordersFacingPages"; | |||
4450 | break; | |||
4451 | case oox::XML_convMailMergeEsc: | |||
4452 | sResult += "convMailMergeEsc"; | |||
4453 | break; | |||
4454 | case oox::XML_truncateFontHeightsLikeWP6: | |||
4455 | sResult += "truncateFontHeightsLikeWP6"; | |||
4456 | break; | |||
4457 | case oox::XML_mwSmallCaps: | |||
4458 | sResult += "mwSmallCaps"; | |||
4459 | break; | |||
4460 | case oox::XML_usePrinterMetrics: | |||
4461 | sResult += "usePrinterMetrics"; | |||
4462 | break; | |||
4463 | case oox::XML_doNotSuppressParagraphBorders: | |||
4464 | sResult += "doNotSuppressParagraphBorders"; | |||
4465 | break; | |||
4466 | case oox::XML_wrapTrailSpaces: | |||
4467 | sResult += "wrapTrailSpaces"; | |||
4468 | break; | |||
4469 | case oox::XML_footnoteLayoutLikeWW8: | |||
4470 | sResult += "footnoteLayoutLikeWW8"; | |||
4471 | break; | |||
4472 | case oox::XML_shapeLayoutLikeWW8: | |||
4473 | sResult += "shapeLayoutLikeWW8"; | |||
4474 | break; | |||
4475 | case oox::XML_alignTablesRowByRow: | |||
4476 | sResult += "alignTablesRowByRow"; | |||
4477 | break; | |||
4478 | case oox::XML_forgetLastTabAlignment: | |||
4479 | sResult += "forgetLastTabAlignment"; | |||
4480 | break; | |||
4481 | case oox::XML_adjustLineHeightInTable: | |||
4482 | sResult += "adjustLineHeightInTable"; | |||
4483 | break; | |||
4484 | case oox::XML_autoSpaceLikeWord95: | |||
4485 | sResult += "autoSpaceLikeWord95"; | |||
4486 | break; | |||
4487 | case oox::XML_noSpaceRaiseLower: | |||
4488 | sResult += "noSpaceRaiseLower"; | |||
4489 | break; | |||
4490 | case oox::XML_doNotUseHTMLParagraphAutoSpacing: | |||
4491 | sResult += "doNotUseHTMLParagraphAutoSpacing"; | |||
4492 | break; | |||
4493 | case oox::XML_layoutRawTableWidth: | |||
4494 | sResult += "layoutRawTableWidth"; | |||
4495 | break; | |||
4496 | case oox::XML_layoutTableRowsApart: | |||
4497 | sResult += "layoutTableRowsApart"; | |||
4498 | break; | |||
4499 | case oox::XML_useWord97LineBreakRules: | |||
4500 | sResult += "useWord97LineBreakRules"; | |||
4501 | break; | |||
4502 | case oox::XML_doNotBreakWrappedTables: | |||
4503 | sResult += "doNotBreakWrappedTables"; | |||
4504 | break; | |||
4505 | case oox::XML_doNotSnapToGridInCell: | |||
4506 | sResult += "doNotSnapToGridInCell"; | |||
4507 | break; | |||
4508 | case oox::XML_selectFldWithFirstOrLastChar: | |||
4509 | sResult += "selectFldWithFirstOrLastChar"; | |||
4510 | break; | |||
4511 | case oox::XML_applyBreakingRules: | |||
4512 | sResult += "applyBreakingRules"; | |||
4513 | break; | |||
4514 | case oox::XML_doNotWrapTextWithPunct: | |||
4515 | sResult += "doNotWrapTextWithPunct"; | |||
4516 | break; | |||
4517 | case oox::XML_doNotUseEastAsianBreakRules: | |||
4518 | sResult += "doNotUseEastAsianBreakRules"; | |||
4519 | break; | |||
4520 | case oox::XML_useWord2002TableStyleRules: | |||
4521 | sResult += "useWord2002TableStyleRules"; | |||
4522 | break; | |||
4523 | case oox::XML_growAutofit: | |||
4524 | sResult += "growAutofit"; | |||
4525 | break; | |||
4526 | case oox::XML_useFELayout: | |||
4527 | sResult += "useFELayout"; | |||
4528 | break; | |||
4529 | case oox::XML_useNormalStyleForList: | |||
4530 | sResult += "useNormalStyleForList"; | |||
4531 | break; | |||
4532 | case oox::XML_doNotUseIndentAsNumberingTabStop: | |||
4533 | sResult += "doNotUseIndentAsNumberingTabStop"; | |||
4534 | break; | |||
4535 | case oox::XML_useAltKinsokuLineBreakRules: | |||
4536 | sResult += "useAltKinsokuLineBreakRules"; | |||
4537 | break; | |||
4538 | case oox::XML_allowSpaceOfSameStyleInTable: | |||
4539 | sResult += "allowSpaceOfSameStyleInTable"; | |||
4540 | break; | |||
4541 | case oox::XML_doNotSuppressIndentation: | |||
4542 | sResult += "doNotSuppressIndentation"; | |||
4543 | break; | |||
4544 | case oox::XML_doNotAutofitConstrainedTables: | |||
4545 | sResult += "doNotAutofitConstrainedTables"; | |||
4546 | break; | |||
4547 | case oox::XML_autofitToFirstFixedWidthCell: | |||
4548 | sResult += "autofitToFirstFixedWidthCell"; | |||
4549 | break; | |||
4550 | case oox::XML_underlineTabInNumList: | |||
4551 | sResult += "underlineTabInNumList"; | |||
4552 | break; | |||
4553 | case oox::XML_displayHangulFixedWidth: | |||
4554 | sResult += "displayHangulFixedWidth"; | |||
4555 | break; | |||
4556 | case oox::XML_splitPgBreakAndParaMark: | |||
4557 | sResult += "splitPgBreakAndParaMark"; | |||
4558 | break; | |||
4559 | case oox::XML_doNotVertAlignCellWithSp: | |||
4560 | sResult += "doNotVertAlignCellWithSp"; | |||
4561 | break; | |||
4562 | case oox::XML_doNotBreakConstrainedForcedTable: | |||
4563 | sResult += "doNotBreakConstrainedForcedTable"; | |||
4564 | break; | |||
4565 | case oox::XML_doNotVertAlignInTxbx: | |||
4566 | sResult += "doNotVertAlignInTxbx"; | |||
4567 | break; | |||
4568 | case oox::XML_useAnsiKerningPairs: | |||
4569 | sResult += "useAnsiKerningPairs"; | |||
4570 | break; | |||
4571 | case oox::XML_cachedColBalance: | |||
4572 | sResult += "cachedColBalance"; | |||
4573 | break; | |||
4574 | case oox::XML_compatSetting: | |||
4575 | sResult += "compatSetting"; | |||
4576 | break; | |||
4577 | case oox::XML_docVar: | |||
4578 | sResult += "docVar"; | |||
4579 | break; | |||
4580 | case oox::XML_rsidRoot: | |||
4581 | sResult += "rsidRoot"; | |||
4582 | break; | |||
4583 | case oox::XML_rsid: | |||
4584 | sResult += "rsid"; | |||
4585 | break; | |||
4586 | case oox::XML_solutionID: | |||
4587 | sResult += "solutionID"; | |||
4588 | break; | |||
4589 | case oox::XML_rPrDefault: | |||
4590 | sResult += "rPrDefault"; | |||
4591 | break; | |||
4592 | case oox::XML_pPrDefault: | |||
4593 | sResult += "pPrDefault"; | |||
4594 | break; | |||
4595 | case oox::XML_t1: | |||
4596 | sResult += "t1"; | |||
4597 | break; | |||
4598 | case oox::XML_t2: | |||
4599 | sResult += "t2"; | |||
4600 | break; | |||
4601 | case oox::XML_followedHyperlink: | |||
4602 | sResult += "followedHyperlink"; | |||
4603 | break; | |||
4604 | case oox::XML_actualPg: | |||
4605 | sResult += "actualPg"; | |||
4606 | break; | |||
4607 | case oox::XML_fontSz: | |||
4608 | sResult += "fontSz"; | |||
4609 | break; | |||
4610 | case oox::XML_recommended: | |||
4611 | sResult += "recommended"; | |||
4612 | break; | |||
4613 | case oox::XML_writeProtection: | |||
4614 | sResult += "writeProtection"; | |||
4615 | break; | |||
4616 | case oox::XML_view: | |||
4617 | sResult += "view"; | |||
4618 | break; | |||
4619 | case oox::XML_linkStyles: | |||
4620 | sResult += "linkStyles"; | |||
4621 | break; | |||
4622 | case oox::XML_removePersonalInformation: | |||
4623 | sResult += "removePersonalInformation"; | |||
4624 | break; | |||
4625 | case oox::XML_removeDateAndTime: | |||
4626 | sResult += "removeDateAndTime"; | |||
4627 | break; | |||
4628 | case oox::XML_doNotDisplayPageBoundaries: | |||
4629 | sResult += "doNotDisplayPageBoundaries"; | |||
4630 | break; | |||
4631 | case oox::XML_displayBackgroundShape: | |||
4632 | sResult += "displayBackgroundShape"; | |||
4633 | break; | |||
4634 | case oox::XML_printPostScriptOverText: | |||
4635 | sResult += "printPostScriptOverText"; | |||
4636 | break; | |||
4637 | case oox::XML_printFractionalCharacterWidth: | |||
4638 | sResult += "printFractionalCharacterWidth"; | |||
4639 | break; | |||
4640 | case oox::XML_printFormsData: | |||
4641 | sResult += "printFormsData"; | |||
4642 | break; | |||
4643 | case oox::XML_embedTrueTypeFonts: | |||
4644 | sResult += "embedTrueTypeFonts"; | |||
4645 | break; | |||
4646 | case oox::XML_embedSystemFonts: | |||
4647 | sResult += "embedSystemFonts"; | |||
4648 | break; | |||
4649 | case oox::XML_saveSubsetFonts: | |||
4650 | sResult += "saveSubsetFonts"; | |||
4651 | break; | |||
4652 | case oox::XML_saveFormsData: | |||
4653 | sResult += "saveFormsData"; | |||
4654 | break; | |||
4655 | case oox::XML_mirrorMargins: | |||
4656 | sResult += "mirrorMargins"; | |||
4657 | break; | |||
4658 | case oox::XML_alignBordersAndEdges: | |||
4659 | sResult += "alignBordersAndEdges"; | |||
4660 | break; | |||
4661 | case oox::XML_bordersDoNotSurroundHeader: | |||
4662 | sResult += "bordersDoNotSurroundHeader"; | |||
4663 | break; | |||
4664 | case oox::XML_bordersDoNotSurroundFooter: | |||
4665 | sResult += "bordersDoNotSurroundFooter"; | |||
4666 | break; | |||
4667 | case oox::XML_gutterAtTop: | |||
4668 | sResult += "gutterAtTop"; | |||
4669 | break; | |||
4670 | case oox::XML_hideSpellingErrors: | |||
4671 | sResult += "hideSpellingErrors"; | |||
4672 | break; | |||
4673 | case oox::XML_hideGrammaticalErrors: | |||
4674 | sResult += "hideGrammaticalErrors"; | |||
4675 | break; | |||
4676 | case oox::XML_activeWritingStyle: | |||
4677 | sResult += "activeWritingStyle"; | |||
4678 | break; | |||
4679 | case oox::XML_proofState: | |||
4680 | sResult += "proofState"; | |||
4681 | break; | |||
4682 | case oox::XML_formsDesign: | |||
4683 | sResult += "formsDesign"; | |||
4684 | break; | |||
4685 | case oox::XML_attachedTemplate: | |||
4686 | sResult += "attachedTemplate"; | |||
4687 | break; | |||
4688 | case oox::XML_stylePaneFormatFilter: | |||
4689 | sResult += "stylePaneFormatFilter"; | |||
4690 | break; | |||
4691 | case oox::XML_stylePaneSortMethod: | |||
4692 | sResult += "stylePaneSortMethod"; | |||
4693 | break; | |||
4694 | case oox::XML_documentType: | |||
4695 | sResult += "documentType"; | |||
4696 | break; | |||
4697 | case oox::XML_mailMerge: | |||
4698 | sResult += "mailMerge"; | |||
4699 | break; | |||
4700 | case oox::XML_revisionView: | |||
4701 | sResult += "revisionView"; | |||
4702 | break; | |||
4703 | case oox::XML_trackRevisions: | |||
4704 | sResult += "trackRevisions"; | |||
4705 | break; | |||
4706 | case oox::XML_doNotTrackMoves: | |||
4707 | sResult += "doNotTrackMoves"; | |||
4708 | break; | |||
4709 | case oox::XML_doNotTrackFormatting: | |||
4710 | sResult += "doNotTrackFormatting"; | |||
4711 | break; | |||
4712 | case oox::XML_documentProtection: | |||
4713 | sResult += "documentProtection"; | |||
4714 | break; | |||
4715 | case oox::XML_autoFormatOverride: | |||
4716 | sResult += "autoFormatOverride"; | |||
4717 | break; | |||
4718 | case oox::XML_styleLockTheme: | |||
4719 | sResult += "styleLockTheme"; | |||
4720 | break; | |||
4721 | case oox::XML_styleLockQFSet: | |||
4722 | sResult += "styleLockQFSet"; | |||
4723 | break; | |||
4724 | case oox::XML_defaultTabStop: | |||
4725 | sResult += "defaultTabStop"; | |||
4726 | break; | |||
4727 | case oox::XML_autoHyphenation: | |||
4728 | sResult += "autoHyphenation"; | |||
4729 | break; | |||
4730 | case oox::XML_consecutiveHyphenLimit: | |||
4731 | sResult += "consecutiveHyphenLimit"; | |||
4732 | break; | |||
4733 | case oox::XML_hyphenationZone: | |||
4734 | sResult += "hyphenationZone"; | |||
4735 | break; | |||
4736 | case oox::XML_doNotHyphenateCaps: | |||
4737 | sResult += "doNotHyphenateCaps"; | |||
4738 | break; | |||
4739 | case oox::XML_showEnvelope: | |||
4740 | sResult += "showEnvelope"; | |||
4741 | break; | |||
4742 | case oox::XML_summaryLength: | |||
4743 | sResult += "summaryLength"; | |||
4744 | break; | |||
4745 | case oox::XML_clickAndTypeStyle: | |||
4746 | sResult += "clickAndTypeStyle"; | |||
4747 | break; | |||
4748 | case oox::XML_defaultTableStyle: | |||
4749 | sResult += "defaultTableStyle"; | |||
4750 | break; | |||
4751 | case oox::XML_evenAndOddHeaders: | |||
4752 | sResult += "evenAndOddHeaders"; | |||
4753 | break; | |||
4754 | case oox::XML_bookFoldRevPrinting: | |||
4755 | sResult += "bookFoldRevPrinting"; | |||
4756 | break; | |||
4757 | case oox::XML_bookFoldPrinting: | |||
4758 | sResult += "bookFoldPrinting"; | |||
4759 | break; | |||
4760 | case oox::XML_bookFoldPrintingSheets: | |||
4761 | sResult += "bookFoldPrintingSheets"; | |||
4762 | break; | |||
4763 | case oox::XML_drawingGridHorizontalSpacing: | |||
4764 | sResult += "drawingGridHorizontalSpacing"; | |||
4765 | break; | |||
4766 | case oox::XML_drawingGridVerticalSpacing: | |||
4767 | sResult += "drawingGridVerticalSpacing"; | |||
4768 | break; | |||
4769 | case oox::XML_displayHorizontalDrawingGridEvery: | |||
4770 | sResult += "displayHorizontalDrawingGridEvery"; | |||
4771 | break; | |||
4772 | case oox::XML_displayVerticalDrawingGridEvery: | |||
4773 | sResult += "displayVerticalDrawingGridEvery"; | |||
4774 | break; | |||
4775 | case oox::XML_doNotUseMarginsForDrawingGridOrigin: | |||
4776 | sResult += "doNotUseMarginsForDrawingGridOrigin"; | |||
4777 | break; | |||
4778 | case oox::XML_drawingGridHorizontalOrigin: | |||
4779 | sResult += "drawingGridHorizontalOrigin"; | |||
4780 | break; | |||
4781 | case oox::XML_drawingGridVerticalOrigin: | |||
4782 | sResult += "drawingGridVerticalOrigin"; | |||
4783 | break; | |||
4784 | case oox::XML_doNotShadeFormData: | |||
4785 | sResult += "doNotShadeFormData"; | |||
4786 | break; | |||
4787 | case oox::XML_noPunctuationKerning: | |||
4788 | sResult += "noPunctuationKerning"; | |||
4789 | break; | |||
4790 | case oox::XML_characterSpacingControl: | |||
4791 | sResult += "characterSpacingControl"; | |||
4792 | break; | |||
4793 | case oox::XML_printTwoOnOne: | |||
4794 | sResult += "printTwoOnOne"; | |||
4795 | break; | |||
4796 | case oox::XML_strictFirstAndLastChars: | |||
4797 | sResult += "strictFirstAndLastChars"; | |||
4798 | break; | |||
4799 | case oox::XML_noLineBreaksAfter: | |||
4800 | sResult += "noLineBreaksAfter"; | |||
4801 | break; | |||
4802 | case oox::XML_noLineBreaksBefore: | |||
4803 | sResult += "noLineBreaksBefore"; | |||
4804 | break; | |||
4805 | case oox::XML_savePreviewPicture: | |||
4806 | sResult += "savePreviewPicture"; | |||
4807 | break; | |||
4808 | case oox::XML_doNotValidateAgainstSchema: | |||
4809 | sResult += "doNotValidateAgainstSchema"; | |||
4810 | break; | |||
4811 | case oox::XML_saveInvalidXml: | |||
4812 | sResult += "saveInvalidXml"; | |||
4813 | break; | |||
4814 | case oox::XML_ignoreMixedContent: | |||
4815 | sResult += "ignoreMixedContent"; | |||
4816 | break; | |||
4817 | case oox::XML_alwaysShowPlaceholderText: | |||
4818 | sResult += "alwaysShowPlaceholderText"; | |||
4819 | break; | |||
4820 | case oox::XML_doNotDemarcateInvalidXml: | |||
4821 | sResult += "doNotDemarcateInvalidXml"; | |||
4822 | break; | |||
4823 | case oox::XML_saveXmlDataOnly: | |||
4824 | sResult += "saveXmlDataOnly"; | |||
4825 | break; | |||
4826 | case oox::XML_useXSLTWhenSaving: | |||
4827 | sResult += "useXSLTWhenSaving"; | |||
4828 | break; | |||
4829 | case oox::XML_saveThroughXslt: | |||
4830 | sResult += "saveThroughXslt"; | |||
4831 | break; | |||
4832 | case oox::XML_showXMLTags: | |||
4833 | sResult += "showXMLTags"; | |||
4834 | break; | |||
4835 | case oox::XML_alwaysMergeEmptyNamespace: | |||
4836 | sResult += "alwaysMergeEmptyNamespace"; | |||
4837 | break; | |||
4838 | case oox::XML_updateFields: | |||
4839 | sResult += "updateFields"; | |||
4840 | break; | |||
4841 | case oox::XML_hdrShapeDefaults: | |||
4842 | sResult += "hdrShapeDefaults"; | |||
4843 | break; | |||
4844 | case oox::XML_compat: | |||
4845 | sResult += "compat"; | |||
4846 | break; | |||
4847 | case oox::XML_docVars: | |||
4848 | sResult += "docVars"; | |||
4849 | break; | |||
4850 | case oox::XML_rsids: | |||
4851 | sResult += "rsids"; | |||
4852 | break; | |||
4853 | case oox::XML_uiCompat97To2003: | |||
4854 | sResult += "uiCompat97To2003"; | |||
4855 | break; | |||
4856 | case oox::XML_attachedSchema: | |||
4857 | sResult += "attachedSchema"; | |||
4858 | break; | |||
4859 | case oox::XML_themeFontLang: | |||
4860 | sResult += "themeFontLang"; | |||
4861 | break; | |||
4862 | case oox::XML_clrSchemeMapping: | |||
4863 | sResult += "clrSchemeMapping"; | |||
4864 | break; | |||
4865 | case oox::XML_doNotIncludeSubdocsInStats: | |||
4866 | sResult += "doNotIncludeSubdocsInStats"; | |||
4867 | break; | |||
4868 | case oox::XML_doNotAutoCompressPictures: | |||
4869 | sResult += "doNotAutoCompressPictures"; | |||
4870 | break; | |||
4871 | case oox::XML_forceUpgrade: | |||
4872 | sResult += "forceUpgrade"; | |||
4873 | break; | |||
4874 | case oox::XML_captions: | |||
4875 | sResult += "captions"; | |||
4876 | break; | |||
4877 | case oox::XML_readModeInkLockDown: | |||
4878 | sResult += "readModeInkLockDown"; | |||
4879 | break; | |||
4880 | case oox::XML_smartTagType: | |||
4881 | sResult += "smartTagType"; | |||
4882 | break; | |||
4883 | case oox::XML_shapeDefaults: | |||
4884 | sResult += "shapeDefaults"; | |||
4885 | break; | |||
4886 | case oox::XML_doNotEmbedSmartTags: | |||
4887 | sResult += "doNotEmbedSmartTags"; | |||
4888 | break; | |||
4889 | case oox::XML_decimalSymbol: | |||
4890 | sResult += "decimalSymbol"; | |||
4891 | break; | |||
4892 | case oox::XML_listSeparator: | |||
4893 | sResult += "listSeparator"; | |||
4894 | break; | |||
4895 | case oox::XML_frameset: | |||
4896 | sResult += "frameset"; | |||
4897 | break; | |||
4898 | case oox::XML_divs: | |||
4899 | sResult += "divs"; | |||
4900 | break; | |||
4901 | case oox::XML_encoding: | |||
4902 | sResult += "encoding"; | |||
4903 | break; | |||
4904 | case oox::XML_optimizeForBrowser: | |||
4905 | sResult += "optimizeForBrowser"; | |||
4906 | break; | |||
4907 | case oox::XML_relyOnVML: | |||
4908 | sResult += "relyOnVML"; | |||
4909 | break; | |||
4910 | case oox::XML_allowPNG: | |||
4911 | sResult += "allowPNG"; | |||
4912 | break; | |||
4913 | case oox::XML_doNotRelyOnCSS: | |||
4914 | sResult += "doNotRelyOnCSS"; | |||
4915 | break; | |||
4916 | case oox::XML_doNotSaveAsSingleFile: | |||
4917 | sResult += "doNotSaveAsSingleFile"; | |||
4918 | break; | |||
4919 | case oox::XML_doNotOrganizeInFolder: | |||
4920 | sResult += "doNotOrganizeInFolder"; | |||
4921 | break; | |||
4922 | case oox::XML_doNotUseLongFileNames: | |||
4923 | sResult += "doNotUseLongFileNames"; | |||
4924 | break; | |||
4925 | case oox::XML_pixelsPerInch: | |||
4926 | sResult += "pixelsPerInch"; | |||
4927 | break; | |||
4928 | case oox::XML_targetScreenSz: | |||
4929 | sResult += "targetScreenSz"; | |||
4930 | break; | |||
4931 | case oox::XML_saveSmartTagsAsXml: | |||
4932 | sResult += "saveSmartTagsAsXml"; | |||
4933 | break; | |||
4934 | case oox::XML_sourceFileName: | |||
4935 | sResult += "sourceFileName"; | |||
4936 | break; | |||
4937 | case oox::XML_marW: | |||
4938 | sResult += "marW"; | |||
4939 | break; | |||
4940 | case oox::XML_marH: | |||
4941 | sResult += "marH"; | |||
4942 | break; | |||
4943 | case oox::XML_scrollbar: | |||
4944 | sResult += "scrollbar"; | |||
4945 | break; | |||
4946 | case oox::XML_noResizeAllowed: | |||
4947 | sResult += "noResizeAllowed"; | |||
4948 | break; | |||
4949 | case oox::XML_linkedToFile: | |||
4950 | sResult += "linkedToFile"; | |||
4951 | break; | |||
4952 | case oox::XML_noBorder: | |||
4953 | sResult += "noBorder"; | |||
4954 | break; | |||
4955 | case oox::XML_flatBorders: | |||
4956 | sResult += "flatBorders"; | |||
4957 | break; | |||
4958 | case oox::XML_framesetSplitbar: | |||
4959 | sResult += "framesetSplitbar"; | |||
4960 | break; | |||
4961 | case oox::XML_frameLayout: | |||
4962 | sResult += "frameLayout"; | |||
4963 | break; | |||
4964 | case oox::XML_numPicBulletId: | |||
4965 | sResult += "numPicBulletId"; | |||
4966 | break; | |||
4967 | case oox::XML_null: | |||
4968 | sResult += "null"; | |||
4969 | break; | |||
4970 | case oox::XML_legacy: | |||
4971 | sResult += "legacy"; | |||
4972 | break; | |||
4973 | case oox::XML_legacySpace: | |||
4974 | sResult += "legacySpace"; | |||
4975 | break; | |||
4976 | case oox::XML_legacyIndent: | |||
4977 | sResult += "legacyIndent"; | |||
4978 | break; | |||
4979 | case oox::XML_lvlRestart: | |||
4980 | sResult += "lvlRestart"; | |||
4981 | break; | |||
4982 | case oox::XML_isLgl: | |||
4983 | sResult += "isLgl"; | |||
4984 | break; | |||
4985 | case oox::XML_suff: | |||
4986 | sResult += "suff"; | |||
4987 | break; | |||
4988 | case oox::XML_lvlText: | |||
4989 | sResult += "lvlText"; | |||
4990 | break; | |||
4991 | case oox::XML_lvlPicBulletId: | |||
4992 | sResult += "lvlPicBulletId"; | |||
4993 | break; | |||
4994 | case oox::XML_lvlJc: | |||
4995 | sResult += "lvlJc"; | |||
4996 | break; | |||
4997 | case oox::XML_tplc: | |||
4998 | sResult += "tplc"; | |||
4999 | break; | |||
5000 | case oox::XML_tentative: | |||
5001 | sResult += "tentative"; | |||
5002 | break; | |||
5003 | case oox::XML_nsid: | |||
5004 | sResult += "nsid"; | |||
5005 | break; | |||
5006 | case oox::XML_multiLevelType: | |||
5007 | sResult += "multiLevelType"; | |||
5008 | break; | |||
5009 | case oox::XML_tmpl: | |||
5010 | sResult += "tmpl"; | |||
5011 | break; | |||
5012 | case oox::XML_styleLink: | |||
5013 | sResult += "styleLink"; | |||
5014 | break; | |||
5015 | case oox::XML_numStyleLink: | |||
5016 | sResult += "numStyleLink"; | |||
5017 | break; | |||
5018 | case oox::XML_lvl: | |||
5019 | sResult += "lvl"; | |||
5020 | break; | |||
5021 | case oox::XML_abstractNumId: | |||
5022 | sResult += "abstractNumId"; | |||
5023 | break; | |||
5024 | case oox::XML_startOverride: | |||
5025 | sResult += "startOverride"; | |||
5026 | break; | |||
5027 | case oox::XML_lvlOverride: | |||
5028 | sResult += "lvlOverride"; | |||
5029 | break; | |||
5030 | case oox::XML_numPicBullet: | |||
5031 | sResult += "numPicBullet"; | |||
5032 | break; | |||
5033 | case oox::XML_abstractNum: | |||
5034 | sResult += "abstractNum"; | |||
5035 | break; | |||
5036 | case oox::XML_numIdMacAtCleanup: | |||
5037 | sResult += "numIdMacAtCleanup"; | |||
5038 | break; | |||
5039 | case oox::XML_aliases: | |||
5040 | sResult += "aliases"; | |||
5041 | break; | |||
5042 | case oox::XML_basedOn: | |||
5043 | sResult += "basedOn"; | |||
5044 | break; | |||
5045 | case oox::XML_next: | |||
5046 | sResult += "next"; | |||
5047 | break; | |||
5048 | case oox::XML_autoRedefine: | |||
5049 | sResult += "autoRedefine"; | |||
5050 | break; | |||
5051 | case oox::XML_uiPriority: | |||
5052 | sResult += "uiPriority"; | |||
5053 | break; | |||
5054 | case oox::XML_semiHidden: | |||
5055 | sResult += "semiHidden"; | |||
5056 | break; | |||
5057 | case oox::XML_unhideWhenUsed: | |||
5058 | sResult += "unhideWhenUsed"; | |||
5059 | break; | |||
5060 | case oox::XML_qFormat: | |||
5061 | sResult += "qFormat"; | |||
5062 | break; | |||
5063 | case oox::XML_personal: | |||
5064 | sResult += "personal"; | |||
5065 | break; | |||
5066 | case oox::XML_personalCompose: | |||
5067 | sResult += "personalCompose"; | |||
5068 | break; | |||
5069 | case oox::XML_personalReply: | |||
5070 | sResult += "personalReply"; | |||
5071 | break; | |||
5072 | case oox::XML_tblStylePr: | |||
5073 | sResult += "tblStylePr"; | |||
5074 | break; | |||
5075 | case oox::XML_styleId: | |||
5076 | sResult += "styleId"; | |||
5077 | break; | |||
5078 | case oox::XML_customStyle: | |||
5079 | sResult += "customStyle"; | |||
5080 | break; | |||
5081 | case oox::XML_lsdException: | |||
5082 | sResult += "lsdException"; | |||
5083 | break; | |||
5084 | case oox::XML_defLockedState: | |||
5085 | sResult += "defLockedState"; | |||
5086 | break; | |||
5087 | case oox::XML_defUIPriority: | |||
5088 | sResult += "defUIPriority"; | |||
5089 | break; | |||
5090 | case oox::XML_defSemiHidden: | |||
5091 | sResult += "defSemiHidden"; | |||
5092 | break; | |||
5093 | case oox::XML_defUnhideWhenUsed: | |||
5094 | sResult += "defUnhideWhenUsed"; | |||
5095 | break; | |||
5096 | case oox::XML_defQFormat: | |||
5097 | sResult += "defQFormat"; | |||
5098 | break; | |||
5099 | case oox::XML_docDefaults: | |||
5100 | sResult += "docDefaults"; | |||
5101 | break; | |||
5102 | case oox::XML_latentStyles: | |||
5103 | sResult += "latentStyles"; | |||
5104 | break; | |||
5105 | case oox::XML_usb0: | |||
5106 | sResult += "usb0"; | |||
5107 | break; | |||
5108 | case oox::XML_usb1: | |||
5109 | sResult += "usb1"; | |||
5110 | break; | |||
5111 | case oox::XML_usb2: | |||
5112 | sResult += "usb2"; | |||
5113 | break; | |||
5114 | case oox::XML_usb3: | |||
5115 | sResult += "usb3"; | |||
5116 | break; | |||
5117 | case oox::XML_csb0: | |||
5118 | sResult += "csb0"; | |||
5119 | break; | |||
5120 | case oox::XML_csb1: | |||
5121 | sResult += "csb1"; | |||
5122 | break; | |||
5123 | case oox::XML_fontKey: | |||
5124 | sResult += "fontKey"; | |||
5125 | break; | |||
5126 | case oox::XML_subsetted: | |||
5127 | sResult += "subsetted"; | |||
5128 | break; | |||
5129 | case oox::XML_altName: | |||
5130 | sResult += "altName"; | |||
5131 | break; | |||
5132 | case oox::XML_panose1: | |||
5133 | sResult += "panose1"; | |||
5134 | break; | |||
5135 | case oox::XML_characterSet: | |||
5136 | sResult += "characterSet"; | |||
5137 | break; | |||
5138 | case oox::XML_family: | |||
5139 | sResult += "family"; | |||
5140 | break; | |||
5141 | case oox::XML_notTrueType: | |||
5142 | sResult += "notTrueType"; | |||
5143 | break; | |||
5144 | case oox::XML_pitch: | |||
5145 | sResult += "pitch"; | |||
5146 | break; | |||
5147 | case oox::XML_sig: | |||
5148 | sResult += "sig"; | |||
5149 | break; | |||
5150 | case oox::XML_embedRegular: | |||
5151 | sResult += "embedRegular"; | |||
5152 | break; | |||
5153 | case oox::XML_embedBold: | |||
5154 | sResult += "embedBold"; | |||
5155 | break; | |||
5156 | case oox::XML_embedItalic: | |||
5157 | sResult += "embedItalic"; | |||
5158 | break; | |||
5159 | case oox::XML_embedBoldItalic: | |||
5160 | sResult += "embedBoldItalic"; | |||
5161 | break; | |||
5162 | case oox::XML_blockQuote: | |||
5163 | sResult += "blockQuote"; | |||
5164 | break; | |||
5165 | case oox::XML_bodyDiv: | |||
5166 | sResult += "bodyDiv"; | |||
5167 | break; | |||
5168 | case oox::XML_marLeft: | |||
5169 | sResult += "marLeft"; | |||
5170 | break; | |||
5171 | case oox::XML_marRight: | |||
5172 | sResult += "marRight"; | |||
5173 | break; | |||
5174 | case oox::XML_marTop: | |||
5175 | sResult += "marTop"; | |||
5176 | break; | |||
5177 | case oox::XML_marBottom: | |||
5178 | sResult += "marBottom"; | |||
5179 | break; | |||
5180 | case oox::XML_divBdr: | |||
5181 | sResult += "divBdr"; | |||
5182 | break; | |||
5183 | case oox::XML_divsChild: | |||
5184 | sResult += "divsChild"; | |||
5185 | break; | |||
5186 | case oox::XML_div: | |||
5187 | sResult += "div"; | |||
5188 | break; | |||
5189 | case oox::XML_altChunk: | |||
5190 | sResult += "altChunk"; | |||
5191 | break; | |||
5192 | case oox::XML_proofErr: | |||
5193 | sResult += "proofErr"; | |||
5194 | break; | |||
5195 | case oox::XML_comment: | |||
5196 | sResult += "comment"; | |||
5197 | break; | |||
5198 | case oox::XML_footnotes: | |||
5199 | sResult += "footnotes"; | |||
5200 | break; | |||
5201 | case oox::XML_endnotes: | |||
5202 | sResult += "endnotes"; | |||
5203 | break; | |||
5204 | case oox::XML_hdr: | |||
5205 | sResult += "hdr"; | |||
5206 | break; | |||
5207 | case oox::XML_ftr: | |||
5208 | sResult += "ftr"; | |||
5209 | break; | |||
5210 | case oox::XML_namespaceuri: | |||
5211 | sResult += "namespaceuri"; | |||
5212 | break; | |||
5213 | case oox::XML_url: | |||
5214 | sResult += "url"; | |||
5215 | break; | |||
5216 | case oox::XML_behavior: | |||
5217 | sResult += "behavior"; | |||
5218 | break; | |||
5219 | case oox::XML_all: | |||
5220 | sResult += "all"; | |||
5221 | break; | |||
5222 | case oox::XML_gallery: | |||
5223 | sResult += "gallery"; | |||
5224 | break; | |||
5225 | case oox::XML_decorated: | |||
5226 | sResult += "decorated"; | |||
5227 | break; | |||
5228 | case oox::XML_category: | |||
5229 | sResult += "category"; | |||
5230 | break; | |||
5231 | case oox::XML_types: | |||
5232 | sResult += "types"; | |||
5233 | break; | |||
5234 | case oox::XML_behaviors: | |||
5235 | sResult += "behaviors"; | |||
5236 | break; | |||
5237 | case oox::XML_description: | |||
5238 | sResult += "description"; | |||
5239 | break; | |||
5240 | case oox::XML_guid: | |||
5241 | sResult += "guid"; | |||
5242 | break; | |||
5243 | case oox::XML_docPartPr: | |||
5244 | sResult += "docPartPr"; | |||
5245 | break; | |||
5246 | case oox::XML_docPartBody: | |||
5247 | sResult += "docPartBody"; | |||
5248 | break; | |||
5249 | case oox::XML_settings: | |||
5250 | sResult += "settings"; | |||
5251 | break; | |||
5252 | case oox::XML_webSettings: | |||
5253 | sResult += "webSettings"; | |||
5254 | break; | |||
5255 | case oox::XML_fonts: | |||
5256 | sResult += "fonts"; | |||
5257 | break; | |||
5258 | case oox::XML_numbering: | |||
5259 | sResult += "numbering"; | |||
5260 | break; | |||
5261 | case oox::XML_styles: | |||
5262 | sResult += "styles"; | |||
5263 | break; | |||
5264 | case oox::XML_chapNum: | |||
5265 | sResult += "chapNum"; | |||
5266 | break; | |||
5267 | case oox::XML_heading: | |||
5268 | sResult += "heading"; | |||
5269 | break; | |||
5270 | case oox::XML_noLabel: | |||
5271 | sResult += "noLabel"; | |||
5272 | break; | |||
5273 | case oox::XML_caption: | |||
5274 | sResult += "caption"; | |||
5275 | break; | |||
5276 | case oox::XML_autoCaption: | |||
5277 | sResult += "autoCaption"; | |||
5278 | break; | |||
5279 | case oox::XML_autoCaptions: | |||
5280 | sResult += "autoCaptions"; | |||
5281 | break; | |||
5282 | case oox::XML_body: | |||
5283 | sResult += "body"; | |||
5284 | break; | |||
5285 | case oox::XML_docParts: | |||
5286 | sResult += "docParts"; | |||
5287 | break; | |||
5288 | case oox::XML_document: | |||
5289 | sResult += "document"; | |||
5290 | break; | |||
5291 | case oox::XML_glossaryDocument: | |||
5292 | sResult += "glossaryDocument"; | |||
5293 | break; | |||
5294 | } | |||
5295 | #else | |||
5296 | (void)nToken; | |||
5297 | #endif | |||
5298 | return sResult; | |||
5299 | } | |||
5300 | ||||
5301 | uno::Reference <xml::sax::XFastParser> OOXMLStreamImpl::getFastParser() | |||
5302 | { | |||
5303 | if (!mxFastParser.is()) | |||
5304 | { | |||
5305 | mxFastParser = css::xml::sax::FastParser::create(mxContext); | |||
5306 | // the threaded parser is about 20% slower loading writer documents | |||
5307 | css::uno::Reference< css::lang::XInitialization > xInit( mxFastParser, css::uno::UNO_QUERY_THROW ); | |||
5308 | css::uno::Sequence< css::uno::Any > args(1); | |||
5309 | args[0] <<= OUString("DisableThreadedParser"); | |||
5310 | xInit->initialize(args); | |||
5311 | ||||
5312 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/chart", oox::NMSP_dmlChart); | |||
5313 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/chartDrawing", oox::NMSP_dmlChartDr); | |||
5314 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/diagram", oox::NMSP_dmlDiagram); | |||
5315 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/lockedCanvas", oox::NMSP_dmlLockedCanvas); | |||
5316 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/main", oox::NMSP_dml); | |||
5317 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/picture", oox::NMSP_dmlPicture); | |||
5318 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/spreadsheetDrawing", oox::NMSP_dmlSpreadDr); | |||
5319 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing", oox::NMSP_dmlWordDr); | |||
5320 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/officeDocument/custom-properties", oox::NMSP_officeCustomPr); | |||
5321 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes", oox::NMSP_officeDocPropsVT); | |||
5322 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/officeDocument/extended-properties", oox::NMSP_officeExtPr); | |||
5323 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/officeDocument/math", oox::NMSP_officeMath); | |||
5324 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/officeDocument/relationships", oox::NMSP_officeRel); | |||
5325 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/officeDocument/relationships/theme", oox::NMSP_officeRelTheme); | |||
5326 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/presentationml/main", oox::NMSP_ppt); | |||
5327 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/schemaLibrary/main", oox::NMSP_schema); | |||
5328 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/spreadsheetml/main", oox::NMSP_xls); | |||
5329 | mxFastParser->registerNamespace("http://purl.oclc.org/ooxml/wordprocessingml/main", oox::NMSP_doc); | |||
5330 | mxFastParser->registerNamespace("http://purl.org/dc/dcmitype/", oox::NMSP_dcmiType); | |||
5331 | mxFastParser->registerNamespace("http://purl.org/dc/elements/1.1/", oox::NMSP_dc); | |||
5332 | mxFastParser->registerNamespace("http://purl.org/dc/terms/", oox::NMSP_dcTerms); | |||
5333 | mxFastParser->registerNamespace("http://schemas.libreoffice.org/", oox::NMSP_loext); | |||
5334 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/2006/activeX", oox::NMSP_ax); | |||
5335 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/drawing/2008/diagram", oox::NMSP_dsp); | |||
5336 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/drawing/2010/main", oox::NMSP_a14); | |||
5337 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/drawing/2012/chart", oox::NMSP_c15); | |||
5338 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/excel/2006/main", oox::NMSP_xm); | |||
5339 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/powerpoint/2010/main", oox::NMSP_p14); | |||
5340 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/powerpoint/2012/main", oox::NMSP_p15); | |||
5341 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/spreadsheetml/2009/9/main", oox::NMSP_xls14Lst); | |||
5342 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/spreadsheetml/2011/1/ac", oox::NMSP_x12ac); | |||
5343 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/word/2010/wordml", oox::NMSP_w14); | |||
5344 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing", oox::NMSP_wp14); | |||
5345 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/word/2010/wordprocessingGroup", oox::NMSP_wpg); | |||
5346 | mxFastParser->registerNamespace("http://schemas.microsoft.com/office/word/2010/wordprocessingShape", oox::NMSP_wps); | |||
5347 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/chart", oox::NMSP_dmlChart); | |||
5348 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/chartDrawing", oox::NMSP_dmlChartDr); | |||
5349 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/diagram", oox::NMSP_dmlDiagram); | |||
5350 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas", oox::NMSP_dmlLockedCanvas); | |||
5351 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/main", oox::NMSP_dml); | |||
5352 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/picture", oox::NMSP_dmlPicture); | |||
5353 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing", oox::NMSP_dmlSpreadDr); | |||
5354 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing", oox::NMSP_dmlWordDr); | |||
5355 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/markup-compatibility/2006", oox::NMSP_mce); | |||
5356 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/officeDocument/2006/custom-properties", oox::NMSP_officeCustomPr); | |||
5357 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes", oox::NMSP_officeDocPropsVT); | |||
5358 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/officeDocument/2006/extended-properties", oox::NMSP_officeExtPr); | |||
5359 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/officeDocument/2006/math", oox::NMSP_officeMath); | |||
5360 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/officeDocument/2006/relationships", oox::NMSP_officeRel); | |||
5361 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme", oox::NMSP_officeRelTheme); | |||
5362 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/package/2006/content-types", oox::NMSP_packageContentTypes); | |||
5363 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/package/2006/metadata/core-properties", oox::NMSP_packageMetaCorePr); | |||
5364 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/package/2006/relationships", oox::NMSP_packageRel); | |||
5365 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/presentationml/2006/main", oox::NMSP_ppt); | |||
5366 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/schemaLibrary/2006/main", oox::NMSP_schema); | |||
5367 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/spreadsheetml/2006/main", oox::NMSP_xls); | |||
5368 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/spreadsheetml/2006/main/v2", oox::NMSP_mceTest); | |||
5369 | mxFastParser->registerNamespace("http://schemas.openxmlformats.org/wordprocessingml/2006/main", oox::NMSP_doc); | |||
5370 | mxFastParser->registerNamespace("http://www.w3.org/2001/XMLSchema-instance", oox::NMSP_xsi); | |||
5371 | mxFastParser->registerNamespace("http://www.w3.org/XML/1998/namespace", oox::NMSP_xml); | |||
5372 | mxFastParser->registerNamespace("urn:schemas-microsoft-com:office:excel", oox::NMSP_vmlExcel); | |||
5373 | mxFastParser->registerNamespace("urn:schemas-microsoft-com:office:office", oox::NMSP_vmlOffice); | |||
5374 | mxFastParser->registerNamespace("urn:schemas-microsoft-com:office:powerpoint", oox::NMSP_vmlPowerpoint); | |||
5375 | mxFastParser->registerNamespace("urn:schemas-microsoft-com:office:word", oox::NMSP_vmlWord); | |||
5376 | mxFastParser->registerNamespace("urn:schemas-microsoft-com:vml", oox::NMSP_vml); | |||
5377 | } | |||
5378 | ||||
5379 | return mxFastParser; | |||
5380 | } | |||
5381 | ||||
5382 | /// @endcond | |||
5383 | }} |
1 | /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ | |||
2 | /* | |||
3 | * This file is part of the LibreOffice project. | |||
4 | * | |||
5 | * This Source Code Form is subject to the terms of the Mozilla Public | |||
6 | * License, v. 2.0. If a copy of the MPL was not distributed with this | |||
7 | * file, You can obtain one at http://mozilla.org/MPL/2.0/. | |||
8 | * | |||
9 | * This file incorporates work covered by the following license notice: | |||
10 | * | |||
11 | * Licensed to the Apache Software Foundation (ASF) under one or more | |||
12 | * contributor license agreements. See the NOTICE file distributed | |||
13 | * with this work for additional information regarding copyright | |||
14 | * ownership. The ASF licenses this file to you under the Apache | |||
15 | * License, Version 2.0 (the "License"); you may not use this file | |||
16 | * except in compliance with the License. You may obtain a copy of | |||
17 | * the License at http://www.apache.org/licenses/LICENSE-2.0 . | |||
18 | */ | |||
19 | #ifndef INCLUDED_TOOLS_REF_HXX | |||
20 | #define INCLUDED_TOOLS_REF_HXX | |||
21 | ||||
22 | #include <sal/config.h> | |||
23 | #include <cassert> | |||
24 | #include <tools/toolsdllapi.h> | |||
25 | #include <utility> | |||
26 | ||||
27 | /** | |||
28 | This implements similar functionality to boost::intrusive_ptr | |||
29 | */ | |||
30 | ||||
31 | namespace tools { | |||
32 | ||||
33 | /** T must be a class that extends SvRefBase */ | |||
34 | template<typename T> class SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) SvRef final { | |||
35 | public: | |||
36 | SvRef(): pObj(nullptr) {} | |||
37 | ||||
38 | SvRef(SvRef&& rObj) noexcept | |||
39 | { | |||
40 | pObj = rObj.pObj; | |||
41 | rObj.pObj = nullptr; | |||
42 | } | |||
43 | ||||
44 | SvRef(SvRef const & rObj): pObj(rObj.pObj) | |||
45 | { | |||
46 | if (pObj != nullptr) pObj->AddNextRef(); | |||
47 | } | |||
48 | ||||
49 | SvRef(T * pObjP): pObj(pObjP) | |||
50 | { | |||
51 | if (pObj != nullptr) pObj->AddFirstRef(); | |||
52 | } | |||
53 | ||||
54 | ~SvRef() | |||
55 | { | |||
56 | if (pObj != nullptr) pObj->ReleaseRef(); | |||
57 | } | |||
58 | ||||
59 | void clear() | |||
60 | { | |||
61 | if (pObj != nullptr) { | |||
62 | T * pRefObj = pObj; | |||
63 | pObj = nullptr; | |||
64 | pRefObj->ReleaseRef(); | |||
65 | } | |||
66 | } | |||
67 | ||||
68 | SvRef & operator =(SvRef const & rObj) | |||
69 | { | |||
70 | if (rObj.pObj != nullptr) { | |||
71 | rObj.pObj->AddNextRef(); | |||
72 | } | |||
73 | T * pRefObj = pObj; | |||
74 | pObj = rObj.pObj; | |||
75 | if (pRefObj != nullptr) { | |||
76 | pRefObj->ReleaseRef(); | |||
77 | } | |||
78 | return *this; | |||
79 | } | |||
80 | ||||
81 | SvRef & operator =(SvRef && rObj) | |||
82 | { | |||
83 | if (pObj != nullptr) { | |||
84 | pObj->ReleaseRef(); | |||
| ||||
85 | } | |||
86 | pObj = rObj.pObj; | |||
87 | rObj.pObj = nullptr; | |||
88 | return *this; | |||
89 | } | |||
90 | ||||
91 | bool is() const { return pObj != nullptr; } | |||
92 | ||||
93 | explicit operator bool() const { return is(); } | |||
94 | ||||
95 | T * get() const { return pObj; } | |||
96 | ||||
97 | T * operator ->() const { assert(pObj != nullptr)(static_cast <bool> (pObj != nullptr) ? void (0) : __assert_fail ("pObj != nullptr", "/home/maarten/src/libreoffice/core/include/tools/ref.hxx" , 97, __extension__ __PRETTY_FUNCTION__)); return pObj; } | |||
98 | ||||
99 | T & operator *() const { assert(pObj != nullptr)(static_cast <bool> (pObj != nullptr) ? void (0) : __assert_fail ("pObj != nullptr", "/home/maarten/src/libreoffice/core/include/tools/ref.hxx" , 99, __extension__ __PRETTY_FUNCTION__)); return *pObj; } | |||
100 | ||||
101 | bool operator ==(const SvRef<T> &rhs) const { return pObj == rhs.pObj; } | |||
102 | bool operator !=(const SvRef<T> &rhs) const { return !(*this == rhs); } | |||
103 | ||||
104 | private: | |||
105 | T * pObj; | |||
106 | }; | |||
107 | ||||
108 | /** | |||
109 | * This implements similar functionality to std::make_shared. | |||
110 | */ | |||
111 | template<typename T, typename... Args> | |||
112 | SvRef<T> make_ref(Args&& ... args) | |||
113 | { | |||
114 | return SvRef<T>(new T(std::forward<Args>(args)...)); | |||
115 | } | |||
116 | ||||
117 | } | |||
118 | ||||
119 | /** Classes that want to be referenced-counted via SvRef<T>, should extend this base class */ | |||
120 | class TOOLS_DLLPUBLIC__attribute__ ((visibility("default"))) SvRefBase | |||
121 | { | |||
122 | // work around a clang 3.5 optimization bug: if the bNoDelete is *first* | |||
123 | // it mis-compiles "if (--nRefCount == 0)" and never deletes any object | |||
124 | unsigned int nRefCount : 31; | |||
125 | // the only reason this is not bool is because MSVC cannot handle mixed type bitfields | |||
126 | unsigned int bNoDelete : 1; | |||
127 | ||||
128 | protected: | |||
129 | virtual ~SvRefBase() COVERITY_NOEXCEPT_FALSE; | |||
130 | ||||
131 | public: | |||
132 | SvRefBase() : nRefCount(0), bNoDelete(1) {} | |||
133 | SvRefBase(const SvRefBase &) : nRefCount(0), bNoDelete(1) {} | |||
134 | ||||
135 | SvRefBase & operator=(const SvRefBase &) { return *this; } | |||
136 | ||||
137 | void RestoreNoDelete() | |||
138 | { bNoDelete = 1; } | |||
139 | ||||
140 | void AddNextRef() | |||
141 | { | |||
142 | assert( nRefCount < (1 << 30) && "Do not add refs to dead objects" )(static_cast <bool> (nRefCount < (1 << 30) && "Do not add refs to dead objects") ? void (0) : __assert_fail ("nRefCount < (1 << 30) && \"Do not add refs to dead objects\"" , "/home/maarten/src/libreoffice/core/include/tools/ref.hxx", 142, __extension__ __PRETTY_FUNCTION__)); | |||
143 | ++nRefCount; | |||
144 | } | |||
145 | ||||
146 | void AddFirstRef() | |||
147 | { | |||
148 | assert( nRefCount < (1 << 30) && "Do not add refs to dead objects" )(static_cast <bool> (nRefCount < (1 << 30) && "Do not add refs to dead objects") ? void (0) : __assert_fail ("nRefCount < (1 << 30) && \"Do not add refs to dead objects\"" , "/home/maarten/src/libreoffice/core/include/tools/ref.hxx", 148, __extension__ __PRETTY_FUNCTION__)); | |||
149 | if( bNoDelete ) | |||
150 | bNoDelete = 0; | |||
151 | ++nRefCount; | |||
152 | } | |||
153 | ||||
154 | void ReleaseRef() | |||
155 | { | |||
156 | assert( nRefCount >= 1)(static_cast <bool> (nRefCount >= 1) ? void (0) : __assert_fail ("nRefCount >= 1", "/home/maarten/src/libreoffice/core/include/tools/ref.hxx" , 156, __extension__ __PRETTY_FUNCTION__)); | |||
157 | if( --nRefCount == 0 && !bNoDelete) | |||
158 | { | |||
159 | // I'm not sure about the original purpose of this line, but right now | |||
160 | // it serves the purpose that anything that attempts to do an AddRef() | |||
161 | // after an object is deleted will trip an assert. | |||
162 | nRefCount = 1 << 30; | |||
163 | delete this; | |||
164 | } | |||
165 | } | |||
166 | ||||
167 | unsigned int GetRefCount() const | |||
168 | { return nRefCount; } | |||
169 | }; | |||
170 | ||||
171 | template<typename T> | |||
172 | class SvCompatWeakBase; | |||
173 | ||||
174 | /** SvCompatWeakHdl acts as an intermediary between SvCompatWeakRef<T> and T. | |||
175 | */ | |||
176 | template<typename T> | |||
177 | class SvCompatWeakHdl final : public SvRefBase | |||
178 | { | |||
179 | friend class SvCompatWeakBase<T>; | |||
180 | T* _pObj; | |||
181 | ||||
182 | SvCompatWeakHdl( T* pObj ) : _pObj( pObj ) {} | |||
183 | ||||
184 | public: | |||
185 | void ResetWeakBase( ) { _pObj = nullptr; } | |||
186 | T* GetObj() { return _pObj; } | |||
187 | }; | |||
188 | ||||
189 | /** We only have one place that extends this, in include/sfx2/frame.hxx, class SfxFrame. | |||
190 | Its function is to notify the SvCompatWeakHdl when an SfxFrame object is deleted. | |||
191 | */ | |||
192 | template<typename T> | |||
193 | class SvCompatWeakBase | |||
194 | { | |||
195 | tools::SvRef< SvCompatWeakHdl<T> > _xHdl; | |||
196 | ||||
197 | public: | |||
198 | /** Does not use initializer due to compiler warnings, | |||
199 | because the lifetime of the _xHdl object can exceed the lifetime of this class. | |||
200 | */ | |||
201 | SvCompatWeakBase( T* pObj ) { _xHdl = new SvCompatWeakHdl<T>( pObj ); } | |||
202 | ||||
203 | ~SvCompatWeakBase() { _xHdl->ResetWeakBase(); } | |||
204 | ||||
205 | SvCompatWeakHdl<T>* GetHdl() { return _xHdl.get(); } | |||
206 | }; | |||
207 | ||||
208 | /** We only have one weak reference in LO, in include/sfx2/frame.hxx, class SfxFrameWeak. | |||
209 | */ | |||
210 | template<typename T> | |||
211 | class SAL_WARN_UNUSED__attribute__((warn_unused)) SvCompatWeakRef | |||
212 | { | |||
213 | tools::SvRef< SvCompatWeakHdl<T> > _xHdl; | |||
214 | public: | |||
215 | SvCompatWeakRef( ) {} | |||
216 | SvCompatWeakRef( T* pObj ) | |||
217 | { if( pObj ) _xHdl = pObj->GetHdl(); } | |||
218 | #if defined(__COVERITY__) | |||
219 | ~SvCompatWeakRef() COVERITY_NOEXCEPT_FALSE {} | |||
220 | #endif | |||
221 | SvCompatWeakRef& operator = ( T * pObj ) | |||
222 | { _xHdl = pObj ? pObj->GetHdl() : nullptr; return *this; } | |||
223 | bool is() const | |||
224 | { return _xHdl.is() && _xHdl->GetObj(); } | |||
225 | explicit operator bool() const { return is(); } | |||
226 | T* operator -> () const | |||
227 | { return _xHdl.is() ? _xHdl->GetObj() : nullptr; } | |||
228 | operator T* () const | |||
229 | { return _xHdl.is() ? _xHdl->GetObj() : nullptr; } | |||
230 | }; | |||
231 | ||||
232 | #endif | |||
233 | ||||
234 | /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |