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 <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 <thread>
#include <list>
#include "CellPointers.h"
#include "VariablesPane.h"
#include "Notification.h"
#include "Cell.h"
#include "EditorCell.h"
#include "GroupCell.h"
#include "TextCell.h"
#include "EvaluationQueue.h"
#include "FindReplaceDialog.h"
#include "Autocomplete.h"
#include "AutocompletePopup.h"
#include "TableOfContents.h"
#include "UnicodeSidebar.h"
#include "ToolBar.h"
 
class Worksheet : public wxScrolled<wxWindow>
{
public:
  WX_DECLARE_STRING_HASH_MAP(wxString, HelpFileAnchors);
  bool UpdateControlsNeeded(){bool result = m_updateControls; m_updateControls = false; return result;}
private:
  wxString m_maximaVersion;
  wxString m_maximaDocDir;
  bool m_updateControls = true;
  bool m_scrollToCaret;
  CellPointers m_cellPointers;
  // The x position to scroll to
  int m_newxPosition;
  // The y position to scroll to
  int m_newyPosition;
  // false = collect scroll events without redrawing for every single one
  bool m_dontSkipScrollEvent;
  double m_zoomAtGestureStart;
  bool m_scrollToTopOfCell;
  bool m_windowActive;
  Configuration m_configurationTopInstance;
  wxRegion m_rectToRefresh;
  int m_scrollUnit;
  wxClientDC m_dc;
  GroupCell *m_redrawStart;
  bool m_redrawRequested;
 
  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(wxString data);
 
    wxmDataObject();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class MathMLDataObject2 : public wxCustomDataObject
  {
  public:
    explicit MathMLDataObject2(wxString data);
 
    MathMLDataObject2();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class RtfDataObject : public wxCustomDataObject
  {
  public:
    explicit RtfDataObject(wxString data);
 
    RtfDataObject();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  class RtfDataObject2 : public wxCustomDataObject
  {
  public:
    explicit RtfDataObject2(wxString data);
 
    RtfDataObject2();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  bool m_hasFocus;
  long m_lastTop;
  long m_lastBottom;
  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();
 
  void TreeUndo_DiscardAction(UndoActions *actionList);
 
  void TreeUndo_AppendAction(UndoActions *actionList)
    {
      if(!actionList->empty())
        actionList->front().m_partOfAtomicAction = true;
    }
 
  void TreeUndo_AppendAction(){TreeUndo_AppendAction(&treeUndoActions);}
 
  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;
 
  EditorCell *m_answerCell;
 
  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
  };
 
  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);
 
  bool m_autoSaveIntervalExpired;
 
  #if wxCHECK_VERSION(3,1,1)
  void OnZoom(wxZoomGestureEvent &event);
  #endif
 
  void OnMouseExit(wxMouseEvent &event);
 
  void OnMouseEnter(wxMouseEvent &event);
 
  void OnPaint(wxPaintEvent &event);
 
  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);
 
  bool IsLesserGCType(int type, int comparedTo);
 
  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;
  GroupCell *m_hCaretPosition;
  GroupCell *m_hCaretPositionStart;
  GroupCell *m_hCaretPositionEnd;
  bool m_leftDown;
  bool m_followEvaluation;
  bool m_mouseDrag;
  bool m_mouseOutside;
  std::unique_ptr<GroupCell> m_tree;
  GroupCell *m_last;
  int m_clickType;
  int m_clickType_selectionStart;
  GroupCell *m_clickInGC;
  bool m_blinkDisplayCaret;
  bool m_hCaretBlinkVisible;
  wxTimer m_timer;
  wxTimer m_caretTimer;
  bool m_saved;
  wxArrayString m_completions;
  bool m_autocompleteTemplates;
  AutocompletePopup *m_autocompletePopup;
 
public:
  wxString GetMaximaHelpFile();
  void SetMaximaVersion(wxString version){m_maximaVersion = version;}
  wxString GetMaximaVersion(){return m_maximaVersion;}
  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();
 
  bool SectioningMoveIn();
  bool SectioningMoveOut();
  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);
  Configuration *m_configuration;
  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()
  { 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); }
 
  Worksheet* &m_observer;
 
  void UpdateTableOfContents() { m_scheduleUpdateToc = true; }
 
  void MarkRefreshAsDone()
  {
    m_redrawStart = NULL;
    m_redrawRequested = false;
  }
 
  bool RedrawIfRequested();
 
  void RequestRedraw(GroupCell *start = NULL);
  void RequestRedraw(wxRect rect);
 
  void ForceRedraw()
  {
    RequestRedraw();
    RedrawIfRequested();
  }
 
  bool RedrawRequested() const
    { return m_redrawRequested || m_mouseMotionWas || m_rectToRefresh.IsEmpty(); }
 
  void CodeCellVisibilityChanged();
 
  void UpdateConfig() { m_configuration->ReadConfig(); }
 
  std::unique_ptr<std::thread> m_helpfileanchorsThread;
 
  wxString m_currentFile;
 
  wxString UnicodeToMaxima(wxString s);
 
  void ScrollToStart() { Scroll(0, 0); }
 
  void ScrollToError();
 
  FindReplaceDialog *m_findDialog;
 
  bool m_scheduleUpdateToc;
 
  bool HCaretActive() const { return m_hCaretActive; }
 
  bool CanMergeSelection() const;
 
  bool CanUndo() const { return CanTreeUndo() || CanUndoInsideCell(); }
 
  bool CanRedo() const { return CanTreeRedo() || CanRedoInsideCell(); }
 
  void Undo();
 
  void Redo();
 
  void TreeUndo_ClearBuffers();
 
  enum PopIds
  {
    popid_comment_selection = wxID_HIGHEST + 500,
    popid_divide_cell,
    popid_copy_image,
    popid_copy_animation,
    popid_copy_svg,
    popid_copy_emf,
    popid_copy_rtf,
    popid_add_watch,
    popid_add_watch_label,
    popid_special_constant_percent,
    popid_changeasterisk,
    popid_hideasterisk,
    popid_delete,
    popid_simplify,
    popid_expand,
    popid_factor,
    popid_solve,
    popid_solve_num,
    popid_integrate,
    popid_diff,
    popid_subst,
    popid_plot2d,
    popid_plot3d,
    popid_float,
    popid_edit,
    popid_add_comment,
    popid_insert_input,
    popid_copy_matlab,
    popid_copy_tex,
    popid_copy_text,
    popid_copy_mathml,
    popid_labels_disable,
    popid_labels_user,
    popid_labels_useronly,
    popid_labels_autogenerated,
    popid_labelwidth,
    popid_labelwidth3,
    popid_labelwidth4,
    popid_labelwidth5,
    popid_labelwidth6,
    popid_labelwidth7,
    popid_labelwidth8,
    popid_labelwidth9,
    popid_labelwidth10,
    popid_digits_20,
    popid_digits_50,
    popid_digits_100,
    popid_digits_all,
    popid_digits_all_linebreak,
    popid_image,
    popid_change_image,
    popid_svg,
    popid_emf,
    popid_animation_save,
    popid_animation_start,
    popid_evaluate,
    popid_evaluate_section,
    popid_merge_cells,
    popid_insert_text,
    popid_insert_title,
    popid_insert_section,
    popid_insert_subsection,
    popid_insert_subsubsection,
    popid_insert_heading5,
    popid_insert_heading6,
    popid_auto_answer,
    popid_never_autoanswer,
    popid_popup_gnuplot,
    popid_fold,
    popid_unfold,
    popid_maxsizechooser,
    popid_resolutionchooser,
    popid_reloadimage,
    popid_suggestion1,
    popid_suggestion2,
    popid_suggestion3,
    popid_suggestion4,
    popid_suggestion5,
    popid_suggestion6,
    popid_suggestion7,
    popid_suggestion8,
    popid_suggestion9,
    popid_suggestion10,
    popid_hide_tooltipMarker,
    popid_hide_tooltipMarkerForThisMessage
  };
 
  Worksheet(wxWindow *parent, int id, Worksheet *&observer,
            wxPoint pos = wxDefaultPosition, wxSize size = wxDefaultSize);
 
  ~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;
 
  // Actually recalculate the worksheet.
  bool RecalculateIfNeeded();
 
  void Recalculate(Cell *start);
 
  void Recalculate() { Recalculate(GetTree()); }
 
  void RecalculateForce();
 
  void ClearDocument();
 
  void ResetInputPrompts();
 
  bool CanCopy(bool fromActive = false)
  {
    return m_cellPointers.m_selectionStart ||
           (fromActive && m_cellPointers.m_activeCell &&
            m_cellPointers.m_activeCell->CanCopy());
  }
 
  bool CanPaste()
  { return m_cellPointers.m_activeCell || m_hCaretActive; }
 
  bool CanCut()
  {
    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();
  
  bool CanDeleteRegion(GroupCell *start, GroupCell *end) const;
 
  bool CanDeleteSelection() const;
 
  void DeleteCurrentCell();
 
  bool CanAnimate()
  {
    return m_cellPointers.m_selectionStart && m_cellPointers.m_selectionStart == m_cellPointers.m_selectionEnd &&
           m_cellPointers.m_selectionStart->GetType() == MC_TYPE_SLIDE;
  }
 
  void Animate(bool run = true);
 
  void DivideCell();
 
  void MergeCells();
 
  void SetLastQuestion(const wxString &lastQuestion){m_lastQuestion = lastQuestion;}
  wxString GetLastQuestion(){return m_lastQuestion;}
 
  bool CutToClipboard();
 
  void PasteFromClipboard();
 
  bool Copy(bool astext = false);
 
  bool CopyCells();
 
  bool CopyMatlab();
 
  bool CopyText();
 
  bool CopyTeX();
 
  wxString ConvertSelectionToMathML();
 
  wxBitmap ConvertSelectionToBitmap();
 
  bool CopyMathML();
 
  bool CopyBitmap();
 
  bool CopyAnimation();
 
  bool CopySVG();
 
#if wxUSE_ENH_METAFILE
  bool CopyEMF();
#endif
 
  bool CopyRTF();
 
  wxSize CopyToFile(const wxString &file);
 
  wxSize CopyToFile(const wxString &file, Cell *start, Cell *end, bool asData = false, double scale = 1);
 
  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);
 
  bool ExportToWXMX(const wxString &file, bool markAsSaved = true);
 
  wxString RTFStart() const;
 
  wxString RTFEnd() const;
 
  bool ExportToTeX(const wxString &file);
 
  wxString GetString(bool lb = false);
 
  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(){return m_statusTextHas;}
private:
  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());
 
      src.release();
      return std::move(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(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()
  { return m_cellPointers.m_activeCell && m_cellPointers.m_activeCell->GetGroup() == m_last; }
 
  GroupCell *GetLastCell()
  {
    return m_last;
  }
 
  bool IsSelectionInWorkingGroup();
 
  void SetActiveCell(EditorCell *cell, bool callRefresh = true);
 
  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()
  { return m_scrolledAwayFromEvaluation; }
 
  void SaveValue();
 
  bool IsSaved()
  { 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;
 
  // methods for folding
  GroupCell *UpdateMLast();
 
  void FoldOccurred();
 
  GroupCell *ToggleFold(GroupCell *which);
 
  GroupCell *ToggleFoldAll(GroupCell *which);
 
  void FoldAll();
 
  void UnfoldAll();
 
  // methods for zooming the document in and out
  void SetZoomFactor(double newzoom, bool recalc = true);
 
  void CommentSelection();
 
  void OnScrollChanged(wxScrollEvent &ev);
  void OnThumbtrack(wxScrollWinEvent &ev);
  void OnMouseWheel(wxMouseEvent &event);
 
  bool FindIncremental(const wxString &str, bool down, bool ignoreCase);
 
  bool FindNext(const wxString &str, bool down, bool ignoreCase, bool warn = true);
 
  void Replace(const wxString &oldString, const wxString &newString, bool ignoreCase);
 
  int ReplaceAll(const wxString &oldString, const wxString &newString, bool ignoreCase);
 
  wxString GetInputAboveCaret();
 
  wxString GetOutputAboveCaret();
 
  void LoadSymbols();
  void CompileHelpFileAnchors();
  bool LoadManualAnchorsFromCache();
  bool LoadManualAnchorsFromXML(wxXmlDocument xmlDocument, bool checkManualVersion = true);
  bool LoadBuiltInManualAnchors();
  void SaveManualAnchorsToCache();
 
  bool Autocomplete(AutoComplete::autoCompletionType type = AutoComplete::command);
 
  void AddSymbol(const wxString &fun, AutoComplete::autoCompletionType type = AutoComplete::command)
  { m_autocomplete.AddSymbol(fun, type); }
 
  void AddSymbols(wxString xml)
  { m_autocomplete.AddSymbols(xml); }
 
  void SetActiveCellText(const wxString &text);
 
  bool InsertText(const wxString &text);
 
  void OpenNextOrCreateCell();
 
  TableOfContents *m_tableOfContents;
 
  void OnFollow();
 
  ToolBar *m_mainToolBar;
 
  void SelectGroupCell(GroupCell *cell);
 
  void SetAnswer(const wxString &answer);
  void QuestionAnswered();
 
  bool m_questionPrompt;
 
  bool QuestionPending()
  { return m_questionPrompt; }
 
  void QuestionPending(bool pending)
  { m_questionPrompt = pending; }
 
  void SetMaximaDocDir(wxString dir)
    {
      m_maximaDocDir = dir;
    }
 
  bool GCContainsCurrentQuestion(GroupCell *cell);
 
  void OpenQuestionCaret(const wxString &txt = {});
  void UpdateScrollPos();
 
  GroupCell *GetWorkingGroup(bool resortToLast = false) const;
 
  Variablespane *m_variablesPane;
 
  int GetCellIndex(Cell *cell) const;
 
  HelpFileAnchors m_helpFileAnchors;
  wxArrayString 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]; }
 
    unsigned int 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;
    Worksheet *m_worksheet;
  };
#endif
protected:
  wxString m_lastQuestion;
  int m_virtualWidth_Last;
  int m_virtualHeight_Last;
  wxBitmap m_memory;
  virtual wxSize DoGetBestClientSize() const;
#if wxUSE_ACCESSIBILITY
  AccessibilityInfo *m_accessibilityInfo;
#endif
  void UpdateConfigurationClientSize();
  GroupCell *m_recalculateStart;
  int m_pointer_x;
  int m_pointer_y;
  bool m_mouseMotionWas;
  bool m_inPopupMenu = false;
};
 
inline Worksheet *Cell::GetWorksheet() const
{
  wxWindow *worksheet = (*m_configuration)->GetWorkSheet();
  wxASSERT(worksheet != NULL);
  return static_cast<Worksheet*>(worksheet);
}
 
inline void Configuration::SetWorkSheet(wxWindow *workSheet)
{ m_workSheet = dynamic_cast<Worksheet*>(workSheet); }
 
#endif // WORKSHEET_H