FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// src/screens/code_editor/CodeEditorScreen_Cells.cpp
//
// CodeTextEdit (lightweight QTextEdit subclass) + CellWidget (per-cell view).
// Both classes are declared in CodeEditorScreen.h and live here as a
// partial-class split — the file in their own folder grouping by widget
// responsibility.
#include "core/keys/KeyConfigManager.h"
#include "core/logging/Logger.h"
#include "core/session/ScreenStateManager.h"
#include "screens/code_editor/CodeEditorScreen.h"
#include "services/file_manager/FileManagerService.h"
#include "ui/theme/Theme.h"
#include <QAbstractTextDocumentLayout>
#include <QAction>
#include <QApplication>
#include <QFileDialog>
#include <QFileInfo>
#include <QHBoxLayout>
#include <QInputDialog>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QKeyEvent>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPushButton>
#include <QScrollArea>
#include <QScrollBar>
#include <QSplitter>
#include <QTextBlock>
#include <QTextCharFormat>
#include <QTextCursor>
#include <QTextDocument>
#include <QToolButton>
#include <QVBoxLayout>
namespace fincept::screens {
using namespace fincept::ui;
// ═════════════════════════════════════════════════════════════════════════════
CodeTextEdit::CodeTextEdit(QWidget* parent) : QTextEdit(parent) {}
void CodeTextEdit::keyPressEvent(QKeyEvent* event) {
auto& km = KeyConfigManager::instance();
const QKeySequence pressed(event->keyCombination());
if (pressed == km.key(KeyAction::RunCell)) {
emit run_shortcut();
return;
}
if (pressed == km.key(KeyAction::RunAndNext)) {
emit run_and_next();
return;
}
// Tab inserts 4 spaces
if (event->key() == Qt::Key_Tab && !(event->modifiers() & Qt::ShiftModifier)) {
insertPlainText(" ");
return;
}
QTextEdit::keyPressEvent(event);
}
// ═════════════════════════════════════════════════════════════════════════════
// CellWidget
// ═════════════════════════════════════════════════════════════════════════════
CellWidget::CellWidget(const NotebookCell& cell, int index, QWidget* parent)
: QWidget(parent),
cell_id_(cell.id),
cell_type_(cell.cell_type),
execution_count_(cell.execution_count),
index_(index) {
build_ui();
set_cell_data(cell);
}
void CellWidget::build_ui() {
auto* root = new QVBoxLayout(this);
root->setContentsMargins(0, 2, 0, 2);
root->setSpacing(0);
// ── Main cell row: [gutter] [editor] ──
auto* cell_row = new QWidget(this);
auto* row_layout = new QHBoxLayout(cell_row);
row_layout->setContentsMargins(0, 0, 0, 0);
row_layout->setSpacing(0);
// ── Gutter ──
gutter_ = new QWidget(cell_row);
gutter_->setFixedWidth(56);
gutter_->setStyleSheet(QString("background:%1;").arg(colors::BG_RAISED()));
auto* gutter_layout = new QVBoxLayout(gutter_);
gutter_layout->setContentsMargins(0, 4, 6, 2);
gutter_layout->setSpacing(2);
gutter_layout->setAlignment(Qt::AlignTop | Qt::AlignRight);
gutter_number_ = new QLabel("[ ]", gutter_);
gutter_number_->setAlignment(Qt::AlignRight | Qt::AlignTop);
gutter_number_->setStyleSheet(
QString("color:%1; font-family:%2; font-size:%3px; font-weight:700; background:transparent;")
.arg(colors::TEXT_TERTIARY(), fonts::DATA_FAMILY)
.arg(fonts::TINY));
gutter_layout->addWidget(gutter_number_);
gutter_type_ = new QLabel("PY", gutter_);
gutter_type_->setAlignment(Qt::AlignRight);
gutter_type_->setStyleSheet(QString("color:%1; font-family:%2; font-size:10px; font-weight:600;"
" letter-spacing:0.5px; background:transparent;")
.arg(colors::TEXT_DIM(), fonts::DATA_FAMILY));
gutter_layout->addWidget(gutter_type_);
gutter_layout->addStretch();
row_layout->addWidget(gutter_);
// ── Editor container ──
editor_container_ = new QWidget(cell_row);
auto* editor_vbox = new QVBoxLayout(editor_container_);
editor_vbox->setContentsMargins(0, 0, 0, 0);
editor_vbox->setSpacing(0);
// Toolbar — always occupies 24px to prevent layout shift; buttons hide/show
toolbar_ = new QWidget(editor_container_);
toolbar_->setFixedHeight(24);
toolbar_->setStyleSheet(QString("background:%1;").arg(colors::BG_RAISED()));
auto* tb_layout = new QHBoxLayout(toolbar_);
tb_layout->setContentsMargins(8, 0, 8, 0);
tb_layout->setSpacing(2);
auto make_tool_btn = [&](const QString& text, const QString& fg_color) -> QPushButton* {
auto* btn = new QPushButton(text, toolbar_);
btn->setFixedHeight(20);
btn->setCursor(Qt::PointingHandCursor);
btn->setAccessibleName(text); // two-letter labels are opaque to a screen reader alone
btn->setVisible(false); // hidden until hover
btn->setStyleSheet(QString("QPushButton { background:transparent; color:%1; border:none;"
" font-family:%2; font-size:%3px; font-weight:600; padding:0 8px;"
" letter-spacing:0.5px; }"
"QPushButton:hover { background:%4; color:%5; }")
.arg(fg_color, fonts::DATA_FAMILY)
.arg(fonts::TINY)
.arg(colors::BG_HOVER(), colors::TEXT_PRIMARY()));
return btn;
};
run_btn_ = make_tool_btn(tr("RUN"), colors::POSITIVE);
run_btn_->setAccessibleName(tr("Run this cell"));
connect(run_btn_, &QPushButton::clicked, this, [this]() { emit run_requested(cell_id_); });
tb_layout->addWidget(run_btn_);
type_btn_ = make_tool_btn(tr("TYPE"), colors::CYAN);
type_btn_->setAccessibleName(tr("Switch between code and markdown"));
type_btn_->setToolTip(tr("Switch between code and markdown (clears this cell's output)"));
connect(type_btn_, &QPushButton::clicked, this, [this]() { emit toggle_type_requested(cell_id_); });
tb_layout->addWidget(type_btn_);
up_btn_ = make_tool_btn(tr("UP"), colors::TEXT_SECONDARY);
up_btn_->setAccessibleName(tr("Move this cell up"));
connect(up_btn_, &QPushButton::clicked, this, [this]() { emit move_up_requested(cell_id_); });
tb_layout->addWidget(up_btn_);
dn_btn_ = make_tool_btn(tr("DN"), colors::TEXT_SECONDARY);
dn_btn_->setAccessibleName(tr("Move this cell down"));
connect(dn_btn_, &QPushButton::clicked, this, [this]() { emit move_down_requested(cell_id_); });
tb_layout->addWidget(dn_btn_);
tb_layout->addStretch();
del_btn_ = make_tool_btn(tr("DEL"), colors::NEGATIVE);
del_btn_->setAccessibleName(tr("Delete this cell"));
connect(del_btn_, &QPushButton::clicked, this, [this]() { emit delete_requested(cell_id_); });
tb_layout->addWidget(del_btn_);
editor_vbox->addWidget(toolbar_);
// ── Code editor ──
editor_ = new CodeTextEdit(editor_container_);
editor_->setAcceptRichText(false);
editor_->setTabStopDistance(28);
editor_->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
editor_->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
editor_->setLineWrapMode(QTextEdit::NoWrap);
editor_->setStyleSheet(QString("QTextEdit { background:%1; color:%2; border:none;"
" font-family:%3, 'Menlo', 'SF Mono', 'Courier New', monospace;"
" font-size:%4px; padding:8px 12px;"
" selection-background-color:%5; }"
"QScrollBar:vertical { background:%1; width:5px; }"
"QScrollBar::handle:vertical { background:%6; min-height:20px; }"
"QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height:0; }"
"QScrollBar:horizontal { background:%1; height:5px; }"
"QScrollBar::handle:horizontal { background:%6; min-width:20px; }"
"QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal { width:0; }")
.arg(colors::BG_SURFACE(), colors::TEXT_PRIMARY(), fonts::DATA_FAMILY)
.arg(fonts::DATA)
.arg(colors::AMBER_DIM(), colors::BORDER_BRIGHT()));
editor_->document()->setDocumentMargin(2);
editor_->setAccessibleName(tr("Notebook cell source"));
editor_->setAccessibleDescription(
tr("Python source. Ctrl+Enter runs this cell, Shift+Enter runs it and moves to the next."));
// Keyboard shortcuts
connect(editor_, &CodeTextEdit::run_shortcut, this, [this]() { emit run_requested(cell_id_); });
connect(editor_, &CodeTextEdit::run_and_next, this, [this]() { emit run_and_advance(cell_id_); });
// Responsive height on every content change
connect(editor_->document()->documentLayout(), &QAbstractTextDocumentLayout::documentSizeChanged, this,
[this](const QSizeF&) { adjust_editor_height(); });
editor_vbox->addWidget(editor_);
// ── Markdown preview (for MD cells, shown when not editing) ──
md_preview_ = new QTextBrowser(editor_container_);
md_preview_->setOpenExternalLinks(true);
md_preview_->setReadOnly(true);
md_preview_->setVisible(false);
md_preview_->setStyleSheet(QString("QTextBrowser { background:%1; color:%2; border:none;"
" font-family:%3; font-size:%4px; padding:10px 12px; }"
"QScrollBar:vertical { background:%1; width:5px; }"
"QScrollBar::handle:vertical { background:%5; min-height:20px; }"
"QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height:0; }")
.arg(colors::BG_SURFACE(), colors::TEXT_PRIMARY(), fonts::DATA_FAMILY)
.arg(fonts::DATA)
.arg(colors::BORDER_BRIGHT()));
// Click on the rendered preview to drop back into the source editor.
// QTextBrowser swallows the press, so CellWidget::mousePressEvent never
// fires for it — the filter below (see eventFilter) is what makes this work.
md_preview_->installEventFilter(this);
md_preview_->setCursor(Qt::IBeamCursor);
md_preview_->setToolTip(tr("Click to edit this markdown cell"));
editor_vbox->addWidget(md_preview_);
row_layout->addWidget(editor_container_, 1);
root->addWidget(cell_row);
// ── Output area ──
auto* output_row = new QWidget(this);
auto* output_row_layout = new QHBoxLayout(output_row);
output_row_layout->setContentsMargins(0, 0, 0, 0);
output_row_layout->setSpacing(0);
auto* output_gutter = new QWidget(output_row);
output_gutter->setFixedWidth(56);
output_row_layout->addWidget(output_gutter);
output_area_ = new QWidget(output_row);
auto* output_vbox = new QVBoxLayout(output_area_);
output_vbox->setContentsMargins(0, 0, 0, 0);
output_vbox->setSpacing(0);
// Output header with collapse toggle
output_toggle_ = new QPushButton(tr("OUTPUT"), output_area_);
output_toggle_->setFixedHeight(22);
output_toggle_->setCursor(Qt::PointingHandCursor);
output_toggle_->setStyleSheet(
QString("QPushButton { background:%1; color:%2; border:none; border-left:3px solid %3;"
" font-family:%4; font-size:10px; font-weight:700; letter-spacing:0.5px;"
" padding:0 10px; text-align:left; }"
"QPushButton:hover { background:%5; }")
.arg(colors::BG_RAISED(), colors::POSITIVE(), colors::BORDER_DIM(), fonts::DATA_FAMILY,
colors::BG_HOVER()));
output_toggle_->setVisible(false);
connect(output_toggle_, &QPushButton::clicked, this, [this]() {
output_collapsed_ = !output_collapsed_;
output_content_->setVisible(!output_collapsed_);
output_toggle_->setText(output_collapsed_ ? tr("OUTPUT [collapsed]") : tr("OUTPUT"));
});
output_vbox->addWidget(output_toggle_);
// Scrollable output content
output_content_ = new QWidget(output_area_);
output_content_layout_ = new QVBoxLayout(output_content_);
output_content_layout_->setContentsMargins(12, 6, 12, 8);
output_content_layout_->setSpacing(4);
output_content_->setStyleSheet(
QString("background:%1; border-left:3px solid %2;").arg(colors::BG_BASE(), colors::BORDER_DIM()));
output_content_->setVisible(false);
output_vbox->addWidget(output_content_);
output_area_->setVisible(false);
output_row_layout->addWidget(output_area_, 1);
root->addWidget(output_row);
// ── Insert-below: always-visible dim "+" centered between cells ──
insert_hint_ = new QWidget(this);
insert_hint_->setFixedHeight(20);
auto* insert_layout = new QHBoxLayout(insert_hint_);
insert_layout->setContentsMargins(56, 0, 0, 0);
insert_layout->setSpacing(0);
auto* insert_line = new QWidget(insert_hint_);
insert_line->setFixedHeight(1);
insert_line->setStyleSheet(QString("background:%1;").arg(colors::BORDER_DIM()));
insert_layout->addWidget(insert_line, 1);
auto* insert_btn = new QPushButton("+", insert_hint_);
insert_btn->setFixedSize(32, 18);
insert_btn->setCursor(Qt::PointingHandCursor);
insert_btn->setObjectName("insertBtn");
insert_btn->setStyleSheet(QString("QPushButton { color:%1; font-family:%2; font-size:12px; font-weight:700;"
" background:%3; border:1px solid %4; }"
"QPushButton:hover { background:%5; color:%6; border-color:%5; }")
.arg(colors::TEXT_DIM(), fonts::DATA_FAMILY, colors::BG_SURFACE(),
colors::BORDER_DIM(), colors::AMBER_DIM(), colors::AMBER()));
connect(insert_btn, &QPushButton::clicked, this, [this]() { emit insert_below_requested(cell_id_); });
insert_layout->addWidget(insert_btn);
auto* insert_line2 = new QWidget(insert_hint_);
insert_line2->setFixedHeight(1);
insert_line2->setStyleSheet(QString("background:%1;").arg(colors::BORDER_DIM()));
insert_layout->addWidget(insert_line2, 1);
root->addWidget(insert_hint_);
setMouseTracking(true);
}
void CellWidget::changeEvent(QEvent* event) {
if (event->type() == QEvent::LanguageChange)
retranslateUi();
QWidget::changeEvent(event);
}
void CellWidget::retranslateUi() {
// Hover toolbar buttons — fixed labels.
if (run_btn_)
run_btn_->setText(tr("RUN"));
if (type_btn_)
type_btn_->setText(tr("TYPE"));
if (up_btn_)
up_btn_->setText(tr("UP"));
if (dn_btn_)
dn_btn_->setText(tr("DN"));
if (del_btn_)
del_btn_->setText(tr("DEL"));
// output_toggle_ reflects live collapse/execution state ("OUT [n]" /
// "OUTPUT [collapsed]") — it is re-applied on the next state change, so we
// deliberately don't clobber it with stale text here.
// gutter_number_ ([n]/[*]) and gutter_type_ (PY/MD) are state/type codes,
// not translatable prose.
}
void CellWidget::adjust_editor_height() {
// Markdown cells showing the rendered preview hide the editor — its height
// is irrelevant. For everything else, size to fit even while the cell's
// stack page is still hidden (cells are built on the Editor page while the
// Library page is showing), so the cell isn't stuck at a tiny default.
if (cell_type_ == "markdown" && !md_editing_)
return;
// adjustSize() below re-emits documentSizeChanged (this slot is connected to
// it) — guard against the infinite recursion that would otherwise overflow
// the stack.
if (adjusting_height_)
return;
adjusting_height_ = true;
// Grow the editor to fit ALL its lines so the cell expands with the amount
// of code it holds — no inner scrollbar for code. The outer notebook scroll
// area handles overall scrolling. Height comes from the document layout, so
// it is accurate regardless of current visibility.
editor_->document()->adjustSize();
const int doc_h = static_cast<int>(editor_->document()->size().height());
const int target = doc_h + 8; // editor CSS padding (2+2) + breathing room
const int min_h = 40;
const int max_h = (cell_type_ == "code") ? 100000 : 800; // code grows freely
editor_->setFixedHeight(qBound(min_h, target, max_h));
adjusting_height_ = false;
}
void CellWidget::showEvent(QShowEvent* event) {
QWidget::showEvent(event);
// Re-measure now that the stylesheet font has been polished (QSS is applied
// on show); construction-time sizing may use the wrong default font metrics.
adjust_editor_height();
}
void CellWidget::set_cell_data(const NotebookCell& cell) {
cell_id_ = cell.id;
cell_type_ = cell.cell_type;
title_ = cell.title;
execution_count_ = cell.execution_count;
running_ = cell.running;
editor_->blockSignals(true);
editor_->setPlainText(cell.source);
editor_->blockSignals(false);
// Force document layout so height measurement is accurate
editor_->document()->adjustSize();
adjust_editor_height();
update_gutter();
// For markdown cells, show rendered preview by default
if (cell_type_ == "markdown" && !cell.source.trimmed().isEmpty()) {
md_editing_ = false;
editor_->setVisible(false);
md_preview_->setVisible(true);
render_markdown();
} else {
md_editing_ = true;
editor_->setVisible(true);
md_preview_->setVisible(false);
}
if (!cell.outputs.isEmpty()) {
set_outputs(cell.outputs, cell.execution_count);
}
}
NotebookCell CellWidget::cell_data() const {
NotebookCell cell;
cell.id = cell_id_;
cell.cell_type = cell_type_;
cell.title = title_;
cell.source = editor_->toPlainText();
cell.execution_count = execution_count_;
return cell;
}
void CellWidget::set_running(bool running) {
running_ = running;
update_gutter();
}
void CellWidget::set_outputs(const QVector<CellOutput>& outputs, int exec_count) {
execution_count_ = exec_count;
live_out_ = nullptr; // deleted with the rest of the output widgets below
update_gutter();
// Clear old output content
while (output_content_layout_->count() > 0) {
auto* item = output_content_layout_->takeAt(0);
if (item->widget())
item->widget()->deleteLater();
delete item;
}
if (outputs.isEmpty()) {
output_area_->setVisible(false);
output_toggle_->setVisible(false);
output_content_->setVisible(false);
return;
}
output_area_->setVisible(true);
output_toggle_->setVisible(true);
output_toggle_->setText(tr("OUT [%1]").arg(exec_count));
output_collapsed_ = false;
output_content_->setVisible(true);
for (const auto& out : outputs) {
if (out.type == "stream" || out.type == "execute_result") {
// Use QTextEdit in read-only mode for proper scrolling of long output
auto* output_view = new QTextEdit(output_content_);
output_view->setReadOnly(true);
output_view->setPlainText(out.text);
output_view->setLineWrapMode(QTextEdit::WidgetWidth);
output_view->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
output_view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
QString fg = (out.name == "stderr") ? colors::WARNING : colors::TEXT_PRIMARY;
output_view->setStyleSheet(
QString("QTextEdit { background:transparent; color:%1; border:none;"
" font-family:%2, 'Menlo', 'SF Mono', monospace; font-size:%3px; padding:2px 0; }"
"QScrollBar:vertical { background:transparent; width:4px; }"
"QScrollBar::handle:vertical { background:%4; }"
"QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height:0; }")
.arg(fg, fonts::DATA_FAMILY)
.arg(fonts::DATA)
.arg(colors::BORDER_BRIGHT()));
// Size to content, max 300px then scroll
int lines = out.text.count('\n') + 1;
int line_h = QFontMetrics(output_view->font()).lineSpacing();
int content_h = lines * line_h + 10;
int clamped = qBound(30, content_h, 300);
output_view->setFixedHeight(clamped);
output_content_layout_->addWidget(output_view);
} else if (out.type == "error") {
auto* err_widget = new QWidget(output_content_);
err_widget->setStyleSheet(QString("background:#1a0808; border-left:2px solid %1;").arg(colors::NEGATIVE()));
auto* err_layout = new QVBoxLayout(err_widget);
err_layout->setContentsMargins(10, 6, 10, 6);
err_layout->setSpacing(4);
auto* err_header = new QLabel(QString("%1: %2").arg(out.error_name, out.error_value), err_widget);
err_header->setWordWrap(true);
err_header->setStyleSheet(QString("color:%1; font-family:%2; font-size:%3px; font-weight:700;")
.arg(colors::NEGATIVE(), fonts::DATA_FAMILY)
.arg(fonts::DATA));
err_layout->addWidget(err_header);
if (!out.traceback.isEmpty()) {
auto* tb_view = new QTextEdit(err_widget);
tb_view->setReadOnly(true);
tb_view->setPlainText(out.traceback.join("\n"));
tb_view->setLineWrapMode(QTextEdit::WidgetWidth);
tb_view->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
tb_view->setStyleSheet(
QString("QTextEdit { background:transparent; color:%1; border:none;"
" font-family:%2, 'Menlo', 'SF Mono', monospace; font-size:%3px; }"
"QScrollBar:vertical { background:transparent; width:4px; }"
"QScrollBar::handle:vertical { background:%4; }"
"QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height:0; }")
.arg(colors::TEXT_SECONDARY(), fonts::DATA_FAMILY)
.arg(fonts::TINY)
.arg(colors::BORDER_BRIGHT()));
int tb_lines = out.traceback.join("\n").count('\n') + 1;
int tb_h = qBound(40, tb_lines * 16 + 10, 200);
tb_view->setFixedHeight(tb_h);
err_layout->addWidget(tb_view);
}
output_content_layout_->addWidget(err_widget);
}
}
}
void CellWidget::begin_stream() {
while (output_content_layout_->count() > 0) {
auto* item = output_content_layout_->takeAt(0);
if (item->widget())
item->widget()->deleteLater();
delete item;
}
// Styled by the screen stylesheet (#nbLiveOut) — no per-run setStyleSheet.
live_out_ = new QPlainTextEdit(output_content_);
live_out_->setObjectName("nbLiveOut");
live_out_->setReadOnly(true);
live_out_->setLineWrapMode(QPlainTextEdit::WidgetWidth);
// Display bound while streaming; the service caps what is kept for saving.
live_out_->setMaximumBlockCount(5000);
live_out_->setFixedHeight(60);
output_content_layout_->addWidget(live_out_);
output_area_->setVisible(true);
output_toggle_->setVisible(true);
output_toggle_->setText(tr("OUTPUT — running…"));
output_collapsed_ = false;
output_content_->setVisible(true);
}
void CellWidget::append_stream(const QString& text, bool is_stderr) {
if (!live_out_)
begin_stream();
QTextCursor cur(live_out_->document());
cur.movePosition(QTextCursor::End);
QTextCharFormat fmt;
fmt.setForeground(QColor(is_stderr ? colors::WARNING() : colors::TEXT_PRIMARY()));
// The service delivers newline-terminated chunks: write the separator before
// a chunk rather than after it, so the pane never ends with an empty line.
const QString body = text.endsWith(QLatin1Char('\n')) ? text.chopped(1) : text;
cur.insertText(live_out_->document()->isEmpty() ? body : QLatin1Char('\n') + body, fmt);
const int lines = live_out_->document()->blockCount();
const int line_h = QFontMetrics(live_out_->font()).lineSpacing();
live_out_->setFixedHeight(qBound(40, lines * line_h + 12, 300));
live_out_->moveCursor(QTextCursor::End);
live_out_->ensureCursorVisible();
}
void CellWidget::set_elapsed(qint64 ms) {
if (!output_toggle_->isVisible())
return;
const QString t = ms < 1000 ? tr("%1 ms").arg(ms) : tr("%1 s").arg(ms / 1000.0, 0, 'f', ms < 10000 ? 2 : 1);
output_toggle_->setText(tr("OUT [%1] · %2").arg(execution_count_).arg(t));
}
void CellWidget::set_selected(bool selected) {
selected_ = selected;
// Selected: amber left accent, brighter surface. Unselected: dim border, standard surface.
QString border = selected ? colors::AMBER : colors::BORDER_MED;
QString bg = selected ? "#0e0e0e" : colors::BG_SURFACE();
editor_container_->setStyleSheet(QString("background:%1; border-left:3px solid %2; border-top:1px solid %3;"
" border-bottom:1px solid %3; border-right:1px solid %3;")
.arg(bg, border, colors::BORDER_DIM()));
// Gutter matches cell background
QString gutter_bg = selected ? "#0e0e0e" : colors::BG_RAISED();
gutter_->setStyleSheet(QString("background:%1;").arg(gutter_bg));
QString num_color = selected ? colors::AMBER : colors::TEXT_TERTIARY;
gutter_number_->setStyleSheet(
QString("color:%1; font-family:%2; font-size:%3px; font-weight:700; background:transparent;")
.arg(num_color, fonts::DATA_FAMILY)
.arg(fonts::TINY));
// For markdown: if selecting, switch to edit mode; if deselecting, render
if (cell_type_ == "markdown") {
if (selected && !md_editing_) {
md_editing_ = true;
md_preview_->setVisible(false);
editor_->setVisible(true);
editor_->setFocus();
adjust_editor_height();
} else if (!selected && md_editing_) {
md_editing_ = false;
editor_->setVisible(false);
md_preview_->setVisible(true);
render_markdown();
}
}
}
void CellWidget::set_index(int index) {
index_ = index;
update_gutter();
}
void CellWidget::update_gutter() {
if (running_) {
gutter_number_->setText("[*]");
gutter_number_->setStyleSheet(QString("color:%1; font-family:%2; font-size:%3px; font-weight:700;")
.arg(colors::WARNING(), fonts::DATA_FAMILY)
.arg(fonts::TINY));
} else if (execution_count_ > 0) {
gutter_number_->setText(QString("[%1]").arg(execution_count_));
gutter_number_->setStyleSheet(QString("color:%1; font-family:%2; font-size:%3px; font-weight:700;")
.arg(selected_ ? colors::AMBER() : colors::POSITIVE(), fonts::DATA_FAMILY)
.arg(fonts::TINY));
} else {
gutter_number_->setText(QString("[%1]").arg(index_ + 1));
gutter_number_->setStyleSheet(
QString("color:%1; font-family:%2; font-size:%3px; font-weight:700;")
.arg(selected_ ? colors::AMBER() : colors::TEXT_TERTIARY(), fonts::DATA_FAMILY)
.arg(fonts::TINY));
}
if (cell_type_ == "markdown") {
gutter_type_->setText("MD");
gutter_type_->setStyleSheet(
QString("color:%1; font-family:%2; font-size:10px; font-weight:600; letter-spacing:0.5px;")
.arg(colors::INFO(), fonts::DATA_FAMILY));
} else {
gutter_type_->setText("PY");
gutter_type_->setStyleSheet(
QString("color:%1; font-family:%2; font-size:10px; font-weight:600; letter-spacing:0.5px;")
.arg(colors::TEXT_DIM(), fonts::DATA_FAMILY));
}
}
void CellWidget::render_markdown() {
QString src = editor_->toPlainText();
if (src.trimmed().isEmpty()) {
md_preview_->setHtml(
QString("<p style='color:%1; font-style:italic;'>%2</p>")
.arg(colors::TEXT_TERTIARY(), tr("Empty markdown cell — click to edit").toHtmlEscaped()));
md_preview_->setMinimumHeight(48);
md_preview_->setMaximumHeight(48);
return;
}
// Convert basic markdown to HTML for rendering
// Handles: headers, bold, italic, code blocks, inline code, lists, links, horizontal rules
QString html;
html +=
QString("<style>"
"body { color:%1; font-family:%2; font-size:%3px; }"
"h1 { color:%4; font-size:20px; font-weight:700; margin:8px 0 4px; border-bottom:1px solid %5; "
"padding-bottom:4px; }"
"h2 { color:%4; font-size:17px; font-weight:700; margin:8px 0 4px; }"
"h3 { color:%4; font-size:15px; font-weight:700; margin:6px 0 3px; }"
"h4 { color:%6; font-size:14px; font-weight:600; margin:4px 0 2px; }"
"code { background:%7; color:%4; padding:2px 4px; font-family:%2; }"
"pre { background:%7; color:%1; padding:8px; font-family:%2; font-size:13px;"
" border-left:2px solid %5; margin:6px 0; }"
"a { color:%8; }"
"strong { color:%1; font-weight:700; }"
"em { color:%6; font-style:italic; }"
"ul, ol { margin:4px 0; padding-left:20px; }"
"li { margin:2px 0; }"
"hr { border:none; border-top:1px solid %5; margin:8px 0; }"
"blockquote { border-left:3px solid %4; padding-left:10px; color:%6; margin:6px 0; }"
"</style>")
.arg(colors::TEXT_PRIMARY(), fonts::DATA_FAMILY)
.arg(fonts::DATA)
.arg(colors::AMBER(), colors::BORDER_MED(), colors::TEXT_SECONDARY(), colors::BG_RAISED(), colors::CYAN());
bool in_code_block = false;
QString code_block;
QStringList lines = src.split('\n');
for (const auto& line : lines) {
// Fenced code blocks
if (line.trimmed().startsWith("```")) {
if (in_code_block) {
html += "<pre>" + code_block.toHtmlEscaped() + "</pre>";
code_block.clear();
in_code_block = false;
} else {
in_code_block = true;
}
continue;
}
if (in_code_block) {
if (!code_block.isEmpty())
code_block += "\n";
code_block += line;
continue;
}
QString trimmed = line.trimmed();
// Horizontal rule
if (trimmed == "---" || trimmed == "***" || trimmed == "___") {
html += "<hr>";
continue;
}
// Headers
if (trimmed.startsWith("#### ")) {
html += "<h4>" + trimmed.mid(5).toHtmlEscaped() + "</h4>";
continue;
}
if (trimmed.startsWith("### ")) {
html += "<h3>" + trimmed.mid(4).toHtmlEscaped() + "</h3>";
continue;
}
if (trimmed.startsWith("## ")) {
html += "<h2>" + trimmed.mid(3).toHtmlEscaped() + "</h2>";
continue;
}
if (trimmed.startsWith("# ")) {
html += "<h1>" + trimmed.mid(2).toHtmlEscaped() + "</h1>";
continue;
}
// Blockquote
if (trimmed.startsWith("> ")) {
html += "<blockquote>" + trimmed.mid(2).toHtmlEscaped() + "</blockquote>";
continue;
}
// Unordered list
if (trimmed.startsWith("- ") || trimmed.startsWith("* ")) {
html += "<ul><li>" + trimmed.mid(2).toHtmlEscaped() + "</li></ul>";
continue;
}
// Ordered list (simple)
if (trimmed.length() > 2 && trimmed[0].isDigit() && trimmed[1] == '.') {
html += "<ol><li>" + trimmed.mid(3).toHtmlEscaped() + "</li></ol>";
continue;
}
// Empty line = paragraph break
if (trimmed.isEmpty()) {
html += "<br>";
continue;
}
// Inline formatting: **bold**, *italic*, `code`, [link](url)
QString escaped = line.toHtmlEscaped();
// Inline code first (to avoid nested processing)
escaped.replace(QRegularExpression("`([^`]+)`"), "<code>\\1</code>");
// Bold
escaped.replace(QRegularExpression("\\*\\*([^*]+)\\*\\*"), "<strong>\\1</strong>");
// Italic
escaped.replace(QRegularExpression("\\*([^*]+)\\*"), "<em>\\1</em>");
// Links
escaped.replace(QRegularExpression("\\[([^\\]]+)\\]\\(([^)]+)\\)"), "<a href='\\2'>\\1</a>");
html += "<p style='margin:2px 0;'>" + escaped + "</p>";
}
// Close unclosed code block
if (in_code_block && !code_block.isEmpty()) {
html += "<pre>" + code_block.toHtmlEscaped() + "</pre>";
}
md_preview_->setHtml(html);
// Size preview to content
QTimer::singleShot(0, this, [this]() {
int h = static_cast<int>(md_preview_->document()->size().height()) + 20;
int clamped = qBound(48, h, 600);
md_preview_->setMinimumHeight(clamped);
md_preview_->setMaximumHeight(clamped);
});
}
void CellWidget::enterEvent(QEnterEvent* /*event*/) {
hovered_ = true;
// Show toolbar buttons
for (int i = 0; i < toolbar_->layout()->count(); ++i) {
auto* w = toolbar_->layout()->itemAt(i)->widget();
if (w)
w->setVisible(true);
}
toolbar_->setStyleSheet(
QString("background:%1; border-bottom:1px solid %2;").arg(colors::BG_RAISED(), colors::BORDER_DIM()));
}
void CellWidget::leaveEvent(QEvent* /*event*/) {
hovered_ = false;
// Hide toolbar buttons
for (int i = 0; i < toolbar_->layout()->count(); ++i) {
auto* w = toolbar_->layout()->itemAt(i)->widget();
if (w)
w->setVisible(false);
}
toolbar_->setStyleSheet(QString("background:%1;").arg(colors::BG_RAISED()));
}
void CellWidget::mousePressEvent(QMouseEvent* event) {
emit cell_clicked(cell_id_);
QWidget::mousePressEvent(event);
}
bool CellWidget::eventFilter(QObject* watched, QEvent* event) {
// The markdown preview is read-only and consumes its own mouse events, so
// without this a rendered markdown cell could only be re-opened from the
// navigator. installEventFilter() was already in place but no override
// existed, so nothing happened.
if (watched == md_preview_ && event->type() == QEvent::MouseButtonPress) {
emit cell_clicked(cell_id_); // selecting a markdown cell switches it to edit mode
if (!md_editing_) {
md_editing_ = true;
md_preview_->setVisible(false);
editor_->setVisible(true);
editor_->setFocus(Qt::MouseFocusReason);
adjust_editor_height();
}
return true;
}
return QWidget::eventFilter(watched, event);
}
// ═════════════════════════════════════════════════════════════════════════════
// CellNavigator (sidebar)
// ═════════════════════════════════════════════════════════════════════════════
} // namespace fincept::screens