FXUndoList.h

/********************************************************************************
*                                                                               *
*                  U n d o / R e d o - a b l e   C o m m a n d                  *
*                                                                               *
*********************************************************************************
* Copyright (C) 2000,2026 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 {


// Declarations
class FXUndoList;
class FXCommandGroup;


class FXAPI FXCommand : public FXObject {
  FXDECLARE_ABSTRACT(FXCommand)
private:
  FXival refs;
private:
  FXCommand(const FXCommand& org);
  FXCommand &operator=(const FXCommand&);
protected:
  FXCommand():refs(0){}
public:

  // Return reference count
  FXival nrefs() const { return refs; }

  // Increment reference count
  void ref(){ ++refs; }

  // Decrement reference count
  void unref(){ if(--refs<=0) delete this; }

  virtual void undo() = 0;

  virtual void redo() = 0;

  virtual FXuval size() const;

  virtual FXString undoName() const;

  virtual FXString redoName() const;

  virtual FXbool canMerge() const;

  virtual FXuint mergeWith(FXCommand* command);
  };


// A marked pointer to a command
typedef FXMarkedPtr<FXCommand> FXCommandPtr;

// Array of marked command pointers
typedef FXArray<FXCommandPtr> FXCommandArray;

// Stack of command group pointers
typedef FXPtrListOf<FXCommandGroup> FXCommandStack;


class FXAPI FXCommandGroup : public FXCommand {
  FXDECLARE(FXCommandGroup)
  friend class FXUndoList;
private:
  FXCommandArray  command;
private:
  FXCommandGroup(const FXCommandGroup&);
  FXCommandGroup &operator=(const FXCommandGroup&);
public:

  FXCommandGroup();

  FXbool empty() const;

  virtual FXbool cut();

  virtual void undo() override;

  virtual void redo() override;

  virtual FXuval size() const override;

  virtual void clear();

  virtual ~FXCommandGroup();
  };


class FXAPI FXUndoList : public FXCommandGroup {
  FXDECLARE(FXUndoList)
private:
  FXCommandStack groups;        // Command group stack
  FXuval         space;         // Total memory in the undo commands
  FXint          undocount;     // Number of undo records
  FXint          redocount;     // Number of redo records
  FXint          working;       // Currently busy with undo or redo
  FXint          marker;        // Marker value
  FXbool         markset;       // Mark is set
  FXbool         alternate;     // Keep alternate history
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 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*);
  long onCmdAltHistory(FXObject*,FXSelector,void*);
  long onUpdAltHistory(FXObject*,FXSelector,void*);
  long onCmdDumpStats(FXObject*,FXSelector,void*);
  long onCmdTrimMark(FXObject*,FXSelector,void*);
  long onCmdTrimSize(FXObject*,FXSelector,void*);
  long onCmdTrimWrinkles(FXObject*,FXSelector,void*);
  long onCmdTrimCount(FXObject*,FXSelector,void*);
  long onCmdClear(FXObject*,FXSelector,void*);
  long onUpdClear(FXObject*,FXSelector,void*);
  long onUpdSize(FXObject*,FXSelector,void*);
public:
  enum{
    ID_REVERT=FXWindow::ID_LAST,
    ID_UNDO,
    ID_REDO,
    ID_UNDO_ALL,
    ID_REDO_ALL,
    ID_UNDO_COUNT,
    ID_REDO_COUNT,
    ID_ALT_HISTORY,
    ID_SIZE,
    ID_CLEAR,
    ID_TRIM_MARK,
    ID_TRIM_COUNT_1K,
    ID_TRIM_COUNT_10K,
    ID_TRIM_COUNT_100K,
    ID_TRIM_COUNT_1M,
    ID_TRIM_COUNT_10M,
    ID_TRIM_COUNT_100M,
    ID_TRIM_COUNT_1G,
    ID_TRIM_COUNT=ID_TRIM_COUNT_1K,
    ID_TRIM_SIZE_1K,
    ID_TRIM_SIZE_10K,
    ID_TRIM_SIZE_100K,
    ID_TRIM_SIZE_1M,
    ID_TRIM_SIZE_10M,
    ID_TRIM_SIZE_100M,
    ID_TRIM_SIZE_1G,
    ID_TRIM_SIZE=ID_TRIM_SIZE_10M,
    ID_TRIM_ALT_1K,
    ID_TRIM_ALT_10K,
    ID_TRIM_ALT_100K,
    ID_TRIM_ALT_1M,
    ID_TRIM_ALT_10M,
    ID_TRIM_ALT_100M,
    ID_TRIM_ALT_1G,
    ID_TRIM_ALT=ID_TRIM_ALT_10M,
    ID_DUMP_STATS,
    ID_LAST
    };
public:

  FXUndoList();

  FXbool busy() const { return (working!=0); }

  void mark();

  void unmark();

  FXbool marked() const;

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

  FXbool begin(FXCommandGroup *command);

  FXbool abort();

  FXbool end();

  virtual FXbool cut() override;

  virtual void undo() override;

  virtual void redo() override;

  void undoAll();

  void redoAll();

  void revert();

  FXbool canUndo() const;

  FXbool canRedo() const;

  FXbool canRevert() const;

  FXCommand* current() const;

  virtual FXString undoName() const override;

  virtual FXString redoName() const override;

  FXint undoCount() const { return undocount; }

  FXint redoCount() const { return redocount; }

  virtual FXuval size() const override;

  void trimMark();

  void trimSize(FXuval sz);

  void trimWrinkles(FXuval sz);

  void trimCount(FXint nc);

  virtual void clear() override;

  void setAlternateHistory(FXbool flag){ alternate=flag; }

  FXbool getAlternateHistory() const { return alternate; }

  void dumpStats();

  virtual ~FXUndoList();
  };

}

#endif