svx/source/svdraw/svdpage.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 <memory>
  21 #include <cassert>
  22 #include <set>
  23 #include <unordered_set>
  24
  25 #include <svx/svdpage.hxx>
  26 #include <svx/unoshape.hxx>
  27
  28 #include <o3tl/safeint.hxx>
  29 #include <string.h>
  30
  31 #include <tools/debug.hxx>
  32 #include <comphelper/diagnose_ex.hxx>
  33 #include <comphelper/lok.hxx>
  34
  35 #include <svtools/colorcfg.hxx>
  36 #include <svx/svdetc.hxx>
  37 #include <svx/svdobj.hxx>
  38 #include <svx/svdogrp.hxx>
  39 #include <svx/svdoedge.hxx>
  40 #include <svx/svdoole2.hxx>
  41 #include <svx/svditer.hxx>
  42 #include <svx/svdmodel.hxx>
  43 #include <svx/svdlayer.hxx>
  44 #include <svx/svdpagv.hxx>
  45 #include <svx/svdundo.hxx>
  46 #include <svx/xfillit0.hxx>
  47 #include <svx/fmdpage.hxx>
  48 #include <svx/theme/ThemeColorChanger.hxx>
  49 #include <svx/ColorSets.hxx>
  50
  51 #include <sdr/contact/viewcontactofsdrpage.hxx>
  52 #include <svx/sdr/contact/viewobjectcontact.hxx>
  53 #include <svx/sdr/contact/displayinfo.hxx>
  54 #include <algorithm>
  55 #include <clonelist.hxx>
  56 #include <svl/hint.hxx>
  57 #include <rtl/strbuf.hxx>
  58 #include <libxml/xmlwriter.h>
  59 #include <docmodel/theme/Theme.hxx>
  60
  61 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  62
  63 using namespace ::com::sun::star;
  64
  65 //////////////////////////////////////////////////////////////////////////////
  66
  67 SdrObjList::SdrObjList()
  68 :   mbObjOrdNumsDirty(false),
  69     mbRectsDirty(false),
  70     mbIsNavigationOrderDirty(false)
  71 {
  72 }
  73
  74 void SdrObjList::impClearSdrObjList(bool bBroadcast)
  75 {
  76     SdrModel* pSdrModelFromRemovedSdrObject(nullptr);
  77
  78     while(!maList.empty())
  79     {
  80         // remove last object from list
  81         rtl::Reference<SdrObject> pObj(maList.back());
  82         RemoveObjectFromContainer(maList.size()-1);
  83
  84         // flushViewObjectContacts() is done since SdrObject::Free is not guaranteed
  85         // to delete the object and thus refresh visualisations
  86         pObj->GetViewContact().flushViewObjectContacts();
  87
  88         if(bBroadcast)
  89         {
  90             if(nullptr == pSdrModelFromRemovedSdrObject)
  91             {
  92                 pSdrModelFromRemovedSdrObject = &pObj->getSdrModelFromSdrObject();
  93             }
  94
  95             // sent remove hint (after removal, see RemoveObject())
  96             // TTTT SdrPage not needed, can be accessed using SdrObject
  97             SdrHint aHint(SdrHintKind::ObjectRemoved, *pObj, getSdrPageFromSdrObjList());
  98             pObj->getSdrModelFromSdrObject().Broadcast(aHint);
  99         }
 100         pObj->setParentOfSdrObject(nullptr);
 101     }
 102
 103     if(bBroadcast && nullptr != pSdrModelFromRemovedSdrObject)
 104     {
 105         pSdrModelFromRemovedSdrObject->SetChanged();
 106     }
 107 }
 108
 109 void SdrObjList::ClearSdrObjList()
 110 {
 111     // clear SdrObjects with broadcasting
 112     impClearSdrObjList(true);
 113 }
 114
 115 SdrObjList::~SdrObjList()
 116 {
 117     // Clear SdrObjects without broadcasting.
 118     for (auto& rxObj : maList)
 119         rxObj->setParentOfSdrObject(nullptr);
 120 }
 121
 122 SdrPage* SdrObjList::getSdrPageFromSdrObjList() const
 123 {
 124     // default is no page and returns zero
 125     return nullptr;
 126 }
 127
 128 SdrObject* SdrObjList::getSdrObjectFromSdrObjList() const
 129 {
 130     // default is no SdrObject (SdrObjGroup)
 131     return nullptr;
 132 }
 133
 134 void SdrObjList::CopyObjects(const SdrObjList& rSrcList)
 135 {
 136     CloneList aCloneList;
 137
 138     // clear SdrObjects with broadcasting
 139     ClearSdrObjList();
 140
 141     mbObjOrdNumsDirty = false;
 142     mbRectsDirty = false;
 143 #ifdef DBG_UTIL
 144     size_t nCloneErrCnt(0);
 145 #endif
 146     const size_t nCount(rSrcList.GetObjCount());
 147
 148     if(nullptr == getSdrObjectFromSdrObjList() && nullptr == getSdrPageFromSdrObjList())
 149     {
 150         OSL_ENSURE(false, "SdrObjList which is not part of SdrPage or SdrObject (!)");
 151         return;
 152     }
 153
 154     SdrModel& rTargetSdrModel(nullptr == getSdrObjectFromSdrObjList()
 155         ? getSdrPageFromSdrObjList()->getSdrModelFromSdrPage()
 156         : getSdrObjectFromSdrObjList()->getSdrModelFromSdrObject());
 157
 158     for (size_t no(0); no < nCount; ++no)
 159     {
 160         SdrObject* pSO(rSrcList.GetObj(no));
 161         rtl::Reference<SdrObject> pDO(pSO->CloneSdrObject(rTargetSdrModel));
 162
 163         if(pDO)
 164         {
 165             NbcInsertObject(pDO.get(), SAL_MAX_SIZE);
 166             aCloneList.AddPair(pSO, pDO.get());
 167         }
 168 #ifdef DBG_UTIL
 169         else
 170         {
 171             nCloneErrCnt++;
 172         }
 173 #endif
 174     }
 175
 176     // Wires up the connections
 177     aCloneList.CopyConnections();
 178 #ifdef DBG_UTIL
 179     if (nCloneErrCnt != 0)
 180     {
 181         OStringBuffer aStr("SdrObjList::operator=(): Error when cloning ");
 182
 183         if(nCloneErrCnt == 1)
 184         {
 185             aStr.append("a drawing object.");
 186         }
 187         else
 188         {
 189             aStr.append(OString::number(static_cast<sal_Int32>(nCloneErrCnt))
 190                 + " drawing objects.");
 191         }
 192
 193         OSL_FAIL(aStr.getStr());
 194     }
 195 #endif
 196 }
 197
 198 void SdrObjList::RecalcObjOrdNums()
 199 {
 200     size_t no=0;
 201     for (const rtl::Reference<SdrObject>& pObj : maList)
 202         pObj->SetOrdNum(no++);
 203     mbObjOrdNumsDirty=false;
 204 }
 205
 206 void SdrObjList::RecalcRects()
 207 {
 208     maSdrObjListOutRect=tools::Rectangle();
 209     maSdrObjListSnapRect=maSdrObjListOutRect;
 210     const size_t nCount = GetObjCount();
 211     for (size_t i=0; i<nCount; ++i) {
 212         SdrObject* pObj=GetObj(i);
 213         if (i==0) {
 214             maSdrObjListOutRect=pObj->GetCurrentBoundRect();
 215             maSdrObjListSnapRect=pObj->GetSnapRect();
 216         } else {
 217             maSdrObjListOutRect.Union(pObj->GetCurrentBoundRect());
 218             maSdrObjListSnapRect.Union(pObj->GetSnapRect());
 219         }
 220     }
 221 }
 222
 223 void SdrObjList::SetSdrObjListRectsDirty()
 224 {
 225     mbRectsDirty=true;
 226     SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList());
 227
 228     if(nullptr != pParentSdrObject)
 229     {
 230         pParentSdrObject->SetBoundAndSnapRectsDirty();
 231     }
 232 }
 233
 234 void SdrObjList::impChildInserted(SdrObject const & rChild)
 235 {
 236     sdr::contact::ViewContact* pParent = rChild.GetViewContact().GetParentContact();
 237
 238     if(pParent)
 239     {
 240         pParent->ActionChildInserted(rChild.GetViewContact());
 241     }
 242 }
 243
 244 void SdrObjList::NbcInsertObject(SdrObject* pObj, size_t nPos)
 245 {
 246     DBG_ASSERT(pObj!=nullptr,"SdrObjList::NbcInsertObject(NULL)");
 247     if (pObj==nullptr)
 248         return;
 249
 250     DBG_ASSERT(!pObj->IsInserted(),"The object already has the status Inserted.");
 251     const size_t nCount = GetObjCount();
 252     if (nPos>nCount) nPos=nCount;
 253     InsertObjectIntoContainer(*pObj,nPos);
 254
 255     if (nPos<nCount) mbObjOrdNumsDirty=true;
 256     pObj->SetOrdNum(nPos);
 257     pObj->setParentOfSdrObject(this);
 258
 259     // Inform the parent about change to allow invalidations at
 260     // evtl. existing parent visualisations
 261     impChildInserted(*pObj);
 262
 263     if (!mbRectsDirty) {
 264         mbRectsDirty = true;
 265     }
 266     pObj->InsertedStateChange(); // calls the UserCall (among others)
 267 }
 268
 269 void SdrObjList::InsertObjectThenMakeNameUnique(SdrObject* pObj)
 270 {
 271     std::unordered_set<rtl::OUString> aNameSet;
 272     InsertObjectThenMakeNameUnique(pObj, aNameSet);
 273 }
 274
 275 void SdrObjList::InsertObjectThenMakeNameUnique(SdrObject* pObj, std::unordered_set<OUString>& rNameSet, size_t nPos)
 276 {
 277     InsertObject(pObj, nPos);
 278     if (pObj->GetName().isEmpty())
 279         return;
 280
 281     pObj->MakeNameUnique(rNameSet);
 282     SdrObjList* pSdrObjList = pObj->GetSubList(); // group
 283     if (pSdrObjList)
 284     {
 285         SdrObject* pListObj;
 286         SdrObjListIter aIter(pSdrObjList, SdrIterMode::DeepWithGroups);
 287         while (aIter.IsMore())
 288         {
 289             pListObj = aIter.Next();
 290             pListObj->MakeNameUnique(rNameSet);
 291         }
 292     }
 293 }
 294
 295 void SdrObjList::InsertObject(SdrObject* pObj, size_t nPos)
 296 {
 297     DBG_ASSERT(pObj!=nullptr,"SdrObjList::InsertObject(NULL)");
 298
 299     if(!pObj)
 300         return;
 301
 302     // if anchor is used, reset it before grouping
 303     if(getSdrObjectFromSdrObjList())
 304     {
 305         const Point& rAnchorPos = pObj->GetAnchorPos();
 306         if(rAnchorPos.X() || rAnchorPos.Y())
 307             pObj->NbcSetAnchorPos(Point());
 308     }
 309
 310     // do insert to new group
 311     NbcInsertObject(pObj, nPos);
 312
 313     // In case the object is inserted into a group and doesn't overlap with
 314     // the group's other members, it needs an own repaint.
 315     SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList());
 316
 317     if(pParentSdrObject)
 318     {
 319         // only repaint here
 320         pParentSdrObject->ActionChanged();
 321     }
 322
 323     // TODO: We need a different broadcast here!
 324     // Repaint from object number ... (heads-up: GroupObj)
 325     if(pObj->getSdrPageFromSdrObject() && !pObj->getSdrModelFromSdrObject().isLocked())
 326     {
 327         SdrHint aHint(SdrHintKind::ObjectInserted, *pObj);
 328         pObj->getSdrModelFromSdrObject().Broadcast(aHint);
 329     }
 330
 331     pObj->getSdrModelFromSdrObject().SetChanged();
 332 }
 333
 334 rtl::Reference<SdrObject> SdrObjList::NbcRemoveObject(size_t nObjNum)
 335 {
 336     if (nObjNum >= maList.size())
 337     {
 338         OSL_ASSERT(nObjNum<maList.size());
 339         return nullptr;
 340     }
 341
 342     const size_t nCount = GetObjCount();
 343     rtl::Reference<SdrObject> pObj=maList[nObjNum];
 344     RemoveObjectFromContainer(nObjNum);
 345
 346     DBG_ASSERT(pObj!=nullptr,"Could not find object to remove.");
 347     if (pObj!=nullptr)
 348     {
 349         // flushViewObjectContacts() clears the VOC's and those invalidate
 350         pObj->GetViewContact().flushViewObjectContacts();
 351
 352         DBG_ASSERT(pObj->IsInserted(),"The object does not have the status Inserted.");
 353
 354         // tdf#121022 Do first remove from SdrObjList - InsertedStateChange
 355         // relies now on IsInserted which uses getParentSdrObjListFromSdrObject
 356         pObj->setParentOfSdrObject(nullptr);
 357
 358         // calls UserCall, among other
 359         pObj->InsertedStateChange();
 360
 361         if (!mbObjOrdNumsDirty)
 362         {
 363             // optimizing for the case that the last object has to be removed
 364             if (nObjNum+1!=nCount) {
 365                 mbObjOrdNumsDirty=true;
 366             }
 367         }
 368         SetSdrObjListRectsDirty();
 369     }
 370     return pObj;
 371 }
 372
 373 rtl::Reference<SdrObject> SdrObjList::RemoveObject(size_t nObjNum)
 374 {
 375     if (nObjNum >= maList.size())
 376     {
 377         OSL_ASSERT(nObjNum<maList.size());
 378         return nullptr;
 379     }
 380
 381     const size_t nCount = GetObjCount();
 382     rtl::Reference<SdrObject> pObj=maList[nObjNum];
 383     RemoveObjectFromContainer(nObjNum);
 384
 385     DBG_ASSERT(pObj!=nullptr,"Object to remove not found.");
 386     if(pObj)
 387     {
 388         // flushViewObjectContacts() clears the VOC's and those invalidate
 389         pObj->GetViewContact().flushViewObjectContacts();
 390         DBG_ASSERT(pObj->IsInserted(),"The object does not have the status Inserted.");
 391
 392         // TODO: We need a different broadcast here.
 393         if (pObj->getSdrPageFromSdrObject()!=nullptr)
 394         {
 395             SdrHint aHint(SdrHintKind::ObjectRemoved, *pObj);
 396             pObj->getSdrModelFromSdrObject().Broadcast(aHint);
 397         }
 398
 399         pObj->getSdrModelFromSdrObject().SetChanged();
 400
 401         // tdf#121022 Do first remove from SdrObjList - InsertedStateChange
 402         // relies now on IsInserted which uses getParentSdrObjListFromSdrObject
 403         pObj->setParentOfSdrObject(nullptr);
 404
 405         // calls, among other things, the UserCall
 406         pObj->InsertedStateChange();
 407
 408         if (!mbObjOrdNumsDirty)
 409         {
 410             // optimization for the case that the last object is removed
 411             if (nObjNum+1!=nCount) {
 412                 mbObjOrdNumsDirty=true;
 413             }
 414         }
 415
 416         SetSdrObjListRectsDirty();
 417         SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList());
 418
 419         if(pParentSdrObject && !GetObjCount())
 420         {
 421             // empty group created; it needs to be repainted since it's
 422             // visualization changes
 423             pParentSdrObject->ActionChanged();
 424         }
 425     }
 426     return pObj;
 427 }
 428
 429 rtl::Reference<SdrObject> SdrObjList::ReplaceObject(SdrObject* pNewObj, size_t nObjNum)
 430 {
 431     if (nObjNum >= maList.size())
 432     {
 433         OSL_ASSERT(nObjNum<maList.size());
 434         return nullptr;
 435     }
 436     if (pNewObj == nullptr)
 437     {
 438         OSL_ASSERT(pNewObj!=nullptr);
 439         return nullptr;
 440     }
 441
 442     rtl::Reference<SdrObject> pObj=maList[nObjNum];
 443     DBG_ASSERT(pObj!=nullptr,"SdrObjList::ReplaceObject: Could not find object to remove.");
 444     if (pObj!=nullptr) {
 445         DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: the object does not have status Inserted.");
 446
 447         // TODO: We need a different broadcast here.
 448         if (pObj->getSdrPageFromSdrObject()!=nullptr)
 449         {
 450             SdrHint aHint(SdrHintKind::ObjectRemoved, *pObj);
 451             pObj->getSdrModelFromSdrObject().Broadcast(aHint);
 452         }
 453
 454         // Change parent and replace in SdrObjList
 455         pObj->setParentOfSdrObject(nullptr);
 456         ReplaceObjectInContainer(*pNewObj,nObjNum);
 457
 458         // tdf#121022 InsertedStateChange uses the parent
 459         // to detect if pObj is inserted or not, so have to call
 460         // it *after* changing these settings, else an obviously wrong
 461         // 'SdrUserCallType::Inserted' would be sent
 462         pObj->InsertedStateChange();
 463
 464         // flushViewObjectContacts() clears the VOC's and those
 465         // trigger the evtl. needed invalidate(s)
 466         pObj->GetViewContact().flushViewObjectContacts();
 467
 468         // Setup data at new SdrObject - it already *is* inserted to
 469         // the SdrObjList due to 'ReplaceObjectInContainer' above
 470         pNewObj->SetOrdNum(nObjNum);
 471         pNewObj->setParentOfSdrObject(this);
 472
 473         // Inform the parent about change to allow invalidations at
 474         // evtl. existing parent visualisations, but also react on
 475         // newly inserted SdrObjects (as e.g. GraphCtrlUserCall does)
 476         impChildInserted(*pNewObj);
 477
 478         pNewObj->InsertedStateChange();
 479
 480         // TODO: We need a different broadcast here.
 481         if (pNewObj->getSdrPageFromSdrObject()!=nullptr) {
 482             SdrHint aHint(SdrHintKind::ObjectInserted, *pNewObj);
 483             pNewObj->getSdrModelFromSdrObject().Broadcast(aHint);
 484         }
 485
 486         pNewObj->getSdrModelFromSdrObject().SetChanged();
 487
 488         SetSdrObjListRectsDirty();
 489     }
 490     return pObj;
 491 }
 492
 493 SdrObject* SdrObjList::SetObjectOrdNum(size_t nOldObjNum, size_t nNewObjNum)
 494 {
 495     if (nOldObjNum >= maList.size() || nNewObjNum >= maList.size())
 496     {
 497         OSL_ASSERT(nOldObjNum<maList.size());
 498         OSL_ASSERT(nNewObjNum<maList.size());
 499         return nullptr;
 500     }
 501
 502     rtl::Reference<SdrObject> pObj=maList[nOldObjNum];
 503     if (nOldObjNum==nNewObjNum) return pObj.get();
 504     DBG_ASSERT(pObj!=nullptr,"SdrObjList::SetObjectOrdNum: Object not found.");
 505     if (pObj!=nullptr) {
 506         DBG_ASSERT(pObj->IsInserted(),"SdrObjList::SetObjectOrdNum: the object does not have status Inserted.");
 507         RemoveObjectFromContainer(nOldObjNum);
 508         InsertObjectIntoContainer(*pObj,nNewObjNum);
 509
 510         // No need to delete visualisation data since same object
 511         // gets inserted again. Also a single ActionChanged is enough
 512         pObj->ActionChanged();
 513
 514         pObj->SetOrdNum(nNewObjNum);
 515         mbObjOrdNumsDirty=true;
 516
 517         // TODO: We need a different broadcast here.
 518         if (pObj->getSdrPageFromSdrObject()!=nullptr)
 519             pObj->getSdrModelFromSdrObject().Broadcast(SdrHint(SdrHintKind::ObjectChange, *pObj));
 520         pObj->getSdrModelFromSdrObject().SetChanged();
 521     }
 522     return pObj.get();
 523 }
 524
 525 void SdrObjList::SetExistingObjectOrdNum(SdrObject* pObj, size_t nNewObjNum)
 526 {
 527     assert(std::find(maList.begin(), maList.end(), pObj) != maList.end() && "This method requires that the child object already be inserted");
 528     assert(pObj->IsInserted() && "SdrObjList::SetObjectOrdNum: the object does not have status Inserted.");
 529
 530     // I am deliberately bypassing getOrdNum() because I don't want to unnecessarily
 531     // trigger RecalcObjOrdNums()
 532     const sal_uInt32 nOldOrdNum = pObj->m_nOrdNum;
 533     if (!mbObjOrdNumsDirty && nOldOrdNum == nNewObjNum)
 534        return;
 535
 536     // Update the navigation positions.
 537     if (HasObjectNavigationOrder())
 538     {
 539         unotools::WeakReference<SdrObject> aReference (pObj);
 540         auto iObject = ::std::find(
 541             mxNavigationOrder->begin(),
 542             mxNavigationOrder->end(),
 543             aReference);
 544         mxNavigationOrder->erase(iObject);
 545         mbIsNavigationOrderDirty = true;
 546         // The new object does not have a user defined position so append it
 547         // to the list.
 548         pObj->SetNavigationPosition(mxNavigationOrder->size());
 549         mxNavigationOrder->push_back(pObj);
 550     }
 551     if (nOldOrdNum < maList.size() && maList[nOldOrdNum] == pObj)
 552         maList.erase(maList.begin()+nOldOrdNum);
 553     else
 554     {
 555         auto it = std::find(maList.begin(), maList.end(), pObj);
 556         maList.erase(it);
 557     }
 558     // Insert object into object list.  Because the insert() method requires
 559     // a valid iterator as insertion position, we have to use push_back() to
 560     // insert at the end of the list.
 561     if (nNewObjNum >= maList.size())
 562         maList.push_back(pObj);
 563     else
 564         maList.insert(maList.begin()+nNewObjNum, pObj);
 565
 566     mbObjOrdNumsDirty=true;
 567
 568     // No need to delete visualisation data since same object
 569     // gets inserted again. Also a single ActionChanged is enough
 570     pObj->ActionChanged();
 571
 572     pObj->SetOrdNum(nNewObjNum);
 573     mbObjOrdNumsDirty=true;
 574
 575     // TODO: We need a different broadcast here.
 576     if (pObj->getSdrPageFromSdrObject()!=nullptr)
 577         pObj->getSdrModelFromSdrObject().Broadcast(SdrHint(SdrHintKind::ObjectChange, *pObj));
 578     pObj->getSdrModelFromSdrObject().SetChanged();
 579 }
 580
 581 void SdrObjList::sort( std::vector<sal_Int32>& sortOrder)
 582 {
 583     // no negative indexes and indexes larger than maList size are allowed
 584     auto it = std::find_if( sortOrder.begin(), sortOrder.end(), [this](const sal_Int32& rIt)
 585          { return ( rIt < 0 || o3tl::make_unsigned(rIt) >= maList.size() ); } );
 586     if ( it != sortOrder.end())
 587         throw css::lang::IllegalArgumentException("negative index of shape", nullptr, 1);
 588
 589     // no duplicates
 590     std::vector<bool> aNoDuplicates(sortOrder.size(), false);
 591     for (size_t i = 0; i < sortOrder.size(); ++i )
 592     {
 593         size_t idx =  static_cast<size_t>( sortOrder[i] );
 594
 595         if ( aNoDuplicates[idx] )
 596             throw css::lang::IllegalArgumentException("duplicate index of shape", nullptr, 2);
 597
 598         aNoDuplicates[idx] = true;
 599     }
 600
 601     // example sortOrder [2 0 1]
 602     // example maList [T T S T T] ( T T = shape with textbox, S = just a shape )
 603     // (shapes at positions 0 and 2 have a textbox)
 604
 605     std::deque<rtl::Reference<SdrObject>> aNewList(maList.size());
 606     std::set<sal_Int32> aShapesWithTextbox;
 607     std::vector<sal_Int32> aIncrements;
 608     std::vector<sal_Int32> aDuplicates;
 609
 610     if ( maList.size() > 1)
 611     {
 612         for (size_t i = 1; i< maList.size(); ++i)
 613         {
 614             // if this shape is a textbox, then look at its left neighbour
 615             // (shape this textbox is in)
 616             // and insert the number of textboxes to the left of it
 617             if (maList[i]->IsTextBox())
 618               aShapesWithTextbox.insert( i - 1 - aShapesWithTextbox.size() );
 619         }
 620         // example aShapesWithTextbox [0 2]
 621     }
 622
 623     if (aShapesWithTextbox.size() != maList.size() - sortOrder.size())
 624     {
 625         throw lang::IllegalArgumentException("mismatch of no. of shapes", nullptr, 0);
 626     }
 627
 628     for (size_t i = 0; i< sortOrder.size(); ++i)
 629     {
 630
 631          if (aShapesWithTextbox.count(sortOrder[i]) > 0)
 632              aDuplicates.push_back(sortOrder[i]);
 633
 634          aDuplicates.push_back(sortOrder[i]);
 635
 636          // example aDuplicates [2 2 0 0 1]
 637     }
 638     assert(aDuplicates.size() == maList.size());
 639
 640     aIncrements.push_back(0);
 641     for (size_t i = 1; i< sortOrder.size(); ++i)
 642     {
 643          if (aShapesWithTextbox.count(i - 1))
 644              aIncrements.push_back(aIncrements[i-1] + 1 );
 645          else
 646              aIncrements.push_back(aIncrements[i-1]);
 647
 648          // example aIncrements [0 1 1]
 649     }
 650     assert(aIncrements.size() == sortOrder.size());
 651
 652     std::vector<sal_Int32> aNewSortOrder(maList.size());
 653     sal_Int32 nPrev = -1;
 654     for (size_t i = 0; i< aDuplicates.size(); ++i)
 655     {
 656         if (nPrev != aDuplicates[i])
 657             aNewSortOrder[i] = aDuplicates[i] + aIncrements[aDuplicates[i]];
 658         else
 659             aNewSortOrder[i] = aNewSortOrder[i-1] + 1;
 660
 661         nPrev = aDuplicates[i];
 662
 663         // example aNewSortOrder [3 4 0 1 2]
 664     }
 665     assert(aNewSortOrder.size() == maList.size());
 666
 667 #ifndef NDEBUG
 668     {
 669         std::vector<sal_Int32> tmp(aNewSortOrder);
 670         std::sort(tmp.begin(), tmp.end());
 671         for (size_t i = 0; i < tmp.size(); ++i)
 672         {
 673             assert(size_t(tmp[i]) == i);
 674         }
 675     }
 676 #endif
 677
 678     SdrModel & rModel(getSdrPageFromSdrObjList()->getSdrModelFromSdrPage());
 679     bool const isUndo(rModel.IsUndoEnabled());
 680     if (isUndo)
 681     {
 682         rModel.AddUndo(SdrUndoFactory::CreateUndoSort(*getSdrPageFromSdrObjList(), sortOrder));
 683     }
 684
 685     for (size_t i = 0; i < aNewSortOrder.size(); ++i)
 686     {
 687         aNewList[i] = maList[ aNewSortOrder[i] ];
 688         aNewList[i]->SetOrdNum(i);
 689     }
 690
 691     std::swap(aNewList, maList);
 692 }
 693
 694 const tools::Rectangle& SdrObjList::GetAllObjSnapRect() const
 695 {
 696     if (mbRectsDirty) {
 697         const_cast<SdrObjList*>(this)->RecalcRects();
 698         const_cast<SdrObjList*>(this)->mbRectsDirty=false;
 699     }
 700     return maSdrObjListSnapRect;
 701 }
 702
 703 const tools::Rectangle& SdrObjList::GetAllObjBoundRect() const
 704 {
 705     // #i106183# for deep group hierarchies like in chart2, the invalidates
 706     // through the hierarchy are not correct; use a 2nd hint for the needed
 707     // recalculation. Future versions will have no bool flag at all, but
 708     // just maSdrObjListOutRect in empty state to represent an invalid state, thus
 709     // it's a step in the right direction.
 710     if (mbRectsDirty || maSdrObjListOutRect.IsEmpty())
 711     {
 712         const_cast<SdrObjList*>(this)->RecalcRects();
 713         const_cast<SdrObjList*>(this)->mbRectsDirty=false;
 714     }
 715     return maSdrObjListOutRect;
 716 }
 717
 718 void SdrObjList::NbcReformatAllTextObjects()
 719 {
 720     size_t nCount=GetObjCount();
 721     size_t nNum=0;
 722
 723     while (nNum<nCount)
 724     {
 725         SdrObject* pObj = GetObj(nNum);
 726
 727         pObj->NbcReformatText();
 728         nCount=GetObjCount();             // ReformatText may delete an object
 729         nNum++;
 730     }
 731
 732 }
 733
 734 void SdrObjList::ReformatAllTextObjects()
 735 {
 736     NbcReformatAllTextObjects();
 737 }
 738
 739 /** steps over all available objects and reformats all
 740     edge objects that are connected to other objects so that
 741     they may reposition themselves.
 742 */
 743 void SdrObjList::ReformatAllEdgeObjects()
 744 {
 745     ImplReformatAllEdgeObjects(*this);
 746 }
 747
 748 void SdrObjList::ImplReformatAllEdgeObjects(const SdrObjList& rObjList)
 749 {
 750     // #i120437# go over whole hierarchy, not only over object level null (seen from grouping)
 751     for(size_t nIdx(0), nCount(rObjList.GetObjCount()); nIdx < nCount; ++nIdx)
 752     {
 753         SdrObject* pSdrObject(rObjList.GetObjectForNavigationPosition(nIdx));
 754         const SdrObjList* pChildren(pSdrObject->getChildrenOfSdrObject());
 755         const bool bIsGroup(nullptr != pChildren);
 756         if(!bIsGroup)
 757         {
 758             // Check IsVirtualObj because sometimes we get SwDrawVirtObj here
 759             if (pSdrObject->GetObjIdentifier() == SdrObjKind::Edge
 760                && !pSdrObject->IsVirtualObj())
 761             {
 762                 SdrEdgeObj* pSdrEdgeObj = static_cast< SdrEdgeObj* >(pSdrObject);
 763                 pSdrEdgeObj->Reformat();
 764             }
 765         }
 766         else
 767         {
 768             ImplReformatAllEdgeObjects(*pChildren);
 769         }
 770     }
 771 }
 772
 773 void SdrObjList::BurnInStyleSheetAttributes()
 774 {
 775     for(size_t a = 0; a < GetObjCount(); ++a)
 776     {
 777         GetObj(a)->BurnInStyleSheetAttributes();
 778     }
 779 }
 780
 781 size_t SdrObjList::GetObjCount() const
 782 {
 783     return maList.size();
 784 }
 785
 786
 787 SdrObject* SdrObjList::GetObj(size_t nNum) const
 788 {
 789     if (nNum < maList.size())
 790         return maList[nNum].get();
 791
 792     return nullptr;
 793 }
 794
 795 SdrObject* SdrObjList::GetObjByName(std::u16string_view sName) const
 796 {
 797     for (size_t i = 0; i < GetObjCount(); ++i)
 798     {
 799         SdrObject* pObj = GetObj(i);
 800         if (pObj->GetName() == sName)
 801             return pObj;
 802     }
 803     return nullptr;
 804 }
 805
 806
 807 bool SdrObjList::IsReadOnly() const
 808 {
 809     bool bRet(false);
 810     SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList());
 811
 812     if(nullptr != pParentSdrObject)
 813     {
 814         SdrPage* pSdrPage(pParentSdrObject->getSdrPageFromSdrObject());
 815
 816         if(nullptr != pSdrPage)
 817         {
 818             bRet = pSdrPage->IsReadOnly();
 819         }
 820     }
 821
 822     return bRet;
 823 }
 824
 825 void SdrObjList::FlattenGroups()
 826 {
 827     const size_t nObj = GetObjCount();
 828     for( size_t i = nObj; i>0; )
 829         UnGroupObj(--i);
 830 }
 831
 832 void SdrObjList::UnGroupObj( size_t nObjNum )
 833 {
 834     // if the given object is no group, this method is a noop
 835     SdrObject* pUngroupObj = GetObj( nObjNum );
 836     if( pUngroupObj )
 837     {
 838         SdrObjList* pSrcLst = pUngroupObj->GetSubList();
 839         if(pSrcLst)
 840             if(auto pUngroupGroup = dynamic_cast<SdrObjGroup*>( pUngroupObj))
 841             {
 842                 // ungroup recursively (has to be head recursion,
 843                 // otherwise our indices will get trashed when doing it in
 844                 // the loop)
 845                 pSrcLst->FlattenGroups();
 846
 847                 // the position at which we insert the members of rUngroupGroup
 848                 size_t nInsertPos( pUngroupGroup->GetOrdNum() );
 849
 850                 const size_t nCount = pSrcLst->GetObjCount();
 851                 for( size_t i=0; i<nCount; ++i )
 852                 {
 853                     rtl::Reference<SdrObject> pObj = pSrcLst->RemoveObject(0);
 854                     InsertObject(pObj.get(), nInsertPos);
 855                     ++nInsertPos;
 856                 }
 857
 858                 RemoveObject(nInsertPos);
 859             }
 860     }
 861 #ifdef DBG_UTIL
 862     else
 863         OSL_FAIL("SdrObjList::UnGroupObj: object index invalid");
 864 #endif
 865 }
 866
 867 bool SdrObjList::HasObjectNavigationOrder() const { return bool(mxNavigationOrder); }
 868
 869 void SdrObjList::SetObjectNavigationPosition (
 870     SdrObject& rObject,
 871     const sal_uInt32 nNewPosition)
 872 {
 873     // When the navigation order container has not yet been created then
 874     // create one now.  It is initialized with the z-order taken from
 875     // maList.
 876     if (!mxNavigationOrder)
 877     {
 878         mxNavigationOrder.emplace(maList.begin(), maList.end());
 879     }
 880     OSL_ASSERT(bool(mxNavigationOrder));
 881     OSL_ASSERT( mxNavigationOrder->size() == maList.size());
 882
 883     unotools::WeakReference<SdrObject> aReference (&rObject);
 884
 885     // Look up the object whose navigation position is to be changed.
 886     auto iObject = ::std::find(
 887         mxNavigationOrder->begin(),
 888         mxNavigationOrder->end(),
 889         aReference);
 890     if (iObject == mxNavigationOrder->end())
 891     {
 892         // The given object is not a member of the navigation order.
 893         return;
 894     }
 895
 896     // Move the object to its new position.
 897     const sal_uInt32 nOldPosition = ::std::distance(mxNavigationOrder->begin(), iObject);
 898     if (nOldPosition == nNewPosition)
 899         return;
 900
 901     mxNavigationOrder->erase(iObject);
 902     sal_uInt32 nInsertPosition (nNewPosition);
 903     // Adapt insertion position for the just erased object.
 904     if (nNewPosition >= nOldPosition)
 905         nInsertPosition -= 1;
 906     if (nInsertPosition >= mxNavigationOrder->size())
 907         mxNavigationOrder->push_back(aReference);
 908     else
 909         mxNavigationOrder->insert(mxNavigationOrder->begin()+nInsertPosition, aReference);
 910
 911     mbIsNavigationOrderDirty = true;
 912
 913     // The navigation order is written out to file so mark the model as modified.
 914     rObject.getSdrModelFromSdrObject().SetChanged();
 915 }
 916
 917
 918 SdrObject* SdrObjList::GetObjectForNavigationPosition (const sal_uInt32 nNavigationPosition) const
 919 {
 920     if (HasObjectNavigationOrder())
 921     {
 922         // There is a user defined navigation order. Make sure the object
 923         // index is correct and look up the object in mxNavigationOrder.
 924         if (nNavigationPosition >= mxNavigationOrder->size())
 925         {
 926             OSL_ASSERT(nNavigationPosition < mxNavigationOrder->size());
 927         }
 928         else
 929             return (*mxNavigationOrder)[nNavigationPosition].get().get();
 930     }
 931     else
 932     {
 933         // There is no user defined navigation order. Use the z-order
 934         // instead.
 935         if (nNavigationPosition >= maList.size())
 936         {
 937             OSL_ASSERT(nNavigationPosition < maList.size());
 938         }
 939         else
 940             return maList[nNavigationPosition].get();
 941     }
 942     return nullptr;
 943 }
 944
 945
 946 void SdrObjList::ClearObjectNavigationOrder()
 947 {
 948     mxNavigationOrder.reset();
 949     mbIsNavigationOrderDirty = true;
 950 }
 951
 952
 953 bool SdrObjList::RecalcNavigationPositions()
 954 {
 955     if (mbIsNavigationOrderDirty)
 956     {
 957         if (mxNavigationOrder)
 958         {
 959             mbIsNavigationOrderDirty = false;
 960
 961             sal_uInt32 nIndex (0);
 962             for (auto& rpObject : *mxNavigationOrder)
 963             {
 964                 rpObject.get()->SetNavigationPosition(nIndex);
 965                 ++nIndex;
 966             }
 967         }
 968     }
 969
 970     return bool(mxNavigationOrder);
 971 }
 972
 973
 974 void SdrObjList::SetNavigationOrder (const uno::Reference<container::XIndexAccess>& rxOrder)
 975 {
 976     if (rxOrder.is())
 977     {
 978         const sal_Int32 nCount = rxOrder->getCount();
 979         if (static_cast<sal_uInt32>(nCount) != maList.size())
 980             return;
 981
 982         if (!mxNavigationOrder)
 983             mxNavigationOrder = std::vector<unotools::WeakReference<SdrObject>>(nCount);
 984
 985         for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
 986         {
 987             uno::Reference<uno::XInterface> xShape (rxOrder->getByIndex(nIndex), uno::UNO_QUERY);
 988             SdrObject* pObject = SdrObject::getSdrObjectFromXShape(xShape);
 989             if (pObject == nullptr)
 990                 break;
 991             (*mxNavigationOrder)[nIndex] = pObject;
 992         }
 993
 994         mbIsNavigationOrderDirty = true;
 995     }
 996     else
 997     {
 998         ClearObjectNavigationOrder();
 999     }
1000 }
1001
1002
1003 void SdrObjList::InsertObjectIntoContainer (
1004     SdrObject& rObject,
1005     const sal_uInt32 nInsertPosition)
1006 {
1007     OSL_ASSERT(nInsertPosition<=maList.size());
1008
1009     // Update the navigation positions.
1010     if (HasObjectNavigationOrder())
1011     {
1012         // The new object does not have a user defined position so append it
1013         // to the list.
1014         rObject.SetNavigationPosition(mxNavigationOrder->size());
1015         mxNavigationOrder->push_back(&rObject);
1016     }
1017
1018     // Insert object into object list.  Because the insert() method requires
1019     // a valid iterator as insertion position, we have to use push_back() to
1020     // insert at the end of the list.
1021     if (nInsertPosition >= maList.size())
1022         maList.push_back(&rObject);
1023     else
1024         maList.insert(maList.begin()+nInsertPosition, &rObject);
1025     mbObjOrdNumsDirty=true;
1026 }
1027
1028
1029 void SdrObjList::ReplaceObjectInContainer (
1030     SdrObject& rNewObject,
1031     const sal_uInt32 nObjectPosition)
1032 {
1033     if (nObjectPosition >= maList.size())
1034     {
1035         OSL_ASSERT(nObjectPosition<maList.size());
1036         return;
1037     }
1038
1039     // Update the navigation positions.
1040     if (HasObjectNavigationOrder())
1041     {
1042         // A user defined position of the object that is to be replaced is
1043         // not transferred to the new object so erase the former and append
1044         // the later object from/to the navigation order.
1045         OSL_ASSERT(nObjectPosition < maList.size());
1046         unotools::WeakReference<SdrObject> aReference (maList[nObjectPosition].get());
1047         auto iObject = ::std::find(
1048             mxNavigationOrder->begin(),
1049             mxNavigationOrder->end(),
1050             aReference);
1051         if (iObject != mxNavigationOrder->end())
1052             mxNavigationOrder->erase(iObject);
1053
1054         mxNavigationOrder->push_back(&rNewObject);
1055
1056         mbIsNavigationOrderDirty = true;
1057     }
1058
1059     maList[nObjectPosition] = &rNewObject;
1060     mbObjOrdNumsDirty=true;
1061 }
1062
1063
1064 void SdrObjList::RemoveObjectFromContainer (
1065     const sal_uInt32 nObjectPosition)
1066 {
1067     if (nObjectPosition >= maList.size())
1068     {
1069         OSL_ASSERT(nObjectPosition<maList.size());
1070         return;
1071     }
1072
1073     // Update the navigation positions.
1074     if (HasObjectNavigationOrder())
1075     {
1076         unotools::WeakReference<SdrObject> aReference (maList[nObjectPosition]);
1077         auto iObject = ::std::find(
1078             mxNavigationOrder->begin(),
1079             mxNavigationOrder->end(),
1080             aReference);
1081         if (iObject != mxNavigationOrder->end())
1082             mxNavigationOrder->erase(iObject);
1083         mbIsNavigationOrderDirty = true;
1084     }
1085
1086     maList.erase(maList.begin()+nObjectPosition);
1087     mbObjOrdNumsDirty=true;
1088 }
1089
1090 void SdrObjList::dumpAsXml(xmlTextWriterPtr pWriter) const
1091 {
1092     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjList"));
1093     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
1094     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name()));
1095
1096     size_t nObjCount = GetObjCount();
1097     for (size_t i = 0; i < nObjCount; ++i)
1098     {
1099         if (const SdrObject* pObject = GetObj(i))
1100             pObject->dumpAsXml(pWriter);
1101     }
1102
1103     (void)xmlTextWriterEndElement(pWriter);
1104 }
1105
1106
1107 void SdrPageGridFrameList::Clear()
1108 {
1109     sal_uInt16 nCount=GetCount();
1110     for (sal_uInt16 i=0; i<nCount; i++) {
1111         delete GetObject(i);
1112     }
1113     aList.clear();
1114 }
1115
1116
1117 // PageUser section
1118
1119 void SdrPage::AddPageUser(sdr::PageUser& rNewUser)
1120 {
1121     maPageUsers.push_back(&rNewUser);
1122 }
1123
1124 void SdrPage::RemovePageUser(sdr::PageUser& rOldUser)
1125 {
1126     const sdr::PageUserVector::iterator aFindResult = ::std::find(maPageUsers.begin(), maPageUsers.end(), &rOldUser);
1127     if(aFindResult != maPageUsers.end())
1128     {
1129         maPageUsers.erase(aFindResult);
1130     }
1131 }
1132
1133
1134 // DrawContact section
1135
1136 std::unique_ptr<sdr::contact::ViewContact> SdrPage::CreateObjectSpecificViewContact()
1137 {
1138     return std::make_unique<sdr::contact::ViewContactOfSdrPage>(*this);
1139 }
1140
1141 const sdr::contact::ViewContact& SdrPage::GetViewContact() const
1142 {
1143     if (!mpViewContact)
1144         const_cast<SdrPage*>(this)->mpViewContact =
1145             const_cast<SdrPage*>(this)->CreateObjectSpecificViewContact();
1146
1147     return *mpViewContact;
1148 }
1149
1150 sdr::contact::ViewContact& SdrPage::GetViewContact()
1151 {
1152     if (!mpViewContact)
1153         mpViewContact = CreateObjectSpecificViewContact();
1154
1155     return *mpViewContact;
1156 }
1157
1158 void SdrPageProperties::ImpRemoveStyleSheet()
1159 {
1160     if(mpStyleSheet)
1161     {
1162         EndListening(*mpStyleSheet);
1163         maProperties.SetParent(nullptr);
1164         mpStyleSheet = nullptr;
1165     }
1166 }
1167
1168 void SdrPageProperties::ImpAddStyleSheet(SfxStyleSheet& rNewStyleSheet)
1169 {
1170     if(mpStyleSheet != &rNewStyleSheet)
1171     {
1172         ImpRemoveStyleSheet();
1173         mpStyleSheet = &rNewStyleSheet;
1174         StartListening(rNewStyleSheet);
1175         maProperties.SetParent(&rNewStyleSheet.GetItemSet());
1176     }
1177 }
1178
1179 static void ImpPageChange(SdrPage& rSdrPage)
1180 {
1181     rSdrPage.ActionChanged();
1182     rSdrPage.getSdrModelFromSdrPage().SetChanged();
1183     SdrHint aHint(SdrHintKind::PageOrderChange, &rSdrPage);
1184     rSdrPage.getSdrModelFromSdrPage().Broadcast(aHint);
1185 }
1186
1187 SdrPageProperties::SdrPageProperties(SdrPage& rSdrPage)
1188     : mpSdrPage(&rSdrPage)
1189     , mpStyleSheet(nullptr)
1190     , maProperties(
1191         mpSdrPage->getSdrModelFromSdrPage().GetItemPool(),
1192         svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>)
1193 {
1194     if (!rSdrPage.IsMasterPage())
1195     {
1196         maProperties.Put(XFillStyleItem(drawing::FillStyle_NONE));
1197     }
1198
1199     //if (rSdrPage.getSdrModelFromSdrPage().IsWriter() || rSdrPage.IsMasterPage())
1200     {
1201         mpTheme.reset(new model::Theme("Office Theme"));
1202         auto const* pColorSet = svx::ColorSets::get().getColorSet(u"LibreOffice");
1203         if (pColorSet)
1204         {
1205             std::shared_ptr<model::ColorSet> pDefaultColorSet(new model::ColorSet(*pColorSet));
1206             mpTheme->setColorSet(pDefaultColorSet);
1207         }
1208     }
1209 }
1210
1211 SdrPageProperties::~SdrPageProperties()
1212 {
1213     ImpRemoveStyleSheet();
1214 }
1215
1216 void SdrPageProperties::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
1217 {
1218     switch(rHint.GetId())
1219     {
1220         case SfxHintId::DataChanged :
1221             {
1222                 // notify change, broadcast
1223                 ImpPageChange(*mpSdrPage);
1224                 break;
1225             }
1226         case SfxHintId::Dying :
1227             {
1228                 // Style needs to be forgotten
1229                 ImpRemoveStyleSheet();
1230                 break;
1231             }
1232         default: break;
1233     }
1234 }
1235
1236 bool SdrPageProperties::isUsedByModel() const
1237 {
1238     assert(mpSdrPage);
1239     return mpSdrPage->IsInserted();
1240 }
1241
1242
1243 void SdrPageProperties::PutItemSet(const SfxItemSet& rSet)
1244 {
1245     OSL_ENSURE(!mpSdrPage->IsMasterPage(), "Item set at MasterPage Attributes (!)");
1246     maProperties.Put(rSet);
1247     ImpPageChange(*mpSdrPage);
1248 }
1249
1250 void SdrPageProperties::PutItem(const SfxPoolItem& rItem)
1251 {
1252     OSL_ENSURE(!mpSdrPage->IsMasterPage(), "Item set at MasterPage Attributes (!)");
1253     maProperties.Put(rItem);
1254     ImpPageChange(*mpSdrPage);
1255 }
1256
1257 void SdrPageProperties::ClearItem(const sal_uInt16 nWhich)
1258 {
1259     maProperties.ClearItem(nWhich);
1260     ImpPageChange(*mpSdrPage);
1261 }
1262
1263 void SdrPageProperties::SetStyleSheet(SfxStyleSheet* pStyleSheet)
1264 {
1265     if(pStyleSheet)
1266     {
1267         ImpAddStyleSheet(*pStyleSheet);
1268     }
1269     else
1270     {
1271         ImpRemoveStyleSheet();
1272     }
1273
1274     ImpPageChange(*mpSdrPage);
1275 }
1276
1277 void SdrPageProperties::SetTheme(std::shared_ptr<model::Theme> const& pTheme)
1278 {
1279     if (mpTheme == pTheme)
1280         return;
1281
1282     mpTheme = pTheme;
1283
1284     if (mpTheme && mpTheme->getColorSet() && mpSdrPage->IsMasterPage())
1285     {
1286         SdrModel& rModel = mpSdrPage->getSdrModelFromSdrPage();
1287         sal_uInt16 nPageCount = rModel.GetPageCount();
1288         for (sal_uInt16 nPage = 0; nPage < nPageCount; ++nPage)
1289         {
1290             SdrPage* pPage = rModel.GetPage(nPage);
1291             if (!pPage->TRG_HasMasterPage() || &pPage->TRG_GetMasterPage() != mpSdrPage)
1292             {
1293                 continue;
1294             }
1295
1296             svx::ThemeColorChanger aChanger(pPage);
1297             aChanger.apply(mpTheme->getColorSet());
1298         }
1299     }
1300 }
1301
1302 std::shared_ptr<model::Theme> const& SdrPageProperties::GetTheme() const
1303 {
1304     return mpTheme;
1305 }
1306
1307 void SdrPageProperties::dumpAsXml(xmlTextWriterPtr pWriter) const
1308 {
1309     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPageProperties"));
1310     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
1311
1312     if (mpTheme)
1313     {
1314         mpTheme->dumpAsXml(pWriter);
1315     }
1316
1317     (void)xmlTextWriterEndElement(pWriter);
1318 }
1319
1320 SdrPage::SdrPage(SdrModel& rModel, bool bMasterPage)
1321 :   mrSdrModelFromSdrPage(rModel),
1322     mnWidth(10),
1323     mnHeight(10),
1324     mnBorderLeft(0),
1325     mnBorderUpper(0),
1326     mnBorderRight(0),
1327     mnBorderLower(0),
1328     mpLayerAdmin(new SdrLayerAdmin(&rModel.GetLayerAdmin())),
1329     nPageNum(0),
1330     mbMaster(bMasterPage),
1331     mbInserted(false),
1332     mbObjectsNotPersistent(false),
1333     mbPageBorderOnlyLeftRight(false)
1334 {
1335     mpSdrPageProperties.reset(new SdrPageProperties(*this));
1336 }
1337
1338 SdrPage::~SdrPage()
1339 {
1340     if( mxUnoPage.is() ) try
1341     {
1342         uno::Reference< lang::XComponent > xPageComponent( mxUnoPage, uno::UNO_QUERY_THROW );
1343         mxUnoPage.clear();
1344         xPageComponent->dispose();
1345     }
1346     catch( const uno::Exception& )
1347     {
1348         DBG_UNHANDLED_EXCEPTION("svx");
1349     }
1350
1351     // tell all the registered PageUsers that the page is in destruction
1352     // This causes some (all?) PageUsers to remove themselves from the list
1353     // of page users.  Therefore we have to use a copy of the list for the
1354     // iteration.
1355     sdr::PageUserVector aListCopy (maPageUsers.begin(), maPageUsers.end());
1356     for(sdr::PageUser* pPageUser : aListCopy)
1357     {
1358         DBG_ASSERT(pPageUser, "SdrPage::~SdrPage: corrupt PageUser list (!)");
1359         pPageUser->PageInDestruction(*this);
1360     }
1361
1362     // Clear the vector. This means that user do not need to call RemovePageUser()
1363     // when they get called from PageInDestruction().
1364     maPageUsers.clear();
1365
1366     mpLayerAdmin.reset();
1367
1368     TRG_ClearMasterPage();
1369
1370     mpViewContact.reset();
1371     mpSdrPageProperties.reset();
1372 }
1373
1374 void SdrPage::lateInit(const SdrPage& rSrcPage)
1375 {
1376     assert(!mpViewContact);
1377     assert(!mxUnoPage.is());
1378
1379     // copy all the local parameters to make this instance
1380     // a valid copy of source page before copying and inserting
1381     // the contained objects
1382     mbMaster = rSrcPage.mbMaster;
1383     mbPageBorderOnlyLeftRight = rSrcPage.mbPageBorderOnlyLeftRight;
1384     mnWidth = rSrcPage.mnWidth;
1385     mnHeight = rSrcPage.mnHeight;
1386     mnBorderLeft = rSrcPage.mnBorderLeft;
1387     mnBorderUpper = rSrcPage.mnBorderUpper;
1388     mnBorderRight = rSrcPage.mnBorderRight;
1389     mnBorderLower = rSrcPage.mnBorderLower;
1390     mbBackgroundFullSize = rSrcPage.mbBackgroundFullSize;
1391     nPageNum = rSrcPage.nPageNum;
1392
1393     if(rSrcPage.TRG_HasMasterPage())
1394     {
1395         TRG_SetMasterPage(rSrcPage.TRG_GetMasterPage());
1396         TRG_SetMasterPageVisibleLayers(rSrcPage.TRG_GetMasterPageVisibleLayers());
1397     }
1398     else
1399     {
1400         TRG_ClearMasterPage();
1401     }
1402
1403     mbObjectsNotPersistent = rSrcPage.mbObjectsNotPersistent;
1404
1405     {
1406         mpSdrPageProperties.reset(new SdrPageProperties(*this));
1407
1408         if(!IsMasterPage())
1409         {
1410             mpSdrPageProperties->PutItemSet(rSrcPage.getSdrPageProperties().GetItemSet());
1411         }
1412
1413         mpSdrPageProperties->SetStyleSheet(rSrcPage.getSdrPageProperties().GetStyleSheet());
1414     }
1415
1416     // Now copy the contained objects
1417     if(0 != rSrcPage.GetObjCount())
1418     {
1419         CopyObjects(rSrcPage);
1420     }
1421 }
1422
1423 rtl::Reference<SdrPage> SdrPage::CloneSdrPage(SdrModel& rTargetModel) const
1424 {
1425     rtl::Reference<SdrPage> pClonedPage(new SdrPage(rTargetModel));
1426     pClonedPage->lateInit(*this);
1427     return pClonedPage;
1428 }
1429
1430 void SdrPage::SetSize(const Size& aSiz)
1431 {
1432     bool bChanged(false);
1433
1434     if(aSiz.Width() != mnWidth)
1435     {
1436         mnWidth = aSiz.Width();
1437         bChanged = true;
1438     }
1439
1440     if(aSiz.Height() != mnHeight)
1441     {
1442         mnHeight = aSiz.Height();
1443         bChanged = true;
1444     }
1445
1446     if(bChanged)
1447     {
1448         SetChanged();
1449     }
1450 }
1451
1452 Size SdrPage::GetSize() const
1453 {
1454     return Size(mnWidth,mnHeight);
1455 }
1456
1457 tools::Long SdrPage::GetWidth() const
1458 {
1459     return mnWidth;
1460 }
1461
1462 void SdrPage::SetOrientation(Orientation eOri)
1463 {
1464     // square: handle like portrait format
1465     Size aSiz(GetSize());
1466     if (aSiz.Width()!=aSiz.Height()) {
1467         if ((eOri==Orientation::Portrait) == (aSiz.Width()>aSiz.Height())) {
1468             // coverity[swapped_arguments : FALSE] - this is in the correct order
1469             SetSize(Size(aSiz.Height(),aSiz.Width()));
1470         }
1471     }
1472 }
1473
1474 Orientation SdrPage::GetOrientation() const
1475 {
1476     // square: handle like portrait format
1477     Orientation eRet=Orientation::Portrait;
1478     Size aSiz(GetSize());
1479     if (aSiz.Width()>aSiz.Height()) eRet=Orientation::Landscape;
1480     return eRet;
1481 }
1482
1483 tools::Long SdrPage::GetHeight() const
1484 {
1485     return mnHeight;
1486 }
1487
1488 void  SdrPage::SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 nLwr)
1489 {
1490     bool bChanged(false);
1491
1492     if(mnBorderLeft != nLft)
1493     {
1494         mnBorderLeft = nLft;
1495         bChanged = true;
1496     }
1497
1498     if(mnBorderUpper != nUpp)
1499     {
1500         mnBorderUpper = nUpp;
1501         bChanged = true;
1502     }
1503
1504     if(mnBorderRight != nRgt)
1505     {
1506         mnBorderRight = nRgt;
1507         bChanged = true;
1508     }
1509
1510     if(mnBorderLower != nLwr)
1511     {
1512         mnBorderLower =  nLwr;
1513         bChanged = true;
1514     }
1515
1516     if(bChanged)
1517     {
1518         SetChanged();
1519     }
1520 }
1521
1522 void  SdrPage::SetLeftBorder(sal_Int32 nBorder)
1523 {
1524     if(mnBorderLeft != nBorder)
1525     {
1526         mnBorderLeft = nBorder;
1527         SetChanged();
1528     }
1529 }
1530
1531 void  SdrPage::SetUpperBorder(sal_Int32 nBorder)
1532 {
1533     if(mnBorderUpper != nBorder)
1534     {
1535         mnBorderUpper = nBorder;
1536         SetChanged();
1537     }
1538 }
1539
1540 void  SdrPage::SetRightBorder(sal_Int32 nBorder)
1541 {
1542     if(mnBorderRight != nBorder)
1543     {
1544         mnBorderRight=nBorder;
1545         SetChanged();
1546     }
1547 }
1548
1549 void  SdrPage::SetLowerBorder(sal_Int32 nBorder)
1550 {
1551     if(mnBorderLower != nBorder)
1552     {
1553         mnBorderLower=nBorder;
1554         SetChanged();
1555     }
1556 }
1557
1558 sal_Int32 SdrPage::GetLeftBorder() const
1559 {
1560     return mnBorderLeft;
1561 }
1562
1563 sal_Int32 SdrPage::GetUpperBorder() const
1564 {
1565     return mnBorderUpper;
1566 }
1567
1568 sal_Int32 SdrPage::GetRightBorder() const
1569 {
1570     return mnBorderRight;
1571 }
1572
1573 sal_Int32 SdrPage::GetLowerBorder() const
1574 {
1575     return mnBorderLower;
1576 }
1577
1578 void SdrPage::SetBackgroundFullSize(bool const bIn)
1579 {
1580     if (bIn != mbBackgroundFullSize)
1581     {
1582         mbBackgroundFullSize = bIn;
1583         SetChanged();
1584     }
1585 }
1586
1587 bool SdrPage::IsBackgroundFullSize() const
1588 {
1589     return mbBackgroundFullSize;
1590 }
1591
1592 // #i68775# React on PageNum changes (from Model in most cases)
1593 void SdrPage::SetPageNum(sal_uInt16 nNew)
1594 {
1595     if(nNew != nPageNum)
1596     {
1597         // change
1598         nPageNum = nNew;
1599
1600         // notify visualisations, also notifies e.g. buffered MasterPages
1601         ActionChanged();
1602     }
1603 }
1604
1605 sal_uInt16 SdrPage::GetPageNum() const
1606 {
1607     if (!mbInserted)
1608         return 0;
1609
1610     if (mbMaster) {
1611         if (getSdrModelFromSdrPage().IsMPgNumsDirty())
1612             getSdrModelFromSdrPage().RecalcPageNums(true);
1613     } else {
1614         if (getSdrModelFromSdrPage().IsPagNumsDirty())
1615             getSdrModelFromSdrPage().RecalcPageNums(false);
1616     }
1617     return nPageNum;
1618 }
1619
1620 void SdrPage::SetChanged()
1621 {
1622     // For test purposes, use the new ViewContact for change
1623     // notification now.
1624     ActionChanged();
1625     getSdrModelFromSdrPage().SetChanged();
1626 }
1627
1628 SdrPage* SdrPage::getSdrPageFromSdrObjList() const
1629 {
1630     return const_cast< SdrPage* >(this);
1631 }
1632
1633 // MasterPage interface
1634
1635 void SdrPage::TRG_SetMasterPage(SdrPage& rNew)
1636 {
1637     if(mpMasterPageDescriptor && &(mpMasterPageDescriptor->GetUsedPage()) == &rNew)
1638         return;
1639
1640     if(mpMasterPageDescriptor)
1641         TRG_ClearMasterPage();
1642
1643     mpMasterPageDescriptor.reset(new sdr::MasterPageDescriptor(*this, rNew));
1644     GetViewContact().ActionChanged();
1645 }
1646
1647 void SdrPage::TRG_ClearMasterPage()
1648 {
1649     if(mpMasterPageDescriptor)
1650     {
1651         SetChanged();
1652
1653         // the flushViewObjectContacts() will do needed invalidates by deleting the involved VOCs
1654         mpMasterPageDescriptor->GetUsedPage().GetViewContact().flushViewObjectContacts();
1655
1656         mpMasterPageDescriptor.reset();
1657     }
1658 }
1659
1660 SdrPage& SdrPage::TRG_GetMasterPage() const
1661 {
1662     DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_GetMasterPage(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1663     return mpMasterPageDescriptor->GetUsedPage();
1664 }
1665
1666 const SdrLayerIDSet& SdrPage::TRG_GetMasterPageVisibleLayers() const
1667 {
1668     DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_GetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1669     return mpMasterPageDescriptor->GetVisibleLayers();
1670 }
1671
1672 void SdrPage::TRG_SetMasterPageVisibleLayers(const SdrLayerIDSet& rNew)
1673 {
1674     DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_SetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1675     mpMasterPageDescriptor->SetVisibleLayers(rNew);
1676 }
1677
1678 sdr::contact::ViewContact& SdrPage::TRG_GetMasterPageDescriptorViewContact() const
1679 {
1680     DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_GetMasterPageDescriptorViewContact(): No MasterPage available. Use TRG_HasMasterPage() before access (!)");
1681     return mpMasterPageDescriptor->GetViewContact();
1682 }
1683
1684 // used from SdrModel::RemoveMasterPage
1685 void SdrPage::TRG_ImpMasterPageRemoved(const SdrPage& rRemovedPage)
1686 {
1687     if(TRG_HasMasterPage())
1688     {
1689         if(&TRG_GetMasterPage() == &rRemovedPage)
1690         {
1691             TRG_ClearMasterPage();
1692         }
1693     }
1694 }
1695
1696 void SdrPage::MakePageObjectsNamesUnique()
1697 {
1698     std::unordered_set<OUString> aNameSet;
1699     for (size_t no(0); no < GetObjCount(); ++no)
1700     {
1701         SdrObject* pObj(GetObj(no));
1702         if(nullptr != pObj)
1703         {
1704             if (!pObj->GetName().isEmpty())
1705             {
1706                 pObj->MakeNameUnique(aNameSet);
1707                 SdrObjList* pSdrObjList = pObj->GetSubList(); // group
1708                 if (pSdrObjList)
1709                 {
1710                     SdrObject* pListObj;
1711                     SdrObjListIter aIter(pSdrObjList, SdrIterMode::DeepWithGroups);
1712                     while (aIter.IsMore())
1713                     {
1714                         pListObj = aIter.Next();
1715                         pListObj->MakeNameUnique(aNameSet);
1716                     }
1717                 }
1718             }
1719         }
1720     }
1721 }
1722
1723 const SdrPageGridFrameList* SdrPage::GetGridFrameList(const SdrPageView* /*pPV*/, const tools::Rectangle* /*pRect*/) const
1724 {
1725     return nullptr;
1726 }
1727
1728 const SdrLayerAdmin& SdrPage::GetLayerAdmin() const
1729 {
1730     return *mpLayerAdmin;
1731 }
1732
1733 SdrLayerAdmin& SdrPage::GetLayerAdmin()
1734 {
1735     return *mpLayerAdmin;
1736 }
1737
1738 OUString SdrPage::GetLayoutName() const
1739 {
1740     return OUString();
1741 }
1742
1743 void SdrPage::SetInserted( bool bIns )
1744 {
1745     if( mbInserted == bIns )
1746         return;
1747
1748     mbInserted = bIns;
1749
1750     // #i120437# go over whole hierarchy, not only over object level null (seen from grouping)
1751     SdrObjListIter aIter(this, SdrIterMode::DeepNoGroups);
1752
1753     while ( aIter.IsMore() )
1754     {
1755         SdrObject* pObj = aIter.Next();
1756         if ( auto pOleObj = dynamic_cast<SdrOle2Obj* >(pObj) )
1757         {
1758             if( mbInserted )
1759                 pOleObj->Connect();
1760             else
1761                 pOleObj->Disconnect();
1762         }
1763     }
1764 }
1765
1766 void SdrPage::SetUnoPage(uno::Reference<drawing::XDrawPage> const& xNewPage)
1767 {
1768     mxUnoPage = xNewPage;
1769 }
1770
1771 uno::Reference< uno::XInterface > const & SdrPage::getUnoPage()
1772 {
1773     if( !mxUnoPage.is() )
1774     {
1775         // create one
1776         mxUnoPage = createUnoPage();
1777     }
1778
1779     return mxUnoPage;
1780 }
1781
1782 uno::Reference< uno::XInterface > SdrPage::createUnoPage()
1783 {
1784     css::uno::Reference< css::uno::XInterface > xInt =
1785         static_cast<cppu::OWeakObject*>( new SvxFmDrawPage( this ) );
1786     return xInt;
1787 }
1788
1789 SfxStyleSheet* SdrPage::GetTextStyleSheetForObject( SdrObject* pObj ) const
1790 {
1791     return pObj->GetStyleSheet();
1792 }
1793
1794 /** returns an averaged background color of this page */
1795 // #i75566# GetBackgroundColor -> GetPageBackgroundColor and bScreenDisplay hint value
1796 Color SdrPage::GetPageBackgroundColor( SdrPageView const * pView, bool bScreenDisplay ) const
1797 {
1798     Color aColor;
1799
1800     if(bScreenDisplay && (!pView || pView->GetApplicationDocumentColor() == COL_AUTO))
1801     {
1802         svtools::ColorConfig aColorConfig;
1803         aColor = aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor;
1804     }
1805     else
1806     {
1807         aColor = pView->GetApplicationDocumentColor();
1808     }
1809
1810     const SfxItemSet* pBackgroundFill = &getSdrPageProperties().GetItemSet();
1811
1812     if(!IsMasterPage() && TRG_HasMasterPage())
1813     {
1814         if(drawing::FillStyle_NONE == pBackgroundFill->Get(XATTR_FILLSTYLE).GetValue())
1815         {
1816             pBackgroundFill = &TRG_GetMasterPage().getSdrPageProperties().GetItemSet();
1817         }
1818     }
1819
1820     GetDraftFillColor(*pBackgroundFill, aColor);
1821
1822     return aColor;
1823 }
1824
1825 /** *deprecated, use GetBackgroundColor with SdrPageView */
1826 Color SdrPage::GetPageBackgroundColor() const
1827 // #i75566# GetBackgroundColor -> GetPageBackgroundColor
1828 {
1829     return GetPageBackgroundColor( nullptr );
1830 }
1831
1832 /** this method returns true if the object from the ViewObjectContact should
1833     be visible on this page while rendering.
1834     bEdit selects if visibility test is for an editing view or a final render,
1835     like printing.
1836 */
1837 bool SdrPage::checkVisibility(
1838     const sdr::contact::ViewObjectContact& /*rOriginal*/,
1839     const sdr::contact::DisplayInfo& /*rDisplayInfo*/,
1840     bool /*bEdit*/)
1841 {
1842     // this will be handled in the application if needed
1843     return true;
1844 }
1845
1846 void SdrPage::dumpAsXml(xmlTextWriterPtr pWriter) const
1847 {
1848     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPage"));
1849     SdrObjList::dumpAsXml(pWriter);
1850
1851     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("width"));
1852     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%s",
1853                                             BAD_CAST(OString::number(mnWidth).getStr()));
1854     (void)xmlTextWriterEndElement(pWriter);
1855     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("height"));
1856     (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%s",
1857                                             BAD_CAST(OString::number(mnHeight).getStr()));
1858     (void)xmlTextWriterEndElement(pWriter);
1859
1860     if (mpSdrPageProperties)
1861     {
1862         mpSdrPageProperties->dumpAsXml(pWriter);
1863     }
1864
1865     (void)xmlTextWriterEndElement(pWriter);
1866 }
1867
1868 // DrawContact support: Methods for handling Page changes
1869 void SdrPage::ActionChanged()
1870 {
1871     // Do necessary ViewContact actions
1872     GetViewContact().ActionChanged();
1873
1874     // #i48535# also handle MasterPage change
1875     if(TRG_HasMasterPage())
1876     {
1877         TRG_GetMasterPageDescriptorViewContact().ActionChanged();
1878     }
1879 }
1880
1881 SdrPageProperties& SdrPage::getSdrPageProperties()
1882 {
1883     return *mpSdrPageProperties;
1884 }
1885
1886 const SdrPageProperties& SdrPage::getSdrPageProperties() const
1887 {
1888     return *mpSdrPageProperties;
1889 }
1890
1891 const SdrPageProperties* SdrPage::getCorrectSdrPageProperties() const
1892 {
1893     if(mpMasterPageDescriptor)
1894     {
1895         return mpMasterPageDescriptor->getCorrectSdrPageProperties();
1896     }
1897     else
1898     {
1899         return &getSdrPageProperties();
1900     }
1901 }
1902
1903
1904 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */