TreeUndoManager.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2026 Gunter Königsmann <wxMaxima@physikbuch.de>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef TREEUNDOMANAGER_H
#define TREEUNDOMANAGER_H
 
#include "TreeUndoAction.h"
 
class TreeUndoManager
{
public:
  UndoActions &UndoStack() { return m_undoActions; }
  const UndoActions &UndoStack() const { return m_undoActions; }
 
  UndoActions &RedoStack() { return m_redoActions; }
  const UndoActions &RedoStack() const { return m_redoActions; }
 
  static void DiscardAction(UndoActions *actionList)
    {
      if (actionList->empty())
        return;
      do {
        actionList->pop_back();
      } while (!actionList->empty() && actionList->back().m_partOfAtomicAction);
    }
 
  static void AppendAction(UndoActions *actionList)
    {
      if (!actionList->empty())
        actionList->front().m_partOfAtomicAction = true;
    }
 
  void AppendAction() { AppendAction(&m_undoActions); }
 
  void ClearRedoActionList()
    {
      while (!m_redoActions.empty())
        DiscardAction(&m_redoActions);
    }
 
  void ClearUndoActionList()
    {
      while (!m_undoActions.empty())
        DiscardAction(&m_undoActions);
    }
 
  void ClearBuffers()
    {
      ClearRedoActionList();
      ClearUndoActionList();
      m_activeCell = nullptr;
    }
 
  void LimitUndoBuffer(long undoLimit)
    {
      if (undoLimit == 0)
        return;
      while (static_cast<long>(m_undoActions.size()) > undoLimit)
        DiscardAction(&m_undoActions);
    }
 
  void CellEntered(GroupCell *group, const wxString &text,
                   long long selStart, long long selEnd)
    {
      m_activeCell = group;
      m_activeCellOldText = text;
      m_activeCellOldSelStart = selStart;
      m_activeCellOldSelEnd = selEnd;
    }
 
  bool CellLeft(GroupCell *activeCell, const wxString &currentText,
                long undoLimit)
    {
      if (m_activeCell) //-V1051
        wxASSERT_MSG(m_activeCell == activeCell,
                     _("Bug: Cell left but not entered."));
 
      // We only can undo a text change if the text has actually changed.
      if ((m_activeCellOldText.Length() > 1) &&
          (m_activeCellOldText != currentText) &&
          (m_activeCellOldText + wxS(";") != currentText)) {
        m_undoActions.emplace_front(activeCell, m_activeCellOldText,
                                    m_activeCellOldSelStart,
                                    m_activeCellOldSelEnd);
        LimitUndoBuffer(undoLimit);
        ClearRedoActionList();
        return true;
      }
      return false;
    }
 
  void ForgetActiveCell() { m_activeCell = nullptr; }
 
  GroupCell *ActiveCell() const { return m_activeCell; }
 
private:
  UndoActions m_undoActions;
 
  UndoActions m_redoActions;
 
  CellPtr<GroupCell> m_activeCell;
 
  wxString m_activeCellOldText;
 
  long long m_activeCellOldSelStart = -1;
  long long m_activeCellOldSelEnd = -1;
};
 
#endif // TREEUNDOMANAGER_H