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