sw/source/core/undo/SwUndoFmt.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SwUndoFmt.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33
  34 #include <tools/resid.hxx>
  35 #include <poolfmt.hxx>
  36 #include <charfmt.hxx>
  37 #include <frmfmt.hxx>
  38 #include <SwUndoFmt.hxx>
  39 #include <SwRewriter.hxx>
  40 #include <swundo.hxx>
  41 #include <undobj.hxx>
  42 #include <fmtcol.hxx>
  43 #include <tools/string.hxx>
  44 #include <doc.hxx>
  45 #include <comcore.hrc>
  46
  47 SwUndoFmtCreate::SwUndoFmtCreate
  48 (SwUndoId nUndoId, SwFmt * _pNew, SwFmt * _pDerivedFrom, SwDoc * _pDoc)
  49     : SwUndo(nUndoId), pNew(_pNew),
  50       pDoc(_pDoc), pNewSet(NULL), nId(0), bAuto(FALSE)
  51 {
  52     if (_pDerivedFrom)
  53         sDerivedFrom = _pDerivedFrom->GetName();
  54 }
  55
  56 SwUndoFmtCreate::~SwUndoFmtCreate()
  57 {
  58 }
  59
  60 void SwUndoFmtCreate::Undo(SwUndoIter &)
  61 {
  62     if (pNew)
  63     {
  64         if (sNewName.Len() == 0 && pNew)
  65             sNewName = pNew->GetName();
  66
  67         if (sNewName.Len() > 0)
  68             pNew = Find(sNewName);
  69
  70         if (pNew)
  71         {
  72             pNewSet = new SfxItemSet(pNew->GetAttrSet());
  73             nId = pNew->GetPoolFmtId() & COLL_GET_RANGE_BITS;
  74             bAuto = pNew->IsAuto();
  75
  76             BOOL bDoesUndo = pDoc->DoesUndo();
  77
  78             pDoc->DoUndo(FALSE);
  79             Delete();
  80             pDoc->DoUndo(bDoesUndo);
  81         }
  82     }
  83 }
  84
  85 void SwUndoFmtCreate::Redo(SwUndoIter &)
  86 {
  87     BOOL bDoesUndo = pDoc->DoesUndo();
  88
  89     pDoc->DoUndo(FALSE);
  90     SwFmt * pDerivedFrom = Find(sDerivedFrom);
  91     SwFmt * pFmt = Create(pDerivedFrom);
  92
  93     if (pFmt && pNewSet)
  94     {
  95         pFmt->SetAuto(bAuto);
  96         pDoc->ChgFmt(*pFmt, *pNewSet);
  97         pFmt->SetPoolFmtId((pFmt->GetPoolFmtId()
  98                             & ~COLL_GET_RANGE_BITS)
  99                            | nId);
 100
 101         pNew = pFmt;
 102     }
 103     else
 104         pNew = NULL;
 105
 106     pDoc->DoUndo(bDoesUndo);
 107 }
 108
 109 SwRewriter SwUndoFmtCreate::GetRewriter() const
 110 {
 111     if (sNewName.Len() == 0 && pNew)
 112         sNewName = pNew->GetName();
 113
 114     SwRewriter aRewriter;
 115
 116     aRewriter.AddRule(UNDO_ARG1, sNewName);
 117
 118     return aRewriter;
 119 }
 120
 121 SwUndoFmtDelete::SwUndoFmtDelete
 122 (SwUndoId nUndoId, SwFmt * _pOld, SwDoc * _pDoc)
 123     : SwUndo(nUndoId),
 124       pDoc(_pDoc), sOldName(_pOld->GetName()),
 125       aOldSet(_pOld->GetAttrSet())
 126 {
 127     sDerivedFrom = _pOld->DerivedFrom()->GetName();
 128     nId = _pOld->GetPoolFmtId() & COLL_GET_RANGE_BITS;
 129     bAuto = _pOld->IsAuto();
 130 }
 131
 132 SwUndoFmtDelete::~SwUndoFmtDelete()
 133 {
 134 }
 135
 136 void SwUndoFmtDelete::Undo(SwUndoIter &)
 137 {
 138     BOOL bDoesUndo = pDoc->DoesUndo();
 139
 140     pDoc->DoUndo(FALSE);
 141
 142     SwFmt * pDerivedFrom = Find(sDerivedFrom);
 143
 144     SwFmt * pFmt = Create(pDerivedFrom);
 145
 146     if (pFmt)
 147     {
 148         pDoc->ChgFmt(*pFmt, aOldSet);
 149         pFmt->SetAuto(bAuto);
 150         pFmt->SetPoolFmtId((pFmt->GetPoolFmtId() &
 151                                 ~COLL_GET_RANGE_BITS)
 152                                | nId);
 153
 154     }
 155
 156     pDoc->DoUndo(bDoesUndo);
 157 }
 158
 159 void SwUndoFmtDelete::Redo(SwUndoIter &)
 160 {
 161     SwFmt * pOld = Find(sOldName);
 162
 163     if (pOld)
 164     {
 165         BOOL bDoesUndo = pDoc->DoesUndo();
 166
 167         pDoc->DoUndo(FALSE);
 168         Delete(pOld);
 169         pDoc->DoUndo(bDoesUndo);
 170     }
 171 }
 172
 173 SwRewriter SwUndoFmtDelete::GetRewriter() const
 174 {
 175     SwRewriter aRewriter;
 176
 177     aRewriter.AddRule(UNDO_ARG1, sOldName);
 178
 179     return aRewriter;
 180 }
 181
 182 SwUndoRenameFmt::SwUndoRenameFmt(SwUndoId nUndoId,
 183                                  const String & _sOldName,
 184                                  const String & _sNewName,
 185                                  SwDoc * _pDoc)
 186     : SwUndo(nUndoId), sOldName(_sOldName),
 187       sNewName(_sNewName), pDoc(_pDoc)
 188 {
 189 }
 190
 191
 192 SwUndoRenameFmt::~SwUndoRenameFmt()
 193 {
 194 }
 195
 196 void SwUndoRenameFmt::Undo(SwUndoIter &)
 197 {
 198     SwFmt * pFmt = Find(sNewName);
 199
 200     if (pFmt)
 201     {
 202         BOOL bDoesUndo = pDoc->DoesUndo();
 203
 204         pDoc->DoUndo(FALSE);
 205         pDoc->RenameFmt(*pFmt, sOldName, TRUE);
 206         pDoc->DoUndo(bDoesUndo);
 207     }
 208 }
 209
 210 void SwUndoRenameFmt::Redo(SwUndoIter &)
 211 {
 212     SwFmt *  pFmt = Find(sOldName);
 213
 214     if (pFmt)
 215     {
 216         BOOL bDoesUndo = pDoc->DoesUndo();
 217
 218         pDoc->DoUndo(FALSE);
 219         pDoc->RenameFmt(*pFmt, sNewName, TRUE);
 220         pDoc->DoUndo(bDoesUndo);
 221     }
 222 }
 223
 224 SwRewriter SwUndoRenameFmt::GetRewriter() const
 225 {
 226     SwRewriter aRewriter;
 227
 228     aRewriter.AddRule(UNDO_ARG1, sOldName);
 229     aRewriter.AddRule(UNDO_ARG2, SW_RES(STR_YIELDS));
 230     aRewriter.AddRule(UNDO_ARG3, sNewName);
 231
 232     return aRewriter;
 233 }
 234
 235 SwUndoTxtFmtCollCreate::SwUndoTxtFmtCollCreate
 236 (SwTxtFmtColl * _pNew, SwTxtFmtColl * _pDerivedFrom, SwDoc * _pDoc)
 237     : SwUndoFmtCreate(UNDO_TXTFMTCOL_CREATE, _pNew, _pDerivedFrom, _pDoc)
 238 {
 239 }
 240
 241 SwFmt * SwUndoTxtFmtCollCreate::Create(SwFmt * pDerivedFrom)
 242 {
 243     return pDoc->MakeTxtFmtColl(sNewName, (SwTxtFmtColl *)pDerivedFrom, TRUE);
 244 }
 245
 246 void SwUndoTxtFmtCollCreate::Delete()
 247 {
 248     pDoc->DelTxtFmtColl((SwTxtFmtColl *) pNew, TRUE);
 249 }
 250
 251 SwFmt * SwUndoTxtFmtCollCreate::Find(const String & rName) const
 252 {
 253     return pDoc->FindTxtFmtCollByName(rName);
 254 }
 255
 256 SwUndoTxtFmtCollDelete::SwUndoTxtFmtCollDelete(SwTxtFmtColl * _pOld,
 257                                                SwDoc * _pDoc)
 258     : SwUndoFmtDelete(UNDO_TXTFMTCOL_DELETE, _pOld, _pDoc)
 259 {
 260 }
 261
 262 SwFmt * SwUndoTxtFmtCollDelete::Create(SwFmt * pDerivedFrom)
 263 {
 264     return pDoc->MakeTxtFmtColl(sOldName, (SwTxtFmtColl *) pDerivedFrom, TRUE);
 265 }
 266
 267 void SwUndoTxtFmtCollDelete::Delete(SwFmt * pOld)
 268 {
 269     pDoc->DelTxtFmtColl((SwTxtFmtColl *) pOld, TRUE);
 270 }
 271
 272 SwFmt * SwUndoTxtFmtCollDelete::Find(const String & rName) const
 273 {
 274     return pDoc->FindTxtFmtCollByName(rName);
 275 }
 276
 277 SwUndoRenameFmtColl::SwUndoRenameFmtColl(const String & sInitOldName,
 278                                          const String & sInitNewName,
 279                                          SwDoc * _pDoc)
 280     : SwUndoRenameFmt(UNDO_TXTFMTCOL_RENAME, sInitOldName, sInitNewName, _pDoc)
 281 {
 282 }
 283
 284 SwFmt * SwUndoRenameFmtColl::Find(const String & rName) const
 285 {
 286     return pDoc->FindTxtFmtCollByName(rName);
 287 }
 288
 289 SwUndoCharFmtCreate::SwUndoCharFmtCreate(SwCharFmt * pNewFmt,
 290                                          SwCharFmt * pDerivedFrom,
 291                                          SwDoc * pDocument)
 292     : SwUndoFmtCreate(UNDO_CHARFMT_CREATE, pNewFmt, pDerivedFrom, pDocument)
 293 {
 294 }
 295
 296 SwFmt * SwUndoCharFmtCreate::Create(SwFmt * pDerivedFrom)
 297 {
 298     return pDoc->MakeCharFmt(sNewName, (SwCharFmt *) pDerivedFrom, TRUE);
 299 }
 300
 301 void SwUndoCharFmtCreate::Delete()
 302 {
 303     pDoc->DelCharFmt((SwCharFmt *) pNew, TRUE);
 304 }
 305
 306 SwFmt * SwUndoCharFmtCreate::Find(const String & rName) const
 307 {
 308     return pDoc->FindCharFmtByName(rName);
 309 }
 310
 311 SwUndoCharFmtDelete::SwUndoCharFmtDelete(SwCharFmt * pOld, SwDoc * pDocument)
 312     : SwUndoFmtDelete(UNDO_CHARFMT_DELETE, pOld, pDocument)
 313 {
 314 }
 315
 316 SwFmt * SwUndoCharFmtDelete::Create(SwFmt * pDerivedFrom)
 317 {
 318     return pDoc->MakeCharFmt(sOldName, (SwCharFmt *) pDerivedFrom, TRUE);
 319 }
 320
 321 void SwUndoCharFmtDelete::Delete(SwFmt * pFmt)
 322 {
 323     pDoc->DelCharFmt((SwCharFmt *) pFmt, TRUE);
 324 }
 325
 326 SwFmt * SwUndoCharFmtDelete::Find(const String & rName) const
 327 {
 328     return pDoc->FindCharFmtByName(rName);
 329 }
 330
 331 SwUndoRenameCharFmt::SwUndoRenameCharFmt(const String & sInitOldName,
 332                                          const String & sInitNewName,
 333                                          SwDoc * pDocument)
 334     : SwUndoRenameFmt(UNDO_CHARFMT_RENAME, sInitOldName, sInitNewName, pDocument)
 335 {
 336 }
 337
 338 SwFmt * SwUndoRenameCharFmt::Find(const String & rName) const
 339 {
 340     return pDoc->FindCharFmtByName(rName);
 341 }
 342
 343 SwUndoFrmFmtCreate::SwUndoFrmFmtCreate(SwFrmFmt * pNewFmt,
 344                                        SwFrmFmt * pDerivedFrom,
 345                                        SwDoc * pDocument)
 346     : SwUndoFmtCreate(UNDO_FRMFMT_CREATE, pNewFmt, pDerivedFrom, pDocument),
 347       bAuto(pNewFmt->IsAuto())
 348 {
 349 }
 350
 351 SwFmt * SwUndoFrmFmtCreate::Create(SwFmt * pDerivedFrom)
 352 {
 353     return pDoc->MakeFrmFmt(sNewName, (SwFrmFmt *) pDerivedFrom, TRUE, bAuto);
 354 }
 355
 356 void SwUndoFrmFmtCreate::Delete()
 357 {
 358     pDoc->DelFrmFmt((SwFrmFmt *) pNew, TRUE);
 359 }
 360
 361 SwFmt * SwUndoFrmFmtCreate::Find(const String & rName) const
 362 {
 363     return pDoc->FindFrmFmtByName(rName);
 364 }
 365
 366 SwUndoFrmFmtDelete::SwUndoFrmFmtDelete(SwFrmFmt * pOld, SwDoc * pDocument)
 367     : SwUndoFmtDelete(UNDO_FRMFMT_DELETE, pOld, pDocument)
 368 {
 369 }
 370
 371 SwFmt * SwUndoFrmFmtDelete::Create(SwFmt * pDerivedFrom)
 372 {
 373     return pDoc->MakeFrmFmt(sOldName, (SwFrmFmt *) pDerivedFrom, TRUE);
 374 }
 375
 376 void SwUndoFrmFmtDelete::Delete(SwFmt * pFmt)
 377 {
 378     pDoc->DelFrmFmt((SwFrmFmt *) pFmt, TRUE);
 379 }
 380
 381 SwFmt * SwUndoFrmFmtDelete::Find(const String & rName) const
 382 {
 383     return pDoc->FindFrmFmtByName(rName);
 384 }
 385
 386 SwUndoRenameFrmFmt::SwUndoRenameFrmFmt(const String & sInitOldName,
 387                                        const String & sInitNewName,
 388                                        SwDoc * pDocument)
 389     : SwUndoRenameFmt(UNDO_FRMFMT_RENAME, sInitOldName, sInitNewName, pDocument)
 390 {
 391 }
 392
 393 SwFmt * SwUndoRenameFrmFmt::Find(const String & rName) const
 394 {
 395     return pDoc->FindFrmFmtByName(rName);
 396 }
 397
 398 SwUndoNumruleCreate::SwUndoNumruleCreate(const SwNumRule * _pNew,
 399                                          SwDoc * _pDoc)
 400     : SwUndo(UNDO_NUMRULE_CREATE), pNew(_pNew), aNew(*_pNew), pDoc(_pDoc),
 401       bInitialized(false)
 402 {
 403 }
 404
 405 void SwUndoNumruleCreate::Undo(SwUndoIter &)
 406 {
 407     BOOL bDoesUndo = pDoc->DoesUndo();
 408
 409     pDoc->DoUndo(FALSE);
 410
 411     if (! bInitialized)
 412     {
 413         aNew = *pNew;
 414         bInitialized = true;
 415     }
 416
 417     pDoc->DelNumRule(aNew.GetName(), TRUE);
 418     pDoc->DoUndo(bDoesUndo);
 419 }
 420
 421 void SwUndoNumruleCreate::Redo(SwUndoIter &)
 422 {
 423     BOOL bDoesUndo = pDoc->DoesUndo();
 424
 425     pDoc->DoUndo(FALSE);
 426     pDoc->MakeNumRule(aNew.GetName(), &aNew, TRUE);
 427     pDoc->DoUndo(bDoesUndo);
 428 }
 429
 430 SwRewriter SwUndoNumruleCreate::GetRewriter() const
 431 {
 432     SwRewriter aResult;
 433
 434     if (! bInitialized)
 435     {
 436         aNew = *pNew;
 437         bInitialized = true;
 438     }
 439
 440     aResult.AddRule(UNDO_ARG1, aNew.GetName());
 441
 442     return aResult;
 443 }
 444
 445 SwUndoNumruleDelete::SwUndoNumruleDelete(const SwNumRule & rRule,
 446                                          SwDoc * _pDoc)
 447     : SwUndo(UNDO_NUMRULE_DELETE), aOld(rRule), pDoc(_pDoc)
 448 {
 449 }
 450
 451 void SwUndoNumruleDelete::Undo(SwUndoIter &)
 452 {
 453     BOOL bDoesUndo = pDoc->DoesUndo();
 454
 455     pDoc->DoUndo(FALSE);
 456     pDoc->MakeNumRule(aOld.GetName(), &aOld, TRUE);
 457     pDoc->DoUndo(bDoesUndo);
 458 }
 459
 460 void SwUndoNumruleDelete::Redo(SwUndoIter &)
 461 {
 462     BOOL bDoesUndo = pDoc->DoesUndo();
 463
 464     pDoc->DoUndo(FALSE);
 465     pDoc->DelNumRule(aOld.GetName(), TRUE);
 466     pDoc->DoUndo(bDoesUndo);
 467 }
 468
 469 SwRewriter SwUndoNumruleDelete::GetRewriter() const
 470 {
 471     SwRewriter aResult;
 472
 473     aResult.AddRule(UNDO_ARG1, aOld.GetName());
 474
 475     return aResult;
 476 }
 477
 478 SwUndoNumruleRename::SwUndoNumruleRename(const String & _aOldName,
 479                                          const String & _aNewName,
 480                                          SwDoc * _pDoc)
 481     : SwUndo(UNDO_NUMRULE_RENAME), aOldName(_aOldName), aNewName(_aNewName),
 482       pDoc(_pDoc)
 483 {
 484 }
 485
 486 void SwUndoNumruleRename::Undo(SwUndoIter &)
 487 {
 488     BOOL bDoesUndo = pDoc->DoesUndo();
 489
 490     pDoc->DoUndo(FALSE);
 491     pDoc->RenameNumRule(aNewName, aOldName, TRUE);
 492     pDoc->DoUndo(bDoesUndo);
 493 }
 494
 495 void SwUndoNumruleRename::Redo(SwUndoIter &)
 496 {
 497     BOOL bDoesUndo = pDoc->DoesUndo();
 498
 499     pDoc->DoUndo(FALSE);
 500     pDoc->RenameNumRule(aOldName, aNewName, TRUE);
 501     pDoc->DoUndo(bDoesUndo);
 502 }
 503
 504 SwRewriter SwUndoNumruleRename::GetRewriter() const
 505 {
 506     SwRewriter aRewriter;
 507
 508     aRewriter.AddRule(UNDO_ARG1, aOldName);
 509     aRewriter.AddRule(UNDO_ARG2, SW_RES(STR_YIELDS));
 510     aRewriter.AddRule(UNDO_ARG3, aNewName);
 511
 512     return aRewriter;
 513 }