#include <QLayout>
#include <QBoxLayout>
#include <QDir>
#include <QMessageBox>

#include "util/CharacterColor.h"
#include "Screen.h"
#include "ScreenWindow.h"
#include "Emulation.h"
#include "TerminalDisplay.h"
#include "Vt102Emulation.h"
#include "util/KeyboardTranslator.h"
#include "util/ColorScheme.h"
#include "util/SearchBar.h"
#include "konsole.h"


QTermWidget::QTermWidget(QWidget *messageParentWidget, QWidget *parent)
    : QWidget(parent) {
    m_layout = new QVBoxLayout(this);
    m_layout->setContentsMargins(0, 0, 0, 0);
    setLayout(m_layout);

    m_terminalDisplay = new TerminalDisplay(this);
    m_emulation = new Vt102Emulation();
    m_terminalDisplay->setBellMode(TerminalDisplay::SystemBeepBell);
    m_terminalDisplay->setTerminalSizeHint(true);
    m_terminalDisplay->setTripleClickMode(TerminalDisplay::SelectWholeLine);
    m_terminalDisplay->setTerminalSizeStartup(true);

    connect(m_terminalDisplay, &TerminalDisplay::keyPressedSignal, m_emulation, &Emulation::sendKeyEvent);
    connect(m_terminalDisplay, &TerminalDisplay::mouseSignal, m_emulation, &Emulation::sendMouseEvent);
    connect(m_terminalDisplay, &TerminalDisplay::sendStringToEmu, this, [this](const char* s){
        m_emulation->sendString(s);
    });
    connect(m_emulation, &Emulation::stateSet, this, &QTermWidget::activityStateSet);
    m_monitorTimer = new QTimer(this);
    m_monitorTimer->setSingleShot(true);
    connect(m_monitorTimer, &QTimer::timeout, this, &QTermWidget::monitorTimerDone);
    connect(m_emulation, &Emulation::programUsesMouseChanged, m_terminalDisplay, &TerminalDisplay::setUsesMouse);
    m_terminalDisplay->setUsesMouse(m_emulation->programUsesMouse());
    connect(m_emulation, &Emulation::programBracketedPasteModeChanged, m_terminalDisplay, &TerminalDisplay::setBracketedPasteMode);
    m_terminalDisplay->setBracketedPasteMode(m_emulation->programBracketedPasteMode());
    m_terminalDisplay->setScreenWindow(m_emulation->createWindow());
    connect(m_emulation, &Emulation::primaryScreenInUse, m_terminalDisplay, &TerminalDisplay::usingPrimaryScreen);
    connect(m_emulation, &Emulation::imageSizeChanged, this, [this](int /*height*/, int /*width*/){
        updateTerminalSize();
    });
    connect(m_terminalDisplay, &TerminalDisplay::changedContentSizeSignal, this, [this](int /*height*/, int /*width*/){
        updateTerminalSize();
    });

    setFlowControlEnabled(true);
    m_emulation->setCodec(QStringEncoder{QStringConverter::Encoding::Utf8});
    m_emulation->setHistory(HistoryTypeBuffer(1000));
    m_emulation->setKeyBindings(QString());

    m_layout->addWidget(m_terminalDisplay);
    m_terminalDisplay->setObjectName("terminalDisplay");
    setMessageParentWidget(messageParentWidget?messageParentWidget:this);

    connect(m_terminalDisplay, &TerminalDisplay::notifyBell, this, &QTermWidget::notifyBell);
    connect(m_terminalDisplay, &TerminalDisplay::handleCtrlC, this, &QTermWidget::handleCtrlC);
    connect(m_terminalDisplay, &TerminalDisplay::changedContentCountSignal, this, &QTermWidget::termSizeChange);
    connect(m_terminalDisplay, &TerminalDisplay::mousePressEventForwarded, this, &QTermWidget::mousePressEventForwarded);
    connect(m_emulation, &Emulation::profileChangeCommandReceived, this, &QTermWidget::profileChanged);
    connect(m_emulation, &Emulation::zmodemRecvDetected, this, &QTermWidget::zmodemRecvDetected);
    connect(m_emulation, &Emulation::zmodemSendDetected, this, &QTermWidget::zmodemSendDetected);
    connect(m_emulation, &Emulation::titleChanged, this, &QTermWidget::titleChanged);
    connect(m_emulation, &Emulation::sendData, this, [this](const char *buff, int len) {
        QByteArray data(buff, len);
        if (m_echo) {
            recvData(buff, len);
        }
        QByteArray dataCopy(buff, len);
        Q_EMIT sendData(dataCopy.constData(), dataCopy.length());
    });
    connect( m_emulation, &Emulation::dupDisplayOutput, this, &QTermWidget::dupDisplayOutput);
    connect( m_emulation, &Emulation::changeTabTextColorRequest, this, &QTermWidget::changeTabTextColorRequest);
    connect( m_emulation, &Emulation::cursorChanged, this, &QTermWidget::cursorChanged);

    m_urlFilter = new UrlFilter();
    connect(m_urlFilter, &UrlFilter::activated, this, &QTermWidget::urlActivated);
    m_terminalDisplay->filterChain()->addFilter(m_urlFilter);
    m_UrlFilterEnable = true;

    m_searchBar = new SearchBar(this);
    m_searchBar->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Maximum);
    connect(m_searchBar, &SearchBar::searchCriteriaChanged, this, [this](){
        search(true, false);
    });
    connect(m_searchBar, &SearchBar::findNext, this, [this](){
        search(true, true);
    });
    connect(m_searchBar, &SearchBar::findPrevious, this, [this](){
        search(false, false);
    });
    m_layout->addWidget(m_searchBar);
    m_searchBar->hide();
    QString style_sheet = qApp->styleSheet();
    m_searchBar->setStyleSheet(style_sheet);
    
    this->setFocus( Qt::OtherFocusReason );
    this->setFocusPolicy( Qt::WheelFocus );
    m_terminalDisplay->resize(this->size());

    this->setFocusProxy(m_terminalDisplay);
    connect(m_terminalDisplay, &TerminalDisplay::copyAvailable,
            this, &QTermWidget::copyAvailable);
    connect(m_terminalDisplay, &TerminalDisplay::termGetFocus,
            this, &QTermWidget::termGetFocus);
    connect(m_terminalDisplay, &TerminalDisplay::termLostFocus,
            this, &QTermWidget::termLostFocus);
    connect(m_terminalDisplay, &TerminalDisplay::keyPressedSignal, this, [this] (QKeyEvent* e, bool) { 
        Q_EMIT termKeyPressed(e);
    });

    setScrollBarPosition(NoScrollBar);
    setKeyboardCursorShape(Emulation::KeyboardCursorShape::BlockCursor);

    connect(m_emulation, &Emulation::imageResizeRequest, this, [this](const QSize& size){
        if ((size.width() <= 1) || (size.height() <= 1)) {
            return;
        }
        setSize(size);
    });
}

QTermWidget::~QTermWidget() {
    setUrlFilterEnabled(false);
    clearHighLightTexts();
    delete m_urlFilter;
    delete m_searchBar;
    Q_EMIT destroyed();
    delete m_emulation;
}

void QTermWidget::selectionChanged(bool textSelected) {
    Q_EMIT copyAvailable(textSelected);
}

void QTermWidget::search(bool forwards, bool next) {
    int startColumn, startLine;

    if (next) {
        m_terminalDisplay->screenWindow()->screen()->getSelectionEnd(startColumn, startLine);
        startColumn++;
    } else {
        m_terminalDisplay->screenWindow()->screen()->getSelectionStart(startColumn, startLine);
    }

    QRegularExpression regExp;
    if (m_searchBar->useRegularExpression()) {
        regExp.setPattern(m_searchBar->searchText());
    } else {
        regExp.setPattern(QRegularExpression::escape(m_searchBar->searchText()));
    }
    regExp.setPatternOptions(m_searchBar->matchCase() ? QRegularExpression::NoPatternOption : QRegularExpression::CaseInsensitiveOption);

    HistorySearch *historySearch =
            new HistorySearch(m_emulation, regExp, forwards, startColumn, startLine, this);
    connect(historySearch, &HistorySearch::matchFound, this, [this](int startColumn, int startLine, int endColumn, int endLine){
        ScreenWindow* sw = m_terminalDisplay->screenWindow();
        sw->scrollTo(startLine);
        sw->setTrackOutput(false);
        sw->notifyOutputChanged();
        sw->setSelectionStart(startColumn, startLine - sw->currentLine(), false);
        sw->setSelectionEnd(endColumn, endLine - sw->currentLine());
    });
    connect(historySearch, &HistorySearch::noMatchFound, this, [this](){
        m_terminalDisplay->screenWindow()->clearSelection();
    });
    connect(historySearch, &HistorySearch::noMatchFound, m_searchBar, &SearchBar::noMatchFound);
    historySearch->search();
}

QSize QTermWidget::sizeHint() const {
    QSize size = m_terminalDisplay->sizeHint();
    size.rheight() = 150;
    return size;
}

void QTermWidget::setTerminalSizeHint(bool enabled) {
    m_terminalDisplay->setTerminalSizeHint(enabled);
}

bool QTermWidget::terminalSizeHint() {
    return m_terminalDisplay->terminalSizeHint();
}

void QTermWidget::setTerminalFont(const QFont &font) {
    m_terminalDisplay->setVTFont(font);
}

QFont QTermWidget::getTerminalFont() {
    return m_terminalDisplay->getVTFont();
}

void QTermWidget::setTerminalOpacity(qreal level) {
    m_terminalDisplay->setOpacity(level);
}

void QTermWidget::setTerminalBackgroundImage(const QString& backgroundImage) {
    m_terminalDisplay->setBackgroundImage(backgroundImage);
}

void QTermWidget::setTerminalBackgroundMovie(const QString& backgroundMovie) {
    m_terminalDisplay->setBackgroundMovie(backgroundMovie);
}

void QTermWidget::setTerminalBackgroundVideo(const QString& backgroundVideo) {
    m_terminalDisplay->setBackgroundVideo(backgroundVideo);
}

void QTermWidget::setTerminalBackgroundMode(int mode) {
    m_terminalDisplay->setBackgroundMode((BackgroundMode)mode);
}

void QTermWidget::setTextCodec(QStringEncoder codec) {
    m_emulation->setCodec(std::move(codec));
}

void QTermWidget::setColorScheme(const QString& origName) {
    const ColorScheme *cs = nullptr;

    const bool isFile = QFile::exists(origName);
    const QString& name = isFile ? QFileInfo(origName).baseName() : origName;

    if (!availableColorSchemes().contains(name)) {
        if (isFile) {
            if (ColorSchemeManager::instance()->loadCustomColorScheme(origName))
                cs = ColorSchemeManager::instance()->findColorScheme(name);
        }

        if (!cs)
            cs = ColorSchemeManager::instance()->defaultColorScheme();
    } else {
        cs = ColorSchemeManager::instance()->findColorScheme(name);
    }

    if (! cs) {
        QMessageBox::information(messageParentWidget,
                                 tr("Color Scheme Error"),
                                 tr("Cannot load color scheme: %1").arg(name));
        return;
    }
    ColorEntry table[TABLE_COLORS];
    cs->getColorTable(table);
    m_terminalDisplay->setColorTable(table);
    m_hasDarkBackground = cs->hasDarkBackground();
}

QStringList QTermWidget::getAvailableColorSchemes() {
   return QTermWidget::availableColorSchemes();
}

QStringList QTermWidget::availableColorSchemes() {
    QStringList ret;
    const auto allColorSchemes = ColorSchemeManager::instance()->allColorSchemes();
    for (const ColorScheme* cs : allColorSchemes)
        ret.append(cs->name());
    return ret;
}

void QTermWidget::setBackgroundColor(const QColor &color) {
    m_terminalDisplay->setBackgroundColor(color);
}

void QTermWidget::setForegroundColor(const QColor &color) {
    m_terminalDisplay->setForegroundColor(color);
}

void QTermWidget::setANSIColor(const int ansiColorId, const QColor &color) {
    m_terminalDisplay->setColorTableColor(ansiColorId, color);
}

void QTermWidget::setPreeditColorIndex(int index) {
    m_terminalDisplay->setPreeditColorIndex(index);
}

void QTermWidget::setSize(const QSize &size) {
    m_terminalDisplay->setSize(size.width(), size.height());
}

void QTermWidget::setHistorySize(int lines) {
    if (lines <= 0)
        m_emulation->setHistory(HistoryTypeNone());
    else
        m_emulation->setHistory(HistoryTypeBuffer(lines));
}

int QTermWidget::historySize() const {
    const HistoryType& currentHistory = m_emulation->history();

     if (currentHistory.isEnabled()) {
         if (currentHistory.isUnlimited()) {
             return -1;
         } else {
             return currentHistory.maximumLineCount();
         }
     } else {
         return 0;
     }
}

void QTermWidget::setScrollBarPosition(ScrollBarPosition pos) {
    m_terminalDisplay->setScrollBarPosition(pos);
}

void QTermWidget::scrollToEnd() {
    m_terminalDisplay->scrollToEnd();
}

void QTermWidget::sendText(const QString &text) {
    m_emulation->sendText(text);
}

void QTermWidget::sendKeyEvent(QKeyEvent *e) {
    m_emulation->sendKeyEvent(e, false);
}

void QTermWidget::resizeEvent(QResizeEvent*) {
    m_terminalDisplay->resize(this->size());
}

void QTermWidget::sessionFinished() {
    Q_EMIT finished();
}

void QTermWidget::updateTerminalSize() {
    int minLines = -1;
    int minColumns = -1;

    const int VIEW_LINES_THRESHOLD = 2;
    const int VIEW_COLUMNS_THRESHOLD = 2;

    if ( m_terminalDisplay->isHidden() == false &&
            m_terminalDisplay->lines() >= VIEW_LINES_THRESHOLD &&
            m_terminalDisplay->columns() >= VIEW_COLUMNS_THRESHOLD ) {
        minLines = (minLines == -1) ? m_terminalDisplay->lines() : qMin( minLines , m_terminalDisplay->lines() );
        minColumns = (minColumns == -1) ? m_terminalDisplay->columns() : qMin( minColumns , m_terminalDisplay->columns() );
    }

    if ( minLines > 0 && minColumns > 0 ) {
        m_emulation->setImageSize( minLines , minColumns );
    }
}

void QTermWidget::monitorTimerDone() {
    if (m_monitorSilence) {
        Q_EMIT silence();
        Q_EMIT stateChanged(NOTIFYSILENCE);
    } else {
        Q_EMIT stateChanged(NOTIFYNORMAL);
    }

    m_notifiedActivity=false;
}

void QTermWidget::activityStateSet(int state) {
    if (state==NOTIFYBELL) {
        m_terminalDisplay->bell();
    } else if (state==NOTIFYACTIVITY) {
        if (m_monitorSilence) {
            m_monitorTimer->start(m_silenceSeconds*1000);
        }

        if ( m_monitorActivity ) {
            if (!m_notifiedActivity) {
                m_notifiedActivity=true;
                Q_EMIT activity();
            }
        }
    }

    if ( state==NOTIFYACTIVITY && !m_monitorActivity ) {
        state = NOTIFYNORMAL;
    }
    if ( state==NOTIFYSILENCE && !m_monitorSilence ) {
        state = NOTIFYNORMAL;
    }

    Q_EMIT stateChanged(state);
}

void QTermWidget::setMonitorActivity(bool enabled) {
    m_monitorActivity=enabled;
    m_notifiedActivity=false;

    activityStateSet(NOTIFYNORMAL);
}

void QTermWidget::setMonitorSilence(bool enabled) {
    if (m_monitorSilence==enabled) {
        return;
    }

    m_monitorSilence=enabled;
    if (m_monitorSilence) {
        m_monitorTimer->start(m_silenceSeconds*1000);
    } else {
        m_monitorTimer->stop();
    }

    activityStateSet(NOTIFYNORMAL);
}

void QTermWidget::setSilenceTimeout(int seconds) {
    m_silenceSeconds=seconds;
    if (m_monitorSilence) {
        m_monitorTimer->start(m_silenceSeconds*1000);
    }
}

void QTermWidget::bracketText(QString& text) {
    m_terminalDisplay->bracketText(text);
}

