UT/UT_UndoBlock.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Ramin Kamal
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_UndoBlock.h ( Utility Library, C++)
 *
 * COMMENTS:
 *              This class is used by UT_UndoManager to organize groups
 *              of operations into a singe undoable block. It is basically
 *              a stack of UT_Undo's with an associated name (for the undo
 *              menu entry)
 */

#ifndef __UT_UndoBlock__
#define __UT_UndoBlock__

#include "UT_API.h"
#include "UT_String.h"
#include "UT_Undo.h"
#include "UT_PtrArray.h"

class UT_API UT_UndoBlock : public UT_Undo
{
public:
                         explicit UT_UndoBlock(const char *name, UT_UndoBlock *next = NULL);
                        ~UT_UndoBlock();

    int                  isEmpty()                      { return !myUndoHead; }
    void                 addUndo(UT_Undo *);
    void                 setNestedBlockName(int level, const char *name);
    const char          *getNestedBlockName(int level) const
                         {
                            if (level < myNestedNames.entries())
                                return myNestedNames(level);
                            return "";
                         }

    virtual void         undo();
    virtual void         redo();
    virtual int          isUndoBlock() const { return 1; }

    // needToUndo/Redo return true if any of the UT_Undos in the block return
    // true for the corresponding method
    virtual bool         needToUndo();
    virtual bool         needToRedo();

    /// Free all invalid undos/redos. Returns true if any pruning was done.
    bool                 pruneInvalidUndos();

    virtual int64        getMemoryUsage();

    void                 clearContents();

    UT_UndoBlock        *getNextBlock()                 { return myNextBlock; }
    const UT_UndoBlock  *getNextBlock() const           { return myNextBlock; }
    void                 setNextBlock(UT_UndoBlock *b)  { myNextBlock = b; }

    // This is firefighting. The undo strategy we've employed is errorprone,
    // and this method attempts to correct frequent programmer errors.
    // Essentially, when a too-many-begins error occurs, this method is
    // called, and it lops out any undos that don't belong in this block,
    // returning them. The caller is responsible for taking ownership of
    // these returned undos.
    UT_UndoBlock        *repairErrors();
    void                 debugPrint(int indent = 1) const;

private:
    UT_Undo             *myUndoHead;
    UT_UndoBlock        *myNextBlock;
    UT_PtrArray<char *>  myNestedNames;
    int64                myMemoryUsage;
};
#endif

---