undo.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_SVL_UNDO_HXX
#define INCLUDED_SVL_UNDO_HXX
 
#include <svl/svldllapi.h>
#include <rtl/ustring.hxx>
#include <tools/datetime.hxx>
#include <o3tl/strong_int.hxx>
 
#include <memory>
#include <vector>
 
typedef o3tl::strong_int<sal_Int32, struct ViewShellIdTag> ViewShellId;
typedef o3tl::strong_int<int, struct ViewShellDocIdTag> ViewShellDocId;
 
typedef struct _xmlTextWriter* xmlTextWriterPtr;
 
class SVL_DLLPUBLIC SAL_LOPLUGIN_ANNOTATE("crosscast") SfxRepeatTarget
{
public:
    virtual             ~SfxRepeatTarget() = 0;
};
 
 
class SVL_DLLPUBLIC SfxUndoContext
{
public:
    virtual size_t GetUndoOffset() { return 0; }
 
    virtual             ~SfxUndoContext() = 0;
};
 
 
class SVL_DLLPUBLIC SfxUndoAction
{
public:
                            SfxUndoAction();
    virtual                 ~SfxUndoAction() COVERITY_NOEXCEPT_FALSE;
 
    virtual void            Undo();
    virtual void            UndoWithContext( SfxUndoContext& i_context );
    virtual void            Redo();
    virtual void            RedoWithContext( SfxUndoContext& i_context );
    virtual void            Repeat(SfxRepeatTarget&);
    virtual bool            CanRepeat(SfxRepeatTarget&) const;
 
    virtual bool            Merge( SfxUndoAction *pNextAction );
 
    virtual OUString    GetComment() const;
    virtual OUString    GetRepeatComment(SfxRepeatTarget&) const;
    virtual ViewShellId GetViewShellId() const;
    const DateTime& GetDateTime() const;
    virtual void dumpAsXml(xmlTextWriterPtr pWriter) const;
 
private:
    SfxUndoAction( const SfxUndoAction& ) = delete;
    SfxUndoAction& operator=( const SfxUndoAction& ) = delete;
 
    DateTime m_aDateTime;
};
 
 
typedef sal_Int32 UndoStackMark;
#define MARK_INVALID    ::std::numeric_limits< UndoStackMark >::max()
 
struct MarkedUndoAction
{
    std::unique_ptr<SfxUndoAction>  pAction;
    ::std::vector< UndoStackMark >  aMarks;
 
    MarkedUndoAction(std::unique_ptr<SfxUndoAction> p) : pAction(std::move(p)) {}
};
 
struct SVL_DLLPUBLIC SfxUndoArray
{
    std::vector<MarkedUndoAction> maUndoActions;
    size_t                  nMaxUndoActions;
    size_t                  nCurUndoAction;
    SfxUndoArray            *pFatherUndoArray;
 
    SfxUndoArray(size_t nMax=0) :
        nMaxUndoActions(nMax), nCurUndoAction(0), pFatherUndoArray(nullptr) {}
    virtual ~SfxUndoArray();
 
    SfxUndoArray& operator=( SfxUndoArray const & ) = delete; // MSVC2017 workaround
    SfxUndoArray( SfxUndoArray const & ) = delete; // MSVC2017 workaround
 
    SfxUndoAction* GetUndoAction(size_t idx) { return maUndoActions[idx].pAction.get(); }
    std::unique_ptr<SfxUndoAction> Remove(int idx);
    void Remove( size_t i_pos, size_t i_count );
    void Insert( std::unique_ptr<SfxUndoAction> i_action, size_t i_pos );
};
 
 
class SVL_DLLPUBLIC SfxListUndoAction final : public SfxUndoAction, public SfxUndoArray
 
/*  [Explanation]
 
    UndoAction to composite multiple Undos in one UndoAction.
    These actions are used by SfxUndomanager. With < SfxUndoManager::EnterListAction >
    you can go one composite level down and with < SfxUndoManager::LeaveListAction > up again.
    Redo and Undo work element wise on SfxListUndoActions.
*/
{
    struct Impl;
    std::unique_ptr<Impl> mpImpl;
 
public:
 
    SfxListUndoAction(
        const OUString &rComment, const OUString& rRepeatComment, sal_uInt16 nId, ViewShellId nViewShellId, SfxUndoArray *pFather );
    virtual ~SfxListUndoAction() override;
 
    virtual void            Undo() override;
    virtual void            UndoWithContext( SfxUndoContext& i_context ) override;
    virtual void            Redo() override;
    virtual void            RedoWithContext( SfxUndoContext& i_context ) override;
    virtual void            Repeat(SfxRepeatTarget&) override;
    virtual bool            CanRepeat(SfxRepeatTarget&) const override;
 
    virtual bool            Merge( SfxUndoAction *pNextAction ) override;
 
    virtual OUString        GetComment() const override;
    ViewShellId GetViewShellId() const override;
    virtual OUString        GetRepeatComment(SfxRepeatTarget&) const override;
    sal_uInt16              GetId() const;
 
    void SetComment(const OUString& rComment);
    void dumpAsXml(xmlTextWriterPtr pWriter) const override;
};
 
 
class SAL_NO_VTABLE SfxUndoListener
{
public:
    virtual void actionUndone( const OUString& i_actionComment ) = 0;
    virtual void actionRedone( const OUString& i_actionComment ) = 0;
    virtual void undoActionAdded( const OUString& i_actionComment ) = 0;
    virtual void cleared() = 0;
    virtual void clearedRedo() = 0;
    virtual void resetAll() = 0;
    virtual void listActionEntered( const OUString& i_comment ) = 0;
    virtual void listActionLeft( const OUString& i_comment ) = 0;
    virtual void listActionCancelled() = 0;
 
protected:
    ~SfxUndoListener() {}
};
 
 
namespace svl::undo::impl
{
    class UndoManagerGuard;
    class LockGuard;
}
 
