File indexing completed on 2024-05-19 05:28:15

 /*
     SPDX-FileCopyrightText: 2007-2008 Robert Knight <robertknight@gmail.com>
     SPDX-FileCopyrightText: 1997, 1998 Lars Doelle <lars.doelle@on-line.de>
     SPDX-FileCopyrightText: 1996 Matthias Ettrich <ettrich@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 
     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.
 */
 
 // Own
 #include "Emulation.h"
 
 // System
 #include <cstdio>
 #include <cstdlib>
 #include <string>
 #include <unistd.h>
 
 // Qt
 #include <QApplication>
 #include <QClipboard>
 #include <QHash>
 #include <QKeyEvent>
 #include <QRegExp>
 #include <QTextStream>
 #include <QThread>
 
 #include <QTime>
 
 // KDE
 // #include <kdebug.h>
 
 // Konsole
 #include "KeyboardTranslator.h"
 #include "Screen.h"
 #include "ScreenWindow.h"
 #include "TerminalCharacterDecoder.h"
 
 using namespace Konsole;
 
 Emulation::Emulation()
     : _currentScreen(nullptr)
     , _codec(nullptr)
     , _decoder(nullptr)
     , _keyTranslator(nullptr)
     , _usesMouse(false)
     , _bracketedPasteMode(false)
 {
     // create screens with a default size
     _primaryScreen = std::make_unique<Screen>(40, 80);
     _alternateScreen = std::make_unique<Screen>(40, 80);
     _currentScreen = _primaryScreen.get();
 
     QObject::connect(&_bulkTimer1, &QTimer::timeout, this, &Emulation::showBulk);
     QObject::connect(&_bulkTimer2, &QTimer::timeout, this, &Emulation::showBulk);
 
     // listen for mouse status changes
     connect(this, &Emulation::programUsesMouseChanged, &Emulation::usesMouseChanged);
     connect(this, &Emulation::programBracketedPasteModeChanged, &Emulation::bracketedPasteModeChanged);
 
     connect(this, &Emulation::cursorChanged, [this](KeyboardCursorShape cursorShape, bool blinkingCursorEnabled) {
         Q_EMIT titleChanged(50,
                             QString(QLatin1String("CursorShape=%1;BlinkingCursorEnabled=%2")).arg(static_cast<int>(cursorShape)).arg(blinkingCursorEnabled));
     });
 }
 
 Emulation::~Emulation() = default;
 
 bool Emulation::programUsesMouse() const
 {
     return _usesMouse;
 }
 
 void Emulation::usesMouseChanged(bool usesMouse)
 {
     _usesMouse = usesMouse;
 }
 
 bool Emulation::programBracketedPasteMode() const
 {
     return _bracketedPasteMode;
 }
 
 void Emulation::bracketedPasteModeChanged(bool bracketedPasteMode)
 {
     _bracketedPasteMode = bracketedPasteMode;
 }
 
 ScreenWindow *Emulation::createWindow()
 {
     auto window = std::make_unique<ScreenWindow>();
     window->setScreen(_currentScreen);
 
     connect(window.get(), &ScreenWindow::selectionChanged, this, &Emulation::bufferedUpdate);
 
     connect(this, &Emulation::outputChanged, window.get(), &ScreenWindow::notifyOutputChanged);
 
     connect(this, &Emulation::handleCommandFromKeyboard, window.get(), &ScreenWindow::handleCommandFromKeyboard);
     connect(this, &Emulation::outputFromKeypressEvent, window.get(), &ScreenWindow::scrollToEnd);
 
     _windows.push_back(std::move(window));
 
     return _windows.back().get();
 }
 
 void Emulation::setScreen(int n)
 {
     Screen *old = _currentScreen;
     Screen *screens[2] = {_primaryScreen.get(), _alternateScreen.get()};
     _currentScreen = screens[n & 1];
     if (_currentScreen != old) {
         // tell all windows onto this emulation to switch to the newly active screen
         for (const auto &window : std::as_const(_windows))
             window->setScreen(_currentScreen);
     }
 }
 
 void Emulation::clearHistory()
 {
     _primaryScreen->setScroll(_primaryScreen->getScroll(), false);
 }
 void Emulation::setHistory(const HistoryType &t)
 {
     _primaryScreen->setScroll(t);
 
     showBulk();
 }
 
 const HistoryType &Emulation::history() const
 {
     return _primaryScreen->getScroll();
 }
 
 void Emulation::setCodec(const QTextCodec *qtc)
 {
     if (qtc)
         _codec = qtc;
     else
         setCodec(LocaleCodec);
 
     _decoder.reset();
     _decoder = std::unique_ptr<QTextDecoder>(_codec->makeDecoder());
 
     Q_EMIT useUtf8Request(utf8());
 }
 
 void Emulation::setCodec(EmulationCodec codec)
 {
     if (codec == Utf8Codec)
         setCodec(QTextCodec::codecForName("utf8"));
     else if (codec == LocaleCodec)
         setCodec(QTextCodec::codecForLocale());
 }
 
 void Emulation::setKeyBindings(const QString &name)
 {
     _keyTranslator = KeyboardTranslatorManager::instance()->findTranslator(name);
     if (!_keyTranslator) {
         _keyTranslator = KeyboardTranslatorManager::instance()->defaultTranslator();
     }
 }
 
 QString Emulation::keyBindings() const
 {
     return _keyTranslator->name();
 }
 
 void Emulation::receiveChar(QChar c)
 // process application unicode input to terminal
 // this is a trivial scanner
 {
     c.unicode() &= 0xff;
     switch (c.unicode()) {
     case '\b':
         _currentScreen->backspace();
         break;
     case '\t':
         _currentScreen->tab();
         break;
     case '\n':
         _currentScreen->newLine();
         break;
     case '\r':
         _currentScreen->toStartOfLine();
         break;
     case 0x07:
         Q_EMIT stateSet(NOTIFYBELL);
         break;
     default:
         _currentScreen->displayCharacter(c);
         break;
     };
 }
 
 void Emulation::sendKeyEvent(QKeyEvent *ev, bool)
 {
     Q_EMIT stateSet(NOTIFYNORMAL);
 
     if (!ev->text().isEmpty()) { // A block of text
         // Note that the text is proper unicode.
         // We should do a conversion here
         Q_EMIT sendData(ev->text().toUtf8().constData(), ev->text().length());
     }
 }
 
 void Emulation::sendString(const char *, int)
 {
     // default implementation does nothing
 }
 
 void Emulation::sendMouseEvent(int /*buttons*/, int /*column*/, int /*row*/, int /*eventType*/)
 {
     // default implementation does nothing
 }
 
 /*
    We are doing code conversion from locale to unicode first.
 TODO: Character composition from the old code.  See #96536
 */
 
 void Emulation::receiveData(const char *text, int length)
 {
     Q_EMIT stateSet(NOTIFYACTIVITY);
 
     bufferedUpdate();
 
     /* XXX: the following code involves encoding & decoding of "UTF-16
      * surrogate pairs", which does not work with characters higher than
      * U+10FFFF
      * https://unicodebook.readthedocs.io/unicode_encodings.html#surrogates
      */
     QString utf16Text = _decoder->toUnicode(text, length);
 
     // send characters to terminal emulator
     for (auto c : utf16Text) {
         receiveChar(c);
     }
 
     // look for z-modem indicator
     //-- someone who understands more about z-modems that I do may be able to move
     // this check into the above for loop?
     for (int i = 0; i < length; i++) {
         if (text[i] == '\030') {
             if ((length - i - 1 > 3) && (strncmp(text + i + 1, "B00", 3) == 0))
                 Q_EMIT zmodemDetected();
         }
     }
 }
 
 // OLDER VERSION
 // This version of onRcvBlock was commented out because
 //     a)  It decoded incoming characters one-by-one, which is slow in the current version of Qt (4.2 tech preview)
 //     b)  It messed up decoding of non-ASCII characters, with the result that (for example) chinese characters
 //         were not printed properly.
 //
 // There is something about stopping the _decoder if "we get a control code halfway a multi-byte sequence" (see below)
 // which hasn't been ported into the newer function (above).  Hopefully someone who understands this better
 // can find an alternative way of handling the check.
 
 /*void Emulation::onRcvBlock(const char *s, int len)
 {
   Q_EMIT notifySessionState(NOTIFYACTIVITY);
 
   bufferedUpdate();
   for (int i = 0; i < len; i++)
   {
 
     QString result = _decoder->toUnicode(&s[i],1);
     int reslen = result.length();
 
     // If we get a control code halfway a multi-byte sequence
     // we flush the _decoder and continue with the control code.
     if ((s[i] < 32) && (s[i] > 0))
     {
        // Flush _decoder
        while(!result.length())
           result = _decoder->toUnicode(&s[i],1);
        reslen = 1;
        result.resize(reslen);
        result[0] = QChar(s[i]);
     }
 
     for (int j = 0; j < reslen; j++)
     {
       if (result[j].characterategory() == QChar::Mark_NonSpacing)
          _currentScreen->compose(result.mid(j,1));
       else
          onRcvChar(result[j].unicode());
     }
     if (s[i] == '\030')
     {
       if ((len-i-1 > 3) && (strncmp(s+i+1, "B00", 3) == 0))
           Q_EMIT zmodemDetected();
     }
   }
 }*/
 
 void Emulation::writeToStream(TerminalCharacterDecoder *_decoder, int startLine, int endLine)
 {
     _currentScreen->writeLinesToStream(_decoder, startLine, endLine);
 }
 
 void Emulation::writeToStream(TerminalCharacterDecoder *_decoder)
 {
     _currentScreen->writeLinesToStream(_decoder, 0, _currentScreen->getHistLines());
 }
 
 int Emulation::lineCount() const
 {
     // sum number of lines currently on _screen plus number of lines in history
     return _currentScreen->getLines() + _currentScreen->getHistLines();
 }
 
 #define BULK_TIMEOUT1 10
 #define BULK_TIMEOUT2 40
 
 void Emulation::showBulk()
 {
     _bulkTimer1.stop();
     _bulkTimer2.stop();
 
     Q_EMIT outputChanged();
 
     _currentScreen->resetScrolledLines();
     _currentScreen->resetDroppedLines();
 }
 
 void Emulation::bufferedUpdate()
 {
     _bulkTimer1.setSingleShot(true);
     _bulkTimer1.start(BULK_TIMEOUT1);
     if (!_bulkTimer2.isActive()) {
         _bulkTimer2.setSingleShot(true);
         _bulkTimer2.start(BULK_TIMEOUT2);
     }
 }
 
 char Emulation::eraseChar() const
 {
     return '\b';
 }
 
 void Emulation::setImageSize(int lines, int columns)
 {
     if ((lines < 1) || (columns < 1))
         return;
 
     QSize screenSize[2] = {QSize(_primaryScreen->getColumns(), _primaryScreen->getLines()),
                            QSize(_alternateScreen->getColumns(), _alternateScreen->getLines())};
     QSize newSize(columns, lines);
 
     if (newSize == screenSize[0] && newSize == screenSize[1])
         return;
 
     _primaryScreen->resizeImage(lines, columns);
     _alternateScreen->resizeImage(lines, columns);
 
     Q_EMIT imageSizeChanged(lines, columns);
 
     bufferedUpdate();
 }
 
 QSize Emulation::imageSize() const
 {
     return {_currentScreen->getColumns(), _currentScreen->getLines()};
 }
 
 ushort ExtendedCharTable::extendedCharHash(ushort *unicodePoints, ushort length) const
 {
     ushort hash = 0;
     for (ushort i = 0; i < length; i++) {
         hash = 31 * hash + unicodePoints[i];
     }
     return hash;
 }
 bool ExtendedCharTable::extendedCharMatch(ushort hash, ushort *unicodePoints, ushort length) const
 {
     std::span entry = extendedCharTable.at(hash);
 
     // compare given length with stored sequence length ( given as the first ushort in the
     // stored buffer )
     if (entry.empty() || entry[0] != length)
         return false;
     // if the lengths match, each character must be checked.  the stored buffer starts at
     // entry[1]
     for (int i = 0; i < length; i++) {
         if (entry[i + 1] != unicodePoints[i])
             return false;
     }
     return true;
 }
 ushort ExtendedCharTable::createExtendedChar(ushort *unicodePoints, ushort length)
 {
     // look for this sequence of points in the table
     ushort hash = extendedCharHash(unicodePoints, length);
 
     // check existing entry for match
     while (extendedCharTable.contains(hash)) {
         if (extendedCharMatch(hash, unicodePoints, length)) {
             // this sequence already has an entry in the table,
             // return its hash
             return hash;
         } else {
             // if hash is already used by another, different sequence of unicode character
             // points then try next hash
             hash++;
         }
     }
 
     // add the new sequence to the table and
     // return that index
     std::vector<ushort> buffer(length + 1);
     buffer[0] = length;
     for (int i = 0; i < length; i++)
         buffer[i + 1] = unicodePoints[i];
 
     extendedCharTable.insert({hash, std::move(buffer)});
 
     return hash;
 }
 
 std::span<const ushort> ExtendedCharTable::lookupExtendedChar(ushort hash, ushort &length) const
 {
     // lookup index in table and if found, set the length
     // argument and return a pointer to the character sequence
 
     std::span buffer = extendedCharTable.at(hash);
     if (!buffer.empty()) {
         length = buffer[0];
         return buffer.subspan(1);
     } else {
         length = 0;
         return std::span<ushort>();
     }
 }
 
 ExtendedCharTable::ExtendedCharTable() = default;
 ExtendedCharTable::~ExtendedCharTable() = default;
 
 // global instance
 ExtendedCharTable ExtendedCharTable::instance;
 
 // #include "Emulation.moc"