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