/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <poolfmt.hxx>
#include <charfmt.hxx>
#include <frmfmt.hxx>
#include <SwUndoFmt.hxx>
#include <SwRewriter.hxx>
#include <swundo.hxx>
#include <undobj.hxx>
#include <fmtcol.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <strings.hrc>
SwUndoFormatCreate::SwUndoFormatCreate
(SwUndoId nUndoId, SwFormat * _pNew, SwFormat const * _pDerivedFrom, SwDoc * _pDoc)
: SwUndo(nUndoId, _pDoc), pNew(_pNew),
pDoc(_pDoc), pNewSet(nullptr), nId(0), bAuto(false)
{
if (_pDerivedFrom)
sDerivedFrom = _pDerivedFrom->GetName();
}
SwUndoFormatCreate::~SwUndoFormatCreate()
{
}
void SwUndoFormatCreate::UndoImpl(::sw::UndoRedoContext &)
{
if (pNew)
{
if (sNewName.isEmpty() && pNew)
sNewName = pNew->GetName();
if (!sNewName.isEmpty())
pNew = Find(sNewName);
if (pNew)
{
pNewSet = new SfxItemSet(pNew->GetAttrSet());
nId = pNew->GetPoolFormatId() & COLL_GET_RANGE_BITS;
bAuto = pNew->IsAuto();
Delete();
}
}
}
void SwUndoFormatCreate::RedoImpl(::sw::UndoRedoContext &)
{
SwFormat * pDerivedFrom = Find(sDerivedFrom);
SwFormat * pFormat = Create(pDerivedFrom);
if (pFormat && pNewSet)
{
pFormat->SetAuto(bAuto);
pDoc->ChgFormat(*pFormat, *pNewSet);
pFormat->SetPoolFormatId((pFormat->GetPoolFormatId()
& ~COLL_GET_RANGE_BITS)
| nId);
pNew = pFormat;
}
else
pNew = nullptr;
}
SwRewriter SwUndoFormatCreate::GetRewriter() const
{
if (sNewName.isEmpty() && pNew)
sNewName = pNew->GetName();
SwRewriter aRewriter;
aRewriter.AddRule(UndoArg1, sNewName);
return aRewriter;
}
SwUndoFormatDelete::SwUndoFormatDelete
(SwUndoId nUndoId, SwFormat const * _pOld, SwDoc * _pDoc)
: SwUndo(nUndoId, _pDoc),
pDoc(_pDoc), sOldName(_pOld->GetName()),
aOldSet(_pOld->GetAttrSet())
{
sDerivedFrom = _pOld->DerivedFrom()->GetName();
nId = _pOld->GetPoolFormatId() & COLL_GET_RANGE_BITS;
bAuto = _pOld->IsAuto();
}
SwUndoFormatDelete::~SwUndoFormatDelete()
{
}
void SwUndoFormatDelete::UndoImpl(::sw::UndoRedoContext &)
{
SwFormat * pDerivedFrom = Find(sDerivedFrom);
SwFormat * pFormat = Create(pDerivedFrom);
if (pFormat)
{
pDoc->ChgFormat(*pFormat, aOldSet);
pFormat->SetAuto(bAuto);
pFormat->SetPoolFormatId((pFormat->GetPoolFormatId() &
~COLL_GET_RANGE_BITS)
| nId);
}
}
void SwUndoFormatDelete::RedoImpl(::sw::UndoRedoContext &)
{
SwFormat * pOld = Find(sOldName);
if (pOld)
{
Delete(pOld);
}
}
SwRewriter SwUndoFormatDelete::GetRewriter() const
{
SwRewriter aRewriter;
aRewriter.AddRule(UndoArg1, sOldName);
return aRewriter;
}
SwUndoRenameFormat::SwUndoRenameFormat(SwUndoId nUndoId,
const OUString & _sOldName,
const OUString & _sNewName,
SwDoc * _pDoc)
: SwUndo(nUndoId, _pDoc), sOldName(_sOldName),
sNewName(_sNewName), pDoc(_pDoc)
{
}
SwUndoRenameFormat::~SwUndoRenameFormat()
{
}
void SwUndoRenameFormat::UndoImpl(::sw::UndoRedoContext &)
{
SwFormat * pFormat = Find(sNewName);
if (pFormat)
{
pDoc->RenameFormat(*pFormat, sOldName, true);
}
}
void SwUndoRenameFormat::RedoImpl(::sw::UndoRedoContext &)
{
SwFormat * pFormat = Find(sOldName);
if (pFormat)
{
pDoc->RenameFormat(*pFormat, sNewName, true);
}
}
SwRewriter SwUndoRenameFormat::GetRewriter() const
{
SwRewriter aRewriter;
aRewriter.AddRule(UndoArg1, sOldName);
aRewriter.AddRule(UndoArg2, SwResId(STR_YIELDS));
aRewriter.AddRule(UndoArg3, sNewName);
return aRewriter;
}
SwUndoTextFormatCollCreate::SwUndoTextFormatCollCreate
(SwTextFormatColl * _pNew, SwTextFormatColl const * _pDerivedFrom, SwDoc * _pDoc)
: SwUndoFormatCreate(SwUndoId::TXTFMTCOL_CREATE, _pNew, _pDerivedFrom, _pDoc)
{
}
SwFormat * SwUndoTextFormatCollCreate::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeTextFormatColl(sNewName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
}
void SwUndoTextFormatCollCreate::Delete()
{
pDoc->DelTextFormatColl(static_cast<SwTextFormatColl *>(pNew), true);
}
SwFormat * SwUndoTextFormatCollCreate::Find(const OUString & rName) const
{
return pDoc->FindTextFormatCollByName(rName);
}
SwUndoTextFormatCollDelete::SwUndoTextFormatCollDelete(SwTextFormatColl const * _pOld,
SwDoc * _pDoc)
: SwUndoFormatDelete(SwUndoId::TXTFMTCOL_DELETE, _pOld, _pDoc)
{
}
SwFormat * SwUndoTextFormatCollDelete::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeTextFormatColl(sOldName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
}
void SwUndoTextFormatCollDelete::Delete(SwFormat * pOld)
{
pDoc->DelTextFormatColl(static_cast<SwTextFormatColl *>(pOld), true);
}
SwFormat * SwUndoTextFormatCollDelete::Find(const OUString & rName) const
{
return pDoc->FindTextFormatCollByName(rName);
}
SwUndoCondTextFormatCollCreate::SwUndoCondTextFormatCollCreate(SwConditionTextFormatColl *_pNew,
SwTextFormatColl const *_pDerivedFrom, SwDoc *_pDoc)
: SwUndoTextFormatCollCreate(_pNew, _pDerivedFrom, _pDoc)
{
}
SwFormat * SwUndoCondTextFormatCollCreate::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeCondTextFormatColl(sNewName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
}
SwUndoCondTextFormatCollDelete::SwUndoCondTextFormatCollDelete(SwTextFormatColl const * _pOld,
SwDoc * _pDoc)
: SwUndoTextFormatCollDelete(_pOld, _pDoc)
{
}
SwFormat * SwUndoCondTextFormatCollDelete::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeCondTextFormatColl(sOldName, static_cast<SwTextFormatColl *>(pDerivedFrom), true);
}
SwUndoRenameFormatColl::SwUndoRenameFormatColl(const OUString & sInitOldName,
const OUString & sInitNewName,
SwDoc * _pDoc)
: SwUndoRenameFormat(SwUndoId::TXTFMTCOL_RENAME, sInitOldName, sInitNewName, _pDoc)
{
}
SwFormat * SwUndoRenameFormatColl::Find(const OUString & rName) const
{
return pDoc->FindTextFormatCollByName(rName);
}
SwUndoCharFormatCreate::SwUndoCharFormatCreate(SwCharFormat * pNewFormat,
SwCharFormat const * pDerivedFrom,
SwDoc * pDocument)
: SwUndoFormatCreate(SwUndoId::CHARFMT_CREATE, pNewFormat, pDerivedFrom, pDocument)
{
}
SwFormat * SwUndoCharFormatCreate::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeCharFormat(sNewName, static_cast<SwCharFormat *>(pDerivedFrom), true);
}
void SwUndoCharFormatCreate::Delete()
{
pDoc->DelCharFormat(static_cast<SwCharFormat *>(pNew), true);
}
SwFormat * SwUndoCharFormatCreate::Find(const OUString & rName) const
{
return pDoc->FindCharFormatByName(rName);
}
SwUndoCharFormatDelete::SwUndoCharFormatDelete(SwCharFormat const * pOld, SwDoc * pDocument)
: SwUndoFormatDelete(SwUndoId::CHARFMT_DELETE, pOld, pDocument)
{
}
SwFormat * SwUndoCharFormatDelete::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeCharFormat(sOldName, static_cast<SwCharFormat *>(pDerivedFrom), true);
}
void SwUndoCharFormatDelete::Delete(SwFormat * pFormat)
{
pDoc->DelCharFormat(static_cast<SwCharFormat *>(pFormat), true);
}
SwFormat * SwUndoCharFormatDelete::Find(const OUString & rName) const
{
return pDoc->FindCharFormatByName(rName);
}
SwUndoRenameCharFormat::SwUndoRenameCharFormat(const OUString & sInitOldName,
const OUString & sInitNewName,
SwDoc * pDocument)
: SwUndoRenameFormat(SwUndoId::CHARFMT_RENAME, sInitOldName, sInitNewName, pDocument)
{
}
SwFormat * SwUndoRenameCharFormat::Find(const OUString & rName) const
{
return pDoc->FindCharFormatByName(rName);
}
SwUndoFrameFormatCreate::SwUndoFrameFormatCreate(SwFrameFormat * pNewFormat,
SwFrameFormat const * pDerivedFrom,
SwDoc * pDocument)
: SwUndoFormatCreate(SwUndoId::FRMFMT_CREATE, pNewFormat, pDerivedFrom, pDocument)
{
}
SwFormat * SwUndoFrameFormatCreate::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeFrameFormat(sNewName, static_cast<SwFrameFormat *>(pDerivedFrom), true, pNew->IsAuto());
}
void SwUndoFrameFormatCreate::Delete()
{
pDoc->DelFrameFormat(static_cast<SwFrameFormat *>(pNew), true);
}
SwFormat * SwUndoFrameFormatCreate::Find(const OUString & rName) const
{
return pDoc->FindFrameFormatByName(rName);
}
SwUndoFrameFormatDelete::SwUndoFrameFormatDelete(SwFrameFormat const * pOld, SwDoc * pDocument)
: SwUndoFormatDelete(SwUndoId::FRMFMT_DELETE, pOld, pDocument)
{
}
SwFormat * SwUndoFrameFormatDelete::Create(SwFormat * pDerivedFrom)
{
return pDoc->MakeFrameFormat(sOldName, static_cast<SwFrameFormat *>(pDerivedFrom), true);
}
void SwUndoFrameFormatDelete::Delete(SwFormat * pFormat)
{
pDoc->DelFrameFormat(static_cast<SwFrameFormat *>(pFormat), true);
}
SwFormat * SwUndoFrameFormatDelete::Find(const OUString & rName) const
{
return pDoc->FindFrameFormatByName(rName);
}
SwUndoRenameFrameFormat::SwUndoRenameFrameFormat(const OUString & sInitOldName,
const OUString & sInitNewName,
SwDoc * pDocument)
: SwUndoRenameFormat(SwUndoId::FRMFMT_RENAME, sInitOldName, sInitNewName, pDocument)
{
}
SwFormat * SwUndoRenameFrameFormat::Find(const OUString & rName) const
{
return pDoc->FindFrameFormatByName(rName);
}
SwUndoNumruleCreate::SwUndoNumruleCreate(const SwNumRule * _pNew,
SwDoc * _pDoc)
: SwUndo(SwUndoId::NUMRULE_CREATE, _pDoc), pNew(_pNew), aNew(*_pNew), pDoc(_pDoc),
bInitialized(false)
{
}
void SwUndoNumruleCreate::UndoImpl(::sw::UndoRedoContext &)
{
if (! bInitialized)
{
aNew = *pNew;
bInitialized = true;
}
pDoc->DelNumRule(aNew.GetName(), true);
}
void SwUndoNumruleCreate::RedoImpl(::sw::UndoRedoContext &)
{
pDoc->MakeNumRule(aNew.GetName(), &aNew, true);
}
SwRewriter SwUndoNumruleCreate::GetRewriter() const
{
SwRewriter aResult;
if (! bInitialized)
{
aNew = *pNew;
bInitialized = true;
}
aResult.AddRule(UndoArg1, aNew.GetName());
return aResult;
}
SwUndoNumruleDelete::SwUndoNumruleDelete(const SwNumRule & rRule,
SwDoc * _pDoc)
: SwUndo(SwUndoId::NUMRULE_DELETE, _pDoc), aOld(rRule), pDoc(_pDoc)
{
}
void SwUndoNumruleDelete::UndoImpl(::sw::UndoRedoContext &)
{
pDoc->MakeNumRule(aOld.GetName(), &aOld, true);
}
void SwUndoNumruleDelete::RedoImpl(::sw::UndoRedoContext &)
{
pDoc->DelNumRule(aOld.GetName(), true);
}
SwRewriter SwUndoNumruleDelete::GetRewriter() const
{
SwRewriter aResult;
aResult.AddRule(UndoArg1, aOld.GetName());
return aResult;
}
SwUndoNumruleRename::SwUndoNumruleRename(const OUString & _aOldName,
const OUString & _aNewName,
SwDoc * _pDoc)
: SwUndo(SwUndoId::NUMRULE_RENAME, _pDoc), aOldName(_aOldName), aNewName(_aNewName),
pDoc(_pDoc)
{
}
void SwUndoNumruleRename::UndoImpl(::sw::UndoRedoContext &)
{
pDoc->RenameNumRule(aNewName, aOldName, true);
}
void SwUndoNumruleRename::RedoImpl(::sw::UndoRedoContext &)
{
pDoc->RenameNumRule(aOldName, aNewName, true);
}
SwRewriter SwUndoNumruleRename::GetRewriter() const
{
SwRewriter aRewriter;
aRewriter.AddRule(UndoArg1, aOldName);
aRewriter.AddRule(UndoArg2, SwResId(STR_YIELDS));
aRewriter.AddRule(UndoArg3, aNewName);
return aRewriter;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V571 Recurring check. The 'pNew' condition was already verified in line 47.
↑ V560 A part of conditional expression is always true: pNew.