svx/source/svdraw/svdedtv.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <vcl/metaact.hxx>
  21 #include <svx/svdedtv.hxx>
  22 #include <svx/svdundo.hxx>
  23 #include <svx/svdograf.hxx>
  24 #include <svx/svdopath.hxx>
  25 #include <svx/svdoole2.hxx>
  26 #include <svx/svdopage.hxx>
  27 #include <svx/svdoedge.hxx>
  28 #include <svx/svdlayer.hxx>
  29 #include <svx/svdpagv.hxx>
  30 #include <svx/svdpage.hxx>
  31 #include <svx/svdpoev.hxx>
  32 #include "svx/svdstr.hrc"
  33 #include "svdglob.hxx"
  34 #include <svx/e3dsceneupdater.hxx>
  35 #include <rtl/strbuf.hxx>
  36 #include <svx/svdview.hxx>
  37 #include <clonelist.hxx>
  38
  39 void SdrEditView::ImpResetPossibilityFlags()
  40 {
  41     bReadOnly               =false;
  42
  43     bGroupPossible          =false;
  44     bUnGroupPossible        =false;
  45     bGrpEnterPossible       =false;
  46     bDeletePossible         =false;
  47     bToTopPossible          =false;
  48     bToBtmPossible          =false;
  49     bReverseOrderPossible   =false;
  50
  51     bImportMtfPossible      =false;
  52     bCombinePossible        =false;
  53     bDismantlePossible      =false;
  54     bCombineNoPolyPolyPossible =false;
  55     bDismantleMakeLinesPossible=false;
  56     bOrthoDesiredOnMarked   =false;
  57
  58     bMoreThanOneNotMovable  =false;
  59     bOneOrMoreMovable       =false;
  60     bMoreThanOneNoMovRot    =false;
  61     bContortionPossible     =false;
  62     bAllPolys               =false;
  63     bOneOrMorePolys         =false;
  64     bMoveAllowed            =false;
  65     bResizeFreeAllowed      =false;
  66     bResizePropAllowed      =false;
  67     bRotateFreeAllowed      =false;
  68     bRotate90Allowed        =false;
  69     bMirrorFreeAllowed      =false;
  70     bMirror45Allowed        =false;
  71     bMirror90Allowed        =false;
  72     bTransparenceAllowed    =false;
  73     bGradientAllowed        =false;
  74     bShearAllowed           =false;
  75     bEdgeRadiusAllowed      =false;
  76     bCanConvToPath          =false;
  77     bCanConvToPoly          =false;
  78     bCanConvToContour       =false;
  79     bCanConvToPathLineToArea=false;
  80     bCanConvToPolyLineToArea=false;
  81     bMoveProtect            =false;
  82     bResizeProtect          =false;
  83 }
  84
  85 void SdrEditView::ImpClearVars()
  86 {
  87     ImpResetPossibilityFlags();
  88     bPossibilitiesDirty=true;   // << Purify didn't like this
  89     bBundleVirtObj=false;
  90 }
  91
  92 SdrEditView::SdrEditView(SdrModel* pModel1, OutputDevice* pOut):
  93     SdrMarkView(pModel1,pOut)
  94 {
  95     ImpClearVars();
  96 }
  97
  98 SdrEditView::~SdrEditView()
  99 {
 100 }
 101
 102
 103
 104 SdrLayer* SdrEditView::InsertNewLayer(const OUString& rName, sal_uInt16 nPos)
 105 {
 106     SdrLayerAdmin& rLA=pMod->GetLayerAdmin();
 107     sal_uInt16 nMax=rLA.GetLayerCount();
 108     if (nPos>nMax) nPos=nMax;
 109     SdrLayer* pNewLayer=rLA.NewLayer(rName,nPos);
 110
 111     if( GetModel()->IsUndoEnabled() )
 112         AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewLayer(nPos,rLA,*pMod));
 113
 114     pMod->SetChanged();
 115     return pNewLayer;
 116 }
 117
 118 #include <svx/svdogrp.hxx>
 119 #include <svx/scene3d.hxx>
 120
 121 bool SdrEditView::ImpDelLayerCheck(SdrObjList* pOL, SdrLayerID nDelID) const
 122 {
 123     bool bDelAll(true);
 124     sal_uInt32 nObjAnz(pOL->GetObjCount());
 125
 126     for(sal_uInt32 nObjNum(nObjAnz); nObjNum > 0 && bDelAll;)
 127     {
 128         nObjNum--;
 129         SdrObject* pObj = pOL->GetObj(nObjNum);
 130         SdrObjList* pSubOL = pObj->GetSubList();
 131
 132         // explicitly test for group objects and 3d scenes
 133         if(pSubOL && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dScene)))
 134         {
 135             if(!ImpDelLayerCheck(pSubOL, nDelID))
 136             {
 137                 bDelAll = false;
 138             }
 139         }
 140         else
 141         {
 142             if(pObj->GetLayer() != nDelID)
 143             {
 144                 bDelAll = false;
 145             }
 146         }
 147     }
 148
 149     return bDelAll;
 150 }
 151
 152 void SdrEditView::ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID)
 153 {
 154     sal_uInt32 nObjAnz(pOL->GetObjCount());
 155     // make sure OrdNums are correct
 156     pOL->GetObj(0)->GetOrdNum();
 157
 158     const bool bUndo = GetModel()->IsUndoEnabled();
 159
 160     for(sal_uInt32 nObjNum(nObjAnz); nObjNum > 0;)
 161     {
 162         nObjNum--;
 163         SdrObject* pObj = pOL->GetObj(nObjNum);
 164         SdrObjList* pSubOL = pObj->GetSubList();
 165
 166
 167         // explicitly test for group objects and 3d scenes
 168         if(pSubOL && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dScene)))
 169         {
 170             if(ImpDelLayerCheck(pSubOL, nDelID))
 171             {
 172                 if( bUndo )
 173                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
 174                 pOL->RemoveObject(nObjNum);
 175
 176                 if( !bUndo )
 177                     SdrObject::Free( pObj );
 178             }
 179             else
 180             {
 181                 ImpDelLayerDelObjs(pSubOL, nDelID);
 182             }
 183         }
 184         else
 185         {
 186             if(pObj->GetLayer() == nDelID)
 187             {
 188                 if( bUndo )
 189                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
 190                 pOL->RemoveObject(nObjNum);
 191                 if( !bUndo )
 192                     SdrObject::Free( pObj );
 193             }
 194         }
 195     }
 196 }
 197
 198 void SdrEditView::DeleteLayer(const OUString& rName)
 199 {
 200     SdrLayerAdmin& rLA = pMod->GetLayerAdmin();
 201     SdrLayer* pLayer = rLA.GetLayer(rName, true);
 202     sal_uInt16 nLayerNum(rLA.GetLayerPos(pLayer));
 203
 204     if(SDRLAYER_NOTFOUND != nLayerNum)
 205     {
 206
 207         SdrLayerID nDelID = pLayer->GetID();
 208
 209         const bool bUndo = IsUndoEnabled();
 210         if( bUndo )
 211             BegUndo(ImpGetResStr(STR_UndoDelLayer));
 212
 213         bool bMaPg(true);
 214
 215         for(sal_uInt16 nPageKind(0); nPageKind < 2; nPageKind++)
 216         {
 217             // MasterPages and DrawPages
 218             sal_uInt16 nPgAnz(bMaPg ? pMod->GetMasterPageCount() : pMod->GetPageCount());
 219
 220             for(sal_uInt16 nPgNum(0); nPgNum < nPgAnz; nPgNum++)
 221             {
 222                 // over all pages
 223                 SdrPage* pPage = (bMaPg) ? pMod->GetMasterPage(nPgNum) : pMod->GetPage(nPgNum);
 224                 sal_uInt32 nObjAnz(pPage->GetObjCount());
 225
 226                 // make sure OrdNums are correct
 227                 if(nObjAnz)
 228                     pPage->GetObj(0)->GetOrdNum();
 229
 230                 for(sal_uInt32 nObjNum(nObjAnz); nObjNum > 0;)
 231                 {
 232                     nObjNum--;
 233                     SdrObject* pObj = pPage->GetObj(nObjNum);
 234                     SdrObjList* pSubOL = pObj->GetSubList();
 235
 236                     // explicitly test for group objects and 3d scenes
 237                     if(pSubOL && (pObj->ISA(SdrObjGroup) || pObj->ISA(E3dScene)))
 238                     {
 239                         if(ImpDelLayerCheck(pSubOL, nDelID))
 240                         {
 241                             if( bUndo )
 242                                 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
 243                             pPage->RemoveObject(nObjNum);
 244                             if( !bUndo )
 245                                 SdrObject::Free(pObj);
 246                         }
 247                         else
 248                         {
 249                             ImpDelLayerDelObjs(pSubOL, nDelID);
 250                         }
 251                     }
 252                     else
 253                     {
 254                         if(pObj->GetLayer() == nDelID)
 255                         {
 256                             if( bUndo )
 257                                 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true));
 258                             pPage->RemoveObject(nObjNum);
 259                             if( !bUndo )
 260                                 SdrObject::Free(pObj);
 261                         }
 262                     }
 263                 }
 264             }
 265             bMaPg = false;
 266         }
 267
 268         if( bUndo )
 269         {
 270             AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteLayer(nLayerNum, rLA, *pMod));
 271             rLA.RemoveLayer(nLayerNum);
 272             EndUndo();
 273         }
 274         else
 275         {
 276             delete rLA.RemoveLayer(nLayerNum);
 277         }
 278
 279         pMod->SetChanged();
 280     }
 281 }
 282
 283
 284
 285 void SdrEditView::EndUndo()
 286 {
 287     // #i13033#
 288     // Comparison changed to 1L since EndUndo() is called later now
 289     // and EndUndo WILL change count to count-1
 290     if(1L == pMod->GetUndoBracketLevel())
 291     {
 292         ImpBroadcastEdgesOfMarkedNodes();
 293     }
 294
 295     // #i13033#
 296     // moved to bottom to still have access to UNDOs inside of
 297     // ImpBroadcastEdgesOfMarkedNodes()
 298     pMod->EndUndo();
 299 }
 300
 301 void SdrEditView::ImpBroadcastEdgesOfMarkedNodes()
 302 {
 303     std::vector<SdrObject*>::const_iterator iterPos;
 304     const std::vector<SdrObject*>& rAllMarkedObjects = GetTransitiveHullOfMarkedObjects();
 305
 306     // #i13033#
 307     // New mechanism to search for necessary disconnections for
 308     // changed connectors inside the transitive hull of all at
 309     // the beginning of UNDO selected objects
 310     for(sal_uInt32 a(0L); a < rAllMarkedObjects.size(); a++)
 311     {
 312         SdrEdgeObj* pEdge = PTR_CAST(SdrEdgeObj, rAllMarkedObjects[a]);
 313
 314         if(pEdge)
 315         {
 316             SdrObject* pObj1 = pEdge->GetConnectedNode(false);
 317             SdrObject* pObj2 = pEdge->GetConnectedNode(true);
 318
 319             if(pObj1 && !pEdge->CheckNodeConnection(false))
 320             {
 321                 iterPos = std::find(rAllMarkedObjects.begin(),rAllMarkedObjects.end(),pObj1);
 322
 323                 if (iterPos == rAllMarkedObjects.end())
 324                 {
 325                     if( IsUndoEnabled() )
 326                         AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pEdge));
 327                     pEdge->DisconnectFromNode(false);
 328                 }
 329             }
 330
 331             if(pObj2 && !pEdge->CheckNodeConnection(true))
 332             {
 333                 iterPos = std::find(rAllMarkedObjects.begin(),rAllMarkedObjects.end(),pObj2);
 334
 335                 if (iterPos == rAllMarkedObjects.end())
 336                 {
 337                     if( IsUndoEnabled() )
 338                         AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pEdge));
 339                     pEdge->DisconnectFromNode(true);
 340                 }
 341             }
 342         }
 343     }
 344
 345     sal_uIntPtr nMarkedEdgeAnz = GetMarkedEdgesOfMarkedNodes().GetMarkCount();
 346     sal_uInt16 i;
 347
 348     for (i=0; i<nMarkedEdgeAnz; i++) {
 349         SdrMark* pEM = GetMarkedEdgesOfMarkedNodes().GetMark(i);
 350         SdrObject* pEdgeTmp=pEM->GetMarkedSdrObj();
 351         SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pEdgeTmp);
 352         if (pEdge!=NULL) {
 353             pEdge->SetEdgeTrackDirty();
 354         }
 355     }
 356 }
 357
 358
 359 // Possibilities
 360
 361
 362 void SdrEditView::MarkListHasChanged()
 363 {
 364     SdrMarkView::MarkListHasChanged();
 365     bPossibilitiesDirty=true;
 366 }
 367
 368 void SdrEditView::ModelHasChanged()
 369 {
 370     SdrMarkView::ModelHasChanged();
 371     bPossibilitiesDirty=true;
 372 }
 373
 374 bool SdrEditView::IsResizeAllowed(bool bProp) const
 375 {
 376     ForcePossibilities();
 377     if (bResizeProtect) return false;
 378     if (bProp) return bResizePropAllowed;
 379     return bResizeFreeAllowed;
 380 }
 381
 382 bool SdrEditView::IsRotateAllowed(bool b90Deg) const
 383 {
 384     ForcePossibilities();
 385     if (bMoveProtect) return false;
 386     if (b90Deg) return bRotate90Allowed;
 387     return bRotateFreeAllowed;
 388 }
 389
 390 bool SdrEditView::IsMirrorAllowed(bool b45Deg, bool b90Deg) const
 391 {
 392     ForcePossibilities();
 393     if (bMoveProtect) return false;
 394     if (b90Deg) return bMirror90Allowed;
 395     if (b45Deg) return bMirror45Allowed;
 396     return bMirrorFreeAllowed && !bMoveProtect;
 397 }
 398
 399 bool SdrEditView::IsTransparenceAllowed() const
 400 {
 401     ForcePossibilities();
 402     return bTransparenceAllowed;
 403 }
 404
 405 bool SdrEditView::IsGradientAllowed() const
 406 {
 407     ForcePossibilities();
 408     return bGradientAllowed;
 409 }
 410
 411 bool SdrEditView::IsShearAllowed() const
 412 {
 413     ForcePossibilities();
 414     if (bResizeProtect) return false;
 415     return bShearAllowed;
 416 }
 417
 418 bool SdrEditView::IsEdgeRadiusAllowed() const
 419 {
 420     ForcePossibilities();
 421     return bEdgeRadiusAllowed;
 422 }
 423
 424 bool SdrEditView::IsCrookAllowed(bool bNoContortion) const
 425 {
 426     // CrookMode missing here (no rotations allowed when shearing ...)
 427     ForcePossibilities();
 428     if (bNoContortion) {
 429         if (!bRotateFreeAllowed) return false;
 430         return !bMoveProtect && bMoveAllowed;
 431     } else {
 432         return !bResizeProtect && bContortionPossible;
 433     }
 434 }
 435
 436 bool SdrEditView::IsDistortAllowed(bool bNoContortion) const
 437 {
 438     ForcePossibilities();
 439     if (bNoContortion) {
 440         return false;
 441     } else {
 442         return !bResizeProtect && bContortionPossible;
 443     }
 444 }
 445
 446 bool SdrEditView::IsCombinePossible(bool bNoPolyPoly) const
 447 {
 448     ForcePossibilities();
 449     if (bNoPolyPoly) return bCombineNoPolyPolyPossible;
 450     else return bCombinePossible;
 451 }
 452
 453 bool SdrEditView::IsDismantlePossible(bool bMakeLines) const
 454 {
 455     ForcePossibilities();
 456     if (bMakeLines) return bDismantleMakeLinesPossible;
 457     else return bDismantlePossible;
 458 }
 459
 460 void SdrEditView::CheckPossibilities()
 461 {
 462     if (bSomeObjChgdFlag) bPossibilitiesDirty=true;
 463
 464     if(bSomeObjChgdFlag)
 465     {
 466         // This call IS necessary to correct the MarkList, in which
 467         // no longer to the model belonging objects still can reside.
 468         // These ones need to be removed.
 469         CheckMarked();
 470     }
 471
 472     if (bPossibilitiesDirty) {
 473         ImpResetPossibilityFlags();
 474         SortMarkedObjects();
 475         sal_uIntPtr nMarkAnz=GetMarkedObjectCount();
 476         if (nMarkAnz!=0) {
 477             bReverseOrderPossible=nMarkAnz>=2;
 478
 479             sal_uIntPtr nMovableCount=0;
 480             bGroupPossible=nMarkAnz>=2;
 481             bCombinePossible=nMarkAnz>=2;
 482             if (nMarkAnz==1) {
 483                 // check bCombinePossible more thoroughly
 484                 // still missing ...
 485                 const SdrObject* pObj=GetMarkedObjectByIndex(0);
 486                 //const SdrPathObj* pPath=PTR_CAST(SdrPathObj,pObj);
 487                 bool bGroup=pObj->GetSubList()!=NULL;
 488                 bool bHasText=pObj->GetOutlinerParaObject()!=NULL;
 489                 if (bGroup || bHasText) {
 490                     bCombinePossible=true;
 491                 }
 492             }
 493             bCombineNoPolyPolyPossible=bCombinePossible;
 494             bDeletePossible=true;
 495             // accept transformations for now
 496             bMoveAllowed      =true;
 497             bResizeFreeAllowed=true;
 498             bResizePropAllowed=true;
 499             bRotateFreeAllowed=true;
 500             bRotate90Allowed  =true;
 501             bMirrorFreeAllowed=true;
 502             bMirror45Allowed  =true;
 503             bMirror90Allowed  =true;
 504             bShearAllowed     =true;
 505             bEdgeRadiusAllowed=false;
 506             bContortionPossible=true;
 507             bCanConvToContour = true;
 508
 509             // these ones are only allowed when single object is selected
 510             bTransparenceAllowed = (nMarkAnz == 1);
 511             bGradientAllowed = (nMarkAnz == 1);
 512             if(bGradientAllowed)
 513             {
 514                 // gradient depends on fill style
 515                 const SdrMark* pM = GetSdrMarkByIndex(0);
 516                 const SdrObject* pObj = pM->GetMarkedSdrObj();
 517
 518                 // may be group object, so get merged ItemSet
 519                 const SfxItemSet& rSet = pObj->GetMergedItemSet();
 520                 SfxItemState eState = rSet.GetItemState(XATTR_FILLSTYLE, false);
 521
 522                 if(SFX_ITEM_DONTCARE != eState)
 523                 {
 524                     // If state is not DONTCARE, test the item
 525                     XFillStyle eFillStyle = ((XFillStyleItem&)(rSet.Get(XATTR_FILLSTYLE))).GetValue();
 526
 527                     if(eFillStyle != XFILL_GRADIENT)
 528                     {
 529                         bGradientAllowed = false;
 530                     }
 531                 }
 532             }
 533
 534             bool bNoMovRotFound=false;
 535             const SdrPageView* pPV0=NULL;
 536
 537             for (sal_uIntPtr nm=0; nm<nMarkAnz; nm++) {
 538                 const SdrMark* pM=GetSdrMarkByIndex(nm);
 539                 const SdrObject* pObj=pM->GetMarkedSdrObj();
 540                 const SdrPageView* pPV=pM->GetPageView();
 541                 if (pPV!=pPV0) {
 542                     if (pPV->IsReadOnly()) bReadOnly=true;
 543                     pPV0=pPV;
 544                 }
 545
 546                 SdrObjTransformInfoRec aInfo;
 547                 pObj->TakeObjInfo(aInfo);
 548                 bool bMovPrt=pObj->IsMoveProtect();
 549                 bool bSizPrt=pObj->IsResizeProtect();
 550                 if (!bMovPrt && aInfo.bMoveAllowed) nMovableCount++; // count MovableObjs
 551                 if (bMovPrt) bMoveProtect=true;
 552                 if (bSizPrt) bResizeProtect=true;
 553
 554                 // not allowed when not allowed at one object
 555                 if(!aInfo.bTransparenceAllowed)
 556                     bTransparenceAllowed = false;
 557
 558                 // If one of these can't do something, none can
 559                 if (!aInfo.bMoveAllowed      ) bMoveAllowed      =false;
 560                 if (!aInfo.bResizeFreeAllowed) bResizeFreeAllowed=false;
 561                 if (!aInfo.bResizePropAllowed) bResizePropAllowed=false;
 562                 if (!aInfo.bRotateFreeAllowed) bRotateFreeAllowed=false;
 563                 if (!aInfo.bRotate90Allowed  ) bRotate90Allowed  =false;
 564                 if (!aInfo.bMirrorFreeAllowed) bMirrorFreeAllowed=false;
 565                 if (!aInfo.bMirror45Allowed  ) bMirror45Allowed  =false;
 566                 if (!aInfo.bMirror90Allowed  ) bMirror90Allowed  =false;
 567                 if (!aInfo.bShearAllowed     ) bShearAllowed     =false;
 568                 if (aInfo.bEdgeRadiusAllowed) bEdgeRadiusAllowed=true;
 569                 if (aInfo.bNoContortion      ) bContortionPossible=false;
 570                 // For Crook with Contortion: all objects have to be
 571                 // Movable and Rotatable, except for a maximum of 1 of them
 572                 if (!bMoreThanOneNoMovRot) {
 573                     if (!aInfo.bMoveAllowed || !aInfo.bResizeFreeAllowed) {
 574                         bMoreThanOneNoMovRot=bNoMovRotFound;
 575                         bNoMovRotFound=true;
 576                     }
 577                 }
 578
 579                 // if one member cannot be converted, no conversion is possible
 580                 if(!aInfo.bCanConvToContour)
 581                     bCanConvToContour = false;
 582
 583                 // Ungroup
 584                 if (!bUnGroupPossible) bUnGroupPossible=pObj->GetSubList()!=NULL;
 585                 // ConvertToCurve: If at least one can be converted, that is fine.
 586                 if (aInfo.bCanConvToPath          ) bCanConvToPath          =true;
 587                 if (aInfo.bCanConvToPoly          ) bCanConvToPoly          =true;
 588                 if (aInfo.bCanConvToPathLineToArea) bCanConvToPathLineToArea=true;
 589                 if (aInfo.bCanConvToPolyLineToArea) bCanConvToPolyLineToArea=true;
 590
 591                 // Combine/Dismantle
 592                 if(bCombinePossible)
 593                 {
 594                     bCombinePossible = ImpCanConvertForCombine(pObj);
 595                     bCombineNoPolyPolyPossible = bCombinePossible;
 596                 }
 597
 598                 if (!bDismantlePossible) bDismantlePossible = ImpCanDismantle(pObj, false);
 599                 if (!bDismantleMakeLinesPossible) bDismantleMakeLinesPossible = ImpCanDismantle(pObj, true);
 600                 // check OrthoDesiredOnMarked
 601                 if (!bOrthoDesiredOnMarked && !aInfo.bNoOrthoDesired) bOrthoDesiredOnMarked=true;
 602                 // check ImportMtf
 603
 604                 if (!bImportMtfPossible)
 605                 {
 606                     const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pObj);
 607                     const SdrOle2Obj* pSdrOle2Obj = dynamic_cast< const SdrOle2Obj* >(pObj);
 608
 609                     if(pSdrGrafObj && ((pSdrGrafObj->HasGDIMetaFile() && !pSdrGrafObj->IsEPS()) || pSdrGrafObj->isEmbeddedSvg()))
 610                     {
 611                         bImportMtfPossible = true;
 612                     }
 613
 614                     if(pSdrOle2Obj)
 615                     {
 616                         bImportMtfPossible = pSdrOle2Obj->GetObjRef().is();
 617                     }
 618                 }
 619             }
 620
 621             bMoreThanOneNotMovable=nMovableCount<nMarkAnz-1;
 622             bOneOrMoreMovable=nMovableCount!=0;
 623             bGrpEnterPossible=bUnGroupPossible;
 624         }
 625         ImpCheckToTopBtmPossible();
 626         ((SdrPolyEditView*)this)->ImpCheckPolyPossibilities();
 627         bPossibilitiesDirty=false;
 628
 629         if (bReadOnly) {
 630             bool bMerker1=bGrpEnterPossible;
 631             ImpResetPossibilityFlags();
 632             bReadOnly=true;
 633             bGrpEnterPossible=bMerker1;
 634         }
 635         if (bMoveAllowed) {
 636             // Don't allow moving glued connectors.
 637             // Currently only implemented for single selection.
 638             if (nMarkAnz==1) {
 639                 SdrObject* pObj=GetMarkedObjectByIndex(0);
 640                 SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pObj);
 641                 if (pEdge!=NULL) {
 642                     SdrObject* pNode1=pEdge->GetConnectedNode(true);
 643                     SdrObject* pNode2=pEdge->GetConnectedNode(false);
 644                     if (pNode1!=NULL || pNode2!=NULL) bMoveAllowed=false;
 645                 }
 646             }
 647         }
 648     }
 649 }
 650
 651
 652
 653 void SdrEditView::ForceMarkedObjToAnotherPage()
 654 {
 655     bool bFlg=false;
 656     for (sal_uIntPtr nm=0; nm<GetMarkedObjectCount(); nm++) {
 657         SdrMark* pM=GetSdrMarkByIndex(nm);
 658         SdrObject* pObj=pM->GetMarkedSdrObj();
 659         Rectangle aObjRect(pObj->GetCurrentBoundRect());
 660         Rectangle aPgRect(pM->GetPageView()->GetPageRect());
 661         if (!aObjRect.IsOver(aPgRect)) {
 662             bool bFnd=false;
 663             SdrPageView* pPV = GetSdrPageView();
 664
 665             if(pPV)
 666             {
 667                 bFnd = aObjRect.IsOver(pPV->GetPageRect());
 668             }
 669
 670             if(bFnd)
 671             {
 672                 pM->GetPageView()->GetObjList()->RemoveObject(pObj->GetOrdNum());
 673                 SdrInsertReason aReason(SDRREASON_VIEWCALL);
 674                 pPV->GetObjList()->InsertObject(pObj,CONTAINER_APPEND,&aReason);
 675                 pM->SetPageView(pPV);
 676                 InvalidateAllWin(aObjRect);
 677                 bFlg=true;
 678             }
 679         }
 680     }
 681     if (bFlg) {
 682         MarkListHasChanged();
 683     }
 684 }
 685
 686 void SdrEditView::DeleteMarkedList(const SdrMarkList& rMark)
 687 {
 688     if (rMark.GetMarkCount()!=0)
 689     {
 690         rMark.ForceSort();
 691
 692         const bool bUndo = IsUndoEnabled();
 693         if( bUndo )
 694             BegUndo();
 695         const sal_uInt32 nMarkAnz(rMark.GetMarkCount());
 696
 697         if(nMarkAnz)
 698         {
 699             sal_uInt32 nm(0);
 700             std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;
 701
 702             if( bUndo )
 703             {
 704                 for(nm = nMarkAnz; nm > 0;)
 705                 {
 706                     nm--;
 707                     SdrMark* pM = rMark.GetMark(nm);
 708                     SdrObject* pObj = pM->GetMarkedSdrObj();
 709
 710                     // extra undo actions for changed connector which now may hold its layed out path (SJ)
 711                     std::vector< SdrUndoAction* > vConnectorUndoActions( CreateConnectorUndo( *pObj ) );
 712                     AddUndoActions( vConnectorUndoActions );
 713
 714                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj));
 715                 }
 716             }
 717
 718             // make sure, OrderNums are correct:
 719             rMark.GetMark(0)->GetMarkedSdrObj()->GetOrdNum();
 720
 721             std::vector< SdrObject* > aRemoved3DObjects;
 722
 723             for(nm = nMarkAnz; nm > 0;)
 724             {
 725                 nm--;
 726                 SdrMark* pM = rMark.GetMark(nm);
 727                 SdrObject* pObj = pM->GetMarkedSdrObj();
 728                 SdrObjList*  pOL = pObj->GetObjList();
 729                 const sal_uInt32 nOrdNum(pObj->GetOrdNumDirect());
 730
 731                 bool bIs3D = dynamic_cast< E3dObject* >(pObj);
 732                 // set up a scene updater if object is a 3d object
 733                 if(bIs3D)
 734                 {
 735                     aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj));
 736                 }
 737
 738                 pOL->RemoveObject(nOrdNum);
 739
 740                 if( !bUndo )
 741                 {
 742                     if( bIs3D )
 743                         aRemoved3DObjects.push_back( pObj ); // may be needed later
 744                     else
 745                         SdrObject::Free(pObj);
 746                 }
 747             }
 748
 749             // fire scene updaters
 750             while(!aUpdaters.empty())
 751             {
 752                 delete aUpdaters.back();
 753                 aUpdaters.pop_back();
 754             }
 755
 756             if( !bUndo )
 757             {
 758                 // now delete removed scene objects
 759                 while(!aRemoved3DObjects.empty())
 760                 {
 761                     SdrObject::Free( aRemoved3DObjects.back() );
 762                     aRemoved3DObjects.pop_back();
 763                 }
 764             }
 765         }
 766
 767         if( bUndo )
 768             EndUndo();
 769     }
 770 }
 771
 772 void SdrEditView::DeleteMarkedObj()
 773 {
 774     // #i110981# return when nothing is to be done at all
 775     if(!GetMarkedObjectCount())
 776     {
 777         return;
 778     }
 779
 780     // moved breaking action and undo start outside loop
 781     BrkAction();
 782     BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedObjects(),SDRREPFUNC_OBJ_DELETE);
 783
 784     // remove as long as something is selected. This allows to schedule objects for
 785     // removal for a next run as needed
 786     while(GetMarkedObjectCount())
 787     {
 788         // vector to remember the parents which may be empty after object removal
 789         std::vector< SdrObject* > aParents;
 790
 791         {
 792             const SdrMarkList& rMarkList = GetMarkedObjectList();
 793             const sal_uInt32 nCount(rMarkList.GetMarkCount());
 794             sal_uInt32 a(0);
 795
 796             for(a = 0; a < nCount; a++)
 797             {
 798                 // in the first run, add all found parents, but only once
 799                 SdrMark* pMark = rMarkList.GetMark(a);
 800                 SdrObject* pObject = pMark->GetMarkedSdrObj();
 801                 SdrObject* pParent = pObject->GetObjList()->GetOwnerObj();
 802
 803                 if(pParent)
 804                 {
 805                     if(!aParents.empty())
 806                     {
 807                         std::vector< SdrObject* >::iterator aFindResult =
 808                             std::find(aParents.begin(), aParents.end(), pParent);
 809
 810                         if(aFindResult == aParents.end())
 811                         {
 812                             aParents.push_back(pParent);
 813                         }
 814                     }
 815                     else
 816                     {
 817                         aParents.push_back(pParent);
 818                     }
 819                 }
 820             }
 821
 822             if(!aParents.empty())
 823             {
 824                 // in a 2nd run, remove all objects which may already be scheduled for
 825                 // removal. I am not sure if this can happen, but theoretically
 826                 // a to-be-removed object may already be the group/3DScene itself
 827                 for(a = 0; a < nCount; a++)
 828                 {
 829                     SdrMark* pMark = rMarkList.GetMark(a);
 830                     SdrObject* pObject = pMark->GetMarkedSdrObj();
 831
 832                     std::vector< SdrObject* >::iterator aFindResult =
 833                         std::find(aParents.begin(), aParents.end(), pObject);
 834
 835                     if(aFindResult != aParents.end())
 836                     {
 837                         aParents.erase(aFindResult);
 838                     }
 839                 }
 840             }
 841         }
 842
 843         // original stuff: remove selected objects. Handle clear will
 844         // do something only once
 845         DeleteMarkedList(GetMarkedObjectList());
 846         GetMarkedObjectListWriteAccess().Clear();
 847         aHdl.Clear();
 848
 849         while(aParents.size() && !GetMarkedObjectCount())
 850         {
 851             // iterate over remembered parents
 852             SdrObject* pParent = aParents.back();
 853             aParents.pop_back();
 854
 855             if(pParent->GetSubList() && 0 == pParent->GetSubList()->GetObjCount())
 856             {
 857                 // we detected an empty parent, a candidate to leave group/3DScene
 858                 // if entered
 859                 if(GetSdrPageView()->GetAktGroup()
 860                     && GetSdrPageView()->GetAktGroup() == pParent)
 861                 {
 862                     GetSdrPageView()->LeaveOneGroup();
 863                 }
 864
 865                 // schedule empty parent for removal
 866                 GetMarkedObjectListWriteAccess().InsertEntry(
 867                     SdrMark(pParent, GetSdrPageView()));
 868             }
 869         }
 870     }
 871
 872     // end undo and change messaging moved at the end
 873     EndUndo();
 874     MarkListHasChanged();
 875 }
 876
 877 void SdrEditView::CopyMarkedObj()
 878 {
 879     SortMarkedObjects();
 880
 881     SdrMarkList aSourceObjectsForCopy(GetMarkedObjectList());
 882     // The following loop is used instead of MarkList::Merge(), to be
 883     // able to flag the MarkEntries.
 884     sal_uIntPtr nEdgeAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 885     for (sal_uIntPtr nEdgeNum=0; nEdgeNum<nEdgeAnz; nEdgeNum++) {
 886         SdrMark aM(*GetEdgesOfMarkedNodes().GetMark(nEdgeNum));
 887         aM.SetUser(1);
 888         aSourceObjectsForCopy.InsertEntry(aM);
 889     }
 890     aSourceObjectsForCopy.ForceSort();
 891
 892     // #i13033#
 893     // New mechanism to re-create the connections of cloned connectors
 894     CloneList aCloneList;
 895
 896     const bool bUndo = IsUndoEnabled();
 897
 898     GetMarkedObjectListWriteAccess().Clear();
 899     sal_uIntPtr nCloneErrCnt=0;
 900     sal_uIntPtr nMarkAnz=aSourceObjectsForCopy.GetMarkCount();
 901     sal_uIntPtr nm;
 902     for (nm=0; nm<nMarkAnz; nm++) {
 903         SdrMark* pM=aSourceObjectsForCopy.GetMark(nm);
 904         SdrObject* pO=pM->GetMarkedSdrObj()->Clone();
 905         if (pO!=NULL) {
 906             SdrInsertReason aReason(SDRREASON_VIEWCALL);
 907             pM->GetPageView()->GetObjList()->InsertObject(pO,CONTAINER_APPEND,&aReason);
 908
 909             if( bUndo )
 910                 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoCopyObject(*pO));
 911
 912             SdrMark aME(*pM);
 913             aME.SetMarkedSdrObj(pO);
 914             aCloneList.AddPair(pM->GetMarkedSdrObj(), pO);
 915
 916             if (pM->GetUser()==0)
 917             {
 918                 // otherwise it is only an Edge we have to copy as well
 919                 GetMarkedObjectListWriteAccess().InsertEntry(aME);
 920             }
 921         } else {
 922             nCloneErrCnt++;
 923         }
 924     }
 925
 926     // #i13033#
 927     // New mechanism to re-create the connections of cloned connectors
 928     aCloneList.CopyConnections();
 929
 930     if(0L != nCloneErrCnt)
 931     {
 932 #ifdef DBG_UTIL
 933         OStringBuffer aStr("SdrEditView::CopyMarkedObj(): Error when cloning ");
 934
 935         if(nCloneErrCnt == 1)
 936         {
 937             aStr.append("a drawing object.");
 938         }
 939         else
 940         {
 941             aStr.append(static_cast<sal_Int32>(nCloneErrCnt));
 942             aStr.append(" drawing objects.");
 943         }
 944
 945         aStr.append(" This object's/These objects's connections will not be copied.");
 946         OSL_FAIL(aStr.getStr());
 947 #endif
 948     }
 949     MarkListHasChanged();
 950 }
 951
 952
 953
 954 bool SdrEditView::InsertObjectAtView(SdrObject* pObj, SdrPageView& rPV, sal_uIntPtr nOptions)
 955 {
 956     if ((nOptions & SDRINSERT_SETDEFLAYER)!=0) {
 957         SdrLayerID nLayer=rPV.GetPage()->GetLayerAdmin().GetLayerID(aAktLayer,true);
 958         if (nLayer==SDRLAYER_NOTFOUND) nLayer=0;
 959         if (rPV.GetLockedLayers().IsSet(nLayer) || !rPV.GetVisibleLayers().IsSet(nLayer)) {
 960             SdrObject::Free( pObj ); // Layer locked or invisible
 961             return false;
 962         }
 963         pObj->NbcSetLayer(nLayer);
 964     }
 965     if ((nOptions & SDRINSERT_SETDEFATTR)!=0) {
 966         if (pDefaultStyleSheet!=NULL) pObj->NbcSetStyleSheet(pDefaultStyleSheet, false);
 967         pObj->SetMergedItemSet(aDefaultAttr);
 968     }
 969     if (!pObj->IsInserted()) {
 970         SdrInsertReason aReason(SDRREASON_VIEWCALL);
 971         if ((nOptions & SDRINSERT_NOBROADCAST)!=0) {
 972             rPV.GetObjList()->NbcInsertObject(pObj,CONTAINER_APPEND,&aReason);
 973         } else {
 974             rPV.GetObjList()->InsertObject(pObj,CONTAINER_APPEND,&aReason);
 975         }
 976     }
 977     if( IsUndoEnabled() )
 978         AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pObj));
 979
 980     if ((nOptions & SDRINSERT_DONTMARK)==0) {
 981         if ((nOptions & SDRINSERT_ADDMARK)==0) UnmarkAllObj();
 982         MarkObj(pObj,&rPV);
 983     }
 984     return true;
 985 }
 986
 987 void SdrEditView::ReplaceObjectAtView(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, bool bMark)
 988 {
 989     if(IsTextEdit())
 990     {
 991 #ifdef DBG_UTIL
 992         if(pOldObj && dynamic_cast< SdrTextObj* >(pOldObj) && static_cast< SdrTextObj* >(pOldObj)->IsTextEditActive())
 993         {
 994             OSL_ENSURE(false, "OldObject is in TextEdit mode, this has to be ended before replacing it usnig SdrEndTextEdit (!)");
 995         }
 996
 997         if(pNewObj && dynamic_cast< SdrTextObj* >(pNewObj) && static_cast< SdrTextObj* >(pNewObj)->IsTextEditActive())
 998         {
 999             OSL_ENSURE(false, "NewObject is in TextEdit mode, this has to be ended before replacing it usnig SdrEndTextEdit (!)");
1000         }
1001 #endif
1002
1003         // #i123468# emergency repair situation, needs to cast up to a class derived from
1004         // this one; (aw080 has a mechanism for that and the view hierarchy is secured to
1005         // always be a SdrView)
1006         SdrView *pSdrView = dynamic_cast<SdrView*>(this);
1007         if (pSdrView)
1008             pSdrView->SdrEndTextEdit();
1009     }
1010
1011     SdrObjList* pOL=pOldObj->GetObjList();
1012     const bool bUndo = IsUndoEnabled();
1013     if( bUndo  )
1014         AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoReplaceObject(*pOldObj,*pNewObj));
1015
1016     if( IsObjMarked( pOldObj ) )
1017         MarkObj( pOldObj, &rPV, true /*unmark!*/ );
1018
1019     pOL->ReplaceObject(pNewObj,pOldObj->GetOrdNum());
1020
1021     if( !bUndo )
1022         SdrObject::Free( pOldObj );
1023
1024     if (bMark) MarkObj(pNewObj,&rPV);
1025 }
1026
1027
1028
1029 bool SdrEditView::IsUndoEnabled() const
1030 {
1031     return pMod->IsUndoEnabled();
1032 }
1033
1034 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */