Cell.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>
//  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 MATHCELL_H
#define MATHCELL_H
 
#include "../precomp.h"
#include "CellPtr.h"
#include "CellIterators.h"
#include "Configuration.h"
#include "StringUtils.h"
#include "TextStyle.h"
#include "utils/CachedValue.h"
#include <wx/defs.h>
#if wxUSE_ACCESSIBILITY
#include <wx/access.h>
#endif // wxUSE_ACCESSIBILITY
#include <algorithm>
#include <map>
#include <memory>
#include <vector>
#include <type_traits>
class CellPointers;
class EditorCell;
class GroupCell;
class TextCell;
class Worksheet;
class wxXmlNode;
 
// Forward declarations
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type = true>
inline auto OnInner(const C *cell);
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type = true>
inline auto OnInner(C *cell);
 
enum CellType : int8_t
{
  MC_TYPE_DEFAULT,
  MC_TYPE_MAIN_PROMPT, 
  MC_TYPE_PROMPT,      
  MC_TYPE_LABEL,       
  MC_TYPE_INPUT,       
  MC_TYPE_WARNING,     
  MC_TYPE_ERROR,       
  MC_TYPE_TEXT,        
  MC_TYPE_ASCIIMATHS,  
  MC_TYPE_SUBSECTION,  
  MC_TYPE_SUBSUBSECTION,  
  MC_TYPE_HEADING5,  
  MC_TYPE_HEADING6,  
  MC_TYPE_SECTION,     
  MC_TYPE_TITLE,       
  MC_TYPE_IMAGE,       
  MC_TYPE_SLIDE,       
  MC_TYPE_GROUP        
};
 
#if wxUSE_ACCESSIBILITY
class CellAccessible;
#endif
 
class CellTypeInfo
{
public:
  virtual const wxString &GetName() const = 0;
};
 
// 120 bytes
class Cell: public Observed
{
#if wxUSE_ACCESSIBILITY
  friend class CellAccessible;
#endif
  friend class CellList;
 
  // This class can be derived from wxAccessible which has no copy constructor
  void operator=(const Cell&) = delete;
  Cell(GroupCell *group, const Cell&) = delete;
 
  template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type>
  friend inline auto OnInner(const C *cell);
  template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type>
  friend inline auto OnInner(C *cell);
 
public:
//  Cell(GroupCell *group, Configuration **config);
  Cell(GroupCell *group, Configuration **config);
 
  virtual std::unique_ptr<Cell> Copy(GroupCell *group) const = 0;
 
  virtual const CellTypeInfo &GetInfo() = 0;
 
  int Scale_Px(double px) const {return (*m_configuration)->Scale_Px(px);}
  AFontSize Scale_Px(AFontSize size) const { return (*m_configuration)->Scale_Px(size); }
 
#if wxUSE_ACCESSIBILITY
  // The methods whose implementation within Cell should be sufficient are
  // not virtual. Should that prove not to be the case eventually, they can be
  // made virtual with due caution.
  wxAccStatus GetParent (Cell ** parent) const;
  wxAccStatus GetChild(int childId, Cell **child) const;
  wxAccStatus HitTest (const wxPoint &pt, int *childId, Cell **child);
 
  virtual wxAccStatus GetDescription(int childId, wxString *description) const;
  virtual wxAccStatus GetFocus (int *childId, Cell **child) const;
  virtual wxAccStatus GetDefaultAction(int childId, wxString *actionName) const;
  virtual wxAccStatus GetLocation (wxRect &rect, int elementId);
  virtual wxAccStatus GetValue (int childId, wxString *strValue) const;
  virtual wxAccStatus GetRole (int childId, wxAccRole *role) const;
#endif
  
 
  virtual const wxString &GetToolTip(wxPoint point) const;
 
  virtual ~Cell();
 
  int CellsInListRecursive() const;
  
  wxRect CropToUpdateRegion(wxRect rect) const;
 
  bool InUpdateRegion() const;
 
  bool SoftLineBreak(bool breakLine = true)
  {
    bool result = (m_breakLine == breakLine);
    m_breakLine = breakLine;
    return result;
  }
 
  bool BreakLineHere() const { return m_breakLine || m_forceBreakLine; }
 
  bool HasHardLineBreak() const { return m_forceBreakLine; }
 
  virtual bool BreakUp();
 
protected:
  void BreakUpAndMark();
 
public:
  bool ContainsRect(const wxRect &sm, bool all = true) const;
 
  bool ContainsPoint(wxPoint point) const { return GetRect().Contains(point); }
 
  virtual void ClearCache()
  {}
 
  void ClearCacheList();
  void SetConfigurationList(Configuration **config);
  virtual void SetConfiguration(Configuration **config);
  Configuration *GetConfiguration(){return *m_configuration;}
 
  
  virtual void Draw(wxPoint point);
 
  void Draw(){Draw(m_currentPoint);}
 
  void DrawList(wxPoint point);
  void DrawList(){DrawList(m_currentPoint);}
 
  virtual void DrawBoundingBox(wxDC &WXUNUSED(dc), bool all = false);
 
  bool DrawThisCell(wxPoint point);
  bool DrawThisCell(){return DrawThisCell(m_currentPoint);}
 
  void ForceBreakLine(bool force = true) { m_forceBreakLine = m_breakLine = force; }
 
  int GetHeight() const
  { return m_height; }
 
  int GetWidth() const
  { return m_width; }
 
  int GetCenter() const
  { return m_center; }
 
  bool HasValidSize() const;
  bool HasStaleSize() const;
  bool HasValidPosition() const;
 
  int GetDrop() const
  { return m_height - m_center; }
 
  CellType GetType() const
  { return m_type; }
 
  int GetMaxDrop() const;
 
  int GetCenterList() const;
 
  int GetHeightList() const;
 
  int GetFullWidth() const;
 
  int GetLineWidth() const;
 
  int GetCurrentX() const
  { return m_currentPoint.x; }
 
  int GetCurrentY() const
  { return m_currentPoint.y; }
 
  virtual wxRect GetRect(bool all = false) const;
 
  virtual bool NeedsRecalculation(AFontSize fontSize) const;
  
  virtual wxString GetDiffPart() const;
 
  virtual void Recalculate(AFontSize fontsize);
 
  void RecalculateList(AFontSize fontsize);
 
  void FontsChangedList();
 
  void ClearNeedsToRecalculateWidths() { m_recalculateWidths = false; }
 
  void ResetData();
 
  void ResetDataList();
 
  void ResetSize();
 
  void ResetCellListSizes();
 
  void ResetCellListSizesList();
 
  void SetZeroSize();
 
  void ResetSizeList();
 
  void SetBigSkip(bool skip) { m_bigSkip = skip; }
  bool HasBigSkip() const { return m_bigSkip; }
 
  virtual void SetType(CellType type);
 
  TextStyle GetStyle() const
  { return m_textStyle; }
 
  // cppcheck-suppress functionStatic
  // cppcheck-suppress functionConst
  void SetPen(double lineWidth = 1.0) const;
  void SetBrush() const;
  wxColour GetForegroundColor() const;
 
  void SetHighlight(bool highlight) { m_highlight = highlight; }
  bool GetHighlight() const { return m_highlight; }
 
  virtual void SetExponentFlag()
  {}
 
  virtual void SetValue(const wxString &WXUNUSED(text)) {}
  virtual const wxString &GetValue() const;
 
  Cell *first() const;
 
  Cell *last() const;
 
  struct Range {
    Cell *first, *last;
  };
 
  Range GetCellsInRect(const wxRect &rect) const;
 
  Range GetListCellsInRect(const wxRect &rect) const;
 
  virtual Range GetInnerCellsInRect(const wxRect &rect) const;
 
  virtual bool IsOperator() const { return false; }
 
  bool IsCompound() const;
 
  virtual bool IsShortNum() const { return false; }
 
  GroupCell *GetGroup() const;
 
  struct SizeInMillimeters
  {
  public:
    double x, y;
  };
 
  virtual wxString ListToString() const;
 
  wxString VariablesAndFunctionsList() const;
  virtual wxString ListToMatlab() const;
  virtual wxString ListToTeX() const;
  virtual wxString ListToXML() const;
 
  virtual wxString ListToMathML(bool startofline = false) const;
 
  virtual wxString ListToOMML(bool startofline = false) const;
 
  virtual wxString ListToRTF(bool startofline = false) const;
 
  virtual wxString ToString() const;
 
  virtual wxString ToRTF() const
  { return wxEmptyString; }
 
  static wxString OMML2RTF(wxXmlNode *node);
 
  static wxString OMML2RTF(wxString ommltext);
 
  virtual wxString ToOMML() const;
  virtual wxString ToMatlab() const;
  virtual wxString ToTeX() const;
  virtual wxString ToXML() const;
  virtual wxString ToMathML() const;
 
  static wxString RTFescape(wxString, bool MarkDown = false);
 
  static wxString XMLescape(wxString);
 
  // cppcheck-suppress functionStatic
  // cppcheck-suppress functionConst
 
  virtual void Unbreak();
 
  virtual void UnbreakList();
 
  Cell *GetPrevious() const { return m_previous; }
 
  Cell *GetNext() const { return m_next.get(); }
  Cell *GetNextToDraw() const { return m_nextToDraw; }
 
  virtual void SetNextToDraw(Cell *next) { m_nextToDraw = next; }
  template <typename T, typename Del,
            typename std::enable_if<std::is_base_of<Cell, T>::value, bool>::type = true>
  void SetNextToDraw(const std::unique_ptr<T, Del> &ptr) { SetNextToDraw(ptr.get()); }
 
  bool IsComment() const
  {
    return m_type == MC_TYPE_TEXT || m_type == MC_TYPE_SECTION ||
           m_type == MC_TYPE_SUBSECTION || m_type == MC_TYPE_SUBSUBSECTION ||
           m_type == MC_TYPE_HEADING5 || m_type == MC_TYPE_HEADING6 || m_type == MC_TYPE_TITLE;
  }
 
  bool IsHidden() const { return m_isHidden; }
 
  virtual void Hide(bool hide = true) { m_isHidden = hide; }
 
  bool IsEditable(bool input = false) const
  {
    return (m_type == MC_TYPE_INPUT &&
            m_previous && m_previous->m_type == MC_TYPE_MAIN_PROMPT)
           || (!input && IsComment());
  }
 
  virtual bool CanPopOut() const { return false; }
  
  virtual wxString GnuplotSource() const {return wxEmptyString;}
 
  virtual void ProcessEvent(wxKeyEvent &WXUNUSED(event))
  {}
 
  virtual bool AddEnding()
  { return false; }
 
  virtual void SelectPointText(wxPoint point);
      
  virtual void SelectRectText(wxPoint one, wxPoint two);
  
  virtual void PasteFromClipboard(bool primary = false);
  
  virtual bool CopyToClipboard() const
  { return false; }
 
  virtual bool CutToClipboard()
  { return false; }
 
  virtual void SelectAll()
  {}
 
  virtual bool CanCopy() const
  { return false; }
 
  virtual wxPoint PositionToPoint(int WXUNUSED(pos) = -1)
  { return wxPoint(-1, -1); }
 
  virtual bool IsDirty() const
  { return false; }
 
  virtual void SwitchCaretDisplay()
  {}
 
  virtual void SetFocus(bool WXUNUSED(focus))
  {}
 
  void SetForeground();
 
  virtual bool IsActive() const
  { return false; }
 
  virtual void SetStyle(TextStyle style)
  {
    m_textStyle = style;
    ResetData();
  }
  bool IsMath() const;
 
  virtual int GetImageBorderWidth() const { return 0; }
 
  void CopyCommonData(const Cell & cell);
 
  std::unique_ptr<Cell> CopyList(GroupCell *group) const;
 
  static std::unique_ptr<Cell> CopyList(GroupCell *group, const Cell *cell);
 
  void ClearToolTip();
  void SetToolTip(wxString &&toolTip);
  void SetToolTip(const wxString *tooltip);
  void AddToolTip(const wxString &tip);
  virtual void SetCurrentPoint(wxPoint point) { m_currentPoint = point; }
  void SetCurrentPoint(int x, int y) { m_currentPoint = {x, y}; }
  wxPoint GetCurrentPoint() const {return m_currentPoint;}
 
  bool IsBrokenIntoLines() const { return m_isBrokenIntoLines; }
 
  bool GetSuppressMultiplicationDot() const { return m_suppressMultiplicationDot; }
  void SetSuppressMultiplicationDot(bool val) { m_suppressMultiplicationDot = val; }
  bool GetHidableMultSign() const { return m_isHidableMultSign; }
  void SetHidableMultSign(bool val) { m_isHidableMultSign = val; }
 
  virtual void SetAltCopyText(const wxString &text);
  virtual const wxString &GetAltCopyText() const { return wxm::emptyString; }
 
#if wxUSE_ACCESSIBILITY
  CellAccessible *GetAccessible();
#endif
#if CELL_TEST
  void MockBreakUp() { m_isBrokenIntoLines = 1; }
#endif
 
protected:
  std::unique_ptr<Cell> MakeVisiblyInvalidCell() const;
public:
  static std::unique_ptr<Cell> MakeVisiblyInvalidCell(GroupCell *group, Configuration **config);
 
protected:
//** Bases and internal members (16 bytes)
//**
// VTable  *__vtable;
// Observed __observed;
 
//** 8-byte objects (8 bytes)
//**
  wxPoint m_currentPoint{-1, -1};
 
//** 8/4-byte objects (40 + 8* bytes)
//**
private:
  std::unique_ptr<Cell> m_next;
 
  Cell *m_previous = {};
 
#if wxUSE_ACCESSIBILITY
  std::unique_ptr<CellAccessible> m_accessible;
#endif
  
public:
    const wxString &GetLocalToolTip() const;
protected:
  CellPtr<GroupCell> m_group;
  CellPtr<Cell> m_nextToDraw;
 
  Configuration **m_configuration;
 
  const wxString *m_toolTip /* initialized in the constructor */;
 
//** 4-byte objects (28 bytes)
//**
protected:
  int m_height = -1;
  int m_width = -1;
  int m_center = -1;
 
private:
  CachedInteger<int> m_fullWidth;
  CachedInteger<int> m_lineWidth;
  CachedInteger<int> m_maxCenter;
  CachedInteger<int> m_maxDrop;
protected:
//** 2-byte objects (2 bytes)
//**
  AFontSize m_fontSize_Scaled = {};
 
//** 1-byte objects (2 bytes)
//**
  CellType m_type = MC_TYPE_DEFAULT;
  TextStyle m_textStyle = TS_DEFAULT;
 
private:
//** Bitfield objects (2 bytes)
//**
  void InitBitFields()
  { // Keep the initialization order below same as the order
    // of bit fields in this class!
    m_ownsToolTip = false;
    m_bigSkip = false;
    m_isBrokenIntoLines = false;
    m_isHidden = false;
    m_isHidableMultSign = false;
    m_suppressMultiplicationDot = false;
    m_recalculateWidths = true;
    m_breakLine = false;
    m_forceBreakLine = false;
    m_highlight = false;
  }
 
  // In the boolean bit fields below, InitBitFields is an indication that
  // the InitBitFields() method initializes a given field. It should be
  // only added once such initialization is in place. It makes it easier
  // to verify that all bit fields are initialized.
 
  bool m_ownsToolTip : 1 /* InitBitFields */;
  bool m_bigSkip : 1 /* InitBitFields */;
  bool m_isBrokenIntoLines : 1 /* InitBitFields */;
  bool m_isHidden : 1 /* InitBitFields */;
  bool m_isHidableMultSign : 1 /* InitBitFields */;
  bool m_suppressMultiplicationDot : 1 /* InitBitFields */;
  bool m_recalculateWidths : 1 /* InitBitFields */;
  bool m_breakLine : 1 /* InitBitFields */;
  bool m_forceBreakLine : 1 /* InitBitFields */;
  bool m_highlight : 1 /* InitBitFields */;
 
protected:
  friend class InnerCellIterator;
  virtual int GetInnerCellCount() const;
  virtual Cell *GetInnerCell(int index) const;
 
  inline Worksheet *GetWorksheet() const;
 
  virtual void FontsChanged()
  {
    ResetSize();
    ResetData();
  }
 
  CellPointers *GetCellPointers() const;
 
  void InvalidateMaxDrop() { m_maxDrop.Invalidate(); }
 
private:
  void RecalcCenterListAndMaxDropCache();
};
 
// The static cast here requires Cell to be defined
template <typename T>
template <typename PtrT, typename std::enable_if<std::is_pointer<PtrT>::value, bool>::type>
inline PtrT CellPtr<T>::CastAs() const noexcept { return dynamic_cast<PtrT>(static_cast<Cell*>(base_get())); }
 
#if wxUSE_ACCESSIBILITY
class CellAccessible final : public wxAccessible
{
public:
  explicit CellAccessible(Cell *const forCell) : m_cell(forCell) {}
 
  wxAccStatus GetParent (wxAccessible **parent) override;
  wxAccStatus GetChildCount (int *childCount) override;
  wxAccStatus GetChild (int childId, wxAccessible **child) override;
  wxAccStatus HitTest (const wxPoint &pt,
                      int *childId, wxAccessible **childObject) override;
  wxAccStatus GetDescription(int childId, wxString *description) override;
  wxAccStatus GetDefaultAction(int childId, wxString *actionName) override;
  wxAccStatus GetFocus (int *childId, wxAccessible **child) override;
  wxAccStatus GetLocation (wxRect &rect, int elementId) override;
  wxAccStatus GetValue (int childId, wxString *strValue) override;
  wxAccStatus GetRole (int childId, wxAccRole *role) override;
private:
  Cell *const m_cell;
};
#endif
 
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type = true>
inline auto OnList(const C *cell) { return CellListAdapter<const C>(cell); }
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type = true>
inline auto OnList(C *cell)       { return CellListAdapter<C>(cell); }
 
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type = true>
inline auto OnDrawList(const C *cell) { return CellDrawListAdapter<const C>(cell); }
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type = true>
inline auto OnDrawList(C *cell)       { return CellDrawListAdapter<C>(cell); }
 
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type>
inline auto OnInner(const C *cell) { return InnerCellAdapter(const_cast<Cell *>(cell)); }
template <typename C, typename std::enable_if<std::is_base_of<Cell, C>::value, bool>::type>
inline auto OnInner(C *cell) { return InnerCellAdapter(cell); }
 
inline int InnerCellIterator::GetInnerCellCount(const Cell *cell) { return cell->GetInnerCellCount(); }
inline Cell *InnerCellIterator::GetInnerCell(const Cell *cell, int index) { return cell->GetInnerCell(index); }
 
#endif // MATHCELL_H