terminal.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2018  Erik Haenel et al.
 
    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 3 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, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
 
#ifdef __GNUG__
#pragma implementation "wxterm.h"
#endif
 
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
 
#ifdef __BORLANDC__
#pragma hdrstop
#endif
 
// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWindows headers
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
 
#include <wx/timer.h>
 
#include <ctype.h>
 
#include "gterm.hpp"
#include "terminal.hpp"
#include "terminalcalltip.hpp"
#include <wx/clipbrd.h>
#include <wx/dataobj.h>
#include "../globals.hpp"
 
void WinMessageBeep();
 
#define CURSOR_BLINK_DEFAULT_TIMEOUT    500
#define CURSOR_BLINK_MAX_TIMEOUT    2000
#define KERNEL_THREAD_STACK_SIZE 4194304 // Bytes
#define MEASURING_STRING "The quick brown fox jumps over a lazy dog."
 
BEGIN_EVENT_TABLE(NumeReTerminal, wxWindow)
    EVT_PAINT                       (NumeReTerminal::OnPaint)
    EVT_CHAR                        (NumeReTerminal::OnChar)
    EVT_LEFT_DOWN                   (NumeReTerminal::OnLeftDown)
    EVT_MOUSE_CAPTURE_LOST          (NumeReTerminal::OnLoseMouseCapture)
    EVT_LEFT_UP                     (NumeReTerminal::OnLeftUp)
    EVT_MOTION                      (NumeReTerminal::OnMouseMove)
//  EVT_ENTER_WINDOW                (NumeReTerminal::OnEnter)
    EVT_TIMER                       (-1, NumeReTerminal::OnTimer)
    EVT_KEY_DOWN                    (NumeReTerminal::OnKeyDown)
    EVT_SIZE                        (NumeReTerminal::OnSize)
    EVT_SET_FOCUS                   (NumeReTerminal::OnGainFocus)
    EVT_KILL_FOCUS                  (NumeReTerminal::OnLoseFocus)
    EVT_CLOSE                       (NumeReTerminal::OnClose)
END_EVENT_TABLE()
 
 
 
