wxMaxima.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//  Copyright (C) 2004-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//            (C) 2013 Doug Ilijev <doug.ilijev@gmail.com>
//            (C) 2014-2018 Gunter Königsmann <wxMaxima@physikbuch.de>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef WXMAXIMA_H
#define WXMAXIMA_H
 
#include <vector>
#include "wxMaximaFrame.h"
#include "WXMXformat.h"
#include "Configuration.h"
#include "MathParser.h"
#include "MaximaIPC.h"
#include "Dirstructure.h"
#include <wx/socket.h>
#include <wx/config.h>
#include <wx/process.h>
#include <wx/regex.h>
#include <wx/dnd.h>
#include <wx/txtstrm.h>
#include <wx/sckstrm.h>
#include <wx/buffer.h>
#include <wx/power.h>
#ifdef USE_QA
#include <wx/debugrpt.h>
#endif
#include <memory>
#ifdef __WXMSW__
#include <windows.h>
#endif
#include <unordered_map>
 
#define MAXIMAPOLLMSECS 2000
 
class Maxima; // The Maxima process interface
 
/* The top-level window and the main application logic
 
 */
class wxMaxima : public wxMaximaFrame
{
public:
  wxMaxima(wxWindow *parent, int id, const wxString &title,
           const wxString &filename = wxEmptyString,
           const wxString &initialWorksheetContents = wxEmptyString,
           const wxPoint pos = wxDefaultPosition, const wxSize size = wxDefaultSize);
 
  virtual ~wxMaxima();
  wxString EscapeFilenameForShell(wxString name);
  static void ExitOnError(){m_exitOnError = true;}
  static bool GetExitOnError(){return m_exitOnError;}
  static void EnableIPC(){ MaximaIPC::EnableIPC(); }
  static bool GetEnableIPC(){ return MaximaIPC::GetEnableIPC(); }
  static void ExtraMaximaArgs(const wxString &args){m_extraMaximaArgs = args;}
  static wxString ExtraMaximaArgs(){return m_extraMaximaArgs;}
 
  enum TimerIDs
  {
    KEYBOARD_INACTIVITY_TIMER_ID,
    AUTO_SAVE_TIMER_ID,
    MAXIMA_STDOUT_POLL_ID
  };
 
#ifdef wxHAS_POWER_EVENTS
  void OnPowerEvent(wxPowerEvent &event);
#endif
 
  void OnTimerEvent(wxTimerEvent &event);
 
  wxTimer m_maximaStdoutPollTimer;
 
  void ShowTip(bool force);
  void EvalOnStartup(bool eval)
    {
      m_evalOnStartup = eval;
    }
 
  void ExitAfterEval(bool exitaftereval);
 
  void StripLispComments(wxString &s);
 
  void LaunchHelpBrowser(wxString uri);
 
  void SendMaxima(wxString s, bool addToHistory = false, bool background = false);
 
  bool OpenFile(const wxString &file, const wxString &command ={});
 
  bool DocumentSaved()
    { return m_fileSaved; }
 
  void LoadImage(const wxString &file)
    { GetWorksheet()->OpenHCaret(file, GC_TYPE_IMAGE); }
 
  bool QueryVariableValue();
 
  class VersionNumber
  {
  public:
    explicit VersionNumber(const wxString &version);
    long Major() const {return m_major;}
    long Minor() const {return m_minor;}
    long Patchlevel() const {return m_patchlevel;}
    auto operator<=>(const VersionNumber&) const = default;
  private:
    long m_major = -1;
    long m_minor = -1;
    long m_patchlevel = -1;
  };
 
  static void Set_Maxima_Commandline_Filename(const wxString &filename)
    {maxima_command_line_filename = filename;}
  static const wxString Get_Maxima_Commandline_Filename() {return maxima_command_line_filename;}
 
  static int GetExitCode(){return m_exitCode;}
 
private:
  static wxString maxima_command_line_filename;
  bool m_maximaAuthenticated = false;
  bool m_discardAllData = false;
  wxString m_maximaAuthString;
  MaximaIPC m_ipc{this};
  static bool m_exitOnError;
  static wxString m_extraMaximaArgs;
  std::vector<wxString> m_varNamesToQuery;
 
  bool m_openInitialFileError = false;
  wxString EscapeForLisp(wxString str);
  long long m_maximaJiffies_old = 0;
  long long m_cpuTotalJiffies_old = 0;
  wxString m_configCommands;
  static wxRegEx m_gnuplotErrorRegex;
  bool AbortOnError();
  wxString m_oldFindString;
  int m_oldFindFlags = 0;
  bool m_hasEvaluatedCells = false;
  long m_outputCellsFromCurrentCommand = 0;
  long m_maxOutputCellsPerCommand = 0;
  int m_unsuccessfulConnectionAttempts = 11;
  wxString m_CWD;
  bool m_evalOnStartup = false;
  bool m_exitAfterEval = false;
  bool m_ready = false;
 
  wxString GetUnmatchedParenthesisState(wxString text, std::size_t &index);
  wxMemoryBuffer m_uncompletedChars;
 
protected:
  void CommandWiz(const wxString &title,
                  const wxString &description, const wxString &description_tooltip,
                  const wxString &commandRule,
                  wxString label1, wxString defaultval1, wxString tooltip1 = {},
                  wxString label2 = {}, wxString defaultval2 = {}, wxString tooltip2 = {},
                  wxString label3 = {}, wxString defaultval3 = {}, wxString tooltip3 = {},
                  wxString label4 = {}, wxString defaultval4 = {}, wxString tooltip4 = {},
                  wxString label5 = {}, wxString defaultval5 = {}, wxString tooltip5 = {},
                  wxString label6 = {}, wxString defaultval6 = {}, wxString tooltip6 = {},
                  wxString label7 = {}, wxString defaultval7 = {}, wxString tooltip7 = {},
                  wxString label8 = {}, wxString defaultval8 = {}, wxString tooltip8 = {},
                  wxString label9 = {}, wxString defaultval9 = {}, wxString tooltip9 = {},
                  wxString label10 = {}, wxString defaultval10 = {}, wxString tooltip10 = {}
    );
  wxString ReadPotentiallyUnclosedTag(wxStringTokenizer &lines, wxString firstLine);
 
  static wxRegEx m_xmlOpeningTagName;
  static wxRegEx m_xmlOpeningTag;
  wxProcess *m_gnuplotProcess = NULL;
  wxProcess *m_gnuplotTerminalQueryProcess = NULL;
  bool m_isActive = true;
  void OnFocus(wxFocusEvent &event);
 
  void PassKeyboardFocus();
  void OnMinimize(wxIconizeEvent &event);
  void ConfigChanged();
  void OnJumpToError(wxCommandEvent &event);
  void OnSymbolAdd(wxCommandEvent &event);
  void OnFollow(wxCommandEvent &event);
  void OnWizardAbort(wxCommandEvent &event);
  void OnWizardOK(wxCommandEvent &event);
  void OnWizardInsert(wxCommandEvent &event);
  void OnWizardHelpButton(wxCommandEvent &event);
 
  void ShowMaximaHelp(wxString = {});
 
  void ShowMaximaHelpWithoutAnchor();
 
  void ShowWxMaximaHelp();
 
  void ShowHelp(const wxString &keyword);
 
  void CheckForUpdates(bool reportUpToDate = false);
 
  void OnRecentDocument(wxCommandEvent &event);
  void OnRecentPackage (wxCommandEvent &event);
  void OnUnsavedDocument(wxCommandEvent &event);
 
  void OnChar(wxKeyEvent &event);
  void OnKeyDown(wxKeyEvent &event);
 
  void OnIdle(wxIdleEvent &event);
  bool m_dataFromMaximaIs = false;
 
