CellPointers.h

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2004-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//  Copyright (C) 2014-2018 Gunter Königsmann <wxMaxima@physikbuch.de>
//  Copyright (C) 2020      Kuba Ober <kuba@bertec.com>
//
//  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 WXMAXIMA_CELLPOINTERS_H
#define WXMAXIMA_CELLPOINTERS_H
 
#include "cells/Cell.h"
#include "cells/MatrixBlock.h"
#include <optional>
#include <utility>
#include <wx/string.h>
#include <vector>
 
class wxWindow;
template<class T> class wxScrolled;
using wxScrolledCanvas = wxScrolled<wxWindow>;
 
class EditorCell;
class TextCell;
 
class DocumentCellPointers
{
public:
  class ErrorList
  {
  public:
    ErrorList() = default;
    bool Empty() const { return m_errors.empty(); }
    void Remove(GroupCell * cell);
    bool Contains(GroupCell * cell) const;
    void Add(GroupCell * cell);
    GroupCell *FirstError() const;
    GroupCell *LastError() const;
    void Clear() { m_errors.clear(); }
  private:
    std::vector<CellPtr<GroupCell>> m_errors;
  };
 
 
  GroupCell *GetWorkingGroup(bool resortToLast = false) const;
  void SetWorkingGroup(GroupCell *group);
  GroupCell *GetLastWorkingGroup() const { return m_lastWorkingGroup; }
 
  bool HasCellsSelected() const { return m_selectionStart && m_selectionEnd; }
 
  const CellPtr<Cell> &GetSelectionStart() const { return m_selectionStart; }
  const CellPtr<Cell> &GetSelectionEnd() const { return m_selectionEnd; }
  void SetSelectionStart(Cell *cell) { m_selectionStart = cell; m_blockMatrix = {}; }
  void SetSelectionEnd(Cell *cell) { m_selectionEnd = cell; m_blockMatrix = {}; }
 
  void SetSelectedMatrixBlock(Cell *matrix, const MatrixEntry &anchor,
                              const MatrixEntry &corner,
                              bool wholeMatrix = false) {
    m_selectionStart = matrix;
    m_selectionEnd = matrix;
    m_blockMatrix = matrix;
    m_blockAnchor = anchor;
    m_blockCorner = corner;
    m_blockIsWholeMatrix = wholeMatrix;
  }
  std::optional<MatrixBlock> GetSelectedMatrixBlock() const {
    if (IsBlockMatrixSelected() && !m_blockIsWholeMatrix)
      return MatrixBlock::Spanning(m_blockAnchor, m_blockCorner);
    return std::nullopt;
  }
  struct BlockCorners
  {
    MatrixEntry anchor;
    MatrixEntry corner;
  };
  std::optional<BlockCorners> GetSelectedMatrixBlockCorners() const {
    if (IsBlockMatrixSelected())
      return BlockCorners{m_blockAnchor, m_blockCorner};
    return std::nullopt;
  }
 
  // The out-of-line definitions convert a CellPtr to (or a raw pointer from)
  // EditorCell*/TextCell*, which needs the complete type this header only
  // forward-declares.
  EditorCell *GetAnswerCell() const;
  void SetAnswerCell(EditorCell *cell);
  void ClearAnswerCell() { m_answerCell = {}; }
  void ClearAnswerCellIfInGroup(GroupCell *group);
 
  TextCell *GetCurrentTextCell() const;
  void SetCurrentTextCell(TextCell *cell);
 
  EditorCell *GetActiveCell() const;
  void SetActiveCell(EditorCell *cell);
  void ClearActiveCell() { m_activeCell = {}; }
 
  const wxString &GetSelectionString() const { return m_selectionString; }
  void SetSelectionString(const wxString &str) { m_selectionString = str; }
  void ClearSelectionString() { m_selectionString.Clear(); }
 
  ErrorList &GetErrorList() { return m_errorList; }
  const ErrorList &GetErrorList() const { return m_errorList; }
 
  void SetEvaluatingStatement(EditorCell *editor, std::size_t start,
                              std::size_t end, const wxString &text);
  std::optional<std::pair<std::size_t, std::size_t>>
  GetEvaluatingStatement(const EditorCell *editor, const wxString &text) const;
 
private:
  CellPtr<GroupCell> m_workingGroup;
  CellPtr<GroupCell> m_lastWorkingGroup;
  CellPtr<EditorCell> m_answerCell;
  CellPtr<TextCell> m_currentTextCell;
  CellPtr<EditorCell> m_activeCell;
  CellPtr<Cell> m_selectionStart;
  CellPtr<Cell> m_selectionEnd;
  CellPtr<Cell> m_blockMatrix;
  MatrixEntry m_blockAnchor;
  MatrixEntry m_blockCorner;
  bool m_blockIsWholeMatrix = false;
  bool IsBlockMatrixSelected() const {
    return m_blockMatrix && (m_selectionStart == m_blockMatrix) &&
      (m_selectionEnd == m_blockMatrix);
  }
  wxString m_selectionString;
  ErrorList m_errorList;
  CellPtr<EditorCell> m_evaluatingEditor;
  std::size_t m_evaluatingStart = 0;
  std::size_t m_evaluatingEnd = 0;
  wxString m_evaluatingText;
};
 
class ViewCellPointers
{
public:
  explicit ViewCellPointers(wxScrolledCanvas *worksheet) : m_worksheet(worksheet) {}
 
  void ScrollToCell(Cell *cell) { m_cellToScrollTo = cell; }
  Cell *CellToScrollTo() { return m_cellToScrollTo; }
 
  bool ScrollToCellScheduled() const { return m_scrollToCell; }
  void SetScrollToCellScheduled(bool scheduled) { m_scrollToCell = scheduled; }
 
  const CellPtr<EditorCell> &SearchStart() const { return m_cellSearchStartedIn; }
  int IndexSearchStartedAt() const { return m_indexSearchStartedAt; }
  void SetSearchStart(EditorCell *cell, int index);
  void ResetSearchStart()
    {
      m_cellSearchStartedIn = {};
      m_indexSearchStartedAt = -1;
    }
 
  const CellPtr<EditorCell> &MouseSelectionStart() const
    { return m_cellMouseSelectionStartedIn; }
  void SetMouseSelectionStart(EditorCell *cell);
  void ResetMouseSelectionStart()
    { m_cellMouseSelectionStartedIn = {}; }
 
  const CellPtr<EditorCell> &KeyboardSelectionStart() const
    { return m_cellKeyboardSelectionStartedIn; }
  void SetKeyboardSelectionStart(EditorCell *cell);
  void ResetKeyboardSelectionStart()
    { m_cellKeyboardSelectionStartedIn = {}; }
 
  void SetTimerIdForCell(Cell *cell, int timerId);
  int GetTimerIdForCell(Cell *cell) const;
  Cell *GetCellForTimerId(int timerId) const;
  void RemoveTimerIdForCell(const Cell *const cell);
 
  GroupCell *GetGroupCellUnderPointer() const;
  void SetGroupCellUnderPointer(GroupCell *cell);
  Cell *GetCellUnderPointer() const { return m_cellUnderPointer; }
  void SetCellUnderPointer(Cell *cell) { m_cellUnderPointer = cell; }
  void ClearCellUnderPointer() { m_cellUnderPointer = {}; }
 
  void WXMXResetCounter() { m_wxmxImgCounter = 0; }
  wxString WXMXGetNewFileName();
  std::size_t WXMXImageCount() const { return m_wxmxImgCounter; }
 
  wxScrolledCanvas *GetWorksheet() { return m_worksheet; }
 
private:
  CellPtr<GroupCell> m_groupCellUnderPointer;
  CellPtr<Cell> m_cellUnderPointer;
  CellPtr<EditorCell> m_cellMouseSelectionStartedIn;
  CellPtr<EditorCell> m_cellKeyboardSelectionStartedIn;
  CellPtr<EditorCell> m_cellSearchStartedIn;
  int m_indexSearchStartedAt = -1;
  bool m_scrollToCell = false;
  struct CellTimerId {
    // A CellPtr, not a raw pointer: animation timers fire asynchronously, so a
    // timer entry can outlive its cell. Auto-nulling means GetCellForTimerId()
    // returns nullptr for a destroyed cell instead of a dangling pointer, even
    // if RemoveTimerIdForCell() was somehow not reached (see the "Long-lived
    // cell references" rule in CellPtr.h).
    CellPtr<Cell> cell;
    int timerId = -1;
    CellTimerId() = default;
    CellTimerId(Cell *cell, int timerId) : cell(cell), timerId(timerId) {}
  };
  std::vector<CellTimerId> m_timerIds;
  CellPtr<Cell> m_cellToScrollTo;
  wxScrolledCanvas *const m_worksheet;
  std::size_t m_wxmxImgCounter = 0;
};
 
#endif