/*************************************************************************
*
* $RCSfile: svdedtv.cxx,v $
*
* $Revision: 1.5 $
*
* last change: $Author: sj $ $Date: 2001-05-22 10:06:06 $
*
* 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 <vcl/metaact.hxx>
#include "svdedtv.hxx"
#include "svdxout.hxx"
#include "svdundo.hxx"
#include "svdograf.hxx" // fuer Possibilities
#include "svdopath.hxx"
#include "svdoole2.hxx"
#include "svdopage.hxx"
#include "svdoedge.hxx"
#include "svdlayer.hxx"
#include "svdpagv.hxx"
#include "svdpage.hxx"
#include "svdpoev.hxx" // fuer die PolyPossiblities
#include "svdstr.hrc" // Namen aus der Resource
#include "svdglob.hxx" // StringCache
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// @@@@@ @@@@@ @@ @@@@@@ @@ @@ @@ @@@@@ @@ @@
// @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@
// @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @ @@
// @@@@ @@ @@ @@ @@ @@@@@ @@ @@@@ @@@@@@@
// @@ @@ @@ @@ @@ @@@ @@ @@ @@@@@@@
// @@ @@ @@ @@ @@ @@@ @@ @@ @@@ @@@
// @@@@@ @@@@@ @@ @@ @ @@ @@@@@ @@ @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
void SdrEditView::ImpResetPossibilityFlags()
{
bReadOnly =FALSE;
bGroupPossible =FALSE;
bUnGroupPossible =FALSE;
bGrpEnterPossible =FALSE;
bDeletePossible =FALSE;
bToTopPossible =FALSE;
bToBtmPossible =FALSE;
bReverseOrderPossible =FALSE;
bImportMtfPossible =FALSE;
bCombinePossible =FALSE;
bDismantlePossible =FALSE;
bCombineNoPolyPolyPossible =FALSE;
bDismantleMakeLinesPossible=FALSE;
bOrthoDesiredOnMarked =FALSE;
bMoreThanOneNotMovable =FALSE;
bOneOrMoreMovable =FALSE;
bMoreThanOneNoMovRot =FALSE;
bContortionPossible =FALSE;
bAllPolys =FALSE;
bOneOrMorePolys =FALSE;
bMoveAllowed =FALSE;
bResizeFreeAllowed =FALSE;
bResizePropAllowed =FALSE;
bRotateFreeAllowed =FALSE;
bRotate90Allowed =FALSE;
bMirrorFreeAllowed =FALSE;
bMirror45Allowed =FALSE;
bMirror90Allowed =FALSE;
bTransparenceAllowed =FALSE;
bGradientAllowed =FALSE;
bShearAllowed =FALSE;
bEdgeRadiusAllowed =FALSE;
bCanConvToPath =FALSE;
bCanConvToPoly =FALSE;
bCanConvToContour =FALSE;
bCanConvToPathLineToArea=FALSE;
bCanConvToPolyLineToArea=FALSE;
bMoveProtect =FALSE;
bResizeProtect =FALSE;
}
void SdrEditView::ImpClearVars()
{
ImpResetPossibilityFlags();
bPossibilitiesDirty=TRUE; // << war von Purify angemeckert
bCombineError=FALSE;
bBundleVirtObj=FALSE;
}
SdrEditView::SdrEditView(SdrModel* pModel1, OutputDevice* pOut):
SdrMarkView(pModel1,pOut)
{
ImpClearVars();
}
SdrEditView::SdrEditView(SdrModel* pModel1, ExtOutputDevice* pXOut):
SdrMarkView(pModel1,pXOut)
{
ImpClearVars();
}
SdrEditView::~SdrEditView()
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
SdrLayer* SdrEditView::InsertNewLayer(const XubString& rName, USHORT nPos)
{
SdrLayerAdmin& rLA=pMod->GetLayerAdmin();
USHORT nMax=rLA.GetLayerCount();
if (nPos>nMax) nPos=nMax;
SdrLayer* pNewLayer=rLA.NewLayer(rName,nPos);
AddUndo(new SdrUndoNewLayer(nPos,rLA,*pMod));
pMod->SetChanged();
return pNewLayer;
}
BOOL SdrEditView::ImpDelLayerCheck(SdrObjList* pOL, SdrLayerID nDelID) const
{
BOOL bDelAll=TRUE;
ULONG nObjAnz=pOL->GetObjCount();
for (ULONG nObjNum=nObjAnz; nObjNum>0 && bDelAll;) {
nObjNum--;
SdrObject* pObj=pOL->GetObj(nObjNum);
SdrObjList* pSubOL=pObj->GetSubList();
if (pSubOL!=NULL) { // Gruppenobjekt
if (!ImpDelLayerCheck(pSubOL,nDelID)) bDelAll=FALSE; // Rekursion
} else {
if (pObj->GetLayer()!=nDelID) bDelAll=FALSE;
}
}
return bDelAll;
}
void SdrEditView::ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID)
{
ULONG nObjAnz=pOL->GetObjCount();
pOL->GetObj(0)->GetOrdNum(); // Sicherstellen, dass die OrdNums stimmen
for (ULONG nObjNum=nObjAnz; nObjNum>0;) {
nObjNum--;
SdrObject* pObj=pOL->GetObj(nObjNum);
SdrObjList* pSubOL=pObj->GetSubList();
if (pSubOL!=NULL) { // Gruppenobjekt
if (ImpDelLayerCheck(pSubOL,nDelID)) {
AddUndo(new SdrUndoDelObj(*pObj,TRUE));
pOL->RemoveObject(nObjNum);
} else {
ImpDelLayerDelObjs(pSubOL,nDelID);
}
} else {
if (pObj->GetLayer()==nDelID) {
AddUndo(new SdrUndoDelObj(*pObj,TRUE));
pOL->RemoveObject(nObjNum);
}
}
}
}
void SdrEditView::DeleteLayer(const XubString& rName)
{
SdrLayerAdmin& rLA=pMod->GetLayerAdmin();
SdrLayer* pLayer=rLA.GetLayer(rName,TRUE);
USHORT nLayerNum=rLA.GetLayerPos(pLayer);
if (nLayerNum!=SDRLAYER_NOTFOUND) {
SdrLayerID nDelID=pLayer->GetID();
BegUndo(ImpGetResStr(STR_UndoDelLayer));
BOOL bMaPg=TRUE;
for (USHORT nPageKind=0; nPageKind<2; nPageKind++) { // MasterPages und Zeichenseiten
USHORT nPgAnz=bMaPg ? pMod->GetMasterPageCount() : pMod->GetPageCount();
for (USHORT nPgNum=0; nPgNum<nPgAnz; nPgNum++) { // ueber alle Seiten
SdrPage* pPage=bMaPg ? pMod->GetMasterPage(nPgNum) : pMod->GetPage(nPgNum);
ULONG nObjAnz=pPage->GetObjCount();
if (nObjAnz!=0) pPage->GetObj(0)->GetOrdNum(); // Sicherstellen, dass die OrdNums stimmen
for (ULONG nObjNum=nObjAnz; nObjNum>0;) {
nObjNum--;
SdrObject* pObj=pPage->GetObj(nObjNum);
SdrObjList* pSubOL=pObj->GetSubList();
if (pSubOL!=NULL) { // Gruppenobjekt
if (ImpDelLayerCheck(pSubOL,nDelID)) {
AddUndo(new SdrUndoDelObj(*pObj,TRUE));
pPage->RemoveObject(nObjNum);
} else {
ImpDelLayerDelObjs(pSubOL,nDelID);
}
} else {
if (pObj->GetLayer()==nDelID) {
AddUndo(new SdrUndoDelObj(*pObj,TRUE));
pPage->RemoveObject(nObjNum);
}
}
}
}
bMaPg=FALSE;
}
AddUndo(new SdrUndoDelLayer(nLayerNum,rLA,*pMod));
rLA.RemoveLayer(nLayerNum);
EndUndo();
pMod->SetChanged();
}
}
void SdrEditView::MoveLayer(const XubString& rName, USHORT nNewPos)
{
SdrLayerAdmin& rLA=pMod->GetLayerAdmin();
SdrLayer* pLayer=rLA.GetLayer(rName,TRUE);
USHORT nLayerNum=rLA.GetLayerPos(pLayer);
if (nLayerNum!=SDRLAYER_NOTFOUND) {
AddUndo(new SdrUndoMoveLayer(nLayerNum,rLA,*pMod,nNewPos));
rLA.MoveLayer(nLayerNum,nNewPos);
pMod->SetChanged();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void SdrEditView::EndUndo()
{
pMod->EndUndo();
if (pMod->GetUndoBracketLevel()==0) {
ImpBroadcastEdgesOfMarkedNodes();
}
}
void SdrEditView::ImpBroadcastEdgesOfMarkedNodes()
{
ForceEdgesOfMarkedNodes();
ULONG nMarkedEdgeAnz=aMarkedEdges.GetMarkCount();
USHORT i;
for (i=0; i<nMarkedEdgeAnz; i++) {
SdrMark* pEM=aMarkedEdges.GetMark(i);
SdrObject* pEdgeTmp=pEM->GetObj();
SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pEdgeTmp);
if (pEdge!=NULL && TRUE) {
SdrObject* pObj1=pEdge->GetConnectedNode(FALSE);
SdrObject* pObj2=pEdge->GetConnectedNode(TRUE);
if (pObj1!=NULL && !IsObjMarked(pObj1) && !pEdge->CheckNodeConnection(FALSE)) pEdge->DisconnectFromNode(FALSE);
if (pObj2!=NULL && !IsObjMarked(pObj2) && !pEdge->CheckNodeConnection(TRUE)) pEdge->DisconnectFromNode(TRUE);
}
}
nMarkedEdgeAnz=aMarkedEdgesOfMarkedNodes.GetMarkCount();
for (i=0; i<nMarkedEdgeAnz; i++) {
SdrMark* pEM=aMarkedEdgesOfMarkedNodes.GetMark(i);
SdrObject* pEdgeTmp=pEM->GetObj();
SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pEdgeTmp);
if (pEdge!=NULL) {
pEdge->SetEdgeTrackDirty();
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// #### ### #### #### # #### # # # ##### # ##### ####
// # # # # # # # # # # # # # # # #
// #### # # ### ### # #### # # # # # #### ###
// # # # # # # # # # # # # # # #
// # ### #### #### # #### # #### # # # ##### ####
//
////////////////////////////////////////////////////////////////////////////////////////////////////
void SdrEditView::MarkListHasChanged()
{
SdrMarkView::MarkListHasChanged();
bPossibilitiesDirty=TRUE;
}
void SdrEditView::ModelHasChanged()
{
SdrMarkView::ModelHasChanged();
bPossibilitiesDirty=TRUE;
}
BOOL SdrEditView::IsResizeAllowed(BOOL bProp) const
{
ForcePossibilities();
if (bResizeProtect) return FALSE;
if (bProp) return bResizePropAllowed;
return bResizeFreeAllowed;
}
BOOL SdrEditView::IsRotateAllowed(BOOL b90Deg) const
{
ForcePossibilities();
if (bMoveProtect) return FALSE;
if (b90Deg) return bRotate90Allowed;
return bRotateFreeAllowed;
}
BOOL SdrEditView::IsMirrorAllowed(BOOL b45Deg, BOOL b90Deg) const
{
ForcePossibilities();
if (bMoveProtect) return FALSE;
if (b90Deg) return bMirror90Allowed;
if (b45Deg) return bMirror45Allowed;
return bMirrorFreeAllowed && !bMoveProtect;
}
BOOL SdrEditView::IsTransparenceAllowed() const
{
ForcePossibilities();
return bTransparenceAllowed;
}
BOOL SdrEditView::IsGradientAllowed() const
{
ForcePossibilities();
return bGradientAllowed;
}
BOOL SdrEditView::IsShearAllowed() const
{
ForcePossibilities();
if (bResizeProtect) return FALSE;
return bShearAllowed;
}
BOOL SdrEditView::IsEdgeRadiusAllowed() const
{
ForcePossibilities();
return bEdgeRadiusAllowed;
}
BOOL SdrEditView::IsCrookAllowed(BOOL bNoContortion) const
{
// CrookMode fehlt hier (weil kein Rotate bei Shear ...)
ForcePossibilities();
if (bNoContortion) {
if (!bRotateFreeAllowed) return FALSE; // Crook is nich
return !bMoveProtect && bMoveAllowed;
} else {
return !bResizeProtect && bContortionPossible;
}
}
BOOL SdrEditView::IsDistortAllowed(BOOL bNoContortion) const
{
ForcePossibilities();
if (bNoContortion) {
return FALSE;
} else {
return !bResizeProtect && bContortionPossible;
}
}
BOOL SdrEditView::IsCombinePossible(BOOL bNoPolyPoly) const
{
ForcePossibilities();
if (bNoPolyPoly) return bCombineNoPolyPolyPossible;
else return bCombinePossible;
}
BOOL SdrEditView::IsDismantlePossible(BOOL bMakeLines) const
{
ForcePossibilities();
if (bMakeLines) return bDismantleMakeLinesPossible;
else return bDismantlePossible;
}
void SdrEditView::CheckPossibilities()
{
if (bSomeObjChgdFlag) bPossibilitiesDirty=TRUE;
if(bSomeObjChgdFlag)
{
// This call IS necessary to correct the MarkList, in which
// no longer to the model belonging objects still can reside.
// These ones nned to be removed.
CheckMarked();
}
if (bPossibilitiesDirty) {
ImpResetPossibilityFlags();
aMark.ForceSort();
ULONG nMarkAnz=aMark.GetMarkCount();
if (nMarkAnz!=0) {
bReverseOrderPossible=nMarkAnz>=2;
ULONG nMovableCount=0;
bGroupPossible=nMarkAnz>=2;
bCombinePossible=nMarkAnz>=2;
if (nMarkAnz==1) {
// bCombinePossible gruendlicher checken
// fehlt noch ...
const SdrObject* pObj=aMark.GetMark(0)->GetObj();
const SdrPathObj* pPath=PTR_CAST(SdrPathObj,pObj);
BOOL bGroup=pObj->GetSubList()!=NULL;
BOOL bHasText=pObj->GetOutlinerParaObject()!=NULL;
if (bGroup || bHasText) {
bCombinePossible=TRUE;
} else {
// folgendes Statemant macht IMHO keinen Sinn (Bugfix am 27-11-1995 Combine und Fontwork):
//bCombinePossible=pPath->GetPathPoly().Count()>1;
}
}
bCombineNoPolyPolyPossible=bCombinePossible;
bDeletePossible=TRUE;
// Zu den Transformationen erstmal ja sagen
bMoveAllowed =TRUE;
bResizeFreeAllowed=TRUE;
bResizePropAllowed=TRUE;
bRotateFreeAllowed=TRUE;
bRotate90Allowed =TRUE;
bMirrorFreeAllowed=TRUE;
bMirror45Allowed =TRUE;
bMirror90Allowed =TRUE;
bShearAllowed =TRUE;
bEdgeRadiusAllowed=FALSE;
bContortionPossible=TRUE;
bCanConvToContour = TRUE;
// these ones are only allowed when single object is selected
bTransparenceAllowed = (nMarkAnz == 1);
bGradientAllowed = (nMarkAnz == 1);
if(bGradientAllowed)
{
// gradient depends on fillstyle
const SdrMark* pM = aMark.GetMark(0);
const SdrObject* pObj = pM->GetObj();
XFillStyle eFillStyle = ((XFillStyleItem&)(pObj->GetItem(XATTR_FILLSTYLE))).GetValue();
if(eFillStyle != XFILL_GRADIENT)
{
bGradientAllowed = FALSE;
}
}
BOOL bNoMovRotFound=FALSE;
const SdrPageView* pPV0=NULL;
for (ULONG nm=0; nm<nMarkAnz; nm++) {
const SdrMark* pM=aMark.GetMark(nm);
const SdrObject* pObj=pM->GetObj();
const SdrPageView* pPV=pM->GetPageView();
if (pPV!=pPV0) {
if (pPV->IsReadOnly()) bReadOnly=TRUE;
pPV0=pPV;
}
SdrObjTransformInfoRec aInfo;
pObj->TakeObjInfo(aInfo);
BOOL bMovPrt=pObj->IsMoveProtect();
BOOL bSizPrt=pObj->IsResizeProtect();
if (!bMovPrt && aInfo.bMoveAllowed) nMovableCount++; // Menge der MovableObjs zaehlen
if (bMovPrt) bMoveProtect=TRUE;
if (bSizPrt) bResizeProtect=TRUE;
// not allowed when not allowed at one object
if(!aInfo.bTransparenceAllowed)
bTransparenceAllowed = FALSE;
// Wenn einer was nicht kann, duerfen's alle nicht
if (!aInfo.bMoveAllowed ) bMoveAllowed =FALSE;
if (!aInfo.bResizeFreeAllowed) bResizeFreeAllowed=FALSE;
if (!aInfo.bResizePropAllowed) bResizePropAllowed=FALSE;
if (!aInfo.bRotateFreeAllowed) bRotateFreeAllowed=FALSE;
if (!aInfo.bRotate90Allowed ) bRotate90Allowed =FALSE;
if (!aInfo.bMirrorFreeAllowed) bMirrorFreeAllowed=FALSE;
if (!aInfo.bMirror45Allowed ) bMirror45Allowed =FALSE;
if (!aInfo.bMirror90Allowed ) bMirror90Allowed =FALSE;
if (!aInfo.bShearAllowed ) bShearAllowed =FALSE;
if (aInfo.bEdgeRadiusAllowed) bEdgeRadiusAllowed=TRUE;
if (aInfo.bNoContortion ) bContortionPossible=FALSE;
// Fuer Crook mit Contortion: Alle Objekte muessen
// Movable und Rotatable sein, ausser maximal 1
if (!bMoreThanOneNoMovRot) {
if (!aInfo.bMoveAllowed || !aInfo.bResizeFreeAllowed) {
bMoreThanOneNoMovRot=bNoMovRotFound;
bNoMovRotFound=TRUE;
}
}
// when one member cannot be converted, no conversion is possible
if(!aInfo.bCanConvToContour)
bCanConvToContour = FALSE;
// Ungroup
if (!bUnGroupPossible) bUnGroupPossible=pObj->GetSubList()!=NULL;
// ConvertToCurve: Wenn mind. einer konvertiert werden kann ist das ok.
if (aInfo.bCanConvToPath ) bCanConvToPath =TRUE;
if (aInfo.bCanConvToPoly ) bCanConvToPoly =TRUE;
if (aInfo.bCanConvToPathLineToArea) bCanConvToPathLineToArea=TRUE;
if (aInfo.bCanConvToPolyLineToArea) bCanConvToPolyLineToArea=TRUE;
// Combine/Dismantle
if (bCombinePossible) {
bCombinePossible=ImpCanConvertForCombine(pObj);
bCombineNoPolyPolyPossible=bCombinePossible;
}
if (!bDismantlePossible) bDismantlePossible=ImpCanDismantle(pObj,FALSE);
if (!bDismantleMakeLinesPossible) bDismantleMakeLinesPossible=ImpCanDismantle(pObj,TRUE);
// OrthoDesiredOnMarked checken
if (!bOrthoDesiredOnMarked && !aInfo.bNoOrthoDesired) bOrthoDesiredOnMarked=TRUE;
// ImportMtf checken
if (!bImportMtfPossible) {
BOOL bGraf=HAS_BASE(SdrGrafObj,pObj);
BOOL bOle2=HAS_BASE(SdrOle2Obj,pObj);
if( bGraf && ((SdrGrafObj*)pObj)->HasGDIMetaFile() && !((SdrGrafObj*)pObj)->IsEPS() )
bImportMtfPossible = TRUE;
if (bOle2)
bImportMtfPossible=((SdrOle2Obj*)pObj)->HasGDIMetaFile();
}
}
bMoreThanOneNotMovable=nMovableCount<nMarkAnz-1;
bOneOrMoreMovable=nMovableCount!=0;
bGrpEnterPossible=bUnGroupPossible;
}
ImpCheckToTopBtmPossible();
((SdrPolyEditView*)this)->ImpCheckPolyPossibilities();
bPossibilitiesDirty=FALSE;
if (bReadOnly) {
BOOL bMerker1=bGrpEnterPossible;
ImpResetPossibilityFlags();
bReadOnly=TRUE;
bGrpEnterPossible=bMerker1;
}
if (bMoveAllowed) {
// Verschieben von angeklebten Verbindern unterbinden
// Derzeit nur fuer Einfachselektion implementiert.
if (nMarkAnz==1) {
SdrObject* pObj=aMark.GetMark(0)->GetObj();
SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pObj);
if (pEdge!=NULL) {
SdrObject* pNode1=pEdge->GetConnectedNode(TRUE);
SdrObject* pNode2=pEdge->GetConnectedNode(FALSE);
if (pNode1!=NULL || pNode2!=NULL) bMoveAllowed=FALSE;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void SdrEditView::ForceMarkedObjToAnotherPage()
{
BOOL bFlg=FALSE;
for (ULONG nm=0; nm<aMark.GetMarkCount(); nm++) {
SdrMark* pM=aMark.GetMark(nm);
SdrObject* pObj=pM->GetObj();
Rectangle aObjRect(pObj->GetBoundRect());
aObjRect+=pM->GetPageView()->GetOffset(); // auf View-Koordinaten
Rectangle aPgRect(pM->GetPageView()->GetPageRect());
if (!aObjRect.IsOver(aPgRect)) {
BOOL bFnd=FALSE;
SdrPageView* pPV;
for (USHORT nv=GetPageViewCount(); nv>0 && !bFnd;) {
nv--;
pPV=GetPageViewPvNum(nv);
bFnd=aObjRect.IsOver(pPV->GetPageRect());
}
if (bFnd) {
pM->GetPageView()->GetObjList()->RemoveObject(pObj->GetOrdNum());
Point aDelta(pM->GetPageView()->GetOffset()-pPV->GetOffset());
pObj->Move(Size(aDelta.X(),aDelta.Y()));
SdrInsertReason aReason(SDRREASON_VIEWCALL);
pPV->GetObjList()->InsertObject(pObj,CONTAINER_APPEND,&aReason);
pM->SetPageView(pPV);
InvalidateAllWin(aObjRect);
bFlg=TRUE;
}
}
}
if (bFlg) {
MarkListHasChanged();
}
}
void SdrEditView::DeleteMarked(SdrMarkList& rMark)
{
if (rMark.GetMarkCount()!=0) {
rMark.ForceSort();
BegUndo();
ULONG nMarkAnz=rMark.GetMarkCount();
ULONG nm;
for (nm=nMarkAnz; nm>0;) {
nm--;
SdrMark* pM=rMark.GetMark(nm);
AddUndo(new SdrUndoDelObj(*pM->GetObj()));
}
// Sicherstellen, dass die OrderNums stimmen:
rMark.GetMark(0)->GetObj()->GetOrdNum();
for (nm=nMarkAnz; nm>0;) {
nm--;
SdrMark* pM=rMark.GetMark(nm);
SdrObject* pObj=pM->GetObj();
SdrPageView* pPV =pM->GetPageView();
SdrObjList* pOL =pObj->GetObjList(); //#52680#
UINT32 nOrdNum=pObj->GetOrdNumDirect();
SdrObject* pChkObj=pOL->RemoveObject(nOrdNum);
DBG_ASSERT(pChkObj==pObj,"DeleteMarked(MarkList): pChkObj!=pObj beim RemoveObject()");
}
EndUndo();
}
}
void SdrEditView::DeleteMarkedObj()
{
if (aMark.GetMarkCount()!=0) {
nSpecialCnt=0;
BrkAction();
HideMarkHdl(NULL);
BegUndo(ImpGetResStr(STR_EditDelete),aMark.GetMarkDescription(),SDRREPFUNC_OBJ_DELETE);
DeleteMarked(aMark);
aMark.Clear();
aHdl.Clear();
EndUndo();
MarkListHasChanged();
}
}
void SdrEditView::CopyMarkedObj()
{
aMark.ForceSort();
ForceEdgesOfMarkedNodes();
SdrMarkList aSourceObjectsForCopy(aMark);
// Folgende Schleife Anstatt MarkList::Merge(), damit
// ich jeweils mein Flag an die MarkEntries setzen kann.
ULONG nEdgeAnz=aEdgesOfMarkedNodes.GetMarkCount();
for (ULONG nEdgeNum=0; nEdgeNum<nEdgeAnz; nEdgeNum++) {
SdrMark aM(*aEdgesOfMarkedNodes.GetMark(nEdgeNum));
aM.SetUser(1);
aSourceObjectsForCopy.InsertEntry(aM);
}
aSourceObjectsForCopy.ForceSort();
SdrMarkList aCopiedObjects;
aMark.Clear();
ULONG nCloneErrCnt=0;
ULONG nMarkAnz=aSourceObjectsForCopy.GetMarkCount();
ULONG nm;
for (nm=0; nm<nMarkAnz; nm++) {
SdrMark* pM=aSourceObjectsForCopy.GetMark(nm);
SdrObject* pO=pM->GetObj()->Clone();
if (pO!=NULL) {
SdrInsertReason aReason(SDRREASON_VIEWCALL);
pM->GetPageView()->GetObjList()->InsertObject(pO,CONTAINER_APPEND,&aReason);
AddUndo(new SdrUndoCopyObj(*pO));
SdrMark aME(*pM);
aME.SetObj(pO);
aCopiedObjects.InsertEntry(aME);
if (pM->GetUser()==0) { // Sonst war's nur eine mitzukierende Edge
aMark.InsertEntry(aME);
}
} else {
nCloneErrCnt++;
}
}
// und nun zu den Konnektoren
// Die Objekte der MarkList aCopiedObjects werden auf die MarkList
// aSourceObjectsForCopy abgebildet und so die Objektverbindungen
// hergestellt.
// Aehnliche Implementation an folgenden Stellen:
// void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
// SdrModel* SdrExchangeView::GetMarkedObjModel() const
// BOOL SdrExchangeView::Paste(const SdrModel& rMod,...)
// void SdrEditView::CopyMarkedObj()
if (nCloneErrCnt==0) {
for (nm=0; nm<nMarkAnz; nm++) {
SdrMark* pM=aSourceObjectsForCopy.GetMark(nm);
SdrObject* pO=pM->GetObj();
SdrEdgeObj* pSrcEdge=PTR_CAST(SdrEdgeObj,pO);
if (pSrcEdge!=NULL) {
SdrObject* pSrcNode1=pSrcEdge->GetConnectedNode(TRUE);
SdrObject* pSrcNode2=pSrcEdge->GetConnectedNode(FALSE);
if (pSrcNode1!=NULL && pSrcNode1->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode1=NULL; // Listenuebergreifend
if (pSrcNode2!=NULL && pSrcNode2->GetObjList()!=pSrcEdge->GetObjList()) pSrcNode2=NULL; // ist (noch) nicht
if (pSrcNode1!=NULL || pSrcNode2!=NULL) {
SdrMark* pEdgeMark=aCopiedObjects.GetMark(nm);
BOOL bMitkopiert=pEdgeMark->GetUser()!=0;
SdrObject* pDstEdgeTmp=pEdgeMark->GetObj();
SdrEdgeObj* pDstEdge=PTR_CAST(SdrEdgeObj,pDstEdgeTmp);
if (pDstEdge!=NULL) {
if (pSrcNode1!=NULL) {
ULONG nDstNode1=aSourceObjectsForCopy.FindObject(pSrcNode1);
SdrObject* pDstNode1=NULL;
if (nDstNode1!=CONTAINER_ENTRY_NOTFOUND) {
pDstNode1=aCopiedObjects.GetMark(nDstNode1)->GetObj();
} else if (bMitkopiert) {
pDstNode1=pSrcNode1; // an den SourceNode Connekten wenn Edge mitkopiert
}
if (pDstNode1!=NULL) { // Node war sonst wohl nicht markiert
pDstEdge->ConnectToNode(TRUE,pDstNode1);
}
}
if (pSrcNode2!=NULL) {
ULONG nDstNode2=aSourceObjectsForCopy.FindObject(pSrcNode2);
SdrObject* pDstNode2=NULL;
if (nDstNode2!=CONTAINER_ENTRY_NOTFOUND) {
pDstNode2=aCopiedObjects.GetMark(nDstNode2)->GetObj();
} else if (bMitkopiert) {
pDstNode2=pSrcNode2; // an den SourceNode Connekten wenn Edge mitkopiert
}
if (pDstNode2!=NULL) { // Node war sonst wohl nicht markiert
pDstEdge->ConnectToNode(FALSE,pDstNode2);
}
}
} else {
DBG_ERROR("SdrEditView::CopyMarkedObj(): pDstEdge==NULL!");
}
}
}
}
} else {
#ifdef DBG_UTIL
ByteString aStr("SdrEditView::CopyMarkedObj(): Fehler beim Clonen ");
if(nCloneErrCnt == 1)
{
aStr += "eines Zeichenobjekts.";
}
else
{
aStr += "von ";
aStr += ByteString::CreateFromInt32( nCloneErrCnt );
aStr += " Zeichenobjekten.";
}
aStr += " Objektverbindungen werden nicht mitkopiert.";
DBG_ERROR(aStr.GetBuffer());
#endif
}
MarkListHasChanged();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL SdrEditView::InsertObject(SdrObject* pObj, SdrPageView& rPV, ULONG nOptions)
{
if ((nOptions & SDRINSERT_SETDEFLAYER)!=0) {
SdrLayerID nLayer=rPV.GetPage()->GetLayerAdmin().GetLayerID(aAktLayer,TRUE);
if (nLayer==SDRLAYER_NOTFOUND) nLayer=0;
if (rPV.GetLockedLayers().IsSet(nLayer) || !rPV.GetVisibleLayers().IsSet(nLayer)) {
delete pObj; // Layer gesperrt oder nicht sichtbar
return FALSE;
}
pObj->NbcSetLayer(nLayer);
}
if ((nOptions & SDRINSERT_SETDEFATTR)!=0) {
if (pDefaultStyleSheet!=NULL) pObj->NbcSetStyleSheet(pDefaultStyleSheet,FALSE);
pObj->SetItemSet(aDefaultAttr);
}
if (!pObj->IsInserted()) {
SdrInsertReason aReason(SDRREASON_VIEWCALL);
if ((nOptions & SDRINSERT_NOBROADCAST)!=0) {
rPV.GetObjList()->NbcInsertObject(pObj,CONTAINER_APPEND,&aReason);
} else {
rPV.GetObjList()->InsertObject(pObj,CONTAINER_APPEND,&aReason);
}
}
AddUndo(new SdrUndoNewObj(*pObj));
if ((nOptions & SDRINSERT_DONTMARK)==0) {
if ((nOptions & SDRINSERT_ADDMARK)==0) UnmarkAllObj();
MarkObj(pObj,&rPV);
}
return TRUE;
}
void SdrEditView::ReplaceObject(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, BOOL bMark)
{
SdrObjList* pOL=pOldObj->GetObjList();
AddUndo(new SdrUndoReplaceObj(*pOldObj,*pNewObj));
pOL->ReplaceObject(pNewObj,pOldObj->GetOrdNum());
if (bMark) MarkObj(pNewObj,&rPV);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef WIN
void SdrEditView::BegUndo() // Undo-Klammerung auf
{
pMod->BegUndo();
}
void SdrEditView::BegUndo(const String& rComment) // Undo-Klammerung auf
{
pMod->BegUndo(rComment);
}
void SdrEditView::BegUndo(const String& rComment, const String& rObjDescr,
SdrRepeatFunc eFunc) // Undo-Klammerung auf
{
pMod->BegUndo(rComment,rObjDescr,eFunc);
}
void SdrEditView::BegUndo(SdrUndoGroup* pUndoGrp) // Undo-Klammerung auf
{
pMod->BegUndo(pUndoGrp);
}
void SdrEditView::AddUndo(SdrUndoAction* pUndo) // Action hinzufuegen
{
pMod->AddUndo(pUndo);
}
// nur nach dem 1. BegUndo oder vor dem letzten EndUndo:
void SdrEditView::SetUndoComment(const String& rComment)
{
pMod->SetUndoComment(rComment);
}
void SdrEditView::SetUndoComment(const String& rComment,
const String& rObjDescr)
{
pMod->SetUndoComment(rComment,rObjDescr);
}
#endif