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/app/DockScreenRouter_Materialize.cpp
//
// Dock-widget construction + lazy materialisation: create_dock_widget,
// prepare_dock_widget, materialize_now, materialize_screen.
//
// Part of the partial-class split of DockScreenRouter.cpp.
#include "app/DockScreenRouter.h"
#include "app/WindowFrame.h"
#include "auth/InactivityGuard.h"
#include "core/components/PopularityTracker.h"
#include "core/keys/WindowCycler.h"
#include "core/logging/Logger.h"
#include "core/panel/PanelHandle.h"
#include "core/panel/PanelRegistry.h"
#include "core/session/ScreenStateManager.h"
#include "core/session/SessionManager.h"
#include "core/symbol/IGroupLinked.h"
#include "core/symbol/SymbolContext.h"
#include "core/symbol/SymbolGroupRegistry.h"
#include "core/symbol/SymbolRef.h"
#include "core/window/WindowRegistry.h"
#include "screens/common/IStatefulScreen.h"
#include "ui/theme/Theme.h"
#include "ui/widgets/GroupBadge.h"
#include <QApplication>
#include <QClipboard>
#include <QContextMenuEvent>
#include <QEvent>
#include <QHBoxLayout>
#include <QInputDialog>
#include <QKeyEvent>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QVBoxLayout>
#include <DockAreaWidget.h>
#include <DockManager.h>
#include <DockWidget.h>
#include <DockWidgetTab.h>
namespace fincept {
ads::CDockWidget* DockScreenRouter::create_dock_widget(const QString& id) {
if (dock_widgets_.contains(id))
return dock_widgets_[id];
auto* dw = new ads::CDockWidget(manager_, title_for_id(id));
dw->setObjectName(id);
// Phase 5 polish: DockWidgetFloatable removed alongside the global
// DoubleClickUndocksWidget flag (see WindowFrame::setup_docking_mode).
// Tear-off goes through the right-click menu's "Tear off into new
// window" entry, which uses the close-and-recreate path that
// preserves the panel UUID + state.
//
// Pinnable is intentionally excluded too: the auto-hide pin button
// converts panels to collapsible sidebars, which causes them to
// disappear when another panel is opened alongside them.
dw->setFeatures(ads::CDockWidget::DockWidgetMovable | ads::CDockWidget::DockWidgetClosable |
ads::CDockWidget::DockWidgetFocusable);
// Use dock-widget minimum size (not content size) so screens with large
// internal canvases (like DashboardCanvas) don't prevent side-by-side splits.
dw->setMinimumSizeHintMode(ads::CDockWidget::MinimumSizeHintFromDockWidget);
dw->setMinimumWidth(200);
// Register the dock widget early so attach_group_badge_to_tab() (called
// from wrap_with_group_badge below) can resolve the tab via dock_widgets_.
dock_widgets_[id] = dw;
// Phase 4b: mint a PanelInstanceId for this string id and register a
// PanelHandle with PanelRegistry. The handle's frame_id comes from
// the parent WindowFrame (the router's QObject parent). Two open
// panels of the same screen type get distinct UUIDs because they go
// through duplicate_panel() which calls create_dock_widget with a
// synthetic `<base>#dup<N>` id — each gets its own UUID.
if (!instance_ids_.contains(id)) {
WindowId frame_id; // null if the router's parent isn't a WindowFrame
int win_id = 0;
if (auto* frame = qobject_cast<WindowFrame*>(parent())) {
frame_id = frame->frame_uuid();
win_id = frame->window_id();
}
// Derive the instance id DETERMINISTICALLY from window+dock id rather
// than a fresh random uuid. The dock id is stable across restarts (the
// ADS layout restores the same ids), so the same panel reuses the same
// PanelInstanceId every launch — which is what lets ScreenStateManager
// find the panel's saved UI state again (restore_by_uuid keys on this).
// A random generate() minted a new id each launch, so per-screen state
// (FNO underlying/expiry, equity symbol/watchlist, …) was written under
// an id that never matched on the next run and was effectively lost.
// window id is included so the same dock id in two windows stays unique.
const PanelInstanceId panel_uuid = PanelInstanceId::from_name(QStringLiteral("w%1:%2").arg(win_id).arg(id));
instance_ids_.insert(id, panel_uuid);
// Strip any "#dup<N>" suffix from the type id so two watchlists
// share a type_id of "watchlist" while having distinct instance_ids.
QString type_id = id;
const int dup_idx = type_id.indexOf("#dup");
if (dup_idx > 0)
type_id = type_id.left(dup_idx);
auto* handle = new PanelHandle(panel_uuid, type_id, title_for_id(type_id), frame_id);
handle->set_dock_widget(dw);
handle->set_state(PanelHandle::State::Active); // dock widget is created
PanelRegistry::instance().register_panel(handle);
}
// Screen widgets must allow shrinking so ADS can create side-by-side splits.
// Factory screens get a lightweight placeholder here; the real widget is swapped
// in on first navigation via materialize_screen().
if (screens_.contains(id)) {
screens_[id]->setMinimumWidth(0);
dw->setWidget(wrap_with_group_badge(id, screens_[id]));
} else {
auto* placeholder = new QWidget;
// Match the app's dark background so placeholders don't flash
// white/system-gray during the brief window between show() and
// deferred screen materialization.
QPalette pal = placeholder->palette();
pal.setColor(QPalette::Window, QColor(ui::colors::BG_BASE()));
placeholder->setPalette(pal);
placeholder->setAutoFillBackground(true);
auto* lbl = new QLabel(title_for_id(id));
lbl->setAlignment(Qt::AlignCenter);
lbl->setStyleSheet(QString("color:%1;font-size:14px;font-weight:500;").arg(QString(ui::colors::TEXT_DIM())));
auto* vl = new QVBoxLayout(placeholder);
vl->addWidget(lbl);
dw->setWidget(placeholder);
// Attach a decorative `[·]` badge for factory screens too — once the
// real screen materialises, attach_group_badge_to_tab is idempotent
// and won't add a second badge, so the existing one stays in place.
attach_group_badge_to_tab(id, placeholder);
}
// Intercept double-click on the title label inside CDockWidgetTab to allow
// inline rename. We use the label (objectName "dockWidgetTabLabel"), NOT the
// tab frame — ADS already uses tab frame double-click to undock/float.
//
// Phase 12 — also install the filter on the tab widget itself so right-click
// anywhere on the tab (including the icon / padding) opens the context
// menu. The event filter distinguishes by event type, not watched object.
if (auto* tab = dw->tabWidget()) {
tab->installEventFilter(this);
tab->setProperty("dock_id", id);
tab->setContextMenuPolicy(Qt::DefaultContextMenu);
if (auto* lbl = tab->findChild<QLabel*>("dockWidgetTabLabel")) {
lbl->installEventFilter(this);
lbl->setProperty("dock_id", id);
}
}
// Restore a previously saved custom title (user may have renamed this tab).
const QString saved_title = load_tab_title(id);
if (!saved_title.isEmpty())
dw->setWindowTitle(saved_title);
// Persist the title whenever the user renames it via the inline editor.
connect(dw, &ads::CDockWidget::titleChanged, this, [this, id](const QString& title) {
if (title != title_for_id(id)) // only save if user actually changed it
save_tab_title(id, title);
});
// Materialize on first show; save state on hide.
connect(dw, &ads::CDockWidget::visibilityChanged, this, [this, id](bool visible) {
if (visible) {
// Bulk-register paths (ensure_all_registered, prepare_dock_widget)
// transiently make the widget visible just to register it with the
// manager before hiding it again with toggleView(false). Skip the
// factory call in that window — the user hasn't asked to see this
// panel yet, and materialising every registered screen at startup
// is the cold-boot bug we're guarding against.
if (suppress_visibility_materialize_)
return;
materialize_screen(id);
} else {
save_screen_state(id);
}
});
// dock_widgets_[id] was registered earlier (before wrap_with_group_badge)
// so attach_group_badge_to_tab could resolve the tab during construction.
return dw;
}
void DockScreenRouter::prepare_dock_widget(const QString& id) {
// Phase 8: pre-create the dock widget shell for restoreState matching.
// Idempotent — a no-op if the widget already exists (likely registered
// earlier by ensure_all_registered() at WindowFrame construction).
if (dock_widgets_.contains(id))
return;
if (!factories_.contains(id) && !screens_.contains(id)) {
LOG_WARN("DockRouter", QString("prepare_dock_widget: unknown id '%1'").arg(id));
return;
}
auto* dw = create_dock_widget(id);
if (!dw)
return;
// CRITICAL: register with the dock manager so restoreState can find
// the widget by objectName via CDockManager::dockWidgetsMap. Without
// this, the saved layout silently fails to restore. Mirrors
// ensure_all_registered's "tab into shared area, hide" pattern so
// we don't generate N vertical splits during the pre-restore pass.
if (manager_) {
// Same rationale as ensure_all_registered: the transient
// visibilityChanged(true) the addDockWidget emits must not
// materialise the screen factory before the layout is restored.
suppress_visibility_materialize_ = true;
manager_->addDockWidget(ads::CenterDockWidgetArea, dw);
dw->toggleView(false); // hidden until restoreState repositions it
suppress_visibility_materialize_ = false;
}
}
void DockScreenRouter::materialize_now(const QString& id) {
materialize_screen(id);
}
void DockScreenRouter::materialize_screen(const QString& id) {
if (screens_.contains(id))
return;
auto fit = factories_.find(id);
if (fit == factories_.end())
return;
LOG_INFO("DockRouter", "Lazy-constructing screen: " + id);
QWidget* screen = nullptr;
try {
screen = fit.value()();
} catch (const std::exception& e) {
LOG_ERROR("DockRouter", QString("Factory threw for '%1': %2").arg(id, e.what()));
} catch (...) {
LOG_ERROR("DockRouter", QString("Factory threw unknown exception for '%1'").arg(id));
}
if (!screen) {
LOG_ERROR("DockRouter", "Factory returned null for: " + id);
return;
}
screen->setMinimumWidth(0);
// Phase 5: keep the factory in factories_ even after first materialise.
// Pre-Phase-5 we erased it as a memory tidy-up, but tear-off / move-to-
// window need to re-create the widget on a different router, which
// requires the factory to still be available. The factory is a small
// std::function — no meaningful memory cost. duplicate_panel's
// factory-reinstall workaround (line ~626) becomes unnecessary too.
auto* dw = dock_widgets_.value(id, nullptr);
if (!dw)
return;
QWidget* old = dw->widget();
dw->setWidget(wrap_with_group_badge(id, screen));
if (old) {
old->setParent(nullptr);
old->deleteLater();
}
screens_[id] = screen;
restore_screen_state(id);
}
// ── Tab title persistence ─────────────────────────────────────────────────────
} // namespace fincept