wxmaxima/Doxygen-documentation/Configuration_8h_source.html

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-

//

//  Copyright (C) 2004-2015 Andrej Vodopivec <andrej.vodopivec@gmail.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 CONFIGURATION_H

#define CONFIGURATION_H


#include "precomp.h"

#include <wx/wx.h>

#include <wx/config.h>

#include <wx/display.h>

#include <wx/fontenum.h>

#include <wx/hashmap.h>

#include "dialogs/LoggingMessageDialog.h"

#include "cells/TextStyle.h"

#include "FontRenderabilityCache.h"

#include "MaximaSessionInfo.h"

#include "RenderContext.h"

#include "Styles.h"

#include <cstdint>

#include <functional>

#include <memory>

#include <mutex>

#include <unordered_map>

#include <random>

#include <list>

#include <variant>

#include <vector>

#include <algorithm>

#include <atomic>

#include <chrono>

#include <wx/wupdlock.h>

#include <list>


#define MC_LINE_SKIP Scale_Px(2)

#define MC_TEXT_PADDING Scale_Px(1)


#define PAREN_OPEN_TOP_UNICODE     "\u239b"

#define PAREN_OPEN_EXTEND_UNICODE  "\u239c"

#define PAREN_OPEN_BOTTOM_UNICODE  "\u239d"

#define PAREN_CLOSE_TOP_UNICODE    "\u239e"

#define PAREN_CLOSE_EXTEND_UNICODE "\u239f"

#define PAREN_CLOSE_BOTTOM_UNICODE "\u23a0"

#define SUM_SIGN "\u2211"

#define PROD_SIGN "\u220F"

#define SUM_DEC 2


#define MC_HCARET_WIDTH 25


#define MC_EXP_INDENT static_cast<wxCoord>(Scale_Px(2))

static constexpr AFontSize MC_MIN_SIZE{ 6.0f };

static constexpr AFontSize MC_MAX_SIZE{ 48.0f };


// The minimal and maximal label width

#define LABELWIDTH_MIN 3

#define LABELWIDTH_MAX 10

class Cell;

class DocumentCellPointers;

class ViewCellPointers;

class GroupCell;

template<class T> class wxScrolled;

typedef wxScrolled<wxWindow> wxScrolledCanvas;


class Configuration

{

public:

  struct PerformanceStats {

    std::atomic<long> manualAnchorsFromBuiltin{0};

    std::atomic<long> manualAnchorsFromCache{0};

    std::atomic<long> manualAnchorsCompiled{0};

    std::atomic<long> maximaProcessesSpawned{0};

    std::atomic<long> fontCacheHits{0};

    std::atomic<long> fontCacheMisses{0};

    std::atomic<long> recalculationNeeded_FontInvalid{0};

    std::atomic<long> recalculationNeeded_SizeInvalid{0};

    std::atomic<long> recalculationNeeded_FontMismatch{0};

    std::atomic<long> recalculationNeeded_ConfigChanged{0};

    std::atomic<long> recalculationNeeded_CellsAppended{0};

    std::atomic<long> recalculationNeeded_EditorDirty{0};

    std::atomic<long> cellsConvertedToLinear{0};

    std::atomic<long> cellsConvertedTo2D{0};

    std::atomic<long> cellsDrawnAtWrongFontSize{0};

    std::atomic<long> worksheetRepaints{0};

    std::atomic<long> worksheetFullRepaints{0};

    void Report() const;

  };

  static PerformanceStats g_stats;


  enum maximaHelpFormat{

    maxima = 0,

    frontend = 1,

    browser = 2

  };

  enum htmlExportFormat

  {

    mathJaX_TeX = 0,

    bitmap = 1,

    mathML_mathJaX = 2,

    svg = 3,

    mathML = 4,

    html_export_invalidChoice

  };


  enum showLabels : int8_t

  {

    labels_automatic = 0,

    labels_prefer_user = 1,

    labels_useronly = 2,

    labels_none = 3,

    labels_invalidSelection

  };


  enum drawMode

  {

    ascii,

    handdrawn

  };


  enum InitOpt

  {

    none,

    temporary

  };


  enum mathDisplayMode

  {

    display_2d,

    display_2dASCII,

    display_2dUNICODE,

    display_1dASCII

  };


  typedef std::unordered_map <wxString, bool, wxStringHash> StringBoolHash;

  bool IsOperator(wxString name) const {return m_maximaSession.IsOperator(name);}

  void AddMaximaOperator(const wxString &name){m_maximaSession.AddOperator(name);}

  const wxEnvVariableHashMap& MaximaEnvVars() const {return m_maximaEnvVars;}

  void ClearMaximaEnvVars(){m_maximaEnvVars.clear();}

  void SetMaximaEnvVar(const wxString &name, const wxString &value){m_maximaEnvVars[name] = value;}


  mathDisplayMode DisplayMode() const {return m_displayMode;}

  void DisplayMode(mathDisplayMode mode ) {m_displayMode = mode;}


  void SetWorkingDirectory(wxString dir)

    { m_maximaSession.SetWorkingDirectory(std::move(dir)); }


  wxString GetWorkingDirectory() const

    { return m_maximaSession.GetWorkingDirectory(); }


  void ReadConfig();


  explicit Configuration(wxDC *dc = {}, InitOpt options = none);

  Configuration(const Configuration &o);


  void ResetAllToDefaults();


  void SetRecalcContext(wxDC &dc)

    {

      m_renderContext.SetRecalcDC(&dc);

    }

  void UnsetContext() {m_renderContext.SetRecalcDC(NULL);}


  void SetBackgroundBrush(const wxBrush &brush);

  bool FixedFontInTextControls() const {return m_fixedFontTC;}

  void FixedFontInTextControls(bool fixed) {m_fixedFontTC = fixed;}

  wxBrush GetBackgroundBrush() const {return m_renderContext.GetBackgroundBrush();}

  wxBrush GetTooltipBrush() const {return m_tooltipBrush;}


  virtual ~Configuration();


  static wxString m_configfileLocation_override;


  using EscCodeContainer = std::unordered_map<wxString, wxString, wxStringHash>;

  using EscCodeIterator = EscCodeContainer::const_iterator;


  static const wxString &GetEscCode(const wxString &key);

  static EscCodeIterator EscCodesBegin();

  static EscCodeIterator EscCodesEnd();


  static double GetMinZoomFactor()

    { return 0.1; }


  static double GetMaxZoomFactor()

    { return 32.0; }


  double GetInterEquationSkip() const

    {

      if (ShowAutomaticLabels())

        return 0;

      else

        return GetZoomFactor() * m_styleStore[TS_MATH].GetFontSize() / 2;

    }


  wxCoord GetCellBracketWidth() const

    {

      return static_cast<wxCoord>(GetZoomFactor() * 16);

    }


  bool HideBrackets() const

    { return m_hideBrackets; }


  void HideBrackets(bool hide){m_hideBrackets = hide;}


  bool OverlayScrollbars() const

    { return m_overlayScrollbars; }


  void OverlayScrollbars(bool overlay){m_overlayScrollbars = overlay;}


  double PrintScale() const

    { return m_printScale; }


  void PrintScale(double scale){m_printScale = scale;}


  void PrintMargin_Top(double margin){m_printMargin_Top = margin;}

  void PrintMargin_Bot(double margin){m_printMargin_Bot = margin;}

  void PrintMargin_Left(double margin){m_printMargin_Left = margin;}

  void PrintMargin_Right(double margin){m_printMargin_Right = margin;}

  double PrintMargin_Top() const {return m_printMargin_Top;}

  double PrintMargin_Bot() const {return m_printMargin_Bot;}

  double PrintMargin_Left() const {return m_printMargin_Left;}

  double PrintMargin_Right() const {return m_printMargin_Right;}


  void SetZoomFactor(double newzoom);


  void SetZoomFactor_temporarily(double newzoom){

    if(m_zoomFactor != newzoom)

      RecalculateForce();

    m_zoomFactor = newzoom;

  }


  wxCoord Scale_Px(double px) const;

  AFontSize Scale_Px(AFontSize size) const;


  double GetZoomFactor() const

    { return m_zoomFactor; }


  wxDC *GetRecalcDC() const

    { return m_renderContext.GetRecalcDC(); }


  void SetRecalcDC(wxDC *dc)

    { m_renderContext.SetRecalcDC(dc); }


  wxString GetFontName(TextStyle ts = TS_CODE_DEFAULT) const;


  // cppcheck-suppress functionStatic

  // cppcheck-suppress functionConst

  wxString GetSymbolFontName() const;


  static const wxString CharsNeedingQuotes()

    {

      return wxString(wxS("°,\\'\"()[]-{}^+*/&§?:;=#<>$"));

    }


  wxFontWeight IsBold(long st) const;


  wxFontStyle IsItalic(long st) const;


  bool IsUnderlined(long st) const {return m_styleStore[st].IsUnderlined();}


  wxCoord GetLabelWidth() const

    { return m_labelWidth * 14; }


  long LabelWidth() const

    { return m_labelWidth; }

  void LabelWidth(long labelWidth)

    {

      if(m_labelWidth != labelWidth)

        RecalculateForce();

      m_labelWidth = labelWidth;

    }


  wxCoord GetIndent() const

    {

      if (m_indent < 0)

        return 3 * GetCellBracketWidth() / 2;

      else

        return m_indent;

    }


  wxSize GetPPI() const;

  int AutosaveMinutes() const {return m_autoSaveMinutes;}

  void AutosaveMinutes(int minutes){m_autoSaveMinutes = minutes;}


  long GetCursorWidth() const

    {

      long ppi;


      if(!GetPrinting())

        ppi = GetPPI().x;

      else

        ppi = 96;


      if (ppi / 45 < 1)

        return 1;

      else

        return ppi / 45;

    }


  long GetBaseIndent() const

    {

      if (GetCursorWidth() < 12)

        return 12;

      else

        return 4 + GetCursorWidth();

    }


  long GetGroupSkip() const

    {

      if (GetCursorWidth() < 10)

        return 20;

      else

        return 10 + GetCursorWidth();

    }


  void SetIndent(long indent)

    {

      if(m_indent != indent)

        RecalculateForce();

      m_indent = indent;

    }


  bool IncrementalSearch() const {return m_incrementalSearch;}


  void IncrementalSearch(bool incrementalSearch) { m_incrementalSearch = incrementalSearch; }


  int MaxLayoutTime() const { return m_maxLayoutTime; }

  void MaxLayoutTime(int time) { m_maxLayoutTime = time; }


  enum class LayoutStrategy {

    layout2DWheneverPossible = 0,

    layout2DIfFits = 1,

    layoutPrefer1D = 2

  };

  LayoutStrategy GetLayoutStrategy() const { return m_layoutStrategy; }

  void SetLayoutStrategy(LayoutStrategy s) { m_layoutStrategy = s; }


  void SetLayoutDeadline(int seconds) {

    m_renderContext.SetLayoutDeadline(seconds);

  }

  void ClearLayoutCancelled() {

    m_renderContext.ClearLayoutCancelled();

  }

  bool IsLayoutCancelled() const {

    return m_renderContext.IsLayoutCancelled();

  }


  void FontChanged()

    {

      RecalculateForce();

    }


  double GetDefaultLineWidth() const

    {

      if (GetZoomFactor() < 1.0)

        return 1.0;

      else

        return GetZoomFactor();

    }


  long LineWidth_em() const

    {

      if(!GetPrinting())

        return m_lineWidth_em;

      else

        return 10000;

    }


  bool AutoSaveAsTempFile() const {return m_autoSaveAsTempFile;}

  void AutoSaveAsTempFile(bool asTempFile){m_autoSaveAsTempFile = asTempFile;}


  void LineWidth_em(long width)

    { m_lineWidth_em = width; }


  // On big 16:9 screens text tends to get \b very wide before it hits the right margin.

  // But text blocks that are 1 meter wide and 2 cm high feel - weird.

  long GetLineWidth() const;


  bool SaveUntitled() const { return m_saveUntitled;}

  void SaveUntitled(bool save) {m_saveUntitled = save;}


  bool CursorJump() const { return m_cursorJump;}

  void CursorJump(bool save){m_cursorJump = save;}


  bool NumpadEnterEvaluates() const { return m_numpadEnterEvaluates;}

  void NumpadEnterEvaluates(bool eval){m_numpadEnterEvaluates = eval;}


  bool SaveImgFileName() const { return m_saveImgFileName;}

  void SaveImgFileName(bool save) { m_saveImgFileName = save;}


  bool GetAutoWrap() const

    { return m_autoWrap > 0; }


  bool GetAutoWrapCode() const

    { return m_autoWrap > 1; }


  void SetAutoWrap(long autoWrap){

    m_autoWrap = autoWrap;

    if (m_autoWrap < 0)

      m_autoWrap = 0;

    if (m_autoWrap > 2)

      m_autoWrap = 1;

  }


  bool GetAutoIndent() const

    { return m_autoIndent; }


  void SetAutoIndent(bool autoIndent){m_autoIndent = autoIndent;}


  bool IndentMaths() const {return m_indentMaths;}

  void IndentMaths(bool indent){

    if(m_indentMaths != indent)

      RecalculateForce();

    m_indentMaths = indent;}

  AFontSize GetFontSize(TextStyle st) const { return m_styleStore[st].GetFontSize(); }


  static const wxString &GetStyleName(TextStyle textStyle);


  void ReadStyles(const wxString &file = {});


  void WriteStyles(const wxString &file = {});

  void WriteStyles(wxConfigBase *config);

  void WriteSettings(const wxString &file = {});

  static const std::vector<std::pair<TextStyle, wxString>> &StyleConfigKeys();


  struct ScalarSetting {

    const wxChar *key;

    std::variant<bool Configuration::*, int Configuration::*,

                 long Configuration::*, double Configuration::*,

                 wxString Configuration::*>

        member;

  };

  static const std::vector<ScalarSetting> &ScalarConfigSettings();

  void MakeStylesConsistent();

  void Outdated(bool outdated)

    { m_outdated = outdated; }


  bool CheckKeepPercent() const

    { return m_keepPercent; }


  void SetKeepPercent(bool keepPercent)

    {

      if(m_keepPercent != keepPercent)

        RecalculateForce();

      m_keepPercent = keepPercent;

    }


  wxString GetTeXCMRI() const

    { return m_fontCMRI; }


  wxString GetTeXCMSY() const

    { return m_fontCMSY; }


  wxString GetTeXCMEX() const

    { return m_fontCMEX; }


  wxString GetTeXCMMI() const

    { return m_fontCMMI; }


  wxString GetTeXCMTI() const

    { return m_fontCMTI; }


  bool ShowCodeCells() const

    { return m_showCodeCells; }


  void ShowCodeCells(bool show);


  void SetPrinting(bool printing);


  bool GetPrinting() const

    { return m_renderContext.Printing(); }


  wxColour GetColor(TextStyle style);


  bool UsePngCairo() const { return m_usepngCairo;}

  void UsePngCairo(bool usepngCairo) { m_usepngCairo = usepngCairo;}


  bool GetMatchParens() const { return m_matchParens; }

  void SetMatchParens(bool matchParens) { m_matchParens = matchParens; }

  bool ShowMatchingParens() const { return m_showMatchingParens; }

  void ShowMatchingParens(bool show) { m_showMatchingParens = show; }


  bool GetChangeAsterisk() const{ return m_changeAsterisk; }


  void SetChangeAsterisk(bool changeAsterisk) {

    if(m_changeAsterisk != changeAsterisk)

      RecalculateForce();

    m_changeAsterisk = changeAsterisk;

  }


  bool HidemultiplicationSign() const {return m_hidemultiplicationsign;}


  void HidemultiplicationSign(bool show) {

    if(m_hidemultiplicationsign != show)

      RecalculateForce();

    m_hidemultiplicationsign = show;

  }


  bool Latin2Greek() const

    {return m_latin2greek;}


  void Latin2Greek(bool latin2greek) {

    if(m_latin2greek != latin2greek)

      RecalculateForce();

    m_latin2greek = latin2greek;

  }


  bool GreekSidebar_ShowLatinLookalikes() const {return m_greekSidebar_ShowLatinLookalikes;}

  void GreekSidebar_ShowLatinLookalikes(bool show){m_greekSidebar_ShowLatinLookalikes = show;}


  bool GreekSidebar_Show_mu() const {return m_greekSidebar_Show_mu;}

  void GreekSidebar_Show_mu(bool show) {m_greekSidebar_Show_mu = show;}


  wxString SymbolPaneAdditionalChars() const

    {return m_symbolPaneAdditionalChars;}

  void SymbolPaneAdditionalChars(wxString symbols) {m_symbolPaneAdditionalChars = std::move(symbols);}


  bool NotifyIfIdle() const

    { return m_notifyIfIdle; }


  void NotifyIfIdle(bool notify) {m_notifyIfIdle = notify;}


  long GetDisplayedDigits() const

    { return m_displayedDigits; }


  void SetDisplayedDigits(long displayedDigits)

    {

      wxASSERT_MSG(displayedDigits >= 0, _("Bug: Maximum number of digits that is to be displayed is too low!"));

      if(m_displayedDigits != displayedDigits)

        RecalculateForce();

      m_displayedDigits = displayedDigits;

    }


  class FileToSave

  {

  public:

    FileToSave(const wxString &filename, const wxMemoryBuffer &data):

      m_data(data),

      m_filename(filename)

      {

      }

    const wxString FileName() const{return m_filename;}

    const wxMemoryBuffer Data() const{return m_data;}

  private:

    const wxMemoryBuffer m_data;

    const wxString m_filename;

  };


  class TextsnippetToDraw

  {

  public:

    TextsnippetToDraw(const wxPoint &pos, const wxString &text, const wxColor &color):

      m_pos(pos),

      m_text(text),

      m_color(color)

      {

      }

    const wxPoint  Pos() const{return m_pos;}

    const wxString Text() const{return m_text;}

    const wxColor  Color() const{return m_color;}

  private:

    const wxPoint  m_pos;

    const wxString m_text;

    const wxColor  m_color;

  };


  void PushFileToSave(const wxString &filename, const wxMemoryBuffer &data)

    { m_filesToSave.emplace_front(FileToSave(filename, data)); }


  wxRect GetUpdateRegion() const {return m_renderContext.GetUpdateRegion();}

  const std::list<FileToSave> &GetFilesToSave() const {return m_filesToSave;}

  void ClearFilesToSave () { m_filesToSave.clear();}

  void SetUpdateRegion(wxRect rect){m_renderContext.SetUpdateRegion(rect);}


  bool InUpdateRegion(wxRect rect) const;


  bool GetInsertAns() const

    { return m_insertAns; }


  void SetInsertAns(bool insertAns){ m_insertAns = insertAns; }


  bool GetOpenHCaret() const

    { return m_openHCaret; }


  void SetOpenHCaret(bool openHCaret){ m_openHCaret = openHCaret; }


  bool RestartOnReEvaluation() const

    { return m_restartOnReEvaluation; }


