sw/source/core/undo/SwUndoFmt.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 <tools/resid.hxx>
  22 #include <tools/string.hxx>
  23
  24 #include <poolfmt.hxx>
  25 #include <charfmt.hxx>
  26 #include <frmfmt.hxx>
  27 #include <SwUndoFmt.hxx>
  28 #include <SwRewriter.hxx>
  29 #include <swundo.hxx>
  30 #include <undobj.hxx>
  31 #include <fmtcol.hxx>
  32 #include <doc.hxx>
  33 #include <IDocumentUndoRedo.hxx>
  34 #include <comcore.hrc>
  35
  36 SwUndoFmtCreate::SwUndoFmtCreate
  37 (SwUndoId nUndoId, SwFmt * _pNew, SwFmt * _pDerivedFrom, SwDoc * _pDoc)
  38     : SwUndo(nUndoId), pNew(_pNew),
  39       pDoc(_pDoc), pNewSet(NULL), nId(0), bAuto(sal_False)
  40 {
  41     if (_pDerivedFrom)
  42         sDerivedFrom = _pDerivedFrom->GetName();
  43 }
  44
  45 SwUndoFmtCreate::~SwUndoFmtCreate()
  46 {
  47 }
  48
  49 void SwUndoFmtCreate::UndoImpl(::sw::UndoRedoContext &)
  50 {
  51     if (pNew)
  52     {
  53         if (sNewName.Len() == 0 && pNew)
  54             sNewName = pNew->GetName();
  55
  56         if (sNewName.Len() > 0)
  57             pNew = Find(sNewName);
  58
  59         if (pNew)
  60         {
  61             pNewSet = new SfxItemSet(pNew->GetAttrSet());
  62             nId = pNew->GetPoolFmtId() & COLL_GET_RANGE_BITS;
  63             bAuto = pNew->IsAuto();
  64
  65             Delete();
  66         }
  67     }
  68 }
  69
  70 void SwUndoFmtCreate::RedoImpl(::sw::UndoRedoContext &)
  71 {
  72     SwFmt * pDerivedFrom = Find(sDerivedFrom);
  73     SwFmt * pFmt = Create(pDerivedFrom);
  74
  75     if (pFmt && pNewSet)
  76     {
  77         pFmt->SetAuto(bAuto);
  78         pDoc->ChgFmt(*pFmt, *pNewSet);
  79         pFmt->SetPoolFmtId((pFmt->GetPoolFmtId()
  80                             & ~COLL_GET_RANGE_BITS)
  81                            | nId);
  82
  83         pNew = pFmt;
  84     }
  85     else
  86         pNew = NULL;
  87 }
  88
  89 SwRewriter SwUndoFmtCreate::GetRewriter() const
  90 {
  91     if (sNewName.Len() == 0 && pNew)
  92         sNewName = pNew->GetName();
  93
  94     SwRewriter aRewriter;
  95
  96     aRewriter.AddRule(UndoArg1, sNewName);
  97
  98     return aRewriter;
  99 }
 100
 101 SwUndoFmtDelete::SwUndoFmtDelete
 102 (SwUndoId nUndoId, SwFmt * _pOld, SwDoc * _pDoc)
 103     : SwUndo(nUndoId),
 104       pDoc(_pDoc), sOldName(_pOld->GetName()),
 105       aOldSet(_pOld->GetAttrSet())
 106 {
 107     sDerivedFrom = _pOld->DerivedFrom()->GetName();
 108     nId = _pOld->GetPoolFmtId() & COLL_GET_RANGE_BITS;
 109     bAuto = _pOld->IsAuto();
 110 }
 111
 112 SwUndoFmtDelete::~SwUndoFmtDelete()
 113 {
 114 }
 115
 116 void SwUndoFmtDelete::UndoImpl(::sw::UndoRedoContext &)
 117 {
 118     SwFmt * pDerivedFrom = Find(sDerivedFrom);
 119
 120     SwFmt * pFmt = Create(pDerivedFrom);
 121
 122     if (pFmt)
 123     {
 124         pDoc->ChgFmt(*pFmt, aOldSet);
 125         pFmt->SetAuto(bAuto);
 126         pFmt->SetPoolFmtId((pFmt->GetPoolFmtId() &
 127                                 ~COLL_GET_RANGE_BITS)
 128                                | nId);
 129     }
 130 }
 131
 132 void SwUndoFmtDelete::RedoImpl(::sw::UndoRedoContext &)
 133 {
 134     SwFmt * pOld = Find(sOldName);
 135
 136     if (pOld)
 137     {
 138         Delete(pOld);
 139     }
 140 }
 141
 142 SwRewriter SwUndoFmtDelete::GetRewriter() const
 143 {
 144     SwRewriter aRewriter;
 145
 146     aRewriter.AddRule(UndoArg1, sOldName);
 147
 148     return aRewriter;
 149 }
 150
 151 SwUndoRenameFmt::SwUndoRenameFmt(SwUndoId nUndoId,
 152                                  const String & _sOldName,
 153                                  const String & _sNewName,
 154                                  SwDoc * _pDoc)
 155     : SwUndo(nUndoId), sOldName(_sOldName),
 156       sNewName(_sNewName), pDoc(_pDoc)
 157 {
 158 }
 159
 160
 161 SwUndoRenameFmt::~SwUndoRenameFmt()
 162 {
 163 }
 164
 165 void SwUndoRenameFmt::UndoImpl(::sw::UndoRedoContext &)
 166 {
 167     SwFmt * pFmt = Find(sNewName);
 168
 169     if (pFmt)
 170     {
 171         pDoc->RenameFmt(*pFmt, sOldName, true);
 172     }
 173 }
 174
 175 void SwUndoRenameFmt::RedoImpl(::sw::UndoRedoContext &)
 176 {
 177     SwFmt *  pFmt = Find(sOldName);
 178
 179     if (pFmt)
 180     {
 181         pDoc->RenameFmt(*pFmt, sNewName, true);
 182     }
 183 }
 184
 185 SwRewriter SwUndoRenameFmt::GetRewriter() const
 186 {
 187     SwRewriter aRewriter;
 188
 189     aRewriter.AddRule(UndoArg1, sOldName);
 190     aRewriter.AddRule(UndoArg2, SW_RES(STR_YIELDS));
 191     aRewriter.AddRule(UndoArg3, sNewName);
 192
 193     return aRewriter;
 194 }
 195
 196 SwUndoTxtFmtCollCreate::SwUndoTxtFmtCollCreate
 197 (SwTxtFmtColl * _pNew, SwTxtFmtColl * _pDerivedFrom, SwDoc * _pDoc)
 198     : SwUndoFmtCreate(UNDO_TXTFMTCOL_CREATE, _pNew, _pDerivedFrom, _pDoc)
 199 {
 200 }
 201
 202 SwFmt * SwUndoTxtFmtCollCreate::Create(SwFmt * pDerivedFrom)
 203 {
 204     return pDoc->MakeTxtFmtColl(sNewName, (SwTxtFmtColl *)pDerivedFrom, sal_True);
 205 }
 206
 207 void SwUndoTxtFmtCollCreate::Delete()
 208 {
 209     pDoc->DelTxtFmtColl((SwTxtFmtColl *) pNew, true);
 210 }
 211
 212 SwFmt * SwUndoTxtFmtCollCreate::Find(const String & rName) const
 213 {
 214     return pDoc->FindTxtFmtCollByName(rName);
 215 }
 216
 217 SwUndoTxtFmtCollDelete::SwUndoTxtFmtCollDelete(SwTxtFmtColl * _pOld,
 218                                                SwDoc * _pDoc)
 219     : SwUndoFmtDelete(UNDO_TXTFMTCOL_DELETE, _pOld, _pDoc)
 220 {
 221 }
 222
 223 SwFmt * SwUndoTxtFmtCollDelete::Create(SwFmt * pDerivedFrom)
 224 {
 225     return pDoc->MakeTxtFmtColl(sOldName, (SwTxtFmtColl *) pDerivedFrom, sal_True);
 226 }
 227
 228 void SwUndoTxtFmtCollDelete::Delete(SwFmt * pOld)
 229 {
 230     pDoc->DelTxtFmtColl((SwTxtFmtColl *) pOld, true);
 231 }
 232
 233 SwFmt * SwUndoTxtFmtCollDelete::Find(const String & rName) const
 234 {
 235     return pDoc->FindTxtFmtCollByName(rName);
 236 }
 237
 238 SwUndoRenameFmtColl::SwUndoRenameFmtColl(const String & sInitOldName,
 239                                          const String & sInitNewName,
 240                                          SwDoc * _pDoc)
 241     : SwUndoRenameFmt(UNDO_TXTFMTCOL_RENAME, sInitOldName, sInitNewName, _pDoc)
 242 {
 243 }
 244
 245 SwFmt * SwUndoRenameFmtColl::Find(const String & rName) const
 246 {
 247     return pDoc->FindTxtFmtCollByName(rName);
 248 }
 249
 250 SwUndoCharFmtCreate::SwUndoCharFmtCreate(SwCharFmt * pNewFmt,
 251                                          SwCharFmt * pDerivedFrom,
 252                                          SwDoc * pDocument)
 253     : SwUndoFmtCreate(UNDO_CHARFMT_CREATE, pNewFmt, pDerivedFrom, pDocument)
 254 {
 255 }
 256
 257 SwFmt * SwUndoCharFmtCreate::Create(SwFmt * pDerivedFrom)
 258 {
 259     return pDoc->MakeCharFmt(sNewName, (SwCharFmt *) pDerivedFrom, true);
 260 }
 261
 262 void SwUndoCharFmtCreate::Delete()
 263 {
 264     pDoc->DelCharFmt((SwCharFmt *) pNew, true);
 265 }
 266
 267 SwFmt * SwUndoCharFmtCreate::Find(const String & rName) const
 268 {
 269     return pDoc->FindCharFmtByName(rName);
 270 }
 271
 272 SwUndoCharFmtDelete::SwUndoCharFmtDelete(SwCharFmt * pOld, SwDoc * pDocument)
 273     : SwUndoFmtDelete(UNDO_CHARFMT_DELETE, pOld, pDocument)
 274 {
 275 }
 276
 277 SwFmt * SwUndoCharFmtDelete::Create(SwFmt * pDerivedFrom)
 278 {
 279     return pDoc->MakeCharFmt(sOldName, (SwCharFmt *) pDerivedFrom, true);
 280 }
 281
 282 void SwUndoCharFmtDelete::Delete(SwFmt * pFmt)
 283 {
 284     pDoc->DelCharFmt((SwCharFmt *) pFmt, true);
 285 }
 286
 287 SwFmt * SwUndoCharFmtDelete::Find(const String & rName) const
 288 {
 289     return pDoc->FindCharFmtByName(rName);
 290 }
 291
 292 SwUndoRenameCharFmt::SwUndoRenameCharFmt(const String & sInitOldName,
 293                                          const String & sInitNewName,
 294                                          SwDoc * pDocument)
 295     : SwUndoRenameFmt(UNDO_CHARFMT_RENAME, sInitOldName, sInitNewName, pDocument)
 296 {
 297 }
 298
 299 SwFmt * SwUndoRenameCharFmt::Find(const String & rName) const
 300 {
 301     return pDoc->FindCharFmtByName(rName);
 302 }
 303
 304 SwUndoFrmFmtCreate::SwUndoFrmFmtCreate(SwFrmFmt * pNewFmt,
 305                                        SwFrmFmt * pDerivedFrom,
 306                                        SwDoc * pDocument)
 307     : SwUndoFmtCreate(UNDO_FRMFMT_CREATE, pNewFmt, pDerivedFrom, pDocument),
 308       bAuto(pNewFmt->IsAuto())
 309 {
 310 }
 311
 312 SwFmt * SwUndoFrmFmtCreate::Create(SwFmt * pDerivedFrom)
 313 {
 314     return pDoc->MakeFrmFmt(sNewName, (SwFrmFmt *) pDerivedFrom, true, bAuto);
 315 }
 316
 317 void SwUndoFrmFmtCreate::Delete()
 318 {
 319     pDoc->DelFrmFmt((SwFrmFmt *) pNew, true);
 320 }
 321
 322 SwFmt * SwUndoFrmFmtCreate::Find(const String & rName) const
 323 {
 324     return pDoc->FindFrmFmtByName(rName);
 325 }
 326
 327 SwUndoFrmFmtDelete::SwUndoFrmFmtDelete(SwFrmFmt * pOld, SwDoc * pDocument)
 328     : SwUndoFmtDelete(UNDO_FRMFMT_DELETE, pOld, pDocument)
 329 {
 330 }
 331
 332 SwFmt * SwUndoFrmFmtDelete::Create(SwFmt * pDerivedFrom)
 333 {
 334     return pDoc->MakeFrmFmt(sOldName, (SwFrmFmt *) pDerivedFrom, true);
 335 }
 336
 337 void SwUndoFrmFmtDelete::Delete(SwFmt * pFmt)
 338 {
 339     pDoc->DelFrmFmt((SwFrmFmt *) pFmt, true);
 340 }
 341
 342 SwFmt * SwUndoFrmFmtDelete::Find(const String & rName) const
 343 {
 344     return pDoc->FindFrmFmtByName(rName);
 345 }
 346
 347 SwUndoRenameFrmFmt::SwUndoRenameFrmFmt(const String & sInitOldName,
 348                                        const String & sInitNewName,
 349                                        SwDoc * pDocument)
 350     : SwUndoRenameFmt(UNDO_FRMFMT_RENAME, sInitOldName, sInitNewName, pDocument)
 351 {
 352 }
 353
 354 SwFmt * SwUndoRenameFrmFmt::Find(const String & rName) const
 355 {
 356     return pDoc->FindFrmFmtByName(rName);
 357 }
 358
 359 SwUndoNumruleCreate::SwUndoNumruleCreate(const SwNumRule * _pNew,
 360                                          SwDoc * _pDoc)
 361     : SwUndo(UNDO_NUMRULE_CREATE), pNew(_pNew), aNew(*_pNew), pDoc(_pDoc),
 362       bInitialized(false)
 363 {
 364 }
 365
 366 void SwUndoNumruleCreate::UndoImpl(::sw::UndoRedoContext &)
 367 {
 368     if (! bInitialized)
 369     {
 370         aNew = *pNew;
 371         bInitialized = true;
 372     }
 373
 374     pDoc->DelNumRule(aNew.GetName(), true);
 375 }
 376
 377 void SwUndoNumruleCreate::RedoImpl(::sw::UndoRedoContext &)
 378 {
 379     pDoc->MakeNumRule(aNew.GetName(), &aNew, true);
 380 }
 381
 382 SwRewriter SwUndoNumruleCreate::GetRewriter() const
 383 {
 384     SwRewriter aResult;
 385
 386     if (! bInitialized)
 387     {
 388         aNew = *pNew;
 389         bInitialized = true;
 390     }
 391
 392     aResult.AddRule(UndoArg1, aNew.GetName());
 393
 394     return aResult;
 395 }
 396
 397 SwUndoNumruleDelete::SwUndoNumruleDelete(const SwNumRule & rRule,
 398                                          SwDoc * _pDoc)
 399     : SwUndo(UNDO_NUMRULE_DELETE), aOld(rRule), pDoc(_pDoc)
 400 {
 401 }
 402
 403 void SwUndoNumruleDelete::UndoImpl(::sw::UndoRedoContext &)
 404 {
 405     pDoc->MakeNumRule(aOld.GetName(), &aOld, true);
 406 }
 407
 408 void SwUndoNumruleDelete::RedoImpl(::sw::UndoRedoContext &)
 409 {
 410     pDoc->DelNumRule(aOld.GetName(), true);
 411 }
 412
 413 SwRewriter SwUndoNumruleDelete::GetRewriter() const
 414 {
 415     SwRewriter aResult;
 416
 417     aResult.AddRule(UndoArg1, aOld.GetName());
 418
 419     return aResult;
 420 }
 421
 422 SwUndoNumruleRename::SwUndoNumruleRename(const String & _aOldName,
 423                                          const String & _aNewName,
 424                                          SwDoc * _pDoc)
 425     : SwUndo(UNDO_NUMRULE_RENAME), aOldName(_aOldName), aNewName(_aNewName),
 426       pDoc(_pDoc)
 427 {
 428 }
 429
 430 void SwUndoNumruleRename::UndoImpl(::sw::UndoRedoContext &)
 431 {
 432     pDoc->RenameNumRule(aNewName, aOldName, true);
 433 }
 434
 435 void SwUndoNumruleRename::RedoImpl(::sw::UndoRedoContext &)
 436 {
 437     pDoc->RenameNumRule(aOldName, aNewName, true);
 438 }
 439
 440 SwRewriter SwUndoNumruleRename::GetRewriter() const
 441 {
 442     SwRewriter aRewriter;
 443
 444     aRewriter.AddRule(UndoArg1, aOldName);
 445     aRewriter.AddRule(UndoArg2, SW_RESSTR(STR_YIELDS));
 446     aRewriter.AddRule(UndoArg3, aNewName);
 447
 448     return aRewriter;
 449 }
 450
 451 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */