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