  void RestartOnReEvaluation(bool arg){ m_restartOnReEvaluation = arg; }


  wxSize GetCanvasSize() const

    { return m_renderContext.GetCanvasSize(); }


  void SetCanvasSize(wxSize siz)

    {

      if(GetCanvasSize().GetWidth() != siz.GetWidth() ||

         GetCanvasSize().GetHeight() != siz.GetHeight())

        RecalculateForce();

      m_renderContext.SetCanvasSize(siz);

    }


  bool RightToLeftDocument() const

    { return m_rightToLeftDocument; }


  bool RightToLeftDocument(bool rightToLeft)

    {

      if (m_rightToLeftDocument != rightToLeft)

        RecalculateForce();

      return m_rightToLeftDocument = rightToLeft;

    }


  bool ShowBrackets() const

    { return m_showBrackets; }


  bool ShowBrackets(bool show)

    {

      if(m_showBrackets != show)

        RecalculateForce();

      return m_showBrackets = show;

    }


  bool PrintBrackets() const

    { return m_printBrackets; }


  showLabels GetLabelChoice() const

    { return m_showLabelChoice; }


  bool ShowInputLabels() const {return m_showInputLabels;}

  void ShowInputLabels(bool show) {

    if(m_showInputLabels != show)

      RecalculateForce();

    m_showInputLabels = show;

  }


  enum class Appearance { light, dark, followSystem };

  Appearance GetAppearance() const { return m_appearance; }

  void SetAppearance(Appearance a) {

    m_appearance = a;

    m_styleStore.SetUseDark(UseDarkMode());

    UpdateBackgroundBrush();

  }

  void UpdateBackgroundBrush();

  bool UseDarkMode() const {

    if (m_appearance == Appearance::dark) return true;

    if (m_appearance == Appearance::light) return false;

    return SystemIsDark();

  }

  static bool SystemIsDark();


  long RecentItems(){return std::max(m_recentItems, static_cast<long>(0));}

  void RecentItems(long items){ m_recentItems = items; }


  bool ShowAutomaticLabels() const

    { return (m_showLabelChoice < labels_useronly); }


  bool UseUserLabels() const

    { return m_showLabelChoice > labels_automatic; }


  bool ShowLabels() const

    { return m_showLabelChoice < labels_none; }


  void SetLabelChoice(showLabels choice) {

    if(m_showLabelChoice != choice)

      RecalculateForce();

    m_showLabelChoice = choice;

  }


  bool PrintBrackets(bool print)

    {

      m_printBrackets = print;

      return print;

    }


  bool AutodetectMaxima() const {return m_autodetectMaxima;}

  void AutodetectMaxima(bool autodetectmaxima){m_autodetectMaxima = autodetectmaxima;}


  wxString MaximaParameters() const {return m_maximaParameters;}

  void MaximaParameters(wxString parameters){m_maximaParameters = std::move(parameters);}


  static wxString MaximaDefaultLocation();


  wxString MaximaLocation() const;


  wxString MaximaUserLocation() const {return m_maximaUserLocation;}


  void MaximaUserLocation(wxString maxima) { m_maximaUserLocation = std::move(maxima); }


  bool AutodetectHelpBrowser() const {return m_autodetectHelpBrowser;}

  void AutodetectHelpBrowser(bool autodetect){m_autodetectHelpBrowser = autodetect;}


  bool InternalHelpBrowser() const {return m_useInternalHelpBrowser && OfferInternalHelpBrowser();}

  void InternalHelpBrowser(bool useInternalHelpBrowser)

    {m_useInternalHelpBrowser = useInternalHelpBrowser;}


  bool SinglePageManual() const {return m_singlePageManual;}

  void SinglePageManual(bool singlePageManual)

    {m_singlePageManual = singlePageManual;}


  wxString HelpBrowserUserLocation() const {return m_helpBrowserUserLocation;}


  void HelpBrowserUserLocation(wxString helpBrowser) { m_helpBrowserUserLocation = std::move(helpBrowser);}


  static wxString FindProgram(const wxString &location);


  bool FixReorderedIndices() const

    { return m_fixReorderedIndices; }


  void FixReorderedIndices(bool fix) { m_fixReorderedIndices = fix;}


  wxString MathJaXURL() const {

    if(m_mathJaxURL_UseUser)

      return m_mathJaxURL;

    else

      return MathJaXURL_Auto();}

  wxString MathJaXURL_User() const { return m_mathJaxURL;}

  bool MathJaXURL_UseUser() const { return m_mathJaxURL_UseUser;}

  void MathJaXURL_UseUser(bool useUser){m_mathJaxURL_UseUser = useUser;}


  bool EnterEvaluates() const {return m_enterEvaluates;}

  void EnterEvaluates(bool enterEvaluates) {m_enterEvaluates = enterEvaluates;}

  static wxString MathJaXURL_Auto() { return wxS("https://cdn.jsdelivr.net/npm/mathjax@4/tex-mml-chtml.js");}

  void MathJaXURL(wxString url){m_mathJaxURL = std::move(url);}


  bool CopyBitmap() const {return m_copyBitmap;}

  void CopyBitmap(bool copyBitmap){ m_copyBitmap = copyBitmap; }


  bool CopyMathML() const {return m_copyMathML;}

  void CopyMathML(bool copyMathML){ m_copyMathML = copyMathML;}

  bool CopyMathMLHTML() const {return m_copyMathMLHTML;}

  void CopyMathMLHTML(bool copyMathMLHTML){ m_copyMathMLHTML = copyMathMLHTML; }

  bool HideMarkerForThisMessage(wxString message);

  void HideMarkerForThisMessage(const wxString &message, bool hide)

    {m_hideMarkerForThisMessage[message] = hide;}

  bool CopyRTF() const {return m_copyRTF;}

  void CopyRTF(bool copyRTF) { m_copyRTF = copyRTF; }

  bool CopySVG() const {return m_copySVG;}

  void CopySVG(bool copySVG) { m_copySVG = copySVG; }

  bool CopyEMF() const {return m_copyEMF;}

  void CopyEMF(bool copyEMF) { m_copyEMF = copyEMF; }

  bool UseSVG() const {return m_useSVG;}

  void UseSVG(bool useSVG) { m_useSVG = useSVG ;}

  void ShowLength(long length) {

    m_showLength = length;

  }

  long ShowLength() const {return m_showLength;}

  std::size_t ShowLength_Bytes() const;


  void SetParenthesisDrawMode(drawMode mode) {

    if(m_parenthesisDrawMode != mode)

      RecalculateForce();

    m_parenthesisDrawMode = mode;

  }


  void TocShowsSectionNumbers(bool showSectionNumbers) { m_TOCshowsSectionNumbers = showSectionNumbers; }


  bool TocShowsSectionNumbers() const {return m_TOCshowsSectionNumbers;}


  void UseUnicodeMaths(bool useunicodemaths)

    { m_useUnicodeMaths = useunicodemaths; }

  bool UseUnicodeMaths() const {return m_useUnicodeMaths;}


  const Style *GetStyle(TextStyle textStyle) const { return &m_styleStore[textStyle]; }

  Style *GetWritableStyle(TextStyle textStyle) { return &m_styleStore[textStyle]; }


  wxScrolledCanvas *GetWorkSheet() const {return m_workSheet;}

  void SetWorkSheet(wxScrolledCanvas *workSheet);


  DocumentCellPointers *GetDocumentCellPointers() const {return m_documentCellPointers;}

  void SetDocumentCellPointers(DocumentCellPointers *p) {m_documentCellPointers = p;}

  ViewCellPointers *GetViewCellPointers() const {return m_viewCellPointers;}

  void SetViewCellPointers(ViewCellPointers *p) {m_viewCellPointers = p;}


  void RequestRecalculate(GroupCell *group) const

    {if (m_recalculateRequest) m_recalculateRequest(group);}

  void SetRecalculateRequestCallback(std::function<void(GroupCell *)> callback)

    {m_recalculateRequest = std::move(callback);}


  void RequestRecalculateAll() const

    {if (m_recalculateAllRequest) m_recalculateAllRequest();}

  void SetRecalculateAllRequestCallback(std::function<void()> callback)

    {m_recalculateAllRequest = std::move(callback);}


  long DefaultPort() const {return m_defaultPort;}

  void DefaultPort(long port){m_defaultPort = port;}

  bool GetAbortOnError() const {return m_abortOnError;}

  void SetAbortOnError(bool abortOnError) {m_abortOnError = abortOnError;}


  long GetLanguage() const {return m_language;}

  void SetLanguage(long language) {m_language = language;}


  long MaxGnuplotMegabytes() const {return m_maxGnuplotMegabytes;}

  void MaxGnuplotMegabytes(long megaBytes)

    {m_maxGnuplotMegabytes = megaBytes;}


  bool OfferKnownAnswers() const {return m_offerKnownAnswers;}

  void OfferKnownAnswers(bool offerKnownAnswers)

    {m_offerKnownAnswers = offerKnownAnswers;}


  bool ScreenReaderAnnouncesMathML() const {return m_screenReaderAnnouncesMathML;}

  void ScreenReaderAnnouncesMathML(bool mathML)

    {m_screenReaderAnnouncesMathML = mathML;}


  wxString Documentclass() const {return m_documentclass;}

  void Documentclass(wxString clss){m_documentclass = std::move(clss);}

  wxString DocumentclassOptions() const {return m_documentclassOptions;}

  void DocumentclassOptions(wxString classOptions){m_documentclassOptions = std::move(classOptions);}


  htmlExportFormat HTMLequationFormat() const {return m_htmlEquationFormat;}

  void HTMLequationFormat(htmlExportFormat HTMLequationFormat)

    {m_htmlEquationFormat = HTMLequationFormat;}


  AFontSize GetDefaultFontSize() const        { return m_styleStore[TS_CODE_DEFAULT].GetFontSize(); }

  AFontSize GetMathFontSize() const           { return m_styleStore[TS_MATH].GetFontSize(); }


  long GetAutosubscript_Num() const {return m_autoSubscript;}

  void SetAutosubscript_Num(long autosubscriptnum) {m_autoSubscript = autosubscriptnum;}

  wxString GetAutosubscript_string() const;

  wxColor DefaultBackgroundColor();

  wxColor EditorBackgroundColor();

  bool ClipToDrawRegion() const {return m_renderContext.ClipToDrawRegion();}

  void ClipToDrawRegion(bool clipToDrawRegion){m_renderContext.ClipToDrawRegion(clipToDrawRegion);}

  void SetVisibleRegion(wxRect visibleRegion){

    if(m_renderContext.GetVisibleRegion().GetWidth() != visibleRegion.GetWidth())

      RecalculateForce();

    m_renderContext.SetVisibleRegion(visibleRegion);

  }

  wxRect GetVisibleRegion() const {return m_renderContext.GetVisibleRegion();}

  void SetWorksheetPosition(wxPoint worksheetPosition){m_renderContext.SetWorksheetPosition(worksheetPosition);}

  wxPoint GetWorksheetPosition() const {return m_renderContext.GetWorksheetPosition();}

  wxString MaximaShareDir() const {return m_maximaSession.ShareDir();}

  void MaximaShareDir(wxString dir){m_maximaSession.ShareDir(std::move(dir));}

  wxString MaximaDemoDir() const {return m_maximaSession.DemoDir();}

  void MaximaDemoDir(wxString dir){m_maximaSession.DemoDir(std::move(dir));}

  void InLispMode(bool lisp){m_maximaSession.InLispMode(lisp);}

  bool InLispMode() const {return m_maximaSession.InLispMode();}

  void BitmapScale(int factor){m_bitmapScale = factor;}

  int BitmapScale() const {return m_bitmapScale;}

  void DefaultPlotHeight(int px){m_defaultPlotHeight = px;}

  int DefaultPlotHeight() const {return m_defaultPlotHeight;}

  void DefaultPlotWidth(int px){m_defaultPlotWidth = px;}

  int DefaultPlotWidth() const {return m_defaultPlotWidth;}

  void DefaultFramerate(double fps){m_defaultFramerate = fps;}

  double DefaultFramerate() const {return m_defaultFramerate;}

  void TocDepth(int depth){m_tocDepth = depth;}

  int TocDepth() const {return m_tocDepth;}

  bool TeXExponentsAfterSubscript() const {return m_TeXExponentsAfterSubscript;}

  void TeXExponentsAfterSubscript(bool ExponentsAfterSubscript)

    {m_TeXExponentsAfterSubscript = ExponentsAfterSubscript;}

  bool UsePartialForDiff() const {return m_usePartialForDiff;}

  void UsePartialForDiff(bool usePartialForDiff)

    {m_usePartialForDiff = usePartialForDiff;}

  void RequestAdjustWorksheetSize() const

    {if (m_adjustWorksheetSizeRequest) m_adjustWorksheetSizeRequest();}

  void SetAdjustWorksheetSizeRequestCallback(std::function<void()> callback)

    {m_adjustWorksheetSizeRequest = std::move(callback);}

  void NotifyOfCellRedraw(const Cell *cell);

  void ClearAndEnableRedrawTracing();

  void ReportMultipleRedraws();

  bool OfferInternalHelpBrowser() const;

  bool WrapLatexMath() const {return m_wrapLatexMath;}

  void WrapLatexMath(bool wrapLatexMath){m_wrapLatexMath = wrapLatexMath;}

  bool AllowNetworkHelp() const {return m_allowNetworkHelp;}

  void AllowNetworkHelp(bool allowNetworkHelp){m_allowNetworkHelp = allowNetworkHelp;}

  bool ShowAllDigits() const {return m_showAllDigits;}

  void ShowAllDigits(bool shw){

    if(m_showAllDigits != shw)

      RecalculateForce();

    m_showAllDigits = shw;

  }

  bool LineBreaksInLongNums() const {return m_lineBreaksInLongNums;}

  void LineBreaksInLongNums(bool brk){

    if(m_lineBreaksInLongNums != brk)

      RecalculateForce();

    m_lineBreaksInLongNums = brk;

  }

  int  MaxClipbrdBitmapMegabytes() const {return m_maxClipbrd_BitmapMegabytes;}

  void MaxClipbrdBitmapMegabytes(int maxClipbrd_BitmapMegabytes)

    {m_maxClipbrd_BitmapMegabytes = maxClipbrd_BitmapMegabytes;}


  void MaximaUsesHtmlBrowser(bool maximaUsesHhtmlBrowser){m_maximaUsesHhtmlBrowser = maximaUsesHhtmlBrowser;}

  bool MaximaUsesHtmlBrowser() const {return m_maximaUsesHhtmlBrowser;}

  void MaximaUsesWxmaximaBrowser(bool maximaUsesWxmaximaBrowser){m_maximaUsesWxmaximaBrowser = maximaUsesWxmaximaBrowser;}

  bool MaximaUsesWxmaximaBrowser() const {return m_maximaUsesWxmaximaBrowser && OfferInternalHelpBrowser();}

  void ExportContainsWXMX(bool exportContainsWXMX){m_exportContainsWXMX = exportContainsWXMX;}

  bool ExportContainsWXMX() const {return m_exportContainsWXMX;}

  void WizardTab(long tab){m_wizardTab = tab;}

  long WizardTab() const {return m_wizardTab;}


  void Display2d_Unicode(bool unicode){m_display2d_Unicode = unicode;}

  bool Display2d_Unicode() const {return m_display2d_Unicode;}


  #ifdef __WXMSW__

  bool UseWGnuplot() const {return m_useWgnuplot;}

  void UseWGnuplot(bool usewgnuplot) {m_useWgnuplot = usewgnuplot;}

  #endif

  wxString TexPreamble() const {return m_texPreamble;}

  void TexPreamble(wxString texPreamble) {m_texPreamble = std::move(texPreamble);}


  void SetMaximaVersion(const wxString &version){m_maximaSession.SetMaximaVersion(version);}

  wxString GetMaximaVersion() const {return m_maximaSession.GetMaximaVersion();}

  void SetMaximaArch(const wxString &arch){m_maximaSession.SetMaximaArch(arch);}

  wxString GetMaximaArch() const {return m_maximaSession.GetMaximaArch();}

  void SetLispVersion(const wxString &version){m_maximaSession.SetLispVersion(version);}

  wxString GetLispVersion() const {return m_maximaSession.GetLispVersion();}

  void SetLispType(const wxString &type){m_maximaSession.SetLispType(type);}

  wxString GetLispType() const {return m_maximaSession.GetLispType();}


  void InitStyles();

  bool FontRendersChar(wxUniChar ch, const wxFont &font = *wxNORMAL_FONT)

    { return m_fontRenderability.FontRendersChar(ch, font); }


  const std::vector<TextStyle> &GetCodeStylesList() const {return m_styleStore.CodeStylesList();}

  const std::vector<TextStyle> &GetMathStylesList() const {return m_styleStore.MathStylesList();}

  const std::vector<TextStyle> &GetColorOnlyStylesList() const {return m_styleStore.ColorOnlyStylesList();}

  bool StyleAffectsCode(TextStyle style) const;

  bool StyleAffectsMathOut(TextStyle style) const;

  bool StyleAffectsColorOnly(TextStyle style) const;

  bool UpdateNeeded() const;

  static void SetDebugmode(){m_debugMode = true;}

  static bool GetDebugmode(){return m_debugMode;}

  maximaHelpFormat MaximaHelpFormat() const;

  void MaximaHelpFormat(maximaHelpFormat format) {m_maximaHelpFormat = format;}


private:

  MaximaSessionInfo m_maximaSession;

  InitOpt m_initOpts;

  long m_configId;

  std::random_device m_rd;

  std::default_random_engine m_eng;

  wxEnvVariableHashMap m_maximaEnvVars;

public:

  std::random_device::result_type RandomEntropy(){return m_rd();}

  std::default_random_engine &RandomEngine(){return m_eng;}

  std::int_fast32_t CellCfgCnt() const {return m_cellCfgCnt;}

  void RecalculateForce() {

    m_cellCfgCnt++;

    RequestRecalculateAll();

  }

  static bool UseThreads(){return m_use_threads;}

  static void UseThreads(bool use){m_use_threads = use;}

  static void SetMaximaLang(const wxString &LANG){m_maxima_LANG = LANG;}

  static wxString GetMaximaLang(){return m_maxima_LANG;}

private:

  static wxString m_maxima_LANG;

  std::list<FileToSave> m_filesToSave;

  Styles m_styleStore;

  StringBoolHash m_hideMarkerForThisMessage;

  FontRenderabilityCache m_fontRenderability;

  mathDisplayMode m_displayMode = display_2d;

  static bool m_debugMode;

  bool m_showInputLabels;

  long m_wizardTab;

  bool m_display2d_Unicode;

  bool m_usePartialForDiff;

  bool m_maximaUsesHhtmlBrowser;

  bool m_maximaUsesWxmaximaBrowser;

  bool m_autoSaveAsTempFile;

  long m_language;

  bool m_autodetectMaxima;

  bool m_autodetectHelpBrowser;

  bool m_useInternalHelpBrowser;

  bool m_singlePageManual;

  bool m_incrementalSearch;

  long m_autoSubscript;

  wxScrolledCanvas *m_workSheet = NULL;

  DocumentCellPointers *m_documentCellPointers = NULL;

  ViewCellPointers *m_viewCellPointers = NULL;

  std::function<void(GroupCell *)> m_recalculateRequest;

  std::function<void()> m_recalculateAllRequest;

  std::function<void()> m_adjustWorksheetSizeRequest;

  RenderContext m_renderContext;

  bool m_wrapLatexMath;

  bool m_allowNetworkHelp;

  bool m_exportContainsWXMX;

  wxString m_texPreamble;


  drawMode m_parenthesisDrawMode;

  bool m_TeXExponentsAfterSubscript;

  wxString m_helpBrowserUserLocation;

  wxString m_maximaUserLocation;

  bool m_hideBrackets;

  bool m_overlayScrollbars;

  double m_printScale;

  double m_printMargin_Top;

  double m_printMargin_Bot;

  double m_printMargin_Left;

  double m_printMargin_Right;

  bool m_rightToLeftDocument;

  bool m_showBrackets;

  bool m_printBrackets;

  bool m_changeAsterisk;

  bool m_notifyIfIdle;

  long m_displayedDigits;

  long m_autoWrap;

  bool m_autoIndent;

  bool m_showAllDigits;

  bool m_lineBreaksInLongNums;

  bool m_matchParens;

  bool m_insertAns;

  bool m_openHCaret;

  long m_labelWidth;

  long m_indent;

  bool m_latin2greek;

  double m_zoomFactor;

  bool m_outdated;

  wxString m_maximaParameters;

  bool m_keepPercent;

  bool m_restartOnReEvaluation;

  wxString m_fontCMRI, m_fontCMSY, m_fontCMEX, m_fontCMMI, m_fontCMTI;

  long m_lineWidth_em;

  showLabels m_showLabelChoice;

  bool m_fixReorderedIndices;

  wxString m_mathJaxURL;

  bool m_mathJaxURL_UseUser;

  bool m_showCodeCells;

  bool m_copyBitmap;

  bool m_copyMathML;

  bool m_copyMathMLHTML;

  long m_showLength;

  bool m_usepngCairo;

  bool m_enterEvaluates;

  bool m_useSVG;

  bool m_fixedFontTC;

  bool m_copyRTF;

  bool m_copySVG;

  bool m_copyEMF;

  bool m_TOCshowsSectionNumbers;

  bool m_useUnicodeMaths;

  bool m_indentMaths;

  bool m_abortOnError;

  bool m_showMatchingParens;

  bool m_hidemultiplicationsign;

  bool m_offerKnownAnswers;

  bool m_screenReaderAnnouncesMathML;

  long m_defaultPort;

  long m_maxGnuplotMegabytes;

  long m_defaultPlotHeight;

  long m_defaultPlotWidth;

  bool m_saveUntitled;

  bool m_cursorJump;

  bool m_numpadEnterEvaluates;

  bool m_saveImgFileName;

  wxString m_documentclass;

  wxString m_documentclassOptions;

  htmlExportFormat m_htmlEquationFormat;


  wxColour m_defaultBackgroundColor;

  wxBrush m_tooltipBrush;

  bool m_greekSidebar_ShowLatinLookalikes;

  #ifdef __WXMSW__

  bool m_useWgnuplot = false;

  #endif

  bool m_greekSidebar_Show_mu;

  wxString m_symbolPaneAdditionalChars;

  Appearance m_appearance = Appearance::followSystem;

  long m_recentItems;

  int m_bitmapScale;

  double m_defaultFramerate;

  int m_tocDepth;

  int m_maxClipbrd_BitmapMegabytes;

  int m_autoSaveMinutes;

  int m_maxLayoutTime;

  LayoutStrategy m_layoutStrategy = LayoutStrategy::layout2DIfFits;

  wxString m_wxMathML_Filename;

  maximaHelpFormat m_maximaHelpFormat;

  std::atomic<std::int_fast32_t> m_cellCfgCnt{0};

  static bool m_use_threads;

};


class Printing

{

public:

  explicit Printing(Configuration *configuration)

    {

      m_configuration = configuration;

      m_configuration->SetPrinting(true);

    }

  virtual ~Printing()

    {

      m_configuration->SetPrinting(false);

    }

private:

  Configuration * m_configuration;

};


class NoClipToDrawRegion

{

public:

  explicit NoClipToDrawRegion(Configuration *configuration)

    {

      m_configuration = configuration;

      m_configuration->ClipToDrawRegion(false);

    }

  virtual ~NoClipToDrawRegion()

    {

      m_configuration->ClipToDrawRegion(true);

    }

private:

  Configuration * m_configuration;

};


#endif // CONFIGURATION_H

FontRenderabilityCache.h
Declares FontRenderabilityCache: which chars can each font render?

LoggingMessageDialog.h
This file declares a message dialog that sends its contents to the log message sink.

MaximaSessionInfo.h
Declares MaximaSessionInfo: what we know about the connected Maxima.

RenderContext.h
Declares RenderContext: the per-render-pass state of a worksheet.

Styles.h
This file declares the class Styles.

TextStyle.h
This file declares everything needed for the text style system used to style all the elements on the ...

TextStyle
TextStyle
All text styles known to wxMaxima.
Definition: TextStyle.h:231

AFontSize
A Type-Safe Fixed-Point Font Size.
Definition: FontAttribs.h:97

Cell
The base class all cell types the worksheet can consist of are derived from.
Definition: Cell.h:142

Configuration::FileToSave
Stores the information about a file we need to write during the save process.
Definition: Configuration.h:744

Configuration::TextsnippetToDraw
Stores the information about a file we need to write during the save process.
Definition: Configuration.h:760

Configuration
The configuration storage for the current worksheet.
Definition: Configuration.h:98

Configuration::RecalculateForce
void RecalculateForce()
Force every cell to be recalculated on the next layout pass.
Definition: Configuration.h:1312

Configuration::GetRecalcDC
wxDC * GetRecalcDC() const
Get a drawing context suitable for size calculations.
Definition: Configuration.h:349

Configuration::Appearance
Appearance
How wxMaxima chooses between the light and the dark style set.
Definition: Configuration.h:869

Configuration::HelpBrowserUserLocation
wxString HelpBrowserUserLocation() const
Returns the location of the web browser the user has selected.
Definition: Configuration.h:956

Configuration::EditorBackgroundColor
wxColor EditorBackgroundColor()
Determine the default background color of editorcells.
Definition: Configuration.cpp:858

Configuration::GetAutosubscript_Num
long GetAutosubscript_Num() const
Get the worksheet this configuration storage is valid for.
Definition: Configuration.h:1139

Configuration::SetViewCellPointers
void SetViewCellPointers(ViewCellPointers *p)
Register the transient view-state half of the cell-pointer registry.
Definition: Configuration.h:1070

Configuration::ShowAutomaticLabels
bool ShowAutomaticLabels() const
Do we want to show maxima's automatic labels (o1, t1, i1,...)?
Definition: Configuration.h:892

Configuration::AutodetectHelpBrowser
void AutodetectHelpBrowser(bool autodetect)
Autodetect the web browser?
Definition: Configuration.h:941

Configuration::FontRendersChar
bool FontRendersChar(wxUniChar ch, const wxFont &font= *wxNORMAL_FONT)
True if we are confident that the font renders this char.
Definition: Configuration.h:1256

Configuration::MathJaXURL
void MathJaXURL(wxString url)
Returns the URL MathJaX can be found at.
Definition: Configuration.h:989

Configuration::GetInterEquationSkip
double GetInterEquationSkip() const
Extra space to leave between two equations in output cells.
Definition: Configuration.h:277

Configuration::GetDebugmode
static bool GetDebugmode()
Enable costly checks?
Definition: Configuration.h:1273

Configuration::GetChangeAsterisk
bool GetChangeAsterisk() const
Use Unicode centered dots for multiplication signs?
Definition: Configuration.h:685

Configuration::SetZoomFactor_temporarily
void SetZoomFactor_temporarily(double newzoom)
Sets the zoom factor without storing the new value in the config file/registry.
Definition: Configuration.h:331

Configuration::SystemIsDark
static bool SystemIsDark()
Whether the OS reports a dark appearance (false where wx cannot tell).
Definition: Configuration.cpp:491

Configuration::SetAutoWrap
void SetAutoWrap(long autoWrap)
Sets the auto wrap mode.
Definition: Configuration.h:547

Configuration::GetPPI
wxSize GetPPI() const
Get the resolution.
Definition: Configuration.cpp:212

Configuration::GetAutoWrap
bool GetAutoWrap() const
Do we want to have automatic line breaks for text cells?
Definition: Configuration.h:529

Configuration::ClearAndEnableRedrawTracing
void ClearAndEnableRedrawTracing()
Clear the memory of ReportMultipleRedraws()
Definition: Configuration.cpp:868

Configuration::ReportMultipleRedraws
void ReportMultipleRedraws()
Report if a cell has been redrawn 2 or more times during a simple Draw() command.
Definition: Configuration.cpp:874

Configuration::FindProgram
static wxString FindProgram(const wxString &location)
Could a maxima binary be found in the path we expect it to be in?
Definition: Configuration.cpp:542

Configuration::ScalarConfigSettings
static const std::vector< ScalarSetting > & ScalarConfigSettings()
The single source of truth pairing each mechanical scalar setting's config key with the member cachin...
Definition: Configuration.cpp:1198

Configuration::FontChanged
void FontChanged()
To be called if a font has changed.
Definition: Configuration.h:481

Configuration::GetMaxZoomFactor
static double GetMaxZoomFactor()
The upper limit we allow for the zoom factor.
Definition: Configuration.h:268

Configuration::GetTooltipBrush
wxBrush GetTooltipBrush() const
Get the brush to be used for worksheet objects that provide a mouse-over tooltip.
Definition: Configuration.h:243

Configuration::GetEscCode
static const wxString & GetEscCode(const wxString &key)
Retrieve a symbol for the escape codes that can be typed after hitting the Escape key in the workshee...
Definition: Configuration.cpp:499

Configuration::HideBrackets
bool HideBrackets() const
Hide brackets that are not under the pointer?
Definition: Configuration.h:292

Configuration::NotifyIfIdle
bool NotifyIfIdle() const
Notify the user if maxima is idle?
Definition: Configuration.h:722

Configuration::RequestRecalculateAll
void RequestRecalculateAll() const
Ask the view to schedule a recalculation of the WHOLE worksheet.
Definition: Configuration.h:1092

Configuration::EscCodesBegin
static EscCodeIterator EscCodesBegin()
Iterators over the escape code list.
Definition: Configuration.cpp:507

Configuration::SetPrinting
void SetPrinting(bool printing)
Are we currently printing?
Definition: Configuration.cpp:886

Configuration::MaximaDefaultLocation
static wxString MaximaDefaultLocation()
The auto-detected maxima location.
Definition: Configuration.cpp:983

Configuration::SetLabelChoice
void SetLabelChoice(showLabels choice)
Sets the value of the Configuration ChoiceBox that treads displaying labels.
Definition: Configuration.h:904

Configuration::InUpdateRegion
bool InUpdateRegion(wxRect rect) const
Whether any part of the given rectangle is within the current update region, or true if drawing is no...
Definition: Configuration.cpp:1136

Configuration::SetKeepPercent
void SetKeepPercent(bool keepPercent)
Do we want to display "%e" as "%e" and "%pi" as "%pi"?
Definition: Configuration.h:628

Configuration::SinglePageManual
bool SinglePageManual() const
Prefer the single-page manual?
Definition: Configuration.h:950

Configuration::ClearMaximaEnvVars
void ClearMaximaEnvVars()
Forget all custom environment variables for the maxima process.
Definition: Configuration.h:197

Configuration::WriteStyles
void WriteStyles(const wxString &file={})
Saves the style settings.
Definition: Configuration.cpp:1303

Configuration::GetMathStylesList
const std::vector< TextStyle > & GetMathStylesList() const
Which styles affect how math output is displayed?
Definition: Configuration.h:1262

Configuration::GetDocumentCellPointers
DocumentCellPointers * GetDocumentCellPointers() const
The registry of special cells (selection, active cell, errors, ...) of this document.
Definition: Configuration.h:1064

Configuration::DefaultBackgroundColor
wxColor DefaultBackgroundColor()
Determine the default background color of the worksheet.
Definition: Configuration.cpp:854

Configuration::UseDarkMode
bool UseDarkMode() const
Whether the dark style set is currently active.
Definition: Configuration.h:880

Configuration::MaximaUserLocation
wxString MaximaUserLocation() const
Returns the location of the maxima binary the user has selected.
Definition: Configuration.h:933

Configuration::GetWritableStyle
Style * GetWritableStyle(TextStyle textStyle)
Get the text Style for a given text style identifier.
Definition: Configuration.h:1045

Configuration::GetLabelWidth
wxCoord GetLabelWidth() const
Get the width of worksheet labels [in unscaled pixels].
Definition: Configuration.h:377

Configuration::WriteSettings
void WriteSettings(const wxString &file={})
Saves the settings to a file.
Definition: Configuration.cpp:1015

Configuration::DisplayMode
mathDisplayMode DisplayMode() const
Does maxima output 1D, 2D or 2D ASCII equations?
Definition: Configuration.h:202

Configuration::GetIndent
wxCoord GetIndent() const
Get the indentation of GroupCells.
Definition: Configuration.h:392

Configuration::CellCfgCnt
std::int_fast32_t CellCfgCnt() const
A counter that increases every time we need to recalculate all worksheet cells.
Definition: Configuration.h:1305

Configuration::ShowLabels
bool ShowLabels() const
Do we want at all to show labels?
Definition: Configuration.h:900

Configuration::MaximaParameters
wxString MaximaParameters() const
Parameters to the maxima binary.
Definition: Configuration.h:922

Configuration::GetCanvasSize
wxSize GetCanvasSize() const
Reads the size of the current worksheet's visible window. See SetCanvasSize.
Definition: Configuration.h:805

Configuration::InternalHelpBrowser
void InternalHelpBrowser(bool useInternalHelpBrowser)
Use the internal help browser? If not a external web browser is used.
Definition: Configuration.h:946

Configuration::GetZoomFactor
double GetZoomFactor() const
Determines the zoom factor the worksheet is displayed at.
Definition: Configuration.h:345

Configuration::LineWidth_em
long LineWidth_em() const
The minimum sensible line width in widths of a letter.
Definition: Configuration.h:496

Configuration::SinglePageManual
void SinglePageManual(bool singlePageManual)
Prefer the single-page manual?
Definition: Configuration.h:952

Configuration::IndentMaths
bool IndentMaths() const
Do we want to indent all maths?
Definition: Configuration.h:562

Configuration::MaximaLocation
wxString MaximaLocation() const
Returns the location of the maxima binary.
Definition: Configuration.cpp:976

Configuration::SetBackgroundBrush
void SetBackgroundBrush(const wxBrush &brush)
Set the brush to be used for the worksheet background.
Definition: Configuration.cpp:536

Configuration::StyleConfigKeys
static const std::vector< std::pair< TextStyle, wxString > > & StyleConfigKeys()
The single source of truth mapping each persisted text style to its config-key prefix.
Definition: Configuration.cpp:1296

Configuration::FixedFontInTextControls
bool FixedFontInTextControls() const
Use a typewriter font in wizard entry fields that can contain maxima commands?
Definition: Configuration.h:237

Configuration::GetAutoIndent
bool GetAutoIndent() const
Do we want automatic indentation?
Definition: Configuration.h:556

Configuration::LabelWidth
long LabelWidth() const
Get the width of worksheet labels [in chars].
Definition: Configuration.h:381

Configuration::SetRecalcContext
void SetRecalcContext(wxDC &dc)
Set the drawing context that is currently active.
Definition: Configuration.h:228

Configuration::PrintScale
double PrintScale() const
Hide brackets that are not under the pointer?
Definition: Configuration.h:312

Configuration::GetWorkingDirectory
wxString GetWorkingDirectory() const
Get maxima's working directory.
Definition: Configuration.h:211

Configuration::GetBaseIndent
long GetBaseIndent() const
The y position the worksheet starts at.
Definition: Configuration.h:426

Configuration::SetRecalculateAllRequestCallback
void SetRecalculateAllRequestCallback(std::function< void()> callback)
Set the callback RequestRecalculateAll() / RecalculateForce() notify through.
Definition: Configuration.h:1095

Configuration::DisplayMode
void DisplayMode(mathDisplayMode mode)
Tell the config if maxima outputs 1D, 2D or 2D ASCII equations, currently.
Definition: Configuration.h:204

Configuration::MaxGnuplotMegabytes
long MaxGnuplotMegabytes() const
The maximum number of Megabytes of gnuplot sources we should store.
Definition: Configuration.h:1107

Configuration::GetGroupSkip
long GetGroupSkip() const
The vertical space between GroupCells.
Definition: Configuration.h:435

Configuration::HelpBrowserUserLocation
void HelpBrowserUserLocation(wxString helpBrowser)
Sets the location of the web browser the user has detected.
Definition: Configuration.h:959

Configuration::SetWorkingDirectory
void SetWorkingDirectory(wxString dir)
Set maxima's working directory.
Definition: Configuration.h:207

Configuration::CheckKeepPercent
bool CheckKeepPercent() const
Do we want to display "%e" as "%e" and "%pi" as "%pi"?
Definition: Configuration.h:624

Configuration::GetCodeStylesList
const std::vector< TextStyle > & GetCodeStylesList() const
Which styles affect how code is displayed?
Definition: Configuration.h:1260

Configuration::CharsNeedingQuotes
static const wxString CharsNeedingQuotes()
Returns a list of chars we need to escape in maxima.
Definition: Configuration.h:362

Configuration::SetAppearance
void SetAppearance(Appearance a)
Choose the appearance and update which style set is active.
Definition: Configuration.h:872

Configuration::MathJaXURL
wxString MathJaXURL() const
Returns the URL MathJaX can be found at.
Definition: Configuration.h:976

Configuration::RightToLeftDocument
bool RightToLeftDocument() const
Does the document read right-to-left (Arabic, Hebrew, Persian, Urdu)?
Definition: Configuration.h:833

Configuration::UpdateBackgroundBrush
void UpdateBackgroundBrush()
Refresh the cached document-background brush from the active style set.
Definition: Configuration.cpp:531

Configuration::AutodetectMaxima
void AutodetectMaxima(bool autodetectmaxima)
Autodetect maxima's location?
Definition: Configuration.h:919

Configuration::SetChangeAsterisk
void SetChangeAsterisk(bool changeAsterisk)
Use Unicode centered dots for multiplication signs?
Definition: Configuration.h:688

Configuration::RandomEntropy
std::random_device::result_type RandomEntropy()
One sample of OS entropy (std::random_device).
Definition: Configuration.h:1295

Configuration::PrintScale
void PrintScale(double scale)
Define if we want to hide brackets that are not under the pointer.
Definition: Configuration.h:316

Configuration::InitStyles
void InitStyles()
Initialize the text styles on construction.
Definition: Configuration.cpp:484

Configuration::SetDebugmode
static void SetDebugmode()
Enable costly checks.
Definition: Configuration.h:1271

Configuration::GetMinZoomFactor
static double GetMinZoomFactor()
The lower limit we allow for the zoom factor.
Definition: Configuration.h:264

Configuration::AutodetectMaxima
bool AutodetectMaxima() const
Autodetect maxima's location? (If false the user-specified location is used)
Definition: Configuration.h:917

Configuration::GetWorkSheet
wxScrolledCanvas * GetWorkSheet() const
Get the worksheet canvas this configuration storage is valid for.
Definition: Configuration.h:1053

Configuration::ClipToDrawRegion
bool ClipToDrawRegion() const
Do we want to save time by only redrawing the area currently shown on the screen?
Definition: Configuration.h:1147

Configuration::SetZoomFactor
void SetZoomFactor(double newzoom)
Sets the zoom factor the worksheet is displayed at.
Definition: Configuration.cpp:930

Configuration::ShowBrackets
bool ShowBrackets() const
Show the cell brackets [displayed left to each group cell showing its extend]?
Definition: Configuration.h:844

Configuration::FixReorderedIndices
bool FixReorderedIndices() const
Renumber out-of-order cell labels on saving.
Definition: Configuration.h:970

Configuration::AddMaximaOperator
void AddMaximaOperator(const wxString &name)
Register name as an operator known to maxima.
Definition: Configuration.h:194

Configuration::GetPrinting
bool GetPrinting() const
Are we currently printing?
Definition: Configuration.h:669

Configuration::GetBackgroundBrush
wxBrush GetBackgroundBrush() const
Get the brush to be used for the worksheet background.
Definition: Configuration.h:241

Configuration::SetIndent
void SetIndent(long indent)
Set the indentation of GroupCells.
Definition: Configuration.h:447

Configuration::GetAutoWrapCode
bool GetAutoWrapCode() const
Do we want to have automatic line breaks for code cells?
Definition: Configuration.h:533

Configuration::GetLineWidth
long GetLineWidth() const
Returns the maximum sensible width for a text line [in characters]:
Definition: Configuration.cpp:895

Configuration::FixedFontInTextControls
void FixedFontInTextControls(bool fixed)
Use a typewriter font in wizard entry fields that can contain maxima commands?
Definition: Configuration.h:239

Configuration::EscCodesEnd
static EscCodeIterator EscCodesEnd()
Iterators over the escape code list.
Definition: Configuration.cpp:510

Configuration::RequestAdjustWorksheetSize
void RequestAdjustWorksheetSize() const
Ask the view (if any) to re-adjust its worksheet (scroll) size.
Definition: Configuration.h:1186

Configuration::GetCellBracketWidth
wxCoord GetCellBracketWidth() const
The width we allocate for our cell brackets.
Definition: Configuration.h:286

Configuration::MaximaUserLocation
void MaximaUserLocation(wxString maxima)
Sets the location of the maxima binary.
Definition: Configuration.h:936

Configuration::OfferInternalHelpBrowser
bool OfferInternalHelpBrowser() const
If we decide that the HTML browser in the sidebar doesn't work for every platform....
Definition: Configuration.cpp:1145

Configuration::OverlayScrollbars
bool OverlayScrollbars() const
Use GTK's overlay scrollbars on the worksheet?
Definition: Configuration.h:305

Configuration::ClipToDrawRegion
void ClipToDrawRegion(bool clipToDrawRegion)
Do we want to save time by only redrawing the area currently shown on the screen?
Definition: Configuration.h:1149

Configuration::GetColor
wxColour GetColor(TextStyle style)
Gets the color for a text style.
Definition: Configuration.cpp:1117

Configuration::GetCursorWidth
long GetCursorWidth() const
How much vertical space is to be left between two group cells?
Definition: Configuration.h:410

Configuration::m_configfileLocation_override
static wxString m_configfileLocation_override
Where to store the configuration.
Definition: Configuration.h:251

Configuration::LineWidth_em
void LineWidth_em(long width)
Set the minimum sensible line width in widths of a letter.
Definition: Configuration.h:508

Configuration::RandomEngine
std::default_random_engine & RandomEngine()
The pseudo-random engine, e.g. to feed a distribution.
Definition: Configuration.h:1297

Configuration::HideBrackets
void HideBrackets(bool hide)
Define if we want to hide brackets that are not under the pointer.
Definition: Configuration.h:296

Configuration::GetDefaultLineWidth
double GetDefaultLineWidth() const
Calculates the default line width for the worksheet.
Definition: Configuration.h:487

Configuration::GetViewCellPointers
ViewCellPointers * GetViewCellPointers() const
The transient view-state half of the cell-pointer registry (null if none).
Definition: Configuration.h:1068

Configuration::Scale_Px
wxCoord Scale_Px(double px) const
Scales a distance [in pixels] according to the zoom factor.
Definition: Configuration.cpp:1124

Configuration::ReadConfig
void ReadConfig()
Read the config from the wxConfig object.
Definition: Configuration.cpp:589

Configuration::SetRecalculateRequestCallback
void SetRecalculateRequestCallback(std::function< void(GroupCell *)> callback)
Set the callback RequestRecalculate() notifies the view through.
Definition: Configuration.h:1081

Configuration::InitOpt
InitOpt
Definition: Configuration.h:177

Configuration::temporary
@ temporary
This configuration is temporary and shouldn't redetect Maxima etc.
Definition: Configuration.h:179

Configuration::InternalHelpBrowser
bool InternalHelpBrowser() const
Use the internal help browser? If not a external web browser is used.
Definition: Configuration.h:944

Configuration::ScreenReaderAnnouncesMathML
bool ScreenReaderAnnouncesMathML() const
Announce maxima's output to screen readers as MathML?
Definition: Configuration.h:1121

Configuration::SetParenthesisDrawMode
void SetParenthesisDrawMode(drawMode mode)
Which way do we want to draw parenthesis?
Definition: Configuration.h:1019

Configuration::drawMode
drawMode
Definition: Configuration.h:171

Configuration::ascii
@ ascii
Use ascii characters only.
Definition: Configuration.h:172

Configuration::handdrawn
@ handdrawn
A parenthesis sign that was created using draw commands.
Definition: Configuration.h:173

Configuration::OverlayScrollbars
void OverlayScrollbars(bool overlay)
Define if the worksheet should use GTK's overlay scrollbars.
Definition: Configuration.h:309

Configuration::SetCanvasSize
void SetCanvasSize(wxSize siz)
Sets the size of the current worksheet's visible window.
Definition: Configuration.h:809

Configuration::MaximaParameters
void MaximaParameters(wxString parameters)
The parameters we pass to the maxima binary.
Definition: Configuration.h:924

Configuration::NotifyOfCellRedraw
void NotifyOfCellRedraw(const Cell *cell)
Record that this cell has been drawn to ReportMultipleRedraws()
Definition: Configuration.cpp:862

Configuration::ShowLength
long ShowLength() const
The choice for the "maximum output length to display" setting.
Definition: Configuration.h:1014

Configuration::ResetAllToDefaults
void ResetAllToDefaults()
Reset the whole configuration to its default values.
Definition: Configuration.cpp:234

Configuration::SetMaximaEnvVar
void SetMaximaEnvVar(const wxString &name, const wxString &value)
Set a custom environment variable for the maxima process.
Definition: Configuration.h:199

Configuration::ReadStyles
void ReadStyles(const wxString &file={})
Reads the style settings.
Definition: Configuration.cpp:987

Configuration::htmlExportFormat
htmlExportFormat
The export formats we support for HTML equations.
Definition: Configuration.h:145

Configuration::mathML_mathJaX
@ mathML_mathJaX
Native MathML, plus MathJaX downloaded as a fall-back only for the few browsers that still lack MathM...
Definition: Configuration.h:153

Configuration::mathJaX_TeX
@ mathJaX_TeX
Deprecated: the TeX-via-MathJaX HTML export was removed. The value is kept so saved configurations mi...
Definition: Configuration.h:149

Configuration::mathML
@ mathML
Native MathML with no MathJaX at all: the exported page makes no external requests....
Definition: Configuration.h:157

Configuration::SetAdjustWorksheetSizeRequestCallback
void SetAdjustWorksheetSizeRequestCallback(std::function< void()> callback)
Set the callback RequestAdjustWorksheetSize() notifies the view through.
Definition: Configuration.h:1189

Configuration::SetDocumentCellPointers
void SetDocumentCellPointers(DocumentCellPointers *p)
Register the document-model half of the cell-pointer registry.
Definition: Configuration.h:1066

Configuration::UseUserLabels
bool UseUserLabels() const
Do we want at all to show labels?
Definition: Configuration.h:896

Configuration::UpdateNeeded
bool UpdateNeeded() const
true means: The system's config storage has changed since the configuration has been read
Definition: Configuration.cpp:1161

Configuration::ShowLength_Bytes
std::size_t ShowLength_Bytes() const
The "maximum output length to display" setting in cells.
Definition: Configuration.cpp:1321

Configuration::GetDisplayedDigits
long GetDisplayedDigits() const
Returns the maximum number of displayed digits.
Definition: Configuration.h:731

Configuration::GetStyle
const Style * GetStyle(TextStyle textStyle) const
Get the text Style for a given text style identifier.
Definition: Configuration.h:1037

