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