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 <functional>
#include <optional>
#include "precomp.h"
#include "MaximaManual.h"
#include "EventIDs.h"
#include "RecentDocuments.h"
#include "WheelSteps.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/MatrCell.h"
#include "TreeUndoManager.h"
#include "WorksheetCursor.h"
#include "WorksheetDocument.h"
#include "WorksheetDocumentView.h"
#include "WorksheetSearch.h"
#include "WorksheetLayout.h"
#include "MatrixScrollbars.h"
#include "ClipboardContents.h"
#include "OutputNavigation.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 WorksheetView,
                  public WorksheetDocumentView
{
public:
  // WorksheetView: the narrow window surface the layout pipeline
  // (WorksheetLayout) drives; each forwards to the wxScrolled base.
  void GetViewClientSize(int *width, int *height) const override
    { GetClientSize(width, height); }
  int GetViewScrollUnitY() const override
    { int x, y; GetViewStart(&x, &y); return y; }
  void SetViewVirtualSize(int width, int height) override
    { SetVirtualSize(width, height); }
  void SetViewScrollRate(int rate) override { SetScrollRate(rate, rate); }
  void GetViewPosition(int *x, int *y) const override
    { const wxPoint p = GetPosition(); *x = p.x; *y = p.y; }
  void ScrollViewToUnitY(int unitY) override
    { Freeze(); Scroll(-1, unitY); Thaw(); RequestRedraw(); }
  long GetStalePaintCount() const { return m_stalePaints; }
 
  // WorksheetDocumentView: how m_document tells this window that a structural
  // edit happened; each forwards to the real layout/redraw/save machinery.
  void NotifyRecalculation(GroupCell *start) override
    { RequestRecalculation(start); }
  void NotifyRedraw(GroupCell *start) override { RequestRedraw(start); }
  void NotifyAdjustSizeNeeded() override { m_layout.RequestAdjustSize(); }
  void NotifySavedStateChanged() override { m_updateControls = true; }
 
  RecentDocuments &UnsavedDocuments() { return m_unsavedDocuments; }
private:
  RecentDocuments m_unsavedDocuments;
public:
  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;
  // 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;
  wxClientDC m_dc;
  CellPtr<GroupCell> m_redrawStart;
  bool m_fullRedrawRequested = false;
  bool RedrawStartBelowView() const;
  long m_stalePaints = 0;
 
  static wxDataFormat m_wxmFormat;
  static wxDataFormat m_xmlFormat;
  static wxDataFormat m_mathmlFormat;
  static wxDataFormat m_mathmlFormat2;
  static wxDataFormat m_rtfFormat;
  static wxDataFormat m_rtfFormat2;
  static wxDataFormat m_rtfFormat3;
 
  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;
  };
 
  class RtfDataObject3 : public wxCustomDataObject
  {
  public:
    explicit RtfDataObject3(const wxString &data);
 
    RtfDataObject3();
 
  private:
    wxCharBuffer m_databuf;
  };
 
  bool m_hasFocus = true;
  long m_lastTop = 0;
  long m_lastBottom = 0;
  // TreeUndoAction/UndoActions live in TreeUndoAction.h and the undo/redo
  // state (the two stacks + the active-cell snapshot) is owned by the
  // TreeUndoManager below; only the tree surgery of applying an action
  // remains a Worksheet responsibility.
 
private:
  TreeUndoManager &GetTreeUndo() { return m_document.GetTreeUndo(); }
  const TreeUndoManager &GetTreeUndo() const { return m_document.GetTreeUndo(); }
 
public:
  void TreeUndo_ClearRedoActionList() { GetTreeUndo().ClearRedoActionList(); }
 
  void TreeUndo_ClearUndoActionList() { GetTreeUndo().ClearUndoActionList(); }
 
  void TreeUndo_AppendAction() { GetTreeUndo().AppendAction(); }
 
  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 TreeUndoFold(UndoActions *sourcelist, UndoActions *undoForThisOperation);
 
  bool TreeUndo()
    { return TreeUndo(&GetTreeUndo().UndoStack(), &GetTreeUndo().RedoStack()); }
 
  bool TreeRedo()
    { return TreeUndo(&GetTreeUndo().RedoStack(), &GetTreeUndo().UndoStack()); }
 
  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);
 
 
private:
  bool m_scrolledAwayFromEvaluation = false;
public:
 
  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
  };
 
  std::unique_ptr<Cell> CopySelection(bool asData = false) const;
 
  std::unique_ptr<MatrCell> CopySelectedMatrixBlock() const;
 
  bool MatrixEntriesSelected() const;
  static wxString SelectionRTFBody(const Cell *cells, bool matrixEntries);
 
  void SelectOutputRect(GroupCell *group, wxPoint down, wxPoint up);
 
  std::optional<std::size_t> SelectedOutputResult() const;
  void SelectOutputResult(GroupCell *group, std::size_t index);
  bool StepOutputResult(int keyCode);
  bool EnterOutputFromInput();
 
  std::optional<OutputNavigation::Item> SelectedOutputItem() const;
  void SelectOutputItem(const OutputNavigation::Item &item);
  bool NavigateOutput(int keyCode, bool shift);
 
  bool StepSelectedMatrixBlock(int keyCode);
 
  std::unique_ptr<Cell> CopySelection(Cell *start, Cell *end, bool asData = false) const;
 
  void GetMaxPoint(int *width, int *height) { m_layout.GetMaxPoint(width, height); }
 
  void OnTimer(wxTimerEvent &event);
 
  void OnZoom(wxZoomGestureEvent &event);
 
  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 OnContextMenuKey(wxContextMenuEvent &event);
 
  void OnSidebarKey(wxCommandEvent &event);
  void InsertSymbol(const wxString &symbol);
 
  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);
  bool OpenMatrixViewerAt(wxPoint position);
 
  void OnCharInActive(wxKeyEvent &event);
 
  void OnCharNoActive(wxKeyEvent &event);
 
  void SelectEditable(EditorCell *editor, bool up);
 
  void SelectWithChar(int ccode);
  bool SelectWholeCellsFromOutput(int ccode);
 
  void ClickNDrag(wxPoint down, wxPoint up);
 
  // Select all group cells inside the given rectangle;
  void SelectGroupCells(wxPoint down, wxPoint up);
 
public:
  static bool OpenLink(const wxString &url);
 
  wxString LinkUnderPointer();
  wxString GetLinkAt(wxPoint point);
 
  const wxString &GetContextMenuLink() const { return m_contextMenuLink; }
  void SetContextMenuLink(const wxString &link) { m_contextMenuLink = link; }
 
  void AdjustSize() { m_layout.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);
 
private:
  wxPoint m_leftDownPosition;
  wxPoint m_down;
  wxPoint m_up;
  wxPoint m_mousePoint;
  WorksheetCursor &GetHCaretCursor() { return m_document.GetCursor(); }
  const WorksheetCursor &GetHCaretCursor() const { return m_document.GetCursor(); }
  bool m_leftDown = false;
  wxm::WheelSteps m_zoomWheelSteps;
  wxm::WheelSteps m_animationWheelSteps;
  const AnimationCell *m_wheelAnimation = nullptr;
  bool m_followEvaluation = true;
  bool m_mouseDrag = false;
  bool m_mouseOutside = false;
 
public:
  GroupCell *GetLastCellInWorksheet() const;
private:
  int m_clickType = CLICK_TYPE_NONE;
  CellPtr<GroupCell> m_clickInGC;
  CellPtr<GroupCell> m_asyncOutputTarget;
  int m_outputBatchDepth = 0;
  std::vector<std::pair<CellPtr<GroupCell>, bool>> m_outputBatchGroups;
  void LayOutAppendedOutput(GroupCell *cell, bool async);
  void FinishBatchedOutput();
  CellPtr<Cell> m_outputRunAnchor;
  bool m_blinkDisplayCaret = true;
  bool m_hCaretBlinkVisible = true;
  wxTimer m_timer;
  wxTimer m_caretTimer;
  std::vector<wxString> m_completions;
  bool m_autocompleteTemplates = true;
  AutocompletePopup *m_autocompletePopup;
 
public:
  bool IsEmpty() const
    { return !GetTree() || (!GetTree()->GetNext() && GetTree()->GetEditable()->GetValue().Length() <= 1); }
  void CloseAutoCompletePopup()
    {
      if(m_autocompletePopup != nullptr)
        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);
  std::optional<Notification> &GetNotification() { return m_notificationMessage; }
private:
  std::optional<Notification> m_notificationMessage;
  std::function<void(bool)> m_attentionCallback;
public:
  void WindowActive(bool active){m_windowActive = active;}
  void ClearNotification();
  void SetNotification(const wxString &message, int flags = wxICON_INFORMATION);
  void SetAttentionCallback(std::function<void(bool)> callback)
    { m_attentionCallback = std::move(callback); }
 
  void OnActivate(wxActivateEvent &event);
private:
  std::unique_ptr<GroupCell> &TreeOwner() { return m_document.TreeOwner(); }
  CellPtr<GroupCell> &LastCache() const { return m_document.LastCache(); }
//  std::vector<std::jthread> m_drawThreads;
  static std::mutex m_drawDCLock;
  Configuration *m_configuration = nullptr;
  mutable std::weak_ptr<ClipboardContents> m_clipboardContents;
  WorksheetLayout m_layout;
  MatrixScrollbars m_matrixScrollbars{this};
public:
  MatrixScrollbars &GetMatrixScrollbars() { return m_matrixScrollbars; }
  void FocusFindDialogue()
    {
      if(FindReplacePane *pane = GetActiveFindPane())
        pane->SetFocus();
    }
  FindReplacePane *GetActiveFindPane() const;
  AutoComplete &GetAutocomplete() { return m_autocomplete; }
private:
  AutoComplete m_autocomplete;
public:
 
  Configuration *GetConfig() const { return m_configuration; }
 
  EditorCell *GetActiveCell() const { return GetDocumentCellPointers().GetActiveCell(); }
 
  EditorCell *KeyboardSelectionStart() const
    { return GetViewCellPointers().KeyboardSelectionStart(); }
 
  EditorCell *MouseSelectionStart() const
    { return GetViewCellPointers().MouseSelectionStart(); }
 
  EditorCell *SearchStart() const
    { return GetViewCellPointers().SearchStart(); }
 
  int IndexSearchStartedAt() const
    { return GetViewCellPointers().IndexSearchStartedAt(); }
 
  DocumentCellPointers &GetDocumentCellPointers() { return m_document.GetCellPointers(); }
  const DocumentCellPointers &GetDocumentCellPointers() const { return m_document.GetCellPointers(); }
  ViewCellPointers &GetViewCellPointers() { return m_viewCellPointers; }
  const ViewCellPointers &GetViewCellPointers() const { return m_viewCellPointers; }
 
  DocumentCellPointers::ErrorList &GetErrorList() { return GetDocumentCellPointers().GetErrorList(); }
  TextCell *GetCurrentTextCell() const { return GetDocumentCellPointers().GetCurrentTextCell(); }
  void SetCurrentTextCell(TextCell *cell) { GetDocumentCellPointers().SetCurrentTextCell(cell); }
  void SetWorkingGroup(GroupCell *group) { GetDocumentCellPointers().SetWorkingGroup(group); }
 
  void UpdateTableOfContents();
 
  void MarkRefreshAsDone()
    {
      m_redrawStart = nullptr;
      m_fullRedrawRequested = false;
    }
 
  bool RedrawIfRequested();
 
  void RequestRedraw(GroupCell *start = nullptr);
  void RequestRedraw(wxRect rect);
 
  void ForceRedraw()
    {
      RequestRedraw();
      RedrawIfRequested();
    }
 
  void CodeCellVisibilityChanged();
 
  void UpdateConfig() {
    m_configuration->ReadConfig();
    ApplyOverlayScrollbarsSetting();
    RequestRecalculation();
    Refresh();
  }
 
  void ApplyOverlayScrollbarsSetting();
 
  const wxString &GetCurrentFile() const { return m_document.GetCurrentFile(); }
  void SetCurrentFile(const wxString &file) { m_document.SetCurrentFile(file); }
 
  const wxString UnicodeToMaxima(wxString s) const
    { return UnicodeToMaxima(std::move(s), m_configuration); }
  static wxString UnicodeToMaxima(wxString s, const Configuration *configuration);
 
  void ScrollToStart() { Scroll(0, 0); }
 
  void ScrollToError();
 
  FindReplaceDialog *m_findDialog = nullptr;
  FindReplacePane *m_findPane = nullptr;
 
  bool HCaretActive() const { return GetHCaretCursor().IsActive(); }
  void DeactivateHCaret() { GetHCaretCursor().Deactivate(); }
 
  bool CanMergeSelection() const { return m_document.CanMergeSelection(); }
 
  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);
 
  ~Worksheet() override;
 
  wxTimer &KeyboardInactiveTimer() { return m_keyboardInactiveTimer; }
private:
  wxTimer m_keyboardInactiveTimer;
public:
 
  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 = nullptr);
 
  void InsertLine(std::unique_ptr<Cell> &&newCell, bool forceNewLine = false);
 
  class OutputBatch {
  public:
    explicit OutputBatch(Worksheet *worksheet) : m_worksheet(worksheet) {
      if (m_worksheet)
        m_worksheet->m_outputBatchDepth++;
    }
    ~OutputBatch() {
      if (m_worksheet && (--m_worksheet->m_outputBatchDepth == 0))
        m_worksheet->FinishBatchedOutput();
    }
    OutputBatch(const OutputBatch &) = delete;
    OutputBatch &operator=(const OutputBatch &) = delete;
  private:
    Worksheet *m_worksheet;
  };
 
  WorksheetLayout::ScrollAnchor GetScrollAnchor() const;
 
  bool ScrollAnchorVisible();
 
  void KeepCursorStillOnScreen();
 
  GroupCell *GetInsertGroup() const;
 
  GroupCell *FindGroupCellByUUID(const wxString &uuid) const;
 
  void SetAsyncOutputTarget(GroupCell *cell) { m_asyncOutputTarget = cell; }
  GroupCell *GetAsyncOutputTarget() const { return m_asyncOutputTarget; }
 
  class AsyncOutputTarget {
  public:
    AsyncOutputTarget(Worksheet *worksheet, GroupCell *cell)
      : m_worksheet(worksheet) {
      if (m_worksheet)
        m_worksheet->SetAsyncOutputTarget(cell);
    }
    ~AsyncOutputTarget() {
      if (m_worksheet)
        m_worksheet->SetAsyncOutputTarget(nullptr);
    }
    AsyncOutputTarget(const AsyncOutputTarget &) = delete;
    AsyncOutputTarget &operator=(const AsyncOutputTarget &) = delete;
  private:
    Worksheet *m_worksheet;
  };
 
  bool RecalculateIfNeeded(bool timeout = false, long timeSliceMs = 50)
    { return m_layout.RecalculateIfNeeded(timeout, timeSliceMs); }
 
  void RequestRecalculation(Cell *start) { m_layout.RequestRecalculation(start); }
 
  void RequestRecalculation() { m_layout.RequestFullRecalculation(); }
 
  int GetLastCellsVisited() const { return m_layout.GetLastCellsVisited(); }
  int GetLastCellsRecalculated() const { return m_layout.GetLastCellsRecalculated(); }
 
  void ClearDocument();
 
  void ResetInputPrompts();
 
  bool CanCopy() const
    {
      return GetDocumentCellPointers().GetSelectionStart() ||
        (GetDocumentCellPointers().GetActiveCell() &&
         GetDocumentCellPointers().GetActiveCell()->CanCopy());
    }
 
  bool CanCopyAsMathML() const;
 
  bool CanCopyCSV() const;
  wxString SelectionToCSV() const;
  static wxString CSVDelimiter();
 
  bool CanPaste() const
    { return GetDocumentCellPointers().GetActiveCell() || GetHCaretCursor().IsActive(); }
 
  bool CanCut() const
    {
      return (GetDocumentCellPointers().GetActiveCell() && GetDocumentCellPointers().GetActiveCell()->CanCopy()) ||
        (GetDocumentCellPointers().GetSelectionStart() && GetDocumentCellPointers().GetSelectionStart()->GetType() == MC_TYPE_GROUP);
    }
 
  void SelectAll();
 
  bool HasCellsSelected() const { return GetDocumentCellPointers().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 { return m_document.CanDeleteSelection(); }
 
  void DeleteCurrentCell();
 
  AnimationCell *GetSelectedAnimation() const
    {
      if(GetDocumentCellPointers().GetSelectionStart() != GetDocumentCellPointers().GetSelectionEnd())
        return nullptr;
      return dynamic_cast<AnimationCell *>(GetSelectionStart());
    }
 
  MatrCell *GetSelectedScrollingMatrix() const;
  bool ScrollSelectedMatrix(const wxMouseEvent &event);
private:
  wxPoint m_matrixWheelRemainder;
public:
 
  ImgCell *GetSelectedImgCell() const
    {
      if(GetDocumentCellPointers().GetSelectionStart() != GetDocumentCellPointers().GetSelectionEnd())
        return nullptr;
      return dynamic_cast<ImgCell *>(GetSelectionStart());
    }
  
  ImgCellBase *GetSelectedImgCellBase() const
    {
      if(GetDocumentCellPointers().GetSelectionStart() != GetDocumentCellPointers().GetSelectionEnd())
        return nullptr;
      return dynamic_cast<ImgCellBase *>(GetSelectionStart());
    }
 
  TextCell *GetSelectedTextCell() const
    {
      if(GetDocumentCellPointers().GetSelectionStart() != GetDocumentCellPointers().GetSelectionEnd())
        return nullptr;
      return dynamic_cast<TextCell *>(GetSelectionStart());
    }
 
  bool CanAnimate() const
    {
      return GetDocumentCellPointers().GetSelectionStart() && GetDocumentCellPointers().GetSelectionStart() == GetDocumentCellPointers().GetSelectionEnd() &&
        (dynamic_cast<AnimationCell *>(GetSelectionStart()) != nullptr);
    }
 
  void Animate(bool run = true) const;
 
  void DivideCell();
 
  void MergeCells();
 
  void SetLastQuestion(const wxString &lastQuestion){m_document.SetLastQuestion(lastQuestion);}
  wxString GetLastQuestion() const {return m_document.GetLastQuestion();}
 
  bool CutToClipboard();
 
  void PasteFromClipboard(bool primary = false);
 
  bool PasteMathAsMaxima();
 
  static constexpr bool HasPrimarySelection() {
#if defined(__UNIX__) && !defined(__APPLE__)
    return true;
#else
    return false;
#endif
  }
 
  bool Copy(bool astext = false) const;
 
  std::unique_ptr<wxDataObject> CreateSelectionDataObject() const;
 
  bool CopyCells() const;
 
  std::unique_ptr<wxDataObject> CreateCellsDataObject() const;
 
  bool CopyMatlab() const;
 
  bool CopyCSV() const;
 
  bool CopyText() const;
 
  bool CopyTeX() const;
 
  wxString ConvertSelectionToMathML() const;
 
  static wxString CellsToMathML(const Cell *cells);
 
  bool RenderClipboardContents();
 
  static std::unique_ptr<wxDataObject>
  CreateIndependentDataObject(const ClipboardContents &contents);
 
  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;
 
  bool CopyHTML() const;
 
  wxString SelectionToSelfContainedHTML() const;
 
  wxSize CopyToFile(const wxString &file) const;
 
  wxSize CopyToFile(const wxString &file, Cell *start, Cell *end, bool asData = false, double scale = 1) const;
 
  int ExportSelectionOutputToDir(const wxString &dir, bool svg);
 
  bool ExportToHTML(const wxString &file);
 
  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_document.GetTree(); }
  std::unique_ptr<GroupCell> *GetTreeAddress() { return &m_document.TreeOwner(); }
 
  Cell *GetSelectionStart() const
    { return GetDocumentCellPointers().GetSelectionStart(); }
 
  Cell *GetSelectionEnd() const
    { return GetDocumentCellPointers().GetSelectionEnd(); }
 
  void ClearSelection() { SetSelection(nullptr, nullptr); }
 
  void SetSelection(Cell *sel) { SetSelection(sel, sel); }
 
  void SetSelection(Cell *start, Cell *end);
 
  Cell *FindCellByUUID(const wxString &uuid);
 
  void UpdateConfigurationClientSize() { m_layout.UpdateConfigurationClientSize(); }
 
  bool CanEdit() const { return m_document.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:
  void UpdateOutputSelectionString();
  /* ! 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()
    {
      GetViewCellPointers().SetScrollToCellScheduled(false);
      m_scrollToCaret = true;
    }
 
  bool ScrollToCaretIfNeeded();
 
  void ScrollToCellIfNeeded();
 
  void ScheduleScrollToCell(Cell *cell, bool scrollToTop = true)
    {
      GetViewCellPointers().ScrollToCell(cell);
      m_scrollToTopOfCell = scrollToTop;
      m_scrollToCaret = false;
 
      GetViewCellPointers().SetScrollToCellScheduled(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) const { return m_document.IsSelected(type); }
 
  void StepAnimation(int change = 1);
 
  bool IsActiveInLast() const
    { return GetDocumentCellPointers().GetActiveCell() && GetDocumentCellPointers().GetActiveCell()->GetGroup() == GetLastCellInWorksheet(); }
 
  GroupCell *GetLastCell()
    {
      return GetLastCellInWorksheet();
    }
 
  bool IsSelectionInWorkingGroup() const { return m_document.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 == nullptr)
        OpenHCaret(txt, GC_TYPE_CODE);
      else
        OpenHCaret(txt, m_mainToolBar->GetCellType());
    }
 
  void OpenHCaret(const wxString &txt, GroupType type);
 
  void ShowHCaret();
 
  bool CanUndoInsideCell() const { return m_document.CanUndoInsideCell(); }
 
  void ToggleTextFormat(TextFormat::Format flag);
  bool HasTextFormat(TextFormat::Format flag) const;
  bool CanFormatText() const;
 
  void UndoInsideCell();
 
  bool CanRedoInsideCell() const { return m_document.CanRedoInsideCell(); }
 
  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_document.IsSaved(); }
 
  void SetSaved(bool saved)
    { m_document.SetSaved(saved); }
 
  void OutputChanged()
    { m_document.OutputChanged(); }
 
  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 &GetEvaluationQueue() { return m_document.GetEvaluationQueue(); }
 
  void FoldOccurred();
 
  // methods for folding
  GroupCell *Fold(GroupCell *which) { return m_document.Fold(which); }
 
  GroupCell *Unfold(GroupCell *which) { return m_document.Unfold(which); }
 
  GroupCell *ToggleFold(GroupCell *which) { return m_document.ToggleFold(which); }
 
  GroupCell *ToggleFoldAll(GroupCell *which) { return m_document.ToggleFoldAll(which); }
 
  void FoldAll() { m_document.FoldAll(); }
 
  void UnfoldAll() { m_document.UnfoldAll(); }
 
  // methods for zooming the document in and out
  void SetZoomFactor(double newzoom);
 
  void CommentSelection();
 
  void OnScrollChanged(wxScrollEvent &ev);
  void OnScrollEvent(wxScrollWinEvent &ev);
  void CheckIfActiveCellScrolledOut();
  void OnMouseWheel(wxMouseEvent &event);
 
  bool FindIncremental(const wxString &str, bool down, bool ignoreCase, bool searchInInput = true, bool searchInOutput = true);
  bool FindIncremental_RegEx(const wxString &str, bool down, bool searchInInput = true, bool searchInOutput = true);
 
private:
  WorksheetSearch::SearchStart FindStart(bool down);
  bool ApplyFindResult(const WorksheetSearch::SearchTarget &target, bool warn);
public:
  bool FindNext(const wxString &str, bool down, bool ignoreCase, bool searchInInput = true, bool searchInOutput = true, bool warn = true);
  bool FindNext_Regex(const wxString &str, const bool &down, bool searchInInput = true, bool searchInOutput = true, 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, bool searchInInput = true, bool searchInOutput = true);
  int ReplaceAll_RegEx(const wxString &oldString, const wxString &newString, bool searchInInput = true, bool searchInOutput = true);
 
  void AnonymizeCodeCells();
 
  std::size_t ForgetKnownAnswers();
 
  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(const wxXmlDocument& xml)
    { m_autocomplete.AddSymbols(xml); }
 
  void SetActiveCellText(const wxString &text);
 
  bool InsertText(const wxString &text);
 
  void OpenNextOrCreateCell();
 
  void OnFollow();
 
  ToolBar *m_mainToolBar = nullptr;
 
  void SelectGroupCell(GroupCell *cell);
 
  void SetAnswer(const wxString &answer);
  void QuestionAnswered();
 
  bool QuestionPending() const
    { return m_document.QuestionPending(); }
 
  void QuestionPending(bool pending)
    { m_document.SetQuestionPending(pending); }
 
  void SetMaximaDocDir(const wxString &dir)
    {
      m_maximaDocDir = dir;
    }
  const wxString &GetMaximaDocDir() const { return m_maximaDocDir; }
 
  bool GCContainsCurrentQuestion(const GroupCell *cell);
 
  bool OpenQuestionCaret(const wxString &txt = {});  
 
  bool WillAutoAnswer() const;
  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);}
 
  std::vector<wxString> m_replacementsForCurrentWord;
#if wxUSE_ACCESSIBILITY
  int GetAccessibilityId(Cell *cell) const;
#endif
 
#if wxUSE_ACCESSIBILITY
  class AccessibilityInfo: public wxAccessible
  {
  public:
    AccessibilityInfo(wxWindow *parent, Worksheet *worksheet);
    wxAccStatus GetName (int childId, wxString *name);
    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);
    wxAccStatus GetRole(int childId, wxAccRole *role);
    wxAccStatus GetState(int childId, long *state);
  private:
    wxWindow *m_parent = nullptr;
    Worksheet *m_worksheet = nullptr;
 
    class CaretAccessibilityInfo : public wxAccessible {
    public:
      CaretAccessibilityInfo(AccessibilityInfo* parent, Worksheet* worksheet)
        : wxAccessible(worksheet->GetTargetWindow()), m_parent(parent), m_worksheet(worksheet) {}
 
      wxAccStatus GetName(int childId, wxString *name) override;
      wxAccStatus GetDescription(int WXUNUSED(childId), wxString *description) override;
      wxAccStatus GetParent(wxAccessible **parent) override;
      wxAccStatus GetChildCount(int *childCount) override;
      wxAccStatus GetChild(int childId, wxAccessible **child) override;
      wxAccStatus GetRole(int childId, wxAccRole *role) override;
    private:
      AccessibilityInfo* m_parent;
      Worksheet* m_worksheet;
    };
    CaretAccessibilityInfo* m_caretAccessible = nullptr;
 
    class SelectionAccessibilityInfo : public wxAccessible {
    public:
      SelectionAccessibilityInfo(AccessibilityInfo* parent, Worksheet* worksheet)
        : wxAccessible(worksheet->GetTargetWindow()), m_parent(parent), m_worksheet(worksheet) {}
 
      wxAccStatus GetName(int childId, wxString *name) override;
      wxAccStatus GetParent(wxAccessible **parent) override;
      wxAccStatus GetChildCount(int *childCount) override;
      wxAccStatus GetChild(int childId, wxAccessible **child) override;
      wxAccStatus GetRole(int childId, wxAccRole *role) override;
      wxAccStatus GetState(int childId, long *state) override;
    private:
      AccessibilityInfo* m_parent;
      Worksheet* m_worksheet;
    };
    SelectionAccessibilityInfo* m_selectionAccessible = nullptr;
    int SelectionChildId() const;
  public:
    static bool HasOutputSelection(const Worksheet *worksheet);
  };
#endif
  MaximaManual m_maximaManual;
  MaximaManual *GetMaximaManual() {return &m_maximaManual;}
protected:
  void FocusTextControl();
  WorksheetDocument m_document;
  ViewCellPointers m_viewCellPointers{this};
  wxBitmap m_memory;
  wxSize DoGetBestClientSize() const override;
#if wxUSE_ACCESSIBILITY
  AccessibilityInfo *m_accessibilityInfo = nullptr;
#endif
  int m_pointer_x = -1;
  int m_pointer_y = -1;
  bool m_mouseMotionWas = false;
  bool m_pointerCmdDown = false;
  bool m_linkCursorShown = false;
  static wxString LinkToolTip(const wxString &link);
  void UpdateLinkCursor(bool overLink);
  wxString m_contextMenuLink;
  bool m_inPopupMenu = false;
};
 
wxDECLARE_EVENT(TOC_UPDATE_NEEDED_EVENT, wxCommandEvent);
 
#endif // WORKSHEET_H