Line data Source code
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 :
20 : #include "xexptran.hxx"
21 : #include <rtl/ustrbuf.hxx>
22 : #include <sax/tools/converter.hxx>
23 : #include <xmloff/xmluconv.hxx>
24 : #include <xmloff/xmlexp.hxx>
25 : #include <xmloff/xmlimp.hxx>
26 : #include <tools/helpers.hxx>
27 : #include <basegfx/vector/b2dvector.hxx>
28 : #include <basegfx/matrix/b2dhommatrix.hxx>
29 : #include <basegfx/tuple/b3dtuple.hxx>
30 : #include <basegfx/matrix/b3dhommatrix.hxx>
31 : #include <basegfx/numeric/ftools.hxx>
32 : #include <basegfx/polygon/b2dpolypolygon.hxx>
33 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
34 : #include <basegfx/tools/unotools.hxx>
35 :
36 : using namespace ::com::sun::star;
37 :
38 : // parsing help functions for simple chars
39 2198 : void Imp_SkipSpaces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
40 : {
41 6594 : while(rPos < nLen
42 2198 : && ' ' == rStr[rPos])
43 0 : rPos++;
44 2198 : }
45 :
46 172 : void Imp_SkipSpacesAndOpeningBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
47 : {
48 1200 : while(rPos < nLen
49 514 : && (' ' == rStr[rPos] || '(' == rStr[rPos]))
50 342 : rPos++;
51 172 : }
52 :
53 6000 : void Imp_SkipSpacesAndCommas(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
54 : {
55 29876 : while(rPos < nLen
56 11938 : && (' ' == rStr[rPos] || ',' == rStr[rPos]))
57 5938 : rPos++;
58 6000 : }
59 :
60 172 : void Imp_SkipSpacesAndClosingBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
61 : {
62 968 : while(rPos < nLen
63 398 : && (' ' == rStr[rPos] || ')' == rStr[rPos]))
64 226 : rPos++;
65 172 : }
66 :
67 : // parsing help functions for integer numbers
68 :
69 900 : bool Imp_IsOnUnitChar(const OUString& rStr, const sal_Int32 nPos)
70 : {
71 900 : sal_Unicode aChar(rStr[nPos]);
72 :
73 900 : if(('a' <= aChar && 'z' >= aChar)
74 300 : || ('A' <= aChar && 'Z' >= aChar)
75 300 : || '%' == aChar
76 : )
77 600 : return true;
78 300 : return false;
79 : }
80 :
81 7834 : double Imp_GetDoubleChar(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen,
82 : const SvXMLUnitConverter& rConv, double fRetval, bool bLookForUnits = false)
83 : {
84 7834 : sal_Unicode aChar(rStr[rPos]);
85 7834 : OUStringBuffer sNumberString;
86 :
87 7834 : if('+' == aChar || '-' == aChar)
88 : {
89 218 : sNumberString.append(rStr[rPos]);
90 218 : ++rPos;
91 218 : aChar = rPos >= nLen ? 0 : rStr[rPos];
92 : }
93 :
94 43400 : while(('0' <= aChar && '9' >= aChar)
95 8556 : || '.' == aChar)
96 : {
97 27732 : sNumberString.append(rStr[rPos]);
98 27732 : ++rPos;
99 27732 : aChar = rPos >= nLen ? 0 : rStr[rPos];
100 : }
101 :
102 7834 : if('e' == aChar || 'E' == aChar)
103 : {
104 0 : sNumberString.append(rStr[rPos]);
105 0 : ++rPos;
106 0 : aChar = rPos >= nLen ? 0 : rStr[rPos];
107 :
108 0 : if('+' == aChar || '-' == aChar)
109 : {
110 0 : sNumberString.append(rStr[rPos]);
111 0 : ++rPos;
112 0 : aChar = rPos >= nLen ? 0 : rStr[rPos];
113 : }
114 :
115 0 : while('0' <= aChar && '9' >= aChar)
116 : {
117 0 : sNumberString.append(rStr[rPos]);
118 0 : ++rPos;
119 0 : aChar = rPos >= nLen ? 0 : rStr[rPos];
120 : }
121 : }
122 :
123 7834 : if(bLookForUnits)
124 : {
125 300 : Imp_SkipSpaces(rStr, rPos, nLen);
126 1200 : while(rPos < nLen && Imp_IsOnUnitChar(rStr, rPos))
127 600 : sNumberString.append(rStr[rPos++]);
128 : }
129 :
130 7834 : if(!sNumberString.isEmpty())
131 : {
132 7834 : if(bLookForUnits)
133 300 : rConv.convertDouble(fRetval, sNumberString.makeStringAndClear(), true);
134 : else
135 : {
136 : ::sax::Converter::convertDouble(fRetval,
137 7534 : sNumberString.makeStringAndClear());
138 : }
139 : }
140 :
141 7834 : return fRetval;
142 : }
143 :
144 112 : void Imp_PutDoubleChar(OUString& rStr, double fValue)
145 : {
146 112 : OUStringBuffer sStringBuffer;
147 112 : ::sax::Converter::convertDouble(sStringBuffer, fValue);
148 112 : rStr += OUString(sStringBuffer.makeStringAndClear());
149 112 : }
150 :
151 2460 : void Imp_PutDoubleChar(OUString& rStr, const SvXMLUnitConverter& rConv, double fValue,
152 : bool bConvertUnits = false)
153 : {
154 2460 : OUStringBuffer sStringBuffer;
155 :
156 2460 : if(bConvertUnits)
157 620 : rConv.convertDouble(sStringBuffer, fValue, true);
158 : else
159 : {
160 1840 : ::sax::Converter::convertDouble(sStringBuffer, fValue);
161 : }
162 :
163 2460 : rStr += OUString(sStringBuffer.makeStringAndClear());
164 2460 : }
165 :
166 : // base class of all 2D transform objects
167 :
168 : struct ImpSdXMLExpTransObj2DBase
169 : {
170 : sal_uInt16 mnType;
171 116 : ImpSdXMLExpTransObj2DBase(sal_uInt16 nType)
172 116 : : mnType(nType) {}
173 : };
174 :
175 : // possible object types for 2D
176 :
177 : #define IMP_SDXMLEXP_TRANSOBJ2D_ROTATE 0x0000
178 : #define IMP_SDXMLEXP_TRANSOBJ2D_SCALE 0x0001
179 : #define IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE 0x0002
180 : #define IMP_SDXMLEXP_TRANSOBJ2D_SKEWX 0x0003
181 : #define IMP_SDXMLEXP_TRANSOBJ2D_SKEWY 0x0004
182 : #define IMP_SDXMLEXP_TRANSOBJ2D_MATRIX 0x0005
183 :
184 : // classes of objects, different sizes
185 :
186 : struct ImpSdXMLExpTransObj2DRotate : public ImpSdXMLExpTransObj2DBase
187 : {
188 : double mfRotate;
189 58 : ImpSdXMLExpTransObj2DRotate(double fVal)
190 58 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_ROTATE), mfRotate(fVal) {}
191 : };
192 0 : struct ImpSdXMLExpTransObj2DScale : public ImpSdXMLExpTransObj2DBase
193 : {
194 : ::basegfx::B2DTuple maScale;
195 0 : ImpSdXMLExpTransObj2DScale(const ::basegfx::B2DTuple& rNew)
196 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SCALE), maScale(rNew) {}
197 : };
198 58 : struct ImpSdXMLExpTransObj2DTranslate : public ImpSdXMLExpTransObj2DBase
199 : {
200 : ::basegfx::B2DTuple maTranslate;
201 58 : ImpSdXMLExpTransObj2DTranslate(const ::basegfx::B2DTuple& rNew)
202 58 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE), maTranslate(rNew) {}
203 : };
204 : struct ImpSdXMLExpTransObj2DSkewX : public ImpSdXMLExpTransObj2DBase
205 : {
206 : double mfSkewX;
207 0 : ImpSdXMLExpTransObj2DSkewX(double fVal)
208 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWX), mfSkewX(fVal) {}
209 : };
210 : struct ImpSdXMLExpTransObj2DSkewY : public ImpSdXMLExpTransObj2DBase
211 : {
212 : double mfSkewY;
213 0 : ImpSdXMLExpTransObj2DSkewY(double fVal)
214 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWY), mfSkewY(fVal) {}
215 : };
216 0 : struct ImpSdXMLExpTransObj2DMatrix : public ImpSdXMLExpTransObj2DBase
217 : {
218 : ::basegfx::B2DHomMatrix maMatrix;
219 0 : ImpSdXMLExpTransObj2DMatrix(const ::basegfx::B2DHomMatrix& rNew)
220 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_MATRIX), maMatrix(rNew) {}
221 : };
222 :
223 : // delete all entries in list
224 :
225 5934 : void SdXMLImExTransform2D::EmptyList()
226 : {
227 5934 : const sal_uInt32 nCount = maList.size();
228 6050 : for(sal_uInt32 a(0L); a < nCount; a++)
229 : {
230 116 : ImpSdXMLExpTransObj2DBase* pObj = maList[a];
231 :
232 116 : switch(pObj->mnType)
233 : {
234 : case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
235 : {
236 58 : delete static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj);
237 58 : break;
238 : }
239 : case IMP_SDXMLEXP_TRANSOBJ2D_SCALE :
240 : {
241 0 : delete static_cast<ImpSdXMLExpTransObj2DScale*>(pObj);
242 0 : break;
243 : }
244 : case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE :
245 : {
246 58 : delete static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj);
247 58 : break;
248 : }
249 : case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX :
250 : {
251 0 : delete static_cast<ImpSdXMLExpTransObj2DSkewX*>(pObj);
252 0 : break;
253 : }
254 : case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY :
255 : {
256 0 : delete static_cast<ImpSdXMLExpTransObj2DSkewY*>(pObj);
257 0 : break;
258 : }
259 : case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX :
260 : {
261 0 : delete static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj);
262 0 : break;
263 : }
264 : default :
265 : {
266 : OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
267 0 : break;
268 : }
269 : }
270 : }
271 :
272 5934 : maList.clear();
273 5934 : }
274 :
275 : // add members
276 :
277 4 : void SdXMLImExTransform2D::AddRotate(double fNew)
278 : {
279 4 : if(fNew != 0.0)
280 4 : maList.push_back(new ImpSdXMLExpTransObj2DRotate(fNew));
281 4 : }
282 :
283 4 : void SdXMLImExTransform2D::AddTranslate(const ::basegfx::B2DTuple& rNew)
284 : {
285 4 : if(!rNew.equalZero())
286 4 : maList.push_back(new ImpSdXMLExpTransObj2DTranslate(rNew));
287 4 : }
288 :
289 4 : void SdXMLImExTransform2D::AddSkewX(double fNew)
290 : {
291 4 : if(fNew != 0.0)
292 0 : maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fNew));
293 4 : }
294 :
295 : // gen string for export
296 4 : const OUString& SdXMLImExTransform2D::GetExportString(const SvXMLUnitConverter& rConv)
297 : {
298 4 : OUString aNewString;
299 8 : OUString aClosingBrace(")");
300 8 : OUString aEmptySpace(" ");
301 :
302 4 : const sal_uInt32 nCount = maList.size();
303 12 : for(sal_uInt32 a(0L); a < nCount; a++)
304 : {
305 8 : ImpSdXMLExpTransObj2DBase* pObj = maList[a];
306 8 : switch(pObj->mnType)
307 : {
308 : case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
309 : {
310 4 : aNewString += "rotate (";
311 4 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj)->mfRotate);
312 4 : aNewString += aClosingBrace;
313 4 : break;
314 : }
315 : case IMP_SDXMLEXP_TRANSOBJ2D_SCALE :
316 : {
317 0 : aNewString += "scale (";
318 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DScale*>(pObj)->maScale.getX());
319 0 : aNewString += aEmptySpace;
320 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DScale*>(pObj)->maScale.getY());
321 0 : aNewString += aClosingBrace;
322 0 : break;
323 : }
324 : case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE :
325 : {
326 4 : aNewString += "translate (";
327 4 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate.getX(), true);
328 4 : aNewString += aEmptySpace;
329 4 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate.getY(), true);
330 4 : aNewString += aClosingBrace;
331 4 : break;
332 : }
333 : case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX :
334 : {
335 0 : aNewString += "skewX (";
336 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DSkewX*>(pObj)->mfSkewX);
337 0 : aNewString += aClosingBrace;
338 0 : break;
339 : }
340 : case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY :
341 : {
342 0 : aNewString += "skewY (";
343 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DSkewY*>(pObj)->mfSkewY);
344 0 : aNewString += aClosingBrace;
345 0 : break;
346 : }
347 : case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX :
348 : {
349 0 : aNewString += "matrix (";
350 :
351 : // a
352 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(0, 0));
353 0 : aNewString += aEmptySpace;
354 :
355 : // b
356 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(1, 0));
357 0 : aNewString += aEmptySpace;
358 :
359 : // c
360 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(0, 1));
361 0 : aNewString += aEmptySpace;
362 :
363 : // d
364 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(1, 1));
365 0 : aNewString += aEmptySpace;
366 :
367 : // e
368 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(0, 2), true);
369 0 : aNewString += aEmptySpace;
370 :
371 : // f
372 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix.get(1, 2), true);
373 :
374 0 : aNewString += aClosingBrace;
375 0 : break;
376 : }
377 : default :
378 : {
379 : OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
380 0 : break;
381 : }
382 : }
383 :
384 : // if not the last entry, add one space to next tag
385 8 : if(a + 1UL != maList.size())
386 : {
387 4 : aNewString += aEmptySpace;
388 : }
389 : }
390 :
391 : // fill string form OUString
392 4 : msString = aNewString;
393 :
394 8 : return msString;
395 : }
396 :
397 : // sets new string, parses it and generates entries
398 54 : void SdXMLImExTransform2D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
399 : {
400 54 : msString = rNew;
401 54 : EmptyList();
402 :
403 54 : if(!msString.isEmpty())
404 : {
405 54 : const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
406 54 : const sal_Int32 nLen(aStr.getLength());
407 :
408 108 : const OUString aString_rotate( "rotate" );
409 108 : const OUString aString_scale( "scale" );
410 108 : const OUString aString_translate( "translate" );
411 108 : const OUString aString_skewX( "skewX" );
412 108 : const OUString aString_skewY( "skewY" );
413 108 : const OUString aString_matrix( "matrix" );
414 :
415 54 : sal_Int32 nPos(0);
416 :
417 216 : while(nPos < nLen)
418 : {
419 : // skip spaces
420 108 : Imp_SkipSpaces(aStr, nPos, nLen);
421 :
422 : // look for tag
423 108 : if(nPos < nLen)
424 : {
425 108 : if(nPos == aStr.indexOf(aString_rotate, nPos))
426 : {
427 54 : double fValue(0.0);
428 54 : nPos += 6;
429 54 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
430 54 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
431 54 : if(fValue != 0.0)
432 54 : maList.push_back(new ImpSdXMLExpTransObj2DRotate(fValue));
433 :
434 54 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
435 : }
436 54 : else if(nPos == aStr.indexOf(aString_scale, nPos))
437 : {
438 0 : ::basegfx::B2DTuple aValue(1.0, 1.0);
439 0 : nPos += 5;
440 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
441 0 : aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
442 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
443 0 : aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
444 :
445 0 : if(aValue.getX() != 1.0 || aValue.getY() != 1.0)
446 0 : maList.push_back(new ImpSdXMLExpTransObj2DScale(aValue));
447 :
448 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
449 : }
450 54 : else if(nPos == aStr.indexOf(aString_translate, nPos))
451 : {
452 54 : ::basegfx::B2DTuple aValue;
453 54 : nPos += 9;
454 54 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
455 54 : aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
456 54 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
457 54 : aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
458 :
459 54 : if(!aValue.equalZero())
460 54 : maList.push_back(new ImpSdXMLExpTransObj2DTranslate(aValue));
461 :
462 54 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
463 : }
464 0 : else if(nPos == aStr.indexOf(aString_skewX, nPos))
465 : {
466 0 : double fValue(0.0);
467 0 : nPos += 5;
468 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
469 0 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
470 0 : if(fValue != 0.0)
471 0 : maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fValue));
472 :
473 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
474 : }
475 0 : else if(nPos == aStr.indexOf(aString_skewY, nPos))
476 : {
477 0 : double fValue(0.0);
478 0 : nPos += 5;
479 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
480 0 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
481 0 : if(fValue != 0.0)
482 0 : maList.push_back(new ImpSdXMLExpTransObj2DSkewY(fValue));
483 :
484 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
485 : }
486 0 : else if(nPos == aStr.indexOf(aString_matrix, nPos))
487 : {
488 0 : ::basegfx::B2DHomMatrix aValue;
489 :
490 0 : nPos += 6;
491 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
492 :
493 : // a
494 0 : aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
495 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
496 :
497 : // b
498 0 : aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
499 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
500 :
501 : // c
502 0 : aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
503 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
504 :
505 : // d
506 0 : aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
507 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
508 :
509 : // e
510 0 : aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2), true));
511 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
512 :
513 : // f
514 0 : aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2), true));
515 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
516 :
517 0 : if(!aValue.isIdentity())
518 0 : maList.push_back(new ImpSdXMLExpTransObj2DMatrix(aValue));
519 :
520 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
521 : }
522 : else
523 : {
524 0 : nPos++;
525 : }
526 : }
527 54 : }
528 : }
529 54 : }
530 :
531 54 : void SdXMLImExTransform2D::GetFullTransform(::basegfx::B2DHomMatrix& rFullTrans)
532 : {
533 54 : rFullTrans.identity();
534 :
535 54 : const sal_uInt32 nCount = maList.size();
536 162 : for(sal_uInt32 a(0L); a < nCount; a++)
537 : {
538 108 : ImpSdXMLExpTransObj2DBase* pObj = maList[a];
539 108 : switch(pObj->mnType)
540 : {
541 : case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
542 : {
543 : // #i78696#
544 : // mfRotate is mathematically wrong oriented since we export/import the angle
545 : // values mirrored. This error is fixed in the API, but not yet in the FileFormat.
546 : // For the FileFormat there is a follow-up task (#i78698#) to fix this in the next
547 : // ODF FileFormat version. For now - to emulate the old behaviour - it is necessary
548 : // to mirror the value here
549 54 : rFullTrans.rotate(static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj)->mfRotate * -1.0);
550 54 : break;
551 : }
552 : case IMP_SDXMLEXP_TRANSOBJ2D_SCALE :
553 : {
554 0 : const ::basegfx::B2DTuple& rScale = static_cast<ImpSdXMLExpTransObj2DScale*>(pObj)->maScale;
555 0 : rFullTrans.scale(rScale.getX(), rScale.getY());
556 0 : break;
557 : }
558 : case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE :
559 : {
560 54 : const ::basegfx::B2DTuple& rTranslate = static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate;
561 54 : rFullTrans.translate(rTranslate.getX(), rTranslate.getY());
562 54 : break;
563 : }
564 : case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX :
565 : {
566 0 : rFullTrans.shearX(tan(static_cast<ImpSdXMLExpTransObj2DSkewX*>(pObj)->mfSkewX));
567 0 : break;
568 : }
569 : case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY :
570 : {
571 0 : rFullTrans.shearY(tan(static_cast<ImpSdXMLExpTransObj2DSkewY*>(pObj)->mfSkewY));
572 0 : break;
573 : }
574 : case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX :
575 : {
576 0 : rFullTrans *= static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix;
577 0 : break;
578 : }
579 : default :
580 : {
581 : OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
582 0 : break;
583 : }
584 : }
585 : }
586 54 : }
587 :
588 : // base class of all 3D transform objects
589 :
590 : struct ImpSdXMLExpTransObj3DBase
591 : {
592 : sal_uInt16 mnType;
593 268 : ImpSdXMLExpTransObj3DBase(sal_uInt16 nType)
594 268 : : mnType(nType) {}
595 : };
596 :
597 : // possible object types for 3D
598 :
599 : #define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X 0x0000
600 : #define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y 0x0001
601 : #define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z 0x0002
602 : #define IMP_SDXMLEXP_TRANSOBJ3D_SCALE 0x0003
603 : #define IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE 0x0004
604 : #define IMP_SDXMLEXP_TRANSOBJ3D_MATRIX 0x0005
605 :
606 : // classes of objects, different sizes
607 :
608 : struct ImpSdXMLExpTransObj3DRotateX : public ImpSdXMLExpTransObj3DBase
609 : {
610 : double mfRotateX;
611 0 : ImpSdXMLExpTransObj3DRotateX(double fVal)
612 0 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X), mfRotateX(fVal) {}
613 : };
614 : struct ImpSdXMLExpTransObj3DRotateY : public ImpSdXMLExpTransObj3DBase
615 : {
616 : double mfRotateY;
617 0 : ImpSdXMLExpTransObj3DRotateY(double fVal)
618 0 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y), mfRotateY(fVal) {}
619 : };
620 : struct ImpSdXMLExpTransObj3DRotateZ : public ImpSdXMLExpTransObj3DBase
621 : {
622 : double mfRotateZ;
623 0 : ImpSdXMLExpTransObj3DRotateZ(double fVal)
624 0 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z), mfRotateZ(fVal) {}
625 : };
626 0 : struct ImpSdXMLExpTransObj3DScale : public ImpSdXMLExpTransObj3DBase
627 : {
628 : ::basegfx::B3DTuple maScale;
629 0 : ImpSdXMLExpTransObj3DScale(const ::basegfx::B3DTuple& rNew)
630 0 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_SCALE), maScale(rNew) {}
631 : };
632 0 : struct ImpSdXMLExpTransObj3DTranslate : public ImpSdXMLExpTransObj3DBase
633 : {
634 : ::basegfx::B3DTuple maTranslate;
635 0 : ImpSdXMLExpTransObj3DTranslate(const ::basegfx::B3DTuple& rNew)
636 0 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE), maTranslate(rNew) {}
637 : };
638 268 : struct ImpSdXMLExpTransObj3DMatrix : public ImpSdXMLExpTransObj3DBase
639 : {
640 : ::basegfx::B3DHomMatrix maMatrix;
641 268 : ImpSdXMLExpTransObj3DMatrix(const ::basegfx::B3DHomMatrix& rNew)
642 268 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_MATRIX), maMatrix(rNew) {}
643 : };
644 :
645 : // delete all entries in list
646 :
647 332 : void SdXMLImExTransform3D::EmptyList()
648 : {
649 332 : const sal_uInt32 nCount = maList.size();
650 600 : for(sal_uInt32 a(0L); a < nCount; a++)
651 : {
652 268 : ImpSdXMLExpTransObj3DBase* pObj = maList[a];
653 :
654 268 : switch(pObj->mnType)
655 : {
656 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X :
657 : {
658 0 : delete static_cast<ImpSdXMLExpTransObj3DRotateX*>(pObj);
659 0 : break;
660 : }
661 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y :
662 : {
663 0 : delete static_cast<ImpSdXMLExpTransObj3DRotateY*>(pObj);
664 0 : break;
665 : }
666 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z :
667 : {
668 0 : delete static_cast<ImpSdXMLExpTransObj3DRotateZ*>(pObj);
669 0 : break;
670 : }
671 : case IMP_SDXMLEXP_TRANSOBJ3D_SCALE :
672 : {
673 0 : delete static_cast<ImpSdXMLExpTransObj3DScale*>(pObj);
674 0 : break;
675 : }
676 : case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE :
677 : {
678 0 : delete static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj);
679 0 : break;
680 : }
681 : case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX :
682 : {
683 268 : delete static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj);
684 268 : break;
685 : }
686 : default :
687 : {
688 : OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
689 0 : break;
690 : }
691 : }
692 : }
693 :
694 332 : maList.clear();
695 332 : }
696 :
697 : // add members
698 :
699 204 : void SdXMLImExTransform3D::AddMatrix(const ::basegfx::B3DHomMatrix& rNew)
700 : {
701 204 : if(!rNew.isIdentity())
702 204 : maList.push_back(new ImpSdXMLExpTransObj3DMatrix(rNew));
703 204 : }
704 :
705 204 : void SdXMLImExTransform3D::AddHomogenMatrix(const drawing::HomogenMatrix& xHomMat)
706 : {
707 204 : ::basegfx::B3DHomMatrix aExportMatrix;
708 :
709 204 : aExportMatrix.set(0, 0, xHomMat.Line1.Column1);
710 204 : aExportMatrix.set(0, 1, xHomMat.Line1.Column2);
711 204 : aExportMatrix.set(0, 2, xHomMat.Line1.Column3);
712 204 : aExportMatrix.set(0, 3, xHomMat.Line1.Column4);
713 204 : aExportMatrix.set(1, 0, xHomMat.Line2.Column1);
714 204 : aExportMatrix.set(1, 1, xHomMat.Line2.Column2);
715 204 : aExportMatrix.set(1, 2, xHomMat.Line2.Column3);
716 204 : aExportMatrix.set(1, 3, xHomMat.Line2.Column4);
717 204 : aExportMatrix.set(2, 0, xHomMat.Line3.Column1);
718 204 : aExportMatrix.set(2, 1, xHomMat.Line3.Column2);
719 204 : aExportMatrix.set(2, 2, xHomMat.Line3.Column3);
720 204 : aExportMatrix.set(2, 3, xHomMat.Line3.Column4);
721 :
722 204 : AddMatrix(aExportMatrix);
723 204 : }
724 :
725 : // gen string for export
726 204 : const OUString& SdXMLImExTransform3D::GetExportString(const SvXMLUnitConverter& rConv)
727 : {
728 204 : OUString aNewString;
729 408 : OUString aClosingBrace(")");
730 408 : OUString aEmptySpace(" ");
731 :
732 204 : const sal_uInt32 nCount = maList.size();
733 408 : for(sal_uInt32 a(0L); a < nCount; a++)
734 : {
735 204 : ImpSdXMLExpTransObj3DBase* pObj = maList[a];
736 204 : switch(pObj->mnType)
737 : {
738 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X :
739 : {
740 0 : aNewString += "rotatex (";
741 0 : Imp_PutDoubleChar(aNewString, rConv, basegfx::rad2deg( static_cast<ImpSdXMLExpTransObj3DRotateX*>(pObj)->mfRotateX) );
742 0 : aNewString += aClosingBrace;
743 0 : break;
744 : }
745 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y :
746 : {
747 0 : aNewString += "rotatey (";
748 0 : Imp_PutDoubleChar(aNewString, rConv, basegfx::rad2deg( static_cast<ImpSdXMLExpTransObj3DRotateY*>(pObj)->mfRotateY) );
749 0 : aNewString += aClosingBrace;
750 0 : break;
751 : }
752 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z :
753 : {
754 0 : aNewString += "rotatez (";
755 0 : Imp_PutDoubleChar(aNewString, rConv, basegfx::rad2deg( static_cast<ImpSdXMLExpTransObj3DRotateZ*>(pObj)->mfRotateZ) );
756 0 : aNewString += aClosingBrace;
757 0 : break;
758 : }
759 : case IMP_SDXMLEXP_TRANSOBJ3D_SCALE :
760 : {
761 0 : aNewString += "scale (";
762 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale.getX());
763 0 : aNewString += aEmptySpace;
764 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale.getY());
765 0 : aNewString += aEmptySpace;
766 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale.getZ());
767 0 : aNewString += aClosingBrace;
768 0 : break;
769 : }
770 : case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE :
771 : {
772 0 : aNewString += "translate (";
773 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate.getX(), true);
774 0 : aNewString += aEmptySpace;
775 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate.getY(), true);
776 0 : aNewString += aEmptySpace;
777 0 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate.getZ(), true);
778 0 : aNewString += aClosingBrace;
779 0 : break;
780 : }
781 : case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX :
782 : {
783 204 : aNewString += "matrix (";
784 :
785 : // a
786 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 0));
787 204 : aNewString += aEmptySpace;
788 :
789 : // b
790 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 0));
791 204 : aNewString += aEmptySpace;
792 :
793 : // c
794 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 0));
795 204 : aNewString += aEmptySpace;
796 :
797 : // d
798 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 1));
799 204 : aNewString += aEmptySpace;
800 :
801 : // e
802 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 1));
803 204 : aNewString += aEmptySpace;
804 :
805 : // f
806 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 1));
807 204 : aNewString += aEmptySpace;
808 :
809 : // g
810 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 2));
811 204 : aNewString += aEmptySpace;
812 :
813 : // h
814 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 2));
815 204 : aNewString += aEmptySpace;
816 :
817 : // i
818 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 2));
819 204 : aNewString += aEmptySpace;
820 :
821 : // j
822 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 3), true);
823 204 : aNewString += aEmptySpace;
824 :
825 : // k
826 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 3), true);
827 204 : aNewString += aEmptySpace;
828 :
829 : // l
830 204 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 3), true);
831 :
832 204 : aNewString += aClosingBrace;
833 204 : break;
834 : }
835 : default :
836 : {
837 : OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
838 0 : break;
839 : }
840 : }
841 :
842 : // if not the last entry, add one space to next tag
843 204 : if(a + 1UL != maList.size())
844 : {
845 0 : aNewString += aEmptySpace;
846 : }
847 : }
848 :
849 : // fill string form OUString
850 204 : msString = aNewString;
851 :
852 408 : return msString;
853 : }
854 :
855 : // for Import: constructor with string, parses it and generates entries
856 64 : SdXMLImExTransform3D::SdXMLImExTransform3D(const OUString& rNew, const SvXMLUnitConverter& rConv)
857 : {
858 64 : SetString(rNew, rConv);
859 64 : }
860 :
861 : // sets new string, parses it and generates entries
862 64 : void SdXMLImExTransform3D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
863 : {
864 64 : msString = rNew;
865 64 : EmptyList();
866 :
867 64 : if(!msString.isEmpty())
868 : {
869 64 : const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
870 64 : const sal_Int32 nLen(aStr.getLength());
871 :
872 128 : const OUString aString_rotatex( "rotatex" );
873 128 : const OUString aString_rotatey( "rotatey" );
874 128 : const OUString aString_rotatez( "rotatez" );
875 128 : const OUString aString_scale( "scale" );
876 128 : const OUString aString_translate( "translate" );
877 128 : const OUString aString_matrix( "matrix" );
878 :
879 64 : sal_Int32 nPos(0);
880 :
881 192 : while(nPos < nLen)
882 : {
883 : // skip spaces
884 64 : Imp_SkipSpaces(aStr, nPos, nLen);
885 :
886 : // look for tag
887 64 : if(nPos < nLen)
888 : {
889 64 : if(nPos == aStr.indexOf(aString_rotatex, nPos))
890 : {
891 0 : double fValue(0.0);
892 :
893 0 : nPos += 7;
894 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
895 0 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
896 0 : if(fValue != 0.0)
897 0 : maList.push_back(new ImpSdXMLExpTransObj3DRotateX(basegfx::deg2rad(fValue)));
898 :
899 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
900 : }
901 64 : else if(nPos == aStr.indexOf(aString_rotatey, nPos))
902 : {
903 0 : double fValue(0.0);
904 :
905 0 : nPos += 7;
906 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
907 0 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
908 0 : if(fValue != 0.0)
909 0 : maList.push_back(new ImpSdXMLExpTransObj3DRotateY(basegfx::deg2rad(fValue)));
910 :
911 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
912 : }
913 64 : else if(nPos == aStr.indexOf(aString_rotatez, nPos))
914 : {
915 0 : double fValue(0.0);
916 :
917 0 : nPos += 7;
918 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
919 0 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
920 0 : if(fValue != 0.0)
921 0 : maList.push_back(new ImpSdXMLExpTransObj3DRotateZ(basegfx::deg2rad(fValue)));
922 :
923 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
924 : }
925 64 : else if(nPos == aStr.indexOf(aString_scale, nPos))
926 : {
927 0 : ::basegfx::B3DTuple aValue(1.0, 1.0, 1.0);
928 :
929 0 : nPos += 5;
930 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
931 0 : aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
932 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
933 0 : aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
934 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
935 0 : aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ()));
936 :
937 0 : if(1.0 != aValue.getX() || 1.0 != aValue.getY() || 1.0 != aValue.getZ())
938 0 : maList.push_back(new ImpSdXMLExpTransObj3DScale(aValue));
939 :
940 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
941 : }
942 64 : else if(nPos == aStr.indexOf(aString_translate, nPos))
943 : {
944 0 : ::basegfx::B3DTuple aValue;
945 :
946 0 : nPos += 9;
947 0 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
948 0 : aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
949 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
950 0 : aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
951 0 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
952 0 : aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ(), true));
953 :
954 0 : if(!aValue.equalZero())
955 0 : maList.push_back(new ImpSdXMLExpTransObj3DTranslate(aValue));
956 :
957 0 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
958 : }
959 64 : else if(nPos == aStr.indexOf(aString_matrix, nPos))
960 : {
961 64 : ::basegfx::B3DHomMatrix aValue;
962 :
963 64 : nPos += 6;
964 64 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
965 :
966 : // a
967 64 : aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
968 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
969 :
970 : // b
971 64 : aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
972 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
973 :
974 : // c
975 64 : aValue.set(2, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 0)));
976 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
977 :
978 : // d
979 64 : aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
980 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
981 :
982 : // e
983 64 : aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
984 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
985 :
986 : // f
987 64 : aValue.set(2, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 1)));
988 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
989 :
990 : // g
991 64 : aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2)));
992 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
993 :
994 : // h
995 64 : aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2)));
996 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
997 :
998 : // i
999 64 : aValue.set(2, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 2)));
1000 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1001 :
1002 : // j
1003 64 : aValue.set(0, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 3), true));
1004 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1005 :
1006 : // k
1007 64 : aValue.set(1, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 3), true));
1008 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1009 :
1010 : // l
1011 64 : aValue.set(2, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 3), true));
1012 64 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1013 :
1014 64 : if(!aValue.isIdentity())
1015 64 : maList.push_back(new ImpSdXMLExpTransObj3DMatrix(aValue));
1016 :
1017 64 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1018 : }
1019 : else
1020 : {
1021 0 : nPos++;
1022 : }
1023 : }
1024 64 : }
1025 : }
1026 64 : }
1027 :
1028 64 : bool SdXMLImExTransform3D::GetFullHomogenTransform(com::sun::star::drawing::HomogenMatrix& xHomMat)
1029 : {
1030 64 : ::basegfx::B3DHomMatrix aFullTransform;
1031 64 : GetFullTransform(aFullTransform);
1032 :
1033 64 : if(!aFullTransform.isIdentity())
1034 : {
1035 64 : xHomMat.Line1.Column1 = aFullTransform.get(0, 0);
1036 64 : xHomMat.Line1.Column2 = aFullTransform.get(0, 1);
1037 64 : xHomMat.Line1.Column3 = aFullTransform.get(0, 2);
1038 64 : xHomMat.Line1.Column4 = aFullTransform.get(0, 3);
1039 :
1040 64 : xHomMat.Line2.Column1 = aFullTransform.get(1, 0);
1041 64 : xHomMat.Line2.Column2 = aFullTransform.get(1, 1);
1042 64 : xHomMat.Line2.Column3 = aFullTransform.get(1, 2);
1043 64 : xHomMat.Line2.Column4 = aFullTransform.get(1, 3);
1044 :
1045 64 : xHomMat.Line3.Column1 = aFullTransform.get(2, 0);
1046 64 : xHomMat.Line3.Column2 = aFullTransform.get(2, 1);
1047 64 : xHomMat.Line3.Column3 = aFullTransform.get(2, 2);
1048 64 : xHomMat.Line3.Column4 = aFullTransform.get(2, 3);
1049 :
1050 64 : xHomMat.Line4.Column1 = aFullTransform.get(3, 0);
1051 64 : xHomMat.Line4.Column2 = aFullTransform.get(3, 1);
1052 64 : xHomMat.Line4.Column3 = aFullTransform.get(3, 2);
1053 64 : xHomMat.Line4.Column4 = aFullTransform.get(3, 3);
1054 :
1055 64 : return true;
1056 : }
1057 :
1058 0 : return false;
1059 : }
1060 :
1061 64 : void SdXMLImExTransform3D::GetFullTransform(::basegfx::B3DHomMatrix& rFullTrans)
1062 : {
1063 64 : rFullTrans.identity();
1064 :
1065 64 : const sal_uInt32 nCount = maList.size();
1066 128 : for(sal_uInt32 a(0L); a < nCount; a++)
1067 : {
1068 64 : ImpSdXMLExpTransObj3DBase* pObj = maList[a];
1069 64 : switch(pObj->mnType)
1070 : {
1071 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X :
1072 : {
1073 0 : rFullTrans.rotate(static_cast<ImpSdXMLExpTransObj3DRotateX*>(pObj)->mfRotateX, 0.0, 0.0);
1074 0 : break;
1075 : }
1076 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y :
1077 : {
1078 0 : rFullTrans.rotate(0.0, static_cast<ImpSdXMLExpTransObj3DRotateY*>(pObj)->mfRotateY, 0.0);
1079 0 : break;
1080 : }
1081 : case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z :
1082 : {
1083 0 : rFullTrans.rotate(0.0, 0.0, static_cast<ImpSdXMLExpTransObj3DRotateZ*>(pObj)->mfRotateZ);
1084 0 : break;
1085 : }
1086 : case IMP_SDXMLEXP_TRANSOBJ3D_SCALE :
1087 : {
1088 0 : const ::basegfx::B3DTuple& rScale = static_cast<ImpSdXMLExpTransObj3DScale*>(pObj)->maScale;
1089 0 : rFullTrans.scale(rScale.getX(), rScale.getY(), rScale.getZ());
1090 0 : break;
1091 : }
1092 : case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE :
1093 : {
1094 0 : const ::basegfx::B3DTuple& rTranslate = static_cast<ImpSdXMLExpTransObj3DTranslate*>(pObj)->maTranslate;
1095 0 : rFullTrans.translate(rTranslate.getX(), rTranslate.getY(), rTranslate.getZ());
1096 0 : break;
1097 : }
1098 : case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX :
1099 : {
1100 64 : rFullTrans *= static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix;
1101 64 : break;
1102 : }
1103 : default :
1104 : {
1105 : OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
1106 0 : break;
1107 : }
1108 : }
1109 : }
1110 64 : }
1111 :
1112 28 : SdXMLImExViewBox::SdXMLImExViewBox(double fX, double fY, double fW, double fH)
1113 : : mfX( fX ),
1114 : mfY( fY ),
1115 : mfW( fW ),
1116 28 : mfH( fH )
1117 : {
1118 28 : }
1119 :
1120 : // #100617# Asked vincent hardy: svg:viewBox values may be double precision.
1121 1726 : SdXMLImExViewBox::SdXMLImExViewBox(const OUString& rNew, const SvXMLUnitConverter& rConv)
1122 : : msString(rNew),
1123 : mfX( 0.0 ),
1124 : mfY( 0.0 ),
1125 : mfW( 1000.0 ),
1126 1726 : mfH( 1000.0 )
1127 : {
1128 1726 : if(!msString.isEmpty())
1129 : {
1130 1726 : const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
1131 1726 : const sal_Int32 nLen(aStr.getLength());
1132 1726 : sal_Int32 nPos(0);
1133 :
1134 : // skip starting spaces
1135 1726 : Imp_SkipSpaces(aStr, nPos, nLen);
1136 :
1137 : // get mX, #100617# be prepared for doubles
1138 1726 : mfX = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfX);
1139 :
1140 : // skip spaces and commas
1141 1726 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1142 :
1143 : // get mY, #100617# be prepared for doubles
1144 1726 : mfY = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfY);
1145 :
1146 : // skip spaces and commas
1147 1726 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1148 :
1149 : // get mW, #100617# be prepared for doubles
1150 1726 : mfW = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfW);
1151 :
1152 : // skip spaces and commas
1153 1726 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1154 :
1155 : // get mH, #100617# be prepared for doubles
1156 1726 : mfH = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfH);
1157 : }
1158 1726 : }
1159 :
1160 28 : const OUString& SdXMLImExViewBox::GetExportString()
1161 : {
1162 28 : OUString aNewString;
1163 56 : OUString aEmptySpace(" ");
1164 :
1165 28 : Imp_PutDoubleChar(aNewString, mfX);
1166 28 : aNewString += aEmptySpace;
1167 :
1168 28 : Imp_PutDoubleChar(aNewString, mfY);
1169 28 : aNewString += aEmptySpace;
1170 :
1171 28 : Imp_PutDoubleChar(aNewString, mfW);
1172 28 : aNewString += aEmptySpace;
1173 :
1174 28 : Imp_PutDoubleChar(aNewString, mfH);
1175 :
1176 : // set new string
1177 28 : msString = aNewString;
1178 :
1179 56 : return msString;
1180 : }
1181 :
1182 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
