Configuration.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>
//
//  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 "LoggingMessageDialog.h"
#include "TextStyle.h"
#include <memory>
#include <unordered_map>
#include <vector>
 
#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 2
static constexpr AFontSize MC_MIN_SIZE{ 6.0f };
static constexpr AFontSize MC_MAX_SIZE{ 48.0f };
 
#define LIBERTINE1 "LinLibertine_DRah.ttf"
#define LIBERTINE2 "LinLibertine_I.ttf"
#define LIBERTINE3 "LinLibertine_Mah.ttf"
#define LIBERTINE4 "LinLibertine_Rah.ttf"
#define LIBERTINE5 "LinLibertine_RBah.ttf"
#define LIBERTINE6 "LinLibertine_RBIah.ttf"
#define LIBERTINE7 "LinLibertine_RIah.ttf"
#define LIBERTINE8 "LinLibertine_RZah.ttf"
#define LIBERTINE9 "LinLibertine_RZIah.ttf"
 
class Cell;
 
class Configuration
{
public:
  enum htmlExportFormat
  {
    mathJaX_TeX = 0,
    bitmap = 1,
    mathML_mathJaX = 2,
    svg = 3
  };
 
  enum showLabels : int8_t
  {
    labels_automatic = 0,
    labels_prefer_user = 1,
    labels_useronly = 2,
    labels_none = 3
  };
 
  enum drawMode
  {
    ascii,              
    assembled_unicode_fallbackfont,  
    assembled_unicode,  
    assembled_unicode_fallbackfont2,  
    handdrawn,           
    unknown
  };
 
  enum InitOpt
  {
    none,
    temporary,          
  };
 
  enum mathDisplayMode
  {
    display_2d,
    display_2dASCII,
    display_1dASCII
  };
 
  WX_DECLARE_STRING_HASH_MAP(int, StringHash);
  StringHash m_maximaOperators;
 
  const wxEnvVariableHashMap& MaximaEnvVars(){return m_maximaEnvVars;}
  wxEnvVariableHashMap m_maximaEnvVars;
 
  mathDisplayMode DisplayMode(){return m_displayMode;}
  void DisplayMode(mathDisplayMode mode ){m_displayMode = mode;}
 
  void SetWorkingDirectory(wxString dir)
  { m_workingdir = dir; }
 
  wxString GetWorkingDirectory() const
  { return m_workingdir; }
 
  void ReadConfig();
 
  explicit Configuration(wxDC *dc = {}, InitOpt options = {});
 
  void ResetAllToDefaults(InitOpt options = {});
 
  void SetContext(wxDC &dc)
  {
    m_dc = &dc;
    m_antialiassingDC = NULL;
  }
  void UnsetContext() {m_dc = NULL;}
 
  void SetBackgroundBrush(wxBrush brush);
  bool FixedFontInTextControls(){return m_fixedFontTC;}
  void FixedFontInTextControls(bool fixed){m_fixedFontTC = fixed;}
  wxBrush GetBackgroundBrush() const {return m_BackgroundBrush;}
  wxBrush GetTooltipBrush() const {return m_tooltipBrush;}
  void SetAntialiassingDC(wxDC &antialiassingDC)
    {m_antialiassingDC = &antialiassingDC;}
 
  void UnsetAntialiassingDC()
    {m_antialiassingDC = NULL;}
 
  ~Configuration();
 
  static wxString m_maximaLocation_override;
  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_styles[TS_MATH].GetFontSize() / 2;
  }
 
  long GetCellBracketWidth() const
  {
    return (int) (GetZoomFactor() * 16);
  }
 
  bool HideBrackets() const
  { return m_hideBrackets; }
 
  void HideBrackets(bool hide){m_hideBrackets = hide;}
 
  double PrintScale() const
  { return m_printScale; }
 
  void PrintScale(double scale){m_printScale = scale;}
 
  void SetZoomFactor(double newzoom);
 
  void SetZoomFactor_temporarily(double newzoom){
    m_zoomFactor = newzoom;
  }
 
  long Scale_Px(double px) const;
  AFontSize Scale_Px(AFontSize size) const;
 
  double GetZoomFactor() const
  { return m_zoomFactor; }
 
  wxDC *GetDC()
  { return m_dc; }
 
  wxDC *GetAntialiassingDC()
    {
      if ((m_antialiassingDC != NULL) && m_antiAliasLines)
        return m_antialiassingDC;
      else
        return m_dc;
    }
  
  AFontName GetFontName(TextStyle ts = TS_DEFAULT) const;
 
  // cppcheck-suppress functionStatic
  // cppcheck-suppress functionConst
  AFontName GetSymbolFontName() const;
 
  wxFontWeight IsBold(long st) const;
 
  wxFontStyle IsItalic(long st) const;
 
  bool IsUnderlined(long st) const {return m_styles[st].IsUnderlined();}
 
  long GetLabelWidth() const
  { return m_labelWidth * 14; }
 
  long LabelWidth() const
    { return m_labelWidth; }
  void LabelWidth(long labelWidth)
    { m_labelWidth = labelWidth; }
  
  long GetIndent() const
  {
    if (m_indent < 0)
      return 3 * GetCellBracketWidth() / 2;
    else
      return m_indent;
  }
 
  void SetPPI(wxSize ppi){m_ppi = ppi;}
  wxSize GetPPI() const;
  int AutosaveMinutes(){return m_autoSaveMinutes;}
  void AutosaveMinutes(int minutes){m_autoSaveMinutes = minutes;}
 
  long GetCursorWidth() const
  {
    long ppi;
 
    if(!m_printing)
      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)
  {
    m_indent = indent;
  }
 
  void SetClientWidth(long width)
  {
    m_clientWidth = width;
  }
 
  bool IncrementalSearch() const {return m_incrementalSearch;}
 
 
  void IncrementalSearch(bool incrementalSearch) { m_incrementalSearch = incrementalSearch; }
 
  struct CharsExist {
    wxString chars;
    bool exist;
    CharsExist(const wxString &chars, bool exist) : chars(chars), exist(exist) {}
  };
  std::vector<CharsExist> m_charsInFont;
 
  void FontChanged()
    {
      m_charsInFont.clear();
    }
  
  void SetClientHeight(long height)
  { m_clientHeight = height; }
 
  long GetClientWidth() const
  { return m_clientWidth; }
 
  long GetClientHeight() const
  { return m_clientHeight; }
 
  double GetDefaultLineWidth() const
  {
    if (GetZoomFactor() < 1.0)
      return 1.0;
    else
      return GetZoomFactor();
  }
 
  long LineWidth_em() const 
  {
    if(!m_printing)
      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(){ return m_saveUntitled;}
  void SaveUntitled(bool save){m_saveUntitled = save;}
 
  bool CursorJump(){ return m_cursorJump;}
  void CursorJump(bool save){m_cursorJump = save;}
 
  bool NumpadEnterEvaluates(){ return m_numpadEnterEvaluates;}
  void NumpadEnterEvaluates(bool eval){m_numpadEnterEvaluates = eval;}
 
  bool SaveImgFileName() { return m_saveImgFileName;}
  void SaveImgFileName(bool save) { m_saveImgFileName = save;}
 
  bool GetAutoWrap() const
  { return m_autoWrap > 0; }
 
  // cppcheck-suppress functionStatic
  bool GetAutoWrapCode() const
  { return false; }
 
  void SetAutoWrap(long autoWrap){m_autoWrap = autoWrap;}
 
  bool GetAutoIndent() const
  { return m_autoIndent; }
 
  void SetAutoIndent(bool autoIndent){m_autoIndent = autoIndent;}
 
  bool IndentMaths() const {return m_indentMaths;}
  void IndentMaths(bool indent){m_indentMaths=indent;}
  AFontSize GetFontSize(TextStyle st) const
  {
    if (st == TS_TEXT || st == TS_HEADING5 || st == TS_HEADING6 || st == TS_SUBSUBSECTION || st == TS_SUBSECTION || st == TS_SECTION || st == TS_TITLE)
      return m_styles[st].GetFontSize();
    return {};
  }
 
  const wxString &GetStyleName(TextStyle textStyle) const;
 
  void ReadStyles(const wxString &file = {});
  
  void WriteStyles(const wxString &file = {});
  void WriteStyles(wxConfigBase *config);
  void WriteSettings(const wxString &file = {});
  
  void Outdated(bool outdated)
  { m_outdated = outdated; }
 
  bool CheckTeXFonts() const
  { return m_TeXFonts; }
 
  void CheckTeXFonts(bool check)
  { m_TeXFonts = check; }
 
  bool CheckKeepPercent() const
  { return m_keepPercent; }
 
  void SetKeepPercent(bool keepPercent)
    { m_keepPercent = keepPercent; }
 
  AFontName GetTeXCMRI() const
  { return m_fontCMRI; }
 
  AFontName GetTeXCMSY() const
  { return m_fontCMSY; }
 
  AFontName GetTeXCMEX() const
  { return m_fontCMEX; }
 
  AFontName GetTeXCMMI() const
  { return m_fontCMMI; }
 
  AFontName GetTeXCMTI() const
  { return m_fontCMTI; }
 
  bool ShowCodeCells() const
  { return m_showCodeCells; }
 
  void ShowCodeCells(bool show);
 
  void SetPrinting(bool printing);
  
  bool GetPrinting() const
    { return m_printing; }
 
  wxColour GetColor(TextStyle style);
  
  wxColour InvertColour(wxColour col);
  
  wxColor MakeColorDifferFromBackground(wxColor color);
 
  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) {m_changeAsterisk = changeAsterisk;}
  
  bool HidemultiplicationSign() const {return m_hidemultiplicationsign;}
  
  void HidemultiplicationSign(bool show) {m_hidemultiplicationsign = show;}
  
  bool Latin2Greek() const
    {return m_latin2greek;}
  
  void Latin2Greek(bool latin2greek) {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 = 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!"));
      m_displayedDigits = displayedDigits;
    }
  
  wxRect GetUpdateRegion() const {return m_updateRegion;}
  void SetUpdateRegion(wxRect rect){m_updateRegion = 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_canvasSize; }
 
  void SetCanvasSize(wxSize siz)
    { m_canvasSize = siz; }
 
  bool ShowBrackets() const
    { return m_showBrackets; }
 
  bool ShowBrackets(bool show)
    { return m_showBrackets = show; }
 
  bool PrintBrackets() const
    { return m_printBrackets; }
 
  showLabels GetLabelChoice() const
    { return m_showLabelChoice; }
 
  bool InvertBackground(){return m_invertBackground;}
  void InvertBackground(bool invert){ m_invertBackground = invert; }
 
  long UndoLimit(){return wxMax(m_undoLimit, 0);}
  void UndoLimit(long limit){ m_undoLimit = limit; }
 
  long RecentItems(){return wxMax(m_recentItems, 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) { 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 = parameters;}
 
  static wxString MaximaDefaultLocation();
 
  wxString MaximaLocation() const;
 
  wxString MaximaUserLocation() const {return m_maximaUserLocation;}
 
  void OnMpBrowse(wxCommandEvent& event);
  
  void MaximaUserLocation(wxString maxima) { m_maximaUserLocation = maxima; }
 
  bool AutodetectHelpBrowser() const {return m_autodetectHelpBrowser;}
  void AutodetectHelpBrowser(bool autodetect){m_autodetectHelpBrowser = autodetect;}
 
  wxString HelpBrowserUserLocation() const {return m_helpBrowserUserLocation;}
 
  void HelpBrowserUserLocation(wxString helpBrowser) { m_helpBrowserUserLocation = helpBrowser;}
 
  static bool MaximaFound(wxString location = wxEmptyString);
 
  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 WxMathML_UseFile() const { return m_wxMathML_UseFile;}
  void WxMathML_UseFile(bool useFile){m_wxMathML_UseFile = useFile;}
  wxString WxMathML_Filename() const { return m_wxMathML_Filename;}
  void WxMathML_Filename(wxString name) { m_wxMathML_Filename = name;}
  bool EnterEvaluates() const {return m_enterEvaluates;}
  void EnterEvaluates(bool enterEvaluates) {m_enterEvaluates = enterEvaluates;}
  static wxString MathJaXURL_Auto() { return wxT("https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js");}
  void MathJaXURL(wxString url){m_mathJaxURL = url;}
  bool AntiAliasLines() const {return m_antiAliasLines;}
  void AntiAliasLines(bool antiAlias){ m_antiAliasLines = antiAlias; }
 
  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(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(){return m_useSVG;}
  void UseSVG(bool useSVG) { m_useSVG = useSVG ;}
  void ShowLength(long length) { m_showLength = length; }
  long ShowLength() const {return m_showLength;}
  void LispType(wxString type) { m_lispType = type; }
  wxString LispType() const {return m_lispType;}
  
  void SetParenthesisDrawMode(drawMode mode) { 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;}
  
  drawMode GetParenthesisDrawMode();
 
  WX_DECLARE_STRING_HASH_MAP(bool, StringBoolHash);
  StringBoolHash m_hideMarkerForThisMessage;
 
  Style GetStyle(TextStyle textStyle, AFontSize fontSize) const;
  
  wxWindow *GetWorkSheet() const {return m_workSheet;}
  inline void SetWorkSheet(wxWindow *workSheet);
 
  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;}
  
  wxString Documentclass() const {return m_documentclass;}
  void Documentclass(wxString clss){m_documentclass = clss;}
wxString DocumentclassOptions() const {return m_documentclassOptions;}
  void DocumentclassOptions(wxString classOptions){m_documentclassOptions = classOptions;}
 
  
  htmlExportFormat HTMLequationFormat() const {return m_htmlEquationFormat;}
  void HTMLequationFormat(htmlExportFormat HTMLequationFormat)
    {m_htmlEquationFormat = HTMLequationFormat;}
 
  AFontSize GetDefaultFontSize() const        { return m_styles[TS_DEFAULT].GetFontSize(); }
  AFontSize GetMathFontSize() const           { return m_styles[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_clipToDrawRegion;}
  void ClipToDrawRegion(bool clipToDrawRegion){m_clipToDrawRegion = clipToDrawRegion; m_forceUpdate = true;}
  void AdjustWorksheetSize(bool adjust)
    { m_adjustWorksheetSizeNeeded = adjust; }
  bool AdjustWorksheetSize() const
    { return m_adjustWorksheetSizeNeeded; }
  void SetVisibleRegion(wxRect visibleRegion){m_visibleRegion = visibleRegion;}
  wxRect GetVisibleRegion() const {return m_visibleRegion;}
  void SetWorksheetPosition(wxPoint worksheetPosition){m_worksheetPosition = worksheetPosition;}
  wxPoint GetWorksheetPosition() const {return m_worksheetPosition;}
  wxString MaximaShareDir() const {return m_maximaShareDir;}
  void MaximaShareDir(wxString dir){m_maximaShareDir = dir;}
  void InLispMode(bool lisp){m_inLispMode = lisp;}
  bool InLispMode() const {return m_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(int fps){m_defaultFramerate = fps;}
  int 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 NotifyOfCellRedraw(const Cell *cell);
  void ClearAndEnableRedrawTracing();
  void ReportMultipleRedraws();
 
  bool WrapLatexMath() const {return m_wrapLatexMath;}
  void WrapLatexMath(bool wrapLatexMath){m_wrapLatexMath = wrapLatexMath;}
  bool ShowAllDigits() const {return m_showAllDigits;}
  void ShowAllDigits(bool shw){m_showAllDigits = shw;}
  bool LineBreaksInLongNums() const {return m_lineBreaksInLongNums;}
  void LineBreaksInLongNums(bool brk){m_lineBreaksInLongNums = brk;}
  int  MaxClipbrdBitmapMegabytes() const {return m_maxClipbrd_BitmapMegabytes;}
  void MaxClipbrdBitmapMegabytes(int maxClipbrd_BitmapMegabytes)
    {m_maxClipbrd_BitmapMegabytes = maxClipbrd_BitmapMegabytes;}
  
  void ExportContainsWXMX(bool exportContainsWXMX){m_exportContainsWXMX = exportContainsWXMX;}
  bool ExportContainsWXMX() const {return m_exportContainsWXMX;}
  wxString TexPreamble() const {return m_texPreamble;}
  void TexPreamble(wxString texPreamble) {m_texPreamble = texPreamble;}
 
  Style m_styles[NUMBEROFSTYLES];
  void InitStyles();
private:
  wxSize m_ppi = wxSize(-1, -1);
  mathDisplayMode m_displayMode = display_2d;
  using CellRedrawTrace = std::vector<const Cell*>;
  bool m_usePartialForDiff;
  bool m_autoSaveAsTempFile;
  long m_language;
  bool m_autodetectMaxima;
  bool m_autodetectHelpBrowser;
  wxRect m_updateRegion;
  bool m_incrementalSearch;
  long m_autoSubscript;
  wxWindow *m_workSheet = NULL;
  bool CharsExistInFont(const wxFont &font, const wxString& chars);
  bool m_wrapLatexMath;
  bool m_exportContainsWXMX;
  wxString m_texPreamble;
 
  drawMode m_parenthesisDrawMode;
  wxString m_workingdir;
  bool m_TeXExponentsAfterSubscript;
  wxString m_helpBrowserUserLocation;
  wxString m_maximaUserLocation;
  bool m_hideBrackets;
  double m_printScale;
  wxSize m_canvasSize;
  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;
  bool m_antiAliasLines;
  double m_zoomFactor;
  wxDC *m_dc;
  wxDC *m_antialiassingDC;
  wxString m_maximaShareDir;
  bool m_forceUpdate;
  bool m_clipToDrawRegion;
  bool m_outdated;
  wxString m_maximaParameters;
  bool m_TeXFonts;
  bool m_keepPercent;
  bool m_restartOnReEvaluation;
  AFontName m_fontCMRI, m_fontCMSY, m_fontCMEX, m_fontCMMI, m_fontCMTI;
  long m_clientWidth;
  long m_clientHeight;
  bool m_printing;
  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_inLispMode;
  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;
  long m_defaultPort;
  long m_maxGnuplotMegabytes;
  long m_defaultPlotHeight;
  long m_defaultPlotWidth;
  bool m_saveUntitled;
  bool m_cursorJump;
  bool m_numpadEnterEvaluates;
  bool m_saveImgFileName;
  std::unique_ptr<CellRedrawTrace> m_cellRedrawTrace;
  wxString m_documentclass;
  wxString m_documentclassOptions;
  htmlExportFormat m_htmlEquationFormat;
  bool m_adjustWorksheetSizeNeeded;
  wxRect m_visibleRegion;
  wxPoint m_worksheetPosition;
 
  wxColour m_defaultBackgroundColor;
  wxBrush m_BackgroundBrush;
  wxBrush m_tooltipBrush;
  bool m_greekSidebar_ShowLatinLookalikes;
  bool m_greekSidebar_Show_mu;
  wxString m_symbolPaneAdditionalChars;
  bool m_invertBackground;
  long m_undoLimit;
  long m_recentItems;
  wxString m_lispType;
  int m_bitmapScale;
  int m_defaultFramerate;
  int m_tocDepth;
  int m_maxClipbrd_BitmapMegabytes;
  int m_autoSaveMinutes;
  wxString m_wxMathML_Filename;
  bool m_wxMathML_UseFile;
};
 
class Printing
{
public:
  explicit Printing(Configuration *configuration)
    {
      m_configuration = configuration;
      m_configuration->SetPrinting(true);
      m_configuration->ClipToDrawRegion(false);
    }
  ~Printing()
    {
      m_configuration->SetPrinting(false);
      m_configuration->ClipToDrawRegion(true);
    }
private:
  Configuration * m_configuration;
};
 
class NoClipToDrawRegion
{
public:
  explicit NoClipToDrawRegion(Configuration *configuration)
    {
      m_configuration = configuration;
      m_configuration->ClipToDrawRegion(false);
    }
  ~NoClipToDrawRegion()
    {
      m_configuration->ClipToDrawRegion(true);
    }
private:
  Configuration * m_configuration;
};
 
#endif // CONFIGURATION_H