xref: /trunk/main/sw/inc/IDocumentUndoRedo.hxx (revision 1d2dbeb0b7301723c6d13094e87a8714ef81a328)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef IDOCUMENTUNDOREDO_HXX_INCLUDED
#define IDOCUMENTUNDOREDO_HXX_INCLUDED

#include <sal/types.h>

#include <swundo.hxx>


class SwRewriter;
class SwNodes;
class SwUndo;

namespace sw {
    class RepeatContext;
}



/** IDocumentUndoRedo
*/
class IDocumentUndoRedo
{
public:

    /** Enable/Disable Undo.
    */
    virtual void DoUndo(bool const bDoUndo) = 0;

    /** Is Undo enabled?
    */
    virtual bool DoesUndo() const = 0;

    /** Enable/Disable Group Undo.
        This determines whether successive Insert/Delete/Overwrite
        actions are combined.
    */
    virtual void DoGroupUndo(bool const bDoUndo) = 0;

    /** Is Group Undo enabled?
    */
    virtual bool DoesGroupUndo() const = 0;

    /** Enable/Disable Undo for Drawing objects.
     */
    virtual void DoDrawUndo(bool const bDoUndo) = 0;

    /** Is Undo for Drawing objects enabled?
        for Draw-Undo: writer wants to handle actions on Flys on its own.
     */
    virtual bool DoesDrawUndo() const = 0;

    /** Set the position at which the document is in the "unmodified" state
        to the current position in the Undo stack.
    */
    virtual void SetUndoNoModifiedPosition() = 0;

    /** Prevent updates to the "unmodified" state position
        via SetUndoNoResetModified().
    */
    virtual void LockUndoNoModifiedPosition() = 0;

    /** Allow updates to the "unmodified" state position
        via SetUndoNoResetModified().
    */
    virtual void UnLockUndoNoModifiedPosition() = 0;

    /** Disable (re)setting the document modified flag on Undo/Redo.
    */
    virtual void SetUndoNoResetModified() = 0;

    /** Is setting the document modified flag on Undo/Redo disabled?
    */
    virtual bool IsUndoNoResetModified() const = 0;

    /** Execute Undo.

        @return     true if executing the last Undo action was successful.
    */
    virtual sal_Bool Undo() = 0;

    /** Opens undo block.

        @remark     StartUndo() and EndUndo() do nothing if !DoesUndo().

        @param nUndoId        undo ID for the list action
        @param pRewriter      rewriter for comments @see SwUndo::GetComment

        If the given nUndoId is equal to zero an undo object with ID
        UNDO_START will be generated.

        @return the undo ID of the created object
    */
    virtual SwUndoId StartUndo(SwUndoId const eUndoId,
                SwRewriter const*const  pRewriter) = 0;

    /**
       Closes undo block.

       @remark     StartUndo() and EndUndo() do nothing if !DoesUndo().

       @param nUndoId         undo ID for the list action
       @param pRewriter       rewriter for comments @see SwUndo::GetComment

       If the given nUndoId is not UNDO_EMPTY or UNDO_END, the comment of
       the resulting list action will be set via the nUndoId, applying the
       given pRewriter (if not 0).  Otherwise the comment of the resulting
       list action is unchanged if it has an UndoId that is not UNDO_START
       set by StartUndo, and in case the UndoId is UNDO_START the comment
       of the list action defaults to the comment of the last action
       contained in the list action.
    */
    virtual SwUndoId EndUndo(SwUndoId const eUndoId,
                SwRewriter const*const  pRewriter) = 0;

    /** <- #111827#
        Delete all Undo actions.
        Of course Undo will be disabled during deletion.
    */
    virtual void DelAllUndoObj() = 0;

    /** Get Id and comment of last Undo action.
        @param o_pStr       if not 0, receives comment of last Undo action.
        @param o_pId        if not 0, receives Id of last Undo action.
        @return     true if there is a Undo action, false if none
    */
    virtual bool GetLastUndoInfo(::rtl::OUString *const o_pStr,
                SwUndoId *const o_pId) const = 0;