  void MenuCommand(const wxString &cmd);           
  void FileMenu(wxCommandEvent &event);            
  void MaximaMenu(wxCommandEvent &event);          
  void MatrixMenu(wxCommandEvent &event);         
  void PropertiesMenu(wxCommandEvent &event);         
  void EquationsMenu(wxCommandEvent &event);       
  void CalculusMenu(wxCommandEvent &event);        
  void SimplifyMenu(wxCommandEvent &event);        
  void PlotMenu(wxCommandEvent &event);            
  void ListMenu(wxCommandEvent &event);            
  void DrawMenu(wxCommandEvent &event);            
  void NumericalMenu(wxCommandEvent &event);       
  void HelpMenu(wxCommandEvent &event);            
  void EditMenu(wxCommandEvent &event);            
  void ReplaceSuggestion(wxCommandEvent &event);   
  void Interrupt(wxCommandEvent &event);           
  void UpdateMenus();        
  void UpdateToolBar();      
  void UpdateSlider();       
  void ShowPane(wxCommandEvent &event);            //<! Makes a sidebar visible
  void OnMaximaClose(wxProcessEvent &event);      //
  void OnMaximaClose();      //
  void OnGnuplotClose(wxProcessEvent &event);      //
  void OnGnuplotQueryTerminals(wxProcessEvent &event);      //
  void PopupMenu(wxCommandEvent &event);           //
  void StatsMenu(wxCommandEvent &event);           //
 
  void ChangeCellStyle(wxCommandEvent &event);
 
  void OnFind(wxFindDialogEvent &event);
 
  void OnReplace(wxFindDialogEvent &event);
 
  void OnReplaceAll(wxFindDialogEvent &event);
 
  void OnMaximaConnect();
 
  void MaximaEvent(wxThreadEvent &event);
 
  void ServerEvent(wxSocketEvent &event);
 
  void AddDrawParameter(wxString cmd, int dimensionsOfNewDrawCommand = 2);
 
  /* Append something to the console. Might be Text or XML maths.
 
     \return A pointer to the last line of Unicode text that was appended or
     NULL, if there is no such line (for example if the appended object is
     maths instead).
  */
  TextCell *ConsoleAppend(wxString s, CellType type);        
  void ConsoleAppend(wxXmlDocument xml, CellType type, const wxString &userLabel = {});        
 
  enum AppendOpt { NewLine = 1, BigSkip = 2, PromptToolTip = 4, DefaultOpt = NewLine|BigSkip };
  void DoConsoleAppend(wxString s, CellType type, AppendOpt opts = AppendOpt::DefaultOpt,
                       const wxString &userLabel = {});
 
  TextCell *DoRawConsoleAppend(wxString s, CellType  type, AppendOpt opts = {});
 
  void EditInputMenu(wxCommandEvent &event);
  void VarReadEvent(wxCommandEvent &event);
  void VarAddAllEvent(wxCommandEvent &event);
  void EvaluateEvent(wxCommandEvent &event);       //
  void InsertMenu(wxCommandEvent &event);          //
  void PrintMenu(wxCommandEvent &event);
 
  void SliderEvent(wxScrollEvent &event);
 
  void NetworkDClick(wxCommandEvent &ev);
  void MaximaDClick(wxCommandEvent &ev);
  void StatusMsgDClick(wxCommandEvent &ev);
 
  void HistoryDClick(wxCommandEvent &event);
 
  void TableOfContentsSelection(wxListEvent &event);
 
  void OnInspectorEvent(wxCommandEvent &ev);
 
  void DumpProcessOutput();
 
  void TriggerEvaluation();
 
  void TryUpdateInspector();
 
  bool UpdateDrawPane();
 
  wxString ExtractFirstExpression(const wxString &entry);
 
  wxString GetDefaultEntry();
 
  bool StartServer();
  bool StartMaxima(bool force = false);
 
  void OnClose(wxCloseEvent &event);               
  wxString GetCommand(bool params = true);         
  //    (uses guessConfiguration)
 
  void ReadStdErr();
 
  void ReadFirstPrompt(const wxString &data);
 
  void ReadMiscText(const wxString &data);
 
  void ReadPrompt(const wxString &data);
 
  void ReadStatusBar(const wxXmlDocument &xmldoc);
  void ReadManualTopicNames(const wxXmlDocument &xmldoc);
 
  void ReadMath(const wxXmlDocument &xml);
 
  void ReadMaximaIPC(const wxString &data){m_ipc.ReadInputData(data);}
  void ReadLoadSymbols(const wxXmlDocument &data);
 
  void ReadSuppressedOutput(const wxString &data);
 
  void ReadVariables(const wxXmlDocument &xmldoc);
 
  void ReadAddVariables(const wxXmlDocument &xmldoc);
  void VariableActionGentranlang(const wxString &value);
  void VariableActionNumer(const wxString &value);
  void VariableActionDisplay2d_Unicode(const wxString &value);
  void VariableActionHtmlHelp(const wxString &value);
  void VariableActionOpSubst(const wxString &value);
  void VariableActionSinnpiflag(const wxString &value);
  void VariableActionSinnpiflagUndefined();
  void VariableActionLogexpand(const wxString &value);
  void VariableActionUserDir(const wxString &value);
  void VariableActionTempDir(const wxString &value);
  void VariableActionDebugmode(const wxString &value);
  void VariableActionAutoconfVersion(const wxString &value);
  void VariableActionAutoconfHost(const wxString &value);
  void VariableActionMaximaInfodir(const wxString &value);
  void VariableActionMaximaHtmldir(const wxString &value);
  void VariableActionGnuplotCommand(const wxString &value);
  void VariableActionMaximaSharedir(const wxString &value);
  void VariableActionMaximaDemodir(const wxString &value);
  void VariableActionLispName(const wxString &value);
  void VariableActionLispVersion(const wxString &value);
  void VariableActionWxLoadFileName(const wxString &value);
  void VariableActionWxSubscripts(const wxString &value);
  void VariableActionLmxChar(const wxString &value);
  void VariableActionDisplay2D(const wxString &value);
  void VariableActionAltDisplay2D(const wxString &value);
  void VariableActionAlgebraic(const wxString &value);
  void VariableActionShowtime(const wxString &value);
  void VariableActionDomain(const wxString &value);
  void VariableActionAutoplay(const wxString &value);
  void VariableActionEngineeringFormat(const wxString &value);
  void VariableActionStringdisp(const wxString &value);
  void VariableActionOperators(const wxString &value);
  wxString m_maximaVariable_wxSubscripts;
  wxString m_maximaVariable_lmxchar;
  wxString m_maximaVariable_display2d;
  wxString m_maximaVariable_altdisplay2d;
  wxString m_maximaVariable_engineeringFormat;
  bool m_readMaximaVariables = false;
  bool m_updateAutocompletion = true;
  long long GetTotalCpuTime();
 
  long long GetMaximaCpuTime();
 
  double GetMaximaCPUPercentage();
 
  bool SaveNecessary();
 
  void SetupVariables();
 
  void KillMaxima(bool logMessage = true);                 
  void ResetTitle(bool saved, bool force = false);
 
  void FirstOutput();
 
  bool OpenXML(const wxString &file, Worksheet *document);
 
  bool CheckWXMXVersion(const wxString &docversion);
 
  bool OpenMACFile(const wxString &file, Worksheet *document, bool clearDocument = true);
 
  bool OpenWXMFile(const wxString &file, Worksheet *document, bool clearDocument = true);
 
  bool OpenWXMXFile(const wxString &file, Worksheet *document, bool clearDocument = true);
 
  std::unique_ptr<GroupCell> CreateTreeFromXMLNode(wxXmlNode *xmlcells, const wxString &wxmxfilename = {});
 
  bool SaveFile(bool forceSave = false);
 
  bool SaveOnClose();
  bool AutoSave();
 
  int SaveDocumentP();
 
  void SetCWD(wxString file);
 
  wxString GetCWD()
    {
      return m_CWD;
    }
 
  std::unique_ptr<Maxima> m_client;
  struct ServerDeleter {
    void operator()(wxSocketServer* server) const {
      server->Destroy(); // Destroy() calls Close() automatically.
    }
  };
  std::unique_ptr<wxSocketServer,  ServerDeleter> m_server;
 
  wxProcess *m_maximaProcess = NULL;
  wxInputStream *m_maximaStdout = NULL;
  wxInputStream *m_maximaStderr = NULL;
  int m_port = -1;
  static wxString m_mathPrefix1;
  static wxString m_mathPrefix2;
  static wxString m_promptPrefix;
public:
  const static wxString m_promptSuffix;
protected:
  bool m_scheduleUpdateToc = false;
  void QuestionAnswered(){if(GetWorksheet()) GetWorksheet()->QuestionAnswered();}
  void OnNewDemoFiles(wxCommandEvent &event);
  void OnDemoFileMenu(wxCommandEvent &ev);
 
  void OnUpdateTOCEvent(wxCommandEvent &event);
 
  void OnSize(wxSizeEvent &event);
  void OnMove(wxMoveEvent &event);
  void OnMaximize(wxCommandEvent &event);
 
  void GnuplotCommandName(wxString gnuplot);
  static wxString m_firstPrompt;
  bool m_dispReadOut = false;               
  wxWindowIDRef m_gnuplot_process_id;
  wxWindowIDRef m_maxima_process_id;
  wxString m_lastPrompt;
  wxString m_firstPromptBuffer;
  wxString m_lastPath;
  std::unique_ptr<wxPrintData> m_printData;
  bool m_closing = false;
  wxString m_maximaTempDir;
  wxString m_maximaHtmlDir;
  bool m_fileSaved = true;
  static int m_exitCode;
  wxString m_gnuplotcommand;
#ifdef __WINDOWS__
  // For Windows, store "gnuplot.exe", even if wgnuplot.exe is preferred.
  // We query the terminals using: gnuplot -e "print GPVAL_TERMINALS"
  // and that does only work with gnuplot, not wgnuplot.
  wxString m_gnuplotcommand_commandline;
#endif
  long m_commandIndex = -1;
  FindReplacePane::FindReplaceData m_findData;
  static wxRegEx m_funRegEx;
  static wxRegEx m_varRegEx;
  static wxRegEx m_blankStatementRegEx;
  static wxRegEx m_sbclCompilationRegEx;
  MathParser m_parser;
  bool m_maximaBusy = true;
  bool m_maximaError = false;
private:
  bool m_fourierLoaded = false;
  wxString m_logexpand;
  typedef void (wxMaxima::*VarReadFunction)(const wxString &value);
  typedef void (wxMaxima::*VarUndefinedFunction)();
  typedef std::unordered_map <wxString, VarReadFunction, wxStringHash> VarReadFunctionHash;
  typedef std::unordered_map <wxString, VarUndefinedFunction,
                              wxStringHash> VarUndefinedFunctionHash;
  static VarReadFunctionHash m_variableReadActions;
  static VarUndefinedFunctionHash m_variableUndefinedActions;
 
#if wxUSE_DRAG_AND_DROP
 
  friend class MyDropTarget;
 
#endif
  friend class MaximaIPC;
 
  wxTimer m_autoSaveTimer;
 
  /* A timer that delays redraws while maxima evaluates
 
     If we always start a redraw when maxima has nearly finished a command that slows
     down evaluating many simple commands in a row.
  */
  wxTimer m_fastResponseTimer;
 
  void StartAutoSaveTimer();
};
 
#if wxUSE_DRAG_AND_DROP
 
// cppcheck-suppress noConstructor
class MyApp : public wxApp
{
public:
  virtual bool OnInit();
  virtual int OnRun();
  virtual int OnExit();
#if wxUSE_ON_FATAL_EXCEPTION && wxUSE_CRASHREPORT
  void  OnFatalException () override;
#endif
  static void NewWindow(const wxString &file = {}, bool evalOnStartup = false, bool exitAfterEval = false, unsigned char *wxmData = NULL, std::size_t wxmLen = 0);
 
  void OnFileMenu(wxCommandEvent &ev);
 
  virtual void MacNewFile();
 
  virtual void MacOpenFile(const wxString &file);
 
public:
  static wxLogWindow *m_logWindow; // The wxWidgets log window, we use.
  static int m_windowcount;
 
  std::unique_ptr<wxLogChain> m_logChain;
  static std::vector<wxProcess *> m_wxMaximaProcesses;
#ifdef USE_QA
#if wxUSE_ON_FATAL_EXCEPTION && wxUSE_CRASHREPORT
  void GenerateDebugReport(wxDebugReport::Context ctx);
#endif
#endif
  std::unique_ptr<wxLocale> m_locale;
  std::unique_ptr<wxTranslations> m_translations;
  wxString m_configFileName;
  Dirstructure m_dirstruct;
  static bool m_allWindowsInOneProcess;
  std::unique_ptr<Configuration> m_configuration;
};
 
class MyDropTarget : public wxFileDropTarget
{
public:
  explicit MyDropTarget(wxMaxima *wxmax)
    { m_wxmax = wxmax; }
 
  bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString &files);
 
private:
  wxMaxima *m_wxmax = NULL;
};
 
#endif
 
 
// cppcheck-suppress noConstructor
 
#endif // WXMAXIMA_H