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

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"

#include <svx/svdedtv.hxx>
#include <math.h>

#ifndef _MATH_H
#define _MATH_H
#endif
#include <tools/bigint.hxx>
#include <svtools/itemiter.hxx>
#include <vcl/msgbox.hxx>
#include <svx/rectenum.hxx>
#include <svx/svxids.hrc>   // fuer SID_ATTR_TRANSFORM_...
#include <svx/svdattr.hxx>  // fuer Get/SetGeoAttr
#include "svditext.hxx"
#include "svditer.hxx"
#include <svx/svdtrans.hxx>
#include <svx/svdundo.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdpagv.hxx>
#include <svx/svdlayer.hxx> // fuer MergeNotPersistAttr
#include <svx/svdattrx.hxx> // fuer MergeNotPersistAttr
#include <svx/svdetc.hxx>   // fuer SearchOutlinerItems
#include <svx/svdopath.hxx>  // fuer Crook
#include "svdstr.hrc"   // Namen aus der Resource
#include "svdglob.hxx"  // StringCache
#include <svx/eeitem.hxx>
#include <svtools/aeitem.hxx>
#include <svtools/whiter.hxx>
#include <svx/sdr/contact/objectcontact.hxx>
#include <svx/sdr/contact/viewcontact.hxx>
#include <svx/e3dsceneupdater.hxx>
#include <svx/obj3d.hxx>

////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  @@@@@ @@@@@  @@ @@@@@@  @@ @@ @@ @@@@@ @@   @@
//  @@    @@  @@ @@   @@    @@ @@ @@ @@    @@   @@
//  @@    @@  @@ @@   @@    @@ @@ @@ @@    @@ @ @@
//  @@@@  @@  @@ @@   @@    @@@@@ @@ @@@@  @@@@@@@
//  @@    @@  @@ @@   @@     @@@  @@ @@    @@@@@@@
//  @@    @@  @@ @@   @@     @@@  @@ @@    @@@ @@@
//  @@@@@ @@@@@  @@   @@      @   @@ @@@@@ @@   @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////

void SdrEditView::SetMarkedObjRect(const Rectangle& rRect, BOOL bCopy)
{
	DBG_ASSERT(!rRect.IsEmpty(),"SetMarkedObjRect() mit leerem Rect mach keinen Sinn");
	if (rRect.IsEmpty()) return;
	ULONG nAnz=GetMarkedObjectCount();
	if (nAnz==0) return;
	Rectangle aR0(GetMarkedObjRect());
	DBG_ASSERT(!aR0.IsEmpty(),"SetMarkedObjRect(): GetMarkedObjRect() ist leer");
	if (aR0.IsEmpty()) return;
	long x0=aR0.Left();
	long y0=aR0.Top();
	long w0=aR0.Right()-x0;
	long h0=aR0.Bottom()-y0;
	long x1=rRect.Left();
	long y1=rRect.Top();
	long w1=rRect.Right()-x1;
	long h1=rRect.Bottom()-y1;
	XubString aStr;
	ImpTakeDescriptionStr(STR_EditPosSize,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	for (ULONG nm=0; nm<nAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
		Rectangle aR1(pO->GetSnapRect());
		if (!aR1.IsEmpty()) {
			if (aR1==aR0) aR1=rRect;
			else { // aR1 von aR0 nach rRect transformieren
				aR1.Move(-x0,-y0);
				BigInt l(aR1.Left());
				BigInt r(aR1.Right());
				BigInt t(aR1.Top());
				BigInt b(aR1.Bottom());
				if (w0!=0) {
					l*=w1; l/=w0;
					r*=w1; r/=w0;
				} else {
					l=0; r=w1;
				}
				if (h0!=0) {
					t*=h1; t/=h0;
					b*=h1; b/=h0;
				} else {
					t=0; b=h1;
				}
				aR1.Left  ()=long(l);
				aR1.Right ()=long(r);
				aR1.Top   ()=long(t);
				aR1.Bottom()=long(b);
				aR1.Move(x1,y1);
			}
			pO->SetSnapRect(aR1);
		} else {
			DBG_ERROR("SetMarkedObjRect(): pObj->GetSnapRect() liefert leeres Rect");
		}
	}
	EndUndo();
}

std::vector< SdrUndoAction* > SdrEditView::CreateConnectorUndo( SdrObject& rO )
{
	std::vector< SdrUndoAction* > vUndoActions;

	if ( rO.GetBroadcaster() )
	{
		const SdrPage* pPage = rO.GetPage();
		if ( pPage )
		{
			SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
			while( aIter.IsMore() )
			{
				SdrObject* pPartObj = aIter.Next();
				if ( pPartObj->ISA( SdrEdgeObj ) )
				{
					if ( ( pPartObj->GetConnectedNode( sal_False ) == &rO ) ||
						 ( pPartObj->GetConnectedNode( sal_True  ) == &rO ) )
					{
						vUndoActions.push_back( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject( *pPartObj ) );
					}
				}
			}
		}
	}
	return vUndoActions;
}

void SdrEditView::AddUndoActions( std::vector< SdrUndoAction* >& rUndoActions )
{
	std::vector< SdrUndoAction* >::iterator aUndoActionIter( rUndoActions.begin() );
	while( aUndoActionIter != rUndoActions.end() )
		AddUndo( *aUndoActionIter++ );
}

void SdrEditView::MoveMarkedObj(const Size& rSiz, bool bCopy)
{
	XubString aStr(ImpGetResStr(STR_EditMove));
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	// benoetigt eigene UndoGroup wegen Parameter
	BegUndo(aStr,GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_MOVE);
	if (bCopy) CopyMarkedObj();
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pO ) );
		AddUndoActions( vConnectorUndoActions );
		AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pO,rSiz));
		pO->Move(rSiz);
	}
	EndUndo();
}

void SdrEditView::ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy)
{
	XubString aStr;
	ImpTakeDescriptionStr(STR_EditResize,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pO ) );
		AddUndoActions( vConnectorUndoActions );
		AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
		pO->Resize(rRef,xFact,yFact);
	}
	EndUndo();
}

long SdrEditView::GetMarkedObjRotate() const
{
	BOOL b1st=TRUE;
	BOOL bOk=TRUE;
	long nWink=0;
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz && bOk; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		long nWink2=pO->GetRotateAngle();
		if (b1st) nWink=nWink2;
		else if (nWink2!=nWink) bOk=FALSE;
		b1st=FALSE;
	}
	if (!bOk) nWink=0;
	return nWink;
}

void SdrEditView::RotateMarkedObj(const Point& rRef, long nWink, bool bCopy)
{
	XubString aStr;
	ImpTakeDescriptionStr(STR_EditRotate,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	double nSin=sin(nWink*nPi180);
	double nCos=cos(nWink*nPi180);
	const sal_uInt32 nMarkAnz(GetMarkedObjectCount());

    if(nMarkAnz)
    {
        std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;
	
        for(sal_uInt32 nm(0); nm < nMarkAnz; nm++) 
        {
		    SdrMark* pM = GetSdrMarkByIndex(nm);
		    SdrObject* pO = pM->GetMarkedSdrObj();
		    
            // extra undo actions for changed connector which now may hold it's layouted path (SJ)
            std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pO ) );
		    AddUndoActions( vConnectorUndoActions );
		    
            AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
            
            // set up a scene updater if object is a 3d object
            if(dynamic_cast< E3dObject* >(pO))
            {
                aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO));
            }
		    
            pO->Rotate(rRef,nWink,nSin,nCos);
	    }

        // fire scene updaters
        while(aUpdaters.size())
        {
            delete aUpdaters.back();
            aUpdaters.pop_back();
        }
    }

	EndUndo();
}

void SdrEditView::MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy)
{
	XubString aStr;
	Point aDif(rRef2-rRef1);
	if (aDif.X()==0) ImpTakeDescriptionStr(STR_EditMirrorHori,aStr);
	else if (aDif.Y()==0) ImpTakeDescriptionStr(STR_EditMirrorVert,aStr);
	else if (Abs(aDif.X())==Abs(aDif.Y())) ImpTakeDescriptionStr(STR_EditMirrorDiag,aStr);
	else ImpTakeDescriptionStr(STR_EditMirrorFree,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	const sal_uInt32 nMarkAnz(GetMarkedObjectCount());

    if(nMarkAnz)
    {
        std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;

        for(sal_uInt32 nm(0); nm < nMarkAnz; nm++) 
        {
		    SdrMark* pM = GetSdrMarkByIndex(nm);
		    SdrObject* pO = pM->GetMarkedSdrObj();
		    
            // extra undo actions for changed connector which now may hold it's layouted path (SJ)
            std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pO ) );
		    AddUndoActions( vConnectorUndoActions );
		    
            AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));

            // set up a scene updater if object is a 3d object
            if(dynamic_cast< E3dObject* >(pO))
            {
                aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO));
            }

            pO->Mirror(rRef1,rRef2);
	    }
        
        // fire scene updaters
        while(aUpdaters.size())
        {
            delete aUpdaters.back();
            aUpdaters.pop_back();
        }
    }

	EndUndo();
}

void SdrEditView::MirrorMarkedObjHorizontal(BOOL bCopy)
{
	Point aCenter(GetMarkedObjRect().Center());
	Point aPt2(aCenter);
	aPt2.Y()++;
	MirrorMarkedObj(aCenter,aPt2,bCopy);
}

void SdrEditView::MirrorMarkedObjVertical(BOOL bCopy)
{
	Point aCenter(GetMarkedObjRect().Center());
	Point aPt2(aCenter);
	aPt2.X()++;
	MirrorMarkedObj(aCenter,aPt2,bCopy);
}

long SdrEditView::GetMarkedObjShear() const
{
	BOOL b1st=TRUE;
	BOOL bOk=TRUE;
	long nWink=0;
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz && bOk; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		long nWink2=pO->GetShearAngle();
		if (b1st) nWink=nWink2;
		else if (nWink2!=nWink) bOk=FALSE;
		b1st=FALSE;
	}
	if (nWink>SDRMAXSHEAR) nWink=SDRMAXSHEAR;
	if (nWink<-SDRMAXSHEAR) nWink=-SDRMAXSHEAR;
	if (!bOk) nWink=0;
	return nWink;
}

void SdrEditView::ShearMarkedObj(const Point& rRef, long nWink, bool bVShear, bool bCopy)
{
	XubString aStr;
	ImpTakeDescriptionStr(STR_EditShear,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	double nTan=tan(nWink*nPi180);
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pO ) );
		AddUndoActions( vConnectorUndoActions );
		AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
		pO->Shear(rRef,nWink,nTan,bVShear);
	}
	EndUndo();
}

void SdrEditView::ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad,
	SdrCrookMode eMode, BOOL bVertical, BOOL bNoContortion, BOOL bRotate, const Rectangle& rMarkRect)
{
	SdrPathObj* pPath=PTR_CAST(SdrPathObj,pO);
	BOOL bDone = FALSE;

	if(pPath!=NULL && !bNoContortion)
	{
		XPolyPolygon aXPP(pPath->GetPathPoly());
		switch (eMode) {
			case SDRCROOK_ROTATE : CrookRotatePoly (aXPP,rRef,rRad,bVertical);           break;
			case SDRCROOK_SLANT  : CrookSlantPoly  (aXPP,rRef,rRad,bVertical);           break;
			case SDRCROOK_STRETCH: CrookStretchPoly(aXPP,rRef,rRad,bVertical,rMarkRect); break;
		} // switch
		pPath->SetPathPoly(aXPP.getB2DPolyPolygon());
		bDone = TRUE;
	}

	if(!bDone && !pPath && pO->IsPolyObj() && 0L != pO->GetPointCount())
	{
		// FuerPolyObj's, aber NICHT fuer SdrPathObj's, z.B. fuer's Bemassungsobjekt
		sal_uInt32 nPtAnz(pO->GetPointCount());
		XPolygon aXP((sal_uInt16)nPtAnz);
		sal_uInt32 nPtNum;
		
		for(nPtNum = 0L; nPtNum < nPtAnz; nPtNum++) 
		{
			Point aPt(pO->GetPoint(nPtNum));
			aXP[(sal_uInt16)nPtNum]=aPt;
		}

		switch (eMode) 
		{
			case SDRCROOK_ROTATE : CrookRotatePoly (aXP,rRef,rRad,bVertical);           break;
			case SDRCROOK_SLANT  : CrookSlantPoly  (aXP,rRef,rRad,bVertical);           break;
			case SDRCROOK_STRETCH: CrookStretchPoly(aXP,rRef,rRad,bVertical,rMarkRect); break;
		}
		
		for(nPtNum = 0L; nPtNum < nPtAnz; nPtNum++) 
		{
			// hier koennte man vieleicht auch mal das Broadcasting optimieren
			// ist aber z.Zt. bei den 2 Punkten des Bemassungsobjekts noch nicht so tragisch
			pO->SetPoint(aXP[(sal_uInt16)nPtNum],nPtNum);
		}

		bDone = TRUE;
	}

	if(!bDone)
	{
		// Fuer alle anderen oder wenn bNoContortion
		Point aCtr0(pO->GetSnapRect().Center());
		Point aCtr1(aCtr0);
		sal_Bool bRotOk(sal_False);
		double nSin(0.0), nCos(1.0);
		double nWink(0.0);
		
		if(0 != rRad.X() && 0 != rRad.Y()) 
		{
			bRotOk = bRotate;

			switch (eMode) 
			{
				case SDRCROOK_ROTATE : nWink=CrookRotateXPoint (aCtr1,NULL,NULL,rRef,rRad,nSin,nCos,bVertical); bRotOk=bRotate; break;
				case SDRCROOK_SLANT  : nWink=CrookSlantXPoint  (aCtr1,NULL,NULL,rRef,rRad,nSin,nCos,bVertical);           break;
				case SDRCROOK_STRETCH: nWink=CrookStretchXPoint(aCtr1,NULL,NULL,rRef,rRad,nSin,nCos,bVertical,rMarkRect); break;
			}
		}

		aCtr1 -= aCtr0;

		if(bRotOk) 
			pO->Rotate(aCtr0, Round(nWink/nPi180), nSin, nCos);

		pO->Move(Size(aCtr1.X(),aCtr1.Y()));
	}
}

void SdrEditView::CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode,
	bool bVertical, bool bNoContortion, bool bCopy)
{
	Rectangle aMarkRect(GetMarkedObjRect());
	XubString aStr;
	BOOL bRotate=bNoContortion && eMode==SDRCROOK_ROTATE && IsRotateAllowed(FALSE);
	ImpTakeDescriptionStr(bNoContortion?STR_EditCrook:STR_EditCrookContortion,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
		const SdrObjList* pOL=pO->GetSubList();
		if (bNoContortion || pOL==NULL) {
			ImpCrookObj(pO,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect);
		} else {
			SdrObjListIter aIter(*pOL,IM_DEEPNOGROUPS);
			while (aIter.IsMore()) {
				SdrObject* pO1=aIter.Next();
				ImpCrookObj(pO1,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect);
			}
		}
	}
	EndUndo();
}

void SdrEditView::ImpDistortObj(SdrObject* pO, const Rectangle& rRef, const XPolygon& rDistortedRect, BOOL bNoContortion)
{
	SdrPathObj* pPath = PTR_CAST(SdrPathObj, pO);

	if(!bNoContortion && pPath) 
	{
		XPolyPolygon aXPP(pPath->GetPathPoly());
		aXPP.Distort(rRef, rDistortedRect);
		pPath->SetPathPoly(aXPP.getB2DPolyPolygon());
	} 
	else if(pO->IsPolyObj()) 
	{
		// z.B. fuer's Bemassungsobjekt
		sal_uInt32 nPtAnz(pO->GetPointCount());
		XPolygon aXP((sal_uInt16)nPtAnz);
		sal_uInt32 nPtNum;

		for(nPtNum = 0L; nPtNum < nPtAnz; nPtNum++) 
		{
			Point aPt(pO->GetPoint(nPtNum));
			aXP[(sal_uInt16)nPtNum]=aPt;
		}

		aXP.Distort(rRef, rDistortedRect);

		for(nPtNum = 0L; nPtNum < nPtAnz; nPtNum++) 
		{
			// hier koennte man vieleicht auch mal das Broadcasting optimieren
			// ist aber z.Zt. bei den 2 Punkten des Bemassungsobjekts noch nicht so tragisch
			pO->SetPoint(aXP[(sal_uInt16)nPtNum],nPtNum);
		}
	}
}

void SdrEditView::DistortMarkedObj(const Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion, bool bCopy)
{
	XubString aStr;
	ImpTakeDescriptionStr(STR_EditDistort,aStr);
	if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
	BegUndo(aStr);
	if (bCopy) CopyMarkedObj();
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pO=pM->GetMarkedSdrObj();
		AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
		Rectangle aRefRect(rRef);
		XPolygon  aRefPoly(rDistortedRect);
		const SdrObjList* pOL=pO->GetSubList();
		if (bNoContortion || pOL==NULL) {
			ImpDistortObj(pO,aRefRect,aRefPoly,bNoContortion);
		} else {
			SdrObjListIter aIter(*pOL,IM_DEEPNOGROUPS);
			while (aIter.IsMore()) {
				SdrObject* pO1=aIter.Next();
				ImpDistortObj(pO1,aRefRect,aRefPoly,bNoContortion);
			}
		}
	}
	EndUndo();
}

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

void SdrEditView::SetNotPersistAttrToMarked(const SfxItemSet& rAttr, BOOL /*bReplaceAll*/)
{
	// bReplaceAll hat hier keinerlei Wirkung
	Rectangle aAllSnapRect(GetMarkedObjRect());
	const SfxPoolItem *pPoolItem=NULL;
	if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1X,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long n=((const SdrTransformRef1XItem*)pPoolItem)->GetValue();
		SetRef1(Point(n,GetRef1().Y()));
	}
	if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1Y,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long n=((const SdrTransformRef1YItem*)pPoolItem)->GetValue();
		SetRef1(Point(GetRef1().X(),n));
	}
	if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2X,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long n=((const SdrTransformRef2XItem*)pPoolItem)->GetValue();
		SetRef2(Point(n,GetRef2().Y()));
	}
	if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2Y,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long n=((const SdrTransformRef2YItem*)pPoolItem)->GetValue();
		SetRef2(Point(GetRef2().X(),n));
	}
	long nAllPosX=0; BOOL bAllPosX=FALSE;
	long nAllPosY=0; BOOL bAllPosY=FALSE;
	long nAllWdt=0;  BOOL bAllWdt=FALSE;
	long nAllHgt=0;  BOOL bAllHgt=FALSE;
	BOOL bDoIt=FALSE;
	if (rAttr.GetItemState(SDRATTR_ALLPOSITIONX,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		nAllPosX=((const SdrAllPositionXItem*)pPoolItem)->GetValue();
		bAllPosX=TRUE; bDoIt=TRUE;
	}
	if (rAttr.GetItemState(SDRATTR_ALLPOSITIONY,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		nAllPosY=((const SdrAllPositionYItem*)pPoolItem)->GetValue();
		bAllPosY=TRUE; bDoIt=TRUE;
	}
	if (rAttr.GetItemState(SDRATTR_ALLSIZEWIDTH,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		nAllWdt=((const SdrAllSizeWidthItem*)pPoolItem)->GetValue();
		bAllWdt=TRUE; bDoIt=TRUE;
	}
	if (rAttr.GetItemState(SDRATTR_ALLSIZEHEIGHT,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		nAllHgt=((const SdrAllSizeHeightItem*)pPoolItem)->GetValue();
		bAllHgt=TRUE; bDoIt=TRUE;
	}
	if (bDoIt) {
		Rectangle aRect(aAllSnapRect); // !!! fuer PolyPt's und GluePt's aber bitte noch aendern !!!
		if (bAllPosX) aRect.Move(nAllPosX-aRect.Left(),0);
		if (bAllPosY) aRect.Move(0,nAllPosY-aRect.Top());
		if (bAllWdt)  aRect.Right()=aAllSnapRect.Left()+nAllWdt;
		if (bAllHgt)  aRect.Bottom()=aAllSnapRect.Top()+nAllHgt;
		SetMarkedObjRect(aRect);
	}
	if (rAttr.GetItemState(SDRATTR_RESIZEXALL,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		Fraction aXFact=((const SdrResizeXAllItem*)pPoolItem)->GetValue();
		ResizeMarkedObj(aAllSnapRect.TopLeft(),aXFact,Fraction(1,1));
	}
	if (rAttr.GetItemState(SDRATTR_RESIZEYALL,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		Fraction aYFact=((const SdrResizeYAllItem*)pPoolItem)->GetValue();
		ResizeMarkedObj(aAllSnapRect.TopLeft(),Fraction(1,1),aYFact);
	}
	if (rAttr.GetItemState(SDRATTR_ROTATEALL,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long nAngle=((const SdrRotateAllItem*)pPoolItem)->GetValue();
		RotateMarkedObj(aAllSnapRect.Center(),nAngle);
	}
	if (rAttr.GetItemState(SDRATTR_HORZSHEARALL,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long nAngle=((const SdrHorzShearAllItem*)pPoolItem)->GetValue();
		ShearMarkedObj(aAllSnapRect.Center(),nAngle,FALSE);
	}
	if (rAttr.GetItemState(SDRATTR_VERTSHEARALL,TRUE,&pPoolItem)==SFX_ITEM_SET) {
		long nAngle=((const SdrVertShearAllItem*)pPoolItem)->GetValue();
		ShearMarkedObj(aAllSnapRect.Center(),nAngle,TRUE);
	}
	// Todo: WhichRange nach Notwendigkeit ueberpruefen.
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		const SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pObj=pM->GetMarkedSdrObj();
		//const SdrPageView* pPV=pM->GetPageView();
		AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
		pObj->ApplyNotPersistAttr(rAttr);
	}
}

void SdrEditView::MergeNotPersistAttrFromMarked(SfxItemSet& rAttr, BOOL /*bOnlyHardAttr*/) const
{
	// bOnlyHardAttr hat hier keinerlei Wirkung
	// Hier muss ausserdem noch der Nullpunkt und
	// die PvPos berueksichtigt werden.
	Rectangle aAllSnapRect(GetMarkedObjRect()); // !!! fuer PolyPt's und GluePt's aber bitte noch aendern !!!
	long nAllSnapPosX=aAllSnapRect.Left();
	long nAllSnapPosY=aAllSnapRect.Top();
	long nAllSnapWdt=aAllSnapRect.GetWidth()-1;
	long nAllSnapHgt=aAllSnapRect.GetHeight()-1;
	// koennte mal zu CheckPossibilities mit rein
	BOOL bMovProtect=FALSE,bMovProtectDC=FALSE;
	BOOL bSizProtect=FALSE,bSizProtectDC=FALSE;
	BOOL bPrintable =TRUE ,bPrintableDC=FALSE;
	SdrLayerID nLayerId=0; BOOL bLayerDC=FALSE;
	XubString aObjName;     BOOL bObjNameDC=FALSE,bObjNameSet=FALSE;
	long nSnapPosX=0;      BOOL bSnapPosXDC=FALSE;
	long nSnapPosY=0;      BOOL bSnapPosYDC=FALSE;
	long nSnapWdt=0;       BOOL bSnapWdtDC=FALSE;
	long nSnapHgt=0;       BOOL bSnapHgtDC=FALSE;
	long nLogicWdt=0;      BOOL bLogicWdtDC=FALSE,bLogicWdtDiff=FALSE;
	long nLogicHgt=0;      BOOL bLogicHgtDC=FALSE,bLogicHgtDiff=FALSE;
	long nRotAngle=0;      BOOL bRotAngleDC=FALSE;
	long nShrAngle=0;      BOOL bShrAngleDC=FALSE;
	Rectangle aSnapRect;
	Rectangle aLogicRect;
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		const SdrMark* pM=GetSdrMarkByIndex(nm);
		const SdrObject* pObj=pM->GetMarkedSdrObj();
		if (nm==0) {
			nLayerId=pObj->GetLayer();
			bMovProtect=pObj->IsMoveProtect();
			bSizProtect=pObj->IsResizeProtect();
			bPrintable =pObj->IsPrintable();
			Rectangle aSnapRect2(pObj->GetSnapRect());
			Rectangle aLogicRect2(pObj->GetLogicRect());
			nSnapPosX=aSnapRect2.Left();
			nSnapPosY=aSnapRect2.Top();
			nSnapWdt=aSnapRect2.GetWidth()-1;
			nSnapHgt=aSnapRect2.GetHeight()-1;
			nLogicWdt=aLogicRect2.GetWidth()-1;
			nLogicHgt=aLogicRect2.GetHeight()-1;
			bLogicWdtDiff=nLogicWdt!=nSnapWdt;
			bLogicHgtDiff=nLogicHgt!=nSnapHgt;
			nRotAngle=pObj->GetRotateAngle();
			nShrAngle=pObj->GetShearAngle();
		} else {
			if (!bLayerDC      && nLayerId   !=pObj->GetLayer())        bLayerDC=TRUE;
			if (!bMovProtectDC && bMovProtect!=pObj->IsMoveProtect())   bMovProtectDC=TRUE;
			if (!bSizProtectDC && bSizProtect!=pObj->IsResizeProtect()) bSizProtectDC=TRUE;
			if (!bPrintableDC  && bPrintable !=pObj->IsPrintable())     bPrintableDC=TRUE;
			if (!bRotAngleDC   && nRotAngle  !=pObj->GetRotateAngle())  bRotAngleDC=TRUE;
			if (!bShrAngleDC   && nShrAngle  !=pObj->GetShearAngle())   bShrAngleDC=TRUE;
			if (!bSnapWdtDC || !bSnapHgtDC || !bSnapPosXDC || !bSnapPosYDC || !bLogicWdtDiff || !bLogicHgtDiff) {
				aSnapRect=pObj->GetSnapRect();
				if (nSnapPosX!=aSnapRect.Left()) bSnapPosXDC=TRUE;
				if (nSnapPosY!=aSnapRect.Top()) bSnapPosYDC=TRUE;
				if (nSnapWdt!=aSnapRect.GetWidth()-1) bSnapWdtDC=TRUE;
				if (nSnapHgt!=aSnapRect.GetHeight()-1) bSnapHgtDC=TRUE;
			}
			if (!bLogicWdtDC || !bLogicHgtDC || !bLogicWdtDiff || !bLogicHgtDiff) {
				aLogicRect=pObj->GetLogicRect();
				if (nLogicWdt!=aLogicRect.GetWidth()-1) bLogicWdtDC=TRUE;
				if (nLogicHgt!=aLogicRect.GetHeight()-1) bLogicHgtDC=TRUE;
				if (!bLogicWdtDiff && aSnapRect.GetWidth()!=aLogicRect.GetWidth()) bLogicWdtDiff=TRUE;
				if (!bLogicHgtDiff && aSnapRect.GetHeight()!=aLogicRect.GetHeight()) bLogicHgtDiff=TRUE;
			}
		}
		if (!bObjNameDC ) {
			if (!bObjNameSet) {
				aObjName=pObj->GetName();
			} else {
				if (aObjName!=pObj->GetName()) bObjNameDC=TRUE;
			}
		}
	}

	if (bSnapPosXDC || nAllSnapPosX!=nSnapPosX) rAttr.Put(SdrAllPositionXItem(nAllSnapPosX));
	if (bSnapPosYDC || nAllSnapPosY!=nSnapPosY) rAttr.Put(SdrAllPositionYItem(nAllSnapPosY));
	if (bSnapWdtDC  || nAllSnapWdt !=nSnapWdt ) rAttr.Put(SdrAllSizeWidthItem(nAllSnapWdt));
	if (bSnapHgtDC  || nAllSnapHgt !=nSnapHgt ) rAttr.Put(SdrAllSizeHeightItem(nAllSnapHgt));

	// Items fuer reine Transformationen
	rAttr.Put(SdrMoveXItem());
	rAttr.Put(SdrMoveYItem());
	rAttr.Put(SdrResizeXOneItem());
	rAttr.Put(SdrResizeYOneItem());
	rAttr.Put(SdrRotateOneItem());
	rAttr.Put(SdrHorzShearOneItem());
	rAttr.Put(SdrVertShearOneItem());
	if (nMarkAnz>1) {
		rAttr.Put(SdrResizeXAllItem());
		rAttr.Put(SdrResizeYAllItem());
		rAttr.Put(SdrRotateAllItem());
		rAttr.Put(SdrHorzShearAllItem());
		rAttr.Put(SdrVertShearAllItem());
	}

	if(eDragMode == SDRDRAG_ROTATE || eDragMode == SDRDRAG_MIRROR) 
	{
		rAttr.Put(SdrTransformRef1XItem(GetRef1().X()));
		rAttr.Put(SdrTransformRef1YItem(GetRef1().Y()));
	}
	
	if(eDragMode == SDRDRAG_MIRROR) 
	{
		rAttr.Put(SdrTransformRef2XItem(GetRef2().X()));
		rAttr.Put(SdrTransformRef2YItem(GetRef2().Y()));
	}
}

SfxItemSet SdrEditView::GetAttrFromMarked(BOOL bOnlyHardAttr) const
{
	SfxItemSet aSet(pMod->GetItemPool());
	MergeAttrFromMarked(aSet,bOnlyHardAttr);
    //the EE_FEATURE items should not be set with SetAttrToMarked (see error message there)
    //so we do not set them here
	// #i32448#
	// Do not disable, but clear the items.
    aSet.ClearItem(EE_FEATURE_TAB);
    aSet.ClearItem(EE_FEATURE_LINEBR);
    aSet.ClearItem(EE_FEATURE_NOTCONV);
    aSet.ClearItem(EE_FEATURE_FIELD);
	return aSet;
}

void SdrEditView::MergeAttrFromMarked(SfxItemSet& rAttr, BOOL bOnlyHardAttr) const
{
	sal_uInt32 nMarkAnz(GetMarkedObjectCount());

	for(sal_uInt32 a(0); a < nMarkAnz; a++) 
	{
		// #80277# merging was done wrong in the prev version
		//const SfxItemSet& rSet = GetMarkedObjectByIndex()->GetItemSet();
		const SfxItemSet& rSet = GetMarkedObjectByIndex(a)->GetMergedItemSet();
		SfxWhichIter aIter(rSet);
		sal_uInt16 nWhich(aIter.FirstWhich());

		while(nWhich)
		{
			if(!bOnlyHardAttr)
			{
				if(SFX_ITEM_DONTCARE == rSet.GetItemState(nWhich, FALSE))
					rAttr.InvalidateItem(nWhich);
				else
					rAttr.MergeValue(rSet.Get(nWhich), TRUE);
			}
			else if(SFX_ITEM_SET == rSet.GetItemState(nWhich, FALSE))
			{
				const SfxPoolItem& rItem = rSet.Get(nWhich);
				rAttr.MergeValue(rItem, TRUE);
			}

			nWhich = aIter.NextWhich();
		}
	}
}

void SdrEditView::SetAttrToMarked(const SfxItemSet& rAttr, BOOL bReplaceAll)
{
	if (AreObjectsMarked()) 
	{
#ifdef DBG_UTIL
		{
			BOOL bHasEEFeatureItems=FALSE;
			SfxItemIter aIter(rAttr);
			const SfxPoolItem* pItem=aIter.FirstItem();
			while (!bHasEEFeatureItems && pItem!=NULL) {
				if (!IsInvalidItem(pItem)) {
					USHORT nW=pItem->Which();
					if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=TRUE;
				}
				pItem=aIter.NextItem();
			}
			if(bHasEEFeatureItems) 
			{
				String aMessage;
				aMessage.AppendAscii("SdrEditView::SetAttrToMarked(): Das setzen von EE_FEATURE-Items an der SdrView macht keinen Sinn! Es fuehrt nur zu Overhead und nicht mehr lesbaren Dokumenten.");
				InfoBox(NULL, aMessage).Execute();
			}
		}
#endif

		// #103836# if the user thets character attributes to the complete shape,
		//			we want to remove all hard set character attributes with same
		//			which ids from the text. We do that later but here we remember
		//			all character attribute which id's that are set.
		std::vector<sal_uInt16> aCharWhichIds;
		{
			SfxItemIter aIter(rAttr);
			const SfxPoolItem* pItem=aIter.FirstItem();
			while( pItem!=NULL )
			{
				if (!IsInvalidItem(pItem))
				{
					sal_uInt16 nWhich = pItem->Which();
					if (nWhich>=EE_CHAR_START && nWhich<=EE_CHAR_END)
						aCharWhichIds.push_back( nWhich );
				}
				pItem=aIter.NextItem();
			}
		}

		// Joe, 2.7.98: Damit Undo nach Format.Standard auch die Textattribute korrekt restauriert
		BOOL bHasEEItems=SearchOutlinerItems(rAttr,bReplaceAll);
		XubString aStr;
		ImpTakeDescriptionStr(STR_EditSetAttributes,aStr);

		// AW 030100: save additional geom info when para or char attributes
		// are changed and the geom form of the text object might be changed
		BOOL bPossibleGeomChange(FALSE);
		SfxWhichIter aIter(rAttr);
		UINT16 nWhich = aIter.FirstWhich();
		while(!bPossibleGeomChange && nWhich) 
		{
			SfxItemState eState = rAttr.GetItemState(nWhich);
			if(eState == SFX_ITEM_SET) 
			{
				if((nWhich >= SDRATTR_TEXT_MINFRAMEHEIGHT && nWhich <= SDRATTR_TEXT_CONTOURFRAME) 
					|| nWhich == SDRATTR_3DOBJ_PERCENT_DIAGONAL
					|| nWhich == SDRATTR_3DOBJ_BACKSCALE
					|| nWhich == SDRATTR_3DOBJ_DEPTH
					|| nWhich == SDRATTR_3DOBJ_END_ANGLE
					|| nWhich == SDRATTR_3DSCENE_DISTANCE)
				{
					bPossibleGeomChange = TRUE;
				}
			}
			nWhich = aIter.NextWhich();
		}

		BegUndo(aStr);
		const sal_uInt32 nMarkAnz(GetMarkedObjectCount());
        std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;

		// create ItemSet without SFX_ITEM_DONTCARE. Put()
		// uses it's second parameter (bInvalidAsDefault) to
		// remove all such items to set them to default.
		SfxItemSet aAttr(*rAttr.GetPool(), rAttr.GetRanges());
		aAttr.Put(rAttr, TRUE);
		
		// #i38135#
		bool bResetAnimationTimer(false);

		for (ULONG nm=0; nm<nMarkAnz; nm++)
		{
			SdrMark* pM=GetSdrMarkByIndex(nm);
			SdrObject* pObj = pM->GetMarkedSdrObj();
			
			std::vector< SdrUndoAction* > vConnectorUndoActions;
			SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >( pObj );
			if ( pEdgeObj )
				bPossibleGeomChange = TRUE;
			else
				vConnectorUndoActions = CreateConnectorUndo( *pObj );
			AddUndoActions( vConnectorUndoActions );	

			// new geometry undo
			if(bPossibleGeomChange)
			{
				// save position and size of obect, too
				AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
			}

			// #i8508#
			// If this is a text object also rescue the OutlinerParaObject since
			// applying attributes to the object may change text layout when
			// multiple portions exist with multiple formats. If a OutlinerParaObject
			// really exists and needs to be rescued is evaluated in the undo
			// implementation itself.
			sal_Bool bRescueText(pObj->ISA(SdrTextObj));

			// add attribute undo
			AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pObj,FALSE,bHasEEItems || bPossibleGeomChange || bRescueText));

            // set up a scxene updater if object is a 3d object
            if(dynamic_cast< E3dObject* >(pObj))
            {
                aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj));
            }

            // set attributes at object
			pObj->SetMergedItemSetAndBroadcast(aAttr, bReplaceAll);

			if(pObj->ISA(SdrTextObj))
			{
				SdrTextObj* pTextObj = ((SdrTextObj*)pObj);

				if(0 != aCharWhichIds.size())
				{
					Rectangle aOldBoundRect = pTextObj->GetLastBoundRect();

					// #110094#-14 pTextObj->SendRepaintBroadcast(pTextObj->GetBoundRect());
					pTextObj->RemoveOutlinerCharacterAttribs( aCharWhichIds );

					// object has changed, should be called form
					// RemoveOutlinerCharacterAttribs. This will change when the text
					// object implementation changes.
					pTextObj->SetChanged();

					pTextObj->BroadcastObjectChange();
					pTextObj->SendUserCall(SDRUSERCALL_CHGATTR, aOldBoundRect);
				}
			}

			// #i38495#
			if(!bResetAnimationTimer)
			{
    			if(pObj->GetViewContact().isAnimatedInAnyViewObjectContact())
				{
					bResetAnimationTimer = true;
				}
			}
		}

        // fire scene updaters
        while(aUpdaters.size())
        {
            delete aUpdaters.back();
            aUpdaters.pop_back();
        }

        // #i38135#
		if(bResetAnimationTimer)
		{
			SetAnimationTimer(0L);
		}

		// besser vorher checken, was gemacht werden soll:
		// pObj->SetAttr() oder SetNotPersistAttr()
		// !!! fehlende Implementation !!!
		SetNotPersistAttrToMarked(rAttr,bReplaceAll);
		EndUndo();
	}
}

SfxStyleSheet* SdrEditView::GetStyleSheetFromMarked() const
{
	SfxStyleSheet* pRet=NULL;
	BOOL b1st=TRUE;
	ULONG nMarkAnz=GetMarkedObjectCount();
	for (ULONG nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SfxStyleSheet* pSS=pM->GetMarkedSdrObj()->GetStyleSheet();
		if (b1st) pRet=pSS;
		else if (pRet!=pSS) return NULL; // verschiedene StyleSheets
		b1st=FALSE;
	}
	return pRet;
}

void SdrEditView::SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr)
{
	if (AreObjectsMarked()) {
		XubString aStr;
		if (pStyleSheet!=NULL) ImpTakeDescriptionStr(STR_EditSetStylesheet,aStr);
		else ImpTakeDescriptionStr(STR_EditDelStylesheet,aStr);
		BegUndo(aStr);
		ULONG nMarkAnz=GetMarkedObjectCount();
		for (ULONG nm=0; nm<nMarkAnz; nm++) {
			SdrMark* pM=GetSdrMarkByIndex(nm);
            AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pM->GetMarkedSdrObj()));
			AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pM->GetMarkedSdrObj(),true,true));
			pM->GetMarkedSdrObj()->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
		}
		EndUndo();
	}
}

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

/* new interface src537 */
BOOL SdrEditView::GetAttributes(SfxItemSet& rTargetSet, BOOL bOnlyHardAttr) const
{
	if(GetMarkedObjectCount())
	{
		rTargetSet.Put(GetAttrFromMarked(bOnlyHardAttr), FALSE);
		return TRUE;
	}
	else
	{
		return SdrMarkView::GetAttributes(rTargetSet, bOnlyHardAttr);
	}
}

BOOL SdrEditView::SetAttributes(const SfxItemSet& rSet, BOOL bReplaceAll)
{
	if (GetMarkedObjectCount()!=0) {
		SetAttrToMarked(rSet,bReplaceAll);
		return TRUE;
	} else {
		return SdrMarkView::SetAttributes(rSet,bReplaceAll);
	}
}

SfxStyleSheet* SdrEditView::GetStyleSheet() const // SfxStyleSheet* SdrEditView::GetStyleSheet(BOOL& rOk) const
{
	if (GetMarkedObjectCount()!=0) {
		//rOk=TRUE;
		return GetStyleSheetFromMarked();
	} else {
		return SdrMarkView::GetStyleSheet(); // SdrMarkView::GetStyleSheet(rOk);
	}
}

BOOL SdrEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr)
{
	if (GetMarkedObjectCount()!=0) {
		SetStyleSheetToMarked(pStyleSheet,bDontRemoveHardAttr);
		return TRUE;
	} else {
		return SdrMarkView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
	}
}

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

SfxItemSet SdrEditView::GetGeoAttrFromMarked() const
{
	SfxItemSet aRetSet(pMod->GetItemPool(),   // SID_ATTR_TRANSFORM_... aus s:svxids.hrc
					   SID_ATTR_TRANSFORM_POS_X,SID_ATTR_TRANSFORM_ANGLE,
					   SID_ATTR_TRANSFORM_PROTECT_POS,SID_ATTR_TRANSFORM_AUTOHEIGHT,
					   SDRATTR_ECKENRADIUS,SDRATTR_ECKENRADIUS,
					   0);
	if (AreObjectsMarked()) {
		SfxItemSet aMarkAttr(GetAttrFromMarked(FALSE)); // wg. AutoGrowHeight und Eckenradius
		Rectangle aRect(GetMarkedObjRect());
		
		if(GetSdrPageView()) 
		{
			GetSdrPageView()->LogicToPagePos(aRect);
		}

		// Position
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_X,aRect.Left()));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_Y,aRect.Top()));

		// Groesse
		long nResizeRefX=aRect.Left();
		long nResizeRefY=aRect.Top();
		if (eDragMode==SDRDRAG_ROTATE) { // Drehachse auch als Referenz fuer Resize
			nResizeRefX=aRef1.X();
			nResizeRefY=aRef1.Y();
		}
		aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_WIDTH,aRect.Right()-aRect.Left()));
		aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_HEIGHT,aRect.Bottom()-aRect.Top()));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_X,nResizeRefX));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_Y,nResizeRefY));

		Point aRotateAxe(aRef1);
		
		if(GetSdrPageView()) 
		{
			GetSdrPageView()->LogicToPagePos(aRotateAxe);
		}

		// Drehung
		long nRotateRefX=aRect.Center().X();
		long nRotateRefY=aRect.Center().Y();
		if (eDragMode==SDRDRAG_ROTATE) {
			nRotateRefX=aRotateAxe.X();
			nRotateRefY=aRotateAxe.Y();
		}
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ANGLE,GetMarkedObjRotate()));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_X,nRotateRefX));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_Y,nRotateRefY));

		// Shear
		long nShearRefX=aRect.Left();
		long nShearRefY=aRect.Bottom();
		if (eDragMode==SDRDRAG_ROTATE) { // Drehachse auch als Referenz fuer Shear
			nShearRefX=aRotateAxe.X();
			nShearRefY=aRotateAxe.Y();
		}
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR,GetMarkedObjShear()));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X,nShearRefX));
		aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y,nShearRefY));

		// Pruefen der einzelnen Objekte, ob Objekte geschuetzt sind
		const SdrMarkList& rMarkList=GetMarkedObjectList();
		ULONG nMarkCount=rMarkList.GetMarkCount();
		SdrObject* pObj=rMarkList.GetMark(0)->GetMarkedSdrObj();
		BOOL bPosProt=pObj->IsMoveProtect();
		BOOL bSizProt=pObj->IsResizeProtect();
		BOOL bPosProtDontCare=FALSE;
		BOOL bSizProtDontCare=FALSE;
		for (ULONG i=1; i<nMarkCount && (!bPosProtDontCare || !bSizProtDontCare); i++) {
			pObj=rMarkList.GetMark(i)->GetMarkedSdrObj();
			if (bPosProt!=pObj->IsMoveProtect()) bPosProtDontCare=TRUE;
			if (bSizProt!=pObj->IsResizeProtect()) bSizProtDontCare=TRUE;
		}

		// InvalidateItem setzt das Item auf DONT_CARE
		if (bPosProtDontCare) {
			aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_POS);
		} else {
			aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_POS,bPosProt));
		}
		if (bSizProtDontCare) {
			aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_SIZE);
		} else {
			aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_SIZE,bSizProt));
		}

		SfxItemState eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWWIDTH);
		BOOL bAutoGrow=((SdrTextAutoGrowWidthItem&)(aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWWIDTH))).GetValue();
		if (eState==SFX_ITEM_DONTCARE) {
			aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOWIDTH);
		} else if (eState==SFX_ITEM_SET) {
			aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOWIDTH,bAutoGrow));
		}

		eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWHEIGHT);
		bAutoGrow=((SdrTextAutoGrowHeightItem&)(aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWHEIGHT))).GetValue();
		if (eState==SFX_ITEM_DONTCARE) {
			aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOHEIGHT);
		} else if (eState==SFX_ITEM_SET) {
			aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOHEIGHT,bAutoGrow));
		}

		eState=aMarkAttr.GetItemState(SDRATTR_ECKENRADIUS);
		long nRadius=((SdrEckenradiusItem&)(aMarkAttr.Get(SDRATTR_ECKENRADIUS))).GetValue();
		if (eState==SFX_ITEM_DONTCARE) {
			aRetSet.InvalidateItem(SDRATTR_ECKENRADIUS);
		} else if (eState==SFX_ITEM_SET) {
			aRetSet.Put(SdrEckenradiusItem(nRadius));
		}

	}
	return aRetSet;
}

Point ImpGetPoint(Rectangle aRect, RECT_POINT eRP)
{
	switch(eRP) {
		case RP_LT: return aRect.TopLeft();
		case RP_MT: return aRect.TopCenter();
		case RP_RT: return aRect.TopRight();
		case RP_LM: return aRect.LeftCenter();
		case RP_MM: return aRect.Center();
		case RP_RM: return aRect.RightCenter();
		case RP_LB: return aRect.BottomLeft();
		case RP_MB: return aRect.BottomCenter();
		case RP_RB: return aRect.BottomRight();
	}
	return Point(); // Sollte nicht vorkommen !
}

void SdrEditView::SetGeoAttrToMarked(const SfxItemSet& rAttr)
{
	Rectangle aRect(GetMarkedObjRect());
	
	if(GetSdrPageView()) 
	{
		GetSdrPageView()->LogicToPagePos(aRect);
	}

	long nOldRotateAngle=GetMarkedObjRotate();
	long nOldShearAngle=GetMarkedObjShear();
	const SdrMarkList& rMarkList=GetMarkedObjectList();
	ULONG nMarkCount=rMarkList.GetMarkCount();
	SdrObject* pObj=NULL;

	RECT_POINT eSizePoint=RP_MM;
	long nPosDX=0;
	long nPosDY=0;
	long nSizX=0;
	long nSizY=0;
	long nRotateAngle=0;
	
	// #86909#
	sal_Bool bModeIsRotate(eDragMode == SDRDRAG_ROTATE);
	long nRotateX(0);
	long nRotateY(0);
	long nOldRotateX(0);
	long nOldRotateY(0);
	if(bModeIsRotate)
	{
		Point aRotateAxe(aRef1);
		
		if(GetSdrPageView())
		{
			GetSdrPageView()->LogicToPagePos(aRotateAxe);
		}

		nRotateX = nOldRotateX = aRotateAxe.X();
		nRotateY = nOldRotateY = aRotateAxe.Y();
	}
	
	long nNewShearAngle=0;
	long nShearAngle=0;
	long nShearX=0;
	long nShearY=0;
	BOOL bShearVert=FALSE;

	BOOL bChgPos=FALSE;
	BOOL bChgSiz=FALSE;
	BOOL bChgHgt=FALSE;
	BOOL bRotate=FALSE;
	BOOL bShear =FALSE;

	BOOL bSetAttr=FALSE;
	SfxItemSet aSetAttr(pMod->GetItemPool());

	const SfxPoolItem* pPoolItem=NULL;

	// Position
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_POS_X,TRUE,&pPoolItem)) {
		nPosDX=((const SfxInt32Item*)pPoolItem)->GetValue()-aRect.Left();
		bChgPos=TRUE;
	}
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_POS_Y,TRUE,&pPoolItem)){
		nPosDY=((const SfxInt32Item*)pPoolItem)->GetValue()-aRect.Top();
		bChgPos=TRUE;
	}
	// Groesse
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_WIDTH,TRUE,&pPoolItem)) {
		nSizX=((const SfxUInt32Item*)pPoolItem)->GetValue();
		bChgSiz=TRUE;
	}
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_HEIGHT,TRUE,&pPoolItem)) {
		nSizY=((const SfxUInt32Item*)pPoolItem)->GetValue();
		bChgSiz=TRUE;
		bChgHgt=TRUE;
	}
	if (bChgSiz) {
		eSizePoint=(RECT_POINT)((const SfxAllEnumItem&)rAttr.Get(SID_ATTR_TRANSFORM_SIZE_POINT)).GetValue();
	}

	// Rotation
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ANGLE,TRUE,&pPoolItem)) {
		nRotateAngle=((const SfxInt32Item*)pPoolItem)->GetValue()-nOldRotateAngle;
		bRotate = (nRotateAngle != 0);
	}

	// #86909# pos rot point x
	if(bRotate || SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ROT_X, TRUE ,&pPoolItem)) 
		nRotateX = ((const SfxInt32Item&)rAttr.Get(SID_ATTR_TRANSFORM_ROT_X)).GetValue();

	// #86909# pos rot point y
	if(bRotate || SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ROT_Y, TRUE ,&pPoolItem)) 
		nRotateY = ((const SfxInt32Item&)rAttr.Get(SID_ATTR_TRANSFORM_ROT_Y)).GetValue();

	// Shear
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_SHEAR,TRUE,&pPoolItem)) {
		nNewShearAngle=((const SfxInt32Item*)pPoolItem)->GetValue();
		if (nNewShearAngle>SDRMAXSHEAR) nNewShearAngle=SDRMAXSHEAR;
		if (nNewShearAngle<-SDRMAXSHEAR) nNewShearAngle=-SDRMAXSHEAR;
		if (nNewShearAngle!=nOldShearAngle) {
			bShearVert=((const SfxBoolItem&)rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_VERTICAL)).GetValue();
			if (bShearVert) {
				nShearAngle=nNewShearAngle;
			} else {
				if (nNewShearAngle!=0 && nOldShearAngle!=0) {
					// Bugfix #25714#.
					double nOld=tan((double)nOldShearAngle*nPi180);
					double nNew=tan((double)nNewShearAngle*nPi180);
					nNew-=nOld;
					nNew=atan(nNew)/nPi180;
					nShearAngle=Round(nNew);
				} else {
					nShearAngle=nNewShearAngle-nOldShearAngle;
				}
			}
			bShear=nShearAngle!=0;
			if (bShear) {
				nShearX=((const SfxInt32Item&)rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_X)).GetValue();
				nShearY=((const SfxInt32Item&)rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_Y)).GetValue();
			}
		}
	}

	// AutoGrow
	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_AUTOWIDTH,TRUE,&pPoolItem)) {
		BOOL bAutoGrow=((const SfxBoolItem*)pPoolItem)->GetValue();
		aSetAttr.Put(SdrTextAutoGrowWidthItem(bAutoGrow));
		bSetAttr=TRUE;
	}

	if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_AUTOHEIGHT,TRUE,&pPoolItem)) {
		BOOL bAutoGrow=((const SfxBoolItem*)pPoolItem)->GetValue();
		aSetAttr.Put(SdrTextAutoGrowHeightItem(bAutoGrow));
		bSetAttr=TRUE;
	}

	// Eckenradius
	if (bEdgeRadiusAllowed && SFX_ITEM_SET==rAttr.GetItemState(SDRATTR_ECKENRADIUS,TRUE,&pPoolItem)) {
		long nRadius=((SdrEckenradiusItem*)pPoolItem)->GetValue();
		aSetAttr.Put(SdrEckenradiusItem(nRadius));
		bSetAttr=TRUE;
	}

	ForcePossibilities();

	BegUndo(ImpGetResStr(STR_EditTransform),GetDescriptionOfMarkedObjects());

	if (bSetAttr) {
		SetAttrToMarked(aSetAttr,FALSE);
	}

	// Groesse und Hoehe aendern
	if (bChgSiz && (bResizeFreeAllowed || bResizePropAllowed)) {
		Fraction aWdt(nSizX,aRect.Right()-aRect.Left());
		Fraction aHgt(nSizY,aRect.Bottom()-aRect.Top());
		Point aRef(ImpGetPoint(aRect,eSizePoint));
		
		if(GetSdrPageView()) 
		{
			GetSdrPageView()->PagePosToLogic(aRef);
		}

		ResizeMarkedObj(aRef,aWdt,aHgt);
	}

	// Rotieren
	if (bRotate && (bRotateFreeAllowed || bRotate90Allowed)) {
		Point aRef(nRotateX,nRotateY);
		
		if(GetSdrPageView()) 
		{
			GetSdrPageView()->PagePosToLogic(aRef);
		}

		RotateMarkedObj(aRef,nRotateAngle);
	}

	// #86909# set rotation point position
	if(bModeIsRotate && (nRotateX != nOldRotateX || nRotateY != nOldRotateY))
	{
		Point aNewRef1(nRotateX, nRotateY);
		
		if(GetSdrPageView())
		{
			GetSdrPageView()->PagePosToLogic(aNewRef1);
		}

		SetRef1(aNewRef1);
	}

	// Shear
	if (bShear && bShearAllowed) {
		Point aRef(nShearX,nShearY);
		
		if(GetSdrPageView()) 
		{
			GetSdrPageView()->PagePosToLogic(aRef);
		}

		ShearMarkedObj(aRef,nShearAngle,bShearVert);

        // #i74358#
		// ShearMarkedObj creates a linear combination of the existing transformation and
		// the new shear to apply. If the object is already transformed (e.g. rotated) the
		// linear combination will not decompose to the same start values again, but to a
		// new combination. Thus it makes no sense to check if the wanted shear is reached
		// or not. Taking out.
#if 0
        long nTempAngle=GetMarkedObjShear();
		if (nTempAngle!=0 && nTempAngle!=nNewShearAngle && !bShearVert) {
			// noch eine 2. Iteration zur Kompensation der Rundungsfehler
			double nOld=tan((double)nTempAngle*nPi180);
			double nNew=tan((double)nNewShearAngle*nPi180);
			nNew-=nOld;
			nNew=atan(nNew)/nPi180;
			nTempAngle=Round(nNew);
			if (nTempAngle!=0) {
				ShearMarkedObj(aRef,nTempAngle,bShearVert);
			}
		}
#endif
	}

	// Position aendern
	if (bChgPos && bMoveAllowed) {
		MoveMarkedObj(Size(nPosDX,nPosDY));
	}

	// protect position
	if(SFX_ITEM_SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_POS, TRUE, &pPoolItem))
	{
		const sal_Bool bProtPos(((const SfxBoolItem*)pPoolItem)->GetValue());
		bool bChanged(false);
		
		for(sal_uInt32 i(0); i < nMarkCount; i++) 
		{
			pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();

			if(pObj->IsMoveProtect() != bProtPos)
			{
				bChanged = true;
				pObj->SetMoveProtect(bProtPos);

				if(bProtPos)
				{
					pObj->SetResizeProtect(true);
				}
			}
		}

		if(bChanged)
		{
			bMoveProtect = bProtPos;

			if(bProtPos)
			{
				bResizeProtect = true;
			}

			// #i77187# there is no simple method to get the toolbars updated
			// in the application. The App is listening to selection change and i 
			// will use it here (even if not true). It's acceptable since changing
			// this model data is pretty rare and only possible using the F4 dialog
			MarkListHasChanged();
		}
	}

	if(!bMoveProtect)
	{
		// protect size
		if(SFX_ITEM_SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_SIZE, TRUE, &pPoolItem))
		{
			const sal_Bool bProtSize(((const SfxBoolItem*)pPoolItem)->GetValue());
			bool bChanged(false);
			
			for(sal_uInt32 i(0); i < nMarkCount; i++) 
			{
				pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();

				if(pObj->IsResizeProtect() != bProtSize)
				{
					bChanged = true;
					pObj->SetResizeProtect(bProtSize);
				}
			}

			if(bChanged)
			{
				bResizeProtect = bProtSize;
		
				// #i77187# see above
				MarkListHasChanged();
			}
		}
	}

	EndUndo();
}

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

BOOL SdrEditView::IsAlignPossible() const
{  // Mindestens 2 markierte Objekte, davon mind. 1 beweglich
	ForcePossibilities();
	ULONG nAnz=GetMarkedObjectCount();
	if (nAnz==0) return FALSE;         // Nix markiert!
	if (nAnz==1) return bMoveAllowed;  // einzelnes Obj an der Seite ausrichten
	return bOneOrMoreMovable;          // ansonsten ist MarkCount>=2
}

void SdrEditView::AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert, BOOL bBoundRects)
{
	if (eHor==SDRHALIGN_NONE && eVert==SDRVALIGN_NONE) return;
	SortMarkedObjects();
	if (GetMarkedObjectCount()<1) return;
	XubString aStr(GetDescriptionOfMarkedObjects());
	if (eHor==SDRHALIGN_NONE) {
		switch (eVert) {
			case SDRVALIGN_TOP   : ImpTakeDescriptionStr(STR_EditAlignVTop   ,aStr); break;
			case SDRVALIGN_BOTTOM: ImpTakeDescriptionStr(STR_EditAlignVBottom,aStr); break;
			case SDRVALIGN_CENTER: ImpTakeDescriptionStr(STR_EditAlignVCenter,aStr); break;
			default: break;
		}
	} else if (eVert==SDRVALIGN_NONE) {
		switch (eHor) {
			case SDRHALIGN_LEFT  : ImpTakeDescriptionStr(STR_EditAlignHLeft  ,aStr); break;
			case SDRHALIGN_RIGHT : ImpTakeDescriptionStr(STR_EditAlignHRight ,aStr); break;
			case SDRHALIGN_CENTER: ImpTakeDescriptionStr(STR_EditAlignHCenter,aStr); break;
			default: break;
		}
	} else if (eHor==SDRHALIGN_CENTER && eVert==SDRVALIGN_CENTER) {
		ImpTakeDescriptionStr(STR_EditAlignCenter,aStr);
	} else {
		ImpTakeDescriptionStr(STR_EditAlign,aStr);
	}
	BegUndo(aStr);
	Rectangle aBound;
	ULONG nMarkAnz=GetMarkedObjectCount();
	ULONG nm;
	BOOL bHasFixed=FALSE;
	for (nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pObj=pM->GetMarkedSdrObj();
		SdrObjTransformInfoRec aInfo;
		pObj->TakeObjInfo(aInfo);
		if (!aInfo.bMoveAllowed || pObj->IsMoveProtect()) {
			Rectangle aObjRect(bBoundRects?pObj->GetCurrentBoundRect():pObj->GetSnapRect());
			aBound.Union(aObjRect);
			bHasFixed=TRUE;
		}
	}
	if (!bHasFixed) {
		if (nMarkAnz==1) { // einzelnes Obj an der Seite ausrichten
			const SdrObject* pObj=GetMarkedObjectByIndex(0L);
			const SdrPage* pPage=pObj->GetPage();
			const SdrPageGridFrameList* pGFL=pPage->GetGridFrameList(GetSdrPageViewOfMarkedByIndex(0),&(pObj->GetSnapRect()));
			const SdrPageGridFrame* pFrame=NULL;
			if (pGFL!=NULL && pGFL->GetCount()!=0) { // Writer
				pFrame=&((*pGFL)[0]);
			}
			if (pFrame!=NULL) { // Writer
				aBound=pFrame->GetUserArea();
			} else {
				aBound=Rectangle(pPage->GetLftBorder(),pPage->GetUppBorder(),
								 pPage->GetWdt()-pPage->GetRgtBorder(),
								 pPage->GetHgt()-pPage->GetLwrBorder());
			}
		} else {
			if (bBoundRects) aBound=GetMarkedObjBoundRect();
			else aBound=GetMarkedObjRect();
		}
	}
	Point aCenter(aBound.Center());
	for (nm=0; nm<nMarkAnz; nm++) {
		SdrMark* pM=GetSdrMarkByIndex(nm);
		SdrObject* pObj=pM->GetMarkedSdrObj();
		SdrObjTransformInfoRec aInfo;
		pObj->TakeObjInfo(aInfo);
		if (aInfo.bMoveAllowed && !pObj->IsMoveProtect()) {
			// SdrPageView* pPV=pM->GetPageView();
			long nXMov=0;
			long nYMov=0;
			Rectangle aObjRect(bBoundRects?pObj->GetCurrentBoundRect():pObj->GetSnapRect());
			switch (eVert) {
				case SDRVALIGN_TOP   : nYMov=aBound.Top()   -aObjRect.Top()       ; break;
				case SDRVALIGN_BOTTOM: nYMov=aBound.Bottom()-aObjRect.Bottom()    ; break;
				case SDRVALIGN_CENTER: nYMov=aCenter.Y()    -aObjRect.Center().Y(); break;
				default: break;
			}
			switch (eHor) {
				case SDRHALIGN_LEFT  : nXMov=aBound.Left()  -aObjRect.Left()      ; break;
				case SDRHALIGN_RIGHT : nXMov=aBound.Right() -aObjRect.Right()     ; break;
				case SDRHALIGN_CENTER: nXMov=aCenter.X()    -aObjRect.Center().X(); break;
				default: break;
			}
			if (nXMov!=0 || nYMov!=0) 
			{
				// #104104# SdrEdgeObj needs an extra SdrUndoGeoObj since the
				// connections may need to be saved
				if(pObj && pObj->ISA(SdrEdgeObj))
				{
					AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
				}

				AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pObj,Size(nXMov,nYMov)));

				pObj->Move(Size(nXMov,nYMov));
			}
		}
	}
	EndUndo();
}

