MatrCell.h

// -*- 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) 2014-2016 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 MATRCELL_H
#define MATRCELL_H
 
#include "Cell.h"
#include "MatrixBlock.h"
#include <optional>
 
#include <vector>
 
class MatrCell final : public Cell
{
public:
  MatrCell(GroupCell *group, Configuration *config);
  MatrCell(GroupCell *group, const MatrCell &cell);
  std::unique_ptr<Cell> Copy(GroupCell *group) const override;
  const CellTypeInfo &GetInfo() override;
 
  size_t GetInnerCellCount() const override { return m_cells.size(); }
  Cell *GetInnerCell(size_t index) const override { return m_cells.at(index).get(); }
  Cell *GetInnerCell(int x, int y) const {
    return m_cells.at(static_cast<size_t>(x) * m_matWidth + y).get(); }
 
  void Recalculate(const AFontSize fontsize) const override;
 
  using Cell::SetCurrentPoint;
  void SetCurrentPoint(wxPoint point) const override;
  void Draw(wxDC *dc, wxDC *antialiassingDC) override;
 
  const wxString GetToolTip(wxPoint point) const override;
  Range GetInnerCellsInRect(const wxRect &rect) const override;
 
  std::optional<MatrixBlock> BlockInRect(const wxRect &rect) const;
  bool IsWholeMatrix(const MatrixBlock &block) const;
  wxRect BlockRect(const MatrixBlock &block) const;
  MatrixEntry StepEntry(const MatrixEntry &entry, int rowStep,
                        int colStep) const;
  std::unique_ptr<MatrCell> CopyBlock(const MatrixBlock &block,
                                      GroupCell *group) const;
 
  size_t GetMatrixRows() const { return m_matHeight; }
  size_t GetMatrixColumns() const { return m_matWidth; }
 
  bool IsElided(size_t row, size_t col) const
    { return m_rowElision.Hides(row) || m_colElision.Hides(col); }
  bool EntryAt(wxPoint point, size_t &row, size_t &col) const;
  size_t ElidedColumns() const { return m_colElision.count; }
  size_t ElidedRows() const { return m_rowElision.count; }
 
  bool HasHorizontalScrollbar() const { return m_hasHorizontalScrollbar; }
  bool HasVerticalScrollbar() const { return m_hasVerticalScrollbar; }
  wxRect HorizontalScrollbarRect() const;
  wxRect VerticalScrollbarRect() const;
  wxRect ViewportRect() const;
  wxSize ScrollableSize() const { return m_scrollableSize; }
  wxSize ViewportSize() const { return m_contentSize; }
  wxPoint ScrollPosition() const { return m_scroll; }
  bool ScrollTo(wxPoint position);
  bool ScrollEntryIntoView(size_t row, size_t col);
  bool IsNestedInMatrix() const { return m_nestedInMatrix; }
  void AddNewCell(std::unique_ptr<Cell> &&cell);
 
  void NewRow() { m_matHeight++; m_dropCenters.emplace_back(-1, -1);}
  void NewColumn() { m_matWidth++; m_widths.emplace_back(-1);}
 
  void SetDimension();
 
  wxString ToMathML() const override;
  wxString ToMatlab() const override;
  wxString ToCSV(const wxString &delimiter) const;
  wxString ToOMML() const override;
  wxString ToString() const override;
  wxString ToTeX() const override;
  wxString ToXML() const override;
 
  void SetSpecialFlag(bool special) { m_specialMatrix = special; }
 
  void SetInferenceFlag(bool inference) { m_inferenceMatrix = inference; }
 
  void RowNames(bool rn) { m_rowNames = rn; }
 
  void ColNames(bool cn) { m_colNames = cn; }
 
  void RoundedParens()  { m_parenType = paren_rounded;}
  void BracketParens()  { m_parenType = paren_brackets;}
  void StraightParens() { m_parenType = paren_straight;}
  void AngledParens()   { m_parenType = paren_angled;}
  void NoParens()       { m_parenType = paren_none;}
 
  void SetOversizedMode(std::optional<Configuration::OversizedMatrices> mode) {
    m_oversizedMode = mode ? static_cast<uint8_t>(*mode) : oversizedFollowConfig;
  }
  std::optional<Configuration::OversizedMatrices> GetOversizedMode() const {
    if (m_oversizedMode == oversizedFollowConfig)
      return std::nullopt;
    return static_cast<Configuration::OversizedMatrices>(m_oversizedMode);
  }
  static wxString OversizedModeName(Configuration::OversizedMatrices mode);
  static std::optional<Configuration::OversizedMatrices>
  OversizedModeFromName(const wxString &name);
 
private:
  struct DropCenter
  {
    int drop = {}, center = {};
    constexpr int Sum() const { return drop + center; }
    constexpr DropCenter() = default;
    constexpr DropCenter(int drop, int center) : drop(drop), center(center) {}
  };
 
  struct Elision
  {
    size_t first = 0;
    size_t count = 0;
    constexpr bool Active() const { return count > 0; }
    constexpr bool Hides(size_t index) const
      { return (index >= first) && (index < first + count); }
  };
 
  static Elision ChooseElision(const std::vector<wxCoord> &sizes,
                               wxCoord gapSize, wxCoord budget);
 
  wxCoord ElementSkip() const {return Scale_Px(5);}
  wxCoord DotsSkip() const {return Scale_Px(20);}
  wxCoord DotPitch() const;
  wxCoord DotRadius() const;
  wxCoord DotsExtent() const { return 2 * DotPitch() + 2 * DotRadius(); }
  wxCoord DotsGap() const {return DotsExtent() + DotsSkip() * 2;}
  void DrawDots(wxDC *dc, wxPoint start, wxPoint step) const;
  void DrawElisionMarks(wxDC *dc) const;
  void DrawBands(wxDC *dc) const;
public:
  bool IsShownPartially() const
    { return m_colElision.Active() || m_rowElision.Active() || IsScrolling(); }
  bool IsBanded() const {
    if (const auto banding = GetBanding())
      return *banding;
    return m_alwaysBanded || IsShownPartially();
  }
  void SetBanding(std::optional<bool> banding) {
    m_banding = !banding ? bandingAuto : (*banding ? bandingOn : bandingOff);
  }
  std::optional<bool> GetBanding() const {
    if (m_banding == bandingAuto)
      return std::nullopt;
    return m_banding == bandingOn;
  }
  void AlwaysBanded(bool banded) { m_alwaysBanded = banded; }
private:
  bool IsScrolling() const
    { return m_hasHorizontalScrollbar || m_hasVerticalScrollbar; }
  bool IsEntryShown(size_t row, size_t col) const;
  wxRect EntrySlotRect(size_t row, size_t col) const;
  void ClampScrollPosition() const;
  static void MarkNestedMatrices(Cell *list);
 
  std::vector<std::unique_ptr<Cell>> m_cells;
 
  mutable std::vector<wxCoord> m_widths;
  mutable std::vector<DropCenter> m_dropCenters;
 
  mutable wxSize m_contentSize;
  mutable wxSize m_scrollableSize;
  mutable wxPoint m_scroll;
  mutable wxCoord m_scrollbarThickness = 0;
 
  mutable Elision m_colElision;
  mutable Elision m_rowElision;
 
  size_t m_matWidth = 0;
  size_t m_matHeight = 0;
 
  enum parenType : int8_t
  {
    paren_rounded = 0,
    paren_brackets = 1,
    paren_angled = 2,
    paren_straight = 3,
    paren_none = 4
  };
//** Bitfield objects (1 bytes)
//**
  uint8_t m_parenType : 3 = paren_rounded;
  static constexpr uint8_t oversizedFollowConfig = 3;
  static_assert(static_cast<uint8_t>(Configuration::OversizedMatrices::scroll) <
                oversizedFollowConfig,
                "m_oversizedMode is too narrow for OversizedMatrices");
  uint8_t m_oversizedMode : 2 = oversizedFollowConfig;
  bool m_specialMatrix : 1 = false;
  bool m_inferenceMatrix : 1 = false;
  bool m_rowNames : 1 = false;
  bool m_colNames : 1 = false;
  bool m_nestedInMatrix : 1 = false;
  bool m_alwaysBanded : 1 = false;
  static constexpr uint8_t bandingAuto = 0, bandingOn = 1, bandingOff = 2;
  uint8_t m_banding : 2 = bandingAuto;
  mutable bool m_hasHorizontalScrollbar : 1 = false;
  mutable bool m_hasVerticalScrollbar : 1 = false;
};
 
#endif // MATRCELL_H