void QTermWidget::disableBracketedPasteMode(bool disable) {
    m_terminalDisplay->disableBracketedPasteMode(disable);
}

bool QTermWidget::bracketedPasteModeIsDisabled() const {
    return m_terminalDisplay->bracketedPasteModeIsDisabled();
}

void QTermWidget::copyClipboard() {
    m_terminalDisplay->copyClipboard(QClipboard::Clipboard);
}

void QTermWidget::copySelection() {
    m_terminalDisplay->copyClipboard(QClipboard::Selection);
}

void QTermWidget::pasteClipboard() {
    m_terminalDisplay->pasteClipboard();
}

void QTermWidget::pasteSelection() {
    m_terminalDisplay->pasteSelection();
}

void QTermWidget::selectAll() {
    m_terminalDisplay->selectAll();
}

int QTermWidget::setZoom(int step) {
    QFont font = m_terminalDisplay->getVTFont();

    font.setPointSize(font.pointSize() + step);
    setTerminalFont(font);
    return font.pointSize();
}

int QTermWidget::zoomIn() {
    return setZoom(STEP_ZOOM);
}

int QTermWidget::zoomOut() {
    return setZoom(-STEP_ZOOM);
}

void QTermWidget::setKeyBindings(const QString & kb) {
    m_emulation->setKeyBindings(kb);
}

void QTermWidget::clear() {
    clearScreen();
    clearScrollback();
}

void QTermWidget::clearScrollback() {
    m_emulation->clearHistory();
}

void QTermWidget::clearScreen() {
    m_emulation->reset();
}

void QTermWidget::setFlowControlEnabled(bool enabled) {
    if (m_flowControl == enabled)
        return;

    m_flowControl = enabled;

    Q_EMIT flowControlEnabledChanged(enabled);
}

bool QTermWidget::flowControlEnabled(void) {
    return m_flowControl;
}

void QTermWidget::setFlowControlWarningEnabled(bool enabled) {
    if (flowControlEnabled())
        m_terminalDisplay->setFlowControlWarningEnabled(enabled);
}

QStringList QTermWidget::availableKeyBindings() {
    return KeyboardTranslatorManager::instance()->allTranslators();
}

QString QTermWidget::keyBindings() {
    return m_emulation->keyBindings();
}

void QTermWidget::toggleShowSearchBar() {
    if(m_searchBar->isHidden()) {
        m_searchBar->setText(selectedText(true));
        m_searchBar->show();
    } else {
        m_searchBar->hide();
    }
}

void QTermWidget::setMotionAfterPasting(int action) {
    m_terminalDisplay->setMotionAfterPasting((MotionAfterPasting) action);
}

int QTermWidget::historyLinesCount() {
    return m_terminalDisplay->screenWindow()->screen()->getHistLines();
}

int QTermWidget::screenColumnsCount() {
    return m_terminalDisplay->screenWindow()->screen()->getColumns();
}

int QTermWidget::screenLinesCount() {
    return m_terminalDisplay->screenWindow()->screen()->getLines();
}

void QTermWidget::setSelectionStart(int row, int column) {
    m_terminalDisplay->screenWindow()->screen()->setSelectionStart(column, row, true);
}

void QTermWidget::setSelectionEnd(int row, int column) {
    m_terminalDisplay->screenWindow()->screen()->setSelectionEnd(column, row);
}

void QTermWidget::getSelectionStart(int& row, int& column) {
    m_terminalDisplay->screenWindow()->screen()->getSelectionStart(column, row);
}

void QTermWidget::getSelectionEnd(int& row, int& column) {
    m_terminalDisplay->screenWindow()->screen()->getSelectionEnd(column, row);
}

QString QTermWidget::selectedText(bool preserveLineBreaks) {
    return m_terminalDisplay->screenWindow()->screen()->selectedText(preserveLineBreaks);
}

Filter::HotSpot* QTermWidget::getHotSpotAt(const QPoint &pos) const {
    int row = 0, column = 0;
    m_terminalDisplay->getCharacterPosition(pos, row, column);
    return getHotSpotAt(row, column);
}

Filter::HotSpot* QTermWidget::getHotSpotAt(int row, int column) const {
    return m_terminalDisplay->filterChain()->hotSpotAt(row, column);
}

