/home/jeroen/FOX/fox/fox-1.7.33/include/FXUndoList.h

/********************************************************************************
*                                                                               *
*                  U n d o / R e d o - a b l e   C o m m a n d                  *
*                                                                               *
*********************************************************************************
* Copyright (C) 2000,2012 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or modify          *
* it under the terms of the GNU Lesser General Public License as published by   *
* the Free Software Foundation; either version 3 of the License, or             *
* (at your option) any later version.                                           *
*                                                                               *
* This library is distributed in the hope that it will be useful,               *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 *
* GNU Lesser General Public License for more details.                           *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public License      *
* along with this program.  If not, see <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXUNDOLIST_H
#define FXUNDOLIST_H

#ifndef FXOBJECT_H
#include "FXObject.h"
#endif

namespace FX {


class FXUndoList;
class FXCommandGroup;


class FXAPI FXCommand : public FXObject {
  FXDECLARE_ABSTRACT(FXCommand)
  friend class FXUndoList;
  friend class FXCommandGroup;
private:
  FXCommand *next;
private:
  FXCommand(const FXCommand&);
  FXCommand &operator=(const FXCommand&);
protected:
  FXCommand():next(NULL){}
public:

  virtual void undo() = 0;

  virtual void redo() = 0;

  virtual FXuint size() const;

  virtual FXString undoName() const;

  virtual FXString redoName() const;

  virtual FXbool canMerge() const;

  virtual FXbool mergeWith(FXCommand* command);

  virtual ~FXCommand(){}
  };



class FXAPI FXCommandGroup : public FXCommand {
  FXDECLARE(FXCommandGroup)
  friend class FXUndoList;
private:
  FXCommand      *undolist;
  FXCommand      *redolist;
  FXCommandGroup *group;
private:
  FXCommandGroup(const FXCommandGroup&);
  FXCommandGroup &operator=(const FXCommandGroup&);
public:

  FXCommandGroup():undolist(NULL),redolist(NULL),group(NULL){}

  FXbool empty(){ return !undolist; }

  virtual void undo();

  virtual void redo();

  virtual FXuint size() const;

  virtual ~FXCommandGroup();
  };



class FXAPI FXUndoList : public FXCommandGroup {
  FXDECLARE(FXUndoList)
private:
  FXint      undocount;     // Number of undo records
  FXint      redocount;     // Number of redo records
  FXint      marker;        // Marker value
  FXuint     space;         // Space taken up by all the undo records
  FXbool     working;       // Currently busy with undo or redo
private:
  FXUndoList(const FXUndoList&);
  FXUndoList &operator=(const FXUndoList&);
public:
  long onCmdUndo(FXObject*,FXSelector,void*);
  long onUpdUndo(FXObject*,FXSelector,void*);
  long onCmdRedo(FXObject*,FXSelector,void*);
  long onUpdRedo(FXObject*,FXSelector,void*);
  long onCmdClear(FXObject*,FXSelector,void*);
  long onUpdClear(FXObject*,FXSelector,void*);
  long onCmdRevert(FXObject*,FXSelector,void*);
  long onUpdRevert(FXObject*,FXSelector,void*);
  long onCmdUndoAll(FXObject*,FXSelector,void*);
  long onCmdRedoAll(FXObject*,FXSelector,void*);
  long onUpdUndoCount(FXObject*,FXSelector,void*);
  long onUpdRedoCount(FXObject*,FXSelector,void*);
public:
  enum{
    ID_CLEAR=FXWindow::ID_LAST,
    ID_REVERT,
    ID_UNDO,
    ID_REDO,
    ID_UNDO_ALL,
    ID_REDO_ALL,
    ID_UNDO_COUNT,
    ID_REDO_COUNT,
    ID_LAST
    };
public:

  FXUndoList();

  void cut();

  void add(FXCommand* command,FXbool doit=false,FXbool merge=true);

  void begin(FXCommandGroup *command);

  void end();

  void abort();

  virtual void undo();

  virtual void redo();

  void undoAll();

  void redoAll();

  void revert();

  FXbool canUndo() const;

  FXbool canRedo() const;

  FXbool canRevert() const;

  FXbool busy() const { return working; }

  FXCommand* current() const { return undolist; }

  virtual FXString undoName() const;

  virtual FXString redoName() const;

  FXint undoCount() const { return undocount; }

  FXint redoCount() const { return redocount; }

  virtual FXuint size() const;

  void clear();

  void trimCount(FXint nc);

  void trimSize(FXuint sz);

  void mark();

  void unmark();

  FXbool marked() const;
  };


}

#endif