NumeReTerminal::NumeReTerminal(wxWindow* parent, wxWindowID id, Options* _option, const wxString& sPath, const wxPoint& pos, int width, int height, const wxString& name) : wxWindow(parent, id, pos, wxSize(-1, -1), wxWANTS_CHARS, name), GenericTerminal(width, height)
{
    // Bind the thread update event to the corresponding handler function
    Bind(wxEVT_THREAD, &NumeReTerminal::OnThreadUpdate, this);
 
    m_init = 1;
 
    // Initialize the terminal member variables
    m_inUpdateSize = false;
    m_isActive = false;
    m_isBusy = false;
    m_scrollBarWidth = wxSystemSettings::GetMetric(wxSYS_VSCROLL_ARROW_X);
    m_curDC = nullptr;
    m_charsInLine = width;
    m_linesDisplayed = height;
    m_selecting = false;
    m_selx1 = m_sely1 = m_selx2 = m_sely2 = 0;
    m_marking = false;
    m_curX = -1;
    m_curY = -1;
    m_curBlinkRate = CURSOR_BLINK_DEFAULT_TIMEOUT;
    m_timer.SetOwner(this);
    m_boldStyle = FONT;
    m_options = _option;
    m_width = width;
    m_height = height;
    m_bitmap = nullptr;
    m_wxParent = nullptr;
    m_callTip = nullptr;
 
    SetCursor(wxCursor(wxCURSOR_IBEAM));
 
    // Start the kernel
    _kernel.StartUp(this, sPath.ToStdString(), getSyntax()->getFunctions());
    m_options->copySettings(_kernel.getKernelSettings());
    m_useSmartSense = m_options->getSetting(SETTING_B_SMARTSENSE).active();
 
    // Update the terminal colors
    UpdateColors();
 
    // Initialize the relevant fonts
    SetFont(m_options->toFont(m_options->getSetting(SETTING_S_TERMINALFONT).stringval()));
 
    m_callTip = new TerminalCallTip(this, wxSize(100*m_charWidth, 2*m_charHeight));
    m_callTip->ChangeFont(m_options->toFont(m_options->getSetting(SETTING_S_TERMINALFONT).stringval()));
    SetClientSize(m_charsInLine * 8, m_linesDisplayed * 16);
    // 10pt Courier New is 8 pixels wide and 16 pixels high... set up
    // a default client size to match
    UpdateSize();
 
    // Start the cursor blink rate timer
    if (m_curBlinkRate)
        m_timer.Start(m_curBlinkRate);
 
#ifdef DO_LOG
    // Activate logging
    wxLog::SetActiveTarget(new wxLogWindow(this, "Logger"));
#endif
 
    // Start the kernel thread
    StartKernelTask();
 
    // Initialize the kernel-specific veriables
    m_KernelStatus = NumeReKernel::NUMERE_DONE;
    m_bCommandAvailable = false;
    m_bTableEditAvailable = false;
    m_bTableEditCanceled = false;
    m_nDebuggerCode = 0;
    m_sCommandLine = "";
    m_sAnswer = "";
 
    // Copy the plugin definitions to the syntax stylers
    {
        wxCriticalSectionLocker lock(m_kernelCS);
        getSyntax()->addPlugins(_kernel.getPluginCommands());
    }
    m_init = 0;
}
 
 
NumeReTerminal::~NumeReTerminal()
{
    if (m_bitmap)
    {
        m_memDC.SelectObject(wxNullBitmap);
        delete m_bitmap;
    }
}
 
 
std::vector<std::string> NumeReTerminal::getPathSettings()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    std::vector<std::string> vPaths = _kernel.getPathSettings();
    return vPaths;
}
 
 
const std::vector<Package>& NumeReTerminal::getInstalledPackages()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getInstalledPackages();
}
 
 
std::map<std::string, std::string> NumeReTerminal::getMenuMap()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getMenuMap();
}
 
 
void NumeReTerminal::updatePackage(const std::string& package)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.getProcedureInterpreter().declareNewPackage(package);
}
 
 
void NumeReTerminal::passEditedTable(NumeRe::Table _table)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.table = _table;
    m_bTableEditAvailable = true;
}
 
 
void NumeReTerminal::addBreakpoint(const std::string& _sFilename, size_t nLine)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.getDebugger().getBreakpointManager().addBreakpoint(_sFilename, nLine);
}
 
 
void NumeReTerminal::removeBreakpoint(const std::string& _sFilename, size_t nLine)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.getDebugger().getBreakpointManager().removeBreakpoint(_sFilename, nLine);
}
 
 
void NumeReTerminal::clearBreakpoints(const std::string& _sFilename)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.getDebugger().getBreakpointManager().clearBreakpoints(_sFilename);
}
 
 
std::string NumeReTerminal::getDocumentation(const std::string& sCommand)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getDocumentation(sCommand);
}
 
 
std::vector<std::string> NumeReTerminal::getDocIndex()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getDocIndex();
}
 
 
std::map<std::string, std::string> NumeReTerminal::getPluginLanguageStrings()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getPluginLanguageStrings();
}
 
 
std::map<std::string, std::string> NumeReTerminal::getFunctionLanguageStrings()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getFunctionLanguageStrings();
}
 
 
NumeReVariables NumeReTerminal::getVariableList()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getVariableList();
}
 
 
Settings NumeReTerminal::getKernelSettings()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    Settings _option(_kernel.getKernelSettings());
    return _option;
}
 
 
void NumeReTerminal::setKernelSettings(const Settings& _settings)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.setKernelSettings(_settings);
    m_useSmartSense = _settings.getSetting(SETTING_B_SMARTSENSE).active();
}
 
 
void NumeReTerminal::StartKernelTask()
{
    if (CreateThread(wxTHREAD_JOINABLE, KERNEL_THREAD_STACK_SIZE) != wxTHREAD_NO_ERROR)
    {
        wxLogError("Could not create kernel thread!");
        return;
    }
    if (GetThread()->Run() != wxTHREAD_NO_ERROR)
    {
        wxLogError("Could not run the kernel thread!");
        return;
    }
}
 
 
wxThread::ExitCode NumeReTerminal::Entry()
{
    std::string sCommand;
    bool bCommandAvailable;
    bool updateLibrary;
    _kernel.initializeStackTracker();
    _kernel.printVersionInfo();
    _kernel.printPreFmt("|\n|<- ");
 
    // Test repeatedly, whether the thread shall terminate
    while (!GetThread()->TestDestroy())
    {
        // Perform this loop only 10 times a second
        Sleep(100);
 
        // start critical section for reading the command and the boolean
        {
            wxCriticalSectionLocker lock(m_kernelCS);
 
            bCommandAvailable = m_bCommandAvailable;
            sCommand = m_sCommandLine;
            m_bCommandAvailable = false;
 
            updateLibrary = m_updateProcedureLibrary;
            m_updateProcedureLibrary = false;
            m_sCommandLine.clear();
 
            if (!sCommand.length() && bCommandAvailable)
            {
                m_KernelStatus = NumeReKernel::NUMERE_PENDING;
                wxQueueEvent(GetEventHandler(), new wxThreadEvent());
                continue;
            }
        }
 
        // Refreshing the library before any command is executed
        if (updateLibrary)
        {
            // update the internal procedure library if needed
            NumeReKernel::ProcLibrary.updateLibrary();
        }
 
        // A command is available
        if (bCommandAvailable)
        {
            // This is the actual evaluating function. It is called from this second thread regularly (every 100ms) and
            // enters the function, if a command was passed to the terminal.
            m_KernelStatus = _kernel.MainLoop(sCommand);
 
            /*if (m_KernelStatus > 0) // these are valid status values (0 = error, -1 = quit)
            {
                wxCriticalSectionLocker lock(m_kernelCS);
 
                switch (m_KernelStatus)
                {
                    case NumeReKernel::NUMERE_DONE:
                        m_sAnswer += _kernel.ReadAnswer();
                        break;
                    default:
                        break;
                        //All others
                }
            }
            else */
            if (m_KernelStatus == NumeReKernel::NUMERE_QUIT) //quit
            {
                break;
            }
 
            // Notify the event handler that there's an update
            wxQueueEvent(GetEventHandler(), new wxThreadEvent());
        }
 
        // During idle times so that these tasks don't interfere with the main evaluation routine
        // do the following:
        if (time(0) - _kernel.getLastSavedTime() >= _kernel.getAutosaveInterval())
            _kernel.Autosave(); // save the cache
 
    }
 
    // The thread will terminate
    // Close the session and inform the thread handler
    _kernel.CloseSession();
    m_KernelStatus = NumeReKernel::NUMERE_QUIT;
    wxQueueEvent(GetEventHandler(), new wxThreadEvent());
    return (wxThread::ExitCode)0;
}
 
 
void NumeReTerminal::EndKernelTask()
{
    if (GetThread() && GetThread()->IsRunning())
    {
        erase_line();
        GetThread()->Delete();
    }
}
 
 
void NumeReTerminal::OnClose(wxCloseEvent& event)
{
    if (GetThread() && GetThread()->IsRunning())
        GetThread()->Wait();
    wxMilliSleep(200);
    Destroy();
}
 
 
void NumeReTerminal::OnThreadUpdate(wxThreadEvent& event)
{
    bool Closing = false;
    bool changedSettings = false;
    bool done = false;
    bool refreshFunctionTree = false;
    std::queue<NumeReTask> taskQueue;
    std::string sAnswer = "";
 
    // Get the kernel status and read the variables
    // correspondingly
    {
        wxCriticalSectionLocker lock(m_kernelCS);
        // Always read the complete task queue
        if (_kernel.taskQueue.size())
            taskQueue.swap(_kernel.taskQueue);
 
        switch (m_KernelStatus)
        {
            case NumeReKernel::NUMERE_ANSWER_READ:
            case NumeReKernel::NUMERE_PENDING_SPECIAL:
                return;
            // fallthrough is intended
            //case NumeReKernel::NUMERE_DONE:
            //  sAnswer = m_sAnswer + "\n|\n|<- ";
            //  done = true;
            //  break;
            // fallthrough is intended
            case NumeReKernel::NUMERE_ERROR:
            case NumeReKernel::NUMERE_DONE:
            case NumeReKernel::NUMERE_DONE_KEYWORD:
                sAnswer = m_sAnswer + "|\n|<- ";
                done = true;
                break;
            case NumeReKernel::NUMERE_PENDING:
                done = true;
                sAnswer = "|<- ";
                break;
            case NumeReKernel::NUMERE_QUIT:
                Closing = true;
                break;
            default:
                //All other cases
                sAnswer = m_sAnswer;
        }
 
        // clear the communication variables
        m_sAnswer.clear();
        changedSettings = _kernel.SettingsModified();
 
        // Warnings may be issued without kernel interaction
        if (m_KernelStatus == NumeReKernel::NUMERE_ISSUE_WARNING && !m_isBusy)
            sAnswer += "|\n|<- ";
 
        m_KernelStatus = NumeReKernel::NUMERE_ANSWER_READ;
    }
 
    // Toggle the toolbar tools used for stopping and starting tasks
    if (done)
    {
        Ready();
    }
 
    // If the kernel asks the application to terminate
    // do this after 200msec
    if (Closing)
    {
        wxMilliSleep(300);
        m_wxParent->Close();
        return;
    }
 
    // Evaluate the task queue. It will contain also the transmitted
    // variables needed for the current task
    while (taskQueue.size())
    {
        // Get the first task and remove it from
        // the queue
        NumeReTask task = taskQueue.front();
        taskQueue.pop();
 
        // Evaluate the current task depending on its type
        switch (task.taskType)
        {
            case NumeReKernel::NUMERE_EDIT_FILE:
            {
                if (task.sString.find(".png") != std::string::npos
                        || task.sString.find(".jpg") != std::string::npos
                        || task.sString.find(".jpeg") != std::string::npos
                        || task.sString.find(".gif") != std::string::npos
                        || task.sString.find(".bmp") != std::string::npos)
                {
                    m_wxParent->openImage(wxFileName(task.sString));
                }
                else
                {
                    m_wxParent->OpenSourceFile(wxArrayString(1, task.sString), task.nLine, _kernel.ReadOpenFileFlag());
                }
                break;
            }
            case NumeReKernel::NUMERE_SHOW_WINDOW:
                Refresh();
                m_wxParent->showWindow(task.window);
                break;
            case NumeReKernel::NUMERE_OPEN_DOC:
                m_wxParent->ShowHelp(task.sString);
                break;
            case NumeReKernel::NUMERE_SHOW_TABLE:
                m_wxParent->openTable(task.table, task.sString, task.sString);
                break;
            case NumeReKernel::NUMERE_SHOW_STRING_TABLE:
                m_wxParent->openTable(task.stringTable, task.sString, task.sString);
                break;
            case NumeReKernel::NUMERE_EDIT_TABLE:
                m_wxParent->editTable(task.table, task.sString);
                break;
            case NumeReKernel::NUMERE_DEBUG_EVENT:
                m_wxParent->evaluateDebugInfo(task.vDebugEvent);
                break;
            case NumeReKernel::NUMERE_REFRESH_FUNCTIONTREE:
                refreshFunctionTree = true;
                break;
            case NumeReKernel::NUMERE_CLOSE_WINDOWS:
                m_wxParent->closeWindows((WindowType)task.nLine);
                break;
            case NumeReKernel::NUMERE_INSTALLATION_DONE:
                m_wxParent->notifyInstallationDone();
                break;
            case NumeReKernel::NUMERE_CLC_TERMINAL:
                clearTerminal();
                break;
        }
    }
 
    // This boolean is true, if the user switched a setting directly in the kernel
    if (changedSettings)
    {
        m_options->copySettings(getKernelSettings());
        m_wxParent->EvaluateOptions();
    }
 
    // Refresh now the function tree (will avoid multiple
    // refreshes in a single event loop).
    if (refreshFunctionTree)
    {
        getSyntax()->addPlugins(_kernel.getPluginCommands());
        m_wxParent->refreshFunctionTree();
    }
 
    // To ensure that the user is able to read the answer
    // scroll to the input location and process the kernel
    // message
    scrollToInput();
 
    if (sAnswer == "|\n|<- " && GetTM()->getPreviousLine() == "|")
        sAnswer = "|<- ";
 
    ProcessOutput(sAnswer.length(), sAnswer);
    Refresh();
}
 
 
bool
NumeReTerminal::SetFont(const wxFont& font)
{
    if (font == m_normalFont)
        return true;
 
    m_init = 1;
 
    // Set the passed font to all internal member variables
    wxWindow::SetFont(font);
    m_normalFont = font;
    m_underlinedFont = font;
    m_underlinedFont.SetUnderlined(true);
    m_boldFont = GetFont();
    m_boldFont.SetWeight(wxBOLD);
    m_boldUnderlinedFont = m_boldFont;
    m_boldUnderlinedFont.SetUnderlined(true);
 
    if (m_callTip)
        m_callTip->ChangeFont(font);
 
    m_init = 0;
 
    // Resize the terminal, because the new
    // font might have a new text extent
    ResizeTerminal(m_width, m_height);
 
    // Refresh the GUI element
    Refresh();
 
    return true;
}
 
 
void
NumeReTerminal::GetDefColors(wxColour colors[16], NumeReTerminal::BOLDSTYLE boldStyle)
{
    // Set the correct bold style
    if (boldStyle == DEFAULT)
        boldStyle = m_boldStyle;
 
    // Beause the enumeration of the internal syntax and the syntax of the
    // terminal is not identical, we need to use this lookup function
    //
    // We could also use a simple array to get the correct index, however
    // using this switch with the correct enumerators is probably more safe.
    for (size_t i = 0; i < 16; i++)
    {
        switch (i)
        {
            case 0:
                colors[0] = m_options->GetSyntaxStyle(Options::CONSOLE_STD).background;
                break;
            case NumeReSyntax::SYNTAX_COMMAND:
                colors[NumeReSyntax::SYNTAX_COMMAND] = m_options->GetSyntaxStyle(Options::COMMAND).foreground;
                break;
            case NumeReSyntax::SYNTAX_OPTION:
                colors[NumeReSyntax::SYNTAX_OPTION] = m_options->GetSyntaxStyle(Options::OPTION).foreground;
                break;
            case NumeReSyntax::SYNTAX_FUNCTION:
                colors[NumeReSyntax::SYNTAX_FUNCTION] = m_options->GetSyntaxStyle(Options::FUNCTION).foreground;
                break;
            case NumeReSyntax::SYNTAX_CONSTANT:
                colors[NumeReSyntax::SYNTAX_CONSTANT] = m_options->GetSyntaxStyle(Options::CONSTANT).foreground;
                break;
            case NumeReSyntax::SYNTAX_SPECIALVAL:
                colors[NumeReSyntax::SYNTAX_SPECIALVAL] = m_options->GetSyntaxStyle(Options::SPECIALVAL).foreground;
                break;
            case NumeReSyntax::SYNTAX_STRING:
                colors[NumeReSyntax::SYNTAX_STRING] = m_options->GetSyntaxStyle(Options::STRING).foreground;
                break;
            case NumeReSyntax::SYNTAX_STD:
                colors[NumeReSyntax::SYNTAX_STD] = m_options->GetSyntaxStyle(Options::CONSOLE_STD).foreground;
                break;
            case NumeReSyntax::SYNTAX_OPERATOR:
                colors[NumeReSyntax::SYNTAX_OPERATOR] = m_options->GetSyntaxStyle(Options::OPERATOR).foreground;
                break;
            case NumeReSyntax::SYNTAX_PROCEDURE:
                colors[NumeReSyntax::SYNTAX_PROCEDURE] = m_options->GetSyntaxStyle(Options::PROCEDURE).foreground;
                break;
            case NumeReSyntax::SYNTAX_NUMBER:
                colors[NumeReSyntax::SYNTAX_NUMBER] = m_options->GetSyntaxStyle(Options::NUMBER).foreground;
                break;
            case NumeReSyntax::SYNTAX_NPRC_COMMAND:
                colors[NumeReSyntax::SYNTAX_NPRC_COMMAND] = m_options->GetSyntaxStyle(Options::PROCEDURE_COMMAND).foreground;
                break;
            case NumeReSyntax::SYNTAX_METHODS:
                colors[NumeReSyntax::SYNTAX_METHODS] = m_options->GetSyntaxStyle(Options::METHODS).foreground;
                break;
            case NumeReSyntax::SYNTAX_COMMENT:
                colors[NumeReSyntax::SYNTAX_COMMENT] = m_options->GetSyntaxStyle(Options::COMMENT).foreground;
                break;
            default:
                colors[i] = *wxBLACK;
        }
    }
}
 
 
void
NumeReTerminal::SetCursorBlinkRate(int rate)
{
    // Ensure that the new rate is reasonable
    if (rate < 0 || rate > CURSOR_BLINK_MAX_TIMEOUT)
        return;
 
    m_init = 1;
 
    // If the new rate is different from the old rate
    // set it and restart the blinking timer
    if (rate != m_curBlinkRate)
    {
        m_curBlinkRate = rate;
        if (!m_curBlinkRate)
            m_timer.Stop();
        else
            m_timer.Start(m_curBlinkRate);
    }
 
    m_init = 0;
}
 
 
void NumeReTerminal::pipe_command(const std::string& sCommand)
{
    wxCriticalSectionLocker lock(m_kernelCS);
 
    // the commandline from tm...
    m_sCommandLine = sCommand;
 
    // only add the line to the history, if the kernel isn't currently fetching a line with NumeReKernel::getline()
    if (!NumeReKernel::bGettingLine)
        m_wxParent->AddToHistory(sCommand);
 
    m_bCommandAvailable = true;
}
 
 
void NumeReTerminal::pass_command(const std::string& command, bool isEvent)
{
    // Don't do anything if the command is emoty
    if (!command.length())
        return;
 
#ifdef DO_LOG
    if (isEvent)
        wxLogDebug("Event: '%s'", command);
#endif
 
    // scroll to the input location
    scrollToInput();
 
    // erase the current line
    erase_line();
 
    Busy();
 
    // Set the new command to the kernel and log it
    wxCriticalSectionLocker lock(m_kernelCS);
 
    if (!isEvent)
        m_wxParent->AddToHistory(command);
 
    m_sCommandLine = command;
    m_bCommandAvailable = true;
}
 
 
NumeRe::Table NumeReTerminal::getTable(const std::string& sTableName)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getTable(sTableName);
}
 
 
NumeRe::Container<std::string> NumeReTerminal::getStringTable(const std::string& sStringTableName)
{
    wxCriticalSectionLocker lock(m_kernelCS);
    return _kernel.getStringTable(sStringTableName);
}
 
 
void NumeReTerminal::CancelCalculation()
{
    wxCriticalSectionLocker lock(m_kernelCS);
    _kernel.CancelCalculation();
}
 
 
void
NumeReTerminal::OnChar(wxKeyEvent& event)
{
    if (!(GetMode() & PC) && event.AltDown())
        event.Skip();
    else
    {
        // if the user is scrolled up and they typed something, scroll
        // all the way to the bottom
        scrollToInput();
 
        int keyCode = (int)event.GetKeyCode();
        int len = 1;
 
        // Clear selection mode
        // can probably be modified to clear the selected input line
        if (HasSelection())
        {
            if (keyCode == WXK_DELETE || keyCode == WXK_BACK)
            {
                delSelected();
                ClearSelection();
                return;
            }
            else if (keyCode < WXK_START)
                delSelected();
 
            ClearSelection();
        }
 
        // Filter special keycodes
        if (filterKeyCodes(keyCode, event.ControlDown()))
            return;
 
        std::string buf = " ";
        buf[0] = (char)keyCode;
 
        GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
        wxClientDC dc(this);
 
        m_curDC = &dc;
 
        // Process the input line
        GenericTerminal::ProcessInput(len, buf);
 
        m_curDC = nullptr;
    }
}
 
 
bool NumeReTerminal::filterKeyCodes(int keyCode, bool ctrlDown)
{
    // Filter special keycodes
    switch (keyCode)
    {
        case WXK_RETURN:
            {
                GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
                std::string sCommand = GetTM()->getCurrentInputLine();
                GenericTerminal::cr();
                GenericTerminal::lf();
                GetTM()->ChangeEditableState();
                Refresh();
                Busy();
                pipe_command(sCommand);
                return true;
            }
        case WXK_BACK:
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            if (GenericTerminal::bs())
                Refresh();
 
            return true;
        case WXK_TAB:
            GenericTerminal::resetAutoComp(RESETCURSOR);
            GenericTerminal::tab();
            Refresh();
            return true;
        case WXK_LEFT:
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            if ((ctrlDown && GenericTerminal::ctrl_left()) || GenericTerminal::cursor_left())
            {
                Refresh();
            }
            return true;
        case WXK_RIGHT:
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            if ((ctrlDown && GenericTerminal::ctrl_right()) || GenericTerminal::cursor_right())
            {
                Refresh();
            }
            return true;
        case WXK_UP:
            GenericTerminal::resetAutoComp(RESETTAB);
            if (GenericTerminal::cursor_up())
            {
                Refresh();
            }
            return true;
        case WXK_DOWN:
            GenericTerminal::resetAutoComp(RESETTAB);
            if (GenericTerminal::cursor_down())
            {
                Refresh();
            }
            return true;
        case WXK_HOME:
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            if (GenericTerminal::home())
            {
                Refresh();
            }
            return true;
        case WXK_END:
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            if (GenericTerminal::end())
            {
                Refresh();
            }
            return true;
        case WXK_DELETE:
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            if (GenericTerminal::del())
                Refresh();
 
            return true;
    }
 
    // Filter out any other non-ASCII characters
    if (keyCode >= WXK_START || keyCode < WXK_SPACE)
        return true;
 
    // No special key code
    return false;
}
 
 
void NumeReTerminal::scrollToInput()
{
    if (GenericTerminal::IsScrolledUp())
    {
        // Get the number of scrolled lines and scroll them down
        GenericTerminal::Scroll(GetTM()->GetNumLinesScrolled(), false);
        GenericTerminal::Update();
        Refresh();
    }
}
 
 
void
NumeReTerminal::OnKeyDown(wxKeyEvent& event)
{
    if (!(GetMode() & PC) && event.AltDown())
        event.Skip();
    else if (event.ControlDown() && event.ShiftDown())
    {
        // The keycode will be in uppercase letters,
        // if we require to push shift
        if (event.GetKeyCode() == 'C' || event.GetKeyCode() == 'V')
        {
            // Copy or paste
            if (event.GetKeyCode() == 'C' && HasSelection())
                copyText();
            else if (event.GetKeyCode() == 'V')
                pasteText();
 
            return;
        }
    }
    else if (event.GetKeyCode() == WXK_ESCAPE)
    {
        if (m_isBusy)
            CancelCalculation();
        else
        {
            GenericTerminal::erase_usercontent_line();
            GenericTerminal::resetAutoComp(RESETCURSOR | RESETTAB);
            Refresh();
        }
    }
    else
        event.Skip();
}
 
 
void
NumeReTerminal::OnPaint(wxPaintEvent& WXUNUSED(event))
{
    wxPaintDC dc(this);
 
#ifdef DO_LOG
    wxLogDebug("Painting");
#endif
 
    wxDC* backup = m_curDC;
 
    m_curDC = &dc;
    update_changes();
    m_curDC = backup;
}
 
 
void
NumeReTerminal::OnLeftDown(wxMouseEvent& event)
{
    SetFocus();
    ClearSelection();
    m_selx1 = m_selx2 = event.GetX() / m_charWidth;
    m_sely1 = m_sely2 = event.GetY() / m_charHeight;
    m_selecting = true;
    this->CaptureMouse();
}
 
 
void NumeReTerminal::OnLoseMouseCapture(wxMouseCaptureLostEvent& event)
{
    if (this->GetCapture() == this)
    {
        m_selecting = false;
        this->ReleaseMouse();
        Refresh();
    }
}
 
 
void
NumeReTerminal::OnLeftUp(wxMouseEvent& event)
{
    m_selecting = false;
    if (this->GetCapture() == this)
    {
        this->ReleaseMouse();
        Refresh();
    }
    move_cursor_editable_area(m_selx2, m_sely2);
}
 
 
void
NumeReTerminal::OnMouseMove(wxMouseEvent& event)
{
    if (m_selecting)
    {
        // Get the text coordinates of the mouse
        m_selx2 = event.GetX() / m_charWidth;
 
        if (m_selx2 >= Width())
            m_selx2 = Width() - 1;
 
        m_sely2 = event.GetY() / m_charHeight;
 
        if (m_sely2 >= Height())
            m_sely2 = Height() - 1;
 
        // Mark the selections
        if (event.AltDown())
            MarkSelection(true);
        else
            MarkSelection();
 
        // Update the terminal
        // GenericTerminal::Update();
        Refresh();
    }
}
 
 
void NumeReTerminal::OnEnter(wxMouseEvent& event)
{
    if (g_findReplace != nullptr && g_findReplace->IsShown())
    {
        event.Skip();
        return;
    }
    this->SetFocus();
    event.Skip();
}
 
 
void
NumeReTerminal::ClearSelection()
{
    if (!HasSelection() || m_selecting)
        return;
 
    m_selx1 = m_sely1 = m_selx2 = m_sely2 = 0;
    GetTM()->unselectAll();
    Refresh();
}
 
 
void
NumeReTerminal::MarkSelection(bool bRectangular)
{
    int x;
    int y;
 
    m_marking = true;
 
    // First deselect all text
    GetTM()->unselectAll();
 
    // Now select the corresponding region
    if (bRectangular)
    {
        // Rectangular mode
        for (y = std::min(m_sely1, m_sely2); y <= std::max(m_sely1, m_sely2); y++)
        {
            for (x = std::min(m_selx1, m_selx2); x <= std::max(m_selx1, m_selx2); x++)
            {
                Select(x, y, 1);
            }
        }
    }
    else
    {
        // Line mode
        // More difficult
        if (m_sely1 == m_sely2)
        {
            for (x = std::min(m_selx1, m_selx2); x <= std::max(m_selx1, m_selx2); x++)
                Select(x, m_sely1, 1);
        }
        else if (m_sely1 < m_sely2)
        {
            for (x = m_selx1; x < Width(); x++)
                Select(x, m_sely1, 1);
 
            for (y = m_sely1 + 1; y < m_sely2; y++)
            {
                for (x = 0; x < Width(); x++)
                    Select(x, y, 1);
            }
 
            for (x = 0; x <= m_selx2; x++)
                Select(x, m_sely2, 1);
        }
        else
        {
            for (x = 0; x <= m_selx1; x++)
                Select(x, m_sely1, 1);
 
            for (y = m_sely2 + 1; y < m_sely1; y++)
            {
                for (x = 0; x < Width(); x++)
                    Select(x, y, 1);
            }
 
            for (x = m_selx2; x < Width(); x++)
                Select(x, m_sely2, 1);
        }
    }
 
    m_marking = false;
}
 
 
bool
NumeReTerminal::HasSelection()
{
    return (m_selx1 != m_selx2 || m_sely1 != m_sely2);
}
 
 
wxString
NumeReTerminal::GetSelection()
{
    wxString sel = get_selected_text();
 
    return sel;
}
 
 
void NumeReTerminal::copyText()
{
    // Get the selection and store it in the clipboard
    wxString sSelection = GetSelection();
 
    if (!sSelection.length())
        return;
 
    if (wxTheClipboard->Open())
    {
        wxTheClipboard->SetData(new wxTextDataObject(sSelection));
        wxTheClipboard->Close();
    }
}
 
 
void NumeReTerminal::pasteText()
{
    // Get the text from the clipboard and process it as new input
    if (wxTheClipboard->Open())
    {
        if (wxTheClipboard->IsSupported(wxDF_TEXT))
        {
            wxTextDataObject data;
            wxTheClipboard->GetData(data);
            NumeReTerminal::ProcessInput(data.GetTextLength(), data.GetText().ToStdString());
            Refresh();
        }
 
        wxTheClipboard->Close();
    }
}
 
 
void NumeReTerminal::cutText()
{
    this->copyText();
    delSelected();
    ClearSelection();
}
 
 
void
NumeReTerminal::DrawText(int fg_color, int bg_color, int flags, int x, int y, const std::string& sText)
{
    int
    t;
 
    // Overwrite the passed colors depending on the flags
    if (flags & SELECTED)
    {
        fg_color = 0;
        bg_color = 15;
    }
 
    if (flags & INVERSE)
    {
        t = fg_color;
        fg_color = bg_color;
        bg_color = t;
    }
 
    if (!m_curDC)
        return;
 
    // Convert std::string into wxString
    wxString
    str(sText);
 
    // Set the correct font
    if (m_boldStyle != FONT)
    {
        if (flags & UNDERLINE)
            m_curDC->SetFont(m_underlinedFont);
        else
            m_curDC->SetFont(m_normalFont);
    }
    else
    {
        if (flags & BOLD)
        {
            if (flags & UNDERLINE)
                m_curDC->SetFont(m_boldUnderlinedFont);
            else
                m_curDC->SetFont(m_boldFont);
        }
        else
        {
            if (flags & UNDERLINE)
                m_curDC->SetFont(m_underlinedFont);
            else
                m_curDC->SetFont(m_normalFont);
        }
    }
 
    // Convert x-y char coordinates into pixel coordinates
    x *= m_charWidth;
    y *= m_charHeight;
 
    // Set colors and background mode
    m_curDC->SetBackgroundMode(wxSOLID);
    m_curDC->SetTextBackground(m_colors[bg_color]);
    m_curDC->SetTextForeground(m_colors[fg_color]);
 
    // Draw the actual text
    m_curDC->DrawText(str, x, y);
    if (flags & BOLD && m_boldStyle == OVERSTRIKE)
        m_curDC->DrawText(str, x + 1, y);
}
 
 
void
NumeReTerminal::DoDrawCursor(int fg_color, int bg_color, int flags, int x, int y, unsigned char c)
{
    // Do nothing, if the terminal is scrolled up
    if (GenericTerminal::IsScrolledUp())
    {
        return;
    }
    int
    t;
 
    // Overwrite the passed colors depending on the flags
    if (flags & BOLD && m_boldStyle == COLOR)
        fg_color = (fg_color % 8) + 8;
 
    if (flags & INVERSE)
    {
        t = fg_color;
        fg_color = bg_color;
        bg_color = t;
    }
 
    if (!m_curDC)
        return;
 
    // Convert the character into wxString
    wxString
    str((char)c);
 
    // Set the correct font
    if (m_boldStyle != FONT)
    {
        if (flags & UNDERLINE)
            m_curDC->SetFont(m_underlinedFont);
        else
            m_curDC->SetFont(m_normalFont);
    }
    else
    {
        if (flags & BOLD)
        {
            if (flags & UNDERLINE)
                m_curDC->SetFont(m_boldUnderlinedFont);
            else
                m_curDC->SetFont(m_boldFont);
        }
        else
        {
            if (flags & UNDERLINE)
                m_curDC->SetFont(m_underlinedFont);
            else
                m_curDC->SetFont(m_normalFont);
        }
    }
 
    // Convert x-y char coordinates into pixel coordinates
    x *= m_charWidth;
    y *= m_charHeight;
 
    // Set colors and background mode
    m_curDC->SetBackgroundMode(wxSOLID);
    m_curDC->SetTextBackground(m_colors[fg_color]);
    m_curDC->SetTextForeground(m_colors[bg_color]);
 
    // Draw the actual text
    m_curDC->DrawText(str, x, y);
    if (flags & BOLD && m_boldStyle == OVERSTRIKE)
        m_curDC->DrawText(str, x + 1, y);
}
 
 
void
NumeReTerminal::DrawCursor(int fg_color, int bg_color, int flags, int x, int y, unsigned char c)
{
    // Set cursor-related member variables
    m_curX = x;
    m_curY = y;
    m_curFG = fg_color;
    m_curBG = bg_color,
    m_curFlags = flags;
    m_curChar = c;
 
    // Stop the timer
    if (m_timer.IsRunning())
        m_timer.Stop();
 
    // Draw the cursor at its position
    DoDrawCursor(fg_color, bg_color, flags, x, y, c);
 
    // Restart the timer
    if (m_curBlinkRate)
    {
        m_timer.Start(m_curBlinkRate);
        m_curState = 1;
    }
}
 
 
void
NumeReTerminal::OnTimer(wxTimerEvent& WXUNUSED(event))
{
    wxClientDC* dc = nullptr;
 
    if (m_init)
        return;
 
    // Do nothing if the cursor coordinates are invalid
    if (m_curX == -1 || m_curY == -1 || m_selecting)
        return;
 
    // Do nothing, if the cursor is invisible
    if (GetMode() & CURSORINVISIBLE)
    {
        //wxLogDebug("Skipping cursor");
        return;
    }
    //wxLogDebug("Drawing cursor");
    if (!m_curDC)
    {
        dc = new wxClientDC(this);
        m_curDC = dc;
    }
 
    // Draw the blinking cursor
    // Blinking is done by alternating fore and background colors
    if (m_curBlinkRate)
    {
        m_curState++;
        if (m_curState & 1 && m_curX != -1 && m_curY != -1)
            DoDrawCursor(m_curBG, m_curFG, m_curFlags, m_curX, m_curY, m_curChar);
        else
            DoDrawCursor(m_curFG, m_curBG, m_curFlags, m_curX, m_curY, m_curChar);
    }
 
    if (dc)
    {
        delete dc;
        m_curDC = nullptr;
    }
}
 
 
void NumeReTerminal::Calltip(int x, int y, NumeRe::CallTip& _cTip)
{
    // Convert x-y char coordinates into pixel coordinates
    // and compensate for an additional line
    x *= m_charWidth;
 
    // Consider here the possible shift due toe the fact that
    // the window could be below the bottom corner
    if ((y+2.1) > m_height) // m_height is already in character units
        y = (y-1) * m_charHeight - 2;
    else
        y = (y+1) * m_charHeight;
 
    m_callTip->PopUp(wxPoint(x, y), _cTip.sDefinition);
    m_callTip->Resize(wxSize(m_charWidth * (_cTip.sDefinition.length()+1.5), m_charHeight));
    m_callTip->Highlight(_cTip.nStart, _cTip.nEnd-_cTip.nStart);
}
 
 
void NumeReTerminal::CalltipCancel()
{
    m_callTip->Dismiss();
}
 
 
void
NumeReTerminal::ClearChars(int bg_color, int x, int y, int w, int h)
{
    x *= m_charWidth;
    y *= m_charHeight;
    w *= m_charWidth;
    h *= m_charHeight;
 
    if (!m_curDC)
        return;
 
    // Clear the area by drawing a rectangle with the background color
    m_curDC->SetPen(m_colorPens[bg_color]);
    m_curDC->SetBrush(wxBrush(m_colors[bg_color], wxSOLID));
    m_curDC->DrawRectangle(x, y, w /* + 1*/, h /*+ 1*/);
}
 
 
void
NumeReTerminal::ModeChange(int state)
{
    ClearSelection();
 
    m_colors = m_color_defs;
    m_colorPens = m_colorPen_defs;
 
    GenericTerminal::ModeChange(state);
}
 
 
void
NumeReTerminal::Bell()
{
#ifdef __WIN32__
    WinMessageBeep();
#else
    wxBell();
#endif
}
 
 
void NumeReTerminal::UpdateSize()
{
    // prevent any nasty recursion
    if (m_inUpdateSize)
    {
        return;
    }
 
    m_inUpdateSize = true;
    int charWidth, charHeight;
    wxClientDC* dc = nullptr;
 
    if (!m_curDC)
    {
        dc = new wxClientDC(this);
        m_curDC = dc;
    }
    else
        return;
 
    // Set the normal font
    dc->SetFont(m_boldFont);
 
    // Calculate the correct text extent
    dc->GetTextExtent(MEASURING_STRING, &charWidth, &charHeight); // EKHL: Changed because Heigth made no sense
    charWidth = std::rint(charWidth / (double)strlen(MEASURING_STRING));
 
    wxSize currentClientSize = GetClientSize();
 
    // Get the number of characters per line and the number of lines
    int numCharsInLine = currentClientSize.GetX() / charWidth;
    int numLinesShown = currentClientSize.GetY() / charHeight;
 
    // Update the size, if the calculated numbers are not matching the previous ones
    if ( (numCharsInLine != m_charsInLine) || (numLinesShown != m_linesDisplayed))
    {
        wxString message;
 
        // FINALLY!  Finally killed the memory leak!  The problem is that somehow a size event
        // was generating negative numbers for these values, which led to weird things happening.
        if ( (numCharsInLine > 0) && (numLinesShown > 0))
        {
            m_charsInLine = numCharsInLine;
            m_linesDisplayed = numLinesShown;
            // tell the GTerm core to resize itself
            ResizeTerminal(numCharsInLine, numLinesShown);
            {
                wxCriticalSectionLocker lock(m_kernelCS);
                _kernel.updateLineLenght(numCharsInLine);
            }
        }
    }
 
    m_inUpdateSize = false;
    Refresh();
 
    delete dc;
    m_curDC = nullptr;
}
 
 
void NumeReTerminal::UpdateColors()
{
    GetDefColors(m_color_defs);
 
    m_colors = m_color_defs;
 
    SetBackgroundColour(m_colors[0]);
    m_parent->SetBackgroundColour(m_colors[0]);
 
    for (int i = 0; i < 16; i++)
        m_colorPen_defs[i] = wxPen(m_color_defs[i], 1, wxSOLID);
 
    m_colorPens = m_colorPen_defs;
    update_changes();
    wxWindow::Update();
    m_parent->Update();
}
 
 
void
NumeReTerminal::ResizeTerminal(int width, int height)
{
    int
    w,
    h;
 
    ClearSelection();
 
    /*
    **  Determine window size from current font
    */
    wxClientDC
    dc(this);
 
    // Calculate text extents
    dc.SetFont(m_boldFont);
    dc.GetTextExtent(MEASURING_STRING, &m_charWidth, &m_charHeight); // EKHL: Changed because Height made no sense
    m_charWidth = std::rint(m_charWidth / (double)strlen(MEASURING_STRING));
 
    w = width * m_charWidth;
    h = height * m_charHeight;
 
    /*
    **  Create our bitmap for copying
    */
    if (m_bitmap)
    {
        m_memDC.SelectObject(wxNullBitmap);
        delete m_bitmap;
    }
    m_bitmap = new wxBitmap(w, h);
    m_memDC.SelectObject(*m_bitmap);
 
    /*
    **  Set window size
    */
    SetSize(w, h);
 
    /*
    **  Set terminal size
    */
    GenericTerminal::ResizeTerminal(width, height);
 
    m_width = width;
    m_height = height;
 
    /*
    **  Send event
    */
    if (!m_init)
    {
        wxCommandEvent e(wxEVT_COMMAND_TERM_RESIZE, GetId());
        e.SetEventObject(this);
        GetParent()->GetEventHandler()->ProcessEvent(e);
    }
}
 
 
 
