/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmloff.hxx"
#include "xexptran.hxx"
#include <tools/debug.hxx>
#include <rtl/ustrbuf.hxx>
#include <xmloff/xmluconv.hxx>
#include <tools/gen.hxx>
#include <basegfx/vector/b2dvector.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/tuple/b3dtuple.hxx>
#include <basegfx/matrix/b3dhommatrix.hxx>
#include <tools/string.hxx>

using ::rtl::OUString;
using ::rtl::OUStringBuffer;

using namespace ::com::sun::star;

//////////////////////////////////////////////////////////////////////////////
// Defines

#define BORDER_INTEGERS_ARE_EQUAL		(4)

//////////////////////////////////////////////////////////////////////////////
// Predeclarations

void Imp_SkipDouble(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen);
void Imp_CalcVectorValues(::basegfx::B2DVector& aVec1, ::basegfx::B2DVector& aVec2, bool& bSameLength, bool& bSameDirection);

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// parsing help functions for simple chars
void Imp_SkipSpaces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
{
	while(rPos < nLen 
		&& sal_Unicode(' ') == rStr[rPos])
		rPos++;
}

void Imp_SkipSpacesAndOpeningBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
{
	while(rPos < nLen 
		&& (sal_Unicode(' ') == rStr[rPos] || sal_Unicode('(') == rStr[rPos]))
		rPos++;
}

void Imp_SkipSpacesAndCommas(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
{
	while(rPos < nLen 
		&& (sal_Unicode(' ') == rStr[rPos] || sal_Unicode(',') == rStr[rPos]))
		rPos++;
}

void Imp_SkipSpacesAndClosingBraces(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
{
	while(rPos < nLen 
		&& (sal_Unicode(' ') == rStr[rPos] || sal_Unicode(')') == rStr[rPos]))
		rPos++;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// parsing help functions for integer numbers

bool Imp_IsOnNumberChar(const OUString& rStr, const sal_Int32 nPos, bool bSignAllowed = true)
{
	sal_Unicode aChar(rStr[nPos]);

	if((sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
		|| (bSignAllowed && sal_Unicode('+') == aChar)
		|| (bSignAllowed && sal_Unicode('-') == aChar)
	)
		return true;
	return false;
}

bool Imp_IsOnUnitChar(const OUString& rStr, const sal_Int32 nPos)
{
	sal_Unicode aChar(rStr[nPos]);

	if((sal_Unicode('a') <= aChar && sal_Unicode('z') >= aChar)
		|| (sal_Unicode('A') <= aChar && sal_Unicode('Z') >= aChar)
		|| sal_Unicode('%') == aChar
	)
		return true;
	return false;
}

void Imp_SkipNumber(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen)
{
	bool bSignAllowed(true);

	while(rPos < nLen && Imp_IsOnNumberChar(rStr, rPos, bSignAllowed))
	{
		bSignAllowed = false;
		rPos++;
	}
}

void Imp_SkipNumberAndSpacesAndCommas(const OUString& rStr, sal_Int32& rPos, 
	const sal_Int32 nLen)
{
	Imp_SkipNumber(rStr, rPos, nLen);
	Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
}

// #100617# Allow to skip doubles, too.
void Imp_SkipDoubleAndSpacesAndCommas(const OUString& rStr, sal_Int32& rPos, 
	const sal_Int32 nLen)
{
	Imp_SkipDouble(rStr, rPos, nLen);
	Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
}

void Imp_PutNumberChar(OUString& rStr, sal_Int32 nValue)
{
	OUStringBuffer sStringBuffer;
	SvXMLUnitConverter::convertNumber(sStringBuffer, nValue);
	rStr += OUString(sStringBuffer.makeStringAndClear());
}

void Imp_PutNumberCharWithSpace(OUString& rStr, sal_Int32 nValue)
{
	const sal_Int32 aLen(rStr.getLength());
	if(aLen)
		if(Imp_IsOnNumberChar(rStr, aLen - 1, false) && nValue >= 0)
			rStr += String(sal_Unicode(' '));
	Imp_PutNumberChar(rStr, nValue);
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// parsing help functions for double numbers

void Imp_SkipDouble(const OUString& rStr, sal_Int32& rPos, const sal_Int32)
{
	sal_Unicode aChar(rStr[rPos]);

	if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
		aChar = rStr[++rPos];

	while((sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
		|| sal_Unicode('.') == aChar)
	{
		aChar = rStr[++rPos];
	}

	if(sal_Unicode('e') == aChar || sal_Unicode('E') == aChar)
	{
		aChar = rStr[++rPos];
	
		if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
			aChar = rStr[++rPos];

		while(sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
		{
			aChar = rStr[++rPos];
		}
	}
}

double Imp_GetDoubleChar(const OUString& rStr, sal_Int32& rPos, const sal_Int32 nLen, 
	const SvXMLUnitConverter& rConv, double fRetval, bool bLookForUnits = false)
{
	sal_Unicode aChar(rStr[rPos]);
	OUStringBuffer sNumberString;

	if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
	{
		sNumberString.append(rStr[rPos]);
		aChar = rStr[++rPos];
	}

	while((sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
		|| sal_Unicode('.') == aChar)
	{
		sNumberString.append(rStr[rPos]);
		aChar = rStr[++rPos];
	}

	if(sal_Unicode('e') == aChar || sal_Unicode('E') == aChar)
	{
		sNumberString.append(rStr[rPos]);
		aChar = rStr[++rPos];
	
		if(sal_Unicode('+') == aChar || sal_Unicode('-') == aChar)
		{
			sNumberString.append(rStr[rPos]);
			aChar = rStr[++rPos];
		}

		while(sal_Unicode('0') <= aChar && sal_Unicode('9') >= aChar)
		{
			sNumberString.append(rStr[rPos]);
			aChar = rStr[++rPos];
		}
	}

	if(bLookForUnits)
	{
		Imp_SkipSpaces(rStr, rPos, nLen);
		while(rPos < nLen && Imp_IsOnUnitChar(rStr, rPos))
			sNumberString.append(rStr[rPos++]);
	}
	
	if(sNumberString.getLength())
	{
		if(bLookForUnits)
			rConv.convertDouble(fRetval, sNumberString.makeStringAndClear(), true);
		else
			rConv.convertDouble(fRetval, sNumberString.makeStringAndClear());
	}

	return fRetval;
}

void Imp_PutDoubleChar(OUString& rStr, const SvXMLUnitConverter& rConv, double fValue, 
	bool bConvertUnits = false)
{
	OUStringBuffer sStringBuffer;

	if(bConvertUnits)
		rConv.convertDouble(sStringBuffer, fValue, true);
	else
		rConv.convertDouble(sStringBuffer, fValue);

	rStr += OUString(sStringBuffer.makeStringAndClear());
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// base class of all 2D transform objects

struct ImpSdXMLExpTransObj2DBase
{
	sal_uInt16					mnType;
	ImpSdXMLExpTransObj2DBase(sal_uInt16 nType) 
	:	mnType(nType) {}
};

//////////////////////////////////////////////////////////////////////////////
// possible object types for 2D

#define	IMP_SDXMLEXP_TRANSOBJ2D_ROTATE			0x0000
#define	IMP_SDXMLEXP_TRANSOBJ2D_SCALE			0x0001
#define	IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE		0x0002
#define	IMP_SDXMLEXP_TRANSOBJ2D_SKEWX			0x0003
#define	IMP_SDXMLEXP_TRANSOBJ2D_SKEWY			0x0004
#define	IMP_SDXMLEXP_TRANSOBJ2D_MATRIX			0x0005

//////////////////////////////////////////////////////////////////////////////
// classes of objects, different sizes

struct ImpSdXMLExpTransObj2DRotate : public ImpSdXMLExpTransObj2DBase
{
	double						mfRotate;
	ImpSdXMLExpTransObj2DRotate(double fVal) 
	:	ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_ROTATE), mfRotate(fVal) {}
};
struct ImpSdXMLExpTransObj2DScale : public ImpSdXMLExpTransObj2DBase
{
	::basegfx::B2DTuple			maScale;
	ImpSdXMLExpTransObj2DScale(const ::basegfx::B2DTuple& rNew) 
	:	ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SCALE), maScale(rNew) {}
};
struct ImpSdXMLExpTransObj2DTranslate : public ImpSdXMLExpTransObj2DBase
{
	::basegfx::B2DTuple			maTranslate;
	ImpSdXMLExpTransObj2DTranslate(const ::basegfx::B2DTuple& rNew) 
	:	ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE), maTranslate(rNew) {}
};
struct ImpSdXMLExpTransObj2DSkewX : public ImpSdXMLExpTransObj2DBase
{
	double						mfSkewX;
	ImpSdXMLExpTransObj2DSkewX(double fVal) 
	:	ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWX), mfSkewX(fVal) {}
};
struct ImpSdXMLExpTransObj2DSkewY : public ImpSdXMLExpTransObj2DBase
{
	double						mfSkewY;
	ImpSdXMLExpTransObj2DSkewY(double fVal) 
	:	ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_SKEWY), mfSkewY(fVal) {}
};
struct ImpSdXMLExpTransObj2DMatrix : public ImpSdXMLExpTransObj2DBase
{
	::basegfx::B2DHomMatrix		maMatrix;
	ImpSdXMLExpTransObj2DMatrix(const ::basegfx::B2DHomMatrix& rNew) 
	:	ImpSdXMLExpTransObj2DBase(IMP_SDXMLEXP_TRANSOBJ2D_MATRIX), maMatrix(rNew) {}
};

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// delete all entries in list

void SdXMLImExTransform2D::EmptyList()
{
    const sal_uInt32 nCount = maList.size();
	for(sal_uInt32 a(0L); a < nCount; a++)
	{
		ImpSdXMLExpTransObj2DBase* pObj = maList[a];

		switch(pObj->mnType)
		{
			case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE		: 
			{
				delete (ImpSdXMLExpTransObj2DRotate*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SCALE		: 
			{
				delete (ImpSdXMLExpTransObj2DScale*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE	: 
			{
				delete (ImpSdXMLExpTransObj2DTranslate*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX		: 
			{
				delete (ImpSdXMLExpTransObj2DSkewX*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY		: 
			{
				delete (ImpSdXMLExpTransObj2DSkewY*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX		: 
			{
				delete (ImpSdXMLExpTransObj2DMatrix*)pObj; 
				break;
			}
			default : 
			{
				DBG_ERROR("SdXMLImExTransform2D: impossible entry!"); 
				break;
			}
		}
	}

	maList.clear();
}

//////////////////////////////////////////////////////////////////////////////
// add members

void SdXMLImExTransform2D::AddRotate(double fNew)
{
	if(fNew != 0.0)
		maList.push_back(new ImpSdXMLExpTransObj2DRotate(fNew));
}

void SdXMLImExTransform2D::AddScale(const ::basegfx::B2DTuple& rNew)
{
	if(1.0 != rNew.getX() || 1.0 != rNew.getY())
		maList.push_back(new ImpSdXMLExpTransObj2DScale(rNew));
}

void SdXMLImExTransform2D::AddTranslate(const ::basegfx::B2DTuple& rNew)
{
	if(!rNew.equalZero())
		maList.push_back(new ImpSdXMLExpTransObj2DTranslate(rNew));
}

void SdXMLImExTransform2D::AddSkewX(double fNew)
{
	if(fNew != 0.0)
		maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fNew));
}

void SdXMLImExTransform2D::AddSkewY(double fNew)
{
	if(fNew != 0.0)
		maList.push_back(new ImpSdXMLExpTransObj2DSkewY(fNew));
}

void SdXMLImExTransform2D::AddMatrix(const ::basegfx::B2DHomMatrix& rNew)
{
	if(!rNew.isIdentity())
		maList.push_back(new ImpSdXMLExpTransObj2DMatrix(rNew));
}

//////////////////////////////////////////////////////////////////////////////
// gen string for export
const OUString& SdXMLImExTransform2D::GetExportString(const SvXMLUnitConverter& rConv)
{
	OUString aNewString;
	OUString aClosingBrace(sal_Unicode(')'));
	OUString aEmptySpace(sal_Unicode(' '));
	
	const sal_uInt32 nCount = maList.size();
	for(sal_uInt32 a(0L); a < nCount; a++)
	{
		ImpSdXMLExpTransObj2DBase* pObj = maList[a];
		switch(pObj->mnType)
		{
			case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE	: 
			{
				aNewString += OUString::createFromAscii("rotate (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DRotate*)pObj)->mfRotate);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SCALE		: 
			{
				aNewString += OUString::createFromAscii("scale (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DScale*)pObj)->maScale.getX());
				aNewString += aEmptySpace;
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DScale*)pObj)->maScale.getY());
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE	: 
			{
				aNewString += OUString::createFromAscii("translate (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DTranslate*)pObj)->maTranslate.getX(), true);
				aNewString += aEmptySpace;
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DTranslate*)pObj)->maTranslate.getY(), true);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX		: 
			{
				aNewString += OUString::createFromAscii("skewX (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DSkewX*)pObj)->mfSkewX);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY		: 
			{
				aNewString += OUString::createFromAscii("skewY (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DSkewY*)pObj)->mfSkewY);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX	: 
			{
				aNewString += OUString::createFromAscii("matrix (");

				// a
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(0, 0));
				aNewString += aEmptySpace;

				// b
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(1, 0));
				aNewString += aEmptySpace;

				// c
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(0, 1));
				aNewString += aEmptySpace;

				// d
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(1, 1));
				aNewString += aEmptySpace;

				// e
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(0, 2), true);
				aNewString += aEmptySpace;

				// f
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix.get(1, 2), true);

				aNewString += aClosingBrace;
				break;
			}
			default : 
			{
				DBG_ERROR("SdXMLImExTransform2D: impossible entry!"); 
				break;
			}
		}

		// if not the last entry, add one space to next tag
		if(a + 1UL != maList.size())
		{
			aNewString += aEmptySpace;
		}
	}
	
	// fill string form OUString
	msString = aNewString;

	return msString;
}

//////////////////////////////////////////////////////////////////////////////
// for Import: constructor with string, parses it and generates entries
SdXMLImExTransform2D::SdXMLImExTransform2D(const OUString& rNew, const SvXMLUnitConverter& rConv)
{
	SetString(rNew, rConv);
}

//////////////////////////////////////////////////////////////////////////////
// sets new string, parses it and generates entries
void SdXMLImExTransform2D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
{
	msString = rNew;
	EmptyList();

	if(msString.getLength())
	{
		const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
		const sal_Int32 nLen(aStr.getLength());

		const OUString aString_rotate(OUString::createFromAscii("rotate"));
		const OUString aString_scale(OUString::createFromAscii("scale"));
		const OUString aString_translate(OUString::createFromAscii("translate"));
		const OUString aString_skewX(OUString::createFromAscii("skewX"));
		const OUString aString_skewY(OUString::createFromAscii("skewY"));
		const OUString aString_matrix(OUString::createFromAscii("matrix"));

		sal_Int32 nPos(0);

		while(nPos < nLen)
		{
			// skip spaces
			Imp_SkipSpaces(aStr, nPos, nLen);

			// look for tag
			if(nPos < nLen)
			{
				if(nPos == aStr.indexOf(aString_rotate, nPos))
				{ 
					double fValue(0.0);
					nPos += 6; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
					if(fValue != 0.0)
						maList.push_back(new ImpSdXMLExpTransObj2DRotate(fValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_scale, nPos))
				{ 
					::basegfx::B2DTuple aValue(1.0, 1.0);
					nPos += 5; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
					aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));

					if(aValue.getX() != 1.0 || aValue.getY() != 1.0)
						maList.push_back(new ImpSdXMLExpTransObj2DScale(aValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_translate, nPos))
				{ 
					::basegfx::B2DTuple aValue;
					nPos += 9; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
					aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));

					if(!aValue.equalZero())
						maList.push_back(new ImpSdXMLExpTransObj2DTranslate(aValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_skewX, nPos))
				{ 
					double fValue(0.0);
					nPos += 5; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
					if(fValue != 0.0)
						maList.push_back(new ImpSdXMLExpTransObj2DSkewX(fValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_skewY, nPos))
				{ 
					double fValue(0.0);
					nPos += 5; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
					if(fValue != 0.0)
						maList.push_back(new ImpSdXMLExpTransObj2DSkewY(fValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_matrix, nPos))
				{ 
					::basegfx::B2DHomMatrix aValue;

					nPos += 6; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);

					// a
					aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// b
					aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// c
					aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// d
					aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// e
					aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// f
					aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					if(!aValue.isIdentity())
						maList.push_back(new ImpSdXMLExpTransObj2DMatrix(aValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else
				{
					nPos++;
				}
			}
		}
	}
}

void SdXMLImExTransform2D::GetFullTransform(::basegfx::B2DHomMatrix& rFullTrans)
{
	rFullTrans.identity();

	const sal_uInt32 nCount = maList.size();
	for(sal_uInt32 a(0L); a < nCount; a++)
	{
		ImpSdXMLExpTransObj2DBase* pObj = maList[a];
		switch(pObj->mnType)
		{
			case IMP_SDXMLEXP_TRANSOBJ2D_ROTATE		: 
			{
                // #i78696#
                // mfRotate is mathematically wrong oriented since we export/import the angle
                // values mirrored. This error is fixed in the API, but not yet in the FileFormat.
                // For the FileFormat there is a follow-up task (#i78698#) to fix this in the next 
                // ODF FileFormat version. For now - to emulate the old behaviour - it is necessary
                // to mirror the value here
				rFullTrans.rotate(((ImpSdXMLExpTransObj2DRotate*)pObj)->mfRotate * -1.0);
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SCALE		: 
			{
				const ::basegfx::B2DTuple& rScale = ((ImpSdXMLExpTransObj2DScale*)pObj)->maScale;
				rFullTrans.scale(rScale.getX(), rScale.getY()); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_TRANSLATE	: 
			{
				const ::basegfx::B2DTuple& rTranslate = ((ImpSdXMLExpTransObj2DTranslate*)pObj)->maTranslate;
				rFullTrans.translate(rTranslate.getX(), rTranslate.getY()); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SKEWX		: 
			{
				rFullTrans.shearX(tan(((ImpSdXMLExpTransObj2DSkewX*)pObj)->mfSkewX)); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_SKEWY		: 
			{
				rFullTrans.shearY(tan(((ImpSdXMLExpTransObj2DSkewY*)pObj)->mfSkewY)); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ2D_MATRIX		: 
			{
				rFullTrans *= ((ImpSdXMLExpTransObj2DMatrix*)pObj)->maMatrix; 
				break;
			}
			default : 
			{
				DBG_ERROR("SdXMLImExTransform2D: impossible entry!"); 
				break;
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// base class of all 3D transform objects

struct ImpSdXMLExpTransObj3DBase
{
	sal_uInt16					mnType;
	ImpSdXMLExpTransObj3DBase(sal_uInt16 nType) 
	:	mnType(nType) {}
};

//////////////////////////////////////////////////////////////////////////////
// possible object types for 3D

#define	IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X		0x0000
#define	IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y		0x0001
#define	IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z		0x0002
#define	IMP_SDXMLEXP_TRANSOBJ3D_SCALE			0x0003
#define	IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE		0x0004
#define	IMP_SDXMLEXP_TRANSOBJ3D_MATRIX			0x0005

//////////////////////////////////////////////////////////////////////////////
// classes of objects, different sizes

struct ImpSdXMLExpTransObj3DRotateX : public ImpSdXMLExpTransObj3DBase
{
	double						mfRotateX;
	ImpSdXMLExpTransObj3DRotateX(double fVal) 
	:	ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X), mfRotateX(fVal) {}
};
struct ImpSdXMLExpTransObj3DRotateY : public ImpSdXMLExpTransObj3DBase
{
	double						mfRotateY;
	ImpSdXMLExpTransObj3DRotateY(double fVal) 
	:	ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y), mfRotateY(fVal) {}
};
struct ImpSdXMLExpTransObj3DRotateZ : public ImpSdXMLExpTransObj3DBase
{
	double						mfRotateZ;
	ImpSdXMLExpTransObj3DRotateZ(double fVal) 
	:	ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z), mfRotateZ(fVal) {}
};
struct ImpSdXMLExpTransObj3DScale : public ImpSdXMLExpTransObj3DBase
{
	::basegfx::B3DTuple			maScale;
	ImpSdXMLExpTransObj3DScale(const ::basegfx::B3DTuple& rNew) 
	:	ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_SCALE), maScale(rNew) {}
};
struct ImpSdXMLExpTransObj3DTranslate : public ImpSdXMLExpTransObj3DBase
{
	::basegfx::B3DTuple			maTranslate;
	ImpSdXMLExpTransObj3DTranslate(const ::basegfx::B3DTuple& rNew) 
	:	ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE), maTranslate(rNew) {}
};
struct ImpSdXMLExpTransObj3DMatrix : public ImpSdXMLExpTransObj3DBase
{
	::basegfx::B3DHomMatrix		maMatrix;
	ImpSdXMLExpTransObj3DMatrix(const ::basegfx::B3DHomMatrix& rNew) 
	:	ImpSdXMLExpTransObj3DBase(IMP_SDXMLEXP_TRANSOBJ3D_MATRIX), maMatrix(rNew) {}
};

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// delete all entries in list

void SdXMLImExTransform3D::EmptyList()
{
	const sal_uInt32 nCount = maList.size();
	for(sal_uInt32 a(0L); a < nCount; a++)
	{
		ImpSdXMLExpTransObj3DBase* pObj = maList[a];

		switch(pObj->mnType)
		{
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X	: 
			{
				delete (ImpSdXMLExpTransObj3DRotateX*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y	: 
			{
				delete (ImpSdXMLExpTransObj3DRotateY*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z	: 
			{
				delete (ImpSdXMLExpTransObj3DRotateZ*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_SCALE		: 
			{
				delete (ImpSdXMLExpTransObj3DScale*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE	: 
			{
				delete (ImpSdXMLExpTransObj3DTranslate*)pObj; 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX		: 
			{
				delete (ImpSdXMLExpTransObj3DMatrix*)pObj; 
				break;
			}
			default : 
			{
				DBG_ERROR("SdXMLImExTransform3D: impossible entry!"); 
				break;
			}
		}
	}

	maList.clear();
}

//////////////////////////////////////////////////////////////////////////////
// add members

void SdXMLImExTransform3D::AddRotateX(double fNew)
{
	if(fNew != 0.0)
		maList.push_back(new ImpSdXMLExpTransObj3DRotateX(fNew));
}

void SdXMLImExTransform3D::AddRotateY(double fNew)
{
	if(fNew != 0.0)
		maList.push_back(new ImpSdXMLExpTransObj3DRotateY(fNew));
}

void SdXMLImExTransform3D::AddRotateZ(double fNew)
{
	if(fNew != 0.0)
		maList.push_back(new ImpSdXMLExpTransObj3DRotateZ(fNew));
}

void SdXMLImExTransform3D::AddScale(const ::basegfx::B3DTuple& rNew)
{
	if(1.0 != rNew.getX() || 1.0 != rNew.getY() || 1.0 != rNew.getZ())
		maList.push_back(new ImpSdXMLExpTransObj3DScale(rNew));
}

void SdXMLImExTransform3D::AddTranslate(const ::basegfx::B3DTuple& rNew)
{
	if(!rNew.equalZero())
		maList.push_back(new ImpSdXMLExpTransObj3DTranslate(rNew));
}

void SdXMLImExTransform3D::AddMatrix(const ::basegfx::B3DHomMatrix& rNew)
{
	if(!rNew.isIdentity())
		maList.push_back(new ImpSdXMLExpTransObj3DMatrix(rNew));
}

void SdXMLImExTransform3D::AddHomogenMatrix(const drawing::HomogenMatrix& xHomMat)
{
	::basegfx::B3DHomMatrix aExportMatrix;

	aExportMatrix.set(0, 0, xHomMat.Line1.Column1);
	aExportMatrix.set(0, 1, xHomMat.Line1.Column2);
	aExportMatrix.set(0, 2, xHomMat.Line1.Column3);
	aExportMatrix.set(0, 3, xHomMat.Line1.Column4);
	aExportMatrix.set(1, 0, xHomMat.Line2.Column1);
	aExportMatrix.set(1, 1, xHomMat.Line2.Column2);
	aExportMatrix.set(1, 2, xHomMat.Line2.Column3);
	aExportMatrix.set(1, 3, xHomMat.Line2.Column4);
	aExportMatrix.set(2, 0, xHomMat.Line3.Column1);
	aExportMatrix.set(2, 1, xHomMat.Line3.Column2);
	aExportMatrix.set(2, 2, xHomMat.Line3.Column3);
	aExportMatrix.set(2, 3, xHomMat.Line3.Column4);

	AddMatrix(aExportMatrix);
}

//////////////////////////////////////////////////////////////////////////////
// gen string for export
const OUString& SdXMLImExTransform3D::GetExportString(const SvXMLUnitConverter& rConv)
{
	OUString aNewString;
	OUString aClosingBrace(sal_Unicode(')'));
	OUString aEmptySpace(sal_Unicode(' '));
	
	const sal_uInt32 nCount = maList.size();
	for(sal_uInt32 a(0L); a < nCount; a++)
	{
		ImpSdXMLExpTransObj3DBase* pObj = maList[a];
		switch(pObj->mnType)
		{
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X	: 
			{
				aNewString += OUString::createFromAscii("rotatex (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DRotateX*)pObj)->mfRotateX);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y	: 
			{
				aNewString += OUString::createFromAscii("rotatey (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DRotateY*)pObj)->mfRotateY);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z	: 
			{
				aNewString += OUString::createFromAscii("rotatez (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DRotateZ*)pObj)->mfRotateZ);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_SCALE		: 
			{
				aNewString += OUString::createFromAscii("scale (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale.getX());
				aNewString += aEmptySpace;
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale.getY());
				aNewString += aEmptySpace;
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale.getZ());
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE	: 
			{
				aNewString += OUString::createFromAscii("translate (");
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate.getX(), true);
				aNewString += aEmptySpace;
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate.getY(), true);
				aNewString += aEmptySpace;
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate.getZ(), true);
				aNewString += aClosingBrace;
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX	: 
			{
				aNewString += OUString::createFromAscii("matrix (");

				// a
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 0));
				aNewString += aEmptySpace;
				
				// b
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 0));
				aNewString += aEmptySpace;
				
				// c
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 0));
				aNewString += aEmptySpace;
				
				// d
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 1));
				aNewString += aEmptySpace;
				
				// e
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 1));
				aNewString += aEmptySpace;
				
				// f
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 1));
				aNewString += aEmptySpace;
				
				// g
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 2));
				aNewString += aEmptySpace;
				
				// h
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 2));
				aNewString += aEmptySpace;
				
				// i
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 2));
				aNewString += aEmptySpace;
				
				// j
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(0, 3), true);
				aNewString += aEmptySpace;
				
				// k
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(1, 3), true);
				aNewString += aEmptySpace;
				
				// l
				Imp_PutDoubleChar(aNewString, rConv, ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix.get(2, 3), true);

				aNewString += aClosingBrace;
				break;
			}
			default : 
			{
				DBG_ERROR("SdXMLImExTransform3D: impossible entry!"); 
				break;
			}
		}

		// if not the last entry, add one space to next tag
		if(a + 1UL != maList.size())
		{
			aNewString += aEmptySpace;
		}
	}
	
	// fill string form OUString
	msString = aNewString;

	return msString;
}

//////////////////////////////////////////////////////////////////////////////
// for Import: constructor with string, parses it and generates entries
SdXMLImExTransform3D::SdXMLImExTransform3D(const OUString& rNew, const SvXMLUnitConverter& rConv)
{
	SetString(rNew, rConv);
}

//////////////////////////////////////////////////////////////////////////////
// sets new string, parses it and generates entries
void SdXMLImExTransform3D::SetString(const OUString& rNew, const SvXMLUnitConverter& rConv)
{
	msString = rNew;
	EmptyList();

	if(msString.getLength())
	{
		const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
		const sal_Int32 nLen(aStr.getLength());

		const OUString aString_rotatex(OUString::createFromAscii("rotatex"));
		const OUString aString_rotatey(OUString::createFromAscii("rotatey"));
		const OUString aString_rotatez(OUString::createFromAscii("rotatez"));
		const OUString aString_scale(OUString::createFromAscii("scale"));
		const OUString aString_translate(OUString::createFromAscii("translate"));
		const OUString aString_matrix(OUString::createFromAscii("matrix"));
		
		sal_Int32 nPos(0);

		while(nPos < nLen)
		{
			// skip spaces
			Imp_SkipSpaces(aStr, nPos, nLen);

			// look for tag
			if(nPos < nLen)
			{
				if(nPos == aStr.indexOf(aString_rotatex, nPos))
				{ 
					double fValue(0.0);

					nPos += 7; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
					if(fValue != 0.0)
						maList.push_back(new ImpSdXMLExpTransObj3DRotateX(fValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_rotatey, nPos))
				{ 
					double fValue(0.0);

					nPos += 7; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
					if(fValue != 0.0)
						maList.push_back(new ImpSdXMLExpTransObj3DRotateY(fValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_rotatez, nPos))
				{ 
					double fValue(0.0);

					nPos += 7; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					fValue = Imp_GetDoubleChar(aStr, nPos, nLen, rConv, fValue);
					if(fValue != 0.0)
						maList.push_back(new ImpSdXMLExpTransObj3DRotateZ(fValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_scale, nPos))
				{ 
					::basegfx::B3DTuple aValue(1.0, 1.0, 1.0);

					nPos += 5; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX()));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
					aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY()));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
					aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ()));

					if(1.0 != aValue.getX() || 1.0 != aValue.getY() || 1.0 != aValue.getZ())
						maList.push_back(new ImpSdXMLExpTransObj3DScale(aValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_translate, nPos))
				{ 
					::basegfx::B3DTuple aValue;

					nPos += 9; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);
					aValue.setX(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getX(), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
					aValue.setY(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getY(), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
					aValue.setZ(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.getZ(), true));

					if(!aValue.equalZero())
						maList.push_back(new ImpSdXMLExpTransObj3DTranslate(aValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else if(nPos == aStr.indexOf(aString_matrix, nPos))
				{ 
					::basegfx::B3DHomMatrix aValue;

					nPos += 6; 
					Imp_SkipSpacesAndOpeningBraces(aStr, nPos, nLen);

					// a
					aValue.set(0, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 0)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// b
					aValue.set(1, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 0)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// c
					aValue.set(2, 0, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 0)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// d
					aValue.set(0, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 1)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// e
					aValue.set(1, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 1)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// f
					aValue.set(2, 1, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 1)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// g
					aValue.set(0, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 2)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// h
					aValue.set(1, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 2)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// i
					aValue.set(2, 2, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 2)));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// j
					aValue.set(0, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(0, 3), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// k
					aValue.set(1, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(1, 3), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					// l
					aValue.set(2, 3, Imp_GetDoubleChar(aStr, nPos, nLen, rConv, aValue.get(2, 3), true));
					Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

					if(!aValue.isIdentity())
						maList.push_back(new ImpSdXMLExpTransObj3DMatrix(aValue));

					Imp_SkipSpacesAndClosingBraces(aStr, nPos, nLen);
				}
				else
				{
					nPos++;
				}
			}
		}
	}
}

bool SdXMLImExTransform3D::GetFullHomogenTransform(com::sun::star::drawing::HomogenMatrix& xHomMat)
{
	::basegfx::B3DHomMatrix aFullTransform;
	GetFullTransform(aFullTransform);

	if(!aFullTransform.isIdentity())
	{
		xHomMat.Line1.Column1 = aFullTransform.get(0, 0);
		xHomMat.Line1.Column2 = aFullTransform.get(0, 1);
		xHomMat.Line1.Column3 = aFullTransform.get(0, 2);
		xHomMat.Line1.Column4 = aFullTransform.get(0, 3);

		xHomMat.Line2.Column1 = aFullTransform.get(1, 0);
		xHomMat.Line2.Column2 = aFullTransform.get(1, 1);
		xHomMat.Line2.Column3 = aFullTransform.get(1, 2);
		xHomMat.Line2.Column4 = aFullTransform.get(1, 3);

		xHomMat.Line3.Column1 = aFullTransform.get(2, 0);
		xHomMat.Line3.Column2 = aFullTransform.get(2, 1);
		xHomMat.Line3.Column3 = aFullTransform.get(2, 2);
		xHomMat.Line3.Column4 = aFullTransform.get(2, 3);

		xHomMat.Line4.Column1 = aFullTransform.get(3, 0);
		xHomMat.Line4.Column2 = aFullTransform.get(3, 1);
		xHomMat.Line4.Column3 = aFullTransform.get(3, 2);
		xHomMat.Line4.Column4 = aFullTransform.get(3, 3);

		return true;
	}

	return false;
}

void SdXMLImExTransform3D::GetFullTransform(::basegfx::B3DHomMatrix& rFullTrans)
{
	rFullTrans.identity();

	const sal_uInt32 nCount = maList.size();
	for(sal_uInt32 a(0L); a < nCount; a++)
	{
		ImpSdXMLExpTransObj3DBase* pObj = maList[a];
		switch(pObj->mnType)
		{
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_X	: 
			{
				rFullTrans.rotate(((ImpSdXMLExpTransObj3DRotateX*)pObj)->mfRotateX, 0.0, 0.0); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Y	: 
			{
				rFullTrans.rotate(0.0, ((ImpSdXMLExpTransObj3DRotateY*)pObj)->mfRotateY, 0.0); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_ROTATE_Z	: 
			{
				rFullTrans.rotate(0.0, 0.0, ((ImpSdXMLExpTransObj3DRotateZ*)pObj)->mfRotateZ); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_SCALE		: 
			{
				const ::basegfx::B3DTuple& rScale = ((ImpSdXMLExpTransObj3DScale*)pObj)->maScale;
				rFullTrans.scale(rScale.getX(), rScale.getY(), rScale.getZ()); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_TRANSLATE	: 
			{
				const ::basegfx::B3DTuple& rTranslate = ((ImpSdXMLExpTransObj3DTranslate*)pObj)->maTranslate;
				rFullTrans.translate(rTranslate.getX(), rTranslate.getY(), rTranslate.getZ()); 
				break;
			}
			case IMP_SDXMLEXP_TRANSOBJ3D_MATRIX		: 
			{
				rFullTrans *= ((ImpSdXMLExpTransObj3DMatrix*)pObj)->maMatrix; 
				break;
			}
			default : 
			{
				DBG_ERROR("SdXMLImExTransform3D: impossible entry!"); 
				break;
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

SdXMLImExViewBox::SdXMLImExViewBox(sal_Int32 nX, sal_Int32 nY, sal_Int32 nW, sal_Int32 nH)
:	mnX( nX ),
	mnY( nY ),
	mnW( nW ),
	mnH( nH )
{
}

// #100617# Asked vincent hardy: svg:viewBox values may be double precision.
SdXMLImExViewBox::SdXMLImExViewBox(const OUString& rNew, const SvXMLUnitConverter& rConv)
:	msString(rNew),
	mnX( 0L ),
	mnY( 0L ),
	mnW( 1000L ),
	mnH( 1000L )
{
	if(msString.getLength())
	{
		const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
		const sal_Int32 nLen(aStr.getLength());
		sal_Int32 nPos(0);

		// skip starting spaces
		Imp_SkipSpaces(aStr, nPos, nLen);
	
		// get mX, #100617# be prepared for doubles
		mnX = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnX));

		// skip spaces and commas
		Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
	
		// get mY, #100617# be prepared for doubles
		mnY = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnY));

		// skip spaces and commas
		Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
	
		// get mW, #100617# be prepared for doubles
		mnW = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnW));

		// skip spaces and commas
		Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
	
		// get mH, #100617# be prepared for doubles
		mnH = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)mnH));
	}
}

const OUString& SdXMLImExViewBox::GetExportString()
{
	OUString aNewString;
	OUString aEmptySpace(sal_Unicode(' '));

	Imp_PutNumberChar(aNewString, mnX);
	aNewString += aEmptySpace;
	
	Imp_PutNumberChar(aNewString, mnY);
	aNewString += aEmptySpace;
	
	Imp_PutNumberChar(aNewString, mnW);
	aNewString += aEmptySpace;
	
	Imp_PutNumberChar(aNewString, mnH);

	// set new string
	msString = aNewString;

	return msString;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

SdXMLImExPointsElement::SdXMLImExPointsElement(drawing::PointSequence* pPoints, 
	const SdXMLImExViewBox& rViewBox,
	const awt::Point& rObjectPos,
	const awt::Size& rObjectSize,
	// #96328#
	const bool bClosed)
:	maPoly( 0L )
{
	DBG_ASSERT(pPoints, "Empty PointSequence handed over to SdXMLImExPointsElement(!)");

	// add polygon to string
	sal_Int32 nCnt(pPoints->getLength());

	// #104076# Convert to string only when at last one point included
	if(nCnt > 0)
	{
		OUString aNewString;
		awt::Point* pArray = pPoints->getArray();

		// last point same? Ignore it.
		// #96328# ...but only when polygon is CLOSED
		if(bClosed && (pArray->X == (pArray + (nCnt - 1))->X) && (pArray->Y == (pArray + (nCnt - 1))->Y))
			nCnt--;

		// object size and ViewBox size different?
		bool bScale(rObjectSize.Width != rViewBox.GetWidth() 
			|| rObjectSize.Height != rViewBox.GetHeight());
		bool bTranslate(rViewBox.GetX() != 0L || rViewBox.GetY() != 0L);

		for(sal_Int32 a(0L); a < nCnt; a++)
		{
			// prepare coordinates
			sal_Int32 nX( pArray->X - rObjectPos.X );
			sal_Int32 nY( pArray->Y - rObjectPos.Y );

			if(bScale && rObjectSize.Width && rObjectSize.Height)
			{
				nX = (nX * rViewBox.GetWidth()) / rObjectSize.Width;
				nY = (nY * rViewBox.GetHeight()) / rObjectSize.Height;
			}

			if(bTranslate)
			{
				nX += rViewBox.GetX();
				nY += rViewBox.GetY();
			}

			// X and comma
			Imp_PutNumberChar(aNewString, nX);
			aNewString += String(sal_Unicode(','));

			// Y and space (not for last)
			Imp_PutNumberChar(aNewString, nY);
			if(a + 1 != nCnt)
				aNewString += String(sal_Unicode(' '));

			// next point
			pArray++;
		}

		// set new string
		msString = aNewString;
	}
}

// #100617# svg:polyline or svg:polygon values may be double precision.
SdXMLImExPointsElement::SdXMLImExPointsElement(const OUString& rNew, 
	const SdXMLImExViewBox& rViewBox,
	const awt::Point& rObjectPos,
	const awt::Size& rObjectSize,
	const SvXMLUnitConverter& rConv)
:	msString( rNew ),
	maPoly( 0L )
{
	// convert string to polygon
	const OUString aStr(msString.getStr(), (sal_uInt16)msString.getLength());
	const sal_Int32 nLen(aStr.getLength());
	sal_Int32 nPos(0);
	sal_Int32 nNumPoints(0L);

	// skip starting spaces
	Imp_SkipSpaces(aStr, nPos, nLen);

	// count points in first loop
	while(nPos < nLen)
	{
		// skip number, #100617# be prepared for doubles
		Imp_SkipDouble(aStr, nPos, nLen);

		// skip spaces and commas
		Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
	
		// skip number, #100617# be prepared for doubles
		Imp_SkipDouble(aStr, nPos, nLen);

		// skip spaces and commas
		Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

		// one more point
		nNumPoints++;
	}

	// second loop
	if(nNumPoints)
	{
        nPos = 0;
        maPoly.realloc(1);
		drawing::PointSequence* pOuterSequence = maPoly.getArray();
		pOuterSequence->realloc(nNumPoints);
		awt::Point* pInnerSequence = pOuterSequence->getArray();

		// object size and ViewBox size different?
		bool bScale(rObjectSize.Width != rViewBox.GetWidth() 
			|| rObjectSize.Height != rViewBox.GetHeight());
		bool bTranslate(rViewBox.GetX() != 0L || rViewBox.GetY() != 0L);

		// skip starting spaces
		Imp_SkipSpaces(aStr, nPos, nLen);
		
		while(nPos < nLen)
		{
			// prepare new parameter pair
			sal_Int32 nX(0L);
			sal_Int32 nY(0L);

			// get mX, #100617# be prepared for doubles
			nX = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)nX));

			// skip spaces and commas
			Imp_SkipSpacesAndCommas(aStr, nPos, nLen);
		
			// get mY, #100617# be prepared for doubles
			nY = FRound(Imp_GetDoubleChar(aStr, nPos, nLen, rConv, (double)nY));

			// skip spaces and commas
			Imp_SkipSpacesAndCommas(aStr, nPos, nLen);

			// prepare parameters
			if(bTranslate)
			{
				nX -= rViewBox.GetX();
				nY -= rViewBox.GetY();
			}

			if(bScale && rViewBox.GetWidth() && rViewBox.GetHeight() )
			{
				nX = (nX * rObjectSize.Width) / rViewBox.GetWidth();
				nY = (nY * rObjectSize.Height) / rViewBox.GetHeight();
			}

			nX += rObjectPos.X;
			nY += rObjectPos.Y;

			// add new point
			*pInnerSequence = awt::Point( nX, nY );
			pInnerSequence++;
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

SdXMLImExSvgDElement::SdXMLImExSvgDElement(const SdXMLImExViewBox& rViewBox)
:	mrViewBox( rViewBox ),
	mbIsClosed( false ),
	mbIsCurve( false ),
	mnLastX( 0L ),
	mnLastY( 0L ),
	maPoly( 0L ),
	maFlag( 0L )
{
}

void Imp_GetPrevPos(awt::Point*& pPrevPos1, 
	drawing::PolygonFlags& aPrevFlag1, 
	const bool bClosed, awt::Point* pPoints, 
	drawing::PolygonFlags* pFlags, const sal_Int32 nPos, 
	const sal_Int32 nCnt, const sal_Int32 nAdd)
{
	if(bClosed)
	{
		pPrevPos1 = pPoints + ((nPos + nCnt - nAdd) % nCnt);
		aPrevFlag1 = *(pFlags + ((nPos + nCnt - nAdd) % nCnt));
	}
	else if(nPos > (nAdd - 1))
	{
		pPrevPos1 = pPoints + (nPos - nAdd);
		aPrevFlag1 = *(pFlags + (nPos - nAdd));
	}
	else
		pPrevPos1 = 0L;
}

void Imp_PrepareCoorExport(sal_Int32& nX, sal_Int32& nY, 
	const awt::Point* pPointArray, const awt::Point& rObjectPos,
	const awt::Size& rObjectSize, const SdXMLImExViewBox& mrViewBox, 
	const bool bScale, const bool bTranslate)
{
	nX = pPointArray->X - rObjectPos.X;
	nY = pPointArray->Y - rObjectPos.Y;

	if(bScale && rObjectSize.Width && rObjectSize.Height )
	{
		nX = (nX * mrViewBox.GetWidth()) / rObjectSize.Width;
		nY = (nY * mrViewBox.GetHeight()) / rObjectSize.Height;
	}

	if(bTranslate)
	{
		nX += mrViewBox.GetX();
		nY += mrViewBox.GetY();
	}
}

//#define TEST_QUADRATIC_CURVES
#ifdef TEST_QUADRATIC_CURVES
// To be able to test quadratic curve code: The code concerning to
// bDoTestHere can be used (see below). Construct shapes which have their control
// points on equal coordinates. When these are written, they can be
// forced to create correct 'Q' and 'T' statements using this flag.
// These may then be tested for import/exporting.
static bool bDoTestHere(true);
#endif // TEST_QUADRATIC_CURVES

void SdXMLImExSvgDElement::AddPolygon(
	drawing::PointSequence* pPoints, 
	drawing::FlagSequence* pFlags,
	const awt::Point& rObjectPos,
	const awt::Size& rObjectSize,
	bool bClosed, bool bRelative)
{
	DBG_ASSERT(pPoints, "Empty PointSequence handed over to SdXMLImExSvgDElement(!)");

	sal_Int32 nCnt(pPoints->getLength());

	// #104076# Convert to string only when at last one point included
	if(nCnt > 0)
	{
		// append polygon to string
		OUString aNewString;
		sal_Unicode aLastCommand = ' ';
		awt::Point* pPointArray = pPoints->getArray();

		// are the flags used at all? If not forget about them
		if(pFlags)
		{
			sal_Int32 nFlagCnt(pFlags->getLength());

			if(nFlagCnt)
			{
				bool bFlagsUsed(false);
				drawing::PolygonFlags* pFlagArray = pFlags->getArray();

				for(sal_Int32 a(0); !bFlagsUsed && a < nFlagCnt; a++)
					if(drawing::PolygonFlags_NORMAL != *pFlagArray++)
						bFlagsUsed = true;

				if(!bFlagsUsed)
					pFlags = 0L;
			}
			else
			{
				pFlags = 0L;
			}
		}

		// object size and ViewBox size different?
		bool bScale(rObjectSize.Width != mrViewBox.GetWidth() 
			|| rObjectSize.Height != mrViewBox.GetHeight());
		bool bTranslate(mrViewBox.GetX() != 0L || mrViewBox.GetY() != 0L);

		// #87202# rework of point reduction:
		// Test for Last point same -> closed, ignore last point. Take
		// some more circumstances in account when looking at curve segments.
		drawing::PolygonFlags* pFlagArray = (pFlags) ? pFlags->getArray() : 0L;
		if((pPointArray->X == (pPointArray + (nCnt - 1))->X) && (pPointArray->Y == (pPointArray + (nCnt - 1))->Y))
		{
			if(pFlags)
			{
				// point needs to be ignored if point before it is
				// NO control point. Else the last point is needed
				// for exporting the last segment of the curve. That means
				// that the last and the first point will be saved double,
				// but SVG does not support a better solution here.
				if(nCnt >= 2 && drawing::PolygonFlags_CONTROL != *(pFlagArray + (nCnt - 2)))
				{
					nCnt--;
				}
			}
			else
			{
				// no curve, ignore last point
				nCnt--;
			}
		}

		// bezier poly, handle curves
		bool  bDidWriteStart(false);

		for(sal_Int32 a(0L); a < nCnt; a++)
		{
			if(!pFlags || drawing::PolygonFlags_CONTROL != *pFlagArray)
			{
				bool bDidWriteAsCurve(false);

				if(bDidWriteStart)
				{
					if(pFlags)
					{
						// real curve point, get previous to see if it's a control point
						awt::Point* pPrevPos1;
						drawing::PolygonFlags aPrevFlag1;

						Imp_GetPrevPos(pPrevPos1, aPrevFlag1, bClosed, pPoints->getArray(), 
							pFlags->getArray(), a, nCnt, 1);

						if(pPrevPos1 && drawing::PolygonFlags_CONTROL == aPrevFlag1)
						{
							// get previous2 to see if it's a control point, too
							awt::Point* pPrevPos2;
							drawing::PolygonFlags aPrevFlag2;

							Imp_GetPrevPos(pPrevPos2, aPrevFlag2, bClosed, pPoints->getArray(), 
								pFlags->getArray(), a, nCnt, 2);

							if(pPrevPos2 && drawing::PolygonFlags_CONTROL == aPrevFlag2)
							{
								// get previous3 to see if it's a curve point and if,
								// if it is fully symmetric or not
								awt::Point* pPrevPos3;
								drawing::PolygonFlags aPrevFlag3;

								Imp_GetPrevPos(pPrevPos3, aPrevFlag3, bClosed, pPoints->getArray(), 
									pFlags->getArray(), a, nCnt, 3);

								if(pPrevPos3)
								{
									// prepare coordinates
									sal_Int32 nX, nY;

									Imp_PrepareCoorExport(nX, nY, pPointArray, rObjectPos, rObjectSize, 
										mrViewBox, bScale, bTranslate);

									// #100617# test if this curve segment may be written as
									// a quadratic bezier
									// That's the case if both control points are in the same place
									// when they are prolonged to the common quadratic control point
									// Left:  P = (3P1 - P0) / 2
									// Right: P = (3P2 - P3) / 2
									bool bIsQuadratic(false);
									const bool bEnableSaveQuadratic(false);

									sal_Int32 nPX_L(FRound((double)((3 * pPrevPos2->X) - pPrevPos3->X) / 2.0));
									sal_Int32 nPY_L(FRound((double)((3 * pPrevPos2->Y) - pPrevPos3->Y) / 2.0));
									sal_Int32 nPX_R(FRound((double)((3 * pPrevPos1->X) - pPointArray->X) / 2.0));
									sal_Int32 nPY_R(FRound((double)((3 * pPrevPos1->Y) - pPointArray->Y) / 2.0));
									sal_Int32 nDist(0);
									
									if(nPX_L != nPX_R)
									{
										nDist += abs(nPX_L - nPX_R);
									}

									if(nPY_L != nPY_R)
									{
										nDist += abs(nPY_L - nPY_R);
									}
									
									if(nDist <= BORDER_INTEGERS_ARE_EQUAL)
									{
										if(bEnableSaveQuadratic)
										{
											bIsQuadratic = true;
										}
									}

#ifdef TEST_QUADRATIC_CURVES
									if(bDoTestHere)
									{
										bIsQuadratic = false;

										if(pPrevPos1->X == pPrevPos2->X && pPrevPos1->Y == pPrevPos2->Y)
											bIsQuadratic = true;
									}
#endif // TEST_QUADRATIC_CURVES

									if(bIsQuadratic)
									{
#ifdef TEST_QUADRATIC_CURVES
										if(bDoTestHere)
										{
											bool bPrevPointIsSymmetric(false);

											if(drawing::PolygonFlags_SYMMETRIC == aPrevFlag3)
											{
												// get previous4 to see if it's a control point
												awt::Point* pPrevPos4;
												drawing::PolygonFlags aPrevFlag4;

												Imp_GetPrevPos(pPrevPos4, aPrevFlag4, bClosed, pPoints->getArray(), 
													pFlags->getArray(), a, nCnt, 4);

												if(drawing::PolygonFlags_CONTROL == aPrevFlag4)
												{
													// okay, prevPos3 is symmetric (c2) and prevPos4
													// is existing control point, the 's' statement can be used
													bPrevPointIsSymmetric = true;
												}
											}

											if(bPrevPointIsSymmetric)
											{
												// write a shorthand/smooth quadratic curveto entry (T)
												if(bRelative)
												{
													if(aLastCommand != sal_Unicode('t'))
														aNewString += OUString(sal_Unicode('t'));

													Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
													Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

													aLastCommand = sal_Unicode('t');
												}
												else
												{
													if(aLastCommand != sal_Unicode('T'))
														aNewString += OUString(sal_Unicode('T'));

													Imp_PutNumberCharWithSpace(aNewString, nX);
													Imp_PutNumberCharWithSpace(aNewString, nY);

													aLastCommand = sal_Unicode('T');
												}
											}
											else
											{
												// prepare coordinates
												sal_Int32 nX1, nY1;
												
												Imp_PrepareCoorExport(nX1, nY1, pPrevPos1, rObjectPos, rObjectSize, 
													mrViewBox, bScale, bTranslate);
												
												// write a quadratic curveto entry (Q)
												if(bRelative)
												{
													if(aLastCommand != sal_Unicode('q'))
														aNewString += OUString(sal_Unicode('q'));

													Imp_PutNumberCharWithSpace(aNewString, nX1 - mnLastX);
													Imp_PutNumberCharWithSpace(aNewString, nY1 - mnLastY);
													Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
													Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

													aLastCommand = sal_Unicode('q');
												}
												else
												{
													if(aLastCommand != sal_Unicode('Q'))
														aNewString += OUString(sal_Unicode('Q'));

													Imp_PutNumberCharWithSpace(aNewString, nX1);
													Imp_PutNumberCharWithSpace(aNewString, nY1);
													Imp_PutNumberCharWithSpace(aNewString, nX);
													Imp_PutNumberCharWithSpace(aNewString, nY);

													aLastCommand = sal_Unicode('Q');
												}
											}
										}
										else
										{
#endif // TEST_QUADRATIC_CURVES
											awt::Point aNewPoint(nPX_L, nPY_L);
											bool bPrevPointIsSmooth(false);

											if(drawing::PolygonFlags_SMOOTH == aPrevFlag3)
											{
												// get previous4 to see if it's a control point
												awt::Point* pPrevPos4;
												drawing::PolygonFlags aPrevFlag4;

												Imp_GetPrevPos(pPrevPos4, aPrevFlag4, bClosed, pPoints->getArray(), 
													pFlags->getArray(), a, nCnt, 4);

												if(drawing::PolygonFlags_CONTROL == aPrevFlag4)
												{
													// okay, prevPos3 is smooth (c1) and prevPos4
													// is existing control point. Test if it's even symmetric
													// and thus the 'T' statement may be used.
													::basegfx::B2DVector aVec1(pPrevPos4->X - pPrevPos3->X, pPrevPos4->Y - pPrevPos3->Y);
													::basegfx::B2DVector aVec2(aNewPoint.X - pPrevPos3->X, aNewPoint.Y - pPrevPos3->Y);
													bool bSameLength(false);
													bool bSameDirection(false);

													// get vector values
													Imp_CalcVectorValues(aVec1, aVec2, bSameLength, bSameDirection);

													if(bSameLength && bSameDirection)
														bPrevPointIsSmooth = true;
												}
											}

											if(bPrevPointIsSmooth)
											{
												// write a shorthand/smooth quadratic curveto entry (T)
												if(bRelative)
												{
													if(aLastCommand != sal_Unicode('t'))
														aNewString += String(sal_Unicode('t'));

													Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
													Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

													aLastCommand = sal_Unicode('t');
												}
												else
												{
													if(aLastCommand != sal_Unicode('T'))
														aNewString += String(sal_Unicode('T'));

													Imp_PutNumberCharWithSpace(aNewString, nX);
													Imp_PutNumberCharWithSpace(aNewString, nY);

													aLastCommand = sal_Unicode('T');
												}
											}
											else
											{
												// prepare coordinates
												sal_Int32 nX1, nY1;
												
												Imp_PrepareCoorExport(nX1, nY1, &aNewPoint, rObjectPos, rObjectSize, 
													mrViewBox, bScale, bTranslate);
												
												// write a quadratic curveto entry (Q)
												if(bRelative)
												{
													if(aLastCommand != sal_Unicode('q'))
														aNewString += String(sal_Unicode('q'));

													Imp_PutNumberCharWithSpace(aNewString, nX1 - mnLastX);
													Imp_PutNumberCharWithSpace(aNewString, nY1 - mnLastY);
													Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
													Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

													aLastCommand = sal_Unicode('q');
												}
												else
												{
													if(aLastCommand != sal_Unicode('Q'))
														aNewString += String(sal_Unicode('Q'));

													Imp_PutNumberCharWithSpace(aNewString, nX1);
													Imp_PutNumberCharWithSpace(aNewString, nY1);
													Imp_PutNumberCharWithSpace(aNewString, nX);
													Imp_PutNumberCharWithSpace(aNewString, nY);

													aLastCommand = sal_Unicode('Q');
												}
											}
#ifdef TEST_QUADRATIC_CURVES
										}
#endif // TEST_QUADRATIC_CURVES
									}
									else
									{
										bool bPrevPointIsSymmetric(false);

										if(drawing::PolygonFlags_SYMMETRIC == aPrevFlag3)
										{
											// get previous4 to see if it's a control point
											awt::Point* pPrevPos4;
											drawing::PolygonFlags aPrevFlag4;

											Imp_GetPrevPos(pPrevPos4, aPrevFlag4, bClosed, pPoints->getArray(), 
												pFlags->getArray(), a, nCnt, 4);

											if(drawing::PolygonFlags_CONTROL == aPrevFlag4)
											{
												// okay, prevPos3 is symmetric (c2) and prevPos4
												// is existing control point, the 's' statement can be used
												bPrevPointIsSymmetric = true;
											}
										}

										// prepare coordinates
										sal_Int32 nX2, nY2;

										Imp_PrepareCoorExport(nX2, nY2, pPrevPos1, rObjectPos, rObjectSize, 
											mrViewBox, bScale, bTranslate);

										if(bPrevPointIsSymmetric)
										{
											// write a shorthand/smooth curveto entry (S)
											if(bRelative)
											{
												if(aLastCommand != sal_Unicode('s'))
													aNewString += String(sal_Unicode('s'));

												Imp_PutNumberCharWithSpace(aNewString, nX2 - mnLastX);
												Imp_PutNumberCharWithSpace(aNewString, nY2 - mnLastY);
												Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
												Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

												aLastCommand = sal_Unicode('s');
											}
											else
											{
												if(aLastCommand != sal_Unicode('S'))
													aNewString += String(sal_Unicode('S'));

												Imp_PutNumberCharWithSpace(aNewString, nX2);
												Imp_PutNumberCharWithSpace(aNewString, nY2);
												Imp_PutNumberCharWithSpace(aNewString, nX);
												Imp_PutNumberCharWithSpace(aNewString, nY);

												aLastCommand = sal_Unicode('S');
											}
										}
										else
										{
											// prepare coordinates
											sal_Int32 nX1, nY1;
			
											Imp_PrepareCoorExport(nX1, nY1, pPrevPos2, rObjectPos, rObjectSize, 
												mrViewBox, bScale, bTranslate);

											// write a curveto entry (C)
											if(bRelative)
											{
												if(aLastCommand != sal_Unicode('c'))
													aNewString += String(sal_Unicode('c'));

												Imp_PutNumberCharWithSpace(aNewString, nX1 - mnLastX);
												Imp_PutNumberCharWithSpace(aNewString, nY1 - mnLastY);
												Imp_PutNumberCharWithSpace(aNewString, nX2 - mnLastX);
												Imp_PutNumberCharWithSpace(aNewString, nY2 - mnLastY);
												Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
												Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

												aLastCommand = sal_Unicode('c');
											}
											else
											{
												if(aLastCommand != sal_Unicode('C'))
													aNewString += String(sal_Unicode('C'));
												
												Imp_PutNumberCharWithSpace(aNewString, nX1);
												Imp_PutNumberCharWithSpace(aNewString, nY1);
												Imp_PutNumberCharWithSpace(aNewString, nX2);
												Imp_PutNumberCharWithSpace(aNewString, nY2);
												Imp_PutNumberCharWithSpace(aNewString, nX);
												Imp_PutNumberCharWithSpace(aNewString, nY);

												aLastCommand = sal_Unicode('C');
											}
										}
									}

									// remember that current point IS written
									bDidWriteAsCurve = true;

									// remember new last position
									mnLastX = nX;
									mnLastY = nY;
								}
							}
						}
					}
				}

				if(!bDidWriteAsCurve)
				{
					// current point not yet written, prepare coordinates
					sal_Int32 nX, nY;
					
					Imp_PrepareCoorExport(nX, nY, pPointArray, rObjectPos, rObjectSize, 
						mrViewBox, bScale, bTranslate);

					if(bDidWriteStart)
					{
						// write as normal point
						if(mnLastX == nX)
						{
							if(bRelative)
							{
								if(aLastCommand != sal_Unicode('v'))
									aNewString += String(sal_Unicode('v'));

								Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

								aLastCommand = sal_Unicode('v');
							}
							else
							{
								if(aLastCommand != sal_Unicode('V'))
									aNewString += String(sal_Unicode('V'));

								Imp_PutNumberCharWithSpace(aNewString, nY);

								aLastCommand = sal_Unicode('V');
							}
						}
						else if(mnLastY == nY)
						{
							if(bRelative)
							{
								if(aLastCommand != sal_Unicode('h'))
									aNewString += String(sal_Unicode('h'));

								Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);

								aLastCommand = sal_Unicode('h');
							}
							else
							{
								if(aLastCommand != sal_Unicode('H'))
									aNewString += String(sal_Unicode('H'));

								Imp_PutNumberCharWithSpace(aNewString, nX);

								aLastCommand = sal_Unicode('H');
							}
						}
						else
						{
							if(bRelative)
							{
								if(aLastCommand != sal_Unicode('l'))
									aNewString += String(sal_Unicode('l'));

								Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
								Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

								aLastCommand = sal_Unicode('l');
							}
							else
							{
								if(aLastCommand != sal_Unicode('L'))
									aNewString += String(sal_Unicode('L'));

								Imp_PutNumberCharWithSpace(aNewString, nX);
								Imp_PutNumberCharWithSpace(aNewString, nY);

								aLastCommand = sal_Unicode('L');
							}
						}
					}
					else
					{
						// write as start point
						if(bRelative)
						{
							aNewString += String(sal_Unicode('m'));

							Imp_PutNumberCharWithSpace(aNewString, nX - mnLastX);
							Imp_PutNumberCharWithSpace(aNewString, nY - mnLastY);

							aLastCommand = sal_Unicode('l');
						}
						else
						{
							aNewString += String(sal_Unicode('M'));

							Imp_PutNumberCharWithSpace(aNewString, nX);
							Imp_PutNumberCharWithSpace(aNewString, nY);

							aLastCommand = sal_Unicode('L');
						}

						// remember start written
						bDidWriteStart = true;
					}

					// remember new last position
					mnLastX = nX;
					mnLastY = nY;
				}
			}

			// next point
			pPointArray++;
			pFlagArray++;
		}

		// close path if closed poly
		if(bClosed)
		{
			if(bRelative)
				aNewString += String(sal_Unicode('z'));
			else
				aNewString += String(sal_Unicode('Z'));
		}

		// append new string
		msString += aNewString;
	}
}

// #100617# Linear double reader
double Imp_ImportDoubleAndSpaces(
	double fRetval, const OUString& rStr, sal_Int32& rPos, 
	const sal_Int32 nLen, const SvXMLUnitConverter& rConv)
{
	fRetval = Imp_GetDoubleChar(rStr, rPos, nLen, rConv, fRetval);
	Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
	return fRetval;
}

// #100617# Allow to read doubles, too. This will need to be changed to
// the usage of Imp_ImportDoubleAndSpaces(...). For now, this is sufficient
// since the interface cannot transport doubles.
sal_Int32 Imp_ImportNumberAndSpaces(
	sal_Int32 nRetval, const OUString& rStr, sal_Int32& rPos, 
	const sal_Int32 nLen, const SvXMLUnitConverter& rConv)
{
	nRetval = FRound(Imp_ImportDoubleAndSpaces(double(nRetval), rStr, rPos, nLen, rConv));
	Imp_SkipSpacesAndCommas(rStr, rPos, nLen);
	return nRetval;
}

void Imp_PrepareCoorImport(sal_Int32& nX, sal_Int32& nY, 
	const awt::Point& rObjectPos, const awt::Size& rObjectSize, 
	const SdXMLImExViewBox& rViewBox, const bool bScale, const bool bTranslate)
{
	if(bTranslate)
	{
		nX -= rViewBox.GetX();
		nY -= rViewBox.GetY();
	}

	if(bScale && rViewBox.GetWidth() && rViewBox.GetHeight())
	{
		nX = (nX * rObjectSize.Width) / rViewBox.GetWidth();
		nY = (nY * rObjectSize.Height) / rViewBox.GetHeight();
	}

	nX += rObjectPos.X;
	nY += rObjectPos.Y;
}

void Imp_AddExportPoints(sal_Int32 nX, sal_Int32 nY, 
	awt::Point* pPoints, drawing::PolygonFlags* pFlags,
	const sal_Int32 nInnerIndex,
	drawing::PolygonFlags eFlag)
{
	if(pPoints)
		pPoints[nInnerIndex] = awt::Point( nX, nY );

	if(pFlags)
		pFlags[nInnerIndex] = eFlag;
}

void Imp_CalcVectorValues(::basegfx::B2DVector& aVec1, ::basegfx::B2DVector& aVec2, bool& bSameLength, bool& bSameDirection)
{
	const sal_Int32 nLen1(FRound(aVec1.getLength()));
	const sal_Int32 nLen2(FRound(aVec2.getLength()));
	aVec1.normalize(); 
	aVec2.normalize();
	aVec1 += aVec2;
	const sal_Int32 nLen3(FRound(aVec1.getLength() * ((nLen1 + nLen2) / 2.0)));

	bSameLength = (abs(nLen1 - nLen2) <= BORDER_INTEGERS_ARE_EQUAL);
	bSameDirection = (nLen3 <= BORDER_INTEGERS_ARE_EQUAL);
}

void Imp_CorrectPolygonFlag(const sal_uInt32 nInnerIndex, const awt::Point* const pInnerSequence,
	drawing::PolygonFlags* const pInnerFlags, const sal_Int32 nX1, const sal_Int32 nY1)
{
	if(nInnerIndex)
	{
		const awt::Point aPPrev1 = pInnerSequence[nInnerIndex - 1];

		if(nInnerIndex > 1)
		{
			const awt::Point aPPrev2 = pInnerSequence[nInnerIndex - 2];
			const drawing::PolygonFlags aFPrev2 = pInnerFlags[nInnerIndex - 2];
			::basegfx::B2DVector aVec1(aPPrev2.X - aPPrev1.X, aPPrev2.Y - aPPrev1.Y);
			::basegfx::B2DVector aVec2(nX1 - aPPrev1.X, nY1 - aPPrev1.Y);
			bool bSameLength(false);
			bool bSameDirection(false);

			// get vector values
			Imp_CalcVectorValues(aVec1, aVec2, bSameLength, bSameDirection);

			if(drawing::PolygonFlags_CONTROL == aFPrev2)
			{
				// point before is a control point
				if(bSameDirection)
				{
					if(bSameLength)
					{
						// set to PolygonFlags_SYMMETRIC
						pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SYMMETRIC;
					}
					else
					{
						// set to PolygonFlags_SMOOTH
						pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SMOOTH;
					}
				}
				else
				{
					// set to PolygonFlags_NORMAL
					pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_NORMAL;
				}
			}
			else
			{
				// point before is a simple curve point
				if(bSameDirection)
				{
					// set to PolygonFlags_SMOOTH
					pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SMOOTH;
				}
				else
				{
					// set to PolygonFlags_NORMAL
					pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_NORMAL;
				}
			}
		}
		else
		{
			// no point before starpoint, set type to PolygonFlags_NORMAL
			pInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_NORMAL;
		}
	}
}

SdXMLImExSvgDElement::SdXMLImExSvgDElement(const OUString& rNew, 
	const SdXMLImExViewBox& rViewBox,
	const awt::Point& rObjectPos,
	const awt::Size& rObjectSize,
	const SvXMLUnitConverter& rConv)
:	msString( rNew ),
	mrViewBox( rViewBox ),
	mbIsClosed( false ),
	mbIsCurve( false ),
	mnLastX( 0L ),
	mnLastY( 0L ),
	maPoly( 0L ),
	maFlag( 0L )
{
	// convert string to polygon
	const OUString aStr(msString.getStr(), msString.getLength());
	const sal_Int32 nLen(aStr.getLength());
	sal_Int32 nPos(0);
	sal_Int32 nNumPolys(0L);
	bool bEllipticalArc(false);

	// object size and ViewBox size different?
	bool bScale(rObjectSize.Width != mrViewBox.GetWidth() 
		|| rObjectSize.Height != mrViewBox.GetHeight());
	bool bTranslate(mrViewBox.GetX() != 0L || mrViewBox.GetY() != 0L);

	// first loop: count polys and get flags
	Imp_SkipSpaces(aStr, nPos, nLen);

	while(nPos < nLen)
	{
		switch(aStr[nPos++])
		{
			case 'Z' :
			case 'z' : 
			{ 
				break; 
			}
			case 'M' :
			case 'm' : 
			{ 
				nNumPolys++; 
				break; 
			}
			case 'S' :
			case 's' :
			case 'C' :
			case 'c' : 
			case 'Q' :
			case 'q' :
			case 'T' :
			case 't' :
			{ 
				mbIsCurve = true; 
				break; 
			}
			case 'L' :
			case 'l' :
			case 'H' :
			case 'h' :
			case 'V' :
			case 'v' :
			{
				// normal, interpreted values. All okay.
				break;
			}
			case 'A' :
			case 'a' :
			{
				// Not yet interpreted value.
				bEllipticalArc = true;
				break;
			}
		}
	}

	DBG_ASSERT(!bEllipticalArc, "XMLIMP: non-interpreted tags in svg:d element!");

	if(nNumPolys)
	{
		// alloc arrays
		maPoly.realloc(nNumPolys);
		if(IsCurve())
			maFlag.realloc(nNumPolys);

		// get outer sequences
		drawing::PointSequence* pOuterSequence = maPoly.getArray();
		drawing::FlagSequence* pOuterFlags = (IsCurve()) ? maFlag.getArray() : 0L;

		// prepare new loop, count
		sal_uInt32 nPointCount(0L);
		nPos = 0;
		Imp_SkipSpaces(aStr, nPos, nLen);

		// #104076# reset closed flag for next to be started polygon
		mbIsClosed = false;

		while(nPos < nLen)
		{
			switch(aStr[nPos])
			{
				case 'z' :
				case 'Z' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					// #104076# remember closed state of current polygon
					mbIsClosed = true;
					
					break;
				}
				case 'm' :
				case 'M' :
				{
					// new poly starts, end-process current poly
					if(nPointCount)
					{
						// #104076# If this partial polygon is closed, use one more point
						// to represent that
						if(mbIsClosed)
						{
							nPointCount++;
						}

						pOuterSequence->realloc(nPointCount);
						pOuterSequence++;
						
						if(pOuterFlags)
						{
							pOuterFlags->realloc(nPointCount);
							pOuterFlags++;
						}
						
						// reset point count for next polygon
						nPointCount = 0L;
					}
					
					// #104076# reset closed flag for next to be started polygon
					mbIsClosed = false;
					
					// NO break, continue in next case
				}
				case 'L' :
				case 'l' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						nPointCount++;
					}
					break;
				}
				case 'H' :
				case 'h' :
				case 'V' :
				case 'v' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						nPointCount++;
					}
					break;
				}
				case 'S' :
				case 's' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						nPointCount += 3;
					}
					break;
				}
				case 'C' :
				case 'c' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						nPointCount += 3;
					}
					break;
				}

				// #100617# quadratic beziers, supported as cubic ones
				case 'Q' :
				case 'q' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						
						// use three points since quadratic is imported as cubic
						nPointCount += 3;
					}
					break;
				}

				// #100617# relative quadratic beziers, supported as cubic ones
				case 'T' :
				case 't' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						
						// use three points since quadratic is imported as cubic
						nPointCount += 3;
					}
					break;
				}

				// #100617# not yet supported: elliptical arc
				case 'A' :
				case 'a' :
				{
					DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (elliptical arc)!");
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
					}
					break;
				}

				default:
				{
					nPos++;
					DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (unknown)!");
					break;
				}
			}
		}

		// alloc last poly (when points used)
		if(nPointCount)
		{
			// #104076# If this partial polygon is closed, use one more point
			// to represent that
			if(mbIsClosed)
			{
				nPointCount++;
			}

			pOuterSequence->realloc(nPointCount);
			pOuterSequence++;

			if(pOuterFlags)
			{
				pOuterFlags->realloc(nPointCount);
				pOuterFlags++;
			}
		}

		// set pointers back
		pOuterSequence = maPoly.getArray();
		pOuterFlags = (IsCurve()) ? maFlag.getArray() : 0L;
		awt::Point* pNotSoInnerSequence = 0L;
		drawing::PolygonFlags* pNotSoInnerFlags = 0L;
		sal_uInt32 nInnerIndex(0L);

		// prepare new loop, read points
		nPos = 0;
		Imp_SkipSpaces(aStr, nPos, nLen);

		// #104076# reset closed flag for next to be started polygon
		mbIsClosed = false;

		while(nPos < nLen)
		{
			bool bRelative(false);

			switch(aStr[nPos])
			{
				case 'z' :
				case 'Z' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					// #104076# remember closed state of current polygon
					mbIsClosed = true;

					// closed: add first point again
					// sal_Int32 nX(pInnerSequence[0].X);
					// sal_Int32 nY(pInnerSequence[0].Y);
					// Imp_AddExportPoints(nX, nY, pInnerSequence, pInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
					
					break;
				}
				
				case 'm' :
				{
					bRelative = true;
				}
				case 'M' :
				{
					// #104076# end-process current poly
					if(mbIsClosed)
					{
						if(pNotSoInnerSequence)
						{
							// closed: add first point again
							sal_Int32 nX(pNotSoInnerSequence[0].X);
							sal_Int32 nY(pNotSoInnerSequence[0].Y);
							Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
						}

						// reset closed flag for next to be started polygon
						mbIsClosed = false;
					}

					// next poly
					pNotSoInnerSequence = pOuterSequence->getArray();
					pOuterSequence++;

					if(pOuterFlags)
					{
						pNotSoInnerFlags = pOuterFlags->getArray();
						pOuterFlags++;
					}

					nInnerIndex = 0L;

					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
						{
							nX += mnLastX;
							nY += mnLastY;
						}

						// set last position
						mnLastX = nX;
						mnLastY = nY;
						
						// calc transform and add point and flag
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
					}
					break;
				}

				case 'l' :
				{
					bRelative = true;
				}
				case 'L' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);
					
					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
						{
							nX += mnLastX;
							nY += mnLastY;
						}

						// set last position
						mnLastX = nX;
						mnLastY = nY;
						
						// calc transform and add point and flag
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
					}
					break;
				}
				
				case 'h' :
				{
					bRelative = true;
				}
				case 'H' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
						sal_Int32 nY(mnLastY);

						if(bRelative)
							nX += mnLastX;

						// set last position
						mnLastX = nX;
						
						// calc transform and add point and flag
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
					}
					break;
				}
				
				case 'v' :
				{
					bRelative = true;
				}
				case 'V' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						sal_Int32 nX(mnLastX);
						sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
							nY += mnLastY;

						// set last position
						mnLastY = nY;
						
						// calc transform and add point and flag
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
					}
					break;
				}
				
				case 's' :
				{
					bRelative = true;
				}
				case 'S' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						sal_Int32 nX1;
						sal_Int32 nY1;
                        sal_Int32 nX2(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY2(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
						{
							nX2 += mnLastX;
							nY2 += mnLastY;
							nX += mnLastX;
							nY += mnLastY;
						}

						// set last position
						mnLastX = nX;
						mnLastY = nY;

						// calc transform for new points
						Imp_PrepareCoorImport(nX2, nY2, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);

						// one more thing is known: the previous real point is PolygonFlags_SYMMETRIC
						// and the Point X1,Y1 can be constructed by mirroring the point before it.
						nX1 = nX2;
						nY1 = nY2;
						if(nInnerIndex)
						{
							awt::Point aPPrev1 = pNotSoInnerSequence[nInnerIndex - 1];

							if(nInnerIndex > 1)
							{
								awt::Point aPPrev2 = pNotSoInnerSequence[nInnerIndex - 2];
								nX1 = aPPrev1.X -(aPPrev2.X - aPPrev1.X);
								nY1 = aPPrev1.Y -(aPPrev2.Y - aPPrev1.Y);
							}

							// set curve point to symmetric
							pNotSoInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SYMMETRIC;
						}

						// add calculated control point
						Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);

						// add new points and set flags
						Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
					}
					break;
				}
				
				case 'c' :
				{
					bRelative = true;
				}
				case 'C' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
                        sal_Int32 nX1(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY1(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nX2(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY2(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
						{
							nX1 += mnLastX;
							nY1 += mnLastY;
							nX2 += mnLastX;
							nY2 += mnLastY;
							nX += mnLastX;
							nY += mnLastY;
						}

						// set last position
						mnLastX = nX;
						mnLastY = nY;

						// calc transform for new points
						Imp_PrepareCoorImport(nX1, nY1, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_PrepareCoorImport(nX2, nY2, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);

						// correct polygon flag for previous point
						Imp_CorrectPolygonFlag(nInnerIndex, pNotSoInnerSequence, pNotSoInnerFlags, nX1, nY1);

						// add new points and set flags
						Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
					}
					break;
				}
				
				// #100617# quadratic beziers are imported as cubic
				case 'q' :
				{
					bRelative = true;
				}
				case 'Q' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
                        sal_Int32 nXX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nYY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
						{
							nXX += mnLastX;
							nYY += mnLastY;
							nX += mnLastX;
							nY += mnLastY;
						}

						// set last position
						mnLastX = nX;
						mnLastY = nY;

						// calc transform for new points
						Imp_PrepareCoorImport(nXX, nYY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);
						
						// calculate X1,X2
						awt::Point aPPrev1 = (nInnerIndex) ? pNotSoInnerSequence[nInnerIndex-1] : pNotSoInnerSequence[0];
						sal_Int32 nX1 = FRound((double)((nXX * 2) + aPPrev1.X) / 3.0);
						sal_Int32 nY1 = FRound((double)((nYY * 2) + aPPrev1.Y) / 3.0);
						sal_Int32 nX2 = FRound((double)((nXX * 2) + nX) / 3.0);
						sal_Int32 nY2 = FRound((double)((nYY * 2) + nY) / 3.0);

						// correct polygon flag for previous point
						Imp_CorrectPolygonFlag(nInnerIndex, pNotSoInnerSequence, pNotSoInnerFlags, nX1, nY1);
						
						// add new points and set flags
						Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
					}
					break;
				}
				
				// #100617# relative quadratic beziers are imported as cubic
				case 't' :
				{
					bRelative = true;
				}
				case 'T' :
				{
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						sal_Int32 nXX;
						sal_Int32 nYY;
                        sal_Int32 nX(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));
                        sal_Int32 nY(Imp_ImportNumberAndSpaces(0, aStr, nPos, nLen, rConv));

						if(bRelative)
						{
							nX += mnLastX;
							nY += mnLastY;
						}

						// set last position
						mnLastX = nX;
						mnLastY = nY;

						// calc transform for new points
						Imp_PrepareCoorImport(nX, nY, rObjectPos, rObjectSize, mrViewBox, bScale, bTranslate);

						// one more thing is known: the previous real point is PolygonFlags_SYMMETRIC
						// and the Point X1,Y1 can be constructed by mirroring the point before it.
						nXX = nX;
						nYY = nY;
						awt::Point aPPrev1 = pNotSoInnerSequence[0];
						
						if(nInnerIndex)
						{
							aPPrev1 = pNotSoInnerSequence[nInnerIndex - 1];

							if(nInnerIndex > 1)
							{
								awt::Point aPPrev2 = pNotSoInnerSequence[nInnerIndex - 2];
								nXX = aPPrev1.X -(aPPrev2.X - aPPrev1.X);
								nYY = aPPrev1.Y -(aPPrev2.Y - aPPrev1.Y);
							}

							// set curve point to smooth here, since length
							// is changed and thus only c1 can be used.
							pNotSoInnerFlags[nInnerIndex - 1] = drawing::PolygonFlags_SMOOTH;
						}

						// calculate X1,X2
						sal_Int32 nX1 = FRound((double)((nXX * 2) + aPPrev1.X) / 3.0);
						sal_Int32 nY1 = FRound((double)((nYY * 2) + aPPrev1.Y) / 3.0);
						sal_Int32 nX2 = FRound((double)((nXX * 2) + nX) / 3.0);
						sal_Int32 nY2 = FRound((double)((nYY * 2) + nY) / 3.0);

						// correct polygon flag for previous point
						Imp_CorrectPolygonFlag(nInnerIndex, pNotSoInnerSequence, pNotSoInnerFlags, nX1, nY1);
						
						// add new points and set flags
						Imp_AddExportPoints(nX1, nY1, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX2, nY2, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_CONTROL);
						Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_SMOOTH);
					}
					break;
				}

				// #100617# not yet supported: elliptical arc
				case 'A' :
				case 'a' :
				{
					DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (elliptical arc)!");
					nPos++;
					Imp_SkipSpaces(aStr, nPos, nLen);

					while(nPos < nLen && Imp_IsOnNumberChar(aStr, nPos))
					{
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipNumberAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
						Imp_SkipDoubleAndSpacesAndCommas(aStr, nPos, nLen);
					}
					break;
				}

				default:
				{
					nPos++;
					DBG_ERROR("XMLIMP: non-interpreted tags in svg:d element (unknown)!");
					break;
				}
			}
		}

		// #104076# end-process closed state of last poly
		if(mbIsClosed)
		{
			if(pNotSoInnerSequence)
			{
				// closed: add first point again
				sal_Int32 nX(pNotSoInnerSequence[0].X);
				sal_Int32 nY(pNotSoInnerSequence[0].Y);
				Imp_AddExportPoints(nX, nY, pNotSoInnerSequence, pNotSoInnerFlags, nInnerIndex++, drawing::PolygonFlags_NORMAL);
			}
		}

		// #87202# If it's a curve and it's closed the last point maybe too much
		// and just exported since SVG does not allow special handling of same
		// start and end point, remove this last point.
		// Evtl. correct the last curve flags, too.
		if(IsCurve() && IsClosed())
		{
			// make one more loop over the PolyPolygon
			pOuterSequence = maPoly.getArray();
			pOuterFlags = maFlag.getArray();
			sal_Int32 nOuterCnt(maPoly.getLength());

			for(sal_Int32 a(0); a < nOuterCnt; a++)
			{
				// get Polygon pointers
				awt::Point* pInnerSequence = pOuterSequence->getArray();
				drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
				sal_Int32 nInnerCnt(pOuterSequence->getLength());

				while( nInnerCnt >= 2
					&& ((pInnerSequence + (nInnerCnt - 2))->X == (pInnerSequence + (nInnerCnt - 1))->X) 
					&& ((pInnerSequence + (nInnerCnt - 2))->Y == (pInnerSequence + (nInnerCnt - 1))->Y)
					&& drawing::PolygonFlags_CONTROL != *(pInnerFlags + (nInnerCnt - 2)))
				{
					// remove last point from array
					pOuterSequence->realloc(nInnerCnt - 1);
					pOuterFlags->realloc(nInnerCnt - 1);

					// get new pointers
					pInnerSequence = pOuterSequence->getArray();
					pInnerFlags = pOuterFlags->getArray();
					nInnerCnt = pOuterSequence->getLength();
				}

				// now evtl. correct the last curve flags
				if(nInnerCnt >= 4)
				{
					if(	pInnerSequence->X == (pInnerSequence + (nInnerCnt - 1))->X
						&& pInnerSequence->Y == (pInnerSequence + (nInnerCnt - 1))->Y
						&& drawing::PolygonFlags_CONTROL == *(pInnerFlags + 1)
						&& drawing::PolygonFlags_CONTROL == *(pInnerFlags + (nInnerCnt - 2)))
					{
						awt::Point aPrev = *(pInnerSequence + (nInnerCnt - 2));
						awt::Point aCurr = *pInnerSequence;
						awt::Point aNext = *(pInnerSequence + 1);
						::basegfx::B2DVector aVec1(aPrev.X - aCurr.X, aPrev.Y - aCurr.Y);
						::basegfx::B2DVector aVec2(aNext.X - aCurr.X, aNext.Y - aCurr.Y);
						bool bSameLength(false);
						bool bSameDirection(false);

						// get vector values
						Imp_CalcVectorValues(aVec1, aVec2, bSameLength, bSameDirection);

						// set correct flag value
						if(bSameDirection)
						{
							if(bSameLength)
							{
								// set to PolygonFlags_SYMMETRIC
								*pInnerFlags = drawing::PolygonFlags_SYMMETRIC;
								*(pInnerFlags + (nInnerCnt - 1)) = drawing::PolygonFlags_SYMMETRIC;
							}
							else
							{
								// set to PolygonFlags_SMOOTH
								*pInnerFlags = drawing::PolygonFlags_SMOOTH;
								*(pInnerFlags + (nInnerCnt - 1)) = drawing::PolygonFlags_SMOOTH;
							}
						}
						else
						{
							// set to PolygonFlags_NORMAL
							*pInnerFlags = drawing::PolygonFlags_NORMAL;
							*(pInnerFlags + (nInnerCnt - 1)) = drawing::PolygonFlags_NORMAL;
						}
					}
				}
				
				// switch to next Polygon
				pOuterSequence++;
				pOuterFlags++;
			}
		}
	}
}

// eof
