/************************************************************************* * * $RCSfile: svdedtv1.cxx,v $ * * $Revision: 1.9 $ * * last change: $Author: aw $ $Date: 2001-02-16 12:16:18 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library 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 for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (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.openoffice.org/license.html. * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): _______________________________________ * * ************************************************************************/ #include "svdedtv.hxx" #include #ifndef _MATH_H #define _MATH_H #endif #ifndef _BIGINT_HXX //autogen #include #endif #ifndef _SFXITEMITER_HXX //autogen #include #endif #ifndef _SV_MSGBOX_HXX //autogen #include #endif #ifndef _SVX_RECTENUM_HXX //autogen #include #endif #include "svxids.hrc" // fuer SID_ATTR_TRANSFORM_... #include "svdattr.hxx" // fuer Get/SetGeoAttr #include "svditext.hxx" #include "svditer.hxx" #include "svdtrans.hxx" #include "svdundo.hxx" #include "svdpage.hxx" #include "svdpagv.hxx" #include "svdlayer.hxx" // fuer MergeNotPersistAttr #include "svdattrx.hxx" // fuer MergeNotPersistAttr #include "svdetc.hxx" // fuer SearchOutlinerItems #include "svdopath.hxx" // fuer Crook #include "svdstr.hrc" // Namen aus der Resource #include "svdglob.hxx" // StringCache #ifndef _EEITEM_HXX //autogen #include #endif #ifndef _AEITEM_HXX //autogen #include #endif #ifndef _SFX_WHITER_HXX #include #endif //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// // // @@@@@ @@@@@ @@ @@@@@@ @@ @@ @@ @@@@@ @@ @@ // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@ // @@@@ @@ @@ @@ @@ @@@@@ @@ @@@@ @@@@@@@ // @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@ // @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@ // @@@@@ @@@@@ @@ @@ @ @@ @@@@@ @@ @@ // //////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////// 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=aMark.GetMarkCount(); 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; nmGetObj(); AddUndo(new SdrUndoGeoObj(*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(); } 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,aMark.GetMarkDescription(),SDRREPFUNC_OBJ_MOVE); if (bCopy) CopyMarkedObj(); ULONG nMarkAnz=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoMoveObj(*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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoGeoObj(*pO)); Point aRef(rRef-pM->GetPageView()->GetOffset()); pO->Resize(aRef,xFact,yFact); } EndUndo(); } long SdrEditView::GetMarkedObjRotate() const { BOOL b1st=TRUE; BOOL bOk=TRUE; long nWink=0; ULONG nMarkAnz=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); 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); ULONG nMarkAnz=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoGeoObj(*pO)); Point aRef(rRef-pM->GetPageView()->GetOffset()); pO->Rotate(aRef,nWink,nSin,nCos); } 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(); ULONG nMarkAnz=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoGeoObj(*pO)); Point aRef1(rRef1-pM->GetPageView()->GetOffset()); Point aRef2(rRef2-pM->GetPageView()->GetOffset()); pO->Mirror(aRef1,aRef2); } 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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); 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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoGeoObj(*pO)); Point aRef(rRef); Point aOfs(pM->GetPageView()->GetOffset()); aRef-=aOfs; pO->Shear(aRef,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); bDone = TRUE; } if(!bDone && !pPath && pO->IsPolyObj() && pO->GetPointCount() != 0) { // FuerPolyObj's, aber NICHT fuer SdrPathObj's, z.B. fuer's Bemassungsobjekt USHORT nPtAnz=pO->GetPointCount(); XPolygon aXP(nPtAnz); USHORT nPtNum; for (nPtNum=0; nPtNumGetPoint(nPtNum)); aXP[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; } // switch for (nPtNum=0; nPtNumSetPoint(aXP[nPtNum],nPtNum); } bDone = TRUE; } if(!bDone) { // Fuer alle anderen oder wenn bNoContortion Point aCtr0(pO->GetSnapRect().Center()); Point aCtr1(aCtr0); BOOL bRotOk=FALSE; double nSin,nCos; double nWink=0; if (rRad.X()!=0 && rRad.Y()!=0) { 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; } // switch } 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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoGeoObj(*pO)); Point aRef(rRef); Point aOfs(pM->GetPageView()->GetOffset()); aRef-=aOfs; const SdrObjList* pOL=pO->GetSubList(); if (bNoContortion || pOL==NULL) { ImpCrookObj(pO,aRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect); } else { SdrObjListIter aIter(*pOL,IM_DEEPNOGROUPS); while (aIter.IsMore()) { SdrObject* pO1=aIter.Next(); ImpCrookObj(pO1,aRef,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!=NULL) { XPolyPolygon aXPP(pPath->GetPathPoly()); aXPP.Distort(rRef,rDistortedRect); pPath->SetPathPoly(aXPP); } else if (pO->IsPolyObj()) { // z.B. fuer's Bemassungsobjekt USHORT nPtAnz=pO->GetPointCount(); XPolygon aXP(nPtAnz); USHORT nPtNum; for (nPtNum=0; nPtNumGetPoint(nPtNum)); aXP[nPtNum]=aPt; } aXP.Distort(rRef,rDistortedRect); for (nPtNum=0; nPtNumSetPoint(aXP[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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); AddUndo(new SdrUndoGeoObj(*pO)); Rectangle aRefRect(rRef); XPolygon aRefPoly(rDistortedRect); Point aOfs(pM->GetPageView()->GetOffset()); if (aOfs.X()!=0 || aOfs.Y()!=0) { aRefRect.Move(-aOfs.X(),-aOfs.Y()); aRefPoly.Move(-aOfs.X(),-aOfs.Y()); } 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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); const SdrPageView* pPV=pM->GetPageView(); AddUndo(new SdrUndoGeoObj(*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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj(); if (nm==0) { nLayerId=pObj->GetLayer(); bMovProtect=pObj->IsMoveProtect(); bSizProtect=pObj->IsResizeProtect(); bPrintable =pObj->IsPrintable(); Rectangle aSnapRect(pObj->GetSnapRect()); Rectangle aLogicRect(pObj->GetLogicRect()); nSnapPosX=aSnapRect.Left(); nSnapPosY=aSnapRect.Top(); nSnapWdt=aSnapRect.GetWidth()-1; nSnapHgt=aSnapRect.GetHeight()-1; nLogicWdt=aLogicRect.GetWidth()-1; nLogicHgt=aLogicRect.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 && pObj->HasSetName()) { 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); return aSet; } void SdrEditView::MergeAttrFromMarked(SfxItemSet& rAttr, BOOL bOnlyHardAttr) const { sal_uInt32 nMarkAnz(aMark.GetMarkCount()); for(sal_uInt32 a(0); a < nMarkAnz; a++) { // #80277# merging was done wrong in the prev version const SfxItemSet& rSet = aMark.GetMark(a)->GetObj()->GetItemSet(); 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 (HasMarkedObj()) { #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 // 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); ULONG nMarkAnz=aMark.GetMarkCount(); // 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); for (ULONG nm=0; nmGetObj())); } // add attribute undo AddUndo(new SdrUndoAttrObj(*pM->GetObj(),FALSE,bHasEEItems || bPossibleGeomChange)); SdrBroadcastItemChange aItemChange(*pM->GetObj()); if(bReplaceAll) pM->GetObj()->ClearItem(); pM->GetObj()->SetItemSet(aAttr); pM->GetObj()->BroadcastItemChange(aItemChange); } // 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=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj()->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 (HasMarkedObj()) { XubString aStr; if (pStyleSheet!=NULL) ImpTakeDescriptionStr(STR_EditSetStylesheet,aStr); else ImpTakeDescriptionStr(STR_EditDelStylesheet,aStr); BegUndo(aStr); ULONG nMarkAnz=aMark.GetMarkCount(); for (ULONG nm=0; nmGetObj())); AddUndo(new SdrUndoAttrObj(*pM->GetObj(),TRUE,TRUE)); pM->GetObj()->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr); } EndUndo(); } } //////////////////////////////////////////////////////////////////////////////////////////////////// /* new interface src537 */ BOOL SdrEditView::GetAttributes(SfxItemSet& rTargetSet, BOOL bOnlyHardAttr) const { if(aMark.GetMarkCount()) { rTargetSet.Put(GetAttrFromMarked(bOnlyHardAttr), FALSE); return TRUE; } else { return SdrMarkView::GetAttributes(rTargetSet, bOnlyHardAttr); } } BOOL SdrEditView::SetAttributes(const SfxItemSet& rSet, BOOL bReplaceAll) { if (aMark.GetMarkCount()!=0) { SetAttrToMarked(rSet,bReplaceAll); return TRUE; } else { return SdrMarkView::SetAttributes(rSet,bReplaceAll); } } SfxStyleSheet* SdrEditView::GetStyleSheet(BOOL& rOk) const { if (aMark.GetMarkCount()!=0) { rOk=TRUE; return GetStyleSheetFromMarked(); } else { return SdrMarkView::GetStyleSheet(rOk); } } BOOL SdrEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr) { if (aMark.GetMarkCount()!=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 (HasMarkedObj()) { SfxItemSet aMarkAttr(GetAttrFromMarked(FALSE)); // wg. AutoGrowHeight und Eckenradius Rectangle aRect(GetMarkedObjRect()); if (GetPageViewCount()==1) { // hier mal etwas verbessern !!! GetPageViewPvNum(0)->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 (GetPageViewCount()==1) { // hier mal etwas verbessern !!! GetPageViewPvNum(0)->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=GetMarkList(); ULONG nMarkCount=rMarkList.GetMarkCount(); SdrObject* pObj=rMarkList.GetMark(0)->GetObj(); BOOL bPosProt=pObj->IsMoveProtect(); BOOL bSizProt=pObj->IsResizeProtect(); BOOL bPosProtDontCare=FALSE; BOOL bSizProtDontCare=FALSE; for (ULONG i=1; iGetObj(); 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 (GetPageViewCount()==1) { GetPageViewPvNum(0)->LogicToPagePos(aRect); } long nOldRotateAngle=GetMarkedObjRotate(); long nOldShearAngle=GetMarkedObjShear(); const SdrMarkList& rMarkList=GetMarkList(); 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; long nRotateX=0; long nRotateY=0; 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; if (bRotate) { nRotateX=((const SfxInt32Item&)rAttr.Get(SID_ATTR_TRANSFORM_ROT_X)).GetValue(); 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),aMark.GetMarkDescription()); 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 (GetPageViewCount()==1) { GetPageViewPvNum(0)->PagePosToLogic(aRef); } ResizeMarkedObj(aRef,aWdt,aHgt); } // Rotieren if (bRotate && (bRotateFreeAllowed || bRotate90Allowed)) { Point aRef(nRotateX,nRotateY); if (GetPageViewCount()==1) { GetPageViewPvNum(0)->PagePosToLogic(aRef); } RotateMarkedObj(aRef,nRotateAngle); } // Shear if (bShear && bShearAllowed) { Point aRef(nShearX,nShearY); if (GetPageViewCount()==1) { GetPageViewPvNum(0)->PagePosToLogic(aRef); } ShearMarkedObj(aRef,nShearAngle,bShearVert); 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); } } } // Position aendern if (bChgPos && bMoveAllowed) { MoveMarkedObj(Size(nPosDX,nPosDY)); } // Position geschuetzt if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_POS,TRUE,&pPoolItem)) { BOOL bProtPos=((const SfxBoolItem*)pPoolItem)->GetValue(); for (ULONG i=0; iGetObj(); pObj->SetMoveProtect(bProtPos); } // BugFix 13897: hier muesste besser ein Broadcast her! // Ausserdem fehlt Undo // oder -> bProtPos/Size als Item (Interface) bMoveProtect=bProtPos; } // Groesse geschuetzt if (SFX_ITEM_SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_SIZE,TRUE,&pPoolItem)) { BOOL bProtSize=((const SfxBoolItem*)pPoolItem)->GetValue(); for (ULONG i=0; iGetObj(); pObj->SetResizeProtect(bProtSize); } // BugFix 13897: hier muesste besser ein Broadcast her! // Ausserdem fehlt Undo // oder -> bProtPos/Size als Item (Interface) bResizeProtect=bProtSize; } EndUndo(); } //////////////////////////////////////////////////////////////////////////////////////////////////// BOOL SdrEditView::IsAlignPossible() const { // Mindestens 2 markierte Objekte, davon mind. 1 beweglich ForcePossibilities(); ULONG nAnz=aMark.GetMarkCount(); 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; aMark.ForceSort(); if (aMark.GetMarkCount()<1) return; XubString aStr(aMark.GetMarkDescription()); 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; } } 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; } } else if (eHor==SDRHALIGN_CENTER && eVert==SDRVALIGN_CENTER) { ImpTakeDescriptionStr(STR_EditAlignCenter,aStr); } else { ImpTakeDescriptionStr(STR_EditAlign,aStr); } BegUndo(aStr); Rectangle aBound; ULONG nMarkAnz=aMark.GetMarkCount(); ULONG nm; BOOL bHasFixed=FALSE; for (nm=0; nmGetObj(); SdrObjTransformInfoRec aInfo; pObj->TakeObjInfo(aInfo); if (!aInfo.bMoveAllowed || pObj->IsMoveProtect()) { Point aOfs(pM->GetPageView()->GetOffset()); Rectangle aObjRect(bBoundRects?pObj->GetBoundRect():pObj->GetSnapRect()); aObjRect.Move(aOfs.X(),aOfs.Y()); aBound.Union(aObjRect); bHasFixed=TRUE; } } if (!bHasFixed) { if (nMarkAnz==1) { // einzelnes Obj an der Seite ausrichten const SdrObject* pObj=aMark.GetMark(0L)->GetObj(); const SdrPage* pPage=pObj->GetPage(); const SdrPageGridFrameList* pGFL=pPage->GetGridFrameList(aMark.GetMark(0L)->GetPageView(),&(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; nmGetObj(); SdrObjTransformInfoRec aInfo; pObj->TakeObjInfo(aInfo); if (aInfo.bMoveAllowed && !pObj->IsMoveProtect()) { SdrPageView* pPV=pM->GetPageView(); Point aOfs(pPV->GetOffset()); long nXMov=0; long nYMov=0; Rectangle aObjRect(bBoundRects?pObj->GetBoundRect():pObj->GetSnapRect()); switch (eVert) { case SDRVALIGN_TOP : nYMov=aBound.Top() -aObjRect.Top() -aOfs.Y(); break; case SDRVALIGN_BOTTOM: nYMov=aBound.Bottom()-aObjRect.Bottom() -aOfs.Y(); break; case SDRVALIGN_CENTER: nYMov=aCenter.Y() -aObjRect.Center().Y()-aOfs.Y(); break; } switch (eHor) { case SDRHALIGN_LEFT : nXMov=aBound.Left() -aObjRect.Left() -aOfs.X(); break; case SDRHALIGN_RIGHT : nXMov=aBound.Right() -aObjRect.Right() -aOfs.X(); break; case SDRHALIGN_CENTER: nXMov=aCenter.X() -aObjRect.Center().X()-aOfs.X(); break; } if (nXMov!=0 || nYMov!=0) { AddUndo(new SdrUndoMoveObj(*pObj,Size(nXMov,nYMov))); pObj->Move(Size(nXMov,nYMov)); } } } EndUndo(); }