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 CELL_H
#define CELL_H
 
#include "../precomp.h"
#include "CellPtr.h"
#include "CellIterators.h"
#include "Configuration.h"
#include "StringUtils.h"
#include "TextStyle.h"
#include "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        
};
std::ostream& operator<<(std::ostream& out, const CellType celltype);
 
#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;
 
  wxCoord 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();
 
  unsigned long CellsInListRecursive() const;
 
  wxRect CropToUpdateRegion(wxRect rect) const;
 
  bool InUpdateRegion() const;
 
  void SoftLineBreak(bool breakLine = true) const
  {
    bool newBreak = breakLine || m_forceBreakLine;
    if (m_breakLine != newBreak)
    {
      m_breakLine = newBreak;
      InvalidateListCache();
    }
  }
  
  bool BreakUpCells() const;
 
  void CollectWideCells(std::vector<const Cell *> &wideCells,
                        int clientWidth) const;
 
  bool UnBreakUpCells() const;
 
  void BreakLines_List() const;
 
  int GetLineIndent() const;
 
  bool BreakLineHere() const { return m_breakLine || m_forceBreakLine; }
 
  bool HasHardLineBreak() const { return m_forceBreakLine; }
 
  virtual bool BreakUp() const;
 
protected:
  void BreakUpAndMark() const;
 
protected:
  wxBitmap BitmapFromSVG(wxString svgData, wxSize size);
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(wxDC *dc, wxDC *antialiassingDC);
 
  void DrawList(wxDC *dc, wxDC *adc);
 
  virtual void DrawBoundingBox(wxDC &WXUNUSED(dc), bool all = false);
 
  bool DrawThisCell();
 
  void ForceBreakLine(bool force = true) const
  {
    if (m_forceBreakLine != force || m_breakLine != force)
    {
      m_forceBreakLine = m_breakLine = force;
      InvalidateListCache();
    }
  }
 
  wxString GetUUID() const { return m_uuid; }
  void SetUUID(const wxString &uuid) { m_uuid = uuid; }
  void GenerateUUID();
  wxString GetExtraXMLAttributes() const;
  void AddExtraAttribute(const wxString &name, const wxString &value);
 
  wxCoord GetHeight() const;
 
  int GetWidth() const;
 
  wxCoord GetCenter() const;
 
  bool HasValidSize() const;
  bool HasStaleSize() const;
  bool HasValidPosition() const;
 
  wxCoord GetDrop() const
    { return GetHeight() - GetCenter(); }
 
  CellType GetType() const
    { return m_type; }
 
  virtual wxCoord GetMaxDrop() const;
 
  virtual wxCoord GetCenterList() const;
 
  virtual wxCoord GetHeightList() const;
 
  wxCoord SumOfWidths() const;
 
  wxCoord GetLineWidth() const;
 
  wxCoord GetCurrentX() const
    { return m_currentPoint.x; }
 
  wxCoord GetCurrentY() const
    { return m_currentPoint.y; }
 
  virtual wxRect GetRect(bool wholeList = false) const;
 
  virtual bool NeedsRecalculation(AFontSize fontSize) const;
  bool NeedsRecalculation() const { return NeedsRecalculation(m_fontSize); }
 
  void ScheduleRecalculation() const {m_cellCfgCnt_last = m_configuration->CellCfgCnt() - 1 ;}
  bool ConfigChanged() const {return m_configuration->CellCfgCnt() != m_cellCfgCnt_last;}
  virtual wxString GetDiffPart() const;
 
  virtual void Recalculate(AFontSize fontsize) const;
 
  void RecalculateList(AFontSize fontsize) const;
 
  void FontsChangedList();
 
  void ResetSize_Recursively() const;
 
  void ResetSize_RecursivelyList() const;
 
  void ResetSize() const;
 
  void ResetSizeList() const;
 
  void SetBigSkip(bool skip) { m_bigSkip = skip; }
  bool HasBigSkip() const { return m_bigSkip; }
 
  virtual void SetType(CellType type);
 
  const TextStyle &GetTextStyle() const
    { return m_textStyle; }
 
  // cppcheck-suppress functionStatic
  // cppcheck-suppress functionConst
  void SetPen(wxDC *dc, double lineWidth = 1.0) const;
  void SetBrush(wxDC *dc) const;
  wxColour GetForegroundColor() const;
 
  void SetHighlight(bool highlight) { m_highlight = highlight; }
  bool GetHighlight() const { return m_highlight; }
 
  virtual void SetIsExponent();
 
  virtual void SetIsExponentList();
 
  virtual void SetValue(const wxString &WXUNUSED(text)) {}
  virtual const wxString &GetValue() const;
  virtual const wxString GetDisplayedString() const {return GetValue();}
 
  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 GetXMLFlags() 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() const;
 
  virtual void UnbreakList() const;
 
  Cell *GetPrevious() const { return m_previous; }
 
  Cell *GetNext() const { return m_next.get(); }
  Cell *GetNextToDraw() const { return m_nextToDraw; }
 
  virtual void SetNextToDraw(Cell *next) const { 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 bool FirstLineOnlyEditor() const;
  
  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(size_t WXUNUSED(pos))
    { return wxDefaultPosition; }
 
  virtual wxPoint PositionToPoint()
    { return wxDefaultPosition; }
 
  virtual bool IsDirty() const
    { return false; }
 
  virtual void SwitchCaretDisplay()
    {}
 
  virtual void SetFocus(bool WXUNUSED(focus))
    {}
 
  void SetTextColor(wxDC *dc);
 
  virtual bool IsActive() const
    { return false; }
 
  virtual void SetStyle(TextStyle style)
    {
      ResetSize_Recursively();
      m_textStyle = style;
    }
  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(const wxString &tooltip) const ;
  void SetToolTip(const wxString *toolTip) const;
  void AddToolTip(const wxString &tip);
 
 
  virtual void SetCurrentPoint(wxPoint point);
 
  void SetCurrentPoint(int x, int y) { SetCurrentPoint({x, y}); }
 
  void SetCurrentPointList(wxPoint point);
 
  void SetCurrentPointDrawList(wxPoint point);
 
  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
 
  static wxString wxColor2HtmlString(wxColor col);
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)
//**
  mutable wxPoint m_currentPoint{-1, -1};
 
protected:
//** 8/4-byte objects (40 + 8* bytes)
//**
 
private:
  mutable std::atomic<std::int_fast32_t> m_cellCfgCnt_last = { -1 };
  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;
  mutable CellPtr<Cell> m_nextToDraw;
 
  Configuration *m_configuration;
 
  mutable const wxString *m_toolTip /* initialized in the constructor */;
 
//** 4-byte objects (28 bytes)
//**
protected:
  mutable CachedInteger<wxCoord> m_height;
  mutable CachedInteger<wxCoord> m_width;
  mutable CachedInteger<wxCoord> m_center;
  mutable CachedInteger<wxCoord> m_cachedMaxDrop;
  mutable CachedInteger<wxCoord> m_cachedCenterList;
  mutable CachedInteger<wxCoord> m_cachedSumOfWidths;
  mutable CachedInteger<wxCoord> m_cachedLineWidth;
protected:
//** 2-byte objects (2 bytes)
//**
  mutable AFontSize m_fontSize_Scaled = {};
  mutable AFontSize m_fontSize = {};
 
//** 1-byte objects (2 bytes)
//**
  // The celltype of this object
  CellType m_type = MC_TYPE_DEFAULT;
  // The text style of this object
  TextStyle m_textStyle = TS_MATH;
 
private:
//** Bitfield objects (2 bytes)
//**
  void InitBitFields_Cell()
    { // 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_breakLine = false;
      m_forceBreakLine = false;
      m_highlight = false;
    }
 
  void UpdateListCaches() const;
 
  // In the boolean bit fields below, InitBitFields_Cell is an indication that
  // the InitBitFields_Cell() 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.
 
  mutable bool m_ownsToolTip : 1 /* InitBitFields_Cell */;
  bool m_bigSkip : 1 /* InitBitFields_Cell */;
  mutable bool m_isBrokenIntoLines : 1 /* InitBitFields_Cell */;
  bool m_isHidden : 1 /* InitBitFields_Cell */;
  bool m_isHidableMultSign : 1 /* InitBitFields_Cell */;
  bool m_suppressMultiplicationDot : 1 /* InitBitFields_Cell */;
  mutable bool m_breakLine : 1 /* InitBitFields_Cell */;
protected:
  wxString m_uuid;
  std::map<wxString, wxString> m_extraAttributes;
 
  mutable bool m_forceBreakLine : 1 /* InitBitFields_Cell */;
  bool m_highlight : 1 /* InitBitFields_Cell */;
 
protected:
  friend class InnerCellIterator;
  virtual size_t GetInnerCellCount() const;
  virtual Cell *GetInnerCell(size_t index) const;
 
  inline Worksheet *GetWorksheet() const;
 
  virtual void FontsChanged() const
    { ResetSize_Recursively(); }
 
  CellPointers *GetCellPointers() const;
 
  void InvalidateListCache() const;
};
 
// 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 **child) 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 size_t InnerCellIterator::GetInnerCellCount(const Cell *cell) { return cell->GetInnerCellCount(); }
inline Cell *InnerCellIterator::GetInnerCell(const Cell *cell, size_t index) { return cell->GetInnerCell(index); }
 
#endif // CELL_H