void NumeReTerminal::ProcessInput(int len, const std::string& sData)
{
    scrollToInput();
 
    // Delete selected characters and/or remove
    // the selection
    if (HasSelection())
    {
        delSelected();
        ClearSelection();
    }
 
    wxClientDC
    dc(this);
 
    m_curDC = &dc;
    GenericTerminal::ProcessInput(len, sData);
    m_curDC = nullptr;
}
 
 
void NumeReTerminal::ProcessOutput(int len, const std::string& sData)
{
    if (HasSelection())
        ClearSelection();
    wxClientDC
    dc(this);
    m_curDC = &dc;
    GenericTerminal::ProcessOutput(len, sData);
    m_curDC = nullptr;
}
 
 
void NumeReTerminal::OnActivate(wxActivateEvent& event)
{
    m_isActive = event.GetActive();
}
 
 
void NumeReTerminal::OnGainFocus(wxFocusEvent& event)
{
    this->clear_mode_flag(CURSORINVISIBLE);
    GenericTerminal::Update();
}
 
 
void NumeReTerminal::OnLoseFocus(wxFocusEvent& event)
{
    this->set_mode_flag(CURSORINVISIBLE);
    GenericTerminal::Update();
}
 
 
void NumeReTerminal::Busy()
{
    m_isBusy = true;
    m_wxParent->Busy();
}
 
 
void NumeReTerminal::Ready()
{
    m_isBusy = false;
    m_wxParent->Ready();
}
 
 
void NumeReTerminal::ScrollTerminal(int numLines, bool scrollUp /* = true */)
{
    if (GenericTerminal::Scroll(numLines, scrollUp))
        Refresh();
}
 
 
void NumeReTerminal::OnSize(wxSizeEvent& event)
{
    UpdateSize();
}
 
 
void NumeReTerminal::UpdateRemoteSize(int width, int height)
{
}
 
 
void NumeReTerminal::clearTerminal()
{
    wxCriticalSectionLocker lock(m_kernelCS);
 
    // Reset terminal removes all lines
    GetTM()->Reset();
 
    // Print the version info same as during start of program
    _kernel.printVersionInfo();
}