UndoCore.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#ifndef INCLUDED_SW_SOURCE_CORE_INC_UNDOCORE_HXX
#define INCLUDED_SW_SOURCE_CORE_INC_UNDOCORE_HXX
 
#include <undobj.hxx>
#include <calbck.hxx>
#include <rtl/ustring.hxx>
#include <redline.hxx>
#include <numrule.hxx>
 
#include <memory>
#include <vector>
 
class SfxItemSet;
class SwFormatColl;
class SwFormatAnchor;
class SdrMarkList;
class SwUndoDelete;
 
namespace sw {
    class UndoManager;
    class IShellCursorSupplier;
}
 
class SwRedlineSaveData final : public SwUndRng, public SwRedlineData, private SwUndoSaveSection
{
public:
    SwRedlineSaveData(
        SwComparePosition eCmpPos,
        const SwPosition& rSttPos,
        const SwPosition& rEndPos,
        SwRangeRedline& rRedl,
        bool bCopyNext );
 
    ~SwRedlineSaveData();
 
    void RedlineToDoc( SwPaM const & rPam );
 
    const SwNodeIndex* GetMvSttIdx() const
    {
        return SwUndoSaveSection::GetMvSttIdx();
    }
 
#if OSL_DEBUG_LEVEL > 0
    sal_uInt16 m_nRedlineCount;
    bool m_bRedlineMoved;
#endif
};
 
class SwRedlineSaveDatas {
private:
    std::vector<std::unique_ptr<SwRedlineSaveData>> m_Data;
 
public:
    SwRedlineSaveDatas() : m_Data() {}
 
    void clear() { m_Data.clear(); }
    bool empty() const { return m_Data.empty(); }
    size_t size() const { return m_Data.size(); }
    void push_back(std::unique_ptr<SwRedlineSaveData> pNew) { m_Data.push_back(std::move(pNew)); }
    const SwRedlineSaveData& operator[](size_t const nIdx) const { return *m_Data[ nIdx ]; }
    SwRedlineSaveData& operator[](size_t const nIdx) { return *m_Data[ nIdx ]; }
};
 
namespace sw {
class UndoRedoContext final
    : public SfxUndoContext
{
public:
    UndoRedoContext(SwDoc & rDoc, IShellCursorSupplier & rCursorSupplier)
        : m_rDoc(rDoc)
        , m_rCursorSupplier(rCursorSupplier)
        , m_pSelFormat(nullptr)
        , m_pMarkList(nullptr)
    { }
 
    SwDoc & GetDoc() const { return m_rDoc; }
 
    IShellCursorSupplier & GetCursorSupplier() { return m_rCursorSupplier; }
 
    void SetSelections(SwFrameFormat *const pSelFormat, SdrMarkList *const pMarkList)
    {
        m_pSelFormat = pSelFormat;
        m_pMarkList = pMarkList;
    }
    void GetSelections(SwFrameFormat *& o_rpSelFormat, SdrMarkList *& o_rpMarkList)
    {
        o_rpSelFormat = m_pSelFormat;
        o_rpMarkList = m_pMarkList;
    }
 
    void SetUndoOffset(size_t nUndoOffset) { m_nUndoOffset = nUndoOffset; }
 
    size_t GetUndoOffset() override { return m_nUndoOffset; }
 
private:
    SwDoc & m_rDoc;
    IShellCursorSupplier & m_rCursorSupplier;
    SwFrameFormat * m_pSelFormat;
    SdrMarkList * m_pMarkList;
    size_t m_nUndoOffset = 0;
};
 
class RepeatContext final
    : public SfxRepeatTarget
{
public:
    RepeatContext(SwDoc & rDoc, SwPaM & rPaM)
        : m_rDoc(rDoc)
        , m_pCurrentPaM(& rPaM)
        , m_bDeleteRepeated(false)
    { }
 
    SwDoc & GetDoc() const { return m_rDoc; }
 
    SwPaM & GetRepeatPaM()
    {
        return *m_pCurrentPaM;
    }
 
private:
    friend class ::sw::UndoManager;
    friend class ::SwUndoDelete;
 
    SwDoc & m_rDoc;
    SwPaM * m_pCurrentPaM;
    bool m_bDeleteRepeated; 
};
 
} // namespace sw
 
class SwUndoFormatColl final : public SwUndo, private SwUndRng
{
    OUString maFormatName;
    std::unique_ptr<SwHistory> mpHistory;
    // for correct <ReDo(..)> and <Repeat(..)>
    // boolean, which indicates that the attributes are reset at the nodes
    // before the format has been applied.
    const bool mbReset;
    // boolean, which indicates that the list attributes had been reset at
    // the nodes before the format has been applied.
    const bool mbResetListAttrs;
 
    void DoSetFormatColl(SwDoc & rDoc, SwPaM const & rPaM);
 
public:
    SwUndoFormatColl( const SwPaM&, const SwFormatColl*,
                   const bool bReset,
                   const bool bResetListAttrs );
    virtual ~SwUndoFormatColl() override;
 
    virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
    virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
    virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 
    virtual SwRewriter GetRewriter() const override;
 
    SwHistory* GetHistory() { return mpHistory.get(); }
 
};
 
class SwUndoSetFlyFormat final : public SwUndo, public SwClient
{
    SwFrameFormat* m_pFrameFormat;                  // saved FlyFormat
    const OUString m_DerivedFromFormatName;
    const OUString m_NewFormatName;
    std::optional<SfxItemSet> m_oItemSet;               // the re-/ set attributes
    SwNodeOffset m_nOldNode, m_nNewNode;
    sal_Int32 m_nOldContent, m_nNewContent;
    RndStdIds m_nOldAnchorType, m_nNewAnchorType;
    bool m_bAnchorChanged;
 
    void PutAttr( sal_uInt16 nWhich, const SfxPoolItem* pItem );
    void SwClientNotify(const SwModify&, const SfxHint&) override;
    void GetAnchor( SwFormatAnchor& rAnhor, SwNodeOffset nNode, sal_Int32 nContent );
 
public:
    SwUndoSetFlyFormat( SwFrameFormat& rFlyFormat, const SwFrameFormat& rNewFrameFormat );
    virtual ~SwUndoSetFlyFormat() override;
 
    virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
    virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 
    virtual SwRewriter GetRewriter() const override;
};
 
class SwUndoOutlineLeftRight final : public SwUndo, private SwUndRng
{
    short m_nOffset;
 
public:
    SwUndoOutlineLeftRight( const SwPaM& rPam, short nOffset );
 
    virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
    virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
    virtual void RepeatImpl( ::sw::RepeatContext & ) override;
};
 
class SwUndoOutlineEdit final : public SwUndo, private SwUndRng
{
    SwNumRule m_aNewNumRule;
    SwNumRule m_aOldNumRule;
 
public:
    SwUndoOutlineEdit(const SwNumRule& rOldRule, const SwNumRule& rNewRule, const SwDoc& rDoc);
 
    virtual void UndoImpl(::sw::UndoRedoContext&) override;
    virtual void RedoImpl(::sw::UndoRedoContext&) override;
    virtual void RepeatImpl(::sw::RepeatContext&) override;
};
 
const int nUndoStringLength = 20;
 
OUString
ShortenString(const OUString & rStr, sal_Int32 nLength, std::u16string_view aFillStr);
OUString DenoteSpecialCharacters(std::u16string_view aStr, bool bQuoted = true);
 
#endif // INCLUDED_SW_SOURCE_CORE_INC_UNDOCORE_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */