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 "BuildConfig.h"
#include <vector>
#include "wxMaximaFrame.h"
#include "WXMXformat.h"
#include "Configuration.h"
#include "MathParser.h"
#include "MaximaIPC.h"
#include "MaximaCommandMenus.h"
#include "MaximaResponseReader.h"
#include "MaximaProcessManager.h"
#include "MaximaEvaluator.h"
#include "MaximaFileIO.h"
#include "MaximaOutputAppender.h"
#include "MaximaInterruptChannel.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;}
  bool ExitOnErrorArmed() const { return m_exitOnError && m_exitOnErrorArmed; }
 
#ifdef __WXMSW__
  static void RepairFileAssociations();
#endif
  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,
    MAXIMA_CONNECT_WATCHDOG_ID
  };
 
#ifdef wxHAS_POWER_EVENTS
  void OnPowerEvent(wxPowerEvent &event);
#endif
 
  void OnTimerEvent(wxTimerEvent &event);
 
  wxTimer m_maximaStdoutPollTimer;
 
  wxTimer m_maximaConnectWatchdogTimer;
  bool m_maximaConnectWatchdogWarningShown = false;
 
  void ShowTip(bool force);
  void EvalOnStartup(bool eval)
    {
      m_evalOnStartup = eval;
    }
 
  void ExitAfterEval(bool exitaftereval);
  bool IsInteractive() const { return !m_exitAfterEval; }
 
  void StripLispComments(wxString &s);
 
  void LaunchHelpBrowser(wxString uri);
 
 
  bool DocumentSaved()
    { return m_fileSaved; }
 
  void LoadImage(const wxString &file)
    { GetWorksheet()->OpenHCaret(file, GC_TYPE_IMAGE); }
 
  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;}
 
  enum ExitCode : int {
    EXIT_MAXIMA_ERROR = 90,
    EXIT_UNANSWERED_QUESTION = 91,
    EXIT_FILE_OPEN_FAILED = 92,
    EXIT_FILE_SAVE_FAILED = 93,
    EXIT_IMAGE_LOAD_FAILED = 94,
    EXIT_IMAGE_DECODE_FAILED = 95,
  };
 
  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;
  bool m_exitOnErrorArmed = true;
  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;
  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 = {}
    );
  static wxRegEx m_xmlOpeningTagName;
  static wxRegEx m_xmlOpeningTag;
  wxProcess *m_gnuplotProcess = nullptr;
  wxProcess *m_gnuplotTerminalQueryProcess = nullptr;
  wxProcess *m_gnuplotPopoutCheckProcess = nullptr;
  wxString m_gnuplotPopoutCheckFile;
  wxString m_gnuplotProbedCommand;
  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(const wxString &anchor = wxEmptyString);
 
  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 ExportWorksheetToHtml(const wxString &filename, const wxString &flavor,
                             bool embedWxmx);
 
  void ExportWorksheetToTex(const wxString &filename,
                            const wxString &documentclass,
                            const wxString &documentclassOptions,
                            bool embedWorksheet);
#ifdef __WXMSW__
  void RegisterWxmxDiffTool();
#endif
  void ReplaceSuggestion(wxCommandEvent &event);   
  void UpdateMenus();        
  void UpdateToolBar();      
  void UpdateSlider();       
  void ShowPane(wxCommandEvent &event);            //<! Makes a sidebar visible
 
  void ChangeCellStyle(wxCommandEvent &event);
  void OnTextFormat(wxCommandEvent &event);
 
  void OnFind(wxFindDialogEvent &event);
 
  void OnReplace(wxFindDialogEvent &event);
 
  void OnReplaceAll(wxFindDialogEvent &event);
 
  void AddDrawParameter(wxString cmd, int dimensionsOfNewDrawCommand = 2);
 
  // The console output appenders (ConsoleAppend / DoConsoleAppend /
  // DoRawConsoleAppend) and their AppendOpt options now live in
  // MaximaOutputAppender (m_outputAppender).
 
  void VarReadEvent(wxCommandEvent &event);
  void VarAddAllEvent(wxCommandEvent &event);
 
  void SliderEvent(wxScrollEvent &event);
 
  void NetworkDClick(wxMouseEvent &ev);
  void MaximaDClick(wxMouseEvent &ev);
  void StatusMsgDClick(wxMouseEvent &ev);
 
#ifdef WXM_USE_AI_TOOLS
  void AiStatusClick(wxMouseEvent &ev);
  void AiStatusDClick(wxMouseEvent &ev);
  void AiStatusRightClick(wxMouseEvent &ev);
#endif
 
  void HistoryDClick(wxCommandEvent &event);
 
  void TableOfContentsSelection(wxListEvent &event);
 
  void OnInspectorEvent(wxCommandEvent &ev);
 
  void DumpProcessOutput();
 
 
  void TryUpdateInspector();
 
  bool UpdateDrawPane();
 
  wxString ExtractFirstExpression(const wxString &entry);
 
  wxString GetDefaultEntry();
 
  void OnClose(wxCloseEvent &event);               
  wxString GetCommand(bool params = true);         
  //    (uses guessConfiguration)
 
  void ReadMaximaIPC(const wxString &data){m_ipc.ReadInputData(data);}
 
  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 ResetTitle(bool saved, bool force = false);
 
  std::unique_ptr<GroupCell> CreateTreeFromXMLNode(wxXmlNode *xmlcells, const wxString &wxmxfilename = {});
 
  bool SaveOnClose();
 
  int SaveDocumentP();
 
  void SetCWD(wxString file);
 
  wxString GetCWD()
    {
      return m_CWD;
    }
 
  std::unique_ptr<Maxima> m_client;
  std::unique_ptr<MaximaInterruptChannel> m_interruptChannel;
  struct ServerDeleter {
    void operator()(wxSocketServer* server) const {
      server->Destroy(); // Destroy() calls Close() automatically.
    }
  };
  std::unique_ptr<wxSocketServer,  ServerDeleter> m_server;
 
  wxProcess *m_maximaProcess = nullptr;
  wxInputStream *m_maximaStdout = nullptr;
  wxInputStream *m_maximaStderr = nullptr;
  wxOutputStream *m_maximaStdin = nullptr;
  bool m_inLDB = false;
  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 OnUpdateTOCEvent(wxCommandEvent &event);
 
  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:
  wxString m_fileToOpen;
  bool m_fourierLoaded = false;
 
#if wxUSE_DRAG_AND_DROP
 
  friend class MyDropTarget;
 
#endif
  friend class MaximaIPC;
  friend class MaximaCommandMenus;
  friend class MaximaResponseReader;
  friend class MaximaProcessManager;
  friend class MaximaEvaluator;
  friend class MaximaFileIO;
  friend class MaximaOutputAppender;
 
  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();
  MaximaCommandMenus m_menuCommands;
  MaximaResponseReader m_responseReader;
  MaximaProcessManager m_processManager;
  MaximaEvaluator m_evaluator;
  MaximaFileIO m_fileIO;
  MaximaOutputAppender m_outputAppender;
};
 
wxString ApplyAppearanceToApp(Configuration::Appearance appearance,
                              bool logImmediately = true);
 
#if wxUSE_DRAG_AND_DROP
 
// cppcheck-suppress noConstructor
class MyApp : public wxApp
{
public:
  virtual bool OnInit() override;
  virtual int OnRun() override;
  virtual int OnExit() override;
  // Both guards are needed, and in this order: the definition in main.cpp
  // carries exactly the same pair, and GenerateDebugReport() -- the QA-only
  // method this one calls -- is already declared under both further down.
  // Declaring an override that no translation unit defines does not merely
  // waste a line: it is emitted into MyApp's vtable, so the link fails with
  // "undefined reference to MyApp::OnFatalException()" pointing at
  // _ZTV5MyApp rather than at any call site. That is what a
  // -DWXM_DISABLE_QA=YES build hit.
  // The macro is USE_QA, not WXM_USE_QA: WXM_USE_QA is the *CMake option*,
  // and src/BuildConfig.h.cin turns it into #cmakedefine USE_QA. Guarding on
  // the option name instead compiles to "never", which removes the
  // declaration from the default build too, where main.cpp still defines the
  // member.
#ifdef USE_QA
#if wxUSE_ON_FATAL_EXCEPTION && wxUSE_DEBUGREPORT
  void  OnFatalException () override;
#endif
#endif
  void OnAssertFailure(const wxChar *file, int line, const wxChar *func,
                       const wxChar *cond, const wxChar *msg) override;
  static void NewWindow(const wxString &file = {}, bool evalOnStartup = false, bool exitAfterEval = false, unsigned char *wxmData = nullptr, std::size_t wxmLen = 0);
 
  void OnFileMenu(wxCommandEvent &ev);
 
#ifdef __WXMSW__
  void DisableConsoleQuickEdit();
  void RestoreConsoleMode();
#endif // __WXMSW__
 
#ifdef __WXMAC__
  void MacNewFile() override;
  void MacOpenFile(const wxString &file) override;
#endif // __WXMAC__
 
public:
  static wxLogWindow *m_logWindow; // The wxWidgets log window, we use.
 
  static std::unique_ptr<wxLogChain> m_logChain;
  static std::vector<wxProcess *> m_wxMaximaProcesses;
#ifdef USE_QA
#if wxUSE_ON_FATAL_EXCEPTION && wxUSE_DEBUGREPORT
  void GenerateDebugReport(wxDebugReport::Context ctx);
#endif
#endif
  std::unique_ptr<wxLocale> m_locale;
  std::unique_ptr<wxTranslations> m_translations;
#ifdef __WXMSW__
  unsigned long m_consoleModeToRestore = 0;
  bool m_consoleModeChanged = false;
#endif
  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 = nullptr;
};
 
#endif
 
 
// cppcheck-suppress noConstructor
 
#endif // WXMAXIMA_H