Configuration::AutodetectHelpBrowser
bool AutodetectHelpBrowser() const
Autodetect the web browser? (If false the user-specified location is used)
Definition: Configuration.h:939

Configuration::SetWorkSheet
void SetWorkSheet(wxScrolledCanvas *workSheet)
Set the worksheet canvas this configuration storage is valid for.
Definition: Configuration.cpp:203

Configuration::IsOperator
bool IsOperator(wxString name) const
Coincides name with a operator known to maxima?
Definition: Configuration.h:192

Configuration::ShowLength
void ShowLength(long length)
The choice for the "maximum output length to display" setting.
Definition: Configuration.h:1010

Configuration::LabelWidth
void LabelWidth(long labelWidth)
Set the width of worksheet labels [in chars].
Definition: Configuration.h:384

Configuration::RequestRecalculate
void RequestRecalculate(GroupCell *group) const
Ask the view (if any) to recalculate the layout starting at the given group cell.
Definition: Configuration.h:1078

Configuration::GetColorOnlyStylesList
const std::vector< TextStyle > & GetColorOnlyStylesList() const
Which styles affect only colors?
Definition: Configuration.h:1264

Configuration::PrintBrackets
bool PrintBrackets() const
Print the cell brackets [displayed left to each group cell showing its extend]?
Definition: Configuration.h:855

DocumentCellPointers
The document-model half of the cell-pointer registry.
Definition: CellPointers.h:50

FontRenderabilityCache
Caches which characters each font can actually render.
Definition: FontRenderabilityCache.h:65

FontRenderabilityCache::FontRendersChar
bool FontRendersChar(wxUniChar ch, const wxFont &font)
True if we are confident that the font renders this char.
Definition: FontRenderabilityCache.cpp:32

GroupCell
A cell grouping input (and, if there is one, also the output) cell to a foldable item.
Definition: GroupCell.h:88

MaximaSessionInfo
What we know about the Maxima instance we are talking to.
Definition: MaximaSessionInfo.h:48

MaximaSessionInfo::GetWorkingDirectory
wxString GetWorkingDirectory() const
Maxima's working directory.
Definition: MaximaSessionInfo.h:95

MaximaSessionInfo::InLispMode
bool InLispMode() const
Is maxima currently in lisp mode (where commands need no trailing ";")?
Definition: MaximaSessionInfo.h:108

MaximaSessionInfo::SetLispType
void SetLispType(const wxString &type)
Sets the type of the lisp the connected Maxima runs on.
Definition: MaximaSessionInfo.h:92

MaximaSessionInfo::SetMaximaArch
void SetMaximaArch(const wxString &arch)
Sets the processor architecture the connected Maxima runs on.
Definition: MaximaSessionInfo.h:84

MaximaSessionInfo::GetMaximaArch
wxString GetMaximaArch() const
The processor architecture the connected Maxima runs on.
Definition: MaximaSessionInfo.h:82

MaximaSessionInfo::GetLispVersion
wxString GetLispVersion() const
The version of the lisp the connected Maxima runs on.
Definition: MaximaSessionInfo.h:86

MaximaSessionInfo::DemoDir
wxString DemoDir() const
The directory maxima's demo files live in.
Definition: MaximaSessionInfo.h:103

MaximaSessionInfo::AddOperator
void AddOperator(const wxString &name)
Registers name as an operator known to maxima.
Definition: MaximaSessionInfo.h:75

MaximaSessionInfo::SetWorkingDirectory
void SetWorkingDirectory(wxString dir)
Sets maxima's working directory.
Definition: MaximaSessionInfo.h:97

MaximaSessionInfo::ShareDir
wxString ShareDir() const
The directory maxima's shared files (e.g. the manual) live in.
Definition: MaximaSessionInfo.h:99

MaximaSessionInfo::GetLispType
wxString GetLispType() const
The type of the lisp the connected Maxima runs on.
Definition: MaximaSessionInfo.h:90

MaximaSessionInfo::SetMaximaVersion
void SetMaximaVersion(const wxString &version)
Sets the version of the connected Maxima.
Definition: MaximaSessionInfo.h:80

MaximaSessionInfo::SetLispVersion
void SetLispVersion(const wxString &version)
Sets the version of the lisp the connected Maxima runs on.
Definition: MaximaSessionInfo.h:88

MaximaSessionInfo::GetMaximaVersion
wxString GetMaximaVersion() const
The version of the connected Maxima.
Definition: MaximaSessionInfo.h:78

MaximaSessionInfo::IsOperator
bool IsOperator(const wxString &name) const
Is this name an operator known to maxima?
Definition: MaximaSessionInfo.h:72

NoClipToDrawRegion
Clears the configuration's "Clip to draw region" flag until this class is left.
Definition: Configuration.h:1506

Printing
Sets the configuration's "printing" flag until this class is left.
Definition: Configuration.h:1489

RenderContext
The state of the current worksheet render pass.
Definition: RenderContext.h:60

RenderContext::SetRecalcDC
void SetRecalcDC(wxDC *dc)
Tells us which dc to measure text sizes on.
Definition: RenderContext.h:79

RenderContext::SetWorksheetPosition
void SetWorksheetPosition(wxPoint worksheetPosition)
Sets where the worksheet is to be drawn.
Definition: RenderContext.h:170

RenderContext::ClearLayoutCancelled
void ClearLayoutCancelled()
Stops the layout deadline and clears the cancelled flag.
Definition: RenderContext.h:187

RenderContext::GetUpdateRegion
wxRect GetUpdateRegion() const
The rectangle of the worksheet that is currently being redrawn.
Definition: RenderContext.h:105

RenderContext::SetVisibleRegion
void SetVisibleRegion(wxRect visibleRegion)
Sets the rectangle of the worksheet that is currently visible.
Definition: RenderContext.h:112

RenderContext::ClipToDrawRegion
bool ClipToDrawRegion() const
Do we want to omit drawing outside the current update region?
Definition: RenderContext.h:162

RenderContext::Printing
bool Printing() const
Are we currently rendering for the printer rather than the screen?
Definition: RenderContext.h:115

RenderContext::SetLayoutDeadline
void SetLayoutDeadline(int seconds)
Starts a layout deadline this many seconds in the future.
Definition: RenderContext.h:179

RenderContext::GetBackgroundBrush
wxBrush GetBackgroundBrush() const
The brush the worksheet's background is painted with.
Definition: RenderContext.h:174

RenderContext::SetCanvasSize
void SetCanvasSize(wxSize siz)
Sets the size of the worksheet's visible window.
Definition: RenderContext.h:102

RenderContext::IsLayoutCancelled
bool IsLayoutCancelled() const
Has the current layout pass exceeded its deadline?
Definition: RenderContext.h:193

RenderContext::GetRecalcDC
wxDC * GetRecalcDC() const
The dc "recalculate" (measuring text) currently draws to.
Definition: RenderContext.h:77

RenderContext::GetWorksheetPosition
wxPoint GetWorksheetPosition() const
Where is the worksheet to be drawn?
Definition: RenderContext.h:168

RenderContext::GetCanvasSize
wxSize GetCanvasSize() const
The size of the worksheet's visible window.
Definition: RenderContext.h:100

RenderContext::GetVisibleRegion
wxRect GetVisibleRegion() const
The rectangle of the worksheet that is currently visible.
Definition: RenderContext.h:110

RenderContext::SetUpdateRegion
void SetUpdateRegion(wxRect rect)
Sets the rectangle of the worksheet that is currently being redrawn.
Definition: RenderContext.h:107

Style
Text Style Definition.
Definition: TextStyle.h:63

Styles
Storage for the worksheet's per-TextStyle text styles.
Definition: Styles.h:42

Styles::ColorOnlyStylesList
const std::vector< TextStyle > & ColorOnlyStylesList() const
The styles where only the color is configurable.
Definition: Styles.h:107

Styles::MathStylesList
const std::vector< TextStyle > & MathStylesList() const
The styles that share the 2d-math font.
Definition: Styles.h:105

Styles::CodeStylesList
const std::vector< TextStyle > & CodeStylesList() const
The styles that share the code-default font/attributes.
Definition: Styles.h:103

Styles::SetUseDark
void SetUseDark(bool dark)
Select which set indexing/iteration return.
Definition: Styles.h:57

ViewCellPointers
The view/interaction half of the cell-pointer registry.
Definition: CellPointers.h:187

wxScrolled
Definition: CellPointers.h:32

Configuration::PerformanceStats
Definition: Configuration.h:100

Configuration::PerformanceStats::worksheetRepaints
std::atomic< long > worksheetRepaints
How often the worksheet was repainted (Worksheet::OnPaint ran)
Definition: Configuration.h:125

Configuration::PerformanceStats::cellsDrawnAtWrongFontSize
std::atomic< long > cellsDrawnAtWrongFontSize
How many cells were drawn at a different font size than they were laid out with.
Definition: Configuration.h:123

Configuration::PerformanceStats::worksheetFullRepaints
std::atomic< long > worksheetFullRepaints
How many of those repaints covered (nearly) the whole visible worksheet.
Definition: Configuration.h:133

Configuration::ScalarSetting
One mechanically persisted scalar setting: its config key and the member variable it is stored in.
Definition: Configuration.h:599

Configuration::ScalarSetting::key
const wxChar * key
The key the setting is stored under in the configuration store.
Definition: Configuration.h:601

Configuration::ScalarSetting::member
std::variant< bool Configuration::*, int Configuration::*, long Configuration::*, double Configuration::*, wxString Configuration::* > member
Which member of Configuration holds the setting's cached value.
Definition: Configuration.h:606