struct SfxUndoManager_Data;
class SVL_DLLPUBLIC SfxUndoManager
{
    std::unique_ptr< SfxUndoManager_Data >
                            m_xData;
public:
    static bool const CurrentLevel = true;
    static bool const TopLevel = false;
 
                            SfxUndoManager( size_t nMaxUndoActionCount = 20 );
    virtual                 ~SfxUndoManager();
 
    void                    SetMaxUndoActionCount( size_t nMaxUndoActionCount );
    size_t                  GetMaxUndoActionCount() const;
    virtual void            AddUndoAction( std::unique_ptr<SfxUndoAction> pAction, bool bTryMerg=false );
    virtual size_t          GetUndoActionCount( bool const i_currentLevel = CurrentLevel ) const;
    OUString                GetUndoActionComment( size_t nNo=0, bool const i_currentLevel = CurrentLevel ) const;
    SfxUndoAction*          GetUndoAction( size_t nNo=0 ) const;
    OUString                GetUndoActionsInfo() const;
    virtual size_t          GetRedoActionCount( bool const i_currentLevel = CurrentLevel ) const;
    OUString                GetRedoActionComment( size_t nNo=0, bool const i_currentLevel = CurrentLevel ) const;
    SfxUndoAction* GetRedoAction(size_t nNo = 0) const;
    OUString                GetRedoActionsInfo() const;
    virtual bool            Undo();
    virtual bool            Redo();
    virtual void            Clear();
    virtual void            ClearRedo();
    void                    Reset();
    bool                    IsDoing() const;
    size_t                  GetRepeatActionCount() const;
    OUString                GetRepeatActionComment( SfxRepeatTarget &rTarget) const;
    bool                    Repeat( SfxRepeatTarget &rTarget );
    bool                    CanRepeat( SfxRepeatTarget &rTarget ) const;
    virtual void            EnterListAction(const OUString &rComment, const OUString& rRepeatComment, sal_uInt16 nId, ViewShellId nViewShellId);
    size_t                  LeaveListAction();
 
    size_t                  LeaveAndMergeListAction();
    bool                    IsInListAction() const;
    size_t                  GetListActionDepth() const;
    void                    RemoveLastUndoAction();
    void                    EnableUndo( bool bEnable );
    bool                    IsUndoEnabled() const;
    void                    AddUndoListener( SfxUndoListener& i_listener );
    void                    RemoveUndoListener( SfxUndoListener& i_listener );
    bool                    IsEmptyActions() const;
 
 
    UndoStackMark   MarkTopUndoAction();
 
    void            RemoveMark( UndoStackMark const i_mark );
 
    bool            HasTopUndoActionMark( UndoStackMark const i_mark );
 
    void            RemoveOldestUndoAction();
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const;
 
protected:
    bool    UndoWithContext( SfxUndoContext& i_context );
    bool    RedoWithContext( SfxUndoContext& i_context );
 
    void    ImplClearRedo_NoLock( bool const i_currentLevel );
 
    void    ClearAllLevels();
    virtual void EmptyActionsChanged();
 
private:
    size_t  ImplLeaveListAction( const bool i_merge, ::svl::undo::impl::UndoManagerGuard& i_guard );
    bool    ImplAddUndoAction_NoNotify( std::unique_ptr<SfxUndoAction> pAction, bool bTryMerge, bool bClearRedo, ::svl::undo::impl::UndoManagerGuard& i_guard );
    void    ImplClearRedo( ::svl::undo::impl::UndoManagerGuard& i_guard, bool const i_currentLevel );
    void    ImplClearUndo( ::svl::undo::impl::UndoManagerGuard& i_guard );
    void    ImplClearCurrentLevel_NoNotify( ::svl::undo::impl::UndoManagerGuard& i_guard );
    size_t  ImplGetRedoActionCount_Lock( bool const i_currentLevel = CurrentLevel ) const;
    bool    ImplIsUndoEnabled_Lock() const;
    bool    ImplIsInListAction_Lock() const;
    void    ImplEnableUndo_Lock( bool const i_enable );
 
    bool    ImplUndo( SfxUndoContext* i_contextOrNull );
    bool    ImplRedo( SfxUndoContext* i_contextOrNull );
    void    ImplCheckEmptyActions();
    inline  bool    ImplIsEmptyActions() const;
 
    friend class ::svl::undo::impl::LockGuard;
};
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */