/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
#include <svx/svdoashp.hxx>
#include "svx/unoapi.hxx"
#include <svx/unoshape.hxx>
#include <ucbhelper/content.hxx>
#include <ucbhelper/contentbroker.hxx>
#include <unotools/datetime.hxx>
#include <sfx2/lnkbase.hxx>
#include <tools/urlobj.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/drawing/XCustomShapeEngine.hpp>
#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/awt/Rectangle.hpp>
#include "unopolyhelper.hxx"
#include <comphelper/processfactory.hxx>
#include <svl/urihelper.hxx>
#include <com/sun/star/uno/Sequence.h>
#include <svx/svdogrp.hxx>
#include <vcl/salbtype.hxx>		// FRound
#include <svx/svddrag.hxx>
#include <svx/xpool.hxx>
#include <svx/xpoly.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdpage.hxx>
#include "svx/svditer.hxx"
#include <svx/svdobj.hxx>
#include <svx/svdtrans.hxx>
#include <svx/svdetc.hxx>
#include <svx/svdattrx.hxx>  // NotPersistItems
#include <svx/svdoedge.hxx>  // #32383# Die Verbinder nach Move nochmal anbroadcasten
#include "svx/svdglob.hxx"   // StringCache
#include "svx/svdstr.hrc"    // Objektname
#include <editeng/eeitem.hxx>
#include "editeng/editstat.hxx"
#include <svx/svdoutl.hxx>
#include <editeng/outlobj.hxx>
#include <svx/sdtfchim.hxx>
#include "../svx/EnhancedCustomShapeGeometry.hxx"
#include "../svx/EnhancedCustomShapeTypeNames.hxx"
#include "../svx/EnhancedCustomShape2d.hxx"
#include <com/sun/star/beans/PropertyValues.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
#include <editeng/writingmodeitem.hxx>
#include <svx/xlnclit.hxx>
#include <svx/svxids.hrc>
#include <svl/whiter.hxx>
#include <svx/sdr/properties/customshapeproperties.hxx>
#include <svx/sdr/contact/viewcontactofsdrobjcustomshape.hxx>
#include <svx/xlnclit.hxx>
#include <svx/xlntrit.hxx>
#include <svx/xfltrit.hxx>
#include <svx/xflclit.hxx>
#include <svx/xflgrit.hxx>
#include <svx/xflhtit.hxx>
#include <svx/xbtmpit.hxx>
#include <vcl/bmpacc.hxx>
#include <svx/svdview.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

// #104018# replace macros above with type-safe methods
inline double ImplTwipsToMM(double fVal) { return (fVal * (127.0 / 72.0)); }
inline double ImplMMToTwips(double fVal) { return (fVal * (72.0 / 127.0)); }

using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::drawing;

static MSO_SPT ImpGetCustomShapeType( const SdrObjCustomShape& rCustoShape )
{
	MSO_SPT eRetValue = mso_sptNil;

	rtl::OUString aEngine( ( (SdrCustomShapeEngineItem&)rCustoShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE ) ).GetValue() );
	if ( !aEngine.getLength() || aEngine.equalsAscii( "com.sun.star.drawing.EnhancedCustomShapeEngine" ) )
	{
		rtl::OUString sShapeType;
		const rtl::OUString	sType( RTL_CONSTASCII_USTRINGPARAM ( "Type" ) );
		SdrCustomShapeGeometryItem& rGeometryItem( (SdrCustomShapeGeometryItem&)rCustoShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
		Any* pAny = rGeometryItem.GetPropertyValueByName( sType );
		if ( pAny && ( *pAny >>= sShapeType ) )
			eRetValue = EnhancedCustomShapeTypeNames::Get( sShapeType );
	}
	return eRetValue;
};

static sal_Bool ImpVerticalSwitch( const SdrObjCustomShape& rCustoShape )
{
	sal_Bool bRet = sal_False;
	MSO_SPT eShapeType( ImpGetCustomShapeType( rCustoShape ) );
	switch( eShapeType )
	{
		case mso_sptAccentBorderCallout90 :		// 2 ortho
		case mso_sptBorderCallout1 :			// 2 diag
		case mso_sptBorderCallout2 :			// 3
		{
			bRet = sal_True;
		}
		break;
/*
		case mso_sptCallout1 :
		case mso_sptAccentCallout1 :
		case mso_sptAccentBorderCallout1 :
		case mso_sptBorderCallout90 :
		case mso_sptCallout90 :
		case mso_sptAccentCallout90 :
		case mso_sptCallout2 :
		case mso_sptCallout3 :
		case mso_sptAccentCallout2 :
		case mso_sptAccentCallout3 :
		case mso_sptBorderCallout3 :
		case mso_sptAccentBorderCallout2 :
		case mso_sptAccentBorderCallout3 :
*/
		default: break;
	}
	return bRet;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// #i37011# create a clone with all attributes changed to shadow attributes
// and translation executed, too.
SdrObject* ImpCreateShadowObjectClone(const SdrObject& rOriginal, const SfxItemSet& rOriginalSet)
{
	SdrObject* pRetval = 0L;
	const sal_Bool bShadow(((SdrShadowItem&)rOriginalSet.Get(SDRATTR_SHADOW)).GetValue());

	if(bShadow)
	{
		// create a shadow representing object
		const sal_Int32 nXDist(((SdrShadowXDistItem&)(rOriginalSet.Get(SDRATTR_SHADOWXDIST))).GetValue());
		const sal_Int32 nYDist(((SdrShadowYDistItem&)(rOriginalSet.Get(SDRATTR_SHADOWYDIST))).GetValue());
		const ::Color aShadowColor(((SdrShadowColorItem&)(rOriginalSet.Get(SDRATTR_SHADOWCOLOR))).GetColorValue());
		const sal_uInt16 nShadowTransparence(((SdrShadowTransparenceItem&)(rOriginalSet.Get(SDRATTR_SHADOWTRANSPARENCE))).GetValue());
		pRetval = rOriginal.Clone();
		DBG_ASSERT(pRetval, "ImpCreateShadowObjectClone: Could not clone object (!)");

		// look for used stuff
		SdrObjListIter aIterator(rOriginal);
		sal_Bool bLineUsed(sal_False);
		sal_Bool bAllFillUsed(sal_False);
		sal_Bool bSolidFillUsed(sal_False);
		sal_Bool bGradientFillUsed(sal_False);
		sal_Bool bHatchFillUsed(sal_False);
		sal_Bool bBitmapFillUsed(sal_False);

		while(aIterator.IsMore())
		{
			SdrObject* pObj = aIterator.Next();
			XFillStyle eFillStyle = ((XFillStyleItem&)(pObj->GetMergedItem(XATTR_FILLSTYLE))).GetValue();

			if(!bLineUsed)
			{
				XLineStyle eLineStyle = ((XLineStyleItem&)(pObj->GetMergedItem(XATTR_LINESTYLE))).GetValue();

				if(XLINE_NONE != eLineStyle)
				{
					bLineUsed = sal_True;
				}
			}

			if(!bAllFillUsed)
			{
				if(!bSolidFillUsed && XFILL_SOLID == eFillStyle)
				{
					bSolidFillUsed = sal_True;
					bAllFillUsed = (bSolidFillUsed || bGradientFillUsed || bHatchFillUsed || bBitmapFillUsed);
				}
				if(!bGradientFillUsed && XFILL_GRADIENT == eFillStyle)
				{
					bGradientFillUsed = sal_True;
					bAllFillUsed = (bSolidFillUsed || bGradientFillUsed || bHatchFillUsed || bBitmapFillUsed);
				}
				if(!bHatchFillUsed && XFILL_HATCH == eFillStyle)
				{
					bHatchFillUsed = sal_True;
					bAllFillUsed = (bSolidFillUsed || bGradientFillUsed || bHatchFillUsed || bBitmapFillUsed);
				}
				if(!bBitmapFillUsed && XFILL_BITMAP == eFillStyle)
				{
					bBitmapFillUsed = sal_True;
					bAllFillUsed = (bSolidFillUsed || bGradientFillUsed || bHatchFillUsed || bBitmapFillUsed);
				}
			}
		}

		// translate to shadow coordinates
		pRetval->NbcMove(Size(nXDist, nYDist));

		// set items as needed
		SfxItemSet aTempSet(rOriginalSet);

		// SJ: #40108# :-(  if a SvxWritingModeItem (Top->Bottom) is set the text object
		// is creating a paraobject, but paraobjects can not be created without model. So
		// we are preventing the crash by setting the writing mode always left to right,
		// this is not bad since our shadow geometry does not contain text.
        aTempSet.Put( SvxWritingModeItem( com::sun::star::text::WritingMode_LR_TB, SDRATTR_TEXTDIRECTION ) );

		// no shadow
		aTempSet.Put(SdrShadowItem(sal_False));
		aTempSet.Put(SdrShadowXDistItem(0L));
		aTempSet.Put(SdrShadowYDistItem(0L));

		// line color and transparence like shadow
		if(bLineUsed)
		{
			aTempSet.Put(XLineColorItem(String(), aShadowColor));
			aTempSet.Put(XLineTransparenceItem(nShadowTransparence));
		}

		// fill color and transparence like shadow
		if(bSolidFillUsed)
		{
			aTempSet.Put(XFillColorItem(String(), aShadowColor));
			aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
		}

		// gradient and transparence like shadow
		if(bGradientFillUsed)
		{
			XGradient aGradient(((XFillGradientItem&)(rOriginalSet.Get(XATTR_FILLGRADIENT))).GetGradientValue());
			sal_uInt8 nStartLuminance(aGradient.GetStartColor().GetLuminance());
			sal_uInt8 nEndLuminance(aGradient.GetEndColor().GetLuminance());

			if(aGradient.GetStartIntens() != 100)
			{
				nStartLuminance = (sal_uInt8)(nStartLuminance * ((double)aGradient.GetStartIntens() / 100.0));
			}

			if(aGradient.GetEndIntens() != 100)
			{
				nEndLuminance = (sal_uInt8)(nEndLuminance * ((double)aGradient.GetEndIntens() / 100.0));
			}

            ::Color aStartColor(
				(sal_uInt8)((nStartLuminance * aShadowColor.GetRed()) / 256),
				(sal_uInt8)((nStartLuminance * aShadowColor.GetGreen()) / 256),
				(sal_uInt8)((nStartLuminance * aShadowColor.GetBlue()) / 256));

            ::Color aEndColor(
				(sal_uInt8)((nEndLuminance * aShadowColor.GetRed()) / 256),
				(sal_uInt8)((nEndLuminance * aShadowColor.GetGreen()) / 256),
				(sal_uInt8)((nEndLuminance * aShadowColor.GetBlue()) / 256));

			aGradient.SetStartColor(aStartColor);
			aGradient.SetEndColor(aEndColor);
			aTempSet.Put(XFillGradientItem(aTempSet.GetPool(), aGradient));
			aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
		}

		// hatch and transparence like shadow
		if(bHatchFillUsed)
		{
			XHatch aHatch(((XFillHatchItem&)(rOriginalSet.Get(XATTR_FILLHATCH))).GetHatchValue());
			aHatch.SetColor(aShadowColor);
			aTempSet.Put(XFillHatchItem(aTempSet.GetPool(), aHatch));
			aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
		}

		// bitmap and transparence like shadow
		if(bBitmapFillUsed)
		{
            GraphicObject aGraphicObject(((XFillBitmapItem&)(rOriginalSet.Get(XATTR_FILLBITMAP))).GetGraphicObject());
            const BitmapEx aBitmapEx(aGraphicObject.GetGraphic().GetBitmapEx());
			Bitmap aBitmap(aBitmapEx.GetBitmap());

			if(!aBitmap.IsEmpty())
			{
    			BitmapReadAccess* pReadAccess = aBitmap.AcquireReadAccess();

                if(pReadAccess)
				{
					Bitmap aDestBitmap(aBitmap.GetSizePixel(), 24L);
					BitmapWriteAccess* pWriteAccess = aDestBitmap.AcquireWriteAccess();

					if(pWriteAccess)
					{
						for(sal_Int32 y(0L); y < pReadAccess->Height(); y++)
						{
							for(sal_Int32 x(0L); x < pReadAccess->Width(); x++)
							{
								sal_uInt16 nLuminance((sal_uInt16)pReadAccess->GetLuminance(y, x) + 1);
								const BitmapColor aDestColor(
									(sal_uInt8)((nLuminance * (sal_uInt16)aShadowColor.GetRed()) >> 8L),
									(sal_uInt8)((nLuminance * (sal_uInt16)aShadowColor.GetGreen()) >> 8L),
									(sal_uInt8)((nLuminance * (sal_uInt16)aShadowColor.GetBlue()) >> 8L));
								pWriteAccess->SetPixel(y, x, aDestColor);
							}
						}

						aDestBitmap.ReleaseAccess(pWriteAccess);
					}

					aBitmap.ReleaseAccess(pReadAccess);

                    if(aBitmapEx.IsTransparent())
                    {
                        if(aBitmapEx.IsAlpha())
                        {
                            aGraphicObject.SetGraphic(Graphic(BitmapEx(aDestBitmap, aBitmapEx.GetAlpha())));
                        }
                        else
                        {
                            aGraphicObject.SetGraphic(Graphic(BitmapEx(aDestBitmap, aBitmapEx.GetMask())));
                        }
                    }
                    else
                    {
                        aGraphicObject.SetGraphic(Graphic(aDestBitmap));
                    }
				}
			}

			aTempSet.Put(XFillBitmapItem(aTempSet.GetPool(), aGraphicObject));
			aTempSet.Put(XFillTransparenceItem(nShadowTransparence));
		}

		// set attributes and paint shadow object
		pRetval->SetMergedItemSet( aTempSet );
	}
	return pRetval;
}

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

Reference< XCustomShapeEngine > SdrObjCustomShape::GetCustomShapeEngine( const SdrObjCustomShape* pCustomShape )
{
	Reference< XCustomShapeEngine > xCustomShapeEngine;
	String aEngine(((SdrCustomShapeEngineItem&)pCustomShape->GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE )).GetValue());
	if ( !aEngine.Len() )
		aEngine = String( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.drawing.EnhancedCustomShapeEngine" ) );

	Reference< XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );

	Reference< XShape > aXShape = GetXShapeForSdrObject( (SdrObjCustomShape*)pCustomShape );
	if ( aXShape.is() )
	{
		if ( aEngine.Len() && xFactory.is() )
		{
			Sequence< Any > aArgument( 1 );
			Sequence< PropertyValue > aPropValues( 1 );
			aPropValues[ 0 ].Name = rtl::OUString::createFromAscii( "CustomShape" );
			aPropValues[ 0 ].Value <<= aXShape;
			aArgument[ 0 ] <<= aPropValues;
			Reference< XInterface > xInterface( xFactory->createInstanceWithArguments( aEngine, aArgument ) );
			if ( xInterface.is() )
				xCustomShapeEngine = Reference< XCustomShapeEngine >( xInterface, UNO_QUERY );
		}
	}
	return xCustomShapeEngine;
}
const SdrObject* SdrObjCustomShape::GetSdrObjectFromCustomShape() const
{
	if ( !mXRenderedCustomShape.is() )
	{
		Reference< XCustomShapeEngine > xCustomShapeEngine( GetCustomShapeEngine( this ) );
		if ( xCustomShapeEngine.is() )
			((SdrObjCustomShape*)this)->mXRenderedCustomShape = xCustomShapeEngine->render();
	}
	SdrObject* pRenderedCustomShape = mXRenderedCustomShape.is()
				? GetSdrObjectFromXShape( mXRenderedCustomShape )
				: NULL;
	return pRenderedCustomShape;
}

// #i37011# Shadow geometry creation
const SdrObject* SdrObjCustomShape::GetSdrObjectShadowFromCustomShape() const
{
	if(!mpLastShadowGeometry)
	{
		const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
		if(pSdrObject)
		{
			const SfxItemSet& rOriginalSet = GetObjectItemSet();
			const sal_Bool bShadow(((SdrShadowItem&)rOriginalSet.Get( SDRATTR_SHADOW )).GetValue());

			if(bShadow)
			{
				// create a clone with all attributes changed to shadow attributes
				// and translation executed, too.
				((SdrObjCustomShape*)this)->mpLastShadowGeometry = ImpCreateShadowObjectClone(*pSdrObject, rOriginalSet);
			}
		}
	}

	return mpLastShadowGeometry;
}

sal_Bool SdrObjCustomShape::IsTextPath() const
{
	const rtl::OUString	sTextPath( RTL_CONSTASCII_USTRINGPARAM ( "TextPath" ) );
	sal_Bool bTextPathOn = sal_False;
	SdrCustomShapeGeometryItem& rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
	Any* pAny = rGeometryItem.GetPropertyValueByName( sTextPath, sTextPath );
	if ( pAny )
		*pAny >>= bTextPathOn;
	return bTextPathOn;
}

sal_Bool SdrObjCustomShape::UseNoFillStyle() const
{
	sal_Bool bRet = sal_False;
	rtl::OUString sShapeType;
	const rtl::OUString	sType( RTL_CONSTASCII_USTRINGPARAM ( "Type" ) );
	SdrCustomShapeGeometryItem& rGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
	Any* pAny = rGeometryItem.GetPropertyValueByName( sType );
	if ( pAny )
		*pAny >>= sShapeType;
	bRet = IsCustomShapeFilledByDefault( EnhancedCustomShapeTypeNames::Get( sType ) ) == 0;

	return bRet;
}

sal_Bool SdrObjCustomShape::IsMirroredX() const
{
	sal_Bool bMirroredX = sal_False;
	SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
	const rtl::OUString	sMirroredX( RTL_CONSTASCII_USTRINGPARAM ( "MirroredX" ) );
	com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredX );
	if ( pAny )
		*pAny >>= bMirroredX;
	return bMirroredX;
}
sal_Bool SdrObjCustomShape::IsMirroredY() const
{
	sal_Bool bMirroredY = sal_False;
	SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
	const rtl::OUString	sMirroredY( RTL_CONSTASCII_USTRINGPARAM ( "MirroredY" ) );
	com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredY );
	if ( pAny )
		*pAny >>= bMirroredY;
	return bMirroredY;
}
void SdrObjCustomShape::SetMirroredX( const sal_Bool bMirrorX )
{
	SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
	const rtl::OUString	sMirroredX( RTL_CONSTASCII_USTRINGPARAM ( "MirroredX" ) );
	//com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredX );
	PropertyValue aPropVal;
	aPropVal.Name = sMirroredX;
	aPropVal.Value <<= bMirrorX;
	aGeometryItem.SetPropertyValue( aPropVal );
	SetMergedItem( aGeometryItem );
}
void SdrObjCustomShape::SetMirroredY( const sal_Bool bMirrorY )
{
	SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
	const rtl::OUString	sMirroredY( RTL_CONSTASCII_USTRINGPARAM ( "MirroredY" ) );
	//com::sun::star::uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sMirroredY );
	PropertyValue aPropVal;
	aPropVal.Name = sMirroredY;
	aPropVal.Value <<= bMirrorY;
	aGeometryItem.SetPropertyValue( aPropVal );
	SetMergedItem( aGeometryItem );
}

double SdrObjCustomShape::GetObjectRotation() const
{
	return fObjectRotation;
}

double SdrObjCustomShape::GetExtraTextRotation() const
{
	const com::sun::star::uno::Any* pAny;
	SdrCustomShapeGeometryItem& rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
	const rtl::OUString sTextRotateAngle( RTL_CONSTASCII_USTRINGPARAM ( "TextRotateAngle" ) );
	pAny = rGeometryItem.GetPropertyValueByName( sTextRotateAngle );
	double fExtraTextRotateAngle = 0.0;
	if ( pAny )
		*pAny >>= fExtraTextRotateAngle;
	return fExtraTextRotateAngle;
}
sal_Bool SdrObjCustomShape::GetTextBounds( Rectangle& rTextBound ) const
{
	sal_Bool bRet = sal_False;
	Reference< XCustomShapeEngine > xCustomShapeEngine( GetCustomShapeEngine( this ) );	// a candidate for being cached
	if ( xCustomShapeEngine.is() )
	{
		awt::Rectangle aR( xCustomShapeEngine->getTextBounds() );
		if ( aR.Width || aR.Height )
		{
			rTextBound = Rectangle( Point( aR.X, aR.Y ), Size( aR.Width, aR.Height ) );
			bRet = sal_True;
		}
	}
	return bRet;
}
basegfx::B2DPolyPolygon SdrObjCustomShape::GetLineGeometry( const SdrObjCustomShape* pCustomShape, const sal_Bool bBezierAllowed )
{
	basegfx::B2DPolyPolygon aRetval;
	sal_Bool bRet = sal_False;
	Reference< XCustomShapeEngine > xCustomShapeEngine( GetCustomShapeEngine( pCustomShape ) );
	if ( xCustomShapeEngine.is() )
	{
		com::sun::star::drawing::PolyPolygonBezierCoords aBezierCoords = xCustomShapeEngine->getLineGeometry();
		try
		{
			aRetval = SvxConvertPolyPolygonBezierToB2DPolyPolygon( &aBezierCoords );
			if ( !bBezierAllowed && aRetval.areControlPointsUsed())
			{
				aRetval = basegfx::tools::adaptiveSubdivideByAngle(aRetval);
			}
			bRet = sal_True;
		}
		catch ( const com::sun::star::lang::IllegalArgumentException )
		{
		}
	}
	return aRetval;
}

std::vector< SdrCustomShapeInteraction > SdrObjCustomShape::GetInteractionHandles( const SdrObjCustomShape* pCustomShape ) const
{
	std::vector< SdrCustomShapeInteraction > xRet;
	try
	{
		Reference< XCustomShapeEngine > xCustomShapeEngine( GetCustomShapeEngine( pCustomShape ) );
		if ( xCustomShapeEngine.is() )
		{
			int i;
			Sequence< Reference< XCustomShapeHandle > > xInteractionHandles( xCustomShapeEngine->getInteraction() );
			for ( i = 0; i < xInteractionHandles.getLength(); i++ )
			{
				if ( xInteractionHandles[ i ].is() )
				{
					SdrCustomShapeInteraction aSdrCustomShapeInteraction;
					aSdrCustomShapeInteraction.xInteraction = xInteractionHandles[ i ];
					aSdrCustomShapeInteraction.aPosition = xInteractionHandles[ i ]->getPosition();

					sal_Int32 nMode = 0;
					switch( ImpGetCustomShapeType( *this ) )
					{
						case mso_sptAccentBorderCallout90 :		// 2 ortho
						{
							if ( !i )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
							else if ( i == 1)
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X | CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y | CUSTOMSHAPE_HANDLE_MOVE_SHAPE | CUSTOMSHAPE_HANDLE_ORTHO4;
						}
						break;

						case mso_sptWedgeRectCallout :
						case mso_sptWedgeRRectCallout :
						case mso_sptCloudCallout :
						case mso_sptWedgeEllipseCallout :
						{
							if ( !i )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED;
						}
						break;

						case mso_sptBorderCallout1 :			// 2 diag
						{
							if ( !i )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
							else if ( i == 1 )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X | CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y | CUSTOMSHAPE_HANDLE_MOVE_SHAPE;
						}
						break;
						case mso_sptBorderCallout2 :			// 3
						{
							if ( !i )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
							else if ( i == 2 )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X | CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y | CUSTOMSHAPE_HANDLE_MOVE_SHAPE;
						}
						break;
						case mso_sptCallout90 :
						case mso_sptAccentCallout90 :
						case mso_sptBorderCallout90 :
						case mso_sptCallout1 :
						case mso_sptCallout2 :
						case mso_sptCallout3 :
						case mso_sptAccentCallout1 :
						case mso_sptAccentCallout2 :
						case mso_sptAccentCallout3 :
						case mso_sptBorderCallout3 :
						case mso_sptAccentBorderCallout1 :
						case mso_sptAccentBorderCallout2 :
						case mso_sptAccentBorderCallout3 :
						{
							if ( !i )
								nMode |= CUSTOMSHAPE_HANDLE_RESIZE_FIXED | CUSTOMSHAPE_HANDLE_CREATE_FIXED;
						}
						break;
						default: break;
					}
					aSdrCustomShapeInteraction.nMode = nMode;
					xRet.push_back( aSdrCustomShapeInteraction );
				}
			}
		}
	}
	catch( const uno::RuntimeException& )
	{
	}
	return xRet;
}

//////////////////////////////////////////////////////////////////////////////
// BaseProperties section
#define	DEFAULT_MINIMUM_SIGNED_COMPARE	((sal_Int32)0x80000000)
#define	DEFAULT_MAXIMUM_SIGNED_COMPARE	((sal_Int32)0x7fffffff)

sdr::properties::BaseProperties* SdrObjCustomShape::CreateObjectSpecificProperties()
{
	return new sdr::properties::CustomShapeProperties(*this);
}

TYPEINIT1(SdrObjCustomShape,SdrTextObj);
SdrObjCustomShape::SdrObjCustomShape() :
	SdrTextObj(),
	fObjectRotation( 0.0 ),
	mpLastShadowGeometry(0L)
{
	bClosedObj = true; // custom shapes may be filled
	bTextFrame = sal_True;
}

SdrObjCustomShape::~SdrObjCustomShape()
{
	// delete buffered display geometry
	InvalidateRenderGeometry();
}

void SdrObjCustomShape::MergeDefaultAttributes( const rtl::OUString* pType )
{
	PropertyValue aPropVal;
	rtl::OUString sShapeType;
	const rtl::OUString	sType( RTL_CONSTASCII_USTRINGPARAM ( "Type" ) );
	SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
	if ( pType && pType->getLength() )
	{
		sal_Int32 nType = pType->toInt32();
		if ( nType )
			sShapeType = EnhancedCustomShapeTypeNames::Get( static_cast< MSO_SPT >( nType ) );
		else
			sShapeType = *pType;

		aPropVal.Name = sType;
		aPropVal.Value <<= sShapeType;
		aGeometryItem.SetPropertyValue( aPropVal );
	}
	else
	{
		Any *pAny = aGeometryItem.GetPropertyValueByName( sType );
		if ( pAny )
			*pAny >>= sShapeType;
	}
	MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType );

	const sal_Int32* pDefData = NULL;
	const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType );
	if ( pDefCustomShape )
		pDefData = pDefCustomShape->pDefData;

	com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > seqAdjustmentValues;

	//////////////////////
	// AdjustmentValues //
	//////////////////////
	const rtl::OUString	sAdjustmentValues( RTL_CONSTASCII_USTRINGPARAM ( "AdjustmentValues" ) );
	const Any* pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sAdjustmentValues );
	if ( pAny )
		*pAny >>= seqAdjustmentValues;
	if ( pDefCustomShape && pDefData )	// now check if we have to default some adjustment values
	{
		// first check if there are adjustment values are to be appended
		sal_Int32 i, nAdjustmentValues = seqAdjustmentValues.getLength();
		sal_Int32 nAdjustmentDefaults = *pDefData++;
		if ( nAdjustmentDefaults > nAdjustmentValues )
		{
			seqAdjustmentValues.realloc( nAdjustmentDefaults );
			for ( i = nAdjustmentValues; i < nAdjustmentDefaults; i++ )
			{
				seqAdjustmentValues[ i ].Value <<= pDefData[ i ];
				seqAdjustmentValues[ i ].State = com::sun::star::beans::PropertyState_DIRECT_VALUE;	// com::sun::star::beans::PropertyState_DEFAULT_VALUE;
			}
		}
		// check if there are defaulted adjustment values that should be filled the hard coded defaults (pDefValue)
		sal_Int32 nCount = nAdjustmentValues > nAdjustmentDefaults ? nAdjustmentDefaults : nAdjustmentValues;
		for ( i = 0; i < nCount; i++ )
		{
			if ( seqAdjustmentValues[ i ].State != com::sun::star::beans::PropertyState_DIRECT_VALUE )
			{
				seqAdjustmentValues[ i ].Value <<= pDefData[ i ];
				seqAdjustmentValues[ i ].State = com::sun::star::beans::PropertyState_DIRECT_VALUE;
			}
		}
	}
	aPropVal.Name = sAdjustmentValues;
	aPropVal.Value <<= seqAdjustmentValues;
	aGeometryItem.SetPropertyValue( aPropVal );

	///////////////
	// Coordsize //
	///////////////
	const rtl::OUString	sViewBox( RTL_CONSTASCII_USTRINGPARAM ( "ViewBox" ) );
	const Any* pViewBox = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sViewBox );
	com::sun::star::awt::Rectangle aViewBox;
	if ( !pViewBox || !(*pViewBox >>= aViewBox ) )
	{
		if ( pDefCustomShape )
		{
			aViewBox.X = 0;
			aViewBox.Y = 0;
			aViewBox.Width = pDefCustomShape->nCoordWidth;
			aViewBox.Height= pDefCustomShape->nCoordHeight;
			aPropVal.Name = sViewBox;
			aPropVal.Value <<= aViewBox;
			aGeometryItem.SetPropertyValue( aPropVal );
		}
	}

	const rtl::OUString	sPath( RTL_CONSTASCII_USTRINGPARAM ( "Path" ) );

	//////////////////////
	// Path/Coordinates //
	//////////////////////
	const rtl::OUString	sCoordinates( RTL_CONSTASCII_USTRINGPARAM ( "Coordinates" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sCoordinates );
	if ( !pAny && pDefCustomShape && pDefCustomShape->nVertices && pDefCustomShape->pVertices )
	{
		com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqCoordinates;

		sal_Int32 i, nCount = pDefCustomShape->nVertices;
		seqCoordinates.realloc( nCount );
		for ( i = 0; i < nCount; i++ )
		{
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates[ i ].First, pDefCustomShape->pVertices[ i ].nValA );
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates[ i ].Second, pDefCustomShape->pVertices[ i ].nValB );
		}
		aPropVal.Name = sCoordinates;
		aPropVal.Value <<= seqCoordinates;
		aGeometryItem.SetPropertyValue( sPath, aPropVal );
	}

	/////////////////////
	// Path/GluePoints //
	/////////////////////
	const rtl::OUString	sGluePoints( RTL_CONSTASCII_USTRINGPARAM ( "GluePoints" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sGluePoints );
	if ( !pAny && pDefCustomShape && pDefCustomShape->nGluePoints && pDefCustomShape->pGluePoints )
	{
		com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqGluePoints;
		sal_Int32 i, nCount = pDefCustomShape->nGluePoints;
		seqGluePoints.realloc( nCount );
		for ( i = 0; i < nCount; i++ )
		{
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints[ i ].First, pDefCustomShape->pGluePoints[ i ].nValA );
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints[ i ].Second, pDefCustomShape->pGluePoints[ i ].nValB );
		}
		aPropVal.Name = sGluePoints;
		aPropVal.Value <<= seqGluePoints;
		aGeometryItem.SetPropertyValue( sPath, aPropVal );
	}

	///////////////////
	// Path/Segments //
	///////////////////
	const rtl::OUString	sSegments( RTL_CONSTASCII_USTRINGPARAM ( "Segments" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sSegments );
	if ( !pAny && pDefCustomShape && pDefCustomShape->nElements && pDefCustomShape->pElements )
	{
		com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments;

		sal_Int32 i, nCount = pDefCustomShape->nElements;
		seqSegments.realloc( nCount );
		for ( i = 0; i < nCount; i++ )
		{
			EnhancedCustomShapeSegment& rSegInfo = seqSegments[ i ];
			sal_uInt16 nSDat = pDefCustomShape->pElements[ i ];
			switch( nSDat >> 8 )
			{
				case 0x00 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::LINETO;
					rSegInfo.Count   = nSDat & 0xff;
					if ( !rSegInfo.Count )
						rSegInfo.Count = 1;
				}
				break;
				case 0x20 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CURVETO;
					rSegInfo.Count   = nSDat & 0xff;
					if ( !rSegInfo.Count )
						rSegInfo.Count = 1;
				}
				break;
				case 0x40 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::MOVETO;
					rSegInfo.Count   = nSDat & 0xff;
					if ( !rSegInfo.Count )
						rSegInfo.Count = 1;
				}
				break;
				case 0x60 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
					rSegInfo.Count   = 0;
				}
				break;
				case 0x80 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
					rSegInfo.Count   = 0;
				}
				break;
				case 0xa1 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
					rSegInfo.Count   = ( nSDat & 0xff ) / 3;
				}
				break;
				case 0xa2 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
					rSegInfo.Count   = ( nSDat & 0xff ) / 3;
				}
				break;
				case 0xa3 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ARCTO;
					rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
				}
				break;
				case 0xa4 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ARC;
					rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
				}
				break;
				case 0xa5 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
					rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
				}
				break;
				case 0xa6 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
					rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
				}
				break;
				case 0xa7 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
					rSegInfo.Count   = nSDat & 0xff;
				}
				break;
				case 0xa8 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
					rSegInfo.Count   = nSDat & 0xff;
				}
				break;
				case 0xaa :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::NOFILL;
					rSegInfo.Count   = 0;
				}
				break;
				case 0xab :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::NOSTROKE;
					rSegInfo.Count   = 0;
				}
				break;
				default:
				case 0xf8 :
				{
					rSegInfo.Command = EnhancedCustomShapeSegmentCommand::UNKNOWN;
					rSegInfo.Count   = nSDat;
				}
				break;
			}
		}
		aPropVal.Name = sSegments;
		aPropVal.Value <<= seqSegments;
		aGeometryItem.SetPropertyValue( sPath, aPropVal );
	}

	///////////////////
	// Path/StretchX //
	///////////////////
	const rtl::OUString	sStretchX( RTL_CONSTASCII_USTRINGPARAM ( "StretchX" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchX );
	if ( !pAny && pDefCustomShape )
	{
		sal_Int32 nXRef = pDefCustomShape->nXRef;
		if ( ( nXRef != DEFAULT_MINIMUM_SIGNED_COMPARE ) )
		{
			aPropVal.Name = sStretchX;
			aPropVal.Value <<= nXRef;
			aGeometryItem.SetPropertyValue( sPath, aPropVal );
		}
	}

	///////////////////
	// Path/StretchY //
	///////////////////
	const rtl::OUString	sStretchY( RTL_CONSTASCII_USTRINGPARAM ( "StretchY" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchY );
	if ( !pAny && pDefCustomShape )
	{
		sal_Int32 nYRef = pDefCustomShape->nYRef;
		if ( ( nYRef != DEFAULT_MINIMUM_SIGNED_COMPARE ) )
		{
			aPropVal.Name = sStretchY;
			aPropVal.Value <<= nYRef;
			aGeometryItem.SetPropertyValue( sPath, aPropVal );
		}
	}

	/////////////////////
	// Path/TextFrames //
	/////////////////////
	const rtl::OUString	sTextFrames( RTL_CONSTASCII_USTRINGPARAM ( "TextFrames" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sTextFrames );
	if ( !pAny && pDefCustomShape && pDefCustomShape->nTextRect && pDefCustomShape->pTextRect )
	{
		com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > seqTextFrames;

		sal_Int32 i, nCount = pDefCustomShape->nTextRect;
		seqTextFrames.realloc( nCount );
		const SvxMSDffTextRectangles* pRectangles = pDefCustomShape->pTextRect;
		for ( i = 0; i < nCount; i++, pRectangles++ )
		{
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].TopLeft.First,	  pRectangles->nPairA.nValA );
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].TopLeft.Second,	  pRectangles->nPairA.nValB );
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].BottomRight.First,  pRectangles->nPairB.nValA );
			EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames[ i ].BottomRight.Second, pRectangles->nPairB.nValB );
		}
		aPropVal.Name = sTextFrames;
		aPropVal.Value <<= seqTextFrames;
		aGeometryItem.SetPropertyValue( sPath, aPropVal );
	}

	///////////////
	// Equations //
	///////////////
	const rtl::OUString	sEquations( RTL_CONSTASCII_USTRINGPARAM( "Equations" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sEquations );
	if ( !pAny && pDefCustomShape && pDefCustomShape->nCalculation && pDefCustomShape->pCalculation )
	{
		com::sun::star::uno::Sequence< rtl::OUString > seqEquations;

		sal_Int32 i, nCount = pDefCustomShape->nCalculation;
		seqEquations.realloc( nCount );
		const SvxMSDffCalculationData* pData = pDefCustomShape->pCalculation;
		for ( i = 0; i < nCount; i++, pData++ )
			seqEquations[ i ] = EnhancedCustomShape2d::GetEquation( pData->nFlags, pData->nVal[ 0 ], pData->nVal[ 1 ], pData->nVal[ 2 ] );
		aPropVal.Name = sEquations;
		aPropVal.Value <<= seqEquations;
		aGeometryItem.SetPropertyValue( aPropVal );
	}

	/////////////
	// Handles //
	/////////////
	const rtl::OUString	sHandles( RTL_CONSTASCII_USTRINGPARAM( "Handles" ) );
	pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sHandles );
	if ( !pAny && pDefCustomShape && pDefCustomShape->nHandles && pDefCustomShape->pHandles )
	{
		com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValues > seqHandles;

		sal_Int32 i, n, nCount = pDefCustomShape->nHandles;
		const SvxMSDffHandle* pData = pDefCustomShape->pHandles;
		seqHandles.realloc( nCount );
		for ( i = 0; i < nCount; i++, pData++ )
		{
			sal_Int32 nPropertiesNeeded = 1;	// position is always needed
			sal_Int32 nFlags = pData->nFlags;
			if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_X )
				nPropertiesNeeded++;
			if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_Y )
				nPropertiesNeeded++;
			if ( nFlags & MSDFF_HANDLE_FLAGS_SWITCHED )
				nPropertiesNeeded++;
			if ( nFlags & MSDFF_HANDLE_FLAGS_POLAR )
			{
				nPropertiesNeeded++;
				if ( nFlags & MSDFF_HANDLE_FLAGS_RADIUS_RANGE )
				{
					if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
						nPropertiesNeeded++;
					if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
						nPropertiesNeeded++;
				}
			}
			else if ( nFlags & MSDFF_HANDLE_FLAGS_RANGE )
			{
				if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
					nPropertiesNeeded++;
				if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
					nPropertiesNeeded++;
				if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
					nPropertiesNeeded++;
				if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
					nPropertiesNeeded++;
			}

			n = 0;
			com::sun::star::beans::PropertyValues& rPropValues = seqHandles[ i ];
			rPropValues.realloc( nPropertiesNeeded );

			// POSITION
			{
				const rtl::OUString	sPosition( RTL_CONSTASCII_USTRINGPARAM ( "Position" ) );
				::com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition;
				EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.First, pData->nPositionX, sal_True, sal_True );
				EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.Second, pData->nPositionY, sal_True, sal_False );
				rPropValues[ n ].Name = sPosition;
				rPropValues[ n++ ].Value <<= aPosition;
			}
			if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_X )
			{
				const rtl::OUString	sMirroredX( RTL_CONSTASCII_USTRINGPARAM ( "MirroredX" ) );
				sal_Bool bMirroredX = sal_True;
				rPropValues[ n ].Name = sMirroredX;
				rPropValues[ n++ ].Value <<= bMirroredX;
			}
			if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_Y )
			{
				const rtl::OUString	sMirroredY( RTL_CONSTASCII_USTRINGPARAM ( "MirroredY" ) );
				sal_Bool bMirroredY = sal_True;
				rPropValues[ n ].Name = sMirroredY;
				rPropValues[ n++ ].Value <<= bMirroredY;
			}
			if ( nFlags & MSDFF_HANDLE_FLAGS_SWITCHED )
			{
				const rtl::OUString	sSwitched( RTL_CONSTASCII_USTRINGPARAM ( "Switched" ) );
				sal_Bool bSwitched = sal_True;
				rPropValues[ n ].Name = sSwitched;
				rPropValues[ n++ ].Value <<= bSwitched;
			}
			if ( nFlags & MSDFF_HANDLE_FLAGS_POLAR )
			{
				const rtl::OUString	sPolar( RTL_CONSTASCII_USTRINGPARAM ( "Polar" ) );
				::com::sun::star::drawing::EnhancedCustomShapeParameterPair aCenter;
				EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.First,  pData->nCenterX,
					( nFlags & MSDFF_HANDLE_FLAGS_CENTER_X_IS_SPECIAL ) != 0, sal_True  );
				EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.Second, pData->nCenterY,
					( nFlags & MSDFF_HANDLE_FLAGS_CENTER_Y_IS_SPECIAL ) != 0, sal_False );
				rPropValues[ n ].Name = sPolar;
				rPropValues[ n++ ].Value <<= aCenter;
				if ( nFlags & MSDFF_HANDLE_FLAGS_RADIUS_RANGE )
				{
					if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
					{
						const rtl::OUString	sRadiusRangeMinimum( RTL_CONSTASCII_USTRINGPARAM ( "RadiusRangeMinimum" ) );
						::com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
						EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMinimum, pData->nRangeXMin,
							( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MIN_IS_SPECIAL ) != 0, sal_True  );
						rPropValues[ n ].Name = sRadiusRangeMinimum;
						rPropValues[ n++ ].Value <<= aRadiusRangeMinimum;
					}
					if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
					{
						const rtl::OUString	sRadiusRangeMaximum( RTL_CONSTASCII_USTRINGPARAM ( "RadiusRangeMaximum" ) );
						::com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
						EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMaximum, pData->nRangeXMax,
							( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MAX_IS_SPECIAL ) != 0, sal_False );
						rPropValues[ n ].Name = sRadiusRangeMaximum;
						rPropValues[ n++ ].Value <<= aRadiusRangeMaximum;
					}
				}
			}
			else if ( nFlags & MSDFF_HANDLE_FLAGS_RANGE )
			{
				if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
				{
					const rtl::OUString	sRangeXMinimum( RTL_CONSTASCII_USTRINGPARAM ( "RangeXMinimum" ) );
					::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeXMinimum;
					EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMinimum, pData->nRangeXMin,
						( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MIN_IS_SPECIAL ) != 0, sal_True  );
					rPropValues[ n ].Name = sRangeXMinimum;
					rPropValues[ n++ ].Value <<= aRangeXMinimum;
				}
				if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
				{
					const rtl::OUString	sRangeXMaximum( RTL_CONSTASCII_USTRINGPARAM ( "RangeXMaximum" ) );
					::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeXMaximum;
					EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMaximum, pData->nRangeXMax,
						( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MAX_IS_SPECIAL ) != 0, sal_False );
					rPropValues[ n ].Name = sRangeXMaximum;
					rPropValues[ n++ ].Value <<= aRangeXMaximum;
				}
				if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
				{
					const rtl::OUString	sRangeYMinimum( RTL_CONSTASCII_USTRINGPARAM ( "RangeYMinimum" ) );
					::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeYMinimum;
					EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMinimum, pData->nRangeYMin,
						( nFlags & MSDFF_HANDLE_FLAGS_RANGE_Y_MIN_IS_SPECIAL ) != 0, sal_True );
					rPropValues[ n ].Name = sRangeYMinimum;
					rPropValues[ n++ ].Value <<= aRangeYMinimum;
				}
				if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
				{
					const rtl::OUString	sRangeYMaximum( RTL_CONSTASCII_USTRINGPARAM ( "RangeYMaximum" ) );
					::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeYMaximum;
					EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMaximum, pData->nRangeYMax,
						( nFlags & MSDFF_HANDLE_FLAGS_RANGE_Y_MAX_IS_SPECIAL ) != 0, sal_False );
					rPropValues[ n ].Name = sRangeYMaximum;
					rPropValues[ n++ ].Value <<= aRangeYMaximum;
				}
			}
		}
		aPropVal.Name = sHandles;
		aPropVal.Value <<= seqHandles;
		aGeometryItem.SetPropertyValue( aPropVal );
	}
	SetMergedItem( aGeometryItem );
}

sal_Bool SdrObjCustomShape::IsDefaultGeometry( const DefaultType eDefaultType ) const
{
	sal_Bool bIsDefaultGeometry = sal_False;

	PropertyValue aPropVal;
	rtl::OUString sShapeType;
	const rtl::OUString	sType( RTL_CONSTASCII_USTRINGPARAM ( "Type" ) );
	SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );

	Any *pAny = aGeometryItem.GetPropertyValueByName( sType );
	if ( pAny )
		*pAny >>= sShapeType;

	MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType );

	const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType );
	const rtl::OUString	sPath( RTL_CONSTASCII_USTRINGPARAM ( "Path" ) );
	switch( eDefaultType )
	{
		case DEFAULT_VIEWBOX :
		{
			const rtl::OUString	sViewBox( RTL_CONSTASCII_USTRINGPARAM ( "ViewBox" ) );
			const Any* pViewBox = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sViewBox );
			com::sun::star::awt::Rectangle aViewBox;
			if ( pViewBox && ( *pViewBox >>= aViewBox ) )
			{
				if ( ( aViewBox.Width == pDefCustomShape->nCoordWidth )
					&& ( aViewBox.Height == pDefCustomShape->nCoordHeight ) )
					bIsDefaultGeometry = sal_True;
			}
		}
		break;

		case DEFAULT_PATH :
		{
			const rtl::OUString	sCoordinates( RTL_CONSTASCII_USTRINGPARAM ( "Coordinates" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sCoordinates );
			if ( pAny && pDefCustomShape && pDefCustomShape->nVertices && pDefCustomShape->pVertices )
			{
				com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqCoordinates1, seqCoordinates2;
				if ( *pAny >>= seqCoordinates1 )
				{
					sal_Int32 i, nCount = pDefCustomShape->nVertices;
					seqCoordinates2.realloc( nCount );
					for ( i = 0; i < nCount; i++ )
					{
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates2[ i ].First, pDefCustomShape->pVertices[ i ].nValA );
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqCoordinates2[ i ].Second, pDefCustomShape->pVertices[ i ].nValB );
					}
					if ( seqCoordinates1 == seqCoordinates2 )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( ( pDefCustomShape->nVertices == 0 ) || ( pDefCustomShape->pVertices == 0 ) ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_GLUEPOINTS :
		{
			const rtl::OUString	sGluePoints( RTL_CONSTASCII_USTRINGPARAM ( "GluePoints" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sGluePoints );
			if ( pAny && pDefCustomShape && pDefCustomShape->nGluePoints && pDefCustomShape->pGluePoints )
			{
				com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> seqGluePoints1, seqGluePoints2;
				if ( *pAny >>= seqGluePoints1 )
				{
					sal_Int32 i, nCount = pDefCustomShape->nGluePoints;
					seqGluePoints2.realloc( nCount );
					for ( i = 0; i < nCount; i++ )
					{
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints2[ i ].First, pDefCustomShape->pGluePoints[ i ].nValA );
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqGluePoints2[ i ].Second, pDefCustomShape->pGluePoints[ i ].nValB );
					}
					if ( seqGluePoints1 == seqGluePoints2 )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( pDefCustomShape->nGluePoints == 0 ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_SEGMENTS :
		{
			///////////////////
			// Path/Segments //
			///////////////////
			const rtl::OUString	sSegments( RTL_CONSTASCII_USTRINGPARAM ( "Segments" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sSegments );
			if ( pAny )
			{
				com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments1, seqSegments2;
				if ( *pAny >>= seqSegments1 )
				{
					if ( pDefCustomShape && pDefCustomShape->nElements && pDefCustomShape->pElements )
					{
						sal_Int32 i, nCount = pDefCustomShape->nElements;
						if ( nCount )
						{
							seqSegments2.realloc( nCount );
							for ( i = 0; i < nCount; i++ )
							{
								EnhancedCustomShapeSegment& rSegInfo = seqSegments2[ i ];
								sal_uInt16 nSDat = pDefCustomShape->pElements[ i ];
								switch( nSDat >> 8 )
								{
									case 0x00 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::LINETO;
										rSegInfo.Count   = nSDat & 0xff;
										if ( !rSegInfo.Count )
											rSegInfo.Count = 1;
									}
									break;
									case 0x20 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CURVETO;
										rSegInfo.Count   = nSDat & 0xff;
										if ( !rSegInfo.Count )
											rSegInfo.Count = 1;
									}
									break;
									case 0x40 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::MOVETO;
										rSegInfo.Count   = nSDat & 0xff;
										if ( !rSegInfo.Count )
											rSegInfo.Count = 1;
									}
									break;
									case 0x60 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
										rSegInfo.Count   = 0;
									}
									break;
									case 0x80 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
										rSegInfo.Count   = 0;
									}
									break;
									case 0xa1 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
										rSegInfo.Count   = ( nSDat & 0xff ) / 3;
									}
									break;
									case 0xa2 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
										rSegInfo.Count   = ( nSDat & 0xff ) / 3;
									}
									break;
									case 0xa3 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ARCTO;
										rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
									}
									break;
									case 0xa4 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ARC;
										rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
									}
									break;
									case 0xa5 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
										rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
									}
									break;
									case 0xa6 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
										rSegInfo.Count   = ( nSDat & 0xff ) >> 2;
									}
									break;
									case 0xa7 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
										rSegInfo.Count   = nSDat & 0xff;
									}
									break;
									case 0xa8 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
										rSegInfo.Count   = nSDat & 0xff;
									}
									break;
									case 0xaa :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::NOFILL;
										rSegInfo.Count   = 0;
									}
									break;
									case 0xab :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::NOSTROKE;
										rSegInfo.Count   = 0;
									}
									break;
									default:
									case 0xf8 :
									{
										rSegInfo.Command = EnhancedCustomShapeSegmentCommand::UNKNOWN;
										rSegInfo.Count   = nSDat;
									}
									break;
								}
							}
							if ( seqSegments1 == seqSegments2 )
								bIsDefaultGeometry = sal_True;
						}
					}
					else
					{
						// check if its the default segment description	( M L Z N )
						if ( seqSegments1.getLength() == 4 )
						{
							if ( ( seqSegments1[ 0 ].Command == EnhancedCustomShapeSegmentCommand::MOVETO )
								&& ( seqSegments1[ 1 ].Command == EnhancedCustomShapeSegmentCommand::LINETO )
								&& ( seqSegments1[ 2 ].Command == EnhancedCustomShapeSegmentCommand::CLOSESUBPATH )
								&& ( seqSegments1[ 3 ].Command == EnhancedCustomShapeSegmentCommand::ENDSUBPATH ) )
								bIsDefaultGeometry = sal_True;
						}
					}
				}
			}
			else if ( pDefCustomShape && ( ( pDefCustomShape->nElements == 0 ) || ( pDefCustomShape->pElements == 0 ) ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_STRETCHX :
		{
			const rtl::OUString	sStretchX( RTL_CONSTASCII_USTRINGPARAM ( "StretchX" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchX );
			if ( pAny && pDefCustomShape )
			{
				sal_Int32 nStretchX = 0;
				if ( *pAny >>= nStretchX )
				{
					if ( pDefCustomShape->nXRef == nStretchX )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( pDefCustomShape->nXRef == DEFAULT_MINIMUM_SIGNED_COMPARE ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_STRETCHY :
		{
			const rtl::OUString	sStretchY( RTL_CONSTASCII_USTRINGPARAM ( "StretchY" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sStretchY );
			if ( pAny && pDefCustomShape )
			{
				sal_Int32 nStretchY = 0;
				if ( *pAny >>= nStretchY )
				{
					if ( pDefCustomShape->nYRef == nStretchY )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( pDefCustomShape->nYRef == DEFAULT_MINIMUM_SIGNED_COMPARE ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_EQUATIONS :
		{
			const rtl::OUString	sEquations( RTL_CONSTASCII_USTRINGPARAM( "Equations" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sEquations );
			if ( pAny && pDefCustomShape && pDefCustomShape->nCalculation && pDefCustomShape->pCalculation )
			{
				com::sun::star::uno::Sequence< rtl::OUString > seqEquations1, seqEquations2;
				if ( *pAny >>= seqEquations1 )
				{
					sal_Int32 i, nCount = pDefCustomShape->nCalculation;
					seqEquations2.realloc( nCount );

					const SvxMSDffCalculationData* pData = pDefCustomShape->pCalculation;
					for ( i = 0; i < nCount; i++, pData++ )
						seqEquations2[ i ] = EnhancedCustomShape2d::GetEquation( pData->nFlags, pData->nVal[ 0 ], pData->nVal[ 1 ], pData->nVal[ 2 ] );

					if ( seqEquations1 == seqEquations2 )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( ( pDefCustomShape->nCalculation == 0 ) || ( pDefCustomShape->pCalculation == 0 ) ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_TEXTFRAMES :
		{
			const rtl::OUString	sTextFrames( RTL_CONSTASCII_USTRINGPARAM( "TextFrames" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sPath, sTextFrames );
			if ( pAny && pDefCustomShape && pDefCustomShape->nTextRect && pDefCustomShape->pTextRect )
			{
				com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > seqTextFrames1, seqTextFrames2;
				if ( *pAny >>= seqTextFrames1 )
				{
					sal_Int32 i, nCount = pDefCustomShape->nTextRect;
					seqTextFrames2.realloc( nCount );
					const SvxMSDffTextRectangles* pRectangles = pDefCustomShape->pTextRect;
					for ( i = 0; i < nCount; i++, pRectangles++ )
					{
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].TopLeft.First,	  pRectangles->nPairA.nValA );
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].TopLeft.Second,	  pRectangles->nPairA.nValB );
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].BottomRight.First,  pRectangles->nPairB.nValA );
						EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( seqTextFrames2[ i ].BottomRight.Second, pRectangles->nPairB.nValB );
					}
					if ( seqTextFrames1 == seqTextFrames2 )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( ( pDefCustomShape->nTextRect == 0 ) || ( pDefCustomShape->pTextRect == 0 ) ) )
				bIsDefaultGeometry = sal_True;
		}
		break;

		case DEFAULT_HANDLES :
		{
			const rtl::OUString	sHandles( RTL_CONSTASCII_USTRINGPARAM( "Handles" ) );
			pAny = ((SdrCustomShapeGeometryItem&)aGeometryItem).GetPropertyValueByName( sHandles );
			if ( pAny && pDefCustomShape && pDefCustomShape->nHandles && pDefCustomShape->pHandles )
			{
				com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValues > seqHandles1, seqHandles2;
				if ( *pAny >>= seqHandles1 )
				{
					sal_Int32 i, n, nCount = pDefCustomShape->nHandles;
					const SvxMSDffHandle* pData = pDefCustomShape->pHandles;
					seqHandles2.realloc( nCount );
					for ( i = 0; i < nCount; i++, pData++ )
					{
						sal_Int32 nPropertiesNeeded = 1;	// position is always needed
						sal_Int32 nFlags = pData->nFlags;
						if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_X )
							nPropertiesNeeded++;
						if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_Y )
							nPropertiesNeeded++;
						if ( nFlags & MSDFF_HANDLE_FLAGS_SWITCHED )
							nPropertiesNeeded++;
						if ( nFlags & MSDFF_HANDLE_FLAGS_POLAR )
						{
							nPropertiesNeeded++;
							if ( nFlags & MSDFF_HANDLE_FLAGS_RADIUS_RANGE )
							{
								if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
									nPropertiesNeeded++;
								if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
									nPropertiesNeeded++;
							}
						}
						else if ( nFlags & MSDFF_HANDLE_FLAGS_RANGE )
						{
							if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
								nPropertiesNeeded++;
							if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
								nPropertiesNeeded++;
							if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
								nPropertiesNeeded++;
							if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
								nPropertiesNeeded++;
						}

						n = 0;
						com::sun::star::beans::PropertyValues& rPropValues = seqHandles2[ i ];
						rPropValues.realloc( nPropertiesNeeded );

						// POSITION
						{
							const rtl::OUString	sPosition( RTL_CONSTASCII_USTRINGPARAM ( "Position" ) );
							::com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition;
							EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.First, pData->nPositionX, sal_True, sal_True );
							EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.Second, pData->nPositionY, sal_True, sal_False );
							rPropValues[ n ].Name = sPosition;
							rPropValues[ n++ ].Value <<= aPosition;
						}
						if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_X )
						{
							const rtl::OUString	sMirroredX( RTL_CONSTASCII_USTRINGPARAM ( "MirroredX" ) );
							sal_Bool bMirroredX = sal_True;
							rPropValues[ n ].Name = sMirroredX;
							rPropValues[ n++ ].Value <<= bMirroredX;
						}
						if ( nFlags & MSDFF_HANDLE_FLAGS_MIRRORED_Y )
						{
							const rtl::OUString	sMirroredY( RTL_CONSTASCII_USTRINGPARAM ( "MirroredY" ) );
							sal_Bool bMirroredY = sal_True;
							rPropValues[ n ].Name = sMirroredY;
							rPropValues[ n++ ].Value <<= bMirroredY;
						}
						if ( nFlags & MSDFF_HANDLE_FLAGS_SWITCHED )
						{
							const rtl::OUString	sSwitched( RTL_CONSTASCII_USTRINGPARAM ( "Switched" ) );
							sal_Bool bSwitched = sal_True;
							rPropValues[ n ].Name = sSwitched;
							rPropValues[ n++ ].Value <<= bSwitched;
						}
						if ( nFlags & MSDFF_HANDLE_FLAGS_POLAR )
						{
							const rtl::OUString	sPolar( RTL_CONSTASCII_USTRINGPARAM ( "Polar" ) );
							::com::sun::star::drawing::EnhancedCustomShapeParameterPair aCenter;
							EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.First,  pData->nCenterX,
								( nFlags & MSDFF_HANDLE_FLAGS_CENTER_X_IS_SPECIAL ) != 0, sal_True  );
							EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.Second, pData->nCenterY,
								( nFlags & MSDFF_HANDLE_FLAGS_CENTER_Y_IS_SPECIAL ) != 0, sal_False );
							rPropValues[ n ].Name = sPolar;
							rPropValues[ n++ ].Value <<= aCenter;
							if ( nFlags & MSDFF_HANDLE_FLAGS_RADIUS_RANGE )
							{
								if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
								{
									const rtl::OUString	sRadiusRangeMinimum( RTL_CONSTASCII_USTRINGPARAM ( "RadiusRangeMinimum" ) );
									::com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
									EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMinimum, pData->nRangeXMin,
										( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MIN_IS_SPECIAL ) != 0, sal_True  );
									rPropValues[ n ].Name = sRadiusRangeMinimum;
									rPropValues[ n++ ].Value <<= aRadiusRangeMinimum;
								}
								if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
								{
									const rtl::OUString	sRadiusRangeMaximum( RTL_CONSTASCII_USTRINGPARAM ( "RadiusRangeMaximum" ) );
									::com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
									EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMaximum, pData->nRangeXMax,
										( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MAX_IS_SPECIAL ) != 0, sal_False );
									rPropValues[ n ].Name = sRadiusRangeMaximum;
									rPropValues[ n++ ].Value <<= aRadiusRangeMaximum;
								}
							}
						}
						else if ( nFlags & MSDFF_HANDLE_FLAGS_RANGE )
						{
							if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
							{
								const rtl::OUString	sRangeXMinimum( RTL_CONSTASCII_USTRINGPARAM ( "RangeXMinimum" ) );
								::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeXMinimum;
								EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMinimum, pData->nRangeXMin,
									( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MIN_IS_SPECIAL ) != 0, sal_True  );
								rPropValues[ n ].Name = sRangeXMinimum;
								rPropValues[ n++ ].Value <<= aRangeXMinimum;
							}
							if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
							{
								const rtl::OUString	sRangeXMaximum( RTL_CONSTASCII_USTRINGPARAM ( "RangeXMaximum" ) );
								::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeXMaximum;
								EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMaximum, pData->nRangeXMax,
									( nFlags & MSDFF_HANDLE_FLAGS_RANGE_X_MAX_IS_SPECIAL ) != 0, sal_False );
								rPropValues[ n ].Name = sRangeXMaximum;
								rPropValues[ n++ ].Value <<= aRangeXMaximum;
							}
							if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE )
							{
								const rtl::OUString	sRangeYMinimum( RTL_CONSTASCII_USTRINGPARAM ( "RangeYMinimum" ) );
								::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeYMinimum;
								EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMinimum, pData->nRangeYMin,
									( nFlags & MSDFF_HANDLE_FLAGS_RANGE_Y_MIN_IS_SPECIAL ) != 0, sal_True );
								rPropValues[ n ].Name = sRangeYMinimum;
								rPropValues[ n++ ].Value <<= aRangeYMinimum;
							}
							if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE )
							{
								const rtl::OUString	sRangeYMaximum( RTL_CONSTASCII_USTRINGPARAM ( "RangeYMaximum" ) );
								::com::sun::star::drawing::EnhancedCustomShapeParameter aRangeYMaximum;
								EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMaximum, pData->nRangeYMax,
									( nFlags & MSDFF_HANDLE_FLAGS_RANGE_Y_MAX_IS_SPECIAL ) != 0, sal_False );
								rPropValues[ n ].Name = sRangeYMaximum;
								rPropValues[ n++ ].Value <<= aRangeYMaximum;
							}
						}
					}
					if ( seqHandles1 == seqHandles2 )
						bIsDefaultGeometry = sal_True;
				}
			}
			else if ( pDefCustomShape && ( ( pDefCustomShape->nHandles == 0 ) || ( pDefCustomShape->pHandles == 0 ) ) )
				bIsDefaultGeometry = sal_True;
		}
		break;
	}
	return bIsDefaultGeometry;
}

void SdrObjCustomShape::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
{
	rInfo.bResizeFreeAllowed=fObjectRotation == 0.0;
	rInfo.bResizePropAllowed=sal_True;
	rInfo.bRotateFreeAllowed=sal_True;
	rInfo.bRotate90Allowed  =sal_True;
	rInfo.bMirrorFreeAllowed=sal_True;
	rInfo.bMirror45Allowed  =sal_True;
	rInfo.bMirror90Allowed  =sal_True;
	rInfo.bTransparenceAllowed = sal_False;
	rInfo.bGradientAllowed = sal_False;
	rInfo.bShearAllowed     =sal_True;
	rInfo.bEdgeRadiusAllowed=sal_False;
	rInfo.bNoContortion     =sal_True;

	// #i37011#
	if ( mXRenderedCustomShape.is() )
	{
		const SdrObject* pRenderedCustomShape = GetSdrObjectFromXShape( mXRenderedCustomShape );
		if ( pRenderedCustomShape )
		{
			// #i37262#
			// Iterate self over the contained objects, since there are combinations of
			// polygon and curve objects. In that case, aInfo.bCanConvToPath and
			// aInfo.bCanConvToPoly would be false. What is needed here is an or, not an and.
			SdrObjListIter aIterator(*pRenderedCustomShape);
			while(aIterator.IsMore())
			{
				SdrObject* pCandidate = aIterator.Next();
				SdrObjTransformInfoRec aInfo;
				pCandidate->TakeObjInfo(aInfo);

				// set path and poly conversion if one is possible since
				// this object will first be broken
				const sal_Bool bCanConvToPathOrPoly(aInfo.bCanConvToPath || aInfo.bCanConvToPoly);
				if(rInfo.bCanConvToPath != bCanConvToPathOrPoly)
				{
					rInfo.bCanConvToPath = bCanConvToPathOrPoly;
				}

				if(rInfo.bCanConvToPoly != bCanConvToPathOrPoly)
				{
					rInfo.bCanConvToPoly = bCanConvToPathOrPoly;
				}

				if(rInfo.bCanConvToContour != aInfo.bCanConvToContour)
				{
					rInfo.bCanConvToContour = aInfo.bCanConvToContour;
				}
			}
		}
	}
}

void SdrObjCustomShape::SetModel(SdrModel* pNewModel)
{
	SdrTextObj::SetModel(pNewModel);
	mXRenderedCustomShape.clear();
}

sal_uInt16 SdrObjCustomShape::GetObjIdentifier() const
{
	return sal_uInt16(OBJ_CUSTOMSHAPE);
}

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

void SdrObjCustomShape::RecalcSnapRect()
{
	SdrTextObj::RecalcSnapRect();
}
const Rectangle& SdrObjCustomShape::GetSnapRect() const
{
	return SdrTextObj::GetSnapRect();
}
const Rectangle& SdrObjCustomShape::GetCurrentBoundRect() const
{
	return SdrTextObj::GetCurrentBoundRect();
}
const Rectangle& SdrObjCustomShape::GetLogicRect() const
{
	return SdrTextObj::GetLogicRect();
}

// #115391# This implementation is based on the TextFrame size of the CustomShape and the
// state of the ResizeShapeToFitText flag to correctly set TextMinFrameWidth/Height
void SdrObjCustomShape::AdaptTextMinSize()
{
    if(!pModel || !pModel->IsPasteResize())
    {
        const bool bResizeShapeToFitText(0 != static_cast< const SdrTextAutoGrowHeightItem& >(GetObjectItem(SDRATTR_TEXT_AUTOGROWHEIGHT)).GetValue());
        SfxItemSet aSet(GetObjectItemSet());
        bool bChanged(false);

        if(bResizeShapeToFitText)
        {
            // always reset MinWidthHeight to zero to only rely on text size and frame size
            // to allow resizing being completely dependent on text size only
            aSet.Put(SdrTextMinFrameWidthItem(0));
            aSet.Put(SdrTextMinFrameHeightItem(0));
            bChanged = true;
        }
        else
        {
            // recreate from CustomShape-specific TextBounds
            Rectangle aTextBound(aRect);

            if(GetTextBounds(aTextBound))
            {
                const long nHDist(GetTextLeftDistance() + GetTextRightDistance());
                const long nVDist(GetTextUpperDistance() + GetTextLowerDistance());
                const long nTWdt(std::max(long(0), (long)(aTextBound.GetWidth() - 1 - nHDist)));
                const long nTHgt(std::max(long(0), (long)(aTextBound.GetHeight() - 1 - nVDist)));
                SfxItemSet aSet(GetObjectItemSet());

                aSet.Put(SdrTextMinFrameWidthItem(nTWdt));
                aSet.Put(SdrTextMinFrameHeightItem(nTHgt));
                bChanged = true;
            }
        }

        if(bChanged)
        {
            SetObjectItemSet(aSet);
            NbcAdjustTextFrameWidthAndHeight();
        }
    }
}

void SdrObjCustomShape::NbcSetSnapRect( const Rectangle& rRect )
{
	aRect=rRect;
	ImpJustifyRect(aRect);
	InvalidateRenderGeometry();

    // #115391#
    AdaptTextMinSize();

	ImpCheckShear();
	SetRectsDirty();
	SetChanged();
}
void SdrObjCustomShape::SetSnapRect( const Rectangle& rRect )
{
	Rectangle aBoundRect0;
	if ( pUserCall )
		aBoundRect0 = GetLastBoundRect();
	NbcSetSnapRect( rRect );
	BroadcastObjectChange();
	SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
}
void SdrObjCustomShape::NbcSetLogicRect( const Rectangle& rRect )
{
	aRect = rRect;
	ImpJustifyRect( aRect );
	InvalidateRenderGeometry();

    // #115391# 
    AdaptTextMinSize();

	SetRectsDirty();
	SetChanged();
}
void SdrObjCustomShape::SetLogicRect( const Rectangle& rRect )
{
	Rectangle aBoundRect0;
	if ( pUserCall )
		aBoundRect0 = GetLastBoundRect();
	NbcSetLogicRect(rRect);
	BroadcastObjectChange();
	SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
}
void SdrObjCustomShape::Move( const Size& rSiz )
{
	if ( rSiz.Width() || rSiz.Height() )
	{
		Rectangle aBoundRect0;
		if ( pUserCall )
			aBoundRect0 = GetLastBoundRect();
		// #110094#-14 SendRepaintBroadcast();
		NbcMove(rSiz);
		SetChanged();
		BroadcastObjectChange();
		SendUserCall(SDRUSERCALL_MOVEONLY,aBoundRect0);
	}
}
void SdrObjCustomShape::NbcMove( const Size& rSiz )
{
	SdrTextObj::NbcMove( rSiz );
	if ( mXRenderedCustomShape.is() )
	{
		SdrObject* pRenderedCustomShape = GetSdrObjectFromXShape( mXRenderedCustomShape );
		if ( pRenderedCustomShape )
        {
            // #i97149# the visualisation shape needs to be informed
            // about change, too
            pRenderedCustomShape->ActionChanged();
			pRenderedCustomShape->NbcMove( rSiz );
        }
	}

	// #i37011# adapt geometry shadow
	if(mpLastShadowGeometry)
	{
		mpLastShadowGeometry->NbcMove( rSiz );
	}
}
void SdrObjCustomShape::Resize( const Point& rRef, const Fraction& xFact, const Fraction& yFact )
{
	SdrTextObj::Resize( rRef, xFact, yFact );
}

void SdrObjCustomShape::NbcResize( const Point& rRef, const Fraction& rxFact, const Fraction& ryFact )
{
	Fraction xFact( rxFact );
	Fraction yFact( ryFact );

	// taking care of handles that should not been changed
	Rectangle aOld( aRect );
	std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );

	SdrTextObj::NbcResize( rRef, xFact, yFact );

	if ( ( xFact.GetNumerator() != xFact.GetDenominator() )
		|| ( yFact.GetNumerator()!= yFact.GetDenominator() ) )
	{
		if ( ( ( xFact.GetNumerator() < 0 ) && ( xFact.GetDenominator() > 0 ) ) ||
			( ( xFact.GetNumerator() > 0 ) && ( xFact.GetDenominator() < 0 ) ) )
		{
			SetMirroredX( IsMirroredX() == sal_False );
		}
		if ( ( ( yFact.GetNumerator() < 0 ) && ( yFact.GetDenominator() > 0 ) ) ||
			( ( yFact.GetNumerator() > 0 ) && ( yFact.GetDenominator() < 0 ) ) )
		{
			SetMirroredY( IsMirroredY() == sal_False );	
		}
	}

	std::vector< SdrCustomShapeInteraction >::iterator aIter( aInteractionHandles.begin() );
	while ( aIter != aInteractionHandles.end() )
	{
		try
		{
			if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
				aIter->xInteraction->setControllerPosition( aIter->aPosition );
			if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X )
			{
				sal_Int32 nX = ( aIter->aPosition.X - aOld.Left() ) + aRect.Left();
				aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( nX, aIter->xInteraction->getPosition().Y ) );
			}
			if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y )
			{
				sal_Int32 nY = ( aIter->aPosition.Y - aOld.Top() ) + aRect.Top();
				aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( aIter->xInteraction->getPosition().X, nY ) );
			}
		}
		catch ( const uno::RuntimeException& )
		{
		}
		aIter++;
	}
	InvalidateRenderGeometry();
}
void SdrObjCustomShape::NbcRotate( const Point& rRef, long nWink, double sn, double cs )
{
	sal_Bool bMirroredX = IsMirroredX();
	sal_Bool bMirroredY = IsMirroredY();

	fObjectRotation = fmod( fObjectRotation, 360.0 );
	if ( fObjectRotation < 0 )
		fObjectRotation = 360 + fObjectRotation;

	// the rotation angle for ashapes is stored in fObjectRotation, this rotation
	// has to be applied to the text object (which is internally using aGeo.nWink).
	SdrTextObj::NbcRotate( aRect.TopLeft(), -aGeo.nDrehWink,		// retrieving the unrotated text object
							sin( (-aGeo.nDrehWink) * F_PI18000 ),
							cos( (-aGeo.nDrehWink) * F_PI18000 ) );
	aGeo.nDrehWink = 0;												// resetting aGeo data
	aGeo.RecalcSinCos();

	long nW = (long)( fObjectRotation * 100 );						// applying our object rotation
	if ( bMirroredX )
		nW = 36000 - nW;
	if ( bMirroredY )
		nW = 18000 - nW;
	nW = nW % 36000;
	if ( nW < 0 )
		nW = 36000 + nW;
	SdrTextObj::NbcRotate( aRect.TopLeft(), nW,						// applying text rotation
							sin( nW * F_PI18000 ),
							cos( nW * F_PI18000 ) );

	int nSwap = 0;
	if ( bMirroredX )
		nSwap ^= 1;
	if ( bMirroredY )
		nSwap ^= 1;

	double fWink = nWink;													// updating to our new object rotation
	fWink /= 100.0;
	fObjectRotation = fmod( nSwap ? fObjectRotation - fWink : fObjectRotation + fWink, 360.0 );
	if ( fObjectRotation < 0 )
		fObjectRotation = 360 + fObjectRotation;

	SdrTextObj::NbcRotate( rRef, nWink, sn, cs );							// applying text rotation
	InvalidateRenderGeometry();
}

void SdrObjCustomShape::NbcMirror( const Point& rRef1, const Point& rRef2 )
{
    // TTTT: Fix for old mirroring, can be removed again in aw080
    // storing horizontal and vertical flipping without modifying the rotate angle
    // decompose other flipping to rotation and MirrorX.
    long ndx = rRef2.X()-rRef1.X();
    long ndy = rRef2.Y()-rRef1.Y();

    if(!ndx) // MirroredX
    {
         SetMirroredX(!IsMirroredX());
         SdrTextObj::NbcMirror( rRef1, rRef2 );
    }
    else
    {
        if(!ndy)  // MirroredY
        {
            SetMirroredY(!IsMirroredY());
            SdrTextObj::NbcMirror( rRef1, rRef2 );
        }
        else // neither horizontal nor vertical
        {
            SetMirroredX(!IsMirroredX());

            // call parent
            SdrTextObj::NbcMirror( rRef1, rRef2 );

            // update fObjectRotation
            long nTextObjRotation = aGeo.nDrehWink;
            double fWink = nTextObjRotation;
            
            fWink /= 100.0;
            
            bool bSingleFlip = (IsMirroredX()!= IsMirroredY());
            
            fObjectRotation = fmod( bSingleFlip ? -fWink : fWink, 360.0 );
            
            if ( fObjectRotation < 0 )
            {
                fObjectRotation = 360.0 + fObjectRotation;
            }
         }
    }

    InvalidateRenderGeometry();
}

void SdrObjCustomShape::Shear( const Point& rRef, long nWink, double tn, FASTBOOL bVShear )
{
	SdrTextObj::Shear( rRef, nWink, tn, bVShear );
	InvalidateRenderGeometry();
}
void SdrObjCustomShape::NbcShear( const Point& rRef, long nWink, double tn, FASTBOOL bVShear )
{
    // TTTT: Fix for old mirroring, can be removed again in aw080
     SdrTextObj::NbcShear(rRef,nWink,tn,bVShear);

    // updating fObjectRotation
    long nTextObjRotation = aGeo.nDrehWink;
    double fWink = nTextObjRotation;

    fWink /= 100.0;

    bool bSingleFlip = (IsMirroredX()!= IsMirroredY());

    fObjectRotation = fmod( bSingleFlip ? -fWink : fWink, 360.0 );

    if ( fObjectRotation < 0 )
    {
        fObjectRotation = 360.0 + fObjectRotation;
    }

    InvalidateRenderGeometry();
}

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

SdrGluePoint SdrObjCustomShape::GetVertexGluePoint(sal_uInt16 nPosNum) const
{
	sal_Int32 nWdt = ImpGetLineWdt(); // #i25616# ((XLineWidthItem&)(GetObjectItem(XATTR_LINEWIDTH))).GetValue();
	
	// #i25616#
	if(!LineIsOutsideGeometry())
	{
		nWdt++;
		nWdt /= 2;
	}

	Point aPt;
	switch (nPosNum) {
		case 0: aPt=aRect.TopCenter();    aPt.Y()-=nWdt; break;
		case 1: aPt=aRect.RightCenter();  aPt.X()+=nWdt; break;
		case 2: aPt=aRect.BottomCenter(); aPt.Y()+=nWdt; break;
		case 3: aPt=aRect.LeftCenter();   aPt.X()-=nWdt; break;
	}
	if (aGeo.nShearWink!=0) ShearPoint(aPt,aRect.TopLeft(),aGeo.nTan);
	if (aGeo.nDrehWink!=0) RotatePoint(aPt,aRect.TopLeft(),aGeo.nSin,aGeo.nCos);
	aPt-=GetSnapRect().Center();
	SdrGluePoint aGP(aPt);
	aGP.SetPercent(sal_False);
	return aGP;
}

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

// #i38892#
void SdrObjCustomShape::ImpCheckCustomGluePointsAreAdded()
{
	const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();

	if(pSdrObject)
	{
		const SdrGluePointList* pSource = pSdrObject->GetGluePointList();

		if(pSource && pSource->GetCount())
		{
			if(!SdrTextObj::GetGluePointList())
			{
				SdrTextObj::ForceGluePointList();
			}

			const SdrGluePointList* pList = SdrTextObj::GetGluePointList();

			if(pList)
			{
				SdrGluePointList aNewList;
				sal_uInt16 a;

				for(a = 0; a < pSource->GetCount(); a++)
				{
					SdrGluePoint aCopy((*pSource)[a]);
					aCopy.SetUserDefined(sal_False);
					aNewList.Insert(aCopy);
				}

				sal_Bool bMirroredX = IsMirroredX();
				sal_Bool bMirroredY = IsMirroredY();

				long nShearWink = aGeo.nShearWink;
				double fTan = aGeo.nTan;

				if ( aGeo.nDrehWink || nShearWink || bMirroredX || bMirroredY )
				{
					Polygon aPoly( aRect );
					if( nShearWink )
					{
						sal_uInt16 nPointCount=aPoly.GetSize();
						for (sal_uInt16 i=0; i<nPointCount; i++)
							ShearPoint(aPoly[i],aRect.Center(), fTan, sal_False );
					}
					if ( aGeo.nDrehWink )
						aPoly.Rotate( aRect.Center(), aGeo.nDrehWink / 10 );

					Rectangle aBoundRect( aPoly.GetBoundRect() );
					sal_Int32 nXDiff = aBoundRect.Left() - aRect.Left();
					sal_Int32 nYDiff = aBoundRect.Top() - aRect.Top();

					if (nShearWink&&((bMirroredX&&!bMirroredY)||(bMirroredY&&!bMirroredX)))
					{
						nShearWink = -nShearWink;
						fTan = -fTan;
					}

					Point aRef( aRect.GetWidth() / 2, aRect.GetHeight() / 2 );
					for ( a = 0; a < aNewList.GetCount(); a++ )
					{
						SdrGluePoint& rPoint = aNewList[ a ];
						Point aGlue( rPoint.GetPos() );
						if ( nShearWink )
							ShearPoint( aGlue, aRef, fTan );

						RotatePoint( aGlue, aRef, sin( fObjectRotation * F_PI180 ), cos( fObjectRotation * F_PI180 ) );
						if ( bMirroredX )
							aGlue.X() = aRect.GetWidth() - aGlue.X();
						if ( bMirroredY )
							aGlue.Y() = aRect.GetHeight() - aGlue.Y();
						aGlue.X() -= nXDiff;
						aGlue.Y() -= nYDiff;
						rPoint.SetPos( aGlue );
					}
				}

				for(a = 0; a < pList->GetCount(); a++)
				{
					const SdrGluePoint& rCandidate = (*pList)[a];

					if(rCandidate.IsUserDefined())
					{
						aNewList.Insert(rCandidate);
					}
				}

				// copy new list to local. This is NOT very convenient behaviour, the local
				// GluePointList should not be set, but be delivered by using GetGluePointList(),
				// maybe on demand. Since the local object is changed here, this is assumed to
				// be a result of GetGluePointList and thus the list is copied
				if(pPlusData)
				{
					*pPlusData->pGluePoints = aNewList;
				}
			}
		}
	}
}

// #i38892#
const SdrGluePointList* SdrObjCustomShape::GetGluePointList() const
{
	((SdrObjCustomShape*)this)->ImpCheckCustomGluePointsAreAdded();
	return SdrTextObj::GetGluePointList();
}

// #i38892#
//SdrGluePointList* SdrObjCustomShape::GetGluePointList()
//{
//	ImpCheckCustomGluePointsAreAdded();
//	return SdrTextObj::GetGluePointList();
//}

// #i38892#
SdrGluePointList* SdrObjCustomShape::ForceGluePointList()
{
	if(SdrTextObj::ForceGluePointList())
	{
		ImpCheckCustomGluePointsAreAdded();
		return SdrTextObj::ForceGluePointList();
	}
	else
	{
		return 0L;
	}
}

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

sal_uInt32 SdrObjCustomShape::GetHdlCount() const
{
	const sal_uInt32 nBasicHdlCount(SdrTextObj::GetHdlCount());
	std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
	return ( aInteractionHandles.size() + nBasicHdlCount );
}

SdrHdl* SdrObjCustomShape::GetHdl( sal_uInt32 nHdlNum ) const
{
	SdrHdl* pH = NULL;
	const sal_uInt32 nBasicHdlCount(SdrTextObj::GetHdlCount());

	if ( nHdlNum < nBasicHdlCount )
		pH = SdrTextObj::GetHdl( nHdlNum );
	else
	{
		std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
		const sal_uInt32 nCustomShapeHdlNum(nHdlNum - nBasicHdlCount);

		if ( nCustomShapeHdlNum < aInteractionHandles.size() )
		{
			if ( aInteractionHandles[ nCustomShapeHdlNum ].xInteraction.is() )
			{
				try
				{
					com::sun::star::awt::Point aPosition( aInteractionHandles[ nCustomShapeHdlNum ].xInteraction->getPosition() );
					pH = new SdrHdl( Point( aPosition.X, aPosition.Y ), HDL_CUSTOMSHAPE1 );
					pH->SetPointNum( nCustomShapeHdlNum );
					pH->SetObj( (SdrObject*)this );
				}
				catch ( const uno::RuntimeException& )
				{
				}
			}
		}
	}
	return pH;
}

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

bool SdrObjCustomShape::hasSpecialDrag() const
{
	return true;
}

bool SdrObjCustomShape::beginSpecialDrag(SdrDragStat& rDrag) const
{
	const SdrHdl* pHdl = rDrag.GetHdl();

    if(pHdl && HDL_CUSTOMSHAPE1 == pHdl->GetKind())
	{
		rDrag.SetEndDragChangesAttributes(true);
		rDrag.SetNoSnap(true);
	}
	else
	{
		const SdrHdl* pHdl2 = rDrag.GetHdl();
		const SdrHdlKind eHdl((pHdl2 == NULL) ? HDL_MOVE : pHdl2->GetKind());

        switch( eHdl )
		{
			case HDL_UPLFT :
			case HDL_UPPER :
			case HDL_UPRGT :
			case HDL_LEFT  :
			case HDL_RIGHT :
			case HDL_LWLFT :
			case HDL_LOWER :
			case HDL_LWRGT :
			case HDL_MOVE  :
			{
    			break;
			}
			default:
            {
				return false;
            }
		}
	}

    return true;
}

void SdrObjCustomShape::DragResizeCustomShape( const Rectangle& rNewRect, SdrObjCustomShape* pObj ) const
{
	Rectangle	aOld( pObj->aRect );
	sal_Bool	bOldMirroredX( pObj->IsMirroredX() );
	sal_Bool	bOldMirroredY( pObj->IsMirroredY() );

	Rectangle aNewRect( rNewRect );
	aNewRect.Justify();

	std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( pObj ) );

	GeoStat aGeoStat( pObj->GetGeoStat() );
	if ( aNewRect.TopLeft()!= pObj->aRect.TopLeft() &&
		( pObj->aGeo.nDrehWink || pObj->aGeo.nShearWink ) )
	{
		Point aNewPos( aNewRect.TopLeft() );
		if ( pObj->aGeo.nShearWink ) ShearPoint( aNewPos, aOld.TopLeft(), aGeoStat.nTan );
		if ( pObj->aGeo.nDrehWink )  RotatePoint(aNewPos, aOld.TopLeft(), aGeoStat.nSin, aGeoStat.nCos );
		aNewRect.SetPos( aNewPos );
	}
	if ( aNewRect != pObj->aRect )
	{
		pObj->SetLogicRect( aNewRect );
		pObj->InvalidateRenderGeometry();

		if ( rNewRect.Left() > rNewRect.Right() )
		{
			Point aTop( ( pObj->GetSnapRect().Left() + pObj->GetSnapRect().Right() ) >> 1, pObj->GetSnapRect().Top() );
			Point aBottom( aTop.X(), aTop.Y() + 1000 );
			pObj->NbcMirror( aTop, aBottom );
		}
		if ( rNewRect.Top() > rNewRect.Bottom() )
		{
			Point aLeft( pObj->GetSnapRect().Left(), ( pObj->GetSnapRect().Top() + pObj->GetSnapRect().Bottom() ) >> 1 );
			Point aRight( aLeft.X() + 1000, aLeft.Y() );
			pObj->NbcMirror( aLeft, aRight );
		}

		std::vector< SdrCustomShapeInteraction >::iterator aIter( aInteractionHandles.begin() );
		while ( aIter != aInteractionHandles.end() )
		{
			try
			{
				if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
					aIter->xInteraction->setControllerPosition( aIter->aPosition );
				if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_X )
				{
					sal_Int32 nX;
					if ( bOldMirroredX )
					{
						nX = ( aIter->aPosition.X - aOld.Right() );
						if ( rNewRect.Left() > rNewRect.Right() )
							nX = pObj->aRect.Left() - nX;
						else
							nX += pObj->aRect.Right();
					}
					else
					{
						nX = ( aIter->aPosition.X - aOld.Left() );
						if ( rNewRect.Left() > rNewRect.Right() )
							nX = pObj->aRect.Right() - nX;
						else
							nX += pObj->aRect.Left();
					}
					aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( nX, aIter->xInteraction->getPosition().Y ) );
				}
				if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_ABSOLUTE_Y )
				{
					sal_Int32 nY;
					if ( bOldMirroredY )
					{
						nY = ( aIter->aPosition.Y - aOld.Bottom() );
						if ( rNewRect.Top() > rNewRect.Bottom() )
							nY = pObj->aRect.Top() - nY;
						else
							nY += pObj->aRect.Bottom();
					}
					else
					{
						nY = ( aIter->aPosition.Y - aOld.Top() );
						if ( rNewRect.Top() > rNewRect.Bottom() )
							nY = pObj->aRect.Bottom() - nY;
						else
							nY += pObj->aRect.Top();
					}
					aIter->xInteraction->setControllerPosition( com::sun::star::awt::Point( aIter->xInteraction->getPosition().X, nY ) );
				}
			}
			catch ( const uno::RuntimeException& )
			{
			}
			aIter++;
		}
	}
}

void SdrObjCustomShape::DragMoveCustomShapeHdl( const Point aDestination, const sal_uInt16 nCustomShapeHdlNum, SdrObjCustomShape* pObj ) const
{
	std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( pObj ) );
	if ( nCustomShapeHdlNum < aInteractionHandles.size() )
	{
		SdrCustomShapeInteraction aInteractionHandle( aInteractionHandles[ nCustomShapeHdlNum ] );
		if ( aInteractionHandle.xInteraction.is() )
		{
			try
			{
				com::sun::star::awt::Point aPt( aDestination.X(), aDestination.Y() );
				if ( aInteractionHandle.nMode & CUSTOMSHAPE_HANDLE_MOVE_SHAPE )
				{
					sal_Int32 nXDiff = aPt.X - aInteractionHandle.aPosition.X;
					sal_Int32 nYDiff = aPt.Y - aInteractionHandle.aPosition.Y;

					pObj->aRect.Move( nXDiff, nYDiff );
					pObj->aOutRect.Move( nXDiff, nYDiff );
					pObj->maSnapRect.Move( nXDiff, nYDiff );
					pObj->SetRectsDirty(sal_True);
					pObj->InvalidateRenderGeometry();

					std::vector< SdrCustomShapeInteraction >::iterator aIter( aInteractionHandles.begin() );
					while ( aIter != aInteractionHandles.end() )
					{
						if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
						{
							if ( aIter->xInteraction.is() )
								aIter->xInteraction->setControllerPosition( aIter->aPosition );
						}
						aIter++;
					}
				}
				aInteractionHandle.xInteraction->setControllerPosition( aPt );
			}
			catch ( const uno::RuntimeException& )
			{
			}
		}
	}
}

bool SdrObjCustomShape::applySpecialDrag(SdrDragStat& rDrag)
{
	const SdrHdl* pHdl = rDrag.GetHdl();
	const SdrHdlKind eHdl((pHdl == NULL) ? HDL_MOVE : pHdl->GetKind());

    switch(eHdl)
	{
		case HDL_CUSTOMSHAPE1 :
		{
			rDrag.SetEndDragChangesGeoAndAttributes(true);
		    DragMoveCustomShapeHdl( rDrag.GetNow(), (sal_uInt16)pHdl->GetPointNum(), this );
		    SetRectsDirty();
		    InvalidateRenderGeometry();
		    SetChanged();
            break;
		}

		case HDL_UPLFT :
		case HDL_UPPER :
		case HDL_UPRGT :
		case HDL_LEFT  :
		case HDL_RIGHT :
		case HDL_LWLFT :
		case HDL_LOWER :
		case HDL_LWRGT :
		{
			DragResizeCustomShape(ImpDragCalcRect(rDrag), this);
			break;
		}
		case HDL_MOVE :
		{
			Move(Size(rDrag.GetDX(), rDrag.GetDY()));
			break;
		}
		default: break;
	}

    return true;
}

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

void SdrObjCustomShape::DragCreateObject( SdrDragStat& rStat )
{
	Rectangle aRect1;
	rStat.TakeCreateRect( aRect1 );

	std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );

	sal_uInt32 nDefaultObjectSizeWidth = 3000;		// default width from SDOptions ?
	sal_uInt32 nDefaultObjectSizeHeight= 3000;

	if ( ImpVerticalSwitch( *this ) )
	{
		SetMirroredX( aRect1.Left() > aRect1.Right() );

		aRect1 = Rectangle( rStat.GetNow(), Size( nDefaultObjectSizeWidth, nDefaultObjectSizeHeight ) );
		// subtracting the horizontal difference of the latest handle from shape position
		if ( !aInteractionHandles.empty() )
		{
			sal_Int32 nHandlePos = aInteractionHandles[ aInteractionHandles.size() - 1 ].xInteraction->getPosition().X;
			aRect1.Move( aRect.Left() - nHandlePos, 0 );
		}
	}
	ImpJustifyRect( aRect1 );
	rStat.SetActionRect( aRect1 );
	aRect = aRect1;
	SetRectsDirty();

	std::vector< SdrCustomShapeInteraction >::iterator aIter( aInteractionHandles.begin() );
	while ( aIter != aInteractionHandles.end() )
	{
		try
		{
			if ( aIter->nMode & CUSTOMSHAPE_HANDLE_CREATE_FIXED )
				aIter->xInteraction->setControllerPosition( awt::Point( rStat.GetStart().X(), rStat.GetStart().Y() ) );
		}
		catch ( const uno::RuntimeException& )
		{
		}
		aIter++;
	}

	SetBoundRectDirty();
	bSnapRectDirty=sal_True;
}

FASTBOOL SdrObjCustomShape::BegCreate( SdrDragStat& rDrag )
{
	return SdrTextObj::BegCreate( rDrag );
}

FASTBOOL SdrObjCustomShape::MovCreate(SdrDragStat& rStat)
{
	SdrView* pView = rStat.GetView();		// #i37448#
	if( pView && pView->IsSolidDragging() )
	{
		InvalidateRenderGeometry();
	}
	DragCreateObject( rStat );
	SetRectsDirty();
	return sal_True;
}

FASTBOOL SdrObjCustomShape::EndCreate( SdrDragStat& rStat, SdrCreateCmd eCmd )
{
    DragCreateObject( rStat );

    // #115391#
    AdaptTextMinSize();

    SetRectsDirty();
    return ( eCmd == SDRCREATE_FORCEEND || rStat.GetPointAnz() >= 2 );
}

basegfx::B2DPolyPolygon SdrObjCustomShape::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const
{
	return GetLineGeometry( this, sal_False );
}

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

// in context with the SdrObjCustomShape the SdrTextAutoGrowHeightItem == true -> Resize Shape to fit text,
//									   the SdrTextAutoGrowWidthItem  == true -> Word wrap text in Shape
FASTBOOL SdrObjCustomShape::IsAutoGrowHeight() const
{
	const SfxItemSet& rSet = GetMergedItemSet();
	FASTBOOL bIsAutoGrowHeight = ((SdrTextAutoGrowHeightItem&)(rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT))).GetValue();
	if ( bIsAutoGrowHeight && IsVerticalWriting() )
		bIsAutoGrowHeight = ((SdrTextWordWrapItem&)(rSet.Get(SDRATTR_TEXT_WORDWRAP))).GetValue() == sal_False;
	return bIsAutoGrowHeight;
}
FASTBOOL SdrObjCustomShape::IsAutoGrowWidth() const
{
	const SfxItemSet& rSet = GetMergedItemSet();
	FASTBOOL bIsAutoGrowWidth = ((SdrTextAutoGrowHeightItem&)(rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT))).GetValue();
	if ( bIsAutoGrowWidth && !IsVerticalWriting() )
		bIsAutoGrowWidth = ((SdrTextWordWrapItem&)(rSet.Get(SDRATTR_TEXT_WORDWRAP))).GetValue() == sal_False;
	return bIsAutoGrowWidth;
}

/* The following method is identical to the SdrTextObj::SetVerticalWriting method, the only difference
   is that the SdrAutoGrowWidthItem and SdrAutoGrowHeightItem are not exchanged if the vertical writing
   mode has been changed */

void SdrObjCustomShape::SetVerticalWriting( sal_Bool bVertical )
{
	ForceOutlinerParaObject();

	OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();

	DBG_ASSERT( pOutlinerParaObject, "SdrTextObj::SetVerticalWriting() without OutlinerParaObject!" );

	if( pOutlinerParaObject )
	{
		if(pOutlinerParaObject->IsVertical() != (bool)bVertical)
		{
			// get item settings
			const SfxItemSet& rSet = GetObjectItemSet();

			// #103516# Also exchange hor/ver adjust items
			SdrTextHorzAdjust eHorz = ((SdrTextHorzAdjustItem&)(rSet.Get(SDRATTR_TEXT_HORZADJUST))).GetValue();
			SdrTextVertAdjust eVert = ((SdrTextVertAdjustItem&)(rSet.Get(SDRATTR_TEXT_VERTADJUST))).GetValue();

			// rescue object size
			Rectangle aObjectRect = GetSnapRect();

			// prepare ItemSet to set exchanged width and height items
			SfxItemSet aNewSet(*rSet.GetPool(),
				SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT,
				// #103516# Expanded item ranges to also support hor and ver adjust.
				SDRATTR_TEXT_VERTADJUST, SDRATTR_TEXT_VERTADJUST,
				SDRATTR_TEXT_AUTOGROWWIDTH, SDRATTR_TEXT_HORZADJUST,
				0, 0);

			aNewSet.Put(rSet);

			// #103516# Exchange horz and vert adjusts
			switch(eVert)
			{
				case SDRTEXTVERTADJUST_TOP: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); break;
				case SDRTEXTVERTADJUST_CENTER: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); break;
				case SDRTEXTVERTADJUST_BOTTOM: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); break;
				case SDRTEXTVERTADJUST_BLOCK: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_BLOCK)); break;
			}
			switch(eHorz)
			{
				case SDRTEXTHORZADJUST_LEFT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); break;
				case SDRTEXTHORZADJUST_CENTER: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); break;
				case SDRTEXTHORZADJUST_RIGHT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); break;
				case SDRTEXTHORZADJUST_BLOCK: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); break;
			}

			pOutlinerParaObject = GetOutlinerParaObject();
			if ( pOutlinerParaObject )
				pOutlinerParaObject->SetVertical(bVertical);
			SetObjectItemSet( aNewSet );
	
			// restore object size
			SetSnapRect(aObjectRect);
		}
	}
}
FASTBOOL SdrObjCustomShape::AdjustTextFrameWidthAndHeight(Rectangle& rR, FASTBOOL bHgt, FASTBOOL bWdt) const
{
 	if ( pModel && HasText() && !rR.IsEmpty() )
	{
		FASTBOOL bWdtGrow=bWdt && IsAutoGrowWidth();
		FASTBOOL bHgtGrow=bHgt && IsAutoGrowHeight();
		if ( bWdtGrow || bHgtGrow )
		{
			Rectangle aR0(rR);
			long nHgt=0,nMinHgt=0,nMaxHgt=0;
			long nWdt=0,nMinWdt=0,nMaxWdt=0;
			Size aSiz(rR.GetSize()); aSiz.Width()--; aSiz.Height()--;
			Size aMaxSiz(100000,100000);
			Size aTmpSiz(pModel->GetMaxObjSize());
			if (aTmpSiz.Width()!=0) aMaxSiz.Width()=aTmpSiz.Width();
			if (aTmpSiz.Height()!=0) aMaxSiz.Height()=aTmpSiz.Height();
			if (bWdtGrow)
			{
				nMinWdt=GetMinTextFrameWidth();
				nMaxWdt=GetMaxTextFrameWidth();
				if (nMaxWdt==0 || nMaxWdt>aMaxSiz.Width()) nMaxWdt=aMaxSiz.Width();
				if (nMinWdt<=0) nMinWdt=1;
				aSiz.Width()=nMaxWdt;
			}
			if (bHgtGrow)
			{
				nMinHgt=GetMinTextFrameHeight();
				nMaxHgt=GetMaxTextFrameHeight();
				if (nMaxHgt==0 || nMaxHgt>aMaxSiz.Height()) nMaxHgt=aMaxSiz.Height();
				if (nMinHgt<=0) nMinHgt=1;
				aSiz.Height()=nMaxHgt;
			}
			long nHDist=GetTextLeftDistance()+GetTextRightDistance();
			long nVDist=GetTextUpperDistance()+GetTextLowerDistance();
			aSiz.Width()-=nHDist;
			aSiz.Height()-=nVDist;
			if ( aSiz.Width() < 2 )
				aSiz.Width() = 2;   // Mindestgroesse 2
			if ( aSiz.Height() < 2 )
				aSiz.Height() = 2; // Mindestgroesse 2

			if(pEdtOutl)
			{
				pEdtOutl->SetMaxAutoPaperSize( aSiz );
				if (bWdtGrow)
				{
					Size aSiz2(pEdtOutl->CalcTextSize());
					nWdt=aSiz2.Width()+1; // lieber etwas Tolleranz
					if (bHgtGrow) nHgt=aSiz2.Height()+1; // lieber etwas Tolleranz
				} else
				{
					nHgt=pEdtOutl->GetTextHeight()+1; // lieber etwas Tolleranz
				}
			}
			else
			{
				Outliner& rOutliner=ImpGetDrawOutliner();
				rOutliner.SetPaperSize(aSiz);
				rOutliner.SetUpdateMode(sal_True);
				// !!! hier sollte ich wohl auch noch mal die Optimierung mit
				// bPortionInfoChecked usw einbauen
				OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject();
				if( pOutlinerParaObject != NULL )
				{
					rOutliner.SetText(*pOutlinerParaObject);
					rOutliner.SetFixedCellHeight(((const SdrTextFixedCellHeightItem&)GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue());
				}
				if ( bWdtGrow )
				{
					Size aSiz2(rOutliner.CalcTextSize());
					nWdt=aSiz2.Width()+1; // lieber etwas Tolleranz
					if ( bHgtGrow )
						nHgt=aSiz2.Height()+1; // lieber etwas Tolleranz
				}
				else
					nHgt = rOutliner.GetTextHeight()+1; // lieber etwas Tolleranz
				rOutliner.Clear();
			}
			if ( nWdt < nMinWdt )
				nWdt = nMinWdt;
			if ( nWdt > nMaxWdt )
				nWdt = nMaxWdt;
			nWdt += nHDist;
			if ( nWdt < 1 )
				nWdt = 1; // nHDist kann auch negativ sein
			if ( nHgt < nMinHgt )
				nHgt = nMinHgt;
			if ( nHgt > nMaxHgt )
				nHgt = nMaxHgt;
			nHgt+=nVDist;
			if ( nHgt < 1 )
				nHgt = 1; // nVDist kann auch negativ sein
			long nWdtGrow = nWdt-(rR.Right()-rR.Left());
			long nHgtGrow = nHgt-(rR.Bottom()-rR.Top());
			if ( nWdtGrow == 0 )
				bWdtGrow = sal_False;
			if ( nHgtGrow == 0 )
				bHgtGrow=sal_False;
			if ( bWdtGrow || bHgtGrow )
			{
				if ( bWdtGrow )
				{
					SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust();
					if ( eHAdj == SDRTEXTHORZADJUST_LEFT )
						rR.Right()+=nWdtGrow;
					else if ( eHAdj == SDRTEXTHORZADJUST_RIGHT )
						rR.Left()-=nWdtGrow;
					else
					{
						long nWdtGrow2=nWdtGrow/2;
						rR.Left()-=nWdtGrow2;
						rR.Right()=rR.Left()+nWdt;
					}
				}
				if ( bHgtGrow )
				{
					SdrTextVertAdjust eVAdj=GetTextVerticalAdjust();
					if ( eVAdj == SDRTEXTVERTADJUST_TOP )
						rR.Bottom()+=nHgtGrow;
					else if ( eVAdj == SDRTEXTVERTADJUST_BOTTOM )
						rR.Top()-=nHgtGrow;
					else
					{
						long nHgtGrow2=nHgtGrow/2;
						rR.Top()-=nHgtGrow2;
						rR.Bottom()=rR.Top()+nHgt;
					}
				}
				if ( aGeo.nDrehWink )
				{
					Point aD1(rR.TopLeft());
					aD1-=aR0.TopLeft();
					Point aD2(aD1);
					RotatePoint(aD2,Point(),aGeo.nSin,aGeo.nCos);
					aD2-=aD1;
					rR.Move(aD2.X(),aD2.Y());
				}
				return sal_True;
			}
		}
	}
	return sal_False;
}

Rectangle SdrObjCustomShape::ImpCalculateTextFrame( const FASTBOOL bHgt, const FASTBOOL bWdt )
{
	Rectangle aReturnValue;

	Rectangle aOldTextRect( aRect );		// <- initial text rectangle

	Rectangle aNewTextRect( aRect );		// <- new text rectangle returned from the custom shape renderer,
	GetTextBounds( aNewTextRect );			//    it depends to the current logical shape size

	Rectangle aAdjustedTextRect( aNewTextRect );							// <- new text rectangle is being tested by AdjustTextFrameWidthAndHeight to ensure
	if ( AdjustTextFrameWidthAndHeight( aAdjustedTextRect, bHgt, bWdt ) )	//    that the new text rectangle is matching the current text size from the outliner
	{
		if ( ( aAdjustedTextRect != aNewTextRect ) && ( aOldTextRect != aAdjustedTextRect ) )
		{
			aReturnValue = aRect;
			double fXScale = (double)aOldTextRect.GetWidth() / (double)aNewTextRect.GetWidth();
			double fYScale = (double)aOldTextRect.GetHeight() / (double)aNewTextRect.GetHeight();
			double fRightDiff = (double)( aAdjustedTextRect.Right() - aNewTextRect.Right() ) * fXScale;
			double fLeftDiff  = (double)( aAdjustedTextRect.Left()  - aNewTextRect.Left()  ) * fXScale;
			double fTopDiff   = (double)( aAdjustedTextRect.Top()   - aNewTextRect.Top()   ) * fYScale;
			double fBottomDiff= (double)( aAdjustedTextRect.Bottom()- aNewTextRect.Bottom()) * fYScale;
			aReturnValue.Left() += (sal_Int32)fLeftDiff;
			aReturnValue.Right() += (sal_Int32)fRightDiff;
			aReturnValue.Top() += (sal_Int32)fTopDiff;
			aReturnValue.Bottom() += (sal_Int32)fBottomDiff;
		}
	}
	return aReturnValue;
}

FASTBOOL SdrObjCustomShape::NbcAdjustTextFrameWidthAndHeight(FASTBOOL bHgt, FASTBOOL bWdt)
{
	Rectangle aNewTextRect = ImpCalculateTextFrame( bHgt, bWdt );
	sal_Bool bRet = !aNewTextRect.IsEmpty() && ( aNewTextRect != aRect );
	if ( bRet )
	{
		// taking care of handles that should not been changed
		std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );

		aRect = aNewTextRect;
		SetRectsDirty();
		SetChanged();

		std::vector< SdrCustomShapeInteraction >::iterator aIter( aInteractionHandles.begin() );
		while ( aIter != aInteractionHandles.end() )
		{
			try
			{
				if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
					aIter->xInteraction->setControllerPosition( aIter->aPosition );
			}
			catch ( const uno::RuntimeException& )
			{
			}
			aIter++;
		}
		InvalidateRenderGeometry();
	}
	return bRet;
}
FASTBOOL SdrObjCustomShape::AdjustTextFrameWidthAndHeight(FASTBOOL bHgt, FASTBOOL bWdt)
{
	Rectangle aNewTextRect = ImpCalculateTextFrame( bHgt, bWdt );
	sal_Bool bRet = !aNewTextRect.IsEmpty() && ( aNewTextRect != aRect );
	if ( bRet )
	{
		Rectangle aBoundRect0;
		if ( pUserCall )
			aBoundRect0 = GetCurrentBoundRect();

		// taking care of handles that should not been changed
		std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles( this ) );
	
//		SendRepaintBroadcast();
		aRect = aNewTextRect;
		SetRectsDirty();

		std::vector< SdrCustomShapeInteraction >::iterator aIter( aInteractionHandles.begin() );
		while ( aIter != aInteractionHandles.end() )
		{
			try
			{
				if ( aIter->nMode & CUSTOMSHAPE_HANDLE_RESIZE_FIXED )
					aIter->xInteraction->setControllerPosition( aIter->aPosition );
			}
			catch ( const uno::RuntimeException& )
			{
			}
			aIter++;
		}

		InvalidateRenderGeometry();
		SetChanged();
//		SendRepaintBroadcast();
		BroadcastObjectChange();
		SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
	}
	return bRet;
}
sal_Bool SdrObjCustomShape::BegTextEdit( SdrOutliner& rOutl )
{
	return SdrTextObj::BegTextEdit( rOutl );
}
void SdrObjCustomShape::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, Rectangle* pViewInit, Rectangle* pViewMin) const
{
	Size aPaperMin,aPaperMax;
	Rectangle aViewInit;
	TakeTextAnchorRect( aViewInit );
	if ( aGeo.nDrehWink )
	{
		Point aCenter(aViewInit.Center());
		aCenter-=aViewInit.TopLeft();
		Point aCenter0(aCenter);
		RotatePoint(aCenter,Point(),aGeo.nSin,aGeo.nCos);
		aCenter-=aCenter0;
		aViewInit.Move(aCenter.X(),aCenter.Y());
	}
	Size aAnkSiz(aViewInit.GetSize());
	aAnkSiz.Width()--; aAnkSiz.Height()--; // weil GetSize() ein draufaddiert
	Size aMaxSiz(1000000,1000000);
	if (pModel!=NULL) {
		Size aTmpSiz(pModel->GetMaxObjSize());
		if (aTmpSiz.Width()!=0) aMaxSiz.Width()=aTmpSiz.Width();
		if (aTmpSiz.Height()!=0) aMaxSiz.Height()=aTmpSiz.Height();
	}
	SdrTextHorzAdjust eHAdj(GetTextHorizontalAdjust());
	SdrTextVertAdjust eVAdj(GetTextVerticalAdjust());

	long nMinWdt = GetMinTextFrameWidth();
	long nMinHgt = GetMinTextFrameHeight();
	long nMaxWdt = GetMaxTextFrameWidth();
	long nMaxHgt = GetMaxTextFrameHeight();
	if (nMinWdt<1) nMinWdt=1;
	if (nMinHgt<1) nMinHgt=1;
	if ( nMaxWdt == 0 || nMaxWdt > aMaxSiz.Width() )
		nMaxWdt = aMaxSiz.Width();
	if ( nMaxHgt == 0 || nMaxHgt > aMaxSiz.Height() )
		nMaxHgt=aMaxSiz.Height();

	if (((SdrTextWordWrapItem&)(GetMergedItem(SDRATTR_TEXT_WORDWRAP))).GetValue())
	{
		if ( IsVerticalWriting() )
		{
			nMaxHgt = aAnkSiz.Height();
			nMinHgt = nMaxHgt;
		}
		else
		{
			nMaxWdt = aAnkSiz.Width();
			nMinWdt = nMaxWdt;
		}
	}
	aPaperMax.Width()=nMaxWdt;
	aPaperMax.Height()=nMaxHgt;

	aPaperMin.Width()=nMinWdt;
	aPaperMin.Height()=nMinHgt;

	if ( pViewMin )
	{
		*pViewMin = aViewInit;

		long nXFree = aAnkSiz.Width() - aPaperMin.Width();
		if ( eHAdj == SDRTEXTHORZADJUST_LEFT )
			pViewMin->Right() -= nXFree;
		else if ( eHAdj == SDRTEXTHORZADJUST_RIGHT )
			pViewMin->Left() += nXFree;
		else { pViewMin->Left() += nXFree / 2; pViewMin->Right() = pViewMin->Left() + aPaperMin.Width(); }

		long nYFree = aAnkSiz.Height() - aPaperMin.Height();
		if ( eVAdj == SDRTEXTVERTADJUST_TOP )
			pViewMin->Bottom() -= nYFree;
		else if ( eVAdj == SDRTEXTVERTADJUST_BOTTOM )
			pViewMin->Top() += nYFree;
		else { pViewMin->Top() += nYFree / 2; pViewMin->Bottom() = pViewMin->Top() + aPaperMin.Height(); }
	}

	if( IsVerticalWriting() )
		aPaperMin.Width() = 0;
	else
		aPaperMin.Height() = 0; // #33102#

	if( eHAdj != SDRTEXTHORZADJUST_BLOCK )
		aPaperMin.Width()=0;

	// #103516# For complete ver adjust support, set paper min height to 0, here.
	if(SDRTEXTVERTADJUST_BLOCK != eVAdj )
		aPaperMin.Height() = 0;

	if (pPaperMin!=NULL) *pPaperMin=aPaperMin;
	if (pPaperMax!=NULL) *pPaperMax=aPaperMax;
	if (pViewInit!=NULL) *pViewInit=aViewInit;
}
void SdrObjCustomShape::EndTextEdit( SdrOutliner& rOutl )
{
	SdrTextObj::EndTextEdit( rOutl );
	InvalidateRenderGeometry();
}
void SdrObjCustomShape::TakeTextAnchorRect( Rectangle& rAnchorRect ) const
{
	if ( GetTextBounds( rAnchorRect ) )
	{
		Point aRotateRef( maSnapRect.Center() );
		rAnchorRect.Left()   += GetTextLeftDistance();
		rAnchorRect.Top()    += GetTextUpperDistance();
		rAnchorRect.Right()  -= GetTextRightDistance();
		rAnchorRect.Bottom() -= GetTextLowerDistance();
		ImpJustifyRect( rAnchorRect );

		if ( rAnchorRect.GetWidth() < 2 )
			rAnchorRect.Right() = rAnchorRect.Left() + 1;	// minimal width is 2
		if ( rAnchorRect.GetHeight() < 2 )
			rAnchorRect.Bottom() = rAnchorRect.Top() + 1;	// minimal height is 2
		if ( aGeo.nDrehWink )
		{
			Point aP( rAnchorRect.TopLeft() );
			RotatePoint( aP, aRotateRef, aGeo.nSin, aGeo. nCos );
			rAnchorRect.SetPos( aP );
		}
	}
	else
		SdrTextObj::TakeTextAnchorRect( rAnchorRect );
}
void SdrObjCustomShape::TakeTextRect( SdrOutliner& rOutliner, Rectangle& rTextRect, FASTBOOL bNoEditText,
	                           Rectangle* pAnchorRect, sal_Bool /*bLineWidth*/) const
{
	Rectangle aAnkRect; // Rect innerhalb dem geankert wird
	TakeTextAnchorRect(aAnkRect);
	SdrTextVertAdjust eVAdj=GetTextVerticalAdjust();
	SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust();
	sal_uIntPtr nStat0=rOutliner.GetControlWord();
	Size aNullSize;

	rOutliner.SetControlWord(nStat0|EE_CNTRL_AUTOPAGESIZE);
	rOutliner.SetMinAutoPaperSize(aNullSize);
	sal_Int32 nMaxAutoPaperWidth = 1000000;
	sal_Int32 nMaxAutoPaperHeight= 1000000;

	long nAnkWdt=aAnkRect.GetWidth();
	long nAnkHgt=aAnkRect.GetHeight();

	if (((SdrTextWordWrapItem&)(GetMergedItem(SDRATTR_TEXT_WORDWRAP))).GetValue())
	{
		if ( IsVerticalWriting() )
			nMaxAutoPaperHeight = nAnkHgt;
		else
			nMaxAutoPaperWidth = nAnkWdt;
	}
	if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting())
	{
		rOutliner.SetMinAutoPaperSize(Size(nAnkWdt, 0));
	}

	if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())
	{
		rOutliner.SetMinAutoPaperSize(Size(0, nAnkHgt));
	}
	rOutliner.SetMaxAutoPaperSize( Size( nMaxAutoPaperWidth, nMaxAutoPaperHeight ) );
	rOutliner.SetPaperSize( aNullSize );

	// Text in den Outliner stecken - ggf. den aus dem EditOutliner
	OutlinerParaObject* pPara= GetOutlinerParaObject();
	if (pEdtOutl && !bNoEditText)
		pPara=pEdtOutl->CreateParaObject();

	if (pPara)
	{
		sal_Bool bHitTest = sal_False;
		if( pModel )
			bHitTest = &pModel->GetHitTestOutliner() == &rOutliner;

		const SdrTextObj* pTestObj = rOutliner.GetTextObj();
		if( !pTestObj || !bHitTest || pTestObj != this ||
		    pTestObj->GetOutlinerParaObject() != GetOutlinerParaObject() )
		{
			if( bHitTest )
				rOutliner.SetTextObj( this );

			rOutliner.SetUpdateMode(sal_True);
			rOutliner.SetText(*pPara);
		}
	}
	else
	{
		rOutliner.SetTextObj( NULL );
	}
	if (pEdtOutl && !bNoEditText && pPara)
		delete pPara;

	rOutliner.SetUpdateMode(sal_True);
	rOutliner.SetControlWord(nStat0);

	SdrText* pText = getActiveText();
	if( pText )
		pText->CheckPortionInfo( rOutliner );

	Point aTextPos(aAnkRect.TopLeft());
	Size aTextSiz(rOutliner.GetPaperSize()); // GetPaperSize() hat etwas Toleranz drauf, oder?

	// #106653#
	// For draw objects containing text correct hor/ver alignment if text is bigger
	// than the object itself. Without that correction, the text would always be
		// formatted to the left edge (or top edge when vertical) of the draw object.

	if( !IsTextFrame() )
	{
		if(aAnkRect.GetWidth() < aTextSiz.Width() && !IsVerticalWriting())
		{
			// #110129#
			// Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK,
			// else the alignment is wanted.
			if(SDRTEXTHORZADJUST_BLOCK == eHAdj)
			{
				eHAdj = SDRTEXTHORZADJUST_CENTER;
			}
		}

		if(aAnkRect.GetHeight() < aTextSiz.Height() && IsVerticalWriting())
		{
			// #110129#
			// Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK,
			// else the alignment is wanted.
			if(SDRTEXTVERTADJUST_BLOCK == eVAdj)
			{
				eVAdj = SDRTEXTVERTADJUST_CENTER;
			}
		}
	}

	if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT)
	{
		long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width();
		if (eHAdj==SDRTEXTHORZADJUST_CENTER)
			aTextPos.X()+=nFreeWdt/2;
		if (eHAdj==SDRTEXTHORZADJUST_RIGHT)
			aTextPos.X()+=nFreeWdt;
	}
	if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM)
	{
		long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height();
		if (eVAdj==SDRTEXTVERTADJUST_CENTER)
			aTextPos.Y()+=nFreeHgt/2;
		if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
			aTextPos.Y()+=nFreeHgt;
	}
	if (aGeo.nDrehWink!=0)
		RotatePoint(aTextPos,aAnkRect.TopLeft(),aGeo.nSin,aGeo.nCos);

	if (pAnchorRect)
		*pAnchorRect=aAnkRect;

	// rTextRect ist bei ContourFrame in einigen Faellen nicht korrekt
	rTextRect=Rectangle(aTextPos,aTextSiz);
}

void SdrObjCustomShape::NbcSetOutlinerParaObject(OutlinerParaObject* pTextObject)
{
	SdrTextObj::NbcSetOutlinerParaObject( pTextObject );
	SetBoundRectDirty();
	SetRectsDirty(sal_True);
	InvalidateRenderGeometry();
}

void SdrObjCustomShape::operator=(const SdrObject& rObj)
{
	SdrTextObj::operator=( rObj );
	aName =((SdrObjCustomShape&)rObj).aName;
	fObjectRotation = ((SdrObjCustomShape&)rObj).fObjectRotation;
	InvalidateRenderGeometry();
}


void SdrObjCustomShape::TakeObjNameSingul(XubString& rName) const
{
	rName = ImpGetResStr(STR_ObjNameSingulCUSTOMSHAPE);
	String aNm( GetName() );
	if( aNm.Len() )
	{
		rName += sal_Unicode(' ');
		rName += sal_Unicode('\'');
		rName += aNm;
		rName += sal_Unicode('\'');
	}
}

void SdrObjCustomShape::TakeObjNamePlural(XubString& rName) const
{
	rName=ImpGetResStr(STR_ObjNamePluralCUSTOMSHAPE);
}

basegfx::B2DPolyPolygon SdrObjCustomShape::TakeXorPoly() const
{
	return GetLineGeometry( (SdrObjCustomShape*)this, sal_False );
}

basegfx::B2DPolyPolygon SdrObjCustomShape::TakeContour() const
{
	const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
	if ( pSdrObject )
		return pSdrObject->TakeContour();
	return basegfx::B2DPolyPolygon();
}

SdrObject* SdrObjCustomShape::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const
{
	// #i37011#
	SdrObject* pRetval = 0L;
	SdrObject* pRenderedCustomShape = 0L;

	if ( !mXRenderedCustomShape.is() )
	{
		// force CustomShape
		((SdrObjCustomShape*)this)->GetSdrObjectFromCustomShape();
	}

	if ( mXRenderedCustomShape.is() )
	{
		pRenderedCustomShape = GetSdrObjectFromXShape( mXRenderedCustomShape );
	}

	if ( pRenderedCustomShape )
	{
		SdrObject* pCandidate = pRenderedCustomShape->Clone();
		DBG_ASSERT(pCandidate, "SdrObjCustomShape::DoConvertToPolyObj: Could not clone SdrObject (!)");
		pCandidate->SetModel(GetModel());
		pRetval = pCandidate->DoConvertToPolyObj(bBezier, bAddText);
		SdrObject::Free( pCandidate );

		if(pRetval)
		{
			const sal_Bool bShadow(((SdrShadowItem&)GetMergedItem(SDRATTR_SHADOW)).GetValue());
			if(bShadow)
			{
				pRetval->SetMergedItem(SdrShadowItem(sal_True));
			}
		}

		if(bAddText && HasText() && !IsTextPath())
		{
			pRetval = ImpConvertAddText(pRetval, bBezier);
		}
	}

	return pRetval;
}

void SdrObjCustomShape::NbcSetStyleSheet( SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr )
{
	// #i40944#
	InvalidateRenderGeometry();
	SdrObject::NbcSetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr );
}

void SdrObjCustomShape::SetPage( SdrPage* pNewPage )
{
	SdrTextObj::SetPage( pNewPage );

	if( pNewPage )
	{
		// invalidating rectangles by SetRectsDirty is not sufficient,
		// AdjustTextFrameWidthAndHeight() also has to be made, both
		// actions are done by NbcSetSnapRect
		Rectangle aTmp( aRect );	//creating temporary rectangle #i61108#
		NbcSetSnapRect( aTmp );
	}
}

SdrObjGeoData* SdrObjCustomShape::NewGeoData() const
{
	return new SdrAShapeObjGeoData;
}

void SdrObjCustomShape::SaveGeoData(SdrObjGeoData& rGeo) const
{
	SdrTextObj::SaveGeoData( rGeo );
	SdrAShapeObjGeoData& rAGeo=(SdrAShapeObjGeoData&)rGeo;
	rAGeo.fObjectRotation = fObjectRotation;
	rAGeo.bMirroredX = IsMirroredX();
	rAGeo.bMirroredY = IsMirroredY();

	const rtl::OUString	sAdjustmentValues( RTL_CONSTASCII_USTRINGPARAM ( "AdjustmentValues" ) );
	Any* pAny( ( (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ).GetPropertyValueByName( sAdjustmentValues ) );
	if ( pAny )
		*pAny >>= rAGeo.aAdjustmentSeq;
}

void SdrObjCustomShape::RestGeoData(const SdrObjGeoData& rGeo)
{
	SdrTextObj::RestGeoData( rGeo );
	SdrAShapeObjGeoData& rAGeo=(SdrAShapeObjGeoData&)rGeo;
	fObjectRotation = rAGeo.fObjectRotation;
	SetMirroredX( rAGeo.bMirroredX );
	SetMirroredY( rAGeo.bMirroredY );

	SdrCustomShapeGeometryItem rGeometryItem = (SdrCustomShapeGeometryItem&)GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
	const rtl::OUString	sAdjustmentValues( RTL_CONSTASCII_USTRINGPARAM ( "AdjustmentValues" ) );
	PropertyValue aPropVal;
	aPropVal.Name = sAdjustmentValues;
	aPropVal.Value <<= rAGeo.aAdjustmentSeq;
	rGeometryItem.SetPropertyValue( aPropVal );
	SetMergedItem( rGeometryItem );

	InvalidateRenderGeometry();
}

void SdrObjCustomShape::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
{
	// break up matrix
	basegfx::B2DTuple aScale;
	basegfx::B2DTuple aTranslate;
	double fRotate, fShearX;
	rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);

	// #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
	// in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
    const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0));
    const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0));

	if(bMirrorX && bMirrorY)
	{
		aScale.setX(fabs(aScale.getX()));
		aScale.setY(fabs(aScale.getY()));
		fRotate = fmod(fRotate + F_PI, F_2PI);
	}
    else if(bMirrorX || bMirrorY)
    {
        basegfx::B2DHomMatrix aNew;

        // create pre-multiplied matrix without mirroring
        aNew.translate(-0.5, -0.5);
        aNew.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0);
        aNew.translate(0.5, 0.5);
        aNew = rMatrix * aNew;

        // decompose to get corrected, mirror-free values
        aNew.decompose(aScale, aTranslate, fRotate, fShearX);

        // apply mirroring to CustomShapeGeometry
        if((bool)IsMirroredX() != bMirrorX)
        {
            SetMirroredX(bMirrorX);
        }

        if((bool)IsMirroredY() != bMirrorY)
        {
            SetMirroredY(bMirrorY);
        }
    }

	// reset object shear and rotations
	aGeo.nDrehWink = 0;
	aGeo.RecalcSinCos();
	aGeo.nShearWink = 0;
	aGeo.RecalcTan();

	// force metric to pool metric
	const SfxMapUnit eMapUnit(GetObjectMapUnit());
	if(eMapUnit != SFX_MAPUNIT_100TH_MM)
	{
		switch(eMapUnit)
		{
			case SFX_MAPUNIT_TWIP :
			{
				// position
				aTranslate.setX(ImplMMToTwips(aTranslate.getX()));
				aTranslate.setY(ImplMMToTwips(aTranslate.getY()));

				// size
				aScale.setX(ImplMMToTwips(aScale.getX()));
				aScale.setY(ImplMMToTwips(aScale.getY()));

				break;
			}
			default:
			{
				DBG_ERROR("TRSetBaseGeometry: Missing unit translation to PoolMetric!");
			}
		}
	}

	// if anchor is used, make position relative to it
	if( pModel && pModel->IsWriter() )
	{
		if(GetAnchorPos().X() || GetAnchorPos().Y())
		{
			aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
		}
	}

	// build and set BaseRect (use scale)
	Point aPoint = Point();
	Size aSize(FRound(aScale.getX()), FRound(aScale.getY()));
	Rectangle aBaseRect(aPoint, aSize);
	SetSnapRect(aBaseRect);

	// shear?
	if(!basegfx::fTools::equalZero(fShearX))
	{
		GeoStat aGeoStat;
        // #123181# The fix for #121932# here was wrong, the trunk version does not correct the
        // mirrored shear values, neither at the object level, nor on the API or XML level. Taking
        // back the mirroring of the shear angle
		aGeoStat.nShearWink = FRound((atan(fShearX) / F_PI180) * 100.0);
		aGeoStat.RecalcTan();
		Shear(Point(), aGeoStat.nShearWink, aGeoStat.nTan, sal_False);
	}

	// rotation?
    if(!basegfx::fTools::equalZero(fRotate))
	{
		GeoStat aGeoStat;

        // #i78696# 
        // fRotate is mathematically correct, but aGeoStat.nDrehWink is
        // mirrored -> mirror value here
		aGeoStat.nDrehWink = NormAngle360(FRound(-fRotate / F_PI18000));
		aGeoStat.RecalcSinCos();
		Rotate(Point(), aGeoStat.nDrehWink, aGeoStat.nSin, aGeoStat.nCos);
	}

	// translate?
    if(!aTranslate.equalZero())
	{
		Move(Size(FRound(aTranslate.getX()), FRound(aTranslate.getY())));
	}
}

// taking fObjectRotation instead of aGeo.nWink
sal_Bool SdrObjCustomShape::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const
{
	// get turn and shear
//	double fRotate = (aGeo.nDrehWink / 100.0) * F_PI180;
	double fRotate = fObjectRotation * F_PI180;
	double fShearX = (aGeo.nShearWink / 100.0) * F_PI180;

	// get aRect, this is the unrotated snaprect
	Rectangle aRectangle(aRect);

	sal_Bool bMirroredX = IsMirroredX();
	sal_Bool bMirroredY = IsMirroredY();
	if ( bMirroredX || bMirroredY )
	{	// we have to retrieve the unmirrored rect

		GeoStat aNewGeo( aGeo );

		if ( bMirroredX )
		{
			Polygon aPol( Rect2Poly( aRect, aNewGeo ) );
			Rectangle aBoundRect( aPol.GetBoundRect() );

			Point aRef1( ( aBoundRect.Left() + aBoundRect.Right() ) >> 1, aBoundRect.Top() );
			Point aRef2( aRef1.X(), aRef1.Y() + 1000 );
			sal_uInt16 i;
			sal_uInt16 nPntAnz=aPol.GetSize();
			for (i=0; i<nPntAnz; i++)
			{
				MirrorPoint(aPol[i],aRef1,aRef2);
			}
			// Polygon wenden und etwas schieben
			Polygon aPol0(aPol);
			aPol[0]=aPol0[1];
			aPol[1]=aPol0[0];
			aPol[2]=aPol0[3];
			aPol[3]=aPol0[2];
			aPol[4]=aPol0[1];
			Poly2Rect(aPol,aRectangle,aNewGeo);
		}
		if ( bMirroredY )
		{
			Polygon aPol( Rect2Poly( aRectangle, aNewGeo ) );
			Rectangle aBoundRect( aPol.GetBoundRect() );

			Point aRef1( aBoundRect.Left(), ( aBoundRect.Top() + aBoundRect.Bottom() ) >> 1 );
			Point aRef2( aRef1.X() + 1000, aRef1.Y() );
			sal_uInt16 i;
			sal_uInt16 nPntAnz=aPol.GetSize();
			for (i=0; i<nPntAnz; i++)
			{
				MirrorPoint(aPol[i],aRef1,aRef2);
			}
			// Polygon wenden und etwas schieben
			Polygon aPol0(aPol);
			aPol[0]=aPol0[1]; // This was WRONG for vertical (!)
			aPol[1]=aPol0[0]; // #121932# Despite my own coment above
			aPol[2]=aPol0[3]; // it was *not* wrong even when the reordering
			aPol[3]=aPol0[2]; // *seems* to be specific for X-Mirrorings. Oh
			aPol[4]=aPol0[1]; // will I be happy when this old stuff is |gone| with aw080 (!)
			Poly2Rect(aPol,aRectangle,aNewGeo);
		}
	}

	// fill other values
	basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight());
	basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top());

	// position maybe relative to anchorpos, convert
	if( pModel && pModel->IsWriter() )
	{
		if(GetAnchorPos().X() || GetAnchorPos().Y())
		{
			aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
		}
	}

	// force MapUnit to 100th mm
	const SfxMapUnit eMapUnit(GetObjectMapUnit());
	if(eMapUnit != SFX_MAPUNIT_100TH_MM)
	{
		switch(eMapUnit)
		{
			case SFX_MAPUNIT_TWIP :
			{
				// postion
				aTranslate.setX(ImplTwipsToMM(aTranslate.getX()));
				aTranslate.setY(ImplTwipsToMM(aTranslate.getY()));

				// size
				aScale.setX(ImplTwipsToMM(aScale.getX()));
				aScale.setY(ImplTwipsToMM(aScale.getY()));

				break;
			}
			default:
			{
				DBG_ERROR("TRGetBaseGeometry: Missing unit translation to 100th mm!");
			}
		}
	}

	// build matrix
	rMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
		aScale,
		basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX),
		basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate,
		aTranslate);

	return sal_False;
}

sdr::contact::ViewContact* SdrObjCustomShape::CreateObjectSpecificViewContact()
{
	return new sdr::contact::ViewContactOfSdrObjCustomShape(*this);
}

// #i33136#
bool SdrObjCustomShape::doConstructOrthogonal(const ::rtl::OUString& rName)
{
	bool bRetval(false);
	static ::rtl::OUString Imps_sNameASOrtho_quadrat( RTL_CONSTASCII_USTRINGPARAM( "quadrat" ) );
	static ::rtl::OUString Imps_sNameASOrtho_round_quadrat( RTL_CONSTASCII_USTRINGPARAM( "round-quadrat" ) );
	static ::rtl::OUString Imps_sNameASOrtho_circle( RTL_CONSTASCII_USTRINGPARAM( "circle" ) );
	static ::rtl::OUString Imps_sNameASOrtho_circle_pie( RTL_CONSTASCII_USTRINGPARAM( "circle-pie" ) );
	static ::rtl::OUString Imps_sNameASOrtho_ring( RTL_CONSTASCII_USTRINGPARAM( "ring" ) );

	if(Imps_sNameASOrtho_quadrat.equalsIgnoreAsciiCase(rName))
	{
		bRetval = true;
	}
	else if(Imps_sNameASOrtho_round_quadrat.equalsIgnoreAsciiCase(rName))
	{
		bRetval = true;
	}
	else if(Imps_sNameASOrtho_circle.equalsIgnoreAsciiCase(rName))
	{
		bRetval = true;
	}
	else if(Imps_sNameASOrtho_circle_pie.equalsIgnoreAsciiCase(rName))
	{
		bRetval = true;
	}
	else if(Imps_sNameASOrtho_ring.equalsIgnoreAsciiCase(rName))
	{
		bRetval = true;
	}

	return bRetval;
}

// #i37011# centralize throw-away of render geometry
void SdrObjCustomShape::InvalidateRenderGeometry()
{
	mXRenderedCustomShape = 0L;
    SdrObject::Free( mpLastShadowGeometry );
	mpLastShadowGeometry = 0L;
}

::rtl::OUString SdrObjCustomShape::GetCustomShapeName()
{
	rtl::OUString sShapeName;
	rtl::OUString aEngine( ( (SdrCustomShapeEngineItem&)( *this ).GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE ) ).GetValue() );
	if ( !aEngine.getLength() || aEngine.equalsAscii( "com.sun.star.drawing.EnhancedCustomShapeEngine" ) )
	{
		rtl::OUString sShapeType;
		const rtl::OUString	sType( RTL_CONSTASCII_USTRINGPARAM ( "Type" ) );
		SdrCustomShapeGeometryItem& rGeometryItem( (SdrCustomShapeGeometryItem&)( *this ).GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
		Any* pAny = rGeometryItem.GetPropertyValueByName( sType );
		if ( pAny && ( *pAny >>= sShapeType ) )
			sShapeName = EnhancedCustomShapeTypeNames::GetAccName( sShapeType );
	}
	return sShapeName;
}
// eof