Worksheet.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2004-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//            (C) 2012-2013 Doug Ilijev <doug.ilijev@gmail.com>
//            (C) 2015      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 WORKSHEET_H
#define WORKSHEET_H
 
#include "stx/optional.hpp"
#include "precomp.h"
#include "MaximaManual.h"
#include "EventIDs.h"
#include "RecentDocuments.h"
#include <wx/wx.h>
#include <wx/xml/xml.h>
#include <wx/aui/aui.h>
#include <wx/textfile.h>
#include <wx/fdrepdlg.h>
#include <wx/dc.h>
#include <vector>
#include <utility>
#include <memory>
#include <list>
#include "CellPointers.h"
#include "sidebars/VariablesPane.h"
#include "Notification.h"
#include "cells/Cell.h"
#include "cells/EditorCell.h"
#include "cells/ImgCell.h"
#include "cells/ImgCellBase.h"
#include "cells/AnimationCell.h"
#include "cells/GroupCell.h"
#include "cells/TextCell.h"
#include "EvaluationQueue.h"
#include "dialogs/FindReplaceDialog.h"
#include "Autocomplete.h"
#include "AutocompletePopup.h"
#include "sidebars/UnicodeSidebar.h"
#include "ToolBar.h"
#include <thread>
 
class Worksheet : public wxScrolled<wxWindow>
{
public:
  RecentDocuments m_unsavedDocuments;
  bool UpdateControlsNeeded(){bool result = m_updateControls; m_updateControls = false; return result;}
  void UpdateControlsNeeded(bool updateControlsNeeded){m_updateControls = updateControlsNeeded;}
private:
  wxString m_maximaDocDir;
  bool m_updateControls = true;
  bool m_scrollToCaret = false;
  CellPointers m_cellPointers;
  // The x position to scroll to
  int m_newxPosition = -1;
  // The y position to scroll to
  int m_newyPosition = -1;
  double m_zoomAtGestureStart = 1.0;
  bool m_scrollToTopOfCell = false;
  bool m_windowActive = true;
  wxRegion m_regionToRefresh;
  int m_scrollUnit = 10;
  wxClientDC m_dc;
  CellPtr<GroupCell> m_redrawStart;
  bool m_fullRedrawRequested = false;
 
  static wxDataFormat m_wxmFormat;
  static wxDataFormat m_mathmlFormat;
  static wxDataFormat m_mathmlFormat2;
  static wxDataFormat m_rtfFormat;
  static wxDataFormat m_rtfFormat2;
 
  class MathMLDataObject : public wxCustomDataObject
  {
  public:
    explicit MathMLDataObject(const wxString &data);
 
    MathMLDataObject();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class wxmDataObject : public wxCustomDataObject
  {
  public:
    explicit wxmDataObject(const wxString &data);
 
    wxmDataObject();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class MathMLDataObject2 : public wxCustomDataObject
  {
  public:
    explicit MathMLDataObject2(const wxString &data);
 
    MathMLDataObject2();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class RtfDataObject : public wxCustomDataObject
  {
  public:
    explicit RtfDataObject(const wxString &data);
 
    RtfDataObject();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class RtfDataObject2 : public wxCustomDataObject
  {
  public:
    explicit RtfDataObject2(const wxString &data);
 
    RtfDataObject2();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  bool m_hasFocus = true;
  long m_lastTop = 0;
  long m_lastBottom = 0;
  class TreeUndoAction
  {
  public:
    TreeUndoAction(GroupCell *start, const wxString &oldText) :
      m_start(start), m_oldText(oldText)
      {
        wxASSERT_MSG(start, _("Bug: Trying to record a cell contents change for undo without a cell."));
      }
    TreeUndoAction(GroupCell *start, GroupCell *end) :
      m_start(start), m_newCellsEnd(end)
      {
        wxASSERT_MSG(start, _("Bug: Trying to record a cell contents change for undo without a cell."));
      }
    TreeUndoAction(GroupCell *start, GroupCell *end, GroupCell *oldCells) :
      m_start(start), m_newCellsEnd(end), m_oldCells(oldCells)
      {
      }
 
    bool m_partOfAtomicAction = false;
 
    GroupCell *const m_start = nullptr;
 
    const wxString m_oldText;
 
    GroupCell *const m_newCellsEnd = nullptr;
 
    std::unique_ptr<GroupCell> m_oldCells;
  };
 
  using UndoActions = std::list<TreeUndoAction>;
 
  UndoActions treeUndoActions;
 
  UndoActions treeRedoActions;
 
  wxString m_treeUndo_ActiveCellOldText;
 
  void TreeUndo_ClearRedoActionList();
 
  void TreeUndo_ClearUndoActionList();
 
  static void TreeUndo_DiscardAction(UndoActions *actionList);
 
  static void TreeUndo_AppendAction(UndoActions *actionList)
    {
      if(!actionList->empty())
        actionList->front().m_partOfAtomicAction = true;
    }
 
  void TreeUndo_AppendAction(){TreeUndo_AppendAction(&treeUndoActions);}
 
  CellPtr<GroupCell> TreeUndo_ActiveCell;
 
  void TreeUndo_LimitUndoBuffer();
 
  bool TreeUndo(UndoActions *sourcelist, UndoActions *undoForThisOperation);
 
  bool TreeUndoTextChange(UndoActions *sourcelist, UndoActions *undoForThisOperation);
  bool TreeUndoCellDeletion(UndoActions *sourcelist, UndoActions *undoForThisOperation);
  bool TreeUndoCellAddition(UndoActions *sourcelist, UndoActions *undoForThisOperation);
 
  bool TreeUndo()
    { return TreeUndo(&treeUndoActions, &treeRedoActions); }
 
  bool TreeRedo()
    { return TreeUndo(&treeRedoActions, &treeUndoActions); }
 
  bool CanTreeUndo() const;
 
  bool CanTreeRedo() const;
 
  void TreeUndo_CellEntered();
 
  void TreeUndo_CellLeft();
 
  void TreeUndo_MarkCellsAsAdded(GroupCell *start, GroupCell *end, UndoActions *undoBuffer);
 
 
  void TreeUndo_MarkCellsAsAdded(GroupCell *parentOfStart, GroupCell *end);
 
  bool m_scrolledAwayFromEvaluation = false;
 
  wxString EscapeHTMLChars(wxString input);
 
  wxString PrependNBSP(wxString input);
 
  enum ClickType
  {
    CLICK_TYPE_NONE,
    CLICK_TYPE_GROUP_SELECTION,
    CLICK_TYPE_INPUT_SELECTION,
    CLICK_TYPE_INPUT_LABEL_SELECTION,
    CLICK_TYPE_OUTPUT_SELECTION
  };
 
  enum TimerIDs
  {
    TIMER_ID,
    CARET_TIMER_ID,
    DISPLAY_TIMEOUT_ID
  };
 
  static void AddLineToFile(wxTextFile &output, const wxString &s);
 
  std::unique_ptr<Cell> CopySelection(bool asData = false) const;
 
  std::unique_ptr<Cell> CopySelection(Cell *start, Cell *end, bool asData = false) const;
 
  void GetMaxPoint(int *width, int *height);
 
  void OnTimer(wxTimerEvent &event);
 
#if wxCHECK_VERSION(3, 1, 1)
  void OnZoom(wxZoomGestureEvent &event);
#endif
 
  void OnMouseExit(wxMouseEvent &event);
 
  void OnMouseEnter(wxMouseEvent &event);
 
  void OnPaint(wxPaintEvent &event);
  void DrawGroupCell(wxDC &dc, wxDC &adc, GroupCell &cell);
  void DrawGroupCell_UsingBitmap(wxDC *dc, GroupCell *cell);
 
  void PrepareDrawGC(wxDC &dc) const;
 
  void OnSize(wxSizeEvent &event);
 
  void OnMouseRightDown(wxMouseEvent &event);
 
  void OnSidebarKey(wxCommandEvent &event);
 
  void OnMouseLeftUp(wxMouseEvent &event);
 
  void OnMouseCaptureLost(wxMouseCaptureLostEvent &event);
 
  void OnMouseLeftDown(wxMouseEvent &event);
 
  void OnMouseLeftInGcCell(wxMouseEvent &event, GroupCell *clickedInGC);
 
  void OnMouseLeftInGcLeft(wxMouseEvent &event, GroupCell *clickedInGC);
 
  void OnMouseLeftInGc(wxMouseEvent &event, GroupCell *clickedInGC);
 
  void OnMouseMotion(wxMouseEvent &event);
 
  void OnDoubleClick(wxMouseEvent &event);
 
  void OnCharInActive(wxKeyEvent &event);
 
  void OnCharNoActive(wxKeyEvent &event);
 
  void SelectEditable(EditorCell *editor, bool up);
 
  void SelectWithChar(int ccode);
 
  void ClickNDrag(wxPoint down, wxPoint up);
 
  // Select all group cells inside the given rectangle;
  void SelectGroupCells(wxPoint down, wxPoint up);
 
  void AdjustSize();
 
  void OnEraseBackground(wxEraseEvent& WXUNUSED(event))
    {}
 
  void CheckUnixCopy();
 
  void OnMouseMiddleUp(wxMouseEvent &event);
 
  static bool IsLesserGCType(int type, int comparedTo);
 
  static GroupCell *StartOfSectioningUnit(GroupCell *start);
 
  GroupCell *EndOfSectioningUnit(GroupCell *start);
 
  void OnComplete(wxCommandEvent &event);
 
  void EraseBackground(wxEraseEvent &event);
 
  wxPoint m_leftDownPosition;
  wxPoint m_down;
  wxPoint m_up;
  wxPoint m_mousePoint;
  bool m_hCaretActive = true;
  CellPtr<GroupCell> m_hCaretPosition;
  CellPtr<GroupCell> m_hCaretPositionStart;
  CellPtr<GroupCell> m_hCaretPositionEnd;
  bool m_leftDown = false;
  bool m_followEvaluation = true;
  bool m_mouseDrag = false;
  bool m_mouseOutside = false;
  mutable bool m_adjustWorksheetSizeNeeded = false;
  GroupCell *GetLastCellInWorksheet() const;
  int m_clickType = CLICK_TYPE_NONE;
  CellPtr<GroupCell> m_clickInGC;
  bool m_blinkDisplayCaret = true;
  bool m_hCaretBlinkVisible = true;
  wxTimer m_timer;
  wxTimer m_caretTimer;
  bool m_saved = true;
  std::vector<wxString> m_completions;
  bool m_autocompleteTemplates = true;
  AutocompletePopup *m_autocompletePopup;
 
public:
  bool IsEmpty() const
    { return !m_tree || (!m_tree->GetNext() && m_tree->GetEditable()->GetValue().Length() <= 1); }
  void CloseAutoCompletePopup()
    {
      if(m_autocompletePopup != NULL)
        m_autocompletePopup->Destroy();
    }
 
  void OnChar(wxKeyEvent &event);
 
  void OnKeyDown(wxKeyEvent &event);
  void SetCellStyle(GroupCell *group, GroupType style);
 
  void NumberSections() const;
 
  bool SectioningMoveIn(GroupCell *parent);
  bool SectioningMoveOut(GroupCell *parent);
  stx::optional<Notification> m_notificationMessage;
  void WindowActive(bool active){m_windowActive = active;}
  void ClearNotification();
  void SetNotification(const wxString &message, int flags = wxICON_INFORMATION);
 
  void OnActivate(wxActivateEvent &event);
private:
  std::unique_ptr<GroupCell> m_tree;
  mutable CellPtr<GroupCell> m_last;
//  std::vector<std::thread> m_drawThreads;
  static std::mutex m_drawDCLock;
  Configuration *m_configuration = NULL;
public:
  void FocusFindDialogue()
    {
      if(m_findDialog)
        m_findDialog->SetFocus();
    }
  AutoComplete m_autocomplete;
 
  EditorCell *GetActiveCell() const { return m_cellPointers.m_activeCell; }
 
  EditorCell *KeyboardSelectionStart() const
    { return m_cellPointers.m_cellKeyboardSelectionStartedIn; }
 
  EditorCell *MouseSelectionStart() const
    { return m_cellPointers.m_cellMouseSelectionStartedIn; }
 
  EditorCell *SearchStart() const
    { return m_cellPointers.m_cellSearchStartedIn; }
 
  int IndexSearchStartedAt() const
    { return m_cellPointers.m_indexSearchStartedAt; }
 
  CellPointers &GetCellPointers() { return m_cellPointers; }
 
  CellPointers::ErrorList &GetErrorList() { return m_cellPointers.m_errorList; }
  TextCell *GetCurrentTextCell() const { return m_cellPointers.m_currentTextCell; }
  void SetCurrentTextCell(TextCell *cell) { m_cellPointers.m_currentTextCell = cell; }
  void SetWorkingGroup(GroupCell *group) { m_cellPointers.SetWorkingGroup(group); }
 
  void UpdateTableOfContents();
 
  void MarkRefreshAsDone()
    {
      m_redrawStart = NULL;
      m_fullRedrawRequested = false;
    }
 
  bool RedrawIfRequested();
 
  void RequestRedraw(GroupCell *start = NULL);
  void RequestRedraw(wxRect rect);
 
  void ForceRedraw()
    {
      RequestRedraw();
      RedrawIfRequested();
    }
 
  void CodeCellVisibilityChanged();
 
  void UpdateConfig() {
    m_configuration->ReadConfig();
    Recalculate();
    Refresh();
  }
 
  wxString m_currentFile;
 
  const wxString UnicodeToMaxima(wxString s);
 
  void ScrollToStart() { Scroll(0, 0); }
 
  void ScrollToError();
 
  FindReplaceDialog *m_findDialog = NULL;
 
  bool HCaretActive() const { return m_hCaretActive; }
 
  bool CanMergeSelection() const;
 
  bool CanUndo() const;
 
  bool CanRedo() const;
 
  void Undo();
 
  void Redo();
 
  void TreeUndo_ClearBuffers();
 
  Worksheet(wxWindow *parent, int id, Configuration *config,
            wxPoint pos = wxDefaultPosition, wxSize size = wxDefaultSize,
            bool reactToEvents = true);
 
  virtual ~Worksheet();
 
  wxTimer m_keyboardInactiveTimer;
 
  void DestroyTree();
 
  std::unique_ptr<GroupCell> CopyTree() const;
 
  GroupCell *InsertGroupCells(std::unique_ptr<GroupCell> &&cells, GroupCell *where,
                              UndoActions *undoBuffer);
 
  GroupCell *InsertGroupCells(std::unique_ptr<GroupCell> &&cells, GroupCell *where = NULL);
 
  void InsertLine(std::unique_ptr<Cell> &&newCell, bool forceNewLine = false);
 
  GroupCell *GetInsertGroup() const;
 
  bool RecalculateIfNeeded(bool timeout = false);
 
  void Recalculate(Cell *start);
 
  void Recalculate() { Recalculate(GetTree()); }
 
  void ClearDocument();
 
  void ResetInputPrompts();
 
  bool CanCopy() const
    {
      return m_cellPointers.m_selectionStart ||
        (m_cellPointers.m_activeCell &&
         m_cellPointers.m_activeCell->CanCopy());
    }
 
  bool CanPaste() const
    { return m_cellPointers.m_activeCell || m_hCaretActive; }
 
  bool CanCut() const
    {
      return (m_cellPointers.m_activeCell && m_cellPointers.m_activeCell->CanCopy()) ||
        (m_cellPointers.m_selectionStart && m_cellPointers.m_selectionStart->GetType() == MC_TYPE_GROUP);
    }
 
  void SelectAll();
 
  bool HasCellsSelected() const { return m_cellPointers.HasCellsSelected(); }
 
  void DeleteRegion(
    GroupCell *start,
    GroupCell *end,
    UndoActions *undoBuffer
    );
 
  void DeleteRegion(
    GroupCell *start,
    GroupCell *end
    );
 
  void DeleteSelection();
 
  void TOCdnd(GroupCell *dndStart, GroupCell *dndEnd);
 
  bool CanDeleteRegion(GroupCell *start, const GroupCell *end) const;
 
  bool CanDeleteSelection() const;
 
  void DeleteCurrentCell();
 
  AnimationCell *GetSelectedAnimation() const
    {
      if(m_cellPointers.m_selectionStart != m_cellPointers.m_selectionEnd)
        return NULL;
      return dynamic_cast<AnimationCell *>(GetSelectionStart());
    }
 
  ImgCell *GetSelectedImgCell() const
    {
      if(m_cellPointers.m_selectionStart != m_cellPointers.m_selectionEnd)
        return NULL;
      return dynamic_cast<ImgCell *>(GetSelectionStart());
    }
  
  ImgCellBase *GetSelectedImgCellBase() const
    {
      if(m_cellPointers.m_selectionStart != m_cellPointers.m_selectionEnd)
        return NULL;
      return dynamic_cast<ImgCellBase *>(GetSelectionStart());
    }
 
  TextCell *GetSelectedTextCell() const
    {
      if(m_cellPointers.m_selectionStart != m_cellPointers.m_selectionEnd)
        return NULL;
      return dynamic_cast<TextCell *>(GetSelectionStart());
    }
 
  bool CanAnimate() const
    {
      return m_cellPointers.m_selectionStart && m_cellPointers.m_selectionStart == m_cellPointers.m_selectionEnd &&
        (dynamic_cast<AnimationCell *>(GetSelectionStart()) != NULL);
    }
 
  void Animate(bool run = true) const;
 
  void DivideCell();
 
  void MergeCells();
 
  void SetLastQuestion(const wxString &lastQuestion){m_lastQuestion = lastQuestion;}
  wxString GetLastQuestion() const {return m_lastQuestion;}
 
  bool CutToClipboard();
 
  void PasteFromClipboard();
 
  bool Copy(bool astext = false) const;
 
  bool CopyCells() const;
 
  bool CopyMatlab() const;
 
  bool CopyText() const;
 
  bool CopyTeX() const;
 
  wxString ConvertSelectionToMathML() const;
 
  wxBitmap ConvertSelectionToBitmap() const;
 
  bool CopyMathML() const;
 
  bool CopyBitmap() const;
 
  bool CopyAnimation() const;
 
  bool CopySVG() const;
 
#if wxUSE_ENH_METAFILE
  bool CopyEMF() const;
#endif
 
  bool CopyRTF() const;
 
  wxSize CopyToFile(const wxString &file) const;
 
  wxSize CopyToFile(const wxString &file, Cell *start, Cell *end, bool asData = false, double scale = 1) const;
 
  void CalculateReorderedCellIndices(GroupCell *tree, int &cellIndex, std::vector<int> &cellMap);
 
  bool ExportToHTML(const wxString &file);
 
  void
  ExportToMAC(wxTextFile &output, GroupCell *tree, bool wxm, const std::vector<int> &cellMap, bool fixReorderedIndices);
 
  bool ExportToMAC(const wxString &file);
 
  wxString RTFStart() const;
 
  wxString RTFEnd() const;
 
  bool ExportToTeX(const wxString &file);
 
  wxString GetString(bool lb = false) const;
 
  GroupCell *GetTree() const { return m_tree.get(); }
  std::unique_ptr<GroupCell> *GetTreeAddress() { return &m_tree; }
 
  Cell *GetSelectionStart() const
    { return m_cellPointers.m_selectionStart; }
 
  Cell *GetSelectionEnd() const
    { return m_cellPointers.m_selectionEnd; }
 
  void ClearSelection() { SetSelection(nullptr, nullptr); }
 
  void SetSelection(Cell *sel) { SetSelection(sel, sel); }
 
  void SetSelection(Cell *start, Cell *end);
 
  bool CanEdit();
 
  bool ActivatePrevInput() { return ActivateInput(-1); }
  bool ActivateNextInput() { return ActivateInput(+1); }
  wxString GetStatusText() const {return m_statusText;}
  bool StatusTextChangedHas() {
    bool retval = (m_statusTextHas != m_statusTextHas_old) ||
      (m_statusText != m_statusText_old);
    m_statusText_old = m_statusText;
    m_statusTextHas_old = m_statusTextHas;
    return retval;
  }
  bool StatusTextHas() const {return m_statusTextHas;}
private:
  /* ! A timer that tells us to urgently update the display
 
     Normally we prioritize tasks: If there are GUI actions to process we do so.
     If not we look if there is data from maxima to process. If not we
     If not we recalculate the worksheet element sizes and positions and if
     there still is no pressing task we update the display. This way we
     respond quickly to the most important inputs.
 
     This timer, if expired, tells us that if we don't update the screen now
     maxima feels like not being responsive.
  */
  wxTimer m_displayTimeoutTimer;
 
  template <class T_SRC, class T_DEST>
  inline std::unique_ptr<T_DEST> unique_cast(std::unique_ptr<T_SRC> &&src)
    {
      if (!src) return std::unique_ptr<T_DEST>();
 
      T_DEST *dest_ptr = &dynamic_cast<T_DEST &>(*src.get());
 
      (void) src.release();
      return std::unique_ptr<T_DEST>(dest_ptr);
    }
  wxString m_statusText;
  wxString m_statusText_old;
  bool m_statusTextHas = false;
  bool m_statusTextHas_old = false;
  void StatusText(const wxString &text){m_statusText = text; m_statusTextHas = true;}
  void UnsetStatusText(){m_statusTextHas = false;}
  bool ActivateInput(int direction);
 
public:
  void ScrollToCaret()
    {
      m_cellPointers.m_scrollToCell = false;
      m_scrollToCaret = true;
    }
 
  bool ScrollToCaretIfNeeded();
 
  void ScrollToCellIfNeeded();
 
  void ScheduleScrollToCell(Cell *cell, bool scrollToTop = true)
    {
      m_cellPointers.ScrollToCell(cell);
      m_scrollToTopOfCell = scrollToTop;
      m_scrollToCaret = false;
 
      m_cellPointers.m_scrollToCell = true;
    }
 
  bool PointVisibleIs(wxPoint point);
 
  bool CaretVisibleIs();
 
  GroupCell *FirstVisibleGC();
 
  void ShowPoint(wxPoint point);
 
  void OnSetFocus(wxFocusEvent &event);
 
  void OnKillFocus(wxFocusEvent &event);
 
  bool IsSelected(CellType type);
 
  void StepAnimation(int change = 1);
 
  bool IsActiveInLast() const
    { return m_cellPointers.m_activeCell && m_cellPointers.m_activeCell->GetGroup() == m_last; }
 
  GroupCell *GetLastCell()
    {
      return m_last;
    }
 
  bool IsSelectionInWorkingGroup();
 
  void SetActiveCell(EditorCell *cell);
 
  void SetDefaultHCaret();
 
  void SetHCaret(GroupCell *where); // call with false, when manually refreshing
  GroupCell *GetHCaret();
 
  void OpenHCaret(const wxString &txt = {})
    {
      if(m_mainToolBar == NULL)
        OpenHCaret(txt, GC_TYPE_CODE);
      else
        OpenHCaret(txt, m_mainToolBar->GetCellType());
    }
 
  void OpenHCaret(const wxString &txt, GroupType type);
 
  void ShowHCaret();
 
  bool CanUndoInsideCell() const;
 
  void UndoInsideCell();
 
  bool CanRedoInsideCell() const;
 
  void RedoInsideCell();
 
  void FollowEvaluation(bool followEvaluation);
 
  bool FollowEvaluation() const
    { return m_followEvaluation; }
 
  void ScrolledAwayFromEvaluation(bool ScrolledAway);
 
  bool ScrolledAwayFromEvaluation() const
    { return m_scrolledAwayFromEvaluation; }
 
  void SaveValue();
 
  bool IsSaved() const
    { return m_saved; }
 
  void SetSaved(bool saved)
    { if(m_saved != saved) m_updateControls = true; m_saved = saved;}
 
  void OutputChanged()
    {
      if(m_currentFile.EndsWith(".wxmx"))
        m_saved = false;
    }
 
  void RemoveAllOutput();
 
  void RemoveAllOutput(GroupCell *cell);
  // methods related to evaluation queue
 
  void Evaluate();
 
  void AddToEvaluationQueue(GroupCell *cell);
 
  void AddDocumentToEvaluationQueue();
 
  void AddEntireDocumentToEvaluationQueue();
 
  void AddDocumentTillHereToEvaluationQueue();
 
  void AddRestToEvaluationQueue();
 
  void AddSectionToEvaluationQueue(GroupCell *start);
 
  void AddSelectionToEvaluationQueue();
 
  void AddSelectionToEvaluationQueue(GroupCell *start, GroupCell *end);
 
  void AddCellToEvaluationQueue(GroupCell *gc);
 
  EvaluationQueue m_evaluationQueue;
 
  void FoldOccurred();
 
  // methods for folding
  GroupCell *ToggleFold(GroupCell *which);
 
  GroupCell *ToggleFoldAll(GroupCell *which);
 
  void FoldAll();
 
  void UnfoldAll();
 
  // methods for zooming the document in and out
  void SetZoomFactor(double newzoom);
 
  void CommentSelection();
 
  void OnScrollChanged(wxScrollEvent &ev);
  void OnScrollEvent(wxScrollWinEvent &ev);
  void OnMouseWheel(wxMouseEvent &event);
 
  bool FindIncremental(const wxString &str, bool down, bool ignoreCase);
  bool FindIncremental_RegEx(const wxString &str, bool down);
 
  bool FindNext(const wxString &str, bool down, bool ignoreCase, bool warn = true);
  bool FindNext_Regex(const wxString &str, const bool &down, bool warn = true);
 
  void Replace(const wxString &oldString, const wxString &newString, bool ignoreCase);
  void Replace_RegEx(const wxString &oldString, const wxString &newString);
 
  int ReplaceAll(const wxString &oldString, const wxString &newString, bool ignoreCase);
  int ReplaceAll_RegEx(const wxString &oldString, const wxString &newString);
 
  wxString GetInputAboveCaret();
 
  wxString GetOutputAboveCaret();
 
  void LoadSymbols();
 
  bool Autocomplete(AutoComplete::autoCompletionType type = AutoComplete::command);
 
  void AddSymbol(const wxString &fun, AutoComplete::autoCompletionType type = AutoComplete::command)
    { m_autocomplete.AddSymbol(fun, type); }
 
  void AddSymbols(const wxString &xml)
    { m_autocomplete.AddSymbols(xml); }
  void AddSymbols(wxXmlDocument xml)
    { m_autocomplete.AddSymbols(xml); }
 
  void SetActiveCellText(const wxString &text);
 
  bool InsertText(const wxString &text);
 
  void OpenNextOrCreateCell();
 
  void OnFollow();
 
  ToolBar *m_mainToolBar = NULL;
 
  void SelectGroupCell(GroupCell *cell);
 
  void SetAnswer(const wxString &answer);
  void QuestionAnswered();
 
  bool m_questionPrompt = false;
 
  bool QuestionPending() const
    { return m_questionPrompt; }
 
  void QuestionPending(bool pending)
    { m_questionPrompt = pending; }
 
  void SetMaximaDocDir(const wxString &dir)
    {
      m_maximaDocDir = dir;
    }
 
  bool GCContainsCurrentQuestion(const GroupCell *cell);
 
  void OpenQuestionCaret(const wxString &txt = {});
  void UpdateScrollPos();
 
  GroupCell *GetWorkingGroup(bool resortToLast = false) const;
  void LoadHelpFileAnchors(const wxString &docdir, const wxString &maximaVersion)
    {m_maximaManual.LoadHelpFileAnchors(docdir, maximaVersion);}
  wxString GetHelpfileAnchorName(const wxString &keyword)
    {return m_maximaManual.GetHelpfileAnchorName(keyword);}
  wxString GetHelpfileURL(const wxString &keyword)
    {return m_maximaManual.GetHelpfileURL(keyword);}
  int GetCellIndex(Cell *cell) const;
 
  std::vector<wxString> m_replacementsForCurrentWord;
  //Simple iterator over a Maxima input string, skipping comments and strings
  class SimpleMathConfigurationIterator
  {
  public:
    explicit SimpleMathConfigurationIterator(const wxString &ainput);
 
    void operator++();
 
    bool isValid() const
      { return pos < input.length(); }
 
 
    inline wxChar operator*() const
      { return input[pos]; }
 
    std::size_t pos;
 
    const wxString &input;
  };
 
#if wxUSE_ACCESSIBILITY
  class AccessibilityInfo: public wxAccessible
  {
  public:
    AccessibilityInfo(wxWindow *parent, Worksheet *worksheet);
    wxAccStatus GetChildCount (int *childCount);
    wxAccStatus GetChild (int childId, wxAccessible **child);
    wxAccStatus GetDefaultAction(int childId, wxString *actionName);
    wxAccStatus GetParent (wxAccessible ** parent);
//    wxAccStatus GetFocus (int *childId, wxAccessible **child);
    wxAccStatus GetLocation (wxRect &rect, int elementId);
    wxAccStatus HitTest         (const wxPoint &pt,
                                 int *childId, wxAccessible **childObject);
    wxAccStatus GetDescription(int childId, wxString *description);
  private:
    wxWindow *m_parent = NULL;
    Worksheet *m_worksheet = NULL;
  };
#endif
  MaximaManual m_maximaManual;
  MaximaManual *GetMaximaManual() {return &m_maximaManual;}
protected:
  void FocusTextControl();
  wxString m_lastQuestion;
  int m_virtualWidth_Last = -1;
  int m_virtualHeight_Last = -1;
  wxBitmap m_memory;
  virtual wxSize DoGetBestClientSize() const override;
#if wxUSE_ACCESSIBILITY
  AccessibilityInfo *m_accessibilityInfo = NULL;
#endif
  void UpdateConfigurationClientSize();
  CellPtr<GroupCell> m_recalculateStart;
  int m_pointer_x = -1;
  int m_pointer_y = -1;
  bool m_mouseMotionWas = false;
  bool m_inPopupMenu = false;
};
 
inline Worksheet *Cell::GetWorksheet() const
{
  wxWindow *worksheet = m_configuration->GetWorkSheet();
  wxASSERT(worksheet != NULL);
  return static_cast<Worksheet*>(worksheet);
}
 
wxDECLARE_EVENT(TOC_UPDATE_NEEDED_EVENT, wxCommandEvent);
 
#endif // WORKSHEET_H