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 #include <poolfmt.hxx>
  21 #include <charfmt.hxx>
  22 #include <frmfmt.hxx>
  23 #include <SwUndoFmt.hxx>
  24 #include <SwRewriter.hxx>
  25 #include <swundo.hxx>
  26 #include <undobj.hxx>
  27 #include <fmtcol.hxx>
  28 #include <doc.hxx>
  29 #include <strings.hrc>
  30 #include <utility>
  31
  32 SwUndoFormatCreate::SwUndoFormatCreate
  33 (SwUndoId nUndoId, SwFormat * _pNew, SwFormat const * _pDerivedFrom, SwDoc& rDoc)
  34     : SwUndo(nUndoId, &rDoc), m_pNew(_pNew),
  35       m_rDoc(rDoc), m_nId(0), m_bAuto(false)
  36 {
  37     if (_pDerivedFrom)
  38         m_sDerivedFrom = _pDerivedFrom->GetName();
  39 }
  40
  41 SwUndoFormatCreate::~SwUndoFormatCreate()
  42 {
  43 }
  44
  45 void SwUndoFormatCreate::UndoImpl(::sw::UndoRedoContext &)
  46 {
  47     if (!m_pNew)
  48         return;
  49
  50     if (m_sNewName.isEmpty())
  51         m_sNewName = m_pNew->GetName();
  52
  53     if (!m_sNewName.isEmpty())
  54         m_pNew = Find(m_sNewName);
  55
  56     if (m_pNew)
  57     {
  58         m_pNewSet.reset(new SfxItemSet(m_pNew->GetAttrSet()));
  59         m_nId = m_pNew->GetPoolFormatId() & COLL_GET_RANGE_BITS;
  60         m_bAuto = m_pNew->IsAuto();
  61
  62         Delete();
  63     }
  64 }
  65
  66 void SwUndoFormatCreate::RedoImpl(::sw::UndoRedoContext &)
  67 {
  68     SwFormat * pDerivedFrom = Find(m_sDerivedFrom);
  69     SwFormat * pFormat = Create(pDerivedFrom);
  70
  71     if (pFormat && m_pNewSet)
  72     {
  73         pFormat->SetAuto(m_bAuto);
  74         m_rDoc.ChgFormat(*pFormat, *m_pNewSet);
  75         pFormat->SetPoolFormatId((pFormat->GetPoolFormatId()
  76                             & ~COLL_GET_RANGE_BITS)
  77                            | m_nId);
  78
  79         m_pNew = pFormat;
  80     }
  81     else
  82         m_pNew = nullptr;
  83 }
  84
  85 SwRewriter SwUndoFormatCreate::GetRewriter() const
  86 {
  87     if (m_sNewName.isEmpty() && m_pNew)
  88         m_sNewName = m_pNew->GetName();
  89
  90     SwRewriter aRewriter;
  91
  92     aRewriter.AddRule(UndoArg1, m_sNewName);
  93
  94     return aRewriter;
  95 }
  96
  97 SwUndoFormatDelete::SwUndoFormatDelete
  98 (SwUndoId nUndoId, SwFormat const * _pOld, SwDoc& rDoc)
  99     : SwUndo(nUndoId, &rDoc),
 100       m_rDoc(rDoc), m_sOldName(_pOld->GetName()),
 101       m_aOldSet(_pOld->GetAttrSet())
 102 {
 103     m_sDerivedFrom = _pOld->DerivedFrom()->GetName();
 104     m_nId = _pOld->GetPoolFormatId() & COLL_GET_RANGE_BITS;
 105     m_bAuto = _pOld->IsAuto();
 106 }
 107
 108 SwUndoFormatDelete::~SwUndoFormatDelete()
 109 {
 110 }
 111
 112 void SwUndoFormatDelete::UndoImpl(::sw::UndoRedoContext &)
 113 {
 114     SwFormat * pDerivedFrom = Find(m_sDerivedFrom);
 115
 116     SwFormat * pFormat = Create(pDerivedFrom);
 117
 118     if (pFormat)
 119     {
 120         m_rDoc.ChgFormat(*pFormat, m_aOldSet);
 121         pFormat->SetAuto(m_bAuto);
 122         pFormat->SetPoolFormatId((pFormat->GetPoolFormatId() &
 123                                 ~COLL_GET_RANGE_BITS)
 124                                | m_nId);
 125     }
 126 }
 127
 128 void SwUndoFormatDelete::RedoImpl(::sw::UndoRedoContext &)
 129 {
 130     SwFormat * pOld = Find(m_sOldName);
 131
 132     if (pOld)
 133     {
 134         Delete(pOld);
 135     }
 136 }
 137
 138 SwRewriter SwUndoFormatDelete::GetRewriter() const
 139 {
 140     SwRewriter aRewriter;
 141
 142     aRewriter.AddRule(UndoArg1, m_sOldName);
 143
 144     return aRewriter;
 145 }
 146
 147 SwUndoRenameFormat::SwUndoRenameFormat(SwUndoId nUndoId,
 148                                  OUString _sOldName,
 149                                  OUString _sNewName,
 150                                  SwDoc& rDoc)
 151     : SwUndo(nUndoId, &rDoc), m_sOldName(std::move(_sOldName)),
 152       m_sNewName(std::move(_sNewName)), m_rDoc(rDoc)
 153 {
 154 }
 155
 156 SwUndoRenameFormat::~SwUndoRenameFormat()
 157 {
 158 }
 159
 160 void SwUndoRenameFormat::UndoImpl(::sw::UndoRedoContext &)
 161 {
 162     SwFormat * pFormat = Find(m_sNewName);
 163
 164     if (pFormat)
 165     {
 166         m_rDoc.RenameFormat(*pFormat, m_sOldName, true);
 167     }
 168 }
 169
 170 void SwUndoRenameFormat::RedoImpl(::sw::UndoRedoContext &)
 171 {
 172     SwFormat *  pFormat = Find(m_sOldName);
 173
 174     if (pFormat)
 175     {
 176         m_rDoc.RenameFormat(*pFormat, m_sNewName, true);
 177     }
 178 }
 179
 180 SwRewriter SwUndoRenameFormat::GetRewriter() const
 181 {
 182     SwRewriter aRewriter;
 183
 184     aRewriter.AddRule(UndoArg1, m_sOldName);
 185     aRewriter.AddRule(UndoArg2, SwResId(STR_YIELDS));
 186     aRewriter.AddRule(UndoArg3, m_sNewName);
 187
 188     return aRewriter;
 189 }
 190
 191 SwUndoTextFormatCollCreate::SwUndoTextFormatCollCreate
 192 (SwTextFormatColl * _pNew, SwTextFormatColl const * _pDerivedFrom, SwDoc& rDoc)
 193     : SwUndoFormatCreate(SwUndoId::TXTFMTCOL_CREATE, _pNew, _pDerivedFrom, rDoc)
 194 {
 195 }
 196
 197 SwFormat * SwUndoTextFormatCollCreate::Create(SwFormat * pDerivedFrom)
 198 {
 199     return m_rDoc.MakeTextFormatColl(m_sNewName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
 200 }
 201
 202 void SwUndoTextFormatCollCreate::Delete()
 203 {
 204     m_rDoc.DelTextFormatColl(static_cast<SwTextFormatColl *>(m_pNew), true);
 205 }
 206
 207 SwFormat * SwUndoTextFormatCollCreate::Find(const OUString & rName) const
 208 {
 209     return m_rDoc.FindTextFormatCollByName(rName);
 210 }
 211
 212 SwUndoTextFormatCollDelete::SwUndoTextFormatCollDelete(SwTextFormatColl const * _pOld,
 213                                                SwDoc& rDoc)
 214     : SwUndoFormatDelete(SwUndoId::TXTFMTCOL_DELETE, _pOld, rDoc)
 215 {
 216 }
 217
 218 SwFormat * SwUndoTextFormatCollDelete::Create(SwFormat * pDerivedFrom)
 219 {
 220     return m_rDoc.MakeTextFormatColl(m_sOldName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
 221 }
 222
 223 void SwUndoTextFormatCollDelete::Delete(SwFormat * pOld)
 224 {
 225     m_rDoc.DelTextFormatColl(static_cast<SwTextFormatColl *>(pOld), true);
 226 }
 227
 228 SwFormat * SwUndoTextFormatCollDelete::Find(const OUString & rName) const
 229 {
 230     return m_rDoc.FindTextFormatCollByName(rName);
 231 }
 232
 233 SwUndoCondTextFormatCollCreate::SwUndoCondTextFormatCollCreate(SwConditionTextFormatColl *_pNew,
 234     SwTextFormatColl const *_pDerivedFrom, SwDoc& rDoc)
 235     : SwUndoTextFormatCollCreate(_pNew, _pDerivedFrom, rDoc)
 236 {
 237 }
 238
 239 SwFormat * SwUndoCondTextFormatCollCreate::Create(SwFormat * pDerivedFrom)
 240 {
 241     return m_rDoc.MakeCondTextFormatColl(m_sNewName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
 242 }
 243
 244 SwUndoCondTextFormatCollDelete::SwUndoCondTextFormatCollDelete(SwTextFormatColl const * _pOld,
 245                                                                SwDoc& rDoc)
 246     : SwUndoTextFormatCollDelete(_pOld, rDoc)
 247 {
 248 }
 249
 250 SwFormat * SwUndoCondTextFormatCollDelete::Create(SwFormat * pDerivedFrom)
 251 {
 252     return m_rDoc.MakeCondTextFormatColl(m_sOldName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
 253 }
 254
 255 SwUndoRenameFormatColl::SwUndoRenameFormatColl(const OUString & sInitOldName,
 256                                          const OUString & sInitNewName,
 257                                          SwDoc& rDoc)
 258     : SwUndoRenameFormat(SwUndoId::TXTFMTCOL_RENAME, sInitOldName, sInitNewName, rDoc)
 259 {
 260 }
 261
 262 SwFormat * SwUndoRenameFormatColl::Find(const OUString & rName) const
 263 {
 264     return m_rDoc.FindTextFormatCollByName(rName);
 265 }
 266
 267 SwUndoCharFormatCreate::SwUndoCharFormatCreate(SwCharFormat * pNewFormat,
 268                                          SwCharFormat const * pDerivedFrom,
 269                                          SwDoc& rDocument)
 270     : SwUndoFormatCreate(SwUndoId::CHARFMT_CREATE, pNewFormat, pDerivedFrom, rDocument)
 271 {
 272 }
 273
 274 SwFormat * SwUndoCharFormatCreate::Create(SwFormat * pDerivedFrom)
 275 {
 276     return m_rDoc.MakeCharFormat(m_sNewName, static_cast<SwCharFormat *>(pDerivedFrom), true);
 277 }
 278
 279 void SwUndoCharFormatCreate::Delete()
 280 {
 281     m_rDoc.DelCharFormat(static_cast<SwCharFormat *>(m_pNew), true);
 282 }
 283
 284 SwFormat * SwUndoCharFormatCreate::Find(const OUString & rName) const
 285 {
 286     return m_rDoc.FindCharFormatByName(rName);
 287 }
 288
 289 SwUndoCharFormatDelete::SwUndoCharFormatDelete(SwCharFormat const * pOld, SwDoc& rDocument)
 290     : SwUndoFormatDelete(SwUndoId::CHARFMT_DELETE, pOld, rDocument)
 291 {
 292 }
 293
 294 SwFormat * SwUndoCharFormatDelete::Create(SwFormat * pDerivedFrom)
 295 {
 296     return m_rDoc.MakeCharFormat(m_sOldName, static_cast<SwCharFormat *>(pDerivedFrom), true);
 297 }
 298
 299 void SwUndoCharFormatDelete::Delete(SwFormat * pFormat)
 300 {
 301     m_rDoc.DelCharFormat(static_cast<SwCharFormat *>(pFormat), true);
 302 }
 303
 304 SwFormat * SwUndoCharFormatDelete::Find(const OUString & rName) const
 305 {
 306     return m_rDoc.FindCharFormatByName(rName);
 307 }
 308
 309 SwUndoRenameCharFormat::SwUndoRenameCharFormat(const OUString & sInitOldName,
 310                                          const OUString & sInitNewName,
 311                                          SwDoc& rDocument)
 312     : SwUndoRenameFormat(SwUndoId::CHARFMT_RENAME, sInitOldName, sInitNewName, rDocument)
 313 {
 314 }
 315
 316 SwFormat * SwUndoRenameCharFormat::Find(const OUString & rName) const
 317 {
 318     return m_rDoc.FindCharFormatByName(rName);
 319 }
 320
 321 SwUndoFrameFormatCreate::SwUndoFrameFormatCreate(SwFrameFormat * pNewFormat,
 322                                        SwFrameFormat const * pDerivedFrom,
 323                                        SwDoc& rDocument)
 324     : SwUndoFormatCreate(SwUndoId::FRMFMT_CREATE, pNewFormat, pDerivedFrom, rDocument)
 325 {
 326 }
 327
 328 SwFormat * SwUndoFrameFormatCreate::Create(SwFormat * pDerivedFrom)
 329 {
 330     return m_rDoc.MakeFrameFormat(m_sNewName, static_cast<SwFrameFormat *>(pDerivedFrom), true, m_pNew->IsAuto());
 331 }
 332
 333 void SwUndoFrameFormatCreate::Delete()
 334 {
 335     m_rDoc.DelFrameFormat(static_cast<SwFrameFormat *>(m_pNew), true);
 336 }
 337
 338 SwFormat * SwUndoFrameFormatCreate::Find(const OUString & rName) const
 339 {
 340     return m_rDoc.FindFrameFormatByName(rName);
 341 }
 342
 343 SwUndoFrameFormatDelete::SwUndoFrameFormatDelete(SwFrameFormat const * pOld, SwDoc& rDocument)
 344     : SwUndoFormatDelete(SwUndoId::FRMFMT_DELETE, pOld, rDocument)
 345 {
 346 }
 347
 348 SwFormat * SwUndoFrameFormatDelete::Create(SwFormat * pDerivedFrom)
 349 {
 350     return m_rDoc.MakeFrameFormat(m_sOldName, static_cast<SwFrameFormat *>(pDerivedFrom), true);
 351 }
 352
 353 void SwUndoFrameFormatDelete::Delete(SwFormat * pFormat)
 354 {
 355     m_rDoc.DelFrameFormat(static_cast<SwFrameFormat *>(pFormat), true);
 356 }
 357
 358 SwFormat * SwUndoFrameFormatDelete::Find(const OUString & rName) const
 359 {
 360     return m_rDoc.FindFrameFormatByName(rName);
 361 }
 362
 363 SwUndoRenameFrameFormat::SwUndoRenameFrameFormat(const OUString & sInitOldName,
 364                                        const OUString & sInitNewName,
 365                                        SwDoc& rDocument)
 366     : SwUndoRenameFormat(SwUndoId::FRMFMT_RENAME, sInitOldName, sInitNewName, rDocument)
 367 {
 368 }
 369
 370 SwFormat * SwUndoRenameFrameFormat::Find(const OUString & rName) const
 371 {
 372     return m_rDoc.FindFrameFormatByName(rName);
 373 }
 374
 375 SwUndoNumruleCreate::SwUndoNumruleCreate(const SwNumRule * _pNew,
 376                                          SwDoc& rDoc)
 377     : SwUndo(SwUndoId::NUMRULE_CREATE, &rDoc), m_pNew(_pNew), m_aNew(*_pNew), m_rDoc(rDoc),
 378       m_bInitialized(false)
 379 {
 380 }
 381
 382 void SwUndoNumruleCreate::UndoImpl(::sw::UndoRedoContext &)
 383 {
 384     if (! m_bInitialized)
 385     {
 386         m_aNew = *m_pNew;
 387         m_bInitialized = true;
 388     }
 389
 390     m_rDoc.DelNumRule(m_aNew.GetName(), true);
 391 }
 392
 393 void SwUndoNumruleCreate::RedoImpl(::sw::UndoRedoContext &)
 394 {
 395     m_rDoc.MakeNumRule(m_aNew.GetName(), &m_aNew, true);
 396 }
 397
 398 SwRewriter SwUndoNumruleCreate::GetRewriter() const
 399 {
 400     SwRewriter aResult;
 401
 402     if (! m_bInitialized)
 403     {
 404         m_aNew = *m_pNew;
 405         m_bInitialized = true;
 406     }
 407
 408     aResult.AddRule(UndoArg1, m_aNew.GetName());
 409
 410     return aResult;
 411 }
 412
 413 SwUndoNumruleDelete::SwUndoNumruleDelete(const SwNumRule & rRule,
 414                                          SwDoc& rDoc)
 415     : SwUndo(SwUndoId::NUMRULE_DELETE, &rDoc), m_aOld(rRule), m_rDoc(rDoc)
 416 {
 417 }
 418
 419 void SwUndoNumruleDelete::UndoImpl(::sw::UndoRedoContext &)
 420 {
 421     m_rDoc.MakeNumRule(m_aOld.GetName(), &m_aOld, true);
 422 }
 423
 424 void SwUndoNumruleDelete::RedoImpl(::sw::UndoRedoContext &)
 425 {
 426     m_rDoc.DelNumRule(m_aOld.GetName(), true);
 427 }
 428
 429 SwRewriter SwUndoNumruleDelete::GetRewriter() const
 430 {
 431     SwRewriter aResult;
 432
 433     aResult.AddRule(UndoArg1, m_aOld.GetName());
 434
 435     return aResult;
 436 }
 437
 438 SwUndoNumruleRename::SwUndoNumruleRename(OUString _aOldName,
 439                                          OUString _aNewName,
 440                                          SwDoc& rDoc)
 441     : SwUndo(SwUndoId::NUMRULE_RENAME, &rDoc), m_aOldName(std::move(_aOldName)), m_aNewName(std::move(_aNewName)),
 442       m_rDoc(rDoc)
 443 {
 444 }
 445
 446 void SwUndoNumruleRename::UndoImpl(::sw::UndoRedoContext &)
 447 {
 448     m_rDoc.RenameNumRule(m_aNewName, m_aOldName, true);
 449 }
 450
 451 void SwUndoNumruleRename::RedoImpl(::sw::UndoRedoContext &)
 452 {
 453     m_rDoc.RenameNumRule(m_aOldName, m_aNewName, true);
 454 }
 455
 456 SwRewriter SwUndoNumruleRename::GetRewriter() const
 457 {
 458     SwRewriter aRewriter;
 459
 460     aRewriter.AddRule(UndoArg1, m_aOldName);
 461     aRewriter.AddRule(UndoArg2, SwResId(STR_YIELDS));
 462     aRewriter.AddRule(UndoArg3, m_aNewName);
 463
 464     return aRewriter;
 465 }
 466
 467 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */