GroupCell.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2008-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//            (C) 2012 Doug Ilijev <doug.ilijev@gmail.com>
//            (C) 2014-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 GROUPCELL_H
#define GROUPCELL_H
 
#include <utility>
#include <memory>
#include <vector>
#include "Cell.h"
#include "EditorCell.h"
#include <unordered_map>
 
// This enum's elements must be synchronized with (WXMFormat.h) WXMHeaderId.
enum GroupType : int8_t
{
  GC_TYPE_INVALID = -1,
  GC_TYPE_CODE = 0,
  GC_TYPE_TITLE,
  GC_TYPE_SECTION,
  GC_TYPE_SUBSECTION,
  GC_TYPE_SUBSUBSECTION,
  GC_TYPE_HEADING5,
  GC_TYPE_HEADING6,
  GC_TYPE_TEXT,
  GC_TYPE_IMAGE,
  GC_TYPE_PAGEBREAK
};
std::ostream& operator<<(std::ostream& out, const GroupType grouptype);
 
class GroupCell : public Cell
{
public:
  GroupCell(Configuration *config, GroupType groupType,
 const wxString &initString = {});
  GroupCell(GroupCell const &cell);
  GroupCell(GroupCell *group, const GroupCell &cell);
  std::unique_ptr<Cell> Copy() const;
  std::unique_ptr<Cell> Copy(GroupCell *group) const override;
  const CellTypeInfo &GetInfo() override;
  std::unique_ptr<GroupCell> CopyList() const;
  ~GroupCell() override;
 
  wxCoord GetMaxDrop() const override;
  wxCoord GetCenterList() const override;
 
  // cppcheck-suppress duplInheritedMember
  GroupCell *first() const { return dynamic_cast<GroupCell*>(Cell::first()); }
  // cppcheck-suppress duplInheritedMember
  GroupCell *last() const { return dynamic_cast<GroupCell*>(Cell::last()); }
 
  const wxString &GetAnswer(size_t answer) const;
  const wxString &GetAnswer(const wxString &question) const;
  bool ContainsSavedAnswers() const { return !m_knownAnswers.empty(); }
  bool AutoAnswer() const { return m_autoAnswer; }
  void SetAutoAnswer(bool autoAnswer);
  void MarkNeedsRecalculate();
  void SetAnswer(const wxString &question, const wxString &answer);
  void ForgetAnswers();
 
  size_t GetInnerCellCount() const override { return (m_groupType == GC_TYPE_PAGEBREAK) ? 0 : 2; }
  Cell *GetInnerCell(size_t index) const override {
    switch (index) {
    case 0:
      return m_inputLabel.get();
    case 1:
      return m_output.get();
    default:
      return nullptr;
    }
  }
 
  GroupCell *GetLastWorkingGroup() const;
 
  void CellUnderPointer(GroupCell *cell);
 
  const wxString GetToolTip(wxPoint point) const override;
  wxString GetLinkAt(wxPoint point) override;
 
  // general methods
  GroupType GetGroupType() const { return m_groupType; }
 
  void SetGroupType(GroupType groupType);
 
  // selection methods
  Range GetInnerCellsInRect(const wxRect &rect) const override;
 
  Range GetCellsInOutput() const;
 
  Range GetCellsInOutputRect(const wxRect &rect, wxPoint one, wxPoint two) const;
 
  // methods for manipulating GroupCell
  // cppcheck-suppress functionConst
  bool SetEditableContent(const wxString &text);
 
  void AppendOutput(std::unique_ptr<Cell> &&cell);
 
  void RemoveOutput();
 
  void RemoveMathOutput();
 
  AFontSize EditorFontSize() const;
 
  void UpdateConfusableCharWarnings();
 
  wxString ToTeX(const wxString &imgDir, const wxString &filename, std::size_t *imgCounter) const;
 
  wxString ToRTF() const override;
 
  wxString ToTeXCodeCell(const wxString &imgDir, const wxString &filename, std::size_t *imgCounter) const;
 
  static wxString ToTeXImage(const Cell *tmp, const wxString &imgDir, const wxString &filename, std::size_t *imgCounter);
 
  static wxString ToTeXAnimation(const Cell *tmp, const wxString &imgDir, const wxString &filename, std::size_t *imgCounter);
 
  wxString ToTeX() const override;
 
  wxString ToXML() const override;
 
  void Hide(bool hide) override;
  bool FirstLineOnlyEditor() const override;
  void SwitchHide();
 
  wxRect HideRect() const;
 
  wxCoord BracketColumnLeft() const;
 
  wxCoord ContentColumnRight() const;
 
  struct OutputLineWidths {
    wxCoord label = 0;
    wxCoord rest = 0;
  };
 
  static bool IsOutputLabel(const Cell &cell);
 
  static std::vector<OutputLineWidths> MeasureOutputLines(Cell *displayed);
 
  wxPoint CalculateLabelPosition() const;
 
  // raw manipulation of GC (should be protected)
  void SetInput(std::unique_ptr<Cell> &&input);
 
  void SetOutput(std::unique_ptr<Cell> &&output);
 
  void AppendInput(std::unique_ptr<Cell> &&cell);
 
  // cppcheck-suppress duplInheritedMember
  GroupCell *GetPrevious() const { return dynamic_cast<GroupCell *>(Cell::GetPrevious()); }
 
  // cppcheck-suppress duplInheritedMember
  GroupCell *GetNext() const { return dynamic_cast<GroupCell *>(Cell::GetNext()); }
 
  static wxString TexEscapeOutputCell(wxString Input);
 
  Cell *GetPrompt() const { return m_inputLabel.get(); }
 
  EditorCell *GetEditable() const
    { return m_inputLabel ? dynamic_cast<EditorCell *>(m_inputLabel->GetNext()) : nullptr; }
 
  Cell *GetLabel() const { return m_output.get(); }
 
  Cell *GetOutput() const
    { return m_output ? m_output->GetNext() : nullptr; }
 
  struct OutputResult
  {
    Cell *first = nullptr;
    Cell *last = nullptr;
  };
  std::vector<OutputResult> GetOutputResults() const;
 
  wxRect GetOutputRect() const { return m_outputRect; }
 
  bool ContainsPointOrOutput(wxPoint point) const
    { return ContainsPoint(point) || m_outputRect.Contains(point); }
 
  wxRect GetBracketRect() const;
 
  void Recalculate(const AFontSize fontsize) const override {
    if (fontsize.IsValid())
      m_mathFontSize = fontsize;
    else
      m_mathFontSize = m_configuration->GetMathFontSize();
    m_fontSize = m_mathFontSize;
    Recalculate();
  }
  bool Recalculate() const;
  bool Reposition() const;
  using Cell::NeedsRecalculation;
  bool NeedsRecalculation(AFontSize fontSize) const override;
  using Cell::SetCurrentPoint;
  void SetCurrentPoint(wxPoint point) const override;
  wxPoint CalculateInputPosition() const;
 
  void RecalculateInput() const;
  wxRect GetRect(bool all = false) const override;
  void RecalculateOutput() const;
 
  Cell *DisplayedOutput() const;
 
  void BreakLines() const;
 
  void ResetInputLabel();
 
  void ResetInputLabelList();
 
  bool IsFoldable() const;
 
  GroupCell *GetHiddenTree() const { return m_hiddenTree.get(); }
 
  bool HideTree(std::unique_ptr<GroupCell> &&tree);
 
  std::unique_ptr<GroupCell> UnhideTree();
 
  bool RevealHidden();
 
  void SetHiddenTreeParent(GroupCell *parent, GroupCell *last = nullptr);
 
  GroupCell *GetHiddenTreeParent() const { return m_hiddenTreeParent; }
 
  GroupCell *Fold(); // returns pointer to this or nullptr if not successful
  GroupCell *Unfold();
 
  GroupCell *FoldAll(std::vector<GroupCell *> *affected = nullptr);
 
  GroupCell *UnfoldAll(std::vector<GroupCell *> *affected = nullptr);
 
  bool IsLesserGCType(GroupType comparedTo) const;
 
  bool IsMainInput(const Cell *active) const;
 
  bool IsHeading() const;
  bool SectioningCanMoveIn() const {return IsHeading() && (GetGroupType() != GC_TYPE_HEADING6);};
  bool SectioningCanMoveOut() const {return IsHeading() && (GetGroupType() != GC_TYPE_TITLE);}
  GroupCell *SectioningUnitGetEndOf() const;
 
  void Number(int &section, int &subsection, int &subsubsection, int &heading5, int &heading6, int &image) const;
 
  void Draw(wxDC *dc, wxDC *antialiassingDC) override;
  bool DrawThisCell();
 
  bool AddEnding() override;
 
  void DrawBracket(wxDC *dc, wxDC *antialiassingDC);
 
  bool Empty() const;
 
  bool Contains(GroupCell *cell) const;
 
  wxString ToString() const override;
 
  void InEvaluationQueue(bool inQueue) { m_inEvaluationQueue = inQueue; }
 
  void LastInEvaluationQueue(bool last) { m_lastInEvaluationQueue = last; }
 
  void OnSize();
 
  void InputHeightChanged();
 
  void OutputHeightChanged();
 
  using CmdsAndVariables = std::unordered_map<wxString, int, wxStringHash>;
 
  std::vector<std::pair<wxString, wxString>> m_knownAnswers;
 
#if wxUSE_ACCESSIBILITY
  wxAccStatus GetName (int childId, wxString *name) const override;
  wxAccStatus GetDescription(int childId, wxString *description) const override;
  wxAccStatus GetLocation (wxRect &rect, int elementId) override;
  wxAccStatus GetRole (int childId, wxAccRole *role) const override;
#endif
 
  void UpdateYPosition() const;
 
  void UpdateOutputPositions() const;
 
  void UpdateYPositionList() const;
 
  bool GetSuppressTooltipMarker() const { return m_suppressTooltipMarker; }
  void SetSuppressTooltipMarker(bool suppress) { m_suppressTooltipMarker = suppress; }
 
protected:
  wxCoord GetInputIndent() const;
  void UpdateCellsInGroup();
 
//** 16-byte objects (16 bytes)
//**
  mutable wxRect m_outputRect{-1, -1, 0, 0};
 
//** 8/4 byte objects (40 bytes)
//**
  DocumentCellPointers *const m_documentCellPointers = GetDocumentCellPointers();
  ViewCellPointers *const m_viewCellPointers = GetViewCellPointers();
 
  std::unique_ptr<GroupCell> m_hiddenTree; 
  GroupCell *m_hiddenTreeParent = {}; 
 
  // The pointers below point to inner cells and must be kept contiguous.
  // ** All pointers must be the same: either Cell * or std::unique_ptr<Cell>.
  // ** NO OTHER TYPES are allowed.
  std::unique_ptr<Cell> m_inputLabel;
  std::unique_ptr<Cell> m_output;
  // The pointers above point to inner cells and must be kept contiguous.
 
  mutable std::unique_ptr<Cell> m_layoutSuppressedNotice;
  CellPtr<Cell> m_lastAppendedOutput;
 
//** 4-byte objects (16 bytes)
//**
  mutable int m_labelWidth_cached = 0;
  mutable int m_inputWidth, m_inputHeight;
protected:
//** 2-byte objects (6 bytes)
//**
  int16_t m_cellsInGroup = 1;
  mutable int16_t m_numberedAnswersCount = 0;
 
  mutable AFontSize m_mathFontSize;
 
//** 1-byte objects (1 byte)
//**
  GroupType m_groupType = {};
 
//** Bitfield objects (1 bytes)
//**
  bool m_autoAnswer : 1 = false;
  bool m_inEvaluationQueue : 1 = false;
  bool m_lastInEvaluationQueue : 1 = false;
  bool m_updateConfusableCharWarnings : 1 = true;
  bool m_suppressTooltipMarker : 1 = false;
  mutable bool m_cellsAppended : 1 = false;
  mutable bool m_layoutSuppressed : 1 = false;
 
  static wxString m_lookalikeChars;
};
 
#endif /* GROUPCELL_H */