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 "wxMaximaFrame.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/wfstream.h>
#include <wx/zstream.h>
#include <wx/txtstrm.h>
#include <wx/sckstrm.h>
#include <wx/buffer.h>
#include <wx/power.h>
#include <memory>
#ifdef __WXMSW__
#include <windows.h>
#endif
#define DOCUMENT_VERSION_MAJOR 1
 
#define DOCUMENT_VERSION_MINOR 5
 
#define MAXIMAPOLLMSECS 2000
 
class Maxima; // The Maxima process interface
class MaximaEvent;
 
/* The top-level window and the main application logic
 
 */
class wxMaxima : public wxMaximaFrame
{
public:
 
  wxMaxima(wxWindow *parent, int id, wxLocale *locale, const wxString title,
           const wxString &filename = wxEmptyString,
           const wxPoint pos = wxDefaultPosition, const wxSize size = wxDefaultSize);
 
  virtual ~wxMaxima();
 
  static void PipeToStdout(){m_pipeToStdout = true;}
  static void ExitOnError(){m_exitOnError = true;}
  static void EnableIPC(){ MaximaIPC::EnableIPC(); }
  static void ExtraMaximaArgs(const wxString &args){m_extraMaximaArgs = args;}
 
  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 SetWXMdata(const wxString &data){m_initialWorkSheetContents = data;}
  void EvalOnStartup(bool eval)
    {
      m_evalOnStartup = eval;
    }
 
  void ExitAfterEval(bool exitaftereval)
    {
      m_exitAfterEval = exitaftereval;
      if(exitaftereval)
      {
        m_logPane->SetBatchMode();
      }
    }
 
  void StripLispComments(wxString &s);
 
  void LaunchHelpBrowser(wxString uri);
 
  void SendMaxima(wxString s, bool addToHistory = false);
 
  bool OpenFile(const wxString &file, const wxString &command ={});
 
  bool DocumentSaved()
  { return m_fileSaved; }
 
  void LoadImage(wxString file)
  { m_worksheet->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;}
    friend bool operator<(const VersionNumber& v1, const VersionNumber& v2);
    friend bool operator>(const VersionNumber& v1, const VersionNumber& v2);
  private:
    long m_major;
    long m_minor;
    long m_patchlevel;
  };
 
private:
  MaximaIPC m_ipc{this};
  wxString m_initialWorkSheetContents;
  static bool m_pipeToStdout;
  static bool m_exitOnError;
  static wxString m_extraMaximaArgs;
  wxLocale *m_locale;
  wxArrayString m_varNamesToQuery;
 
  bool m_isLogTarget;
  bool m_openInitialFileError;
  wxString EscapeForLisp(wxString str);
  long long m_maximaJiffies_old;
  long long m_cpuTotalJiffies_old;
  wxString m_configCommands;
  static wxRegEx m_gnuplotErrorRegex;
  bool AbortOnError();
  wxString m_oldFindString;
  int m_oldFindFlags;
  bool m_hasEvaluatedCells;
//  static wxRegEx m_outputPromptRegEx;
  int m_outputCellsFromCurrentCommand;
  int m_maxOutputCellsPerCommand;
  int m_unsuccessfulConnectionAttempts;
  wxString m_CWD;
  bool m_evalOnStartup;
  bool m_exitAfterEval;
  bool m_ready;
 
  wxString GetUnmatchedParenthesisState(wxString text,int &index);
  wxMemoryBuffer m_uncompletedChars;
 
protected:
  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;
  void OnActivate(wxActivateEvent &event);
  void OnMinimize(wxIconizeEvent &event);
  void ConfigChanged();
  void OnJumpToError(wxCommandEvent &event);
  void OnSymbolAdd(wxCommandEvent &event);
  void OnFollow(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 InterpretDataFromMaxima(const wxString &newData);
  bool m_dataFromMaximaIs;
 
  void MenuCommand(const wxString &cmd);           
  void FileMenu(wxCommandEvent &event);            
  void MaximaMenu(wxCommandEvent &event);          
  void MatrixMenu(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 OnProcessEvent(wxProcessEvent &event);      //
  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 OnFindClose(wxFindDialogEvent &event);
 
  void OnReplace(wxFindDialogEvent &event);
 
  void OnReplaceAll(wxFindDialogEvent &event);
 
  void OnMaximaConnect();
 
  void MaximaEvent(::MaximaEvent &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, 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 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(wxString &data);
 
  bool ParseNextChunkFromMaxima(wxString &data);
 
  int FindTagEnd(const wxString &data, const wxString &tag);
 
  void ReadMiscText(const wxString &data);
 
  void ReadPrompt(wxString &data);
 
  void ReadStatusBar(wxString &data);
 
  void ReadMath(wxString &data);
 
  void ReadMaximaIPC(wxString &data){m_ipc.ReadInputData(data);}
  void ReadLoadSymbols(wxString &data);
 
  void ReadSuppressedOutput(wxString &data);
 
  void ReadVariables(wxString &data);
 
  void ReadAddVariables(wxString &data);
  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 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 VariableActionNumer(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;
  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 BecomeLogTarget();
 
  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->Close();
    wxLogMessage(_("Closing the socket maxima could connect to!"));
    server->Destroy();
  }
};
  std::unique_ptr<wxSocketServer,  ServerDeleter> m_server;
 
  wxProcess *m_process;
  wxInputStream *m_maximaStdout;
  wxInputStream *m_maximaStderr;
  int m_port;
  wxString m_currentOutputEnd;
  wxString m_currentOutput;
  static wxString m_mathPrefix1;
  static wxString m_mathPrefix2;
  static wxString m_mathSuffix1;
  static wxString m_mathSuffix2;
  static wxString m_promptPrefix;
public:
  const static wxString m_promptSuffix;
protected:
  void GnuplotCommandName(wxString gnuplot);
  static wxString m_variablesPrefix;
  static wxString m_variablesSuffix;
//  static wxString m_outputPromptPrefix;
//  static wxString m_outputPromptSuffix;
  static wxString m_statusbarPrefix;
  static wxString m_statusbarSuffix;
  static wxString m_addVariablesPrefix;
  static wxString m_addVariablesSuffix;
  static wxString m_symbolsPrefix;
  static wxString m_symbolsSuffix;
  static wxString m_suppressOutputPrefix;
  static wxString m_suppressOutputSuffix;
  static wxString m_firstPrompt;
  static wxString m_emptywxxmlSymbols;
  bool m_dispReadOut;               
  wxString m_lastPrompt;
  wxString m_lastPath;
  std::unique_ptr<wxPrintData> m_printData;
  bool m_closing;
  wxString m_openFile;
  wxString m_maximaTempDir;
  wxString m_maximaHtmlDir;
  bool m_fileSaved;
  wxString m_maximaArch;
  wxString m_lispVersion;
  wxString m_lispType;
  static int m_exitCode;
  wxString m_gnuplotcommand;
  int m_commandIndex;
  wxFindReplaceData m_findData;
  static wxRegEx m_funRegEx;
  static wxRegEx m_varRegEx;
  static wxRegEx m_blankStatementRegEx;
  static wxRegEx m_sbclCompilationRegEx;
  MathParser m_parser;
  bool m_maximaBusy;
private:
  typedef void (wxMaxima::*ParseFunction)(wxString &s);
  WX_DECLARE_STRING_HASH_MAP(ParseFunction, ParseFunctionHash);
  typedef void (wxMaxima::*VarReadFunction)(const wxString &value);
  WX_DECLARE_STRING_HASH_MAP(VarReadFunction, VarReadFunctionHash);
  static ParseFunctionHash m_knownXMLTags;
  static VarReadFunctionHash m_variableReadActions;
 
#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
 
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;
};
 
#endif
 
 
// cppcheck-suppress noConstructor
class MyApp : public wxApp
{
public:
  virtual bool OnInit();
  virtual int OnRun();
  virtual int OnExit();
  wxLocale m_locale;
 
  void NewWindow(const wxString &file = {}, bool evalOnStartup = false, bool exitAfterEval = false, unsigned char *wxmData = NULL, size_t wxmLen = 0);
 
  static std::vector<wxMaxima *> m_topLevelWindows;
  static void DelistTopLevelWindow(wxMaxima *);
 
  void OnFileMenu(wxCommandEvent &ev);
 
  virtual void MacNewFile();
  void BecomeLogTarget();
 
  virtual void MacOpenFile(const wxString &file);
 
private:
  wxString m_configFileName;
  Dirstructure m_dirstruct;
  #if defined __WXOSX__
  bool m_allWindowsInOneProcess = true;
  #else
  bool m_allWindowsInOneProcess = false;
  #endif
};
 
 
 
// cppcheck-suppress unknownMacro
DECLARE_APP(MyApp)
 
#endif // WXMAXIMA_H