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 1131 : void Imp_SkipSpaces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
40 : {
41 3399 : while(rPos < nLen
42 1134 : && ' ' == rStr[rPos])
43 3 : rPos++;
44 1131 : }
45 :
46 73 : void Imp_SkipSpacesAndOpeningBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
47 : {
48 501 : while(rPos < nLen
49 214 : && (' ' == rStr[rPos] || '(' == rStr[rPos]))
50 141 : rPos++;
51 73 : }
52 :
53 3076 : void Imp_SkipSpacesAndCommas(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
54 : {
55 15344 : while(rPos < nLen
56 6134 : && (' ' == rStr[rPos] || ',' == rStr[rPos]))
57 3058 : rPos++;
58 3076 : }
59 :
60 73 : void Imp_SkipSpacesAndClosingBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
61 : {
62 421 : while(rPos < nLen
63 174 : && (' ' == rStr[rPos] || ')' == rStr[rPos]))
64 101 : rPos++;
65 73 : }
66 :
67 : // parsing help functions for integer numbers
68 :
69 300 : bool Imp_IsOnUnitChar(const OUString& rStr, const sal_Int32 nPos)
70 : {
71 300 : sal_Unicode aChar(rStr[nPos]);
72 :
73 300 : if(('a' <= aChar && 'z' >= aChar)
74 104 : || ('A' <= aChar && 'Z' >= aChar)
75 104 : || '%' == aChar
76 : )
77 196 : return true;
78 104 : return false;
79 : }
80 :
81 4086 : double Imp_GetDoubleChar(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen,
82 : const SvXMLUnitConverter& rConv, double fRetval, bool bLookForUnits = false)
83 : {
84 4086 : sal_Unicode aChar(rStr[rPos]);
85 4086 : OUStringBuffer sNumberString;
86 :
87 4086 : if('+' == aChar || '-' == aChar)
88 : {
89 65 : sNumberString.append(rStr[rPos]);
90 65 : ++rPos;
91 65 : aChar = rPos >= nLen ? 0 : rStr[rPos];
92 : }
93 :
94 20143 : while(('0' <= aChar && '9' >= aChar)
95 4302 : || '.' == aChar)
96 : {
97 11971 : sNumberString.append(rStr[rPos]);
98 11971 : ++rPos;
99 11971 : aChar = rPos >= nLen ? 0 : rStr[rPos];
100 : }
101 :
102 4086 : 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 4086 : if(bLookForUnits)
124 : {
125 104 : Imp_SkipSpaces(rStr, rPos, nLen);
126 404 : while(rPos < nLen && Imp_IsOnUnitChar(rStr, rPos))
127 196 : sNumberString.append(rStr[rPos++]);
128 : }
129 :
130 4086 : if(!sNumberString.isEmpty())
131 : {
132 4086 : if(bLookForUnits)
133 104 : rConv.convertDouble(fRetval, sNumberString.makeStringAndClear(), true);
134 : else
135 : {
136 : ::sax::Converter::convertDouble(fRetval,
137 3982 : sNumberString.makeStringAndClear());
138 : }
139 : }
140 :
141 4086 : return fRetval;
142 : }
143 :
144 96 : void Imp_PutDoubleChar(OUString& rStr, double fValue)
145 : {
146 96 : OUStringBuffer sStringBuffer;
147 96 : ::sax::Converter::convertDouble(sStringBuffer, fValue);
148 96 : rStr += OUString(sStringBuffer.makeStringAndClear());
149 96 : }
150 :
151 1230 : void Imp_PutDoubleChar(OUString& rStr, const SvXMLUnitConverter& rConv, double fValue,
152 : bool bConvertUnits = false)
153 : {
154 1230 : OUStringBuffer sStringBuffer;
155 :
156 1230 : if(bConvertUnits)
157 310 : rConv.convertDouble(sStringBuffer, fValue, true);
158 : else
159 : {
160 920 : ::sax::Converter::convertDouble(sStringBuffer, fValue);
161 : }
162 :
163 1230 : rStr += OUString(sStringBuffer.makeStringAndClear());
164 1230 : }
165 :
166 : // base class of all 2D transform objects
167 :
168 : struct ImpSdXMLExpTransObj2DBase
169 : {
170 : sal_uInt16 mnType;
171 63 : explicit ImpSdXMLExpTransObj2DBase(sal_uInt16 nType)
172 63 : : 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 30 : explicit ImpSdXMLExpTransObj2DRotate(double fVal)
190 30 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_ROTATE), mfRotate(fVal) {}
191 : };
192 0 : struct ImpSdXMLExpTransObj2DScale : public ImpSdXMLExpTransObj2DBase
193 : {
194 : ::basegfx::B2DTuple maScale;
195 0 : explicit ImpSdXMLExpTransObj2DScale(const ::basegfx::B2DTuple& rNew)
196 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SCALE), maScale(rNew) {}
197 : };
198 30 : struct ImpSdXMLExpTransObj2DTranslate : public ImpSdXMLExpTransObj2DBase
199 : {
200 : ::basegfx::B2DTuple maTranslate;
201 30 : explicit ImpSdXMLExpTransObj2DTranslate(const ::basegfx::B2DTuple& rNew)
202 30 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE), maTranslate(rNew) {}
203 : };
204 : struct ImpSdXMLExpTransObj2DSkewX : public ImpSdXMLExpTransObj2DBase
205 : {
206 : double mfSkewX;
207 0 : explicit ImpSdXMLExpTransObj2DSkewX(double fVal)
208 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWX), mfSkewX(fVal) {}
209 : };
210 : struct ImpSdXMLExpTransObj2DSkewY : public ImpSdXMLExpTransObj2DBase
211 : {
212 : double mfSkewY;
213 0 : explicit ImpSdXMLExpTransObj2DSkewY(double fVal)
214 0 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWY), mfSkewY(fVal) {}
215 : };
216 3 : struct ImpSdXMLExpTransObj2DMatrix : public ImpSdXMLExpTransObj2DBase
217 : {
218 : ::basegfx::B2DHomMatrix maMatrix;
219 3 : explicit ImpSdXMLExpTransObj2DMatrix(const ::basegfx::B2DHomMatrix& rNew)
220 3 : : ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_MATRIX), maMatrix(rNew) {}
221 : };
222 :
223 : // delete all entries in list
224 :
225 4425 : void SdXMLImExTransform2D::EmptyList()
226 : {
227 4425 : const sal_uInt32 nCount = maList.size();
228 4488 : for(sal_uInt32 a(0L); a < nCount; a++)
229 : {
230 63 : ImpSdXMLExpTransObj2DBase* pObj = maList[a];
231 :
232 63 : switch(pObj->mnType)
233 : {
234 : case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
235 : {
236 30 : delete static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj);
237 30 : 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 30 : delete static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj);
247 30 : 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 3 : delete static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj);
262 3 : break;
263 : }
264 : default :
265 : {
266 : OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
267 0 : break;
268 : }
269 : }
270 : }
271 :
272 4425 : maList.clear();
273 4425 : }
274 :
275 : // add members
276 :
277 2 : void SdXMLImExTransform2D::AddRotate(double fNew)
278 : {
279 2 : if(fNew != 0.0)
280 2 : maList.push_back(new ImpSdXMLExpTransObj2DRotate(fNew));
281 2 : }
282 :
283 2 : void SdXMLImExTransform2D::AddTranslate(const ::basegfx::B2DTuple& rNew)
284 : {
285 2 : if(!rNew.equalZero())
286 2 : maList.push_back(new ImpSdXMLExpTransObj2DTranslate(rNew));
287 2 : }
288 :
289 2 : void SdXMLImExTransform2D::AddSkewX(double fNew)
290 : {
291 2 : if(fNew != 0.0)
292 0 : maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fNew));
293 2 : }
294 :
295 : // gen string for export
296 2 : const OUString& SdXMLImExTransform2D::GetExportString(const SvXMLUnitConverter& rConv)
297 : {
298 2 : OUString aNewString;
299 4 : OUString aClosingBrace(")");
300 4 : OUString aEmptySpace(" ");
301 :
302 2 : const sal_uInt32 nCount = maList.size();
303 6 : for(sal_uInt32 a(0L); a < nCount; a++)
304 : {
305 4 : ImpSdXMLExpTransObj2DBase* pObj = maList[a];
306 4 : switch(pObj->mnType)
307 : {
308 : case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
309 : {
310 2 : aNewString += "rotate (";
311 2 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj)->mfRotate);
312 2 : aNewString += aClosingBrace;
313 2 : 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 2 : aNewString += "translate (";
327 2 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate.getX(), true);
328 2 : aNewString += aEmptySpace;
329 2 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate.getY(), true);
330 2 : aNewString += aClosingBrace;
331 2 : 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 4 : if(a + 1UL != maList.size())
386 : {
387 2 : aNewString += aEmptySpace;
388 : }
389 : }
390 :
391 : // fill string form OUString
392 2 : msString = aNewString;
393 :
394 4 : return msString;
395 : }
396 :
397 : // sets new string, parses it and generates entries
398 31 : void SdXMLImExTransform2D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
399 : {
400 31 : msString = rNew;
401 31 : EmptyList();
402 :
403 31 : if(!msString.isEmpty())
404 : {
405 31 : const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
406 31 : const sal_Int32 nLen(aStr.getLength());
407 :
408 62 : const OUString aString_rotate( "rotate" );
409 62 : const OUString aString_scale( "scale" );
410 62 : const OUString aString_translate( "translate" );
411 62 : const OUString aString_skewX( "skewX" );
412 62 : const OUString aString_skewY( "skewY" );
413 62 : const OUString aString_matrix( "matrix" );
414 :
415 31 : sal_Int32 nPos(0);
416 :
417 121 : while(nPos < nLen)
418 : {
419 : // skip spaces
420 59 : Imp_SkipSpaces(aStr, nPos, nLen);
421 :
422 : // look for tag
423 59 : if(nPos < nLen)
424 : {
425 59 : if(nPos == aStr.indexOf(aString_rotate, nPos))
426 : {
427 28 : double fValue(0.0);
428 28 : nPos += 6;
429 28 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
430 28 : fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
431 28 : if(fValue != 0.0)
432 28 : maList.push_back(new ImpSdXMLExpTransObj2DRotate(fValue));
433 :
434 28 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
435 : }
436 31 : 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 31 : else if(nPos == aStr.indexOf(aString_translate, nPos))
451 : {
452 28 : ::basegfx::B2DTuple aValue;
453 28 : nPos += 9;
454 28 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
455 28 : aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
456 28 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
457 28 : aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
458 :
459 28 : if(!aValue.equalZero())
460 28 : maList.push_back(new ImpSdXMLExpTransObj2DTranslate(aValue));
461 :
462 28 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
463 : }
464 3 : 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 3 : 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 3 : else if(nPos == aStr.indexOf(aString_matrix, nPos))
487 : {
488 3 : ::basegfx::B2DHomMatrix aValue;
489 :
490 3 : nPos += 6;
491 3 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
492 :
493 : // a
494 3 : aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
495 3 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
496 :
497 : // b
498 3 : aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
499 3 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
500 :
501 : // c
502 3 : aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
503 3 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
504 :
505 : // d
506 3 : aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
507 3 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
508 :
509 : // e
510 3 : aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2), true));
511 3 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
512 :
513 : // f
514 3 : aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2), true));
515 3 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
516 :
517 3 : if(!aValue.isIdentity())
518 3 : maList.push_back(new ImpSdXMLExpTransObj2DMatrix(aValue));
519 :
520 3 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
521 : }
522 : else
523 : {
524 0 : nPos++;
525 : }
526 : }
527 31 : }
528 : }
529 31 : }
530 :
531 31 : void SdXMLImExTransform2D::GetFullTransform(::basegfx::B2DHomMatrix& rFullTrans)
532 : {
533 31 : rFullTrans.identity();
534 :
535 31 : const sal_uInt32 nCount = maList.size();
536 90 : for(sal_uInt32 a(0L); a < nCount; a++)
537 : {
538 59 : ImpSdXMLExpTransObj2DBase* pObj = maList[a];
539 59 : 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 28 : rFullTrans.rotate(static_cast<ImpSdXMLExpTransObj2DRotate*>(pObj)->mfRotate * -1.0);
550 28 : 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 28 : const ::basegfx::B2DTuple& rTranslate = static_cast<ImpSdXMLExpTransObj2DTranslate*>(pObj)->maTranslate;
561 28 : rFullTrans.translate(rTranslate.getX(), rTranslate.getY());
562 28 : 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 3 : rFullTrans *= static_cast<ImpSdXMLExpTransObj2DMatrix*>(pObj)->maMatrix;
577 3 : break;
578 : }
579 : default :
580 : {
581 : OSL_FAIL("SdXMLImExTransform2D: impossible entry!");
582 0 : break;
583 : }
584 : }
585 : }
586 31 : }
587 :
588 : // base class of all 3D transform objects
589 :
590 : struct ImpSdXMLExpTransObj3DBase
591 : {
592 : sal_uInt16 mnType;
593 116 : explicit ImpSdXMLExpTransObj3DBase(sal_uInt16 nType)
594 116 : : 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 : explicit 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 : explicit 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 : explicit 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 : explicit 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 : explicit ImpSdXMLExpTransObj3DTranslate(const ::basegfx::B3DTuple& rNew)
636 0 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE), maTranslate(rNew) {}
637 : };
638 116 : struct ImpSdXMLExpTransObj3DMatrix : public ImpSdXMLExpTransObj3DBase
639 : {
640 : ::basegfx::B3DHomMatrix maMatrix;
641 116 : explicit ImpSdXMLExpTransObj3DMatrix(const ::basegfx::B3DHomMatrix& rNew)
642 116 : : ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_MATRIX), maMatrix(rNew) {}
643 : };
644 :
645 : // delete all entries in list
646 :
647 130 : void SdXMLImExTransform3D::EmptyList()
648 : {
649 130 : const sal_uInt32 nCount = maList.size();
650 246 : for(sal_uInt32 a(0L); a < nCount; a++)
651 : {
652 116 : ImpSdXMLExpTransObj3DBase* pObj = maList[a];
653 :
654 116 : 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 116 : delete static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj);
684 116 : break;
685 : }
686 : default :
687 : {
688 : OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
689 0 : break;
690 : }
691 : }
692 : }
693 :
694 130 : maList.clear();
695 130 : }
696 :
697 : // add members
698 :
699 102 : void SdXMLImExTransform3D::AddMatrix(const ::basegfx::B3DHomMatrix& rNew)
700 : {
701 102 : if(!rNew.isIdentity())
702 102 : maList.push_back(new ImpSdXMLExpTransObj3DMatrix(rNew));
703 102 : }
704 :
705 102 : void SdXMLImExTransform3D::AddHomogenMatrix(const drawing::HomogenMatrix& xHomMat)
706 : {
707 102 : ::basegfx::B3DHomMatrix aExportMatrix;
708 :
709 102 : aExportMatrix.set(0, 0, xHomMat.Line1.Column1);
710 102 : aExportMatrix.set(0, 1, xHomMat.Line1.Column2);
711 102 : aExportMatrix.set(0, 2, xHomMat.Line1.Column3);
712 102 : aExportMatrix.set(0, 3, xHomMat.Line1.Column4);
713 102 : aExportMatrix.set(1, 0, xHomMat.Line2.Column1);
714 102 : aExportMatrix.set(1, 1, xHomMat.Line2.Column2);
715 102 : aExportMatrix.set(1, 2, xHomMat.Line2.Column3);
716 102 : aExportMatrix.set(1, 3, xHomMat.Line2.Column4);
717 102 : aExportMatrix.set(2, 0, xHomMat.Line3.Column1);
718 102 : aExportMatrix.set(2, 1, xHomMat.Line3.Column2);
719 102 : aExportMatrix.set(2, 2, xHomMat.Line3.Column3);
720 102 : aExportMatrix.set(2, 3, xHomMat.Line3.Column4);
721 :
722 102 : AddMatrix(aExportMatrix);
723 102 : }
724 :
725 : // gen string for export
726 102 : const OUString& SdXMLImExTransform3D::GetExportString(const SvXMLUnitConverter& rConv)
727 : {
728 102 : OUString aNewString;
729 204 : OUString aClosingBrace(")");
730 204 : OUString aEmptySpace(" ");
731 :
732 102 : const sal_uInt32 nCount = maList.size();
733 204 : for(sal_uInt32 a(0L); a < nCount; a++)
734 : {
735 102 : ImpSdXMLExpTransObj3DBase* pObj = maList[a];
736 102 : 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 102 : aNewString += "matrix (";
784 :
785 : // a
786 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 0));
787 102 : aNewString += aEmptySpace;
788 :
789 : // b
790 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 0));
791 102 : aNewString += aEmptySpace;
792 :
793 : // c
794 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 0));
795 102 : aNewString += aEmptySpace;
796 :
797 : // d
798 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 1));
799 102 : aNewString += aEmptySpace;
800 :
801 : // e
802 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 1));
803 102 : aNewString += aEmptySpace;
804 :
805 : // f
806 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 1));
807 102 : aNewString += aEmptySpace;
808 :
809 : // g
810 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 2));
811 102 : aNewString += aEmptySpace;
812 :
813 : // h
814 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 2));
815 102 : aNewString += aEmptySpace;
816 :
817 : // i
818 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 2));
819 102 : aNewString += aEmptySpace;
820 :
821 : // j
822 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(0, 3), true);
823 102 : aNewString += aEmptySpace;
824 :
825 : // k
826 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(1, 3), true);
827 102 : aNewString += aEmptySpace;
828 :
829 : // l
830 102 : Imp_PutDoubleChar(aNewString, rConv, static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix.get(2, 3), true);
831 :
832 102 : aNewString += aClosingBrace;
833 102 : 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 102 : if(a + 1UL != maList.size())
844 : {
845 0 : aNewString += aEmptySpace;
846 : }
847 : }
848 :
849 : // fill string form OUString
850 102 : msString = aNewString;
851 :
852 204 : return msString;
853 : }
854 :
855 : // for Import: constructor with string, parses it and generates entries
856 14 : SdXMLImExTransform3D::SdXMLImExTransform3D(const OUString& rNew, const SvXMLUnitConverter& rConv)
857 : {
858 14 : SetString(rNew, rConv);
859 14 : }
860 :
861 : // sets new string, parses it and generates entries
862 14 : void SdXMLImExTransform3D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
863 : {
864 14 : msString = rNew;
865 14 : EmptyList();
866 :
867 14 : if(!msString.isEmpty())
868 : {
869 14 : const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
870 14 : const sal_Int32 nLen(aStr.getLength());
871 :
872 28 : const OUString aString_rotatex( "rotatex" );
873 28 : const OUString aString_rotatey( "rotatey" );
874 28 : const OUString aString_rotatez( "rotatez" );
875 28 : const OUString aString_scale( "scale" );
876 28 : const OUString aString_translate( "translate" );
877 28 : const OUString aString_matrix( "matrix" );
878 :
879 14 : sal_Int32 nPos(0);
880 :
881 42 : while(nPos < nLen)
882 : {
883 : // skip spaces
884 14 : Imp_SkipSpaces(aStr, nPos, nLen);
885 :
886 : // look for tag
887 14 : if(nPos < nLen)
888 : {
889 14 : 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 14 : 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 14 : 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 14 : 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 14 : 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 14 : else if(nPos == aStr.indexOf(aString_matrix, nPos))
960 : {
961 14 : ::basegfx::B3DHomMatrix aValue;
962 :
963 14 : nPos += 6;
964 14 : Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
965 :
966 : // a
967 14 : aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
968 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
969 :
970 : // b
971 14 : aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
972 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
973 :
974 : // c
975 14 : aValue.set(2, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 0)));
976 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
977 :
978 : // d
979 14 : aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
980 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
981 :
982 : // e
983 14 : aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
984 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
985 :
986 : // f
987 14 : aValue.set(2, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 1)));
988 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
989 :
990 : // g
991 14 : aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2)));
992 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
993 :
994 : // h
995 14 : aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2)));
996 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
997 :
998 : // i
999 14 : aValue.set(2, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 2)));
1000 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1001 :
1002 : // j
1003 14 : aValue.set(0, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 3), true));
1004 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1005 :
1006 : // k
1007 14 : aValue.set(1, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 3), true));
1008 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1009 :
1010 : // l
1011 14 : aValue.set(2, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 3), true));
1012 14 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1013 :
1014 14 : if(!aValue.isIdentity())
1015 14 : maList.push_back(new ImpSdXMLExpTransObj3DMatrix(aValue));
1016 :
1017 14 : Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1018 : }
1019 : else
1020 : {
1021 0 : nPos++;
1022 : }
1023 : }
1024 14 : }
1025 : }
1026 14 : }
1027 :
1028 14 : bool SdXMLImExTransform3D::GetFullHomogenTransform(com::sun::star::drawing::HomogenMatrix& xHomMat)
1029 : {
1030 14 : ::basegfx::B3DHomMatrix aFullTransform;
1031 14 : GetFullTransform(aFullTransform);
1032 :
1033 14 : if(!aFullTransform.isIdentity())
1034 : {
1035 14 : xHomMat.Line1.Column1 = aFullTransform.get(0, 0);
1036 14 : xHomMat.Line1.Column2 = aFullTransform.get(0, 1);
1037 14 : xHomMat.Line1.Column3 = aFullTransform.get(0, 2);
1038 14 : xHomMat.Line1.Column4 = aFullTransform.get(0, 3);
1039 :
1040 14 : xHomMat.Line2.Column1 = aFullTransform.get(1, 0);
1041 14 : xHomMat.Line2.Column2 = aFullTransform.get(1, 1);
1042 14 : xHomMat.Line2.Column3 = aFullTransform.get(1, 2);
1043 14 : xHomMat.Line2.Column4 = aFullTransform.get(1, 3);
1044 :
1045 14 : xHomMat.Line3.Column1 = aFullTransform.get(2, 0);
1046 14 : xHomMat.Line3.Column2 = aFullTransform.get(2, 1);
1047 14 : xHomMat.Line3.Column3 = aFullTransform.get(2, 2);
1048 14 : xHomMat.Line3.Column4 = aFullTransform.get(2, 3);
1049 :
1050 14 : xHomMat.Line4.Column1 = aFullTransform.get(3, 0);
1051 14 : xHomMat.Line4.Column2 = aFullTransform.get(3, 1);
1052 14 : xHomMat.Line4.Column3 = aFullTransform.get(3, 2);
1053 14 : xHomMat.Line4.Column4 = aFullTransform.get(3, 3);
1054 :
1055 14 : return true;
1056 : }
1057 :
1058 0 : return false;
1059 : }
1060 :
1061 14 : void SdXMLImExTransform3D::GetFullTransform(::basegfx::B3DHomMatrix& rFullTrans)
1062 : {
1063 14 : rFullTrans.identity();
1064 :
1065 14 : const sal_uInt32 nCount = maList.size();
1066 28 : for(sal_uInt32 a(0L); a < nCount; a++)
1067 : {
1068 14 : ImpSdXMLExpTransObj3DBase* pObj = maList[a];
1069 14 : 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 14 : rFullTrans *= static_cast<ImpSdXMLExpTransObj3DMatrix*>(pObj)->maMatrix;
1101 14 : break;
1102 : }
1103 : default :
1104 : {
1105 : OSL_FAIL("SdXMLImExTransform3D: impossible entry!");
1106 0 : break;
1107 : }
1108 : }
1109 : }
1110 14 : }
1111 :
1112 24 : SdXMLImExViewBox::SdXMLImExViewBox(double fX, double fY, double fW, double fH)
1113 : : mfX( fX ),
1114 : mfY( fY ),
1115 : mfW( fW ),
1116 24 : mfH( fH )
1117 : {
1118 24 : }
1119 :
1120 : // #100617# Asked vincent hardy: svg:viewBox values may be double precision.
1121 954 : SdXMLImExViewBox::SdXMLImExViewBox(const OUString& rNew, const SvXMLUnitConverter& rConv)
1122 : : msString(rNew),
1123 : mfX( 0.0 ),
1124 : mfY( 0.0 ),
1125 : mfW( 1000.0 ),
1126 954 : mfH( 1000.0 )
1127 : {
1128 954 : if(!msString.isEmpty())
1129 : {
1130 954 : const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
1131 954 : const sal_Int32 nLen(aStr.getLength());
1132 954 : sal_Int32 nPos(0);
1133 :
1134 : // skip starting spaces
1135 954 : Imp_SkipSpaces(aStr, nPos, nLen);
1136 :
1137 : // get mX, #100617# be prepared for doubles
1138 954 : mfX = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfX);
1139 :
1140 : // skip spaces and commas
1141 954 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1142 :
1143 : // get mY, #100617# be prepared for doubles
1144 954 : mfY = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfY);
1145 :
1146 : // skip spaces and commas
1147 954 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1148 :
1149 : // get mW, #100617# be prepared for doubles
1150 954 : mfW = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfW);
1151 :
1152 : // skip spaces and commas
1153 954 : Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1154 :
1155 : // get mH, #100617# be prepared for doubles
1156 954 : mfH = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, mfH);
1157 : }
1158 954 : }
1159 :
1160 24 : const OUString& SdXMLImExViewBox::GetExportString()
1161 : {
1162 24 : OUString aNewString;
1163 48 : OUString aEmptySpace(" ");
1164 :
1165 24 : Imp_PutDoubleChar(aNewString, mfX);
1166 24 : aNewString += aEmptySpace;
1167 :
1168 24 : Imp_PutDoubleChar(aNewString, mfY);
1169 24 : aNewString += aEmptySpace;
1170 :
1171 24 : Imp_PutDoubleChar(aNewString, mfW);
1172 24 : aNewString += aEmptySpace;
1173 :
1174 24 : Imp_PutDoubleChar(aNewString, mfH);
1175 :
1176 : // set new string
1177 24 : msString = aNewString;
1178 :
1179 48 : return msString;
1180 : }
1181 :
1182 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