QList<QAction*> QTermWidget::filterActions(const QPoint& position) {
    return m_terminalDisplay->filterActions(position);
}

int QTermWidget::recvData(const char *buff, int len) const {
    m_emulation->receiveData( buff, len );
    return len;
}

void QTermWidget::setKeyboardCursorShape(KeyboardCursorShape shape) {
    m_terminalDisplay->setKeyboardCursorShape(shape);
}

void QTermWidget::setKeyboardCursorShape(uint32_t shape) {
    m_terminalDisplay->setKeyboardCursorShape((KeyboardCursorShape)shape);
}

void QTermWidget::setBlinkingCursor(bool blink) {
    m_terminalDisplay->setBlinkingCursor(blink);
}

void QTermWidget::setBidiEnabled(bool enabled) {
    m_terminalDisplay->setBidiEnabled(enabled);
}

bool QTermWidget::isBidiEnabled() {
    return m_terminalDisplay->isBidiEnabled();
}

void QTermWidget::cursorChanged(Emulation::KeyboardCursorShape cursorShape, bool blinkingCursorEnabled) {
    setKeyboardCursorShape(cursorShape);
    setBlinkingCursor(blinkingCursorEnabled);
}

void QTermWidget::setMargin(int margin) {
    m_terminalDisplay->setMargin(margin);
}

int QTermWidget::getMargin() const {
    return m_terminalDisplay->margin();
}

void QTermWidget::saveHistory(QTextStream *stream, int format, int start, int end) {
    TerminalCharacterDecoder *decoder;
    if(format == 0) {
        decoder = new PlainTextDecoder;
    } else {
        decoder = new HTMLDecoder;
    }
    decoder->begin(stream);
    if(start < 0) {
        start = 0;
    }
    if(end < 0) {
        end = m_emulation->lineCount();
    }
    m_emulation->writeToStream(decoder, start, end);
    delete decoder;
}

void QTermWidget::saveHistory(QIODevice *device, int format, int start, int end) {
    QTextStream stream(device);
    saveHistory(&stream, format, start, end);
}

void QTermWidget::screenShot(QPixmap *pixmap) {
    QPixmap currPixmap(m_terminalDisplay->size());
    m_terminalDisplay->render(&currPixmap);
    *pixmap = currPixmap.scaled(pixmap->size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
}

void QTermWidget::repaintDisplay(void) {
    m_terminalDisplay->repaintDisplay();
}

void QTermWidget::screenShot(const QString &fileName) {
    qreal deviceratio = m_terminalDisplay->devicePixelRatio();
    deviceratio = deviceratio*2;
    QPixmap pixmap(m_terminalDisplay->size() * deviceratio);
    pixmap.setDevicePixelRatio(deviceratio);
    m_terminalDisplay->render(&pixmap);
    pixmap.save(fileName);
}

void QTermWidget::setLocked(bool enabled) {
    this->setEnabled(!enabled);
    m_terminalDisplay->setLocked(enabled);
}

void QTermWidget::setDrawLineChars(bool drawLineChars) {
    m_terminalDisplay->setDrawLineChars(drawLineChars);
}

void QTermWidget::setBoldIntense(bool boldIntense) {
    m_terminalDisplay->setBoldIntense(boldIntense);
}

void QTermWidget::setConfirmMultilinePaste(bool confirmMultilinePaste) {
    m_terminalDisplay->setConfirmMultilinePaste(confirmMultilinePaste);
}

void QTermWidget::setTrimPastedTrailingNewlines(bool trimPastedTrailingNewlines) {
    m_terminalDisplay->setTrimPastedTrailingNewlines(trimPastedTrailingNewlines);
}

void QTermWidget::setEcho(bool echo) {
    m_echo = echo;
}

void QTermWidget::setKeyboardCursorColor(bool useForegroundColor, const QColor& color) {
    m_terminalDisplay->setKeyboardCursorColor(useForegroundColor, color);
}

void QTermWidget::addHighLightText(const QString &text, const QColor &color) {
    for (int i = 0; i < m_highLightTexts.size(); i++) {
        if (m_highLightTexts.at(i)->text == text) {
            return;
        }
    }
    HighLightText *highLightText = new HighLightText(text,color);
    m_highLightTexts.append(highLightText);
    m_terminalDisplay->filterChain()->addFilter(highLightText->regExpFilter);
    m_terminalDisplay->updateFilters();
    m_terminalDisplay->repaint();
}

QMap<QString, QColor> QTermWidget::getHighLightTexts(void) {
    QMap<QString, QColor> highLightTexts;
    for (int i = 0; i < m_highLightTexts.size(); i++) {
        highLightTexts.insert(m_highLightTexts.at(i)->text, m_highLightTexts.at(i)->color);
    }
    return highLightTexts;
}

bool QTermWidget::isContainHighLightText(const QString &text) {
    for (int i = 0; i < m_highLightTexts.size(); i++) {
        if (m_highLightTexts.at(i)->text == text) {
            return true;
        }
    }
    return false;
}

void QTermWidget::removeHighLightText(const QString &text) {
    for (int i = 0; i < m_highLightTexts.size(); i++) {
        if (m_highLightTexts.at(i)->text == text) {
            m_terminalDisplay->filterChain()->removeFilter(m_highLightTexts.at(i)->regExpFilter);
            delete m_highLightTexts.at(i);
            m_highLightTexts.removeAt(i);
            m_terminalDisplay->updateFilters();
            break;
        }
    }
    m_terminalDisplay->repaint();
}

void QTermWidget::clearHighLightTexts(void) {
    for (int i = 0; i < m_highLightTexts.size(); i++) {
        m_terminalDisplay->filterChain()->removeFilter(m_highLightTexts.at(i)->regExpFilter);
        delete m_highLightTexts.at(i);
    }
    m_terminalDisplay->updateFilters();
    m_highLightTexts.clear();
    m_terminalDisplay->repaint();
}

void QTermWidget::setWordCharacters(const QString &wordCharacters) {
    m_terminalDisplay->setWordCharacters(wordCharacters);
}

QString QTermWidget::wordCharacters(void) {
    return m_terminalDisplay->wordCharacters();
}

void QTermWidget::autoHideMouseAfter(int delay)
{
    m_terminalDisplay->autoHideMouseAfter(delay);
}

void QTermWidget::setShowResizeNotificationEnabled(bool enabled) {
    m_terminalDisplay->setShowResizeNotificationEnabled(enabled);
}

void QTermWidget::setEnableHandleCtrlC(bool enable) {
    m_emulation->setEnableHandleCtrlC(enable);
}

int QTermWidget::lines() {
    return m_terminalDisplay->lines();
}

int QTermWidget::columns() {
    return m_terminalDisplay->columns();
}

int QTermWidget::getCursorX() {
    return m_terminalDisplay->getCursorX();
}

int QTermWidget::getCursorY() {
    return m_terminalDisplay->getCursorY();
}

void QTermWidget::setCursorX(int x) {
    m_terminalDisplay->setCursorX(x);
}

void QTermWidget::setCursorY(int y) {
    m_terminalDisplay->setCursorY(y);
}

QString QTermWidget::screenGet(int row1, int col1, int row2, int col2, int mode) {
    return m_terminalDisplay->screenGet(row1, col1, row2, col2, mode);
}

void QTermWidget::setSelectionOpacity(qreal opacity) {
    m_terminalDisplay->setSelectionOpacity(opacity);
}

void QTermWidget::setUrlFilterEnabled(bool enable) {
    if(m_UrlFilterEnable == enable) {
        return;
    }
    if(enable) {
        m_terminalDisplay->filterChain()->addFilter(m_urlFilter);
    } else {
        m_terminalDisplay->filterChain()->removeFilter(m_urlFilter);
    }
}

void QTermWidget::setMessageParentWidget(QWidget *parent) {
    messageParentWidget = parent;
    m_terminalDisplay->setMessageParentWidget(messageParentWidget);
}

void QTermWidget::reTranslateUi(void) {
    m_searchBar->retranslateUi();
}

void QTermWidget::set_fix_quardCRT_issue33(bool fix) {
    m_terminalDisplay->set_fix_quardCRT_issue33(fix);
}