xmloff/source/draw/xexptran.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xexptran.cxx,v $
  10  * $Revision: 1.29 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33 #include "xexptran.hxx"
  34 #include <tools/debug.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <xmloff/xmluconv.hxx>
  37 #include <vcl/salbtype.hxx>
  38 #include <basegfx/vector/b2dvector.hxx>
  39 #include <basegfx/matrix/b2dhommatrix.hxx>
  40 #include <basegfx/tuple/b3dtuple.hxx>
  41 #include <basegfx/matrix/b3dhommatrix.hxx>
  42 #include <tools/string.hxx>
  43
  44 using ::rtl::OUString;
  45 using ::rtl::OUStringBuffer;
  46
  47 using namespace ::com::sun::star;
  48
  49 //////////////////////////////////////////////////////////////////////////////
  50 // Defines
  51
  52 #define BORDER_INTEGERS_ARE_EQUAL               (4)
  53
  54 //////////////////////////////////////////////////////////////////////////////
  55 // Predeclarations
  56
  57 void Imp_SkipDouble(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen);
  58 void Imp_CalcVectorValues(::basegfx::B2DVector& aVec1, ::basegfx::B2DVector& aVec2, bool& bSameLength, bool& bSameDirection);
  59
  60 //////////////////////////////////////////////////////////////////////////////
  61 //////////////////////////////////////////////////////////////////////////////
  62 // parsing help functions for simple chars
  63 void Imp_SkipSpaces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
  64 {
  65     while(rPos < nLen
  66         && sal_Unicode(' ') == rStr[rPos])
  67         rPos++;
  68 }
  69
  70 void Imp_SkipSpacesAndOpeningBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
  71 {
  72     while(rPos < nLen
  73         && (sal_Unicode(' ') == rStr[rPos] || sal_Unicode('(') == rStr[rPos]))
  74         rPos++;
  75 }
  76
  77 void Imp_SkipSpacesAndCommas(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
  78 {
  79     while(rPos < nLen
  80         && (sal_Unicode(' ') == rStr[rPos] || sal_Unicode(',') == rStr[rPos]))
  81         rPos++;
  82 }
  83
  84 void Imp_SkipSpacesAndClosingBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
  85 {
  86     while(rPos < nLen
  87         && (sal_Unicode(' ') == rStr[rPos] || sal_Unicode(')') == rStr[rPos]))
  88         rPos++;
  89 }
  90
  91 //////////////////////////////////////////////////////////////////////////////
  92 //////////////////////////////////////////////////////////////////////////////
  93 // parsing help functions for integer numbers
  94
  95 bool Imp_IsOnNumberChar(const OUString& rStr, const sal_Int32 nPos, bool bSignAllowed = true)
  96 {
  97     sal_Unicode aChar(rStr[nPos]);
  98
  99     if((sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
 100         || (bSignAllowed && sal_Unicode('+') == aChar)
 101         || (bSignAllowed && sal_Unicode('-') == aChar)
 102     )
 103         return true;
 104     return false;
 105 }
 106
 107 bool Imp_IsOnUnitChar(const OUString& rStr, const sal_Int32 nPos)
 108 {
 109     sal_Unicode aChar(rStr[nPos]);
 110
 111     if((sal_Unicode('a') <= aChar && sal_Unicode('z') >= aChar)
 112         || (sal_Unicode('A') <= aChar && sal_Unicode('Z') >= aChar)
 113         || sal_Unicode('%') == aChar
 114     )
 115         return true;
 116     return false;
 117 }
 118
 119 void Imp_SkipNumber(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
 120 {
 121     bool bSignAllowed(true);
 122
 123     while(rPos < nLen && Imp_IsOnNumberChar(rStr, rPos, bSignAllowed))
 124     {
 125         bSignAllowed = false;
 126         rPos++;
 127     }
 128 }
 129
 130 void Imp_SkipNumberAndSpacesAndCommas(const OUString& rStr, sal_Int32& rPos,
 131     const sal_Int32 nLen)
 132 {
 133     Imp_SkipNumber(rStr, rPos, nLen);
 134     Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
 135 }
 136
 137 // #100617# Allow to skip doubles, too.
 138 void Imp_SkipDoubleAndSpacesAndCommas(const OUString& rStr, sal_Int32& rPos,
 139     const sal_Int32 nLen)
 140 {
 141     Imp_SkipDouble(rStr, rPos, nLen);
 142     Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
 143 }
 144
 145 void Imp_PutNumberChar(OUString& rStr, sal_Int32 nValue)
 146 {
 147     OUStringBuffer sStringBuffer;
 148     SvXMLUnitConverter::convertNumber(sStringBuffer, nValue);
 149     rStr += OUString(sStringBuffer.makeStringAndClear());
 150 }
 151
 152 void Imp_PutNumberCharWithSpace(OUString& rStr, sal_Int32 nValue)
 153 {
 154     const sal_Int32 aLen(rStr.getLength());
 155     if(aLen)
 156         if(Imp_IsOnNumberChar(rStr, aLen - 1, false) && nValue >= 0)
 157             rStr += String(sal_Unicode(' '));
 158     Imp_PutNumberChar(rStr, nValue);
 159 }
 160
 161 //////////////////////////////////////////////////////////////////////////////
 162 //////////////////////////////////////////////////////////////////////////////
 163 // parsing help functions for double numbers
 164
 165 void Imp_SkipDouble(const OUString& rStr, sal_Int32& rPos, const sal_Int32)
 166 {
 167     sal_Unicode aChar(rStr[rPos]);
 168
 169     if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
 170         aChar = rStr[++rPos];
 171
 172     while((sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
 173         || sal_Unicode('.') == aChar)
 174     {
 175         aChar = rStr[++rPos];
 176     }
 177
 178     if(sal_Unicode('e') == aChar || sal_Unicode('E') == aChar)
 179     {
 180         aChar = rStr[++rPos];
 181
 182         if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
 183             aChar = rStr[++rPos];
 184
 185         while(sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
 186         {
 187             aChar = rStr[++rPos];
 188         }
 189     }
 190 }
 191
 192 double Imp_GetDoubleChar(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen,
 193     const SvXMLUnitConverter& rConv, double fRetval, bool bLookForUnits = false)
 194 {
 195     sal_Unicode aChar(rStr[rPos]);
 196     OUStringBuffer sNumberString;
 197
 198     if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
 199     {
 200         sNumberString.append(rStr[rPos]);
 201         aChar = rStr[++rPos];
 202     }
 203
 204     while((sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
 205         || sal_Unicode('.') == aChar)
 206     {
 207         sNumberString.append(rStr[rPos]);
 208         aChar = rStr[++rPos];
 209     }
 210
 211     if(sal_Unicode('e') == aChar || sal_Unicode('E') == aChar)
 212     {
 213         sNumberString.append(rStr[rPos]);
 214         aChar = rStr[++rPos];
 215
 216         if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
 217         {
 218             sNumberString.append(rStr[rPos]);
 219             aChar = rStr[++rPos];
 220         }
 221
 222         while(sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
 223         {
 224             sNumberString.append(rStr[rPos]);
 225             aChar = rStr[++rPos];
 226         }
 227     }
 228
 229     if(bLookForUnits)
 230     {
 231         Imp_SkipSpaces(rStr, rPos, nLen);
 232         while(rPos < nLen && Imp_IsOnUnitChar(rStr, rPos))
 233             sNumberString.append(rStr[rPos++]);
 234     }
 235
 236     if(sNumberString.getLength())
 237     {
 238         if(bLookForUnits)
 239             rConv.convertDouble(fRetval, sNumberString.makeStringAndClear(), true);
 240         else
 241             rConv.convertDouble(fRetval, sNumberString.makeStringAndClear());
 242     }
 243
 244     return fRetval;
 245 }
 246
 247 void Imp_PutDoubleChar(OUString& rStr, const SvXMLUnitConverter& rConv, double fValue,
 248     bool bConvertUnits = false)
 249 {
 250     OUStringBuffer sStringBuffer;
 251
 252     if(bConvertUnits)
 253         rConv.convertDouble(sStringBuffer, fValue, true);
 254     else
 255         rConv.convertDouble(sStringBuffer, fValue);
 256
 257     rStr += OUString(sStringBuffer.makeStringAndClear());
 258 }
 259
 260 //////////////////////////////////////////////////////////////////////////////
 261 //////////////////////////////////////////////////////////////////////////////
 262 // base class of all 2D transform objects
 263
 264 struct ImpSdXMLExpTransObj2DBase
 265 {
 266     sal_uInt16                                  mnType;
 267     ImpSdXMLExpTransObj2DBase(sal_uInt16 nType)
 268     :   mnType(nType) {}
 269 };
 270
 271 //////////////////////////////////////////////////////////////////////////////
 272 // possible object types for 2D
 273
 274 #define IMP_SDXMLEXP_TRANSOBJ2D_ROTATE                  0x0000
 275 #define IMP_SDXMLEXP_TRANSOBJ2D_SCALE                   0x0001
 276 #define IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE               0x0002
 277 #define IMP_SDXMLEXP_TRANSOBJ2D_SKEWX                   0x0003
 278 #define IMP_SDXMLEXP_TRANSOBJ2D_SKEWY                   0x0004
 279 #define IMP_SDXMLEXP_TRANSOBJ2D_MATRIX                  0x0005
 280
 281 //////////////////////////////////////////////////////////////////////////////
 282 // classes of objects, different sizes
 283
 284 struct ImpSdXMLExpTransObj2DRotate : public ImpSdXMLExpTransObj2DBase
 285 {
 286     double                                              mfRotate;
 287     ImpSdXMLExpTransObj2DRotate(double fVal)
 288     :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_ROTATE), mfRotate(fVal) {}
 289 };
 290 struct ImpSdXMLExpTransObj2DScale : public ImpSdXMLExpTransObj2DBase
 291 {
 292     ::basegfx::B2DTuple                 maScale;
 293     ImpSdXMLExpTransObj2DScale(const ::basegfx::B2DTuple& rNew)
 294     :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SCALE), maScale(rNew) {}
 295 };
 296 struct ImpSdXMLExpTransObj2DTranslate : public ImpSdXMLExpTransObj2DBase
 297 {
 298     ::basegfx::B2DTuple                 maTranslate;
 299     ImpSdXMLExpTransObj2DTranslate(const ::basegfx::B2DTuple& rNew)
 300     :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE), maTranslate(rNew) {}
 301 };
 302 struct ImpSdXMLExpTransObj2DSkewX : public ImpSdXMLExpTransObj2DBase
 303 {
 304     double                                              mfSkewX;
 305     ImpSdXMLExpTransObj2DSkewX(double fVal)
 306     :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWX), mfSkewX(fVal) {}
 307 };
 308 struct ImpSdXMLExpTransObj2DSkewY : public ImpSdXMLExpTransObj2DBase
 309 {
 310     double                                              mfSkewY;
 311     ImpSdXMLExpTransObj2DSkewY(double fVal)
 312     :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWY), mfSkewY(fVal) {}
 313 };
 314 struct ImpSdXMLExpTransObj2DMatrix : public ImpSdXMLExpTransObj2DBase
 315 {
 316     ::basegfx::B2DHomMatrix             maMatrix;
 317     ImpSdXMLExpTransObj2DMatrix(const ::basegfx::B2DHomMatrix& rNew)
 318     :   ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_MATRIX), maMatrix(rNew) {}
 319 };
 320
 321 //////////////////////////////////////////////////////////////////////////////
 322 //////////////////////////////////////////////////////////////////////////////
 323 // delete all entries in list
 324
 325 void SdXMLImExTransform2D::EmptyList()
 326 {
 327     const sal_uInt32 nCount = maList.size();
 328     for(sal_uInt32 a(0L); a < nCount; a++)
 329     {
 330         ImpSdXMLExpTransObj2DBase* pObj = maList[a];
 331
 332         switch(pObj->mnType)
 333         {
 334             case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE         :
 335             {
 336                 delete (ImpSdXMLExpTransObj2DRotate*)pObj;
 337                 break;
 338             }
 339             case IMP_SDXMLEXP_TRANSOBJ2D_SCALE          :
 340             {
 341                 delete (ImpSdXMLExpTransObj2DScale*)pObj;
 342                 break;
 343             }
 344             case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE      :
 345             {
 346                 delete (ImpSdXMLExpTransObj2DTranslate*)pObj;
 347                 break;
 348             }
 349             case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX          :
 350             {
 351                 delete (ImpSdXMLExpTransObj2DSkewX*)pObj;
 352                 break;
 353             }
 354             case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY          :
 355             {
 356                 delete (ImpSdXMLExpTransObj2DSkewY*)pObj;
 357                 break;
 358             }
 359             case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX         :
 360             {
 361                 delete (ImpSdXMLExpTransObj2DMatrix*)pObj;
 362                 break;
 363             }
 364             default :
 365             {
 366                 DBG_ERROR("SdXMLImExTransform2D: impossible entry!");
 367                 break;
 368             }
 369         }
 370     }
 371
 372     maList.clear();
 373 }
 374
 375 //////////////////////////////////////////////////////////////////////////////
 376 // add members
 377
 378 void SdXMLImExTransform2D::AddRotate(double fNew)
 379 {
 380     if(fNew != 0.0)
 381         maList.push_back(new ImpSdXMLExpTransObj2DRotate(fNew));
 382 }
 383
 384 void SdXMLImExTransform2D::AddScale(const ::basegfx::B2DTuple& rNew)
 385 {
 386     if(1.0 != rNew.getX() || 1.0 != rNew.getY())
 387         maList.push_back(new ImpSdXMLExpTransObj2DScale(rNew));
 388 }
 389
 390 void SdXMLImExTransform2D::AddTranslate(const ::basegfx::B2DTuple& rNew)
 391 {
 392     if(!rNew.equalZero())
 393         maList.push_back(new ImpSdXMLExpTransObj2DTranslate(rNew));
 394 }
 395
 396 void SdXMLImExTransform2D::AddSkewX(double fNew)
 397 {
 398     if(fNew != 0.0)
 399         maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fNew));
 400 }
 401
 402 void SdXMLImExTransform2D::AddSkewY(double fNew)
 403 {
 404     if(fNew != 0.0)
 405         maList.push_back(new ImpSdXMLExpTransObj2DSkewY(fNew));
 406 }
 407
 408 void SdXMLImExTransform2D::AddMatrix(const ::basegfx::B2DHomMatrix& rNew)
 409 {
 410     if(!rNew.isIdentity())
 411         maList.push_back(new ImpSdXMLExpTransObj2DMatrix(rNew));
 412 }
 413
 414 //////////////////////////////////////////////////////////////////////////////
 415 // gen string for export
 416 const OUString& SdXMLImExTransform2D::GetExportString(const SvXMLUnitConverter& rConv)
 417 {
 418     OUString aNewString;
 419     OUString aClosingBrace(sal_Unicode(')'));
 420     OUString aEmptySpace(sal_Unicode(' '));
 421
 422     const sal_uInt32 nCount = maList.size();
 423     for(sal_uInt32 a(0L); a < nCount; a++)
 424     {
 425         ImpSdXMLExpTransObj2DBase* pObj = maList[a];
 426         switch(pObj->mnType)
 427         {
 428             case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE :
 429             {
 430                 aNewString += OUString::createFromAscii("rotate (");
 431                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DRotate*)pObj)->mfRotate);
 432                 aNewString += aClosingBrace;
 433                 break;
 434             }
 435             case IMP_SDXMLEXP_TRANSOBJ2D_SCALE          :
 436             {
 437                 aNewString += OUString::createFromAscii("scale (");
 438                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DScale*)pObj)->maScale.getX());
 439                 aNewString += aEmptySpace;
 440                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DScale*)pObj)->maScale.getY());
 441                 aNewString += aClosingBrace;
 442                 break;
 443             }
 444             case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE      :
 445             {
 446                 aNewString += OUString::createFromAscii("translate (");
 447                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DTranslate*)pObj)->maTranslate.getX(), true);
 448                 aNewString += aEmptySpace;
 449                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DTranslate*)pObj)->maTranslate.getY(), true);
 450                 aNewString += aClosingBrace;
 451                 break;
 452             }
 453             case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX          :
 454             {
 455                 aNewString += OUString::createFromAscii("skewX (");
 456                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DSkewX*)pObj)->mfSkewX);
 457                 aNewString += aClosingBrace;
 458                 break;
 459             }
 460             case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY          :
 461             {
 462                 aNewString += OUString::createFromAscii("skewY (");
 463                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DSkewY*)pObj)->mfSkewY);
 464                 aNewString += aClosingBrace;
 465                 break;
 466             }
 467             case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX :
 468             {
 469                 aNewString += OUString::createFromAscii("matrix (");
 470
 471                 // a
 472                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(0, 0));
 473                 aNewString += aEmptySpace;
 474
 475                 // b
 476                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(1, 0));
 477                 aNewString += aEmptySpace;
 478
 479                 // c
 480                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(0, 1));
 481                 aNewString += aEmptySpace;
 482
 483                 // d
 484                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(1, 1));
 485                 aNewString += aEmptySpace;
 486
 487                 // e
 488                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(0, 2), true);
 489                 aNewString += aEmptySpace;
 490
 491                 // f
 492                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(1, 2), true);
 493
 494                 aNewString += aClosingBrace;
 495                 break;
 496             }
 497             default :
 498             {
 499                 DBG_ERROR("SdXMLImExTransform2D: impossible entry!");
 500                 break;
 501             }
 502         }
 503
 504         // if not the last entry, add one space to next tag
 505         if(a + 1UL != maList.size())
 506         {
 507             aNewString += aEmptySpace;
 508         }
 509     }
 510
 511     // fill string form OUString
 512     msString = aNewString;
 513
 514     return msString;
 515 }
 516
 517 //////////////////////////////////////////////////////////////////////////////
 518 // for Import: constructor with string, parses it and generates entries
 519 SdXMLImExTransform2D::SdXMLImExTransform2D(const OUString& rNew, const SvXMLUnitConverter& rConv)
 520 {
 521     SetString(rNew, rConv);
 522 }
 523
 524 //////////////////////////////////////////////////////////////////////////////
 525 // sets new string, parses it and generates entries
 526 void SdXMLImExTransform2D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
 527 {
 528     msString = rNew;
 529     EmptyList();
 530
 531     if(msString.getLength())
 532     {
 533         const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
 534         const sal_Int32 nLen(aStr.getLength());
 535
 536         const OUString aString_rotate(OUString::createFromAscii("rotate"));
 537         const OUString aString_scale(OUString::createFromAscii("scale"));
 538         const OUString aString_translate(OUString::createFromAscii("translate"));
 539         const OUString aString_skewX(OUString::createFromAscii("skewX"));
 540         const OUString aString_skewY(OUString::createFromAscii("skewY"));
 541         const OUString aString_matrix(OUString::createFromAscii("matrix"));
 542
 543         sal_Int32 nPos(0);
 544
 545         while(nPos < nLen)
 546         {
 547             // skip spaces
 548             Imp_SkipSpaces(aStr, nPos, nLen);
 549
 550             // look for tag
 551             if(nPos < nLen)
 552             {
 553                 if(nPos == aStr.indexOf(aString_rotate, nPos))
 554                 {
 555                     double fValue(0.0);
 556                     nPos += 6;
 557                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
 558                     fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
 559                     if(fValue != 0.0)
 560                         maList.push_back(new ImpSdXMLExpTransObj2DRotate(fValue));
 561
 562                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
 563                 }
 564                 else if(nPos == aStr.indexOf(aString_scale, nPos))
 565                 {
 566                     ::basegfx::B2DTuple aValue(1.0, 1.0);
 567                     nPos += 5;
 568                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
 569                     aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
 570                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 571                     aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
 572
 573                     if(aValue.getX() != 1.0 || aValue.getY() != 1.0)
 574                         maList.push_back(new ImpSdXMLExpTransObj2DScale(aValue));
 575
 576                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
 577                 }
 578                 else if(nPos == aStr.indexOf(aString_translate, nPos))
 579                 {
 580                     ::basegfx::B2DTuple aValue;
 581                     nPos += 9;
 582                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
 583                     aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
 584                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 585                     aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
 586
 587                     if(!aValue.equalZero())
 588                         maList.push_back(new ImpSdXMLExpTransObj2DTranslate(aValue));
 589
 590                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
 591                 }
 592                 else if(nPos == aStr.indexOf(aString_skewX, nPos))
 593                 {
 594                     double fValue(0.0);
 595                     nPos += 5;
 596                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
 597                     fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
 598                     if(fValue != 0.0)
 599                         maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fValue));
 600
 601                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
 602                 }
 603                 else if(nPos == aStr.indexOf(aString_skewY, nPos))
 604                 {
 605                     double fValue(0.0);
 606                     nPos += 5;
 607                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
 608                     fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
 609                     if(fValue != 0.0)
 610                         maList.push_back(new ImpSdXMLExpTransObj2DSkewY(fValue));
 611
 612                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
 613                 }
 614                 else if(nPos == aStr.indexOf(aString_matrix, nPos))
 615                 {
 616                     ::basegfx::B2DHomMatrix aValue;
 617
 618                     nPos += 6;
 619                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
 620
 621                     // a
 622                     aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
 623                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 624
 625                     // b
 626                     aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
 627                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 628
 629                     // c
 630                     aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
 631                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 632
 633                     // d
 634                     aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
 635                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 636
 637                     // e
 638                     aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2), true));
 639                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 640
 641                     // f
 642                     aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2), true));
 643                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
 644
 645                     if(!aValue.isIdentity())
 646                         maList.push_back(new ImpSdXMLExpTransObj2DMatrix(aValue));
 647
 648                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
 649                 }
 650                 else
 651                 {
 652                     nPos++;
 653                 }
 654             }
 655         }
 656     }
 657 }
 658
 659 void SdXMLImExTransform2D::GetFullTransform(::basegfx::B2DHomMatrix& rFullTrans)
 660 {
 661     rFullTrans.identity();
 662
 663     const sal_uInt32 nCount = maList.size();
 664     for(sal_uInt32 a(0L); a < nCount; a++)
 665     {
 666         ImpSdXMLExpTransObj2DBase* pObj = maList[a];
 667         switch(pObj->mnType)
 668         {
 669             case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE         :
 670             {
 671                 // #i78696#
 672                 // mfRotate is mathematically wrong oriented since we export/import the angle
 673                 // values mirrored. This error is fixed in the API, but not yet in the FileFormat.
 674                 // For the FileFormat there is a follow-up task (#i78698#) to fix this in the next
 675                 // ODF FileFormat version. For now - to emulate the old behaviour - it is necessary
 676                 // to mirror the value here
 677                 rFullTrans.rotate(((ImpSdXMLExpTransObj2DRotate*)pObj)->mfRotate * -1.0);
 678                 break;
 679             }
 680             case IMP_SDXMLEXP_TRANSOBJ2D_SCALE          :
 681             {
 682                 const ::basegfx::B2DTuple& rScale = ((ImpSdXMLExpTransObj2DScale*)pObj)->maScale;
 683                 rFullTrans.scale(rScale.getX(), rScale.getY());
 684                 break;
 685             }
 686             case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE      :
 687             {
 688                 const ::basegfx::B2DTuple& rTranslate = ((ImpSdXMLExpTransObj2DTranslate*)pObj)->maTranslate;
 689                 rFullTrans.translate(rTranslate.getX(), rTranslate.getY());
 690                 break;
 691             }
 692             case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX          :
 693             {
 694                 rFullTrans.shearX(tan(((ImpSdXMLExpTransObj2DSkewX*)pObj)->mfSkewX));
 695                 break;
 696             }
 697             case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY          :
 698             {
 699                 rFullTrans.shearY(tan(((ImpSdXMLExpTransObj2DSkewY*)pObj)->mfSkewY));
 700                 break;
 701             }
 702             case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX         :
 703             {
 704                 rFullTrans *= ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix;
 705                 break;
 706             }
 707             default :
 708             {
 709                 DBG_ERROR("SdXMLImExTransform2D: impossible entry!");
 710                 break;
 711             }
 712         }
 713     }
 714 }
 715
 716 //////////////////////////////////////////////////////////////////////////////
 717 //////////////////////////////////////////////////////////////////////////////
 718 // base class of all 3D transform objects
 719
 720 struct ImpSdXMLExpTransObj3DBase
 721 {
 722     sal_uInt16                                  mnType;
 723     ImpSdXMLExpTransObj3DBase(sal_uInt16 nType)
 724     :   mnType(nType) {}
 725 };
 726
 727 //////////////////////////////////////////////////////////////////////////////
 728 // possible object types for 3D
 729
 730 #define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X                0x0000
 731 #define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y                0x0001
 732 #define IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z                0x0002
 733 #define IMP_SDXMLEXP_TRANSOBJ3D_SCALE                   0x0003
 734 #define IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE               0x0004
 735 #define IMP_SDXMLEXP_TRANSOBJ3D_MATRIX                  0x0005
 736
 737 //////////////////////////////////////////////////////////////////////////////
 738 // classes of objects, different sizes
 739
 740 struct ImpSdXMLExpTransObj3DRotateX : public ImpSdXMLExpTransObj3DBase
 741 {
 742     double                                              mfRotateX;
 743     ImpSdXMLExpTransObj3DRotateX(double fVal)
 744     :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X), mfRotateX(fVal) {}
 745 };
 746 struct ImpSdXMLExpTransObj3DRotateY : public ImpSdXMLExpTransObj3DBase
 747 {
 748     double                                              mfRotateY;
 749     ImpSdXMLExpTransObj3DRotateY(double fVal)
 750     :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y), mfRotateY(fVal) {}
 751 };
 752 struct ImpSdXMLExpTransObj3DRotateZ : public ImpSdXMLExpTransObj3DBase
 753 {
 754     double                                              mfRotateZ;
 755     ImpSdXMLExpTransObj3DRotateZ(double fVal)
 756     :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z), mfRotateZ(fVal) {}
 757 };
 758 struct ImpSdXMLExpTransObj3DScale : public ImpSdXMLExpTransObj3DBase
 759 {
 760     ::basegfx::B3DTuple                 maScale;
 761     ImpSdXMLExpTransObj3DScale(const ::basegfx::B3DTuple& rNew)
 762     :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_SCALE), maScale(rNew) {}
 763 };
 764 struct ImpSdXMLExpTransObj3DTranslate : public ImpSdXMLExpTransObj3DBase
 765 {
 766     ::basegfx::B3DTuple                 maTranslate;
 767     ImpSdXMLExpTransObj3DTranslate(const ::basegfx::B3DTuple& rNew)
 768     :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE), maTranslate(rNew) {}
 769 };
 770 struct ImpSdXMLExpTransObj3DMatrix : public ImpSdXMLExpTransObj3DBase
 771 {
 772     ::basegfx::B3DHomMatrix             maMatrix;
 773     ImpSdXMLExpTransObj3DMatrix(const ::basegfx::B3DHomMatrix& rNew)
 774     :   ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_MATRIX), maMatrix(rNew) {}
 775 };
 776
 777 //////////////////////////////////////////////////////////////////////////////
 778 //////////////////////////////////////////////////////////////////////////////
 779 // delete all entries in list
 780
 781 void SdXMLImExTransform3D::EmptyList()
 782 {
 783     const sal_uInt32 nCount = maList.size();
 784     for(sal_uInt32 a(0L); a < nCount; a++)
 785     {
 786         ImpSdXMLExpTransObj3DBase* pObj = maList[a];
 787
 788         switch(pObj->mnType)
 789         {
 790             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X       :
 791             {
 792                 delete (ImpSdXMLExpTransObj3DRotateX*)pObj;
 793                 break;
 794             }
 795             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y       :
 796             {
 797                 delete (ImpSdXMLExpTransObj3DRotateY*)pObj;
 798                 break;
 799             }
 800             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z       :
 801             {
 802                 delete (ImpSdXMLExpTransObj3DRotateZ*)pObj;
 803                 break;
 804             }
 805             case IMP_SDXMLEXP_TRANSOBJ3D_SCALE          :
 806             {
 807                 delete (ImpSdXMLExpTransObj3DScale*)pObj;
 808                 break;
 809             }
 810             case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE      :
 811             {
 812                 delete (ImpSdXMLExpTransObj3DTranslate*)pObj;
 813                 break;
 814             }
 815             case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX         :
 816             {
 817                 delete (ImpSdXMLExpTransObj3DMatrix*)pObj;
 818                 break;
 819             }
 820             default :
 821             {
 822                 DBG_ERROR("SdXMLImExTransform3D: impossible entry!");
 823                 break;
 824             }
 825         }
 826     }
 827
 828     maList.clear();
 829 }
 830
 831 //////////////////////////////////////////////////////////////////////////////
 832 // add members
 833
 834 void SdXMLImExTransform3D::AddRotateX(double fNew)
 835 {
 836     if(fNew != 0.0)
 837         maList.push_back(new ImpSdXMLExpTransObj3DRotateX(fNew));
 838 }
 839
 840 void SdXMLImExTransform3D::AddRotateY(double fNew)
 841 {
 842     if(fNew != 0.0)
 843         maList.push_back(new ImpSdXMLExpTransObj3DRotateY(fNew));
 844 }
 845
 846 void SdXMLImExTransform3D::AddRotateZ(double fNew)
 847 {
 848     if(fNew != 0.0)
 849         maList.push_back(new ImpSdXMLExpTransObj3DRotateZ(fNew));
 850 }
 851
 852 void SdXMLImExTransform3D::AddScale(const ::basegfx::B3DTuple& rNew)
 853 {
 854     if(1.0 != rNew.getX() || 1.0 != rNew.getY() || 1.0 != rNew.getZ())
 855         maList.push_back(new ImpSdXMLExpTransObj3DScale(rNew));
 856 }
 857
 858 void SdXMLImExTransform3D::AddTranslate(const ::basegfx::B3DTuple& rNew)
 859 {
 860     if(!rNew.equalZero())
 861         maList.push_back(new ImpSdXMLExpTransObj3DTranslate(rNew));
 862 }
 863
 864 void SdXMLImExTransform3D::AddMatrix(const ::basegfx::B3DHomMatrix& rNew)
 865 {
 866     if(!rNew.isIdentity())
 867         maList.push_back(new ImpSdXMLExpTransObj3DMatrix(rNew));
 868 }
 869
 870 void SdXMLImExTransform3D::AddHomogenMatrix(const drawing::HomogenMatrix& xHomMat)
 871 {
 872     ::basegfx::B3DHomMatrix aExportMatrix;
 873
 874     aExportMatrix.set(0, 0, xHomMat.Line1.Column1);
 875     aExportMatrix.set(0, 1, xHomMat.Line1.Column2);
 876     aExportMatrix.set(0, 2, xHomMat.Line1.Column3);
 877     aExportMatrix.set(0, 3, xHomMat.Line1.Column4);
 878     aExportMatrix.set(1, 0, xHomMat.Line2.Column1);
 879     aExportMatrix.set(1, 1, xHomMat.Line2.Column2);
 880     aExportMatrix.set(1, 2, xHomMat.Line2.Column3);
 881     aExportMatrix.set(1, 3, xHomMat.Line2.Column4);
 882     aExportMatrix.set(2, 0, xHomMat.Line3.Column1);
 883     aExportMatrix.set(2, 1, xHomMat.Line3.Column2);
 884     aExportMatrix.set(2, 2, xHomMat.Line3.Column3);
 885     aExportMatrix.set(2, 3, xHomMat.Line3.Column4);
 886
 887     AddMatrix(aExportMatrix);
 888 }
 889
 890 //////////////////////////////////////////////////////////////////////////////
 891 // gen string for export
 892 const OUString& SdXMLImExTransform3D::GetExportString(const SvXMLUnitConverter& rConv)
 893 {
 894     OUString aNewString;
 895     OUString aClosingBrace(sal_Unicode(')'));
 896     OUString aEmptySpace(sal_Unicode(' '));
 897
 898     const sal_uInt32 nCount = maList.size();
 899     for(sal_uInt32 a(0L); a < nCount; a++)
 900     {
 901         ImpSdXMLExpTransObj3DBase* pObj = maList[a];
 902         switch(pObj->mnType)
 903         {
 904             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X       :
 905             {
 906                 aNewString += OUString::createFromAscii("rotatex (");
 907                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DRotateX*)pObj)->mfRotateX);
 908                 aNewString += aClosingBrace;
 909                 break;
 910             }
 911             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y       :
 912             {
 913                 aNewString += OUString::createFromAscii("rotatey (");
 914                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DRotateY*)pObj)->mfRotateY);
 915                 aNewString += aClosingBrace;
 916                 break;
 917             }
 918             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z       :
 919             {
 920                 aNewString += OUString::createFromAscii("rotatez (");
 921                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DRotateZ*)pObj)->mfRotateZ);
 922                 aNewString += aClosingBrace;
 923                 break;
 924             }
 925             case IMP_SDXMLEXP_TRANSOBJ3D_SCALE          :
 926             {
 927                 aNewString += OUString::createFromAscii("scale (");
 928                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale.getX());
 929                 aNewString += aEmptySpace;
 930                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale.getY());
 931                 aNewString += aEmptySpace;
 932                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale.getZ());
 933                 aNewString += aClosingBrace;
 934                 break;
 935             }
 936             case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE      :
 937             {
 938                 aNewString += OUString::createFromAscii("translate (");
 939                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate.getX(), true);
 940                 aNewString += aEmptySpace;
 941                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate.getY(), true);
 942                 aNewString += aEmptySpace;
 943                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate.getZ(), true);
 944                 aNewString += aClosingBrace;
 945                 break;
 946             }
 947             case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX :
 948             {
 949                 aNewString += OUString::createFromAscii("matrix (");
 950
 951                 // a
 952                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 0));
 953                 aNewString += aEmptySpace;
 954
 955                 // b
 956                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 0));
 957                 aNewString += aEmptySpace;
 958
 959                 // c
 960                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 0));
 961                 aNewString += aEmptySpace;
 962
 963                 // d
 964                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 1));
 965                 aNewString += aEmptySpace;
 966
 967                 // e
 968                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 1));
 969                 aNewString += aEmptySpace;
 970
 971                 // f
 972                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 1));
 973                 aNewString += aEmptySpace;
 974
 975                 // g
 976                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 2));
 977                 aNewString += aEmptySpace;
 978
 979                 // h
 980                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 2));
 981                 aNewString += aEmptySpace;
 982
 983                 // i
 984                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 2));
 985                 aNewString += aEmptySpace;
 986
 987                 // j
 988                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 3), true);
 989                 aNewString += aEmptySpace;
 990
 991                 // k
 992                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 3), true);
 993                 aNewString += aEmptySpace;
 994
 995                 // l
 996                 Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 3), true);
 997
 998                 aNewString += aClosingBrace;
 999                 break;
1000             }
1001             default :
1002             {
1003                 DBG_ERROR("SdXMLImExTransform3D: impossible entry!");
1004                 break;
1005             }
1006         }
1007
1008         // if not the last entry, add one space to next tag
1009         if(a + 1UL != maList.size())
1010         {
1011             aNewString += aEmptySpace;
1012         }
1013     }
1014
1015     // fill string form OUString
1016     msString = aNewString;
1017
1018     return msString;
1019 }
1020
1021 //////////////////////////////////////////////////////////////////////////////
1022 // for Import: constructor with string, parses it and generates entries
1023 SdXMLImExTransform3D::SdXMLImExTransform3D(const OUString& rNew, const SvXMLUnitConverter& rConv)
1024 {
1025     SetString(rNew, rConv);
1026 }
1027
1028 //////////////////////////////////////////////////////////////////////////////
1029 // sets new string, parses it and generates entries
1030 void SdXMLImExTransform3D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
1031 {
1032     msString = rNew;
1033     EmptyList();
1034
1035     if(msString.getLength())
1036     {
1037         const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
1038         const sal_Int32 nLen(aStr.getLength());
1039
1040         const OUString aString_rotatex(OUString::createFromAscii("rotatex"));
1041         const OUString aString_rotatey(OUString::createFromAscii("rotatey"));
1042         const OUString aString_rotatez(OUString::createFromAscii("rotatez"));
1043         const OUString aString_scale(OUString::createFromAscii("scale"));
1044         const OUString aString_translate(OUString::createFromAscii("translate"));
1045         const OUString aString_matrix(OUString::createFromAscii("matrix"));
1046
1047         sal_Int32 nPos(0);
1048
1049         while(nPos < nLen)
1050         {
1051             // skip spaces
1052             Imp_SkipSpaces(aStr, nPos, nLen);
1053
1054             // look for tag
1055             if(nPos < nLen)
1056             {
1057                 if(nPos == aStr.indexOf(aString_rotatex, nPos))
1058                 {
1059                     double fValue(0.0);
1060
1061                     nPos += 7;
1062                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
1063                     fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
1064                     if(fValue != 0.0)
1065                         maList.push_back(new ImpSdXMLExpTransObj3DRotateX(fValue));
1066
1067                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1068                 }
1069                 else if(nPos == aStr.indexOf(aString_rotatey, nPos))
1070                 {
1071                     double fValue(0.0);
1072
1073                     nPos += 7;
1074                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
1075                     fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
1076                     if(fValue != 0.0)
1077                         maList.push_back(new ImpSdXMLExpTransObj3DRotateY(fValue));
1078
1079                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1080                 }
1081                 else if(nPos == aStr.indexOf(aString_rotatez, nPos))
1082                 {
1083                     double fValue(0.0);
1084
1085                     nPos += 7;
1086                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
1087                     fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
1088                     if(fValue != 0.0)
1089                         maList.push_back(new ImpSdXMLExpTransObj3DRotateZ(fValue));
1090
1091                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1092                 }
1093                 else if(nPos == aStr.indexOf(aString_scale, nPos))
1094                 {
1095                     ::basegfx::B3DTuple aValue(1.0, 1.0, 1.0);
1096
1097                     nPos += 5;
1098                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
1099                     aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
1100                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1101                     aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
1102                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1103                     aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ()));
1104
1105                     if(1.0 != aValue.getX() || 1.0 != aValue.getY() || 1.0 != aValue.getZ())
1106                         maList.push_back(new ImpSdXMLExpTransObj3DScale(aValue));
1107
1108                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1109                 }
1110                 else if(nPos == aStr.indexOf(aString_translate, nPos))
1111                 {
1112                     ::basegfx::B3DTuple aValue;
1113
1114                     nPos += 9;
1115                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
1116                     aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
1117                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1118                     aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
1119                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1120                     aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ(), true));
1121
1122                     if(!aValue.equalZero())
1123                         maList.push_back(new ImpSdXMLExpTransObj3DTranslate(aValue));
1124
1125                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1126                 }
1127                 else if(nPos == aStr.indexOf(aString_matrix, nPos))
1128                 {
1129                     ::basegfx::B3DHomMatrix aValue;
1130
1131                     nPos += 6;
1132                     Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
1133
1134                     // a
1135                     aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
1136                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1137
1138                     // b
1139                     aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
1140                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1141
1142                     // c
1143                     aValue.set(2, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 0)));
1144                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1145
1146                     // d
1147                     aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
1148                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1149
1150                     // e
1151                     aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
1152                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1153
1154                     // f
1155                     aValue.set(2, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 1)));
1156                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1157
1158                     // g
1159                     aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2)));
1160                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1161
1162                     // h
1163                     aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2)));
1164                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1165
1166                     // i
1167                     aValue.set(2, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 2)));
1168                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1169
1170                     // j
1171                     aValue.set(0, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 3), true));
1172                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1173
1174                     // k
1175                     aValue.set(1, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 3), true));
1176                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1177
1178                     // l
1179                     aValue.set(2, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 3), true));
1180                     Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1181
1182                     if(!aValue.isIdentity())
1183                         maList.push_back(new ImpSdXMLExpTransObj3DMatrix(aValue));
1184
1185                     Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
1186                 }
1187                 else
1188                 {
1189                     nPos++;
1190                 }
1191             }
1192         }
1193     }
1194 }
1195
1196 bool SdXMLImExTransform3D::GetFullHomogenTransform(com::sun::star::drawing::HomogenMatrix& xHomMat)
1197 {
1198     ::basegfx::B3DHomMatrix aFullTransform;
1199     GetFullTransform(aFullTransform);
1200
1201     if(!aFullTransform.isIdentity())
1202     {
1203         xHomMat.Line1.Column1 = aFullTransform.get(0, 0);
1204         xHomMat.Line1.Column2 = aFullTransform.get(0, 1);
1205         xHomMat.Line1.Column3 = aFullTransform.get(0, 2);
1206         xHomMat.Line1.Column4 = aFullTransform.get(0, 3);
1207
1208         xHomMat.Line2.Column1 = aFullTransform.get(1, 0);
1209         xHomMat.Line2.Column2 = aFullTransform.get(1, 1);
1210         xHomMat.Line2.Column3 = aFullTransform.get(1, 2);
1211         xHomMat.Line2.Column4 = aFullTransform.get(1, 3);
1212
1213         xHomMat.Line3.Column1 = aFullTransform.get(2, 0);
1214         xHomMat.Line3.Column2 = aFullTransform.get(2, 1);
1215         xHomMat.Line3.Column3 = aFullTransform.get(2, 2);
1216         xHomMat.Line3.Column4 = aFullTransform.get(2, 3);
1217
1218         xHomMat.Line4.Column1 = aFullTransform.get(3, 0);
1219         xHomMat.Line4.Column2 = aFullTransform.get(3, 1);
1220         xHomMat.Line4.Column3 = aFullTransform.get(3, 2);
1221         xHomMat.Line4.Column4 = aFullTransform.get(3, 3);
1222
1223         return true;
1224     }
1225
1226     return false;
1227 }
1228
1229 void SdXMLImExTransform3D::GetFullTransform(::basegfx::B3DHomMatrix& rFullTrans)
1230 {
1231     rFullTrans.identity();
1232
1233     const sal_uInt32 nCount = maList.size();
1234     for(sal_uInt32 a(0L); a < nCount; a++)
1235     {
1236         ImpSdXMLExpTransObj3DBase* pObj = maList[a];
1237         switch(pObj->mnType)
1238         {
1239             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X       :
1240             {
1241                 rFullTrans.rotate(((ImpSdXMLExpTransObj3DRotateX*)pObj)->mfRotateX, 0.0, 0.0);
1242                 break;
1243             }
1244             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y       :
1245             {
1246                 rFullTrans.rotate(0.0, ((ImpSdXMLExpTransObj3DRotateY*)pObj)->mfRotateY, 0.0);
1247                 break;
1248             }
1249             case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z       :
1250             {
1251                 rFullTrans.rotate(0.0, 0.0, ((ImpSdXMLExpTransObj3DRotateZ*)pObj)->mfRotateZ);
1252                 break;
1253             }
1254             case IMP_SDXMLEXP_TRANSOBJ3D_SCALE          :
1255             {
1256                 const ::basegfx::B3DTuple& rScale = ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale;
1257                 rFullTrans.scale(rScale.getX(), rScale.getY(), rScale.getZ());
1258                 break;
1259             }
1260             case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE      :
1261             {
1262                 const ::basegfx::B3DTuple& rTranslate = ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate;
1263                 rFullTrans.translate(rTranslate.getX(), rTranslate.getY(), rTranslate.getZ());
1264                 break;
1265             }
1266             case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX         :
1267             {
1268                 rFullTrans *= ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix;
1269                 break;
1270             }
1271             default :
1272             {
1273                 DBG_ERROR("SdXMLImExTransform3D: impossible entry!");
1274                 break;
1275             }
1276         }
1277     }
1278 }
1279
1280 //////////////////////////////////////////////////////////////////////////////
1281 //////////////////////////////////////////////////////////////////////////////
1282
1283 SdXMLImExViewBox::SdXMLImExViewBox(sal_Int32 nX, sal_Int32 nY, sal_Int32 nW, sal_Int32 nH)
1284 :       mnX( nX ),
1285     mnY( nY ),
1286     mnW( nW ),
1287     mnH( nH )
1288 {
1289 }
1290
1291 // #100617# Asked vincent hardy: svg:viewBox values may be double precision.
1292 SdXMLImExViewBox::SdXMLImExViewBox(const OUString& rNew, const SvXMLUnitConverter& rConv)
1293 :       msString(rNew),
1294     mnX( 0L ),
1295     mnY( 0L ),
1296     mnW( 1000L ),
1297     mnH( 1000L )
1298 {
1299     if(msString.getLength())
1300     {
1301         const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
1302         const sal_Int32 nLen(aStr.getLength());
1303         sal_Int32 nPos(0);
1304
1305         // skip starting spaces
1306         Imp_SkipSpaces(aStr, nPos, nLen);
1307
1308         // get mX, #100617# be prepared for doubles
1309         mnX = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnX));
1310
1311         // skip spaces and commas
1312         Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1313
1314         // get mY, #100617# be prepared for doubles
1315         mnY = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnY));
1316
1317         // skip spaces and commas
1318         Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1319
1320         // get mW, #100617# be prepared for doubles
1321         mnW = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnW));
1322
1323         // skip spaces and commas
1324         Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1325
1326         // get mH, #100617# be prepared for doubles
1327         mnH = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnH));
1328     }
1329 }
1330
1331 const OUString& SdXMLImExViewBox::GetExportString()
1332 {
1333     OUString aNewString;
1334     OUString aEmptySpace(sal_Unicode(' '));
1335
1336     Imp_PutNumberChar(aNewString, mnX);
1337     aNewString += aEmptySpace;
1338
1339     Imp_PutNumberChar(aNewString, mnY);
1340     aNewString += aEmptySpace;
1341
1342     Imp_PutNumberChar(aNewString, mnW);
1343     aNewString += aEmptySpace;
1344
1345     Imp_PutNumberChar(aNewString, mnH);
1346
1347     // set new string
1348     msString = aNewString;
1349
1350     return msString;
1351 }
1352
1353 //////////////////////////////////////////////////////////////////////////////
1354 //////////////////////////////////////////////////////////////////////////////
1355
1356 SdXMLImExPointsElement::SdXMLImExPointsElement(drawing::PointSequence* pPoints,
1357     const SdXMLImExViewBox& rViewBox,
1358     const awt::Point& rObjectPos,
1359     const awt::Size& rObjectSize,
1360     // #96328#
1361     const bool bClosed)
1362 :       maPoly( 0L )
1363 {
1364     DBG_ASSERT(pPoints, "Empty PointSequence handed over to SdXMLImExPointsElement(!)");
1365
1366     // add polygon to string
1367     sal_Int32 nCnt(pPoints->getLength());
1368
1369     // #104076# Convert to string only when at last one point included
1370     if(nCnt > 0)
1371     {
1372         OUString aNewString;
1373         awt::Point* pArray = pPoints->getArray();
1374
1375         // last point same? Ignore it.
1376         // #96328# ...but only when polygon is CLOSED
1377         if(bClosed && (pArray->X == (pArray + (nCnt - 1))->X) && (pArray->Y == (pArray + (nCnt - 1))->Y))
1378             nCnt--;
1379
1380         // object size and ViewBox size different?
1381         bool bScale(rObjectSize.Width != rViewBox.GetWidth()
1382             || rObjectSize.Height != rViewBox.GetHeight());
1383         bool bTranslate(rViewBox.GetX() != 0L || rViewBox.GetY() != 0L);
1384
1385         for(sal_Int32 a(0L); a < nCnt; a++)
1386         {
1387             // prepare coordinates
1388             sal_Int32 nX( pArray->X - rObjectPos.X );
1389             sal_Int32 nY( pArray->Y - rObjectPos.Y );
1390
1391             if(bScale && rObjectSize.Width && rObjectSize.Height)
1392             {
1393                 nX = (nX * rViewBox.GetWidth()) / rObjectSize.Width;
1394                 nY = (nY * rViewBox.GetHeight()) / rObjectSize.Height;
1395             }
1396
1397             if(bTranslate)
1398             {
1399                 nX += rViewBox.GetX();
1400                 nY += rViewBox.GetY();
1401             }
1402
1403             // X and comma
1404             Imp_PutNumberChar(aNewString, nX);
1405             aNewString += String(sal_Unicode(','));
1406
1407             // Y and space (not for last)
1408             Imp_PutNumberChar(aNewString, nY);
1409             if(a + 1 != nCnt)
1410                 aNewString += String(sal_Unicode(' '));
1411
1412             // next point
1413             pArray++;
1414         }
1415
1416         // set new string
1417         msString = aNewString;
1418     }
1419 }
1420
1421 // #100617# svg:polyline or svg:polygon values may be double precision.
1422 SdXMLImExPointsElement::SdXMLImExPointsElement(const OUString& rNew,
1423     const SdXMLImExViewBox& rViewBox,
1424     const awt::Point& rObjectPos,
1425     const awt::Size& rObjectSize,
1426     const SvXMLUnitConverter& rConv)
1427 :       msString( rNew ),
1428     maPoly( 0L )
1429 {
1430     // convert string to polygon
1431     const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
1432     const sal_Int32 nLen(aStr.getLength());
1433     sal_Int32 nPos(0);
1434     sal_Int32 nNumPoints(0L);
1435
1436     // skip starting spaces
1437     Imp_SkipSpaces(aStr, nPos, nLen);
1438
1439     // count points in first loop
1440     while(nPos < nLen)
1441     {
1442         // skip number, #100617# be prepared for doubles
1443         Imp_SkipDouble(aStr, nPos, nLen);
1444
1445         // skip spaces and commas
1446         Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1447
1448         // skip number, #100617# be prepared for doubles
1449         Imp_SkipDouble(aStr, nPos, nLen);
1450
1451         // skip spaces and commas
1452         Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1453
1454         // one more point
1455         nNumPoints++;
1456     }
1457
1458     // second loop
1459     if(nNumPoints)
1460     {
1461         nPos = 0L;
1462         maPoly.realloc(1L);
1463         drawing::PointSequence* pOuterSequence = maPoly.getArray();
1464         pOuterSequence->realloc(nNumPoints);
1465         awt::Point* pInnerSequence = pOuterSequence->getArray();
1466
1467         // object size and ViewBox size different?
1468         bool bScale(rObjectSize.Width != rViewBox.GetWidth()
1469             || rObjectSize.Height != rViewBox.GetHeight());
1470         bool bTranslate(rViewBox.GetX() != 0L || rViewBox.GetY() != 0L);
1471
1472         // skip starting spaces
1473         Imp_SkipSpaces(aStr, nPos, nLen);
1474
1475         while(nPos < nLen)
1476         {
1477             // prepare new parameter pair
1478             sal_Int32 nX(0L);
1479             sal_Int32 nY(0L);
1480
1481             // get mX, #100617# be prepared for doubles
1482             nX = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)nX));
1483
1484             // skip spaces and commas
1485             Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1486
1487             // get mY, #100617# be prepared for doubles
1488             nY = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)nY));
1489
1490             // skip spaces and commas
1491             Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
1492
1493             // prepare parameters
1494             if(bTranslate)
1495             {
1496                 nX -= rViewBox.GetX();
1497                 nY -= rViewBox.GetY();
1498             }
1499
1500             if(bScale && rViewBox.GetWidth() && rViewBox.GetHeight() )
1501             {
1502                 nX = (nX * rObjectSize.Width) / rViewBox.GetWidth();
1503                 nY = (nY * rObjectSize.Height) / rViewBox.GetHeight();
1504             }
1505
1506             nX += rObjectPos.X;
1507             nY += rObjectPos.Y;
1508
1509             // add new point
1510             *pInnerSequence = awt::Point( nX, nY );
1511             pInnerSequence++;
1512         }
1513     }
1514 }
1515
1516 //////////////////////////////////////////////////////////////////////////////
1517 //////////////////////////////////////////////////////////////////////////////
1518
1519 SdXMLImExSvgDElement::SdXMLImExSvgDElement(const SdXMLImExViewBox& rViewBox)
1520 :       mrViewBox( rViewBox ),
1521     mbIsClosed( false ),
1522     mbIsCurve( false ),
1523     mnLastX( 0L ),
1524     mnLastY( 0L ),
1525     maPoly( 0L ),
1526     maFlag( 0L )
1527 {
1528 }
1529
1530 void Imp_GetPrevPos(awt::Point*& pPrevPos1,
1531     drawing::PolygonFlags& aPrevFlag1,
1532     const bool bClosed, awt::Point* pPoints,
1533     drawing::PolygonFlags* pFlags, const sal_Int32 nPos,
1534     const sal_Int32 nCnt, const sal_Int32 nAdd)
1535 {
1536     if(bClosed)
1537     {
1538         pPrevPos1 = pPoints + ((nPos + nCnt - nAdd) % nCnt);
1539         aPrevFlag1 = *(pFlags + ((nPos + nCnt - nAdd) % nCnt));
1540     }
1541     else if(nPos > (nAdd - 1))
1542     {
1543         pPrevPos1 = pPoints + (nPos - nAdd);
1544         aPrevFlag1 = *(pFlags + (nPos - nAdd));
1545     }
1546     else
1547         pPrevPos1 = 0L;
1548 }
1549
1550 void Imp_PrepareCoorExport(sal_Int32& nX, sal_Int32& nY,
1551     const awt::Point* pPointArray, const awt::Point& rObjectPos,
1552     const awt::Size& rObjectSize, const SdXMLImExViewBox& mrViewBox,
1553     const bool bScale, const bool bTranslate)
1554 {
1555     nX = pPointArray->X - rObjectPos.X;
1556     nY = pPointArray->Y - rObjectPos.Y;
1557
1558     if(bScale && rObjectSize.Width && rObjectSize.Height )
1559     {
1560         nX = (nX * mrViewBox.GetWidth()) / rObjectSize.Width;
1561         nY = (nY * mrViewBox.GetHeight()) / rObjectSize.Height;
1562     }
1563
1564     if(bTranslate)
1565     {
1566         nX += mrViewBox.GetX();
1567         nY += mrViewBox.GetY();
1568     }
1569 }
1570
1571 //#define TEST_QUADRATIC_CURVES
1572 #ifdef TEST_QUADRATIC_CURVES
1573 // To be able to test quadratic curve code: The code concerning to
1574 // bDoTestHere can be used (see below). Construct shapes which have their control
1575 // points on equal coordinates. When these are written, they can be
1576 // forced to create correct 'Q' and 'T' statements using this flag.
1577 // These may then be tested for import/exporting.
1578 static bool bDoTestHere(true);
1579 #endif // TEST_QUADRATIC_CURVES
1580
1581 void SdXMLImExSvgDElement::AddPolygon(
1582     drawing::PointSequence* pPoints,
1583     drawing::FlagSequence* pFlags,
1584     const awt::Point& rObjectPos,
1585     const awt::Size& rObjectSize,
1586     bool bClosed, bool bRelative)
1587 {
1588     DBG_ASSERT(pPoints, "Empty PointSequence handed over to SdXMLImExSvgDElement(!)");
1589
1590     sal_Int32 nCnt(pPoints->getLength());
1591
1592     // #104076# Convert to string only when at last one point included
1593     if(nCnt > 0)
1594     {
1595         // append polygon to string
1596         OUString aNewString;
1597         sal_Unicode aLastCommand = ' ';
1598         awt::Point* pPointArray = pPoints->getArray();
1599
1600         // are the flags used at all? If not forget about them
1601         if(pFlags)
1602         {
1603             sal_Int32 nFlagCnt(pFlags->getLength());
1604
1605             if(nFlagCnt)
1606             {
1607                 bool bFlagsUsed(false);
1608                 drawing::PolygonFlags* pFlagArray = pFlags->getArray();
1609
1610                 for(sal_Int32 a(0); !bFlagsUsed && a < nFlagCnt; a++)
1611                     if(drawing::PolygonFlags_NORMAL != *pFlagArray++)
1612                         bFlagsUsed = true;
1613
1614                 if(!bFlagsUsed)
1615                     pFlags = 0L;
1616             }
1617             else
1618             {
1619                 pFlags = 0L;
1620             }
1621         }
1622
1623         // object size and ViewBox size different?
1624         bool bScale(rObjectSize.Width != mrViewBox.GetWidth()
1625             || rObjectSize.Height != mrViewBox.GetHeight());
1626         bool bTranslate(mrViewBox.GetX() != 0L || mrViewBox.GetY() != 0L);
1627
1628         // #87202# rework of point reduction:
1629         // Test for Last point same -> closed, ignore last point. Take
1630         // some more circumstances in account when looking at curve segments.
1631         drawing::PolygonFlags* pFlagArray = (pFlags) ? pFlags->getArray() : 0L;
1632         if((pPointArray->X == (pPointArray + (nCnt - 1))->X) && (pPointArray->Y == (pPointArray + (nCnt - 1))->Y))
1633         {
1634             if(pFlags)
1635             {
1636                 // point needs to be ignored if point before it is
1637                 // NO control point. Else the last point is needed
1638                 // for exporting the last segment of the curve. That means
1639                 // that the last and the first point will be saved double,
1640                 // but SVG does not support a better solution here.
1641                 if(nCnt >= 2 && drawing::PolygonFlags_CONTROL != *(pFlagArray + (nCnt - 2)))
1642                 {
1643                     nCnt--;
1644                 }
1645             }
1646             else
1647             {
1648                 // no curve, ignore last point
1649                 nCnt--;
1650             }
1651         }
1652
1653         // bezier poly, handle curves
1654         bool  bDidWriteStart(false);
1655
1656         for(sal_Int32 a(0L); a < nCnt; a++)
1657         {
1658             if(!pFlags || drawing::PolygonFlags_CONTROL != *pFlagArray)
1659             {
1660                 bool bDidWriteAsCurve(false);
1661
1662                 if(bDidWriteStart)
1663                 {
1664                     if(pFlags)
1665                     {
1666                         // real curve point, get previous to see if it's a control point
1667                         awt::Point* pPrevPos1;
1668                         drawing::PolygonFlags aPrevFlag1;
1669
1670                         Imp_GetPrevPos(pPrevPos1, aPrevFlag1, bClosed, pPoints->getArray(),
1671                             pFlags->getArray(), a, nCnt, 1);
1672
1673                         if(pPrevPos1 && drawing::PolygonFlags_CONTROL == aPrevFlag1)
1674                         {
1675                             // get previous2 to see if it's a control point, too
1676                             awt::Point* pPrevPos2;
1677                             drawing::PolygonFlags aPrevFlag2;
1678
1679                             Imp_GetPrevPos(pPrevPos2, aPrevFlag2, bClosed, pPoints->getArray(),
1680                                 pFlags->getArray(), a, nCnt, 2);
1681
1682                             if(pPrevPos2 && drawing::PolygonFlags_CONTROL == aPrevFlag2)
1683                             {
1684                                 // get previous3 to see if it's a curve point and if,
1685                                 // if it is fully symmetric or not
1686                                 awt::Point* pPrevPos3;
1687                                 drawing::PolygonFlags aPrevFlag3;
1688
1689                                 Imp_GetPrevPos(pPrevPos3, aPrevFlag3, bClosed, pPoints->getArray(),
1690                                     pFlags->getArray(), a, nCnt, 3);
1691
1692                                 if(pPrevPos3)
1693                                 {
1694                                     // prepare coordinates
1695                                     sal_Int32 nX, nY;
1696
1697                                     Imp_PrepareCoorExport(nX, nY, pPointArray, rObjectPos, rObjectSize,
1698                                         mrViewBox, bScale, bTranslate);
1699
1700                                     // #100617# test if this curve segment may be written as
1701                                     // a quadratic bezier
1702                                     // That's the case if both control points are in the same place
1703                                     // when they are prolonged to the common quadratic control point
1704                                     // Left:  P = (3P1 - P0) / 2
1705                                     // Right: P = (3P2 - P3) / 2
1706                                     bool bIsQuadratic(false);
1707                                     const bool bEnableSaveQuadratic(false);
1708
1709                                     sal_Int32 nPX_L(FRound((double)((3 * pPrevPos2->X) - pPrevPos3->X) / 2.0));
1710                                     sal_Int32 nPY_L(FRound((double)((3 * pPrevPos2->Y) - pPrevPos3->Y) / 2.0));
1711                                     sal_Int32 nPX_R(FRound((double)((3 * pPrevPos1->X) - pPointArray->X) / 2.0));
1712                                     sal_Int32 nPY_R(FRound((double)((3 * pPrevPos1->Y) - pPointArray->Y) / 2.0));
1713                                     sal_Int32 nDist(0);
1714
1715                                     if(nPX_L != nPX_R)
1716                                     {
1717                                         nDist += abs(nPX_L - nPX_R);
1718                                     }
1719
1720                                     if(nPY_L != nPY_R)
1721                                     {
1722                                         nDist += abs(nPY_L - nPY_R);
1723                                     }
1724
1725                                     if(nDist <= BORDER_INTEGERS_ARE_EQUAL)
1726                                     {
1727                                         if(bEnableSaveQuadratic)
1728                                         {
1729                                             bIsQuadratic = true;
1730                                         }
1731                                     }
1732
1733 #ifdef TEST_QUADRATIC_CURVES
1734                                     if(bDoTestHere)
1735                                     {
1736                                         bIsQuadratic = false;
1737
1738                                         if(pPrevPos1->X == pPrevPos2->X && pPrevPos1->Y == pPrevPos2->Y)
1739                                             bIsQuadratic = true;
1740                                     }
1741 #endif // TEST_QUADRATIC_CURVES
1742
1743                                     if(bIsQuadratic)
1744                                     {
1745 #ifdef TEST_QUADRATIC_CURVES
1746                                         if(bDoTestHere)
1747                                         {
1748                                             bool bPrevPointIsSymmetric(false);
1749
1750                                             if(drawing::PolygonFlags_SYMMETRIC == aPrevFlag3)
1751                                             {
1752                                                 // get previous4 to see if it's a control point
1753                                                 awt::Point* pPrevPos4;
1754                                                 drawing::PolygonFlags aPrevFlag4;
1755
1756                                                 Imp_GetPrevPos(pPrevPos4, aPrevFlag4, bClosed, pPoints->getArray(),
1757                                                     pFlags->getArray(), a, nCnt, 4);
1758
1759                                                 if(drawing::PolygonFlags_CONTROL == aPrevFlag4)
1760                                                 {
1761                                                     // okay, prevPos3 is symmetric (c2) and prevPos4
1762                                                     // is existing control point, the 's' statement can be used
1763                                                     bPrevPointIsSymmetric = true;
1764                                                 }
1765                                             }
1766
1767                                             if(bPrevPointIsSymmetric)
1768                                             {
1769                                                 // write a shorthand/smooth quadratic curveto entry (T)
1770                                                 if(bRelative)
1771                                                 {
1772                                                     if(aLastCommand != sal_Unicode('t'))
1773                                                         aNewString += OUString(sal_Unicode('t'));
1774
1775                                                     Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
1776                                                     Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
1777
1778                                                     aLastCommand = sal_Unicode('t');
1779                                                 }
1780                                                 else
1781                                                 {
1782                                                     if(aLastCommand != sal_Unicode('T'))
1783                                                         aNewString += OUString(sal_Unicode('T'));
1784
1785                                                     Imp_PutNumberCharWithSpace(aNewString, nX);
1786                                                     Imp_PutNumberCharWithSpace(aNewString, nY);
1787
1788                                                     aLastCommand = sal_Unicode('T');
1789                                                 }
1790                                             }
1791                                             else
1792                                             {
1793                                                 // prepare coordinates
1794                                                 sal_Int32 nX1, nY1;
1795
1796                                                 Imp_PrepareCoorExport(nX1, nY1, pPrevPos1, rObjectPos, rObjectSize,
1797                                                     mrViewBox, bScale, bTranslate);
1798
1799                                                 // write a quadratic curveto entry (Q)
1800                                                 if(bRelative)
1801                                                 {
1802                                                     if(aLastCommand != sal_Unicode('q'))
1803                                                         aNewString += OUString(sal_Unicode('q'));
1804
1805                                                     Imp_PutNumberCharWithSpace(aNewString, nX1 - mnLastX);
1806                                                     Imp_PutNumberCharWithSpace(aNewString, nY1 - mnLastY);
1807                                                     Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
1808                                                     Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
1809
1810                                                     aLastCommand = sal_Unicode('q');
1811                                                 }
1812                                                 else
1813                                                 {
1814                                                     if(aLastCommand != sal_Unicode('Q'))
1815                                                         aNewString += OUString(sal_Unicode('Q'));
1816
1817                                                     Imp_PutNumberCharWithSpace(aNewString, nX1);
1818                                                     Imp_PutNumberCharWithSpace(aNewString, nY1);
1819                                                     Imp_PutNumberCharWithSpace(aNewString, nX);
1820                                                     Imp_PutNumberCharWithSpace(aNewString, nY);
1821
1822                                                     aLastCommand = sal_Unicode('Q');
1823                                                 }
1824                                             }
1825                                         }
1826                                         else
1827                                         {
1828 #endif // TEST_QUADRATIC_CURVES
1829                                             awt::Point aNewPoint(nPX_L, nPY_L);
1830                                             bool bPrevPointIsSmooth(false);
1831
1832                                             if(drawing::PolygonFlags_SMOOTH == aPrevFlag3)
1833                                             {
1834                                                 // get previous4 to see if it's a control point
1835                                                 awt::Point* pPrevPos4;
1836                                                 drawing::PolygonFlags aPrevFlag4;
1837
1838                                                 Imp_GetPrevPos(pPrevPos4, aPrevFlag4, bClosed, pPoints->getArray(),
1839                                                     pFlags->getArray(), a, nCnt, 4);
1840
1841                                                 if(drawing::PolygonFlags_CONTROL == aPrevFlag4)
1842                                                 {
1843                                                     // okay, prevPos3 is smooth (c1) and prevPos4
1844                                                     // is existing control point. Test if it's even symmetric
1845                                                     // and thus the 'T' statement may be used.
1846                                                     ::basegfx::B2DVector aVec1(pPrevPos4->X - pPrevPos3->X, pPrevPos4->Y - pPrevPos3->Y);
1847                                                     ::basegfx::B2DVector aVec2(aNewPoint.X - pPrevPos3->X, aNewPoint.Y - pPrevPos3->Y);
1848                                                     bool bSameLength(false);
1849                                                     bool bSameDirection(false);
1850
1851                                                     // get vector values
1852                                                     Imp_CalcVectorValues(aVec1, aVec2, bSameLength, bSameDirection);
1853
1854                                                     if(bSameLength && bSameDirection)
1855                                                         bPrevPointIsSmooth = true;
1856                                                 }
1857                                             }
1858
1859                                             if(bPrevPointIsSmooth)
1860                                             {
1861                                                 // write a shorthand/smooth quadratic curveto entry (T)
1862                                                 if(bRelative)
1863                                                 {
1864                                                     if(aLastCommand != sal_Unicode('t'))
1865                                                         aNewString += String(sal_Unicode('t'));
1866
1867                                                     Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
1868                                                     Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
1869
1870                                                     aLastCommand = sal_Unicode('t');
1871                                                 }
1872                                                 else
1873                                                 {
1874                                                     if(aLastCommand != sal_Unicode('T'))
1875                                                         aNewString += String(sal_Unicode('T'));
1876
1877                                                     Imp_PutNumberCharWithSpace(aNewString, nX);
1878                                                     Imp_PutNumberCharWithSpace(aNewString, nY);
1879
1880                                                     aLastCommand = sal_Unicode('T');
1881                                                 }
1882                                             }
1883                                             else
1884                                             {
1885                                                 // prepare coordinates
1886                                                 sal_Int32 nX1, nY1;
1887
1888                                                 Imp_PrepareCoorExport(nX1, nY1, &aNewPoint, rObjectPos, rObjectSize,
1889                                                     mrViewBox, bScale, bTranslate);
1890
1891                                                 // write a quadratic curveto entry (Q)
1892                                                 if(bRelative)
1893                                                 {
1894                                                     if(aLastCommand != sal_Unicode('q'))
1895                                                         aNewString += String(sal_Unicode('q'));
1896
1897                                                     Imp_PutNumberCharWithSpace(aNewString, nX1 - mnLastX);
1898                                                     Imp_PutNumberCharWithSpace(aNewString, nY1 - mnLastY);
1899                                                     Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
1900                                                     Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
1901
1902                                                     aLastCommand = sal_Unicode('q');
1903                                                 }
1904                                                 else
1905                                                 {
1906                                                     if(aLastCommand != sal_Unicode('Q'))
1907                                                         aNewString += String(sal_Unicode('Q'));
1908
1909                                                     Imp_PutNumberCharWithSpace(aNewString, nX1);
1910                                                     Imp_PutNumberCharWithSpace(aNewString, nY1);
1911                                                     Imp_PutNumberCharWithSpace(aNewString, nX);
1912                                                     Imp_PutNumberCharWithSpace(aNewString, nY);
1913
1914                                                     aLastCommand = sal_Unicode('Q');
1915                                                 }
1916                                             }
1917 #ifdef TEST_QUADRATIC_CURVES
1918                                         }
1919 #endif // TEST_QUADRATIC_CURVES
1920                                     }
1921                                     else
1922                                     {
1923                                         bool bPrevPointIsSymmetric(false);
1924
1925                                         if(drawing::PolygonFlags_SYMMETRIC == aPrevFlag3)
1926                                         {
1927                                             // get previous4 to see if it's a control point
1928                                             awt::Point* pPrevPos4;
1929                                             drawing::PolygonFlags aPrevFlag4;
1930
1931                                             Imp_GetPrevPos(pPrevPos4, aPrevFlag4, bClosed, pPoints->getArray(),
1932                                                 pFlags->getArray(), a, nCnt, 4);
1933
1934                                             if(drawing::PolygonFlags_CONTROL == aPrevFlag4)
1935                                             {
1936                                                 // okay, prevPos3 is symmetric (c2) and prevPos4
1937                                                 // is existing control point, the 's' statement can be used
1938                                                 bPrevPointIsSymmetric = true;
1939                                             }
1940                                         }
1941
1942                                         // prepare coordinates
1943                                         sal_Int32 nX2, nY2;
1944
1945                                         Imp_PrepareCoorExport(nX2, nY2, pPrevPos1, rObjectPos, rObjectSize,
1946                                             mrViewBox, bScale, bTranslate);
1947
1948                                         if(bPrevPointIsSymmetric)
1949                                         {
1950                                             // write a shorthand/smooth curveto entry (S)
1951                                             if(bRelative)
1952                                             {
1953                                                 if(aLastCommand != sal_Unicode('s'))
1954                                                     aNewString += String(sal_Unicode('s'));
1955
1956                                                 Imp_PutNumberCharWithSpace(aNewString, nX2 - mnLastX);
1957                                                 Imp_PutNumberCharWithSpace(aNewString, nY2 - mnLastY);
1958                                                 Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
1959                                                 Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
1960
1961                                                 aLastCommand = sal_Unicode('s');
1962                                             }
1963                                             else
1964                                             {
1965                                                 if(aLastCommand != sal_Unicode('S'))
1966                                                     aNewString += String(sal_Unicode('S'));
1967
1968                                                 Imp_PutNumberCharWithSpace(aNewString, nX2);
1969                                                 Imp_PutNumberCharWithSpace(aNewString, nY2);
1970                                                 Imp_PutNumberCharWithSpace(aNewString, nX);
1971                                                 Imp_PutNumberCharWithSpace(aNewString, nY);
1972
1973                                                 aLastCommand = sal_Unicode('S');
1974                                             }
1975                                         }
1976                                         else
1977                                         {
1978                                             // prepare coordinates
1979                                             sal_Int32 nX1, nY1;
1980
1981                                             Imp_PrepareCoorExport(nX1, nY1, pPrevPos2, rObjectPos, rObjectSize,
1982                                                 mrViewBox, bScale, bTranslate);
1983
1984                                             // write a curveto entry (C)
1985                                             if(bRelative)
1986                                             {
1987                                                 if(aLastCommand != sal_Unicode('c'))
1988                                                     aNewString += String(sal_Unicode('c'));
1989
1990                                                 Imp_PutNumberCharWithSpace(aNewString, nX1 - mnLastX);
1991                                                 Imp_PutNumberCharWithSpace(aNewString, nY1 - mnLastY);
1992                                                 Imp_PutNumberCharWithSpace(aNewString, nX2 - mnLastX);
1993                                                 Imp_PutNumberCharWithSpace(aNewString, nY2 - mnLastY);
1994                                                 Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
1995                                                 Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
1996
1997                                                 aLastCommand = sal_Unicode('c');
1998                                             }
1999                                             else
2000                                             {
2001                                                 if(aLastCommand != sal_Unicode('C'))
2002                                                     aNewString += String(sal_Unicode('C'));
2003
2004                                                 Imp_PutNumberCharWithSpace(aNewString, nX1);
2005                                                 Imp_PutNumberCharWithSpace(aNewString, nY1);
2006                                                 Imp_PutNumberCharWithSpace(aNewString, nX2);
2007                                                 Imp_PutNumberCharWithSpace(aNewString, nY2);
2008                                                 Imp_PutNumberCharWithSpace(aNewString, nX);
2009                                                 Imp_PutNumberCharWithSpace(aNewString, nY);
2010
2011                                                 aLastCommand = sal_Unicode('C');
2012                                             }
2013                                         }
2014                                     }
2015
2016                                     // remember that current point IS written
2017                                     bDidWriteAsCurve = true;
2018
2019                                     // remember new last position
2020                                     mnLastX = nX;
2021                                     mnLastY = nY;
2022                                 }
2023                             }
2024                         }
2025                     }
2026                 }
2027
2028                 if(!bDidWriteAsCurve)
2029                 {
2030                     // current point not yet written, prepare coordinates
2031                     sal_Int32 nX, nY;
2032
2033                     Imp_PrepareCoorExport(nX, nY, pPointArray, rObjectPos, rObjectSize,
2034                         mrViewBox, bScale, bTranslate);
2035
2036                     if(bDidWriteStart)
2037                     {
2038                         // write as normal point
2039                         if(mnLastX == nX)
2040                         {
2041                             if(bRelative)
2042                             {
2043                                 if(aLastCommand != sal_Unicode('v'))
2044                                     aNewString += String(sal_Unicode('v'));
2045
2046                                 Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
2047
2048                                 aLastCommand = sal_Unicode('v');
2049                             }
2050                             else
2051                             {
2052                                 if(aLastCommand != sal_Unicode('V'))
2053                                     aNewString += String(sal_Unicode('V'));
2054
2055                                 Imp_PutNumberCharWithSpace(aNewString, nY);
2056
2057                                 aLastCommand = sal_Unicode('V');
2058                             }
2059                         }
2060                         else if(mnLastY == nY)
2061                         {
2062                             if(bRelative)
2063                             {
2064                                 if(aLastCommand != sal_Unicode('h'))
2065                                     aNewString += String(sal_Unicode('h'));
2066
2067                                 Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
2068
2069                                 aLastCommand = sal_Unicode('h');
2070                             }
2071                             else
2072                             {
2073                                 if(aLastCommand != sal_Unicode('H'))
2074                                     aNewString += String(sal_Unicode('H'));
2075
2076                                 Imp_PutNumberCharWithSpace(aNewString, nX);
2077
2078                                 aLastCommand = sal_Unicode('H');
2079                             }
2080                         }
2081                         else
2082                         {
2083                             if(bRelative)
2084                             {
2085                                 if(aLastCommand != sal_Unicode('l'))
2086                                     aNewString += String(sal_Unicode('l'));
2087
2088                                 Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
2089                                 Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
2090
2091                                 aLastCommand = sal_Unicode('l');
2092                             }
2093                             else
2094                             {
2095                                 if(aLastCommand != sal_Unicode('L'))
2096                                     aNewString += String(sal_Unicode('L'));
2097
2098                                 Imp_PutNumberCharWithSpace(aNewString, nX);
2099                                 Imp_PutNumberCharWithSpace(aNewString, nY);
2100
2101                                 aLastCommand = sal_Unicode('L');
2102                             }
2103                         }
2104                     }
2105                     else
2106                     {
2107                         // write as start point
2108                         if(bRelative)
2109                         {
2110                             aNewString += String(sal_Unicode('m'));
2111
2112                             Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
2113                             Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);
2114
2115                             aLastCommand = sal_Unicode('l');
2116                         }
2117                         else
2118                         {
2119                             aNewString += String(sal_Unicode('M'));
2120
2121                             Imp_PutNumberCharWithSpace(aNewString, nX);
2122                             Imp_PutNumberCharWithSpace(aNewString, nY);
2123
2124                             aLastCommand = sal_Unicode('L');
2125                         }
2126
2127                         // remember start written
2128                         bDidWriteStart = true;
2129                     }
2130
2131                     // remember new last position
2132                     mnLastX = nX;
2133                     mnLastY = nY;
2134                 }
2135             }
2136
2137             // next point
2138             pPointArray++;
2139             pFlagArray++;
2140         }
2141
2142         // close path if closed poly
2143         if(bClosed)
2144         {
2145             if(bRelative)
2146                 aNewString += String(sal_Unicode('z'));
2147             else
2148                 aNewString += String(sal_Unicode('Z'));
2149         }
2150
2151         // append new string
2152         msString += aNewString;
2153     }
2154 }
2155
2156 // #100617# Linear double reader
2157 double Imp_ImportDoubleAndSpaces(
2158     double fRetval, const OUString& rStr, sal_Int32& rPos,
2159     const sal_Int32 nLen, const SvXMLUnitConverter& rConv)
2160 {
2161     fRetval = Imp_GetDoubleChar(rStr, rPos, nLen, rConv, fRetval);
2162     Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
2163     return fRetval;
2164 }
2165
2166 // #100617# Allow to read doubles, too. This will need to be changed to
2167 // the usage of Imp_ImportDoubleAndSpaces(...). For now, this is sufficient
2168 // since the interface cannot transport doubles.
2169 sal_Int32 Imp_ImportNumberAndSpaces(
2170     sal_Int32 nRetval, const OUString& rStr, sal_Int32& rPos,
2171     const sal_Int32 nLen, const SvXMLUnitConverter& rConv)
2172 {
2173     nRetval = FRound(Imp_ImportDoubleAndSpaces(double(nRetval), rStr, rPos, nLen, rConv));
2174     Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
2175     return nRetval;
2176 }
2177
2178 void Imp_PrepareCoorImport(sal_Int32& nX, sal_Int32& nY,
2179     const awt::Point& rObjectPos, const awt::Size& rObjectSize,
2180     const SdXMLImExViewBox& rViewBox, const bool bScale, const bool bTranslate)
2181 {
2182     if(bTranslate)
2183     {
2184         nX -= rViewBox.GetX();
2185         nY -= rViewBox.GetY();
2186     }
2187
2188     if(bScale && rViewBox.GetWidth() && rViewBox.GetHeight())
2189     {
2190         nX = (nX * rObjectSize.Width) / rViewBox.GetWidth();
2191         nY = (nY * rObjectSize.Height) / rViewBox.GetHeight();
2192     }
2193
2194     nX += rObjectPos.X;
2195     nY += rObjectPos.Y;
2196 }
2197
2198 void Imp_AddExportPoints(sal_Int32 nX, sal_Int32 nY,
2199     awt::Point* pPoints, drawing::PolygonFlags* pFlags,
2200     const sal_Int32 nInnerIndex,
2201     drawing::PolygonFlags eFlag)
2202 {
2203     if(pPoints)
2204         pPoints[nInnerIndex] = awt::Point( nX, nY );
2205
2206     if(pFlags)
2207         pFlags[nInnerIndex] = eFlag;
2208 }
2209
2210 void Imp_CalcVectorValues(::basegfx::B2DVector& aVec1, ::basegfx::B2DVector& aVec2, bool& bSameLength, bool& bSameDirection)
2211 {
2212     const sal_Int32 nLen1(FRound(aVec1.getLength()));
2213     const sal_Int32 nLen2(FRound(aVec2.getLength()));
2214     aVec1.normalize();
2215     aVec2.normalize();
2216     aVec1 += aVec2;
2217     const sal_Int32 nLen3(FRound(aVec1.getLength() * ((nLen1 + nLen2) / 2.0)));
2218
2219     bSameLength = (abs(nLen1 - nLen2) <= BORDER_INTEGERS_ARE_EQUAL);
2220     bSameDirection = (nLen3 <= BORDER_INTEGERS_ARE_EQUAL);
2221 }
2222
2223 void Imp_CorrectPolygonFlag(const sal_uInt32 nInnerIndex, const awt::Point* const pInnerSequence,
2224     drawing::PolygonFlags* const pInnerFlags, const sal_Int32 nX1, const sal_Int32 nY1)
2225 {
2226     if(nInnerIndex)
2227     {
2228         const awt::Point aPPrev1 = pInnerSequence[nInnerIndex - 1];
2229
2230         if(nInnerIndex > 1)
2231         {
2232             const awt::Point aPPrev2 = pInnerSequence[nInnerIndex - 2];
2233             const drawing::PolygonFlags aFPrev2 = pInnerFlags[nInnerIndex - 2];
2234             ::basegfx::B2DVector aVec1(aPPrev2.X - aPPrev1.X, aPPrev2.Y - aPPrev1.Y);
2235             ::basegfx::B2DVector aVec2(nX1 - aPPrev1.X, nY1 - aPPrev1.Y);
2236             bool bSameLength(false);
2237             bool bSameDirection(false);
2238
2239             // get vector values
2240             Imp_CalcVectorValues(aVec1, aVec2, bSameLength, bSameDirection);
2241
2242             if(drawing::PolygonFlags_CONTROL == aFPrev2)
2243             {
2244                 // point before is a control point
2245                 if(bSameDirection)
2246                 {
2247                     if(bSameLength)
2248                     {
2249                         // set to PolygonFlags_SYMMETRIC
2250                         pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SYMMETRIC;
2251                     }
2252                     else
2253                     {
2254                         // set to PolygonFlags_SMOOTH
2255                         pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SMOOTH;
2256                     }
2257                 }
2258                 else
2259                 {
2260                     // set to PolygonFlags_NORMAL
2261                     pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_NORMAL;
2262                 }
2263             }
2264             else
2265             {
2266                 // point before is a simple curve point
2267                 if(bSameDirection)
2268                 {
2269                     // set to PolygonFlags_SMOOTH
2270                     pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SMOOTH;
2271                 }
2272                 else
2273                 {
2274                     // set to PolygonFlags_NORMAL
2275                     pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_NORMAL;
2276                 }
2277             }
2278         }
2279         else
2280         {
2281             // no point before starpoint, set type to PolygonFlags_NORMAL
2282             pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_NORMAL;
2283         }
2284     }
2285 }
2286
2287 SdXMLImExSvgDElement::SdXMLImExSvgDElement(const OUString& rNew,
2288     const SdXMLImExViewBox& rViewBox,
2289     const awt::Point& rObjectPos,
2290     const awt::Size& rObjectSize,
2291     const SvXMLUnitConverter& rConv)
2292 :       msString( rNew ),
2293     mrViewBox( rViewBox ),
2294     mbIsClosed( false ),
2295     mbIsCurve( false ),
2296     mnLastX( 0L ),
2297     mnLastY( 0L ),
2298     maPoly( 0L ),
2299     maFlag( 0L )
2300 {
2301     // convert string to polygon
2302     const OUString aStr(msString.getStr(), msString.getLength());
2303     const sal_Int32 nLen(aStr.getLength());
2304     sal_Int32 nPos(0);
2305     sal_Int32 nNumPolys(0L);
2306     bool bEllipticalArc(false);
2307
2308     // object size and ViewBox size different?
2309     bool bScale(rObjectSize.Width != mrViewBox.GetWidth()
2310         || rObjectSize.Height != mrViewBox.GetHeight());
2311     bool bTranslate(mrViewBox.GetX() != 0L || mrViewBox.GetY() != 0L);
2312
2313     // first loop: count polys and get flags
2314     Imp_SkipSpaces(aStr, nPos, nLen);
2315
2316     while(nPos < nLen)
2317     {
2318         switch(aStr[nPos++])
2319         {
2320             case 'Z' :
2321             case 'z' :
2322             {
2323                 break;
2324             }
2325             case 'M' :
2326             case 'm' :
2327             {
2328                 nNumPolys++;
2329                 break;
2330             }
2331             case 'S' :
2332             case 's' :
2333             case 'C' :
2334             case 'c' :
2335             case 'Q' :
2336             case 'q' :
2337             case 'T' :
2338             case 't' :
2339             {
2340                 mbIsCurve = true;
2341                 break;
2342             }
2343             case 'L' :
2344             case 'l' :
2345             case 'H' :
2346             case 'h' :
2347             case 'V' :
2348             case 'v' :
2349             {
2350                 // normal, interpreted values. All okay.
2351                 break;
2352             }
2353             case 'A' :
2354             case 'a' :
2355             {
2356                 // Not yet interpreted value.
2357                 bEllipticalArc = true;
2358                 break;
2359             }
2360         }
2361     }
2362
2363     DBG_ASSERT(!bEllipticalArc, "XMLIMP: non-interpreted tags in svg:d element!");
2364
2365     if(nNumPolys)
2366     {
2367         // alloc arrays
2368         maPoly.realloc(nNumPolys);
2369         if(IsCurve())
2370             maFlag.realloc(nNumPolys);
2371
2372         // get outer sequences
2373         drawing::PointSequence* pOuterSequence = maPoly.getArray();
2374         drawing::FlagSequence* pOuterFlags = (IsCurve()) ? maFlag.getArray() : 0L;
2375
2376         // prepare new loop, count
2377         sal_uInt32 nPointCount(0L);
2378         nPos = 0;
2379         Imp_SkipSpaces(aStr, nPos, nLen);
2380
2381         // #104076# reset closed flag for next to be started polygon
2382         mbIsClosed = false;
2383
2384         while(nPos < nLen)
2385         {
2386             switch(aStr[nPos])
2387             {
2388                 case 'z' :
2389                 case 'Z' :
2390                 {
2391                     nPos++;
2392                     Imp_SkipSpaces(aStr, nPos, nLen);
2393
2394                     // #104076# remember closed state of current polygon
2395                     mbIsClosed = true;
2396
2397                     break;
2398                 }
2399                 case 'm' :
2400                 case 'M' :
2401                 {
2402                     // new poly starts, end-process current poly
2403                     if(nPointCount)
2404                     {
2405                         // #104076# If this partial polygon is closed, use one more point
2406                         // to represent that
2407                         if(mbIsClosed)
2408                         {
2409                             nPointCount++;
2410                         }
2411
2412                         pOuterSequence->realloc(nPointCount);
2413                         pOuterSequence++;
2414
2415                         if(pOuterFlags)
2416                         {
2417                             pOuterFlags->realloc(nPointCount);
2418                             pOuterFlags++;
2419                         }
2420
2421                         // reset point count for next polygon
2422                         nPointCount = 0L;
2423                     }
2424
2425                     // #104076# reset closed flag for next to be started polygon
2426                     mbIsClosed = false;
2427
2428                     // NO break, continue in next case
2429                 }
2430                 case 'L' :
2431                 case 'l' :
2432                 {
2433                     nPos++;
2434                     Imp_SkipSpaces(aStr, nPos, nLen);
2435
2436                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2437                     {
2438                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2439                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2440                         nPointCount++;
2441                     }
2442                     break;
2443                 }
2444                 case 'H' :
2445                 case 'h' :
2446                 case 'V' :
2447                 case 'v' :
2448                 {
2449                     nPos++;
2450                     Imp_SkipSpaces(aStr, nPos, nLen);
2451
2452                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2453                     {
2454                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2455                         nPointCount++;
2456                     }
2457                     break;
2458                 }
2459                 case 'S' :
2460                 case 's' :
2461                 {
2462                     nPos++;
2463                     Imp_SkipSpaces(aStr, nPos, nLen);
2464
2465                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2466                     {
2467                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2468                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2469                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2470                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2471                         nPointCount += 3;
2472                     }
2473                     break;
2474                 }
2475                 case 'C' :
2476                 case 'c' :
2477                 {
2478                     nPos++;
2479                     Imp_SkipSpaces(aStr, nPos, nLen);
2480
2481                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2482                     {
2483                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2484                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2485                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2486                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2487                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2488                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2489                         nPointCount += 3;
2490                     }
2491                     break;
2492                 }
2493
2494                 // #100617# quadratic beziers, supported as cubic ones
2495                 case 'Q' :
2496                 case 'q' :
2497                 {
2498                     nPos++;
2499                     Imp_SkipSpaces(aStr, nPos, nLen);
2500
2501                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2502                     {
2503                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2504                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2505                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2506                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2507
2508                         // use three points since quadratic is imported as cubic
2509                         nPointCount += 3;
2510                     }
2511                     break;
2512                 }
2513
2514                 // #100617# relative quadratic beziers, supported as cubic ones
2515                 case 'T' :
2516                 case 't' :
2517                 {
2518                     nPos++;
2519                     Imp_SkipSpaces(aStr, nPos, nLen);
2520
2521                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2522                     {
2523                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2524                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2525
2526                         // use three points since quadratic is imported as cubic
2527                         nPointCount += 3;
2528                     }
2529                     break;
2530                 }
2531
2532                 // #100617# not yet supported: elliptical arc
2533                 case 'A' :
2534                 case 'a' :
2535                 {
2536                     DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (elliptical arc)!");
2537                     nPos++;
2538                     Imp_SkipSpaces(aStr, nPos, nLen);
2539
2540                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2541                     {
2542                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2543                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2544                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2545                         Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
2546                         Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
2547                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2548                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
2549                     }
2550                     break;
2551                 }
2552
2553                 default:
2554                 {
2555                     nPos++;
2556                     DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (unknown)!");
2557                     break;
2558                 }
2559             }
2560         }
2561
2562         // alloc last poly (when points used)
2563         if(nPointCount)
2564         {
2565             // #104076# If this partial polygon is closed, use one more point
2566             // to represent that
2567             if(mbIsClosed)
2568             {
2569                 nPointCount++;
2570             }
2571
2572             pOuterSequence->realloc(nPointCount);
2573             pOuterSequence++;
2574
2575             if(pOuterFlags)
2576             {
2577                 pOuterFlags->realloc(nPointCount);
2578                 pOuterFlags++;
2579             }
2580         }
2581
2582         // set pointers back
2583         pOuterSequence = maPoly.getArray();
2584         pOuterFlags = (IsCurve()) ? maFlag.getArray() : 0L;
2585         awt::Point* pNotSoInnerSequence = 0L;
2586         drawing::PolygonFlags* pNotSoInnerFlags = 0L;
2587         sal_uInt32 nInnerIndex(0L);
2588
2589         // prepare new loop, read points
2590         nPos = 0;
2591         Imp_SkipSpaces(aStr, nPos, nLen);
2592
2593         // #104076# reset closed flag for next to be started polygon
2594         mbIsClosed = false;
2595
2596         while(nPos < nLen)
2597         {
2598             bool bRelative(false);
2599
2600             switch(aStr[nPos])
2601             {
2602                 case 'z' :
2603                 case 'Z' :
2604                 {
2605                     nPos++;
2606                     Imp_SkipSpaces(aStr, nPos, nLen);
2607
2608                     // #104076# remember closed state of current polygon
2609                     mbIsClosed = true;
2610
2611                     // closed: add first point again
2612                     // sal_Int32 nX(pInnerSequence[0].X);
2613                     // sal_Int32 nY(pInnerSequence[0].Y);
2614                     // Imp_AddExportPoints(nX, nY, pInnerSequence, pInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
2615
2616                     break;
2617                 }
2618
2619                 case 'm' :
2620                 {
2621                     bRelative = true;
2622                 }
2623                 case 'M' :
2624                 {
2625                     // #104076# end-process current poly
2626                     if(mbIsClosed)
2627                     {
2628                         if(pNotSoInnerSequence)
2629                         {
2630                             // closed: add first point again
2631                             sal_Int32 nX(pNotSoInnerSequence[0].X);
2632                             sal_Int32 nY(pNotSoInnerSequence[0].Y);
2633                             Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
2634                         }
2635
2636                         // reset closed flag for next to be started polygon
2637                         mbIsClosed = false;
2638                     }
2639
2640                     // next poly
2641                     pNotSoInnerSequence = pOuterSequence->getArray();
2642                     pOuterSequence++;
2643
2644                     if(pOuterFlags)
2645                     {
2646                         pNotSoInnerFlags = pOuterFlags->getArray();
2647                         pOuterFlags++;
2648                     }
2649
2650                     nInnerIndex = 0L;
2651
2652                     nPos++;
2653                     Imp_SkipSpaces(aStr, nPos, nLen);
2654
2655                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2656                     {
2657                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2658                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2659
2660                         if(bRelative)
2661                         {
2662                             nX += mnLastX;
2663                             nY += mnLastY;
2664                         }
2665
2666                         // set last position
2667                         mnLastX = nX;
2668                         mnLastY = nY;
2669
2670                         // calc transform and add point and flag
2671                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2672                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
2673                     }
2674                     break;
2675                 }
2676
2677                 case 'l' :
2678                 {
2679                     bRelative = true;
2680                 }
2681                 case 'L' :
2682                 {
2683                     nPos++;
2684                     Imp_SkipSpaces(aStr, nPos, nLen);
2685
2686                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2687                     {
2688                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2689                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2690
2691                         if(bRelative)
2692                         {
2693                             nX += mnLastX;
2694                             nY += mnLastY;
2695                         }
2696
2697                         // set last position
2698                         mnLastX = nX;
2699                         mnLastY = nY;
2700
2701                         // calc transform and add point and flag
2702                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2703                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
2704                     }
2705                     break;
2706                 }
2707
2708                 case 'h' :
2709                 {
2710                     bRelative = true;
2711                 }
2712                 case 'H' :
2713                 {
2714                     nPos++;
2715                     Imp_SkipSpaces(aStr, nPos, nLen);
2716
2717                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2718                     {
2719                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2720                         sal_Int32 nY(mnLastY);
2721
2722                         if(bRelative)
2723                             nX += mnLastX;
2724
2725                         // set last position
2726                         mnLastX = nX;
2727
2728                         // calc transform and add point and flag
2729                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2730                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
2731                     }
2732                     break;
2733                 }
2734
2735                 case 'v' :
2736                 {
2737                     bRelative = true;
2738                 }
2739                 case 'V' :
2740                 {
2741                     nPos++;
2742                     Imp_SkipSpaces(aStr, nPos, nLen);
2743
2744                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2745                     {
2746                         sal_Int32 nX(mnLastX);
2747                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2748
2749                         if(bRelative)
2750                             nY += mnLastY;
2751
2752                         // set last position
2753                         mnLastY = nY;
2754
2755                         // calc transform and add point and flag
2756                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2757                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
2758                     }
2759                     break;
2760                 }
2761
2762                 case 's' :
2763                 {
2764                     bRelative = true;
2765                 }
2766                 case 'S' :
2767                 {
2768                     nPos++;
2769                     Imp_SkipSpaces(aStr, nPos, nLen);
2770
2771                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2772                     {
2773                         sal_Int32 nX1;
2774                         sal_Int32 nY1;
2775                         sal_Int32 nX2(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2776                         sal_Int32 nY2(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2777                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2778                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2779
2780                         if(bRelative)
2781                         {
2782                             nX2 += mnLastX;
2783                             nY2 += mnLastY;
2784                             nX += mnLastX;
2785                             nY += mnLastY;
2786                         }
2787
2788                         // set last position
2789                         mnLastX = nX;
2790                         mnLastY = nY;
2791
2792                         // calc transform for new points
2793                         Imp_PrepareCoorImport(nX2, nY2, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2794                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2795
2796                         // one more thing is known: the previous real point is PolygonFlags_SYMMETRIC
2797                         // and the Point X1,Y1 can be constructed by mirroring the point before it.
2798                         nX1 = nX2;
2799                         nY1 = nY2;
2800                         if(nInnerIndex)
2801                         {
2802                             awt::Point aPPrev1 = pNotSoInnerSequence[nInnerIndex - 1];
2803
2804                             if(nInnerIndex > 1)
2805                             {
2806                                 awt::Point aPPrev2 = pNotSoInnerSequence[nInnerIndex - 2];
2807                                 nX1 = aPPrev1.X -(aPPrev2.X - aPPrev1.X);
2808                                 nY1 = aPPrev1.Y -(aPPrev2.Y - aPPrev1.Y);
2809                             }
2810
2811                             // set curve point to symmetric
2812                             pNotSoInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SYMMETRIC;
2813                         }
2814
2815                         // add calculated control point
2816                         Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2817
2818                         // add new points and set flags
2819                         Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2820                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
2821                     }
2822                     break;
2823                 }
2824
2825                 case 'c' :
2826                 {
2827                     bRelative = true;
2828                 }
2829                 case 'C' :
2830                 {
2831                     nPos++;
2832                     Imp_SkipSpaces(aStr, nPos, nLen);
2833
2834                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2835                     {
2836                         sal_Int32 nX1(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2837                         sal_Int32 nY1(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2838                         sal_Int32 nX2(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2839                         sal_Int32 nY2(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2840                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2841                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2842
2843                         if(bRelative)
2844                         {
2845                             nX1 += mnLastX;
2846                             nY1 += mnLastY;
2847                             nX2 += mnLastX;
2848                             nY2 += mnLastY;
2849                             nX += mnLastX;
2850                             nY += mnLastY;
2851                         }
2852
2853                         // set last position
2854                         mnLastX = nX;
2855                         mnLastY = nY;
2856
2857                         // calc transform for new points
2858                         Imp_PrepareCoorImport(nX1, nY1, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2859                         Imp_PrepareCoorImport(nX2, nY2, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2860                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2861
2862                         // correct polygon flag for previous point
2863                         Imp_CorrectPolygonFlag(nInnerIndex, pNotSoInnerSequence, pNotSoInnerFlags, nX1, nY1);
2864
2865                         // add new points and set flags
2866                         Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2867                         Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2868                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
2869                     }
2870                     break;
2871                 }
2872
2873                 // #100617# quadratic beziers are imported as cubic
2874                 case 'q' :
2875                 {
2876                     bRelative = true;
2877                 }
2878                 case 'Q' :
2879                 {
2880                     nPos++;
2881                     Imp_SkipSpaces(aStr, nPos, nLen);
2882
2883                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2884                     {
2885                         sal_Int32 nXX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2886                         sal_Int32 nYY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2887                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2888                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2889
2890                         if(bRelative)
2891                         {
2892                             nXX += mnLastX;
2893                             nYY += mnLastY;
2894                             nX += mnLastX;
2895                             nY += mnLastY;
2896                         }
2897
2898                         // set last position
2899                         mnLastX = nX;
2900                         mnLastY = nY;
2901
2902                         // calc transform for new points
2903                         Imp_PrepareCoorImport(nXX, nYY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2904                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2905
2906                         // calculate X1,X2
2907                         awt::Point aPPrev1 = (nInnerIndex) ? pNotSoInnerSequence[nInnerIndex-1] : pNotSoInnerSequence[0];
2908                         sal_Int32 nX1 = FRound((double)((nXX * 2) + aPPrev1.X) / 3.0);
2909                         sal_Int32 nY1 = FRound((double)((nYY * 2) + aPPrev1.Y) / 3.0);
2910                         sal_Int32 nX2 = FRound((double)((nXX * 2) + nX) / 3.0);
2911                         sal_Int32 nY2 = FRound((double)((nYY * 2) + nY) / 3.0);
2912
2913                         // correct polygon flag for previous point
2914                         Imp_CorrectPolygonFlag(nInnerIndex, pNotSoInnerSequence, pNotSoInnerFlags, nX1, nY1);
2915
2916                         // add new points and set flags
2917                         Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2918                         Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2919                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
2920                     }
2921                     break;
2922                 }
2923
2924                 // #100617# relative quadratic beziers are imported as cubic
2925                 case 't' :
2926                 {
2927                     bRelative = true;
2928                 }
2929                 case 'T' :
2930                 {
2931                     nPos++;
2932                     Imp_SkipSpaces(aStr, nPos, nLen);
2933
2934                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
2935                     {
2936                         sal_Int32 nXX;
2937                         sal_Int32 nYY;
2938                         sal_Int32 nX(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2939                         sal_Int32 nY(Imp_ImportNumberAndSpaces(0L, aStr, nPos, nLen, rConv));
2940
2941                         if(bRelative)
2942                         {
2943                             nX += mnLastX;
2944                             nY += mnLastY;
2945                         }
2946
2947                         // set last position
2948                         mnLastX = nX;
2949                         mnLastY = nY;
2950
2951                         // calc transform for new points
2952                         Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
2953
2954                         // one more thing is known: the previous real point is PolygonFlags_SYMMETRIC
2955                         // and the Point X1,Y1 can be constructed by mirroring the point before it.
2956                         nXX = nX;
2957                         nYY = nY;
2958                         awt::Point aPPrev1 = pNotSoInnerSequence[0];
2959
2960                         if(nInnerIndex)
2961                         {
2962                             aPPrev1 = pNotSoInnerSequence[nInnerIndex - 1];
2963
2964                             if(nInnerIndex > 1)
2965                             {
2966                                 awt::Point aPPrev2 = pNotSoInnerSequence[nInnerIndex - 2];
2967                                 nXX = aPPrev1.X -(aPPrev2.X - aPPrev1.X);
2968                                 nYY = aPPrev1.Y -(aPPrev2.Y - aPPrev1.Y);
2969                             }
2970
2971                             // set curve point to smooth here, since length
2972                             // is changed and thus only c1 can be used.
2973                             pNotSoInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SMOOTH;
2974                         }
2975
2976                         // calculate X1,X2
2977                         sal_Int32 nX1 = FRound((double)((nXX * 2) + aPPrev1.X) / 3.0);
2978                         sal_Int32 nY1 = FRound((double)((nYY * 2) + aPPrev1.Y) / 3.0);
2979                         sal_Int32 nX2 = FRound((double)((nXX * 2) + nX) / 3.0);
2980                         sal_Int32 nY2 = FRound((double)((nYY * 2) + nY) / 3.0);
2981
2982                         // correct polygon flag for previous point
2983                         Imp_CorrectPolygonFlag(nInnerIndex, pNotSoInnerSequence, pNotSoInnerFlags, nX1, nY1);
2984
2985                         // add new points and set flags
2986                         Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2987                         Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
2988                         Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
2989                     }
2990                     break;
2991                 }
2992
2993                 // #100617# not yet supported: elliptical arc
2994                 case 'A' :
2995                 case 'a' :
2996                 {
2997                     DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (elliptical arc)!");
2998                     nPos++;
2999                     Imp_SkipSpaces(aStr, nPos, nLen);
3000
3001                     while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
3002                     {
3003                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
3004                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
3005                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
3006                         Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
3007                         Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
3008                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
3009                         Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
3010                     }
3011                     break;
3012                 }
3013
3014                 default:
3015                 {
3016                     nPos++;
3017                     DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (unknown)!");
3018                     break;
3019                 }
3020             }
3021         }
3022
3023         // #104076# end-process closed state of last poly
3024         if(mbIsClosed)
3025         {
3026             if(pNotSoInnerSequence)
3027             {
3028                 // closed: add first point again
3029                 sal_Int32 nX(pNotSoInnerSequence[0].X);
3030                 sal_Int32 nY(pNotSoInnerSequence[0].Y);
3031                 Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
3032             }
3033         }
3034
3035         // #87202# If it's a curve and it's closed the last point maybe too much
3036         // and just exported since SVG does not allow special handling of same
3037         // start and end point, remove this last point.
3038         // Evtl. correct the last curve flags, too.
3039         if(IsCurve() && IsClosed())
3040         {
3041             // make one more loop over the PolyPolygon
3042             pOuterSequence = maPoly.getArray();
3043             pOuterFlags = maFlag.getArray();
3044             sal_Int32 nOuterCnt(maPoly.getLength());
3045
3046             for(sal_Int32 a(0); a < nOuterCnt; a++)
3047             {
3048                 // get Polygon pointers
3049                 awt::Point* pInnerSequence = pOuterSequence->getArray();
3050                 drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
3051                 sal_Int32 nInnerCnt(pOuterSequence->getLength());
3052
3053                 while( nInnerCnt >= 2
3054                     && ((pInnerSequence + (nInnerCnt - 2))->X == (pInnerSequence + (nInnerCnt - 1))->X)
3055                     && ((pInnerSequence + (nInnerCnt - 2))->Y == (pInnerSequence + (nInnerCnt - 1))->Y)
3056                     && drawing::PolygonFlags_CONTROL != *(pInnerFlags + (nInnerCnt - 2)))
3057                 {
3058                     // remove last point from array
3059                     pOuterSequence->realloc(nInnerCnt - 1);
3060                     pOuterFlags->realloc(nInnerCnt - 1);
3061
3062                     // get new pointers
3063                     pInnerSequence = pOuterSequence->getArray();
3064                     pInnerFlags = pOuterFlags->getArray();
3065                     nInnerCnt = pOuterSequence->getLength();
3066                 }
3067
3068                 // now evtl. correct the last curve flags
3069                 if(nInnerCnt >= 4)
3070                 {
3071                     if( pInnerSequence->X == (pInnerSequence + (nInnerCnt - 1))->X
3072                         && pInnerSequence->Y == (pInnerSequence + (nInnerCnt - 1))->Y
3073                         && drawing::PolygonFlags_CONTROL == *(pInnerFlags + 1)
3074                         && drawing::PolygonFlags_CONTROL == *(pInnerFlags + (nInnerCnt - 2)))
3075                     {
3076                         awt::Point aPrev = *(pInnerSequence + (nInnerCnt - 2));
3077                         awt::Point aCurr = *pInnerSequence;
3078                         awt::Point aNext = *(pInnerSequence + 1);
3079                         ::basegfx::B2DVector aVec1(aPrev.X - aCurr.X, aPrev.Y - aCurr.Y);
3080                         ::basegfx::B2DVector aVec2(aNext.X - aCurr.X, aNext.Y - aCurr.Y);
3081                         bool bSameLength(false);
3082                         bool bSameDirection(false);
3083
3084                         // get vector values
3085                         Imp_CalcVectorValues(aVec1, aVec2, bSameLength, bSameDirection);
3086
3087                         // set correct flag value
3088                         if(bSameDirection)
3089                         {
3090                             if(bSameLength)
3091                             {
3092                                 // set to PolygonFlags_SYMMETRIC
3093                                 *pInnerFlags = drawing::PolygonFlags_SYMMETRIC;
3094                                 *(pInnerFlags + (nInnerCnt - 1)) = drawing::PolygonFlags_SYMMETRIC;
3095                             }
3096                             else
3097                             {
3098                                 // set to PolygonFlags_SMOOTH
3099                                 *pInnerFlags = drawing::PolygonFlags_SMOOTH;
3100                                 *(pInnerFlags + (nInnerCnt - 1)) = drawing::PolygonFlags_SMOOTH;
3101                             }
3102                         }
3103                         else
3104                         {
3105                             // set to PolygonFlags_NORMAL
3106                             *pInnerFlags = drawing::PolygonFlags_NORMAL;
3107                             *(pInnerFlags + (nInnerCnt - 1)) = drawing::PolygonFlags_NORMAL;
3108                         }
3109                     }
3110                 }
3111
3112                 // switch to next Polygon
3113                 pOuterSequence++;
3114                 pOuterFlags++;
3115             }
3116         }
3117     }
3118 }
3119
3120 // eof