PanelRegion.cpp

#include "layout/PanelRegion.h"

#include "panels/DiagnosticsPanel.h"
#include "panels/OutputPanel.h"
#include "run/CodeRunner.h"
#include "settings/SettingsService.h"

#if defined(COLD_HAS_TERMINAL)
#include "terminal/VtermTerminalWidget.h"
#endif

#include <QDir>
#include <QLabel>
#include <QTabWidget>
#include <QTimer>
#include <QVBoxLayout>

namespace cold {

namespace {

bool isOffscreenPlatform() {
    return qgetenv("QT_QPA_PLATFORM") == "offscreen";
}

} // namespace

PanelRegion::PanelRegion(SettingsService& settings, CodeRunner& codeRunner, QWidget* parent)
    : QWidget(parent), m_settings(settings), m_codeRunner(codeRunner) {
    auto* layout = new QVBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);

    m_tabs = new QTabWidget(this);
    layout->addWidget(m_tabs);

#if defined(COLD_HAS_TERMINAL)
    m_terminal = new VtermTerminalWidget(m_settings, m_tabs);
    m_tabs->addTab(m_terminal, QStringLiteral("Terminal"));
#else
    m_terminalPlaceholder = new QWidget(m_tabs);
    auto* placeholderLayout = new QVBoxLayout(m_terminalPlaceholder);
    auto* label =
        new QLabel(QStringLiteral("Terminal requires building with -DCOLD_ENABLE_TERMINAL=ON"),
                   m_terminalPlaceholder);
    label->setAlignment(Qt::AlignCenter);
    placeholderLayout->addWidget(label);
    m_tabs->addTab(m_terminalPlaceholder, QStringLiteral("Terminal"));
#endif

    m_outputPanel = new OutputPanel(m_tabs);
    m_tabs->addTab(m_outputPanel, QStringLiteral("Output"));

    m_diagnosticsPanel = new DiagnosticsPanel(m_tabs);
    m_tabs->addTab(m_diagnosticsPanel, QStringLiteral("Problems"));

    connect(m_outputPanel, &OutputPanel::stopRequested, &m_codeRunner, &CodeRunner::cancel);

    connect(&m_codeRunner, &CodeRunner::runStarted, this, [this](const QString& summary) {
        m_outputPanel->clear();
        m_outputPanel->appendRunHeader(summary);
        showOutputTab();
    });
    connect(&m_codeRunner, &CodeRunner::outputLine, m_outputPanel, &OutputPanel::appendChannel);
    connect(&m_codeRunner, &CodeRunner::runFinished, m_outputPanel, &OutputPanel::showExitCode);
    connect(&m_codeRunner, &CodeRunner::runFailed, m_outputPanel, &OutputPanel::appendLine);
    connect(&m_codeRunner, &CodeRunner::runningChanged, m_outputPanel,
            &OutputPanel::setStopEnabled);

#if defined(COLD_HAS_TERMINAL)
    connect(m_tabs, &QTabWidget::currentChanged, this, [this](int index) {
        if (m_terminal && m_tabs->widget(index) == m_terminal) {
            m_terminal->refreshDisplay();
        }
    });

    if (!isOffscreenPlatform()) {
        QTimer::singleShot(0, this, [this]() { restartTerminal(QDir::homePath()); });
    }
#endif
}

OutputPanel* PanelRegion::outputPanel() const {
    return m_outputPanel;
}

DiagnosticsPanel* PanelRegion::diagnosticsPanel() const {
    return m_diagnosticsPanel;
}

#if defined(COLD_HAS_TERMINAL)
VtermTerminalWidget* PanelRegion::terminalWidget() const {
    return m_terminal;
}
#endif

void PanelRegion::setProjectRoot(const QString& root) {
    m_projectRoot = root;
}

void PanelRegion::showTerminalTab() {
#if defined(COLD_HAS_TERMINAL)
    m_tabs->setCurrentWidget(m_terminal);
#else
    m_tabs->setCurrentWidget(m_terminalPlaceholder);
#endif
}

void PanelRegion::showOutputTab() {
    m_tabs->setCurrentWidget(m_outputPanel);
}

void PanelRegion::showProblemsTab() {
    m_tabs->setCurrentWidget(m_diagnosticsPanel);
}

PanelPosition PanelRegion::panelPosition() const {
    return m_position;
}

void PanelRegion::setPanelPosition(PanelPosition position) {
    m_position = position;
}

void PanelRegion::onProjectOpened(const QString& rootPath) {
    setProjectRoot(rootPath);
#if defined(COLD_HAS_TERMINAL)
    restartTerminal(rootPath);
#endif
}

void PanelRegion::onProjectClosed() {
    setProjectRoot({});
#if defined(COLD_HAS_TERMINAL)
    if (m_terminal) {
        m_terminal->stopSession();
    }
#endif
}

void PanelRegion::restartTerminal(const QString& cwd) {
#if defined(COLD_HAS_TERMINAL)
    if (isOffscreenPlatform() || !m_terminal) {
        return;
    }
    m_terminal->stopSession();
    m_terminal->startSession(cwd);
#else
    Q_UNUSED(cwd);
#endif
}

} // namespace cold