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