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