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