LCOV - code coverage report
Current view: top level - xmloff/source/draw - xexptran.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 348 575 60.5 %
Date: 2014-11-03 Functions: 33 46 71.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10