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