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