svx/source/svdraw/svdundo.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 <com/sun/star/drawing/FillStyle.hpp>
  21
  22 #include <svl/lstner.hxx>
  23
  24 #include <svx/svdundo.hxx>
  25 #include <svx/svdotext.hxx>
  26 #include <svx/svdobj.hxx>
  27 #include <svx/svdpage.hxx>
  28 #include <svx/svdlayer.hxx>
  29 #include <svx/svdmodel.hxx>
  30 #include <svx/svdview.hxx>
  31 #include <svx/xfillit0.hxx>
  32 #include <svx/strings.hrc>
  33 #include <svdglob.hxx>
  34 #include <svx/scene3d.hxx>
  35 #include <editeng/editdata.hxx>
  36 #include <editeng/outlobj.hxx>
  37 #include <svx/svdogrp.hxx>
  38 #include <sdr/properties/itemsettools.hxx>
  39 #include <svx/sdr/properties/properties.hxx>
  40 #include <svx/svdocapt.hxx>
  41 #include <svl/whiter.hxx>
  42 #include <svx/e3dsceneupdater.hxx>
  43 #include <svx/svdviter.hxx>
  44 #include <svx/svdograf.hxx>
  45 #include <sdr/contact/viewcontactofgraphic.hxx>
  46 #include <svx/svdotable.hxx> // #i124389#
  47 #include <vcl/svapp.hxx>
  48 #include <sfx2/viewsh.hxx>
  49
  50
  51 // iterates over all views and unmarks this SdrObject if it is marked
  52 static void ImplUnmarkObject( SdrObject* pObj )
  53 {
  54     SdrViewIter aIter( pObj );
  55     for ( SdrView* pView = aIter.FirstView(); pView; pView = aIter.NextView() )
  56     {
  57         pView->MarkObj( pObj, pView->GetSdrPageView(), true );
  58     }
  59 }
  60
  61 SdrUndoAction::SdrUndoAction(SdrModel& rNewMod)
  62     : rMod(rNewMod), m_nViewShellId(-1)
  63 {
  64     if (SfxViewShell* pViewShell = SfxViewShell::Current())
  65         m_nViewShellId = pViewShell->GetViewShellId();
  66 }
  67
  68 SdrUndoAction::~SdrUndoAction() {}
  69
  70 bool SdrUndoAction::CanRepeat(SfxRepeatTarget& rView) const
  71 {
  72     SdrView* pV=dynamic_cast<SdrView*>( &rView );
  73     if (pV!=nullptr) return CanSdrRepeat(*pV);
  74     return false;
  75 }
  76
  77 void SdrUndoAction::Repeat(SfxRepeatTarget& rView)
  78 {
  79     SdrView* pV=dynamic_cast<SdrView*>( &rView );
  80     if (pV!=nullptr) SdrRepeat(*pV);
  81     DBG_ASSERT(pV!=nullptr,"Repeat: SfxRepeatTarget that was handed over is not a SdrView");
  82 }
  83
  84 OUString SdrUndoAction::GetRepeatComment(SfxRepeatTarget& rView) const
  85 {
  86     SdrView* pV=dynamic_cast<SdrView*>( &rView );
  87     if (pV!=nullptr) return GetSdrRepeatComment(*pV);
  88     return OUString();
  89 }
  90
  91 bool SdrUndoAction::CanSdrRepeat(SdrView& /*rView*/) const
  92 {
  93     return false;
  94 }
  95
  96 void SdrUndoAction::SdrRepeat(SdrView& /*rView*/)
  97 {
  98 }
  99
 100 OUString SdrUndoAction::GetSdrRepeatComment(SdrView& /*rView*/) const
 101 {
 102     return OUString();
 103 }
 104
 105 ViewShellId SdrUndoAction::GetViewShellId() const
 106 {
 107     return m_nViewShellId;
 108 }
 109
 110 SdrUndoGroup::SdrUndoGroup(SdrModel& rNewMod)
 111 :   SdrUndoAction(rNewMod),
 112     aBuf(),
 113     eFunction(SdrRepeatFunc::NONE)
 114 {}
 115
 116 SdrUndoGroup::~SdrUndoGroup()
 117 {
 118     Clear();
 119 }
 120
 121 void SdrUndoGroup::Clear()
 122 {
 123     for (sal_Int32 nu=0; nu<GetActionCount(); nu++) {
 124         SdrUndoAction* pAct=GetAction(nu);
 125         delete pAct;
 126     }
 127     aBuf.clear();
 128 }
 129
 130 void SdrUndoGroup::AddAction(SdrUndoAction* pAct)
 131 {
 132     aBuf.push_back(pAct);
 133 }
 134
 135 void SdrUndoGroup::Undo()
 136 {
 137     for (sal_Int32 nu=GetActionCount(); nu>0;) {
 138         nu--;
 139         SdrUndoAction* pAct=GetAction(nu);
 140         pAct->Undo();
 141     }
 142 }
 143
 144 void SdrUndoGroup::Redo()
 145 {
 146     for (sal_Int32 nu=0; nu<GetActionCount(); nu++) {
 147         SdrUndoAction* pAct=GetAction(nu);
 148         pAct->Redo();
 149     }
 150 }
 151
 152 OUString SdrUndoGroup::GetComment() const
 153 {
 154     return aComment.replaceAll("%1", aObjDescription);
 155 }
 156
 157 bool SdrUndoGroup::CanSdrRepeat(SdrView& rView) const
 158 {
 159     switch (eFunction)
 160     {
 161     case SdrRepeatFunc::NONE           :  return false;
 162     case SdrRepeatFunc::Delete         :  return rView.AreObjectsMarked();
 163     case SdrRepeatFunc::CombinePolyPoly:  return rView.IsCombinePossible();
 164     case SdrRepeatFunc::CombineOnePoly :  return rView.IsCombinePossible(true);
 165     case SdrRepeatFunc::DismantlePolys :  return rView.IsDismantlePossible();
 166     case SdrRepeatFunc::DismantleLines :  return rView.IsDismantlePossible(true);
 167     case SdrRepeatFunc::ConvertToPoly  :  return rView.IsConvertToPolyObjPossible();
 168     case SdrRepeatFunc::ConvertToPath  :  return rView.IsConvertToPathObjPossible();
 169     case SdrRepeatFunc::Group          :  return rView.IsGroupPossible();
 170     case SdrRepeatFunc::Ungroup        :  return rView.IsUnGroupPossible();
 171     case SdrRepeatFunc::PutToTop       :  return rView.IsToTopPossible();
 172     case SdrRepeatFunc::PutToBottom    :  return rView.IsToBtmPossible();
 173     case SdrRepeatFunc::MoveToTop      :  return rView.IsToTopPossible();
 174     case SdrRepeatFunc::MoveToBottom   :  return rView.IsToBtmPossible();
 175     case SdrRepeatFunc::ReverseOrder   :  return rView.IsReverseOrderPossible();
 176     case SdrRepeatFunc::ImportMtf      :  return rView.IsImportMtfPossible();
 177     default: break;
 178     } // switch
 179     return false;
 180 }
 181
 182 void SdrUndoGroup::SdrRepeat(SdrView& rView)
 183 {
 184     switch (eFunction)
 185     {
 186     case SdrRepeatFunc::NONE            :  break;
 187     case SdrRepeatFunc::Delete          :  rView.DeleteMarked();                break;
 188     case SdrRepeatFunc::CombinePolyPoly :  rView.CombineMarkedObjects(false);   break;
 189     case SdrRepeatFunc::CombineOnePoly  :  rView.CombineMarkedObjects();        break;
 190     case SdrRepeatFunc::DismantlePolys  :  rView.DismantleMarkedObjects();      break;
 191     case SdrRepeatFunc::DismantleLines  :  rView.DismantleMarkedObjects(true);  break;
 192     case SdrRepeatFunc::ConvertToPoly   :  rView.ConvertMarkedToPolyObj();      break;
 193     case SdrRepeatFunc::ConvertToPath   :  rView.ConvertMarkedToPathObj(false); break;
 194     case SdrRepeatFunc::Group           :  rView.GroupMarked();                 break;
 195     case SdrRepeatFunc::Ungroup         :  rView.UnGroupMarked();               break;
 196     case SdrRepeatFunc::PutToTop        :  rView.PutMarkedToTop();              break;
 197     case SdrRepeatFunc::PutToBottom     :  rView.PutMarkedToBtm();              break;
 198     case SdrRepeatFunc::MoveToTop       :  rView.MovMarkedToTop();              break;
 199     case SdrRepeatFunc::MoveToBottom    :  rView.MovMarkedToBtm();              break;
 200     case SdrRepeatFunc::ReverseOrder    :  rView.ReverseOrderOfMarked();        break;
 201     case SdrRepeatFunc::ImportMtf       :  rView.DoImportMarkedMtf();           break;
 202     default: break;
 203     } // switch
 204 }
 205
 206 OUString SdrUndoGroup::GetSdrRepeatComment(SdrView& /*rView*/) const
 207 {
 208     return aComment.replaceAll("%1", ImpGetResStr(STR_ObjNameSingulPlural));
 209 }
 210
 211 SdrUndoObj::SdrUndoObj(SdrObject& rNewObj)
 212     : SdrUndoAction(*rNewObj.GetModel())
 213     , pObj(&rNewObj)
 214 {
 215 }
 216
 217 OUString SdrUndoObj::GetDescriptionStringForObject( const SdrObject& _rForObject, const char* pStrCacheID, bool bRepeat )
 218 {
 219     const OUString rStr {ImpGetResStr(pStrCacheID)};
 220
 221     const sal_Int32 nPos = rStr.indexOf("%1");
 222     if (nPos < 0)
 223         return rStr;
 224
 225     if (bRepeat)
 226         return rStr.replaceAt(nPos, 2, ImpGetResStr(STR_ObjNameSingulPlural));
 227
 228     return rStr.replaceAt(nPos, 2, _rForObject.TakeObjNameSingul());
 229 }
 230
 231 void SdrUndoObj::ImpTakeDescriptionStr(const char* pStrCacheID, OUString& rStr, bool bRepeat) const
 232 {
 233     if ( pObj )
 234         rStr = GetDescriptionStringForObject( *pObj, pStrCacheID, bRepeat );
 235 }
 236
 237 // common call method for possible change of the page when UNDO/REDO is triggered
 238 void SdrUndoObj::ImpShowPageOfThisObject()
 239 {
 240     if(pObj && pObj->IsInserted() && pObj->GetPage() && pObj->GetModel())
 241     {
 242         SdrHint aHint(SdrHintKind::SwitchToPage, *pObj, pObj->GetPage());
 243         pObj->GetModel()->Broadcast(aHint);
 244     }
 245 }
 246
 247 void SdrUndoAttrObj::ensureStyleSheetInStyleSheetPool(SfxStyleSheetBasePool& rStyleSheetPool, SfxStyleSheet& rSheet)
 248 {
 249     SfxStyleSheetBase* pThere = rStyleSheetPool.Find(rSheet.GetName(), rSheet.GetFamily());
 250
 251     if(!pThere)
 252     {
 253         // re-insert remembered style which was removed in the meantime. To do this
 254         // without assertion, do it without parent and set parent after insertion
 255         const OUString aParent(rSheet.GetParent());
 256
 257         rSheet.SetParent(OUString());
 258         rStyleSheetPool.Insert(&rSheet);
 259         rSheet.SetParent(aParent);
 260     }
 261 }
 262
 263 SdrUndoAttrObj::SdrUndoAttrObj(SdrObject& rNewObj, bool bStyleSheet1, bool bSaveText)
 264     : SdrUndoObj(rNewObj)
 265     , pUndoSet(nullptr)
 266     , pRedoSet(nullptr)
 267     , mxUndoStyleSheet()
 268     , mxRedoStyleSheet()
 269     , bHaveToTakeRedoSet(true)
 270     , pTextUndo(nullptr)
 271     , pTextRedo(nullptr)
 272     , pUndoGroup(nullptr)
 273 {
 274     bStyleSheet = bStyleSheet1;
 275
 276     SdrObjList* pOL = rNewObj.GetSubList();
 277     bool bIsGroup(pOL!=nullptr && pOL->GetObjCount());
 278     bool bIs3DScene(bIsGroup && dynamic_cast< E3dScene* >(pObj) !=  nullptr);
 279
 280     if(bIsGroup)
 281     {
 282         // it's a group object!
 283         pUndoGroup = new SdrUndoGroup(*pObj->GetModel());
 284         const size_t nObjCount(pOL->GetObjCount());
 285
 286         for(size_t nObjNum = 0; nObjNum < nObjCount; ++nObjNum)
 287         {
 288             pUndoGroup->AddAction(
 289                 new SdrUndoAttrObj(*pOL->GetObj(nObjNum), bStyleSheet1));
 290         }
 291     }
 292
 293     if(!bIsGroup || bIs3DScene)
 294     {
 295         pUndoSet = new SfxItemSet(pObj->GetMergedItemSet());
 296
 297         if(bStyleSheet)
 298             mxUndoStyleSheet = pObj->GetStyleSheet();
 299
 300         if(bSaveText)
 301         {
 302             pTextUndo = pObj->GetOutlinerParaObject();
 303             if(pTextUndo)
 304                 pTextUndo = new OutlinerParaObject(*pTextUndo);
 305         }
 306     }
 307 }
 308
 309 SdrUndoAttrObj::~SdrUndoAttrObj()
 310 {
 311     delete pUndoSet;
 312     delete pRedoSet;
 313     delete pUndoGroup;
 314     delete pTextUndo;
 315     delete pTextRedo;
 316 }
 317
 318 void SdrUndoAttrObj::Undo()
 319 {
 320     E3DModifySceneSnapRectUpdater aUpdater(pObj);
 321     bool bIs3DScene(dynamic_cast< E3dScene* >(pObj) !=  nullptr);
 322
 323     // Trigger PageChangeCall
 324     ImpShowPageOfThisObject();
 325
 326     if(!pUndoGroup || bIs3DScene)
 327     {
 328         if(bHaveToTakeRedoSet)
 329         {
 330             bHaveToTakeRedoSet = false;
 331
 332             delete pRedoSet;
 333
 334             pRedoSet = new SfxItemSet(pObj->GetMergedItemSet());
 335
 336             if(bStyleSheet)
 337                 mxRedoStyleSheet = pObj->GetStyleSheet();
 338
 339             if(pTextUndo)
 340             {
 341                 // #i8508#
 342                 pTextRedo = pObj->GetOutlinerParaObject();
 343
 344                 if(pTextRedo)
 345                     pTextRedo = new OutlinerParaObject(*pTextRedo);
 346             }
 347         }
 348
 349         if(bStyleSheet)
 350         {
 351             mxRedoStyleSheet = pObj->GetStyleSheet();
 352             SfxStyleSheet* pSheet = dynamic_cast< SfxStyleSheet* >(mxUndoStyleSheet.get());
 353
 354             if(pSheet && pObj->GetModel() && pObj->GetModel()->GetStyleSheetPool())
 355             {
 356                 ensureStyleSheetInStyleSheetPool(*pObj->GetModel()->GetStyleSheetPool(), *pSheet);
 357                 pObj->SetStyleSheet(pSheet, true);
 358             }
 359             else
 360             {
 361                 OSL_ENSURE(false, "OOps, something went wrong in SdrUndoAttrObj (!)");
 362             }
 363         }
 364
 365         sdr::properties::ItemChangeBroadcaster aItemChange(*pObj);
 366
 367         // Since ClearItem sets back everything to normal
 368         // it also sets fit-to-size text to non-fit-to-size text and
 369         // switches on autogrowheight (the default). That may lead to
 370         // losing the geometry size info for the object when it is
 371         // laid out again from AdjustTextFrameWidthAndHeight(). This makes
 372         // rescuing the size of the object necessary.
 373         const tools::Rectangle aSnapRect = pObj->GetSnapRect();
 374
 375         if(pUndoSet)
 376         {
 377             if(dynamic_cast<const SdrCaptionObj*>( pObj) !=  nullptr)
 378             {
 379                 // do a more smooth item deletion here, else the text
 380                 // rect will be reformatted, especially when information regarding
 381                 // vertical text is changed. When clearing only set items it's
 382                 // slower, but safer regarding such information (it's not changed
 383                 // usually)
 384                 SfxWhichIter aIter(*pUndoSet);
 385                 sal_uInt16 nWhich(aIter.FirstWhich());
 386
 387                 while(nWhich)
 388                 {
 389                     if(SfxItemState::SET != pUndoSet->GetItemState(nWhich, false))
 390                     {
 391                         pObj->ClearMergedItem(nWhich);
 392                     }
 393
 394                     nWhich = aIter.NextWhich();
 395                 }
 396             }
 397             else
 398             {
 399                 pObj->ClearMergedItem();
 400             }
 401
 402             pObj->SetMergedItemSet(*pUndoSet);
 403         }
 404
 405         // Restore previous size here when it was changed.
 406         if(aSnapRect != pObj->GetSnapRect())
 407         {
 408             pObj->NbcSetSnapRect(aSnapRect);
 409         }
 410
 411         pObj->GetProperties().BroadcastItemChange(aItemChange);
 412
 413         if(pTextUndo)
 414         {
 415             pObj->SetOutlinerParaObject(new OutlinerParaObject(*pTextUndo));
 416         }
 417     }
 418
 419     if(pUndoGroup)
 420     {
 421         pUndoGroup->Undo();
 422     }
 423 }
 424
 425 void SdrUndoAttrObj::Redo()
 426 {
 427     E3DModifySceneSnapRectUpdater aUpdater(pObj);
 428     bool bIs3DScene(dynamic_cast< E3dScene* >(pObj) !=  nullptr);
 429
 430     if(!pUndoGroup || bIs3DScene)
 431     {
 432         if(bStyleSheet)
 433         {
 434             mxUndoStyleSheet = pObj->GetStyleSheet();
 435             SfxStyleSheet* pSheet = dynamic_cast< SfxStyleSheet* >(mxRedoStyleSheet.get());
 436
 437             if(pSheet && pObj->GetModel() && pObj->GetModel()->GetStyleSheetPool())
 438             {
 439                 ensureStyleSheetInStyleSheetPool(*pObj->GetModel()->GetStyleSheetPool(), *pSheet);
 440                 pObj->SetStyleSheet(pSheet, true);
 441             }
 442             else
 443             {
 444                 OSL_ENSURE(false, "OOps, something went wrong in SdrUndoAttrObj (!)");
 445             }
 446         }
 447
 448         sdr::properties::ItemChangeBroadcaster aItemChange(*pObj);
 449
 450         const tools::Rectangle aSnapRect = pObj->GetSnapRect();
 451
 452         if(pRedoSet)
 453         {
 454             if(dynamic_cast<const SdrCaptionObj*>( pObj) !=  nullptr)
 455             {
 456                 // do a more smooth item deletion here, else the text
 457                 // rect will be reformatted, especially when information regarding
 458                 // vertical text is changed. When clearing only set items it's
 459                 // slower, but safer regarding such information (it's not changed
 460                 // usually)
 461                 SfxWhichIter aIter(*pRedoSet);
 462                 sal_uInt16 nWhich(aIter.FirstWhich());
 463
 464                 while(nWhich)
 465                 {
 466                     if(SfxItemState::SET != pRedoSet->GetItemState(nWhich, false))
 467                     {
 468                         pObj->ClearMergedItem(nWhich);
 469                     }
 470
 471                     nWhich = aIter.NextWhich();
 472                 }
 473             }
 474             else
 475             {
 476                 pObj->ClearMergedItem();
 477             }
 478
 479             pObj->SetMergedItemSet(*pRedoSet);
 480         }
 481
 482         // Restore previous size here when it was changed.
 483         if(aSnapRect != pObj->GetSnapRect())
 484         {
 485             pObj->NbcSetSnapRect(aSnapRect);
 486         }
 487
 488         pObj->GetProperties().BroadcastItemChange(aItemChange);
 489
 490         // #i8508#
 491         if(pTextRedo)
 492         {
 493             pObj->SetOutlinerParaObject(new OutlinerParaObject(*pTextRedo));
 494         }
 495     }
 496
 497     if(pUndoGroup)
 498     {
 499         pUndoGroup->Redo();
 500     }
 501
 502     // Trigger PageChangeCall
 503     ImpShowPageOfThisObject();
 504 }
 505
 506 OUString SdrUndoAttrObj::GetComment() const
 507 {
 508     OUString aStr;
 509
 510     if(bStyleSheet)
 511     {
 512         ImpTakeDescriptionStr(STR_EditSetStylesheet, aStr);
 513     }
 514     else
 515     {
 516         ImpTakeDescriptionStr(STR_EditSetAttributes, aStr);
 517     }
 518
 519     return aStr;
 520 }
 521
 522 OUString SdrUndoAttrObj::GetSdrRepeatComment(SdrView& /*rView*/) const
 523 {
 524     OUString aStr;
 525
 526     if(bStyleSheet)
 527     {
 528         ImpTakeDescriptionStr(STR_EditSetStylesheet, aStr, true);
 529     }
 530     else
 531     {
 532         ImpTakeDescriptionStr(STR_EditSetAttributes, aStr, true);
 533     }
 534
 535     return aStr;
 536 }
 537
 538
 539 SdrUndoMoveObj::~SdrUndoMoveObj() {}
 540
 541 void SdrUndoMoveObj::Undo()
 542 {
 543     // Trigger PageChangeCall
 544     ImpShowPageOfThisObject();
 545
 546     pObj->Move(Size(-aDistance.Width(),-aDistance.Height()));
 547 }
 548
 549 void SdrUndoMoveObj::Redo()
 550 {
 551     pObj->Move(Size(aDistance.Width(),aDistance.Height()));
 552
 553     // Trigger PageChangeCall
 554     ImpShowPageOfThisObject();
 555 }
 556
 557 OUString SdrUndoMoveObj::GetComment() const
 558 {
 559     OUString aStr;
 560     ImpTakeDescriptionStr(STR_EditMove,aStr);
 561     return aStr;
 562 }
 563
 564 void SdrUndoMoveObj::SdrRepeat(SdrView& rView)
 565 {
 566     rView.MoveMarkedObj(aDistance);
 567 }
 568
 569 bool SdrUndoMoveObj::CanSdrRepeat(SdrView& rView) const
 570 {
 571     return rView.AreObjectsMarked();
 572 }
 573
 574 OUString SdrUndoMoveObj::GetSdrRepeatComment(SdrView& /*rView*/) const
 575 {
 576     OUString aStr;
 577     ImpTakeDescriptionStr(STR_EditMove,aStr,true);
 578     return aStr;
 579 }
 580
 581
 582 SdrUndoGeoObj::SdrUndoGeoObj(SdrObject& rNewObj)
 583      : SdrUndoObj(rNewObj)
 584      , pUndoGeo(nullptr)
 585      , pRedoGeo(nullptr)
 586      , pUndoGroup(nullptr)
 587      , mbSkipChangeLayout(false)
 588 {
 589     SdrObjList* pOL=rNewObj.GetSubList();
 590     if (pOL!=nullptr && pOL->GetObjCount() && dynamic_cast<const E3dScene* >( &rNewObj) ==  nullptr)
 591     {
 592         // this is a group object!
 593         // If this were 3D scene, we'd only add an Undo for the scene itself
 594         // (which we do elsewhere).
 595         pUndoGroup=new SdrUndoGroup(*pObj->GetModel());
 596         const size_t nObjCount = pOL->GetObjCount();
 597         for (size_t nObjNum = 0; nObjNum<nObjCount; ++nObjNum) {
 598             pUndoGroup->AddAction(new SdrUndoGeoObj(*pOL->GetObj(nObjNum)));
 599         }
 600     }
 601     else
 602     {
 603         pUndoGeo=pObj->GetGeoData();
 604     }
 605 }
 606
 607 SdrUndoGeoObj::~SdrUndoGeoObj()
 608 {
 609     delete pUndoGeo;
 610     delete pRedoGeo;
 611     delete pUndoGroup;
 612 }
 613
 614 void SdrUndoGeoObj::Undo()
 615 {
 616     // Trigger PageChangeCall
 617     ImpShowPageOfThisObject();
 618
 619     if(pUndoGroup)
 620     {
 621         pUndoGroup->Undo();
 622
 623         // only repaint, no objectchange
 624         pObj->ActionChanged();
 625     }
 626     else
 627     {
 628         delete pRedoGeo;
 629         pRedoGeo=pObj->GetGeoData();
 630
 631         auto pTableObj = dynamic_cast<sdr::table::SdrTableObj*>(pObj);
 632         if (pTableObj && mbSkipChangeLayout)
 633             pTableObj->SetSkipChangeLayout(true);
 634         pObj->SetGeoData(*pUndoGeo);
 635         if (pTableObj && mbSkipChangeLayout)
 636             pTableObj->SetSkipChangeLayout(false);
 637     }
 638 }
 639
 640 void SdrUndoGeoObj::Redo()
 641 {
 642     if(pUndoGroup)
 643     {
 644         pUndoGroup->Redo();
 645
 646         // only repaint, no objectchange
 647         pObj->ActionChanged();
 648     }
 649     else
 650     {
 651         delete pUndoGeo;
 652         pUndoGeo=pObj->GetGeoData();
 653         pObj->SetGeoData(*pRedoGeo);
 654     }
 655
 656     // Trigger PageChangeCall
 657     ImpShowPageOfThisObject();
 658 }
 659
 660 OUString SdrUndoGeoObj::GetComment() const
 661 {
 662     OUString aStr;
 663     ImpTakeDescriptionStr(STR_DragMethObjOwn,aStr);
 664     return aStr;
 665 }
 666
 667
 668 SdrUndoObjList::SdrUndoObjList(SdrObject& rNewObj, bool bOrdNumDirect)
 669     : SdrUndoObj(rNewObj)
 670     , bOwner(false)
 671 {
 672     pObjList=pObj->GetObjList();
 673     if (bOrdNumDirect)
 674     {
 675         nOrdNum=pObj->GetOrdNumDirect();
 676     }
 677     else
 678     {
 679         nOrdNum=pObj->GetOrdNum();
 680     }
 681 }
 682
 683 SdrUndoObjList::~SdrUndoObjList()
 684 {
 685     SolarMutexGuard aGuard;
 686
 687     if (pObj!=nullptr && IsOwner())
 688     {
 689         // Attribute have to go back to the regular Pool
 690         SetOwner(false);
 691
 692         // now delete
 693         SdrObject::Free( pObj );
 694     }
 695 }
 696
 697 void SdrUndoObjList::SetOwner(bool bNew)
 698 {
 699     bOwner = bNew;
 700 }
 701
 702
 703 void SdrUndoRemoveObj::Undo()
 704 {
 705     // Trigger PageChangeCall
 706     ImpShowPageOfThisObject();
 707
 708     DBG_ASSERT(!pObj->IsInserted(),"UndoRemoveObj: pObj has already been inserted.");
 709     if (!pObj->IsInserted())
 710     {
 711         // #i11426#
 712         // For UNDOs in Calc/Writer it is necessary to adapt the anchor
 713         // position of the target object.
 714         Point aOwnerAnchorPos(0, 0);
 715
 716         if (dynamic_cast<const SdrObjGroup*>(pObjList->GetOwnerObj()) != nullptr)
 717         {
 718             aOwnerAnchorPos = pObjList->GetOwnerObj()->GetAnchorPos();
 719         }
 720
 721         E3DModifySceneSnapRectUpdater aUpdater(pObjList->GetOwnerObj());
 722         pObjList->InsertObject(pObj,nOrdNum);
 723
 724         // #i11426#
 725         if(aOwnerAnchorPos.X() || aOwnerAnchorPos.Y())
 726         {
 727             pObj->NbcSetAnchorPos(aOwnerAnchorPos);
 728         }
 729     }
 730 }
 731
 732 void SdrUndoRemoveObj::Redo()
 733 {
 734     DBG_ASSERT(pObj->IsInserted(),"RedoRemoveObj: pObj is not inserted.");
 735     if (pObj->IsInserted())
 736     {
 737         ImplUnmarkObject( pObj );
 738         E3DModifySceneSnapRectUpdater aUpdater(pObj);
 739         pObjList->RemoveObject(nOrdNum);
 740     }
 741
 742     // Trigger PageChangeCall
 743     ImpShowPageOfThisObject();
 744 }
 745
 746 SdrUndoRemoveObj::~SdrUndoRemoveObj()
 747 {
 748 }
 749
 750
 751 void SdrUndoInsertObj::Undo()
 752 {
 753     // Trigger PageChangeCall
 754     ImpShowPageOfThisObject();
 755
 756     DBG_ASSERT(pObj->IsInserted(),"UndoInsertObj: pObj is not inserted.");
 757     if (pObj->IsInserted())
 758     {
 759         ImplUnmarkObject( pObj );
 760
 761         SdrObject* pChkObj= pObjList->RemoveObject(nOrdNum);
 762         DBG_ASSERT(pChkObj==pObj,"UndoInsertObj: RemoveObjNum!=pObj");
 763     }
 764 }
 765
 766 void SdrUndoInsertObj::Redo()
 767 {
 768     DBG_ASSERT(!pObj->IsInserted(),"RedoInsertObj: pObj is already inserted");
 769     if (!pObj->IsInserted())
 770     {
 771         // Restore anchor position of an object,
 772         // which becomes a member of a group, because its cleared in method
 773         // <InsertObject(..)>. Needed for correct Redo in Writer. (#i45952#)
 774         Point aAnchorPos( 0, 0 );
 775         if (dynamic_cast<const SdrObjGroup*>(pObjList->GetOwnerObj()) != nullptr)
 776         {
 777             aAnchorPos = pObj->GetAnchorPos();
 778         }
 779
 780         pObjList->InsertObject(pObj,nOrdNum);
 781
 782         // Arcs lose position when grouped (#i45952#)
 783         if ( aAnchorPos.X() || aAnchorPos.Y() )
 784         {
 785             pObj->NbcSetAnchorPos( aAnchorPos );
 786         }
 787     }
 788
 789     // Trigger PageChangeCall
 790     ImpShowPageOfThisObject();
 791 }
 792
 793 SdrUndoDelObj::SdrUndoDelObj(SdrObject& rNewObj, bool bOrdNumDirect)
 794 :   SdrUndoRemoveObj(rNewObj,bOrdNumDirect)
 795 {
 796     SetOwner(true);
 797 }
 798
 799 void SdrUndoDelObj::Undo()
 800 {
 801     SdrUndoRemoveObj::Undo();
 802     DBG_ASSERT(IsOwner(),"UndoDeleteObj: pObj does not belong to UndoAction");
 803     SetOwner(false);
 804 }
 805
 806 void SdrUndoDelObj::Redo()
 807 {
 808     SdrUndoRemoveObj::Redo();
 809     DBG_ASSERT(!IsOwner(),"RedoDeleteObj: pObj already belongs to UndoAction");
 810     SetOwner(true);
 811 }
 812
 813 OUString SdrUndoDelObj::GetComment() const
 814 {
 815     OUString aStr;
 816     ImpTakeDescriptionStr(STR_EditDelete,aStr);
 817     return aStr;
 818 }
 819
 820 void SdrUndoDelObj::SdrRepeat(SdrView& rView)
 821 {
 822     rView.DeleteMarked();
 823 }
 824
 825 bool SdrUndoDelObj::CanSdrRepeat(SdrView& rView) const
 826 {
 827     return rView.AreObjectsMarked();
 828 }
 829
 830 OUString SdrUndoDelObj::GetSdrRepeatComment(SdrView& /*rView*/) const
 831 {
 832     OUString aStr;
 833     ImpTakeDescriptionStr(STR_EditDelete,aStr,true);
 834     return aStr;
 835 }
 836
 837
 838 void SdrUndoNewObj::Undo()
 839 {
 840     SdrUndoInsertObj::Undo();
 841     DBG_ASSERT(!IsOwner(),"RedoNewObj: pObj already belongs to UndoAction");
 842     SetOwner(true);
 843 }
 844
 845 void SdrUndoNewObj::Redo()
 846 {
 847     SdrUndoInsertObj::Redo();
 848     DBG_ASSERT(IsOwner(),"RedoNewObj: pObj does not belong to UndoAction");
 849     SetOwner(false);
 850 }
 851
 852 OUString SdrUndoNewObj::GetComment( const SdrObject& _rForObject )
 853 {
 854     return GetDescriptionStringForObject( _rForObject, STR_UndoInsertObj );
 855 }
 856
 857 OUString SdrUndoNewObj::GetComment() const
 858 {
 859     OUString aStr;
 860     ImpTakeDescriptionStr(STR_UndoInsertObj,aStr);
 861     return aStr;
 862 }
 863
 864 SdrUndoReplaceObj::SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1, bool bOrdNumDirect)
 865     : SdrUndoObj(rOldObj1)
 866     , bOldOwner(false)
 867     , bNewOwner(false)
 868     , pNewObj(&rNewObj1)
 869 {
 870     SetOldOwner(true);
 871
 872     pObjList=pObj->GetObjList();
 873     if (bOrdNumDirect)
 874     {
 875         nOrdNum=pObj->GetOrdNumDirect();
 876     }
 877     else
 878     {
 879         nOrdNum=pObj->GetOrdNum();
 880     }
 881 }
 882
 883 SdrUndoReplaceObj::~SdrUndoReplaceObj()
 884 {
 885     if (pObj!=nullptr && IsOldOwner())
 886     {
 887         // Attribute have to go back into the Pool
 888         SetOldOwner(false);
 889
 890         // now delete
 891         SdrObject::Free( pObj );
 892     }
 893     if (pNewObj!=nullptr && IsNewOwner())
 894     {
 895         // Attribute have to go back into the Pool
 896         SetNewOwner(false);
 897
 898         // now delete
 899         SdrObject::Free( pNewObj );
 900     }
 901 }
 902
 903 void SdrUndoReplaceObj::Undo()
 904 {
 905     // Trigger PageChangeCall
 906     ImpShowPageOfThisObject();
 907
 908     if (IsOldOwner() && !IsNewOwner())
 909     {
 910         DBG_ASSERT(!pObj->IsInserted(),"SdrUndoReplaceObj::Undo(): Old object is already inserted!");
 911         DBG_ASSERT(pNewObj->IsInserted(),"SdrUndoReplaceObj::Undo(): New object is not inserted!");
 912         SetOldOwner(false);
 913         SetNewOwner(true);
 914
 915         ImplUnmarkObject( pNewObj );
 916         pObjList->ReplaceObject(pObj,nOrdNum);
 917     }
 918     else
 919     {
 920         OSL_FAIL("SdrUndoReplaceObj::Undo(): Wrong IsMine flags. Did you call Undo twice?");
 921     }
 922 }
 923
 924 void SdrUndoReplaceObj::Redo()
 925 {
 926     if (!IsOldOwner() && IsNewOwner())
 927     {
 928         DBG_ASSERT(!pNewObj->IsInserted(),"SdrUndoReplaceObj::Redo(): New object is already inserted!!");
 929         DBG_ASSERT(pObj->IsInserted(),"SdrUndoReplaceObj::Redo(): Old object is not inserted!!");
 930         SetOldOwner(true);
 931         SetNewOwner(false);
 932
 933         ImplUnmarkObject( pObj );
 934         pObjList->ReplaceObject(pNewObj,nOrdNum);
 935
 936     }
 937     else
 938     {
 939         OSL_FAIL("SdrUndoReplaceObj::Redo(): Wrong IsMine flags. Did you call Redo twice?");
 940     }
 941
 942     // Trigger PageChangeCall
 943     ImpShowPageOfThisObject();
 944 }
 945
 946 void SdrUndoReplaceObj::SetNewOwner(bool bNew)
 947 {
 948     bNewOwner = bNew;
 949 }
 950
 951 void SdrUndoReplaceObj::SetOldOwner(bool bNew)
 952 {
 953     bOldOwner = bNew;
 954 }
 955
 956
 957 OUString SdrUndoCopyObj::GetComment() const
 958 {
 959     OUString aStr;
 960     ImpTakeDescriptionStr(STR_UndoCopyObj,aStr);
 961     return aStr;
 962 }
 963
 964
 965 // #i11702#
 966
 967 SdrUndoObjectLayerChange::SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer)
 968   : SdrUndoObj(rObj)
 969   , maOldLayer(aOldLayer)
 970   , maNewLayer(aNewLayer)
 971 {
 972 }
 973
 974 void SdrUndoObjectLayerChange::Undo()
 975 {
 976     ImpShowPageOfThisObject();
 977     pObj->SetLayer(maOldLayer);
 978 }
 979
 980 void SdrUndoObjectLayerChange::Redo()
 981 {
 982     pObj->SetLayer(maNewLayer);
 983     ImpShowPageOfThisObject();
 984 }
 985
 986
 987 SdrUndoObjOrdNum::SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1)
 988     : SdrUndoObj(rNewObj)
 989     , nOldOrdNum(nOldOrdNum1)
 990     , nNewOrdNum(nNewOrdNum1)
 991 {
 992 }
 993
 994 void SdrUndoObjOrdNum::Undo()
 995 {
 996     // Trigger PageChangeCall
 997     ImpShowPageOfThisObject();
 998
 999     SdrObjList* pOL=pObj->GetObjList();
1000     if (pOL==nullptr)
1001     {
1002         OSL_FAIL("UndoObjOrdNum: pObj does not have an ObjList.");
1003         return;
1004     }
1005     pOL->SetObjectOrdNum(nNewOrdNum,nOldOrdNum);
1006 }
1007
1008 void SdrUndoObjOrdNum::Redo()
1009 {
1010     SdrObjList* pOL=pObj->GetObjList();
1011     if (pOL==nullptr)
1012     {
1013         OSL_FAIL("RedoObjOrdNum: pObj does not have an ObjList.");
1014         return;
1015     }
1016     pOL->SetObjectOrdNum(nOldOrdNum,nNewOrdNum);
1017
1018     // Trigger PageChangeCall
1019     ImpShowPageOfThisObject();
1020 }
1021
1022 OUString SdrUndoObjOrdNum::GetComment() const
1023 {
1024     OUString aStr;
1025     ImpTakeDescriptionStr(STR_UndoObjOrdNum,aStr);
1026     return aStr;
1027 }
1028
1029
1030 SdrUndoObjSetText::SdrUndoObjSetText(SdrObject& rNewObj, sal_Int32 nText)
1031     : SdrUndoObj(rNewObj)
1032     , pOldText(nullptr)
1033     , pNewText(nullptr)
1034     , bNewTextAvailable(false)
1035     , bEmptyPresObj(false)
1036     , mnText(nText)
1037 {
1038     SdrText* pText = static_cast< SdrTextObj*>( &rNewObj )->getText(mnText);
1039     if( pText && pText->GetOutlinerParaObject() )
1040         pOldText = new OutlinerParaObject(*pText->GetOutlinerParaObject());
1041
1042     bEmptyPresObj = rNewObj.IsEmptyPresObj();
1043 }
1044
1045 SdrUndoObjSetText::~SdrUndoObjSetText()
1046 {
1047     delete pOldText;
1048     delete pNewText;
1049 }
1050
1051 void SdrUndoObjSetText::AfterSetText()
1052 {
1053     if (!bNewTextAvailable)
1054     {
1055         SdrText* pText = static_cast< SdrTextObj*>( pObj )->getText(mnText);
1056         if( pText && pText->GetOutlinerParaObject() )
1057             pNewText = new OutlinerParaObject(*pText->GetOutlinerParaObject());
1058         bNewTextAvailable=true;
1059     }
1060 }
1061
1062 void SdrUndoObjSetText::Undo()
1063 {
1064     // only works with SdrTextObj
1065     SdrTextObj* pTarget = dynamic_cast< SdrTextObj* >(pObj);
1066
1067     if(!pTarget)
1068     {
1069         OSL_ENSURE(false, "SdrUndoObjSetText::Undo with SdrObject not based on SdrTextObj (!)");
1070         return;
1071     }
1072
1073     // Trigger PageChangeCall
1074     ImpShowPageOfThisObject();
1075
1076     // save old text for Redo
1077     if(!bNewTextAvailable)
1078     {
1079         AfterSetText();
1080     }
1081
1082     SdrText* pText = pTarget->getText(mnText);
1083     if (pText)
1084     {
1085         // copy text for Undo, because the original now belongs to SetOutlinerParaObject()
1086         OutlinerParaObject* pText1 = pOldText ? new OutlinerParaObject(*pOldText) : nullptr;
1087         pText->SetOutlinerParaObject(pText1);
1088         pTarget->NbcSetOutlinerParaObjectForText(pText1, pText);
1089     }
1090
1091     pTarget->SetEmptyPresObj(bEmptyPresObj);
1092     pTarget->ActionChanged();
1093
1094     // #i124389# if it's a table, also need to relayout TextFrame
1095     if(dynamic_cast< sdr::table::SdrTableObj* >(pTarget) !=  nullptr)
1096     {
1097         pTarget->NbcAdjustTextFrameWidthAndHeight();
1098     }
1099
1100     // #i122410# SetOutlinerParaObject at SdrText does not trigger a
1101     // BroadcastObjectChange, but it is needed to make evtl. SlideSorters
1102     // update their preview.
1103     pTarget->BroadcastObjectChange();
1104 }
1105
1106 void SdrUndoObjSetText::Redo()
1107 {
1108     // only works with SdrTextObj
1109     SdrTextObj* pTarget = dynamic_cast< SdrTextObj* >(pObj);
1110
1111     if(!pTarget)
1112     {
1113         OSL_ENSURE(false, "SdrUndoObjSetText::Redo with SdrObject not based on SdrTextObj (!)");
1114         return;
1115     }
1116
1117     SdrText* pText = pTarget->getText(mnText);
1118     if (pText)
1119     {
1120         // copy text for Undo, because the original now belongs to SetOutlinerParaObject()
1121         OutlinerParaObject* pText1 = pNewText ? new OutlinerParaObject(*pNewText) : nullptr;
1122         pTarget->NbcSetOutlinerParaObjectForText( pText1, pText );
1123     }
1124
1125     pTarget->ActionChanged();
1126
1127     // #i124389# if it's a table, also need to relayout TextFrame
1128     if(dynamic_cast< sdr::table::SdrTableObj* >(pTarget) !=  nullptr)
1129     {
1130         pTarget->NbcAdjustTextFrameWidthAndHeight();
1131     }
1132
1133     // #i122410# NbcSetOutlinerParaObjectForText at SdrTextObj does not trigger a
1134     // BroadcastObjectChange, but it is needed to make evtl. SlideSorters
1135     // update their preview.
1136     pTarget->BroadcastObjectChange();
1137
1138     // Trigger PageChangeCall
1139     ImpShowPageOfThisObject();
1140 }
1141
1142 OUString SdrUndoObjSetText::GetComment() const
1143 {
1144     OUString aStr;
1145     ImpTakeDescriptionStr(STR_UndoObjSetText,aStr);
1146     return aStr;
1147 }
1148
1149 OUString SdrUndoObjSetText::GetSdrRepeatComment(SdrView& /*rView*/) const
1150 {
1151     OUString aStr;
1152     ImpTakeDescriptionStr(STR_UndoObjSetText,aStr);
1153     return aStr;
1154 }
1155
1156 void SdrUndoObjSetText::SdrRepeat(SdrView& rView)
1157 {
1158     if (bNewTextAvailable && rView.AreObjectsMarked())
1159     {
1160         const SdrMarkList& rML=rView.GetMarkedObjectList();
1161
1162         const bool bUndo = rView.IsUndoEnabled();
1163         if( bUndo )
1164         {
1165             OUString aStr;
1166             ImpTakeDescriptionStr(STR_UndoObjSetText,aStr);
1167             rView.BegUndo(aStr);
1168         }
1169
1170         const size_t nCount=rML.GetMarkCount();
1171         for (size_t nm=0; nm<nCount; ++nm)
1172         {
1173             SdrObject* pObj2=rML.GetMark(nm)->GetMarkedSdrObj();
1174             SdrTextObj* pTextObj=dynamic_cast<SdrTextObj*>( pObj2 );
1175             if (pTextObj!=nullptr)
1176             {
1177                 if( bUndo )
1178                     rView.AddUndo(new SdrUndoObjSetText(*pTextObj,0));
1179
1180                 OutlinerParaObject* pText1=pNewText;
1181                 if (pText1!=nullptr)
1182                     pText1 = new OutlinerParaObject(*pText1);
1183                 pTextObj->SetOutlinerParaObject(pText1);
1184             }
1185         }
1186
1187         if( bUndo )
1188             rView.EndUndo();
1189     }
1190 }
1191
1192 bool SdrUndoObjSetText::CanSdrRepeat(SdrView& rView) const
1193 {
1194     bool bOk = false;
1195     if (bNewTextAvailable && rView.AreObjectsMarked()) {
1196         bOk=true;
1197     }
1198     return bOk;
1199 }
1200
1201 // Undo/Redo for setting object's name (#i73249#)
1202 SdrUndoObjStrAttr::SdrUndoObjStrAttr( SdrObject& rNewObj,
1203                                       const ObjStrAttrType eObjStrAttr,
1204                                       const OUString& sOldStr,
1205                                       const OUString& sNewStr)
1206     : SdrUndoObj( rNewObj )
1207     , meObjStrAttr( eObjStrAttr )
1208     , msOldStr( sOldStr )
1209     , msNewStr( sNewStr )
1210 {
1211 }
1212
1213 void SdrUndoObjStrAttr::Undo()
1214 {
1215     ImpShowPageOfThisObject();
1216
1217     switch ( meObjStrAttr )
1218     {
1219     case ObjStrAttrType::Name:
1220         pObj->SetName( msOldStr );
1221         break;
1222     case ObjStrAttrType::Title:
1223         pObj->SetTitle( msOldStr );
1224         break;
1225     case ObjStrAttrType::Description:
1226         pObj->SetDescription( msOldStr );
1227         break;
1228     }
1229 }
1230
1231 void SdrUndoObjStrAttr::Redo()
1232 {
1233     switch ( meObjStrAttr )
1234     {
1235     case ObjStrAttrType::Name:
1236         pObj->SetName( msNewStr );
1237         break;
1238     case ObjStrAttrType::Title:
1239         pObj->SetTitle( msNewStr );
1240         break;
1241     case ObjStrAttrType::Description:
1242         pObj->SetDescription( msNewStr );
1243         break;
1244     }
1245
1246     ImpShowPageOfThisObject();
1247 }
1248
1249 OUString SdrUndoObjStrAttr::GetComment() const
1250 {
1251     OUString aStr;
1252     switch ( meObjStrAttr )
1253     {
1254     case ObjStrAttrType::Name:
1255         ImpTakeDescriptionStr( STR_UndoObjName, aStr );
1256         aStr += " '" + msNewStr + "'";
1257         break;
1258     case ObjStrAttrType::Title:
1259         ImpTakeDescriptionStr( STR_UndoObjTitle, aStr );
1260         break;
1261     case ObjStrAttrType::Description:
1262         ImpTakeDescriptionStr( STR_UndoObjDescription, aStr );
1263         break;
1264     }
1265
1266     return aStr;
1267 }
1268
1269
1270 SdrUndoLayer::SdrUndoLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
1271     : SdrUndoAction(rNewModel)
1272     , pLayer(rNewLayerAdmin.GetLayer(nLayerNum))
1273     , pLayerAdmin(&rNewLayerAdmin)
1274     , nNum(nLayerNum)
1275     , bItsMine(false)
1276 {
1277 }
1278
1279 SdrUndoLayer::~SdrUndoLayer()
1280 {
1281     if (bItsMine)
1282     {
1283         delete pLayer;
1284     }
1285 }
1286
1287
1288 void SdrUndoNewLayer::Undo()
1289 {
1290     DBG_ASSERT(!bItsMine,"SdrUndoNewLayer::Undo(): Layer already belongs to UndoAction.");
1291     bItsMine=true;
1292     SdrLayer* pCmpLayer= pLayerAdmin->RemoveLayer(nNum);
1293     DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoNewLayer::Undo(): Removed layer is != pLayer.");
1294 }
1295
1296 void SdrUndoNewLayer::Redo()
1297 {
1298     DBG_ASSERT(bItsMine,"SdrUndoNewLayer::Undo(): Layer does not belong to UndoAction.");
1299     bItsMine=false;
1300     pLayerAdmin->InsertLayer(pLayer,nNum);
1301 }
1302
1303 OUString SdrUndoNewLayer::GetComment() const
1304 {
1305     return ImpGetResStr(STR_UndoNewLayer);
1306 }
1307
1308
1309 void SdrUndoDelLayer::Undo()
1310 {
1311     DBG_ASSERT(bItsMine,"SdrUndoDelLayer::Undo(): Layer does not belong to UndoAction.");
1312     bItsMine=false;
1313     pLayerAdmin->InsertLayer(pLayer,nNum);
1314 }
1315
1316 void SdrUndoDelLayer::Redo()
1317 {
1318     DBG_ASSERT(!bItsMine,"SdrUndoDelLayer::Undo(): Layer already belongs to UndoAction.");
1319     bItsMine=true;
1320     SdrLayer* pCmpLayer= pLayerAdmin->RemoveLayer(nNum);
1321     DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoDelLayer::Redo(): Removed layer is != pLayer.");
1322 }
1323
1324 OUString SdrUndoDelLayer::GetComment() const
1325 {
1326     return ImpGetResStr(STR_UndoDelLayer);
1327 }
1328
1329
1330 void SdrUndoMoveLayer::Undo()
1331 {
1332     SdrLayer* pCmpLayer= pLayerAdmin->RemoveLayer(nNewPos);
1333     DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoMoveLayer::Undo(): Removed layer is != pLayer.");
1334     pLayerAdmin->InsertLayer(pLayer,nNum);
1335 }
1336
1337 void SdrUndoMoveLayer::Redo()
1338 {
1339     SdrLayer* pCmpLayer= pLayerAdmin->RemoveLayer(nNum);
1340     DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoMoveLayer::Redo(): Removed layer is != pLayer.");
1341     pLayerAdmin->InsertLayer(pLayer,nNewPos);
1342 }
1343
1344 OUString SdrUndoMoveLayer::GetComment() const
1345 {
1346     return ImpGetResStr(STR_UndoMovLayer);
1347 }
1348
1349
1350 SdrUndoPage::SdrUndoPage(SdrPage& rNewPg)
1351     : SdrUndoAction(*rNewPg.GetModel())
1352     , mrPage(rNewPg)
1353 {
1354 }
1355
1356 void SdrUndoPage::ImpInsertPage(sal_uInt16 nNum)
1357 {
1358     DBG_ASSERT(!mrPage.IsInserted(),"SdrUndoPage::ImpInsertPage(): mrPage is already inserted.");
1359     if (!mrPage.IsInserted())
1360     {
1361         if (mrPage.IsMasterPage())
1362         {
1363             rMod.InsertMasterPage(&mrPage,nNum);
1364         }
1365         else
1366         {
1367             rMod.InsertPage(&mrPage,nNum);
1368         }
1369     }
1370 }
1371
1372 void SdrUndoPage::ImpRemovePage(sal_uInt16 nNum)
1373 {
1374     DBG_ASSERT(mrPage.IsInserted(),"SdrUndoPage::ImpRemovePage(): mrPage is not inserted.");
1375     if (mrPage.IsInserted())
1376     {
1377         SdrPage* pChkPg=nullptr;
1378         if (mrPage.IsMasterPage())
1379         {
1380             pChkPg=rMod.RemoveMasterPage(nNum);
1381         }
1382         else
1383         {
1384             pChkPg=rMod.RemovePage(nNum);
1385         }
1386         DBG_ASSERT(pChkPg==&mrPage,"SdrUndoPage::ImpRemovePage(): RemovePage!=&mrPage");
1387     }
1388 }
1389
1390 void SdrUndoPage::ImpMovePage(sal_uInt16 nOldNum, sal_uInt16 nNewNum)
1391 {
1392     DBG_ASSERT(mrPage.IsInserted(),"SdrUndoPage::ImpMovePage(): mrPage is not inserted.");
1393     if (mrPage.IsInserted())
1394     {
1395         if (mrPage.IsMasterPage())
1396         {
1397             rMod.MoveMasterPage(nOldNum,nNewNum);
1398         }
1399         else
1400         {
1401             rMod.MovePage(nOldNum,nNewNum);
1402         }
1403     }
1404 }
1405
1406 void SdrUndoPage::ImpTakeDescriptionStr(const char* pStrCacheID, OUString& rStr)
1407 {
1408     rStr = ImpGetResStr(pStrCacheID);
1409 }
1410
1411
1412 SdrUndoPageList::SdrUndoPageList(SdrPage& rNewPg)
1413     : SdrUndoPage(rNewPg)
1414     , bItsMine(false)
1415 {
1416     nPageNum=rNewPg.GetPageNum();
1417 }
1418
1419 SdrUndoPageList::~SdrUndoPageList()
1420 {
1421     if(bItsMine)
1422     {
1423         delete (&mrPage);
1424     }
1425 }
1426
1427
1428 SdrUndoDelPage::SdrUndoDelPage(SdrPage& rNewPg)
1429     : SdrUndoPageList(rNewPg)
1430     , pUndoGroup(nullptr)
1431     , mbHasFillBitmap(false)
1432 {
1433     bItsMine = true;
1434
1435     // keep fill bitmap separately to remove it from pool if not used elsewhere
1436     if (mrPage.IsMasterPage())
1437     {
1438         SfxStyleSheet* const pStyleSheet = mrPage.getSdrPageProperties().GetStyleSheet();
1439         if (pStyleSheet)
1440             queryFillBitmap(pStyleSheet->GetItemSet());
1441     }
1442     else
1443     {
1444         queryFillBitmap(mrPage.getSdrPageProperties().GetItemSet());
1445     }
1446     if (bool(mpFillBitmapItem))
1447         clearFillBitmap();
1448
1449     // now remember the master page relationships
1450     if(mrPage.IsMasterPage())
1451     {
1452         sal_uInt16 nPageCnt(rMod.GetPageCount());
1453
1454         for(sal_uInt16 nPageNum2(0); nPageNum2 < nPageCnt; nPageNum2++)
1455         {
1456             SdrPage* pDrawPage = rMod.GetPage(nPageNum2);
1457
1458             if(pDrawPage->TRG_HasMasterPage())
1459             {
1460                 SdrPage& rMasterPage = pDrawPage->TRG_GetMasterPage();
1461
1462                 if(&mrPage == &rMasterPage)
1463                 {
1464                     if(!pUndoGroup)
1465                     {
1466                         pUndoGroup.reset( new SdrUndoGroup(rMod) );
1467                     }
1468
1469                     pUndoGroup->AddAction(rMod.GetSdrUndoFactory().CreateUndoPageRemoveMasterPage(*pDrawPage));
1470                 }
1471             }
1472         }
1473     }
1474 }
1475
1476 SdrUndoDelPage::~SdrUndoDelPage()
1477 {
1478 }
1479
1480 void SdrUndoDelPage::Undo()
1481 {
1482     if (bool(mpFillBitmapItem))
1483         restoreFillBitmap();
1484     ImpInsertPage(nPageNum);
1485     if (pUndoGroup!=nullptr)
1486     {
1487         // recover master page relationships
1488         pUndoGroup->Undo();
1489     }
1490     DBG_ASSERT(bItsMine,"UndoDeletePage: mrPage does not belong to UndoAction.");
1491     bItsMine=false;
1492 }
1493
1494 void SdrUndoDelPage::Redo()
1495 {
1496     ImpRemovePage(nPageNum);
1497     if (bool(mpFillBitmapItem))
1498         clearFillBitmap();
1499     // master page relations are dissolved automatically
1500     DBG_ASSERT(!bItsMine,"RedoDeletePage: mrPage already belongs to UndoAction.");
1501     bItsMine=true;
1502 }
1503
1504 OUString SdrUndoDelPage::GetComment() const
1505 {
1506     OUString aStr;
1507     ImpTakeDescriptionStr(STR_UndoDelPage,aStr);
1508     return aStr;
1509 }
1510
1511 OUString SdrUndoDelPage::GetSdrRepeatComment(SdrView& /*rView*/) const
1512 {
1513     OUString aStr;
1514     ImpTakeDescriptionStr(STR_UndoDelPage,aStr);
1515     return aStr;
1516 }
1517
1518 void SdrUndoDelPage::SdrRepeat(SdrView& /*rView*/)
1519 {
1520 }
1521
1522 bool SdrUndoDelPage::CanSdrRepeat(SdrView& /*rView*/) const
1523 {
1524     return false;
1525 }
1526
1527 void SdrUndoDelPage::queryFillBitmap(const SfxItemSet& rItemSet)
1528 {
1529     const SfxPoolItem *pItem = nullptr;
1530     if (rItemSet.GetItemState(XATTR_FILLBITMAP, false, &pItem) == SfxItemState::SET)
1531         mpFillBitmapItem.reset(pItem->Clone());
1532     if (rItemSet.GetItemState(XATTR_FILLSTYLE, false, &pItem) == SfxItemState::SET)
1533         mbHasFillBitmap = static_cast<const XFillStyleItem*>(pItem)->GetValue() == css::drawing::FillStyle_BITMAP;
1534 }
1535
1536 void SdrUndoDelPage::clearFillBitmap()
1537 {
1538     if (mrPage.IsMasterPage())
1539     {
1540         SfxStyleSheet* const pStyleSheet = mrPage.getSdrPageProperties().GetStyleSheet();
1541         assert(bool(pStyleSheet)); // who took away my stylesheet?
1542         if (pStyleSheet->GetListenerCount() == 1)
1543         {
1544             SfxItemSet& rItemSet = pStyleSheet->GetItemSet();
1545             rItemSet.ClearItem(XATTR_FILLBITMAP);
1546             if (mbHasFillBitmap)
1547                 rItemSet.ClearItem(XATTR_FILLSTYLE);
1548         }
1549     }
1550     else
1551     {
1552         SdrPageProperties &rPageProps = mrPage.getSdrPageProperties();
1553         rPageProps.ClearItem(XATTR_FILLBITMAP);
1554         if (mbHasFillBitmap)
1555             rPageProps.ClearItem(XATTR_FILLSTYLE);
1556     }
1557 }
1558
1559 void SdrUndoDelPage::restoreFillBitmap()
1560 {
1561     if (mrPage.IsMasterPage())
1562     {
1563         SfxStyleSheet* const pStyleSheet = mrPage.getSdrPageProperties().GetStyleSheet();
1564         assert(bool(pStyleSheet)); // who took away my stylesheet?
1565         if (pStyleSheet->GetListenerCount() == 1)
1566         {
1567             SfxItemSet& rItemSet = pStyleSheet->GetItemSet();
1568             rItemSet.Put(*mpFillBitmapItem);
1569             if (mbHasFillBitmap)
1570                 rItemSet.Put(XFillStyleItem(css::drawing::FillStyle_BITMAP));
1571         }
1572     }
1573     else
1574     {
1575         SdrPageProperties &rPageProps = mrPage.getSdrPageProperties();
1576         rPageProps.PutItem(*mpFillBitmapItem);
1577         if (mbHasFillBitmap)
1578             rPageProps.PutItem(XFillStyleItem(css::drawing::FillStyle_BITMAP));
1579     }
1580 }
1581
1582
1583 void SdrUndoNewPage::Undo()
1584 {
1585     ImpRemovePage(nPageNum);
1586     DBG_ASSERT(!bItsMine,"UndoNewPage: mrPage already belongs to UndoAction.");
1587     bItsMine=true;
1588 }
1589
1590 void SdrUndoNewPage::Redo()
1591 {
1592     ImpInsertPage(nPageNum);
1593     DBG_ASSERT(bItsMine,"RedoNewPage: mrPage does not belong to UndoAction.");
1594     bItsMine=false;
1595 }
1596
1597 OUString SdrUndoNewPage::GetComment() const
1598 {
1599     OUString aStr;
1600     ImpTakeDescriptionStr(STR_UndoNewPage,aStr);
1601     return aStr;
1602 }
1603
1604
1605 OUString SdrUndoCopyPage::GetComment() const
1606 {
1607     OUString aStr;
1608     ImpTakeDescriptionStr(STR_UndoCopPage,aStr);
1609     return aStr;
1610 }
1611
1612 OUString SdrUndoCopyPage::GetSdrRepeatComment(SdrView& /*rView*/) const
1613 {
1614     OUString aStr;
1615     ImpTakeDescriptionStr(STR_UndoCopPage,aStr);
1616     return aStr;
1617 }
1618
1619 void SdrUndoCopyPage::SdrRepeat(SdrView& /*rView*/)
1620 {
1621
1622 }
1623
1624 bool SdrUndoCopyPage::CanSdrRepeat(SdrView& /*rView*/) const
1625 {
1626     return false;
1627 }
1628
1629
1630 void SdrUndoSetPageNum::Undo()
1631 {
1632     ImpMovePage(nNewPageNum,nOldPageNum);
1633 }
1634
1635 void SdrUndoSetPageNum::Redo()
1636 {
1637     ImpMovePage(nOldPageNum,nNewPageNum);
1638 }
1639
1640 OUString SdrUndoSetPageNum::GetComment() const
1641 {
1642     OUString aStr;
1643     ImpTakeDescriptionStr(STR_UndoMovPage,aStr);
1644     return aStr;
1645 }
1646
1647 SdrUndoPageMasterPage::SdrUndoPageMasterPage(SdrPage& rChangedPage)
1648     : SdrUndoPage(rChangedPage)
1649     , mbOldHadMasterPage(mrPage.TRG_HasMasterPage())
1650     , maOldMasterPageNumber(0)
1651 {
1652     // get current state from page
1653     if(mbOldHadMasterPage)
1654     {
1655         maOldSet = mrPage.TRG_GetMasterPageVisibleLayers();
1656         maOldMasterPageNumber = mrPage.TRG_GetMasterPage().GetPageNum();
1657     }
1658 }
1659
1660 SdrUndoPageMasterPage::~SdrUndoPageMasterPage()
1661 {
1662 }
1663
1664 SdrUndoPageRemoveMasterPage::SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage)
1665 :   SdrUndoPageMasterPage(rChangedPage)
1666 {
1667 }
1668
1669 void SdrUndoPageRemoveMasterPage::Undo()
1670 {
1671     if(mbOldHadMasterPage)
1672     {
1673         mrPage.TRG_SetMasterPage(*mrPage.GetModel()->GetMasterPage(maOldMasterPageNumber));
1674         mrPage.TRG_SetMasterPageVisibleLayers(maOldSet);
1675     }
1676 }
1677
1678 void SdrUndoPageRemoveMasterPage::Redo()
1679 {
1680     mrPage.TRG_ClearMasterPage();
1681 }
1682
1683 OUString SdrUndoPageRemoveMasterPage::GetComment() const
1684 {
1685     OUString aStr;
1686     ImpTakeDescriptionStr(STR_UndoDelPageMasterDscr,aStr);
1687     return aStr;
1688 }
1689
1690 SdrUndoPageChangeMasterPage::SdrUndoPageChangeMasterPage(SdrPage& rChangedPage)
1691     : SdrUndoPageMasterPage(rChangedPage)
1692     , mbNewHadMasterPage(false)
1693     , maNewMasterPageNumber(0)
1694 {
1695 }
1696
1697 void SdrUndoPageChangeMasterPage::Undo()
1698 {
1699     // remember values from new page
1700     if(mrPage.TRG_HasMasterPage())
1701     {
1702         mbNewHadMasterPage = true;
1703         maNewSet = mrPage.TRG_GetMasterPageVisibleLayers();
1704         maNewMasterPageNumber = mrPage.TRG_GetMasterPage().GetPageNum();
1705     }
1706
1707     // restore old values
1708     if(mbOldHadMasterPage)
1709     {
1710         mrPage.TRG_ClearMasterPage();
1711         mrPage.TRG_SetMasterPage(*mrPage.GetModel()->GetMasterPage(maOldMasterPageNumber));
1712         mrPage.TRG_SetMasterPageVisibleLayers(maOldSet);
1713     }
1714 }
1715
1716 void SdrUndoPageChangeMasterPage::Redo()
1717 {
1718     // restore new values
1719     if(mbNewHadMasterPage)
1720     {
1721         mrPage.TRG_ClearMasterPage();
1722         mrPage.TRG_SetMasterPage(*mrPage.GetModel()->GetMasterPage(maNewMasterPageNumber));
1723         mrPage.TRG_SetMasterPageVisibleLayers(maNewSet);
1724     }
1725 }
1726
1727 OUString SdrUndoPageChangeMasterPage::GetComment() const
1728 {
1729     OUString aStr;
1730     ImpTakeDescriptionStr(STR_UndoChgPageMasterDscr,aStr);
1731     return aStr;
1732 }
1733
1734
1735 SdrUndoFactory::~SdrUndoFactory(){}
1736 // shapes
1737 SdrUndoAction* SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject )
1738 {
1739     return new SdrUndoMoveObj( rObject );
1740 }
1741
1742 SdrUndoAction* SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject, const Size& rDist )
1743 {
1744     return new SdrUndoMoveObj( rObject, rDist );
1745 }
1746
1747 SdrUndoAction* SdrUndoFactory::CreateUndoGeoObject( SdrObject& rObject )
1748 {
1749     return new SdrUndoGeoObj( rObject );
1750 }
1751
1752 SdrUndoAction* SdrUndoFactory::CreateUndoAttrObject( SdrObject& rObject, bool bStyleSheet1, bool bSaveText )
1753 {
1754     return new SdrUndoAttrObj( rObject, bStyleSheet1, bSaveText );
1755 }
1756
1757 SdrUndoAction* SdrUndoFactory::CreateUndoRemoveObject( SdrObject& rObject, bool bOrdNumDirect )
1758 {
1759     return new SdrUndoRemoveObj( rObject, bOrdNumDirect );
1760 }
1761
1762 SdrUndoAction* SdrUndoFactory::CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect )
1763 {
1764     return new SdrUndoInsertObj( rObject, bOrdNumDirect );
1765 }
1766
1767 SdrUndoAction* SdrUndoFactory::CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect )
1768 {
1769     return new SdrUndoDelObj( rObject, bOrdNumDirect );
1770 }
1771
1772 SdrUndoAction* SdrUndoFactory::CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect )
1773 {
1774     return new SdrUndoNewObj( rObject, bOrdNumDirect );
1775 }
1776
1777 SdrUndoAction* SdrUndoFactory::CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect )
1778 {
1779     return new SdrUndoCopyObj( rObject, bOrdNumDirect );
1780 }
1781
1782 SdrUndoAction* SdrUndoFactory::CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1)
1783 {
1784     return new SdrUndoObjOrdNum( rObject, nOldOrdNum1, nNewOrdNum1 );
1785 }
1786
1787 SdrUndoAction* SdrUndoFactory::CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject, bool bOrdNumDirect )
1788 {
1789     return new SdrUndoReplaceObj( rOldObject, rNewObject, bOrdNumDirect );
1790 }
1791
1792 SdrUndoAction* SdrUndoFactory::CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer )
1793 {
1794     return new SdrUndoObjectLayerChange( rObject, aOldLayer, aNewLayer );
1795 }
1796
1797 SdrUndoAction* SdrUndoFactory::CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText )
1798 {
1799     return new SdrUndoObjSetText( rNewObj, nText );
1800 }
1801
1802 SdrUndoAction* SdrUndoFactory::CreateUndoObjectStrAttr( SdrObject& rObject,
1803                                                         SdrUndoObjStrAttr::ObjStrAttrType eObjStrAttrType,
1804                                                         const OUString& sOldStr,
1805                                                         const OUString& sNewStr )
1806 {
1807     return new SdrUndoObjStrAttr( rObject, eObjStrAttrType, sOldStr, sNewStr );
1808 }
1809
1810
1811 // layer
1812 SdrUndoAction* SdrUndoFactory::CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
1813 {
1814     return new SdrUndoNewLayer( nLayerNum, rNewLayerAdmin, rNewModel );
1815 }
1816
1817 SdrUndoAction* SdrUndoFactory::CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
1818 {
1819     return new SdrUndoDelLayer( nLayerNum, rNewLayerAdmin, rNewModel );
1820 }
1821
1822 SdrUndoAction* SdrUndoFactory::CreateUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNewPos1)
1823 {
1824     return new SdrUndoMoveLayer( nLayerNum, rNewLayerAdmin, rNewModel, nNewPos1 );
1825 }
1826
1827 // page
1828 SdrUndoAction*  SdrUndoFactory::CreateUndoDeletePage(SdrPage& rPage)
1829 {
1830     return new SdrUndoDelPage(rPage);
1831 }
1832
1833 SdrUndoAction* SdrUndoFactory::CreateUndoNewPage(SdrPage& rPage)
1834 {
1835     return new SdrUndoNewPage( rPage );
1836 }
1837
1838 SdrUndoAction* SdrUndoFactory::CreateUndoCopyPage(SdrPage& rPage)
1839 {
1840     return new SdrUndoCopyPage( rPage );
1841 }
1842
1843 SdrUndoAction* SdrUndoFactory::CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1)
1844 {
1845     return new SdrUndoSetPageNum( rNewPg, nOldPageNum1, nNewPageNum1 );
1846 }
1847     // master page
1848 SdrUndoAction* SdrUndoFactory::CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage)
1849 {
1850     return new SdrUndoPageRemoveMasterPage( rChangedPage );
1851 }
1852
1853 SdrUndoAction* SdrUndoFactory::CreateUndoPageChangeMasterPage(SdrPage& rChangedPage)
1854 {
1855     return new SdrUndoPageChangeMasterPage(rChangedPage);
1856 }
1857
1858
1859 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */