aboutsummaryrefslogtreecommitdiffstats
path: root/src/plugins/terminal/terminalsurface.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/terminal/terminalsurface.cpp')
-rw-r--r--src/plugins/terminal/terminalsurface.cpp531
1 files changed, 531 insertions, 0 deletions
diff --git a/src/plugins/terminal/terminalsurface.cpp b/src/plugins/terminal/terminalsurface.cpp
new file mode 100644
index 0000000000..ea99430231
--- /dev/null
+++ b/src/plugins/terminal/terminalsurface.cpp
@@ -0,0 +1,531 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+
+#include "terminalsurface.h"
+
+#include "keys.h"
+#include "scrollback.h"
+
+#include <utils/qtcassert.h>
+
+#include <vterm.h>
+
+#include <QLoggingCategory>
+
+namespace Terminal::Internal {
+
+Q_LOGGING_CATEGORY(log, "qtc.terminal.surface", QtWarningMsg);
+
+QColor toQColor(const VTermColor &c)
+{
+ return QColor(qRgb(c.rgb.red, c.rgb.green, c.rgb.blue));
+};
+
+struct TerminalSurfacePrivate
+{
+ TerminalSurfacePrivate(TerminalSurface *surface,
+ const QSize &initialGridSize,
+ ShellIntegration *shellIntegration)
+ : m_vterm(vterm_new(initialGridSize.height(), initialGridSize.width()), vterm_free)
+ , m_vtermScreen(vterm_obtain_screen(m_vterm.get()))
+ , m_scrollback(std::make_unique<Internal::Scrollback>(5000))
+ , m_shellIntegration(shellIntegration)
+ , q(surface)
+ {}
+
+ void init()
+ {
+ vterm_set_utf8(m_vterm.get(), true);
+
+ static auto writeToPty = [](const char *s, size_t len, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ emit p->q->writeToPty(QByteArray(s, static_cast<int>(len)));
+ };
+
+ vterm_output_set_callback(m_vterm.get(), writeToPty, this);
+
+ memset(&m_vtermScreenCallbacks, 0, sizeof(m_vtermScreenCallbacks));
+
+ m_vtermScreenCallbacks.damage = [](VTermRect rect, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ p->invalidate(rect);
+ return 1;
+ };
+ m_vtermScreenCallbacks.sb_pushline = [](int cols, const VTermScreenCell *cells, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ return p->sb_pushline(cols, cells);
+ };
+ m_vtermScreenCallbacks.sb_popline = [](int cols, VTermScreenCell *cells, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ return p->sb_popline(cols, cells);
+ };
+ m_vtermScreenCallbacks.settermprop = [](VTermProp prop, VTermValue *val, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ return p->setTerminalProperties(prop, val);
+ };
+ m_vtermScreenCallbacks.movecursor =
+ [](VTermPos pos, VTermPos oldpos, int visible, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ return p->movecursor(pos, oldpos, visible);
+ };
+ m_vtermScreenCallbacks.sb_clear = [](void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ return p->sb_clear();
+ };
+ m_vtermScreenCallbacks.bell = [](void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ emit p->q->bell();
+ return 1;
+ };
+
+ vterm_screen_set_callbacks(m_vtermScreen, &m_vtermScreenCallbacks, this);
+ vterm_screen_set_damage_merge(m_vtermScreen, VTERM_DAMAGE_SCROLL);
+ vterm_screen_enable_altscreen(m_vtermScreen, true);
+
+ memset(&m_vtermStateFallbacks, 0, sizeof(m_vtermStateFallbacks));
+
+ m_vtermStateFallbacks.osc = [](int cmd, VTermStringFragment fragment, void *user) {
+ auto p = static_cast<TerminalSurfacePrivate *>(user);
+ return p->osc(cmd, fragment);
+ };
+
+ VTermState *vts = vterm_obtain_state(m_vterm.get());
+ vterm_state_set_unrecognised_fallbacks(vts, &m_vtermStateFallbacks, this);
+ vterm_state_set_bold_highbright(vts, true);
+
+ VTermColor fg;
+ VTermColor bg;
+ vterm_color_indexed(&fg, ColorIndex::Foreground);
+ vterm_color_indexed(&bg, ColorIndex::Background);
+ vterm_state_set_default_colors(vts, &fg, &bg);
+
+ for (int i = 0; i < 16; ++i) {
+ VTermColor col;
+ vterm_color_indexed(&col, i);
+ vterm_state_set_palette_color(vts, i, &col);
+ }
+
+ vterm_screen_reset(m_vtermScreen, 1);
+ }
+
+ QSize liveSize() const
+ {
+ int rows;
+ int cols;
+ vterm_get_size(m_vterm.get(), &rows, &cols);
+
+ return QSize(cols, rows);
+ }
+
+ std::variant<int, QColor> toVariantColor(const VTermColor &color)
+ {
+ if (color.type & VTERM_COLOR_DEFAULT_BG)
+ return ColorIndex::Background;
+ else if (color.type & VTERM_COLOR_DEFAULT_FG)
+ return ColorIndex::Foreground;
+ else if (color.type & VTERM_COLOR_INDEXED) {
+ if (color.indexed.idx >= 16) {
+ VTermColor c = color;
+ vterm_state_convert_color_to_rgb(vterm_obtain_state(m_vterm.get()), &c);
+ return toQColor(c);
+ }
+ return color.indexed.idx;
+ } else if (color.type == VTERM_COLOR_RGB)
+ return toQColor(color);
+ else
+ return -1;
+ }
+
+ TerminalCell toCell(const VTermScreenCell &cell)
+ {
+ TerminalCell result;
+ result.width = cell.width;
+ result.text = QString::fromUcs4(cell.chars);
+
+ const VTermColor *bg = &cell.bg;
+ const VTermColor *fg = &cell.fg;
+
+ if (static_cast<bool>(cell.attrs.reverse))
+ std::swap(fg, bg);
+
+ result.backgroundColor = toVariantColor(*bg);
+ result.foregroundColor = toVariantColor(*fg);
+
+ result.bold = cell.attrs.bold;
+ result.strikeOut = cell.attrs.strike;
+
+ if (cell.attrs.underline > 0) {
+ result.underlineStyle = QTextCharFormat::NoUnderline;
+ switch (cell.attrs.underline) {
+ case VTERM_UNDERLINE_SINGLE:
+ result.underlineStyle = QTextCharFormat::SingleUnderline;
+ break;
+ case VTERM_UNDERLINE_DOUBLE:
+ // TODO: Double underline
+ result.underlineStyle = QTextCharFormat::SingleUnderline;
+ break;
+ case VTERM_UNDERLINE_CURLY:
+ result.underlineStyle = QTextCharFormat::WaveUnderline;
+ break;
+ case VTERM_UNDERLINE_DASHED:
+ result.underlineStyle = QTextCharFormat::DashUnderline;
+ break;
+ case VTERM_UNDERLINE_DOTTED:
+ result.underlineStyle = QTextCharFormat::DotLine;
+ break;
+ }
+ }
+
+ result.strikeOut = cell.attrs.strike;
+
+ return result;
+ }
+
+ // Callbacks from vterm
+ void invalidate(VTermRect rect)
+ {
+ if (!m_altscreen) {
+ rect.start_row += m_scrollback->size();
+ rect.end_row += m_scrollback->size();
+ }
+
+ emit q->invalidated(
+ QRect{QPoint{rect.start_col, rect.start_row}, QPoint{rect.end_col, rect.end_row - 1}});
+ }
+
+ int sb_pushline(int cols, const VTermScreenCell *cells)
+ {
+ m_scrollback->emplace(cols, cells);
+ emit q->fullSizeChanged(q->fullSize());
+ return 1;
+ }
+
+ int sb_popline(int cols, VTermScreenCell *cells)
+ {
+ if (m_scrollback->size() == 0)
+ return 0;
+
+ m_scrollback->popto(cols, cells);
+ emit q->fullSizeChanged(q->fullSize());
+ return 1;
+ }
+
+ int sb_clear()
+ {
+ m_scrollback->clear();
+ emit q->fullSizeChanged(q->fullSize());
+ return 1;
+ }
+
+ int osc(int cmd, const VTermStringFragment &fragment)
+ {
+ if (m_shellIntegration)
+ m_shellIntegration->onOsc(cmd, fragment);
+
+ return 1;
+ }
+
+ int setTerminalProperties(VTermProp prop, VTermValue *val)
+ {
+ switch (prop) {
+ case VTERM_PROP_CURSORVISIBLE: {
+ Cursor old = q->cursor();
+ m_cursor.visible = val->boolean;
+ q->cursorChanged(old, q->cursor());
+ break;
+ }
+ case VTERM_PROP_CURSORBLINK: {
+ Cursor old = q->cursor();
+ m_cursor.blink = val->boolean;
+ emit q->cursorChanged(old, q->cursor());
+ break;
+ }
+ case VTERM_PROP_CURSORSHAPE: {
+ Cursor old = q->cursor();
+ m_cursor.shape = (Cursor::Shape) val->number;
+ emit q->cursorChanged(old, q->cursor());
+ break;
+ }
+ case VTERM_PROP_ICONNAME:
+ break;
+ case VTERM_PROP_TITLE:
+ break;
+ case VTERM_PROP_ALTSCREEN:
+ m_altscreen = val->boolean;
+ emit q->altscreenChanged(m_altscreen);
+ break;
+ case VTERM_PROP_MOUSE:
+ qCDebug(log) << "Ignoring VTERM_PROP_MOUSE" << val->number;
+ break;
+ case VTERM_PROP_REVERSE:
+ qCDebug(log) << "Ignoring VTERM_PROP_REVERSE" << val->boolean;
+ break;
+ case VTERM_N_PROPS:
+ break;
+ }
+ return 1;
+ }
+ int movecursor(VTermPos pos, VTermPos oldpos, int visible)
+ {
+ Q_UNUSED(oldpos);
+ Cursor oldCursor = q->cursor();
+ m_cursor.position = {pos.col, pos.row};
+ m_cursor.visible = visible > 0;
+ q->cursorChanged(oldCursor, q->cursor());
+ return 1;
+ }
+
+ const VTermScreenCell *cellAt(int x, int y)
+ {
+ QTC_ASSERT(y >= 0 && x >= 0, return nullptr);
+ QTC_ASSERT(y < q->fullSize().height() && x < liveSize().width(), return nullptr);
+
+ if (!m_altscreen && y < m_scrollback->size()) {
+ const auto &sbl = m_scrollback->line((m_scrollback->size() - 1) - y);
+ if (x < sbl.cols()) {
+ return sbl.cell(x);
+ }
+ return nullptr;
+ }
+
+ if (!m_altscreen)
+ y -= m_scrollback->size();
+
+ static VTermScreenCell refCell{};
+ VTermPos vtp{y, x};
+ vterm_screen_get_cell(m_vtermScreen, vtp, &refCell);
+
+ return &refCell;
+ }
+
+ std::unique_ptr<VTerm, void (*)(VTerm *)> m_vterm;
+ VTermScreen *m_vtermScreen;
+ VTermScreenCallbacks m_vtermScreenCallbacks;
+ VTermStateFallbacks m_vtermStateFallbacks;
+
+ Cursor m_cursor;
+ QString m_currentCommand;
+
+ bool m_altscreen{false};
+
+ std::unique_ptr<Internal::Scrollback> m_scrollback;
+
+ ShellIntegration *m_shellIntegration{nullptr};
+
+ TerminalSurface *q;
+};
+
+TerminalSurface::TerminalSurface(QSize initialGridSize, ShellIntegration *shellIntegration)
+ : d(std::make_unique<TerminalSurfacePrivate>(this, initialGridSize, shellIntegration))
+{
+ d->init();
+}
+
+TerminalSurface::~TerminalSurface() = default;
+
+int TerminalSurface::cellWidthAt(int x, int y) const
+{
+ const VTermScreenCell *cell = d->cellAt(x, y);
+ if (!cell)
+ return 0;
+ return cell->width;
+}
+
+QSize TerminalSurface::liveSize() const
+{
+ return d->liveSize();
+}
+
+QSize TerminalSurface::fullSize() const
+{
+ if (d->m_altscreen)
+ return liveSize();
+ return QSize{d->liveSize().width(), d->liveSize().height() + d->m_scrollback->size()};
+}
+
+std::u32string::value_type TerminalSurface::fetchCharAt(int x, int y) const
+{
+ const VTermScreenCell *cell = d->cellAt(x, y);
+ if (!cell)
+ return 0;
+
+ if (cell->width == 0)
+ return 0;
+
+ QString s = QString::fromUcs4(cell->chars, 6).normalized(QString::NormalizationForm_C);
+ const QList<uint> ucs4 = s.toUcs4();
+ return std::u32string(ucs4.begin(), ucs4.end()).front();
+}
+
+TerminalCell TerminalSurface::fetchCell(int x, int y) const
+{
+ static TerminalCell emptyCell{1,
+ {},
+ {},
+ false,
+ ColorIndex::Foreground,
+ ColorIndex::Background,
+ QTextCharFormat::NoUnderline,
+ false};
+
+ QTC_ASSERT(y >= 0, return emptyCell);
+ QTC_ASSERT(y < fullSize().height() && x < fullSize().width(), return emptyCell);
+
+ const VTermScreenCell *refCell = d->cellAt(x, y);
+ if (!refCell)
+ return emptyCell;
+
+ return d->toCell(*refCell);
+}
+
+void TerminalSurface::clearAll()
+{
+ // Fake a scrollback clearing
+ QByteArray data{"\x1b[3J"};
+ vterm_input_write(d->m_vterm.get(), data.constData(), data.size());
+
+ // Send Ctrl+L which will clear the screen
+ emit writeToPty(QByteArray("\f"));
+}
+
+void TerminalSurface::resize(QSize newSize)
+{
+ vterm_set_size(d->m_vterm.get(), newSize.height(), newSize.width());
+}
+
+QPoint TerminalSurface::posToGrid(int pos) const
+{
+ return {pos % d->liveSize().width(), pos / d->liveSize().width()};
+}
+int TerminalSurface::gridToPos(QPoint gridPos) const
+{
+ return gridPos.y() * d->liveSize().width() + gridPos.x();
+}
+
+void TerminalSurface::dataFromPty(const QByteArray &data)
+{
+ vterm_input_write(d->m_vterm.get(), data.constData(), data.size());
+ vterm_screen_flush_damage(d->m_vtermScreen);
+}
+
+void TerminalSurface::flush()
+{
+ vterm_screen_flush_damage(d->m_vtermScreen);
+}
+
+void TerminalSurface::pasteFromClipboard(const QString &clipboardText)
+{
+ if (clipboardText.isEmpty())
+ return;
+
+ vterm_keyboard_start_paste(d->m_vterm.get());
+ for (unsigned int ch : clipboardText.toUcs4())
+ vterm_keyboard_unichar(d->m_vterm.get(), ch, VTERM_MOD_NONE);
+ vterm_keyboard_end_paste(d->m_vterm.get());
+
+ if (!d->m_altscreen) {
+ emit unscroll();
+ }
+}
+
+void TerminalSurface::sendKey(Qt::Key key)
+{
+ if (key == Qt::Key_Escape)
+ vterm_keyboard_key(d->m_vterm.get(), VTERM_KEY_ESCAPE, VTERM_MOD_NONE);
+}
+
+void TerminalSurface::sendKey(const QString &text)
+{
+ for (const unsigned int ch : text.toUcs4())
+ vterm_keyboard_unichar(d->m_vterm.get(), ch, VTERM_MOD_NONE);
+}
+
+void TerminalSurface::sendKey(QKeyEvent *event)
+{
+ bool keypad = event->modifiers() & Qt::KeypadModifier;
+ VTermModifier mod = Internal::qtModifierToVTerm(event->modifiers());
+ VTermKey key = Internal::qtKeyToVTerm(Qt::Key(event->key()), keypad);
+
+ if (key != VTERM_KEY_NONE) {
+ if (mod == VTERM_MOD_SHIFT && (key == VTERM_KEY_ESCAPE || key == VTERM_KEY_BACKSPACE))
+ mod = VTERM_MOD_NONE;
+
+ vterm_keyboard_key(d->m_vterm.get(), key, mod);
+ } else if (event->text().length() == 1) {
+ // This maps to delete word and is way to easy to mistakenly type
+ // if (event->key() == Qt::Key_Space && mod == VTERM_MOD_SHIFT)
+ // mod = VTERM_MOD_NONE;
+
+ // Per https://github.com/justinmk/neovim/commit/317d5ca7b0f92ef42de989b3556ca9503f0a3bf6
+ // libvterm prefers we send the full keycode rather than sending the
+ // ctrl modifier. This helps with ncurses applications which otherwise
+ // do not recognize ctrl+<key> and in the shell for getting common control characters
+ // like ctrl+i for tab or ctrl+j for newline.
+
+ // Workaround for "ALT+SHIFT+/" (\ on german mac keyboards)
+ if (mod == (VTERM_MOD_SHIFT | VTERM_MOD_ALT) && event->key() == Qt::Key_Slash) {
+ mod = VTERM_MOD_NONE;
+ }
+
+ vterm_keyboard_unichar(d->m_vterm.get(), event->text().toUcs4()[0], VTERM_MOD_NONE);
+ } else if (mod == VTERM_MOD_CTRL && event->key() >= Qt::Key_A && event->key() < Qt::Key_Z) {
+ vterm_keyboard_unichar(d->m_vterm.get(), 'a' + (event->key() - Qt::Key_A), mod);
+ }
+}
+
+Cursor TerminalSurface::cursor() const
+{
+ Cursor cursor = d->m_cursor;
+ if (!d->m_altscreen)
+ cursor.position.setY(cursor.position.y() + d->m_scrollback->size());
+
+ return cursor;
+}
+
+ShellIntegration *TerminalSurface::shellIntegration() const
+{
+ return d->m_shellIntegration;
+}
+
+CellIterator TerminalSurface::begin() const
+{
+ auto res = CellIterator(this, {0, 0});
+ res.m_state = CellIterator::State::BEGIN;
+ return res;
+}
+
+CellIterator TerminalSurface::end() const
+{
+ return CellIterator(this);
+}
+
+std::reverse_iterator<CellIterator> TerminalSurface::rbegin() const
+{
+ return std::make_reverse_iterator(end());
+}
+
+std::reverse_iterator<CellIterator> TerminalSurface::rend() const
+{
+ return std::make_reverse_iterator(begin());
+}
+
+CellIterator TerminalSurface::iteratorAt(QPoint pos) const
+{
+ return CellIterator(this, pos);
+}
+CellIterator TerminalSurface::iteratorAt(int pos) const
+{
+ return CellIterator(this, pos);
+}
+
+std::reverse_iterator<CellIterator> TerminalSurface::rIteratorAt(QPoint pos) const
+{
+ return std::make_reverse_iterator(iteratorAt(pos));
+}
+
+std::reverse_iterator<CellIterator> TerminalSurface::rIteratorAt(int pos) const
+{
+ return std::make_reverse_iterator(iteratorAt(pos));
+}
+
+} // namespace Terminal::Internal