    /** Get comments of Undo actions.
        @return     comments of all top-level Undo actions.
    */
    virtual SwUndoComments_t GetUndoComments() const = 0;

    /** Execute Redo.

        @return     true if executing the first Redo action was successful.
    */
    virtual sal_Bool Redo() = 0;

    /** Get comment of first Redo action.
        @param o_pStr       if not 0, receives comment of first Redo action.
        @return     true if there is a Redo action, false if none
    */
    virtual bool GetFirstRedoInfo(::rtl::OUString *const o_pStr) const = 0;

    /** Get comments of Redo actions.
        @return     comments of all top-level Redo actions.
    */
    virtual SwUndoComments_t GetRedoComments() const = 0;

    /** Repeat the last Undo action.
        @return     true if repeating the last Undo Redo action was attempted.
    */
    virtual bool Repeat(::sw::RepeatContext & rContext,
                sal_uInt16 const nRepeatCnt) = 0;

    /** Get Id and comment of last Undo action, if it is Repeat capable.
        @param o_pStr       if not 0, receives comment of last Undo action
                            if it is Repeat capable.
        @return     Id of last Undo action if it is Repeat capable,
                    or UNDO_EMPTY if there is none or it is not Repeat capable.
    */
    virtual SwUndoId GetRepeatInfo(::rtl::OUString *const o_pStr) const = 0;

    /** Add new Undo action.
        Takes over ownership of pUndo.
        @remark     calls ClearRedo(), except for UNDO_START/UNDO_END.
        @remark     does nothing if !DoesUndo().
    */
    virtual void AppendUndo(SwUndo *const pUndo) = 0;

    /** Delete all Redo actions.
    */
    virtual void ClearRedo() = 0;

    /* Is the given nodes array the Undo nodes array?
    */
    virtual bool IsUndoNodes(SwNodes const& rNodes) const = 0;

protected:
    virtual ~IDocumentUndoRedo() {};
};


namespace sw {

class UndoGuard
{
public:

    UndoGuard(IDocumentUndoRedo & rUndoRedo)
        :   m_rUndoRedo(rUndoRedo)
        ,   m_bUndoWasEnabled(rUndoRedo.DoesUndo())
    {
        m_rUndoRedo.DoUndo(false);
    }
    ~UndoGuard()
    {
        m_rUndoRedo.DoUndo(m_bUndoWasEnabled);
    }

    bool UndoWasEnabled() const
    {
        return m_bUndoWasEnabled;
    }

private:
    IDocumentUndoRedo & m_rUndoRedo;
    bool const m_bUndoWasEnabled;
};

class GroupUndoGuard
{
public:

    GroupUndoGuard(IDocumentUndoRedo & rUndoRedo)
        :   m_rUndoRedo(rUndoRedo)
        ,   m_bGroupUndoWasEnabled(rUndoRedo.DoesGroupUndo())
    {
        m_rUndoRedo.DoGroupUndo(false);
    }
    ~GroupUndoGuard()
    {
        m_rUndoRedo.DoGroupUndo(m_bGroupUndoWasEnabled);
    }

private:
    IDocumentUndoRedo & m_rUndoRedo;
    bool const m_bGroupUndoWasEnabled;
};

class DrawUndoGuard
{
public:

    DrawUndoGuard(IDocumentUndoRedo & rUndoRedo)
        :   m_rUndoRedo(rUndoRedo)
        ,   m_bDrawUndoWasEnabled(rUndoRedo.DoesDrawUndo())
    {
        m_rUndoRedo.DoDrawUndo(false);
    }
    ~DrawUndoGuard()
    {
        m_rUndoRedo.DoDrawUndo(m_bDrawUndoWasEnabled);
    }

private:
    IDocumentUndoRedo & m_rUndoRedo;
    bool const m_bDrawUndoWasEnabled;
};


} // namespace sw

#endif