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
#include "app/WindowFrame.h"
#include "app/DockScreenRouter.h"
#include "app/MonitorPickerDialog.h"
#include "app/TerminalShell.h"
#include "auth/AuthManager.h"
#include "auth/InactivityGuard.h"
#include "auth/PinManager.h"
#include "auth/lock/LockOverlayController.h"
#include "core/actions/ActionRegistry.h"
#include "core/actions/builtin_actions.h"
#include "core/config/ProfileManager.h"
#include "core/events/EventBus.h"
#include "core/keys/KeyConfigManager.h"
#include "core/keys/WindowCycler.h"
#include "core/layout/LayoutCatalog.h"
#include "core/layout/WorkspaceShell.h"
#include "core/logging/Logger.h"
#include "core/panel/PanelMaterialiser.h"
#include "core/session/SessionManager.h"
#include "core/symbol/IGroupLinked.h"
#include "core/symbol/SymbolGroup.h"
#include "core/window/WindowRegistry.h"
#include "screens/about/AboutScreen.h"
#include "screens/agent_config/AgentConfigScreen.h"
#include "screens/ai_chat/AiChatBubble.h"
#include "screens/ai_chat/AiChatScreen.h"
#include "screens/ai_quant_lab/AIQuantLabScreen.h"
#include "screens/akshare/AkShareScreen.h"
#include "screens/algo_trading/AlgoTradingScreen.h"
#include "screens/alpha_arena/AlphaArenaScreen.h"
#include "screens/alt_investments/AltInvestmentsScreen.h"
#include "screens/asia_markets/AsiaMarketsScreen.h"
#include "screens/auth/ForgotPasswordScreen.h"
#include "screens/auth/LockScreen.h"
#include "screens/auth/LoginScreen.h"
#include "screens/auth/PricingScreen.h"
#include "screens/auth/RegisterScreen.h"
#include "screens/backtesting/BacktestingScreen.h"
#include "screens/chat_mode/ChatModeScreen.h"
#include "screens/code_editor/CodeEditorScreen.h"
#include "screens/common/IStatefulScreen.h"
#include "screens/crypto_center/CryptoCenterScreen.h"
#include "screens/crypto_trading/CryptoTradingScreen.h"
#include "screens/dashboard/DashboardScreen.h"
#include "screens/data_mapping/DataMappingScreen.h"
#include "screens/data_sources/DataSourcesScreen.h"
#include "screens/dbnomics/DBnomicsScreen.h"
#include "screens/derivatives/DerivativesScreen.h"
#include "screens/docs/DocsScreen.h"
#include "screens/economics/EconomicsScreen.h"
#include "screens/equity_research/EquityResearchScreen.h"
#include "screens/equity_trading/EquityTradingScreen.h"
#include "screens/excel/ExcelScreen.h"
#include "screens/file_manager/FileManagerScreen.h"
#include "screens/fno/FnoScreen.h"
#include "screens/geopolitics/GeopoliticsScreen.h"
#include "screens/gov_data/GovDataScreen.h"
#include "screens/info/ContactScreen.h"
#include "screens/info/HelpScreen.h"
#include "screens/info/PrivacyScreen.h"
#include "screens/info/TermsScreen.h"
#include "screens/info/TrademarksScreen.h"
#include "screens/ma_analytics/MAAnalyticsScreen.h"
#include "screens/maritime/MaritimeScreen.h"
#include "screens/markets/MarketsScreen.h"
#include "screens/mcp_servers/McpServersScreen.h"
#include "screens/news/NewsScreen.h"
#include "screens/node_editor/NodeEditorScreen.h"
#include "screens/notes/NotesScreen.h"
#include "screens/polymarket/PolymarketScreen.h"
#include "screens/portfolio/PortfolioScreen.h"
#include "screens/profile/ProfileScreen.h"
#include "screens/quantlib/QuantLibScreen.h"
#include "screens/relationship_map/RelationshipMapScreen.h"
#include "screens/report_builder/ReportBuilderScreen.h"
#include "screens/settings/SettingsScreen.h"
#include "screens/support/SupportScreen.h"
#include "screens/surface_analytics/SurfaceAnalyticsScreen.h"
#include "screens/trade_viz/TradeVizScreen.h"
#include "screens/watchlist/WatchlistScreen.h"
#include "services/llm/LlmService.h"
#include "services/updater/UpdateService.h"
#include "storage/repositories/SettingsRepository.h"
#include "trading/instruments/InstrumentService.h"
#include "ui/command/CommandPalette.h"
#include "ui/command/QuickCommandBar.h"
#include "ui/components/ComponentBrowserDialog.h"
#include "ui/debug/DebugOverlay.h"
#include "ui/navigation/DockStatusBar.h"
#include "ui/navigation/DockToolBar.h"
#include "ui/navigation/FKeyBar.h"
#include "ui/navigation/StatusBar.h"
#include "ui/navigation/ToolBar.h"
#include "ui/pushpins/PushpinBar.h"
#include "ui/theme/Theme.h"
#include "ui/widgets/EnterprisePromo.h"
#include "ui/workspace/LayoutOpenDialog.h"
#include "ui/workspace/LayoutSaveAsDialog.h"
#include <QApplication>
#include <QCloseEvent>
#include <QDateTime>
#include <QDir>
#include <QEvent>
#include <QFile>
#include <QFileDialog>
#include <QInputDialog>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QMessageBox>
#include <QPalette>
#include <QPointer>
#include <QScreen>
#include <QSet>
#include <QShortcut>
#include <QStatusBar>
#include <QTimer>
#include <QToolBar>
#include <QVBoxLayout>
#include <QWindow>
#include <DockAreaWidget.h>
#include <DockManager.h>
#include <DockWidget.h>
#include <FloatingDockContainer.h>
#include <algorithm>
namespace fincept {
namespace {
/// Binds a QTimer's run state to its host widget's visibility (§P3).
///
/// The rule is "start in showEvent, stop in hideEvent", but WindowFrame's header
/// is shared with the multi-window shell and declares no show/hide overrides, so
/// the same contract is enforced from an installed event filter instead. Minimise
/// is covered too: on Windows a minimised top-level gets WindowStateChange, not
/// Hide, and a minimised window has no reason to keep polling.
class VisibilityTimerGate final : public QObject {
public:
VisibilityTimerGate(QTimer* timer, QObject* parent) : QObject(parent), timer_(timer) {}
protected:
bool eventFilter(QObject* watched, QEvent* event) override {
if (timer_) {
switch (event->type()) {
case QEvent::Show:
timer_->start();
break;
case QEvent::Hide:
timer_->stop();
break;
case QEvent::WindowStateChange:
if (auto* w = qobject_cast<QWidget*>(watched)) {
if (w->isMinimized())
timer_->stop();
else if (w->isVisible())
timer_->start();
}
break;
default:
break;
}
}
return QObject::eventFilter(watched, event);
}
private:
QPointer<QTimer> timer_;
};
/// The frame the user most recently worked in (updated from changeEvent). Only a
/// fallback for wf_app_event_target() when no frame is the active window.
QPointer<WindowFrame>& wf_last_active_frame() {
static QPointer<WindowFrame> frame;
return frame;
}
/// Picks the ONE frame that should act on an app-wide EventBus event.
///
/// Every WindowFrame subscribes to the same bus, so without arbitration a single
/// publish of nav.switch_screen / equity.open_order_ticket / nav.open_symbol would
/// navigate (or pop an order ticket in) every open window. Each frame's handler
/// asks this helper from its queued lambda (GUI thread) and acts only when it is
/// the answer, so exactly one frame handles each event:
/// 1. the active window, resolved to its owning frame — activeWindow() can be a
/// floating ADS dock container or a modal dialog rather than the frame
/// itself, both of which are parented (transitively) to a frame;
/// 2. else the frame the user last worked in (app not focused, e.g. an MCP tool
/// or automation published the event);
/// 3. else the first registered frame.
WindowFrame* wf_app_event_target() {
for (QWidget* w = QApplication::activeWindow(); w; w = w->parentWidget()) {
if (auto* frame = qobject_cast<WindowFrame*>(w))
return frame;
}
if (WindowFrame* last = wf_last_active_frame().data(); last && last->isVisible())
return last;
const auto frames = WindowRegistry::instance().frames();
return frames.isEmpty() ? nullptr : frames.first();
}
} // namespace
int WindowFrame::next_window_id() {
// Seed from the max of (persisted window IDs, live window IDs) so a new
// window never reuses an ID that already owns saved geometry/dock layout.
// Live IDs matter too: during a single session we may have deleted a
// secondary window without clearing its QSettings keys yet, and we still
// must not collide with any WindowFrame currently on screen.
int max_id = 0;
const auto saved = SessionManager::instance().load_window_ids();
for (int id : saved)
max_id = std::max(max_id, id);
// Live frames (Phase 1: WindowRegistry replaces the topLevelWidgets walk).
for (int id : WindowRegistry::instance().frame_ids())
max_id = std::max(max_id, id);
return max_id + 1;
}
WindowFrame::WindowFrame(int window_id, QWidget* parent, const WindowId& adopted_uuid)
: QMainWindow(parent), window_id_(window_id) {
// Adopt the saved UUID before any panel is created — see header rationale.
// Null adopted_uuid = mint a fresh one lazily on first frame_uuid() call.
if (!adopted_uuid.is_null())
frame_uuid_ = adopted_uuid;
// Phase 8: seed the dynamic property DataHub uses to gate
// pause_when_inactive topics. Initial state = active (we wouldn't be
// constructing the frame if we didn't intend to show it). changeEvent
// updates this on every minimise/restore.
setProperty("fincept.active_for_work", true);
// Phase 6 trim: connect QWindow::screenChanged so paint-cached widgets
// can invalidate at the new DPR. The QWindow is created lazily on
// first show — queue the connect via QMetaObject::invokeMethod with
// QueuedConnection so it runs after the event loop has had a chance
// to construct the window handle.
QMetaObject::invokeMethod(
this,
[this]() {
if (auto* wh = windowHandle()) {
connect(wh, &QWindow::screenChanged, this, [this](QScreen* scr) { emit screen_changed(scr); });
}
},
Qt::QueuedConnection);
// Show active profile in title bar when using a non-default profile.
// "Fincept Terminal" is the product brand and is intentionally not
// translated — the bracketed profile name is the only variable part.
const QString profile = ProfileManager::instance().active();
setWindowTitle(profile == "default" ? QStringLiteral("Fincept Terminal")
: QStringLiteral("Fincept Terminal [%1]").arg(profile));
// Load icon from the embedded Windows resource (IDI_ICON1 in app.rc).
// Falls back to the .ico beside the executable on other platforms.
QIcon app_icon;
#if defined(Q_OS_WIN)
app_icon = QApplication::windowIcon(); // set by app.rc at link time
if (app_icon.isNull()) {
// Fallback: look next to the executable (works after windeployqt)
const QString ico = QCoreApplication::applicationDirPath() + "/fincept.ico";
if (QFile::exists(ico))
app_icon = QIcon(ico);
}
#else
{
const QString ico = QCoreApplication::applicationDirPath() + "/fincept.ico";
if (QFile::exists(ico))
app_icon = QIcon(ico);
}
#endif
if (!app_icon.isNull())
setWindowIcon(app_icon);
// Minimum size must be small enough to allow OS window-snap (half/third screen).
// On a 1920-wide display, left-snap = 960px. Use 800x500 as minimum so snapping
// works on any 1080p+ monitor without the window bouncing back to centre.
setMinimumSize(800, 500);
// Primary windows (id 0) restore saved geometry from last session.
// Secondary windows (id > 0) restore their own saved geometry if available,
// otherwise use smart multi-monitor placement (handled by the caller after show()).
const QByteArray saved_geom = SessionManager::instance().load_geometry(window_id_);
bool geometry_applied = false;
if (!saved_geom.isEmpty() && restoreGeometry(saved_geom)) {
// Verify the restored frame actually intersects a currently-connected
// screen — if the user unplugged a monitor between sessions, Qt will
// happily hand back off-screen coordinates and the window becomes
// invisible/unreachable. Guard against that by falling through to
// smart placement if no intersection exists.
const QRect frame = frameGeometry();
bool on_some_screen = false;
const auto screens = QGuiApplication::screens();
for (QScreen* s : screens) {
if (s->availableGeometry().intersects(frame)) {
on_some_screen = true;
break;
}
}
geometry_applied = on_some_screen;
}
if (!geometry_applied) {
// Prefer the screen the window lived on last session (by name); fall
// back to primary if that screen is gone.
QScreen* target = nullptr;
const QString saved_screen = SessionManager::instance().load_screen_name(window_id_);
if (!saved_screen.isEmpty()) {
for (QScreen* s : QGuiApplication::screens()) {
if (s->name() == saved_screen) {
target = s;
break;
}
}
}
if (!target)
target = QApplication::primaryScreen();
if (target) {
QRect geom = target->availableGeometry();
resize(geom.width() * 9 / 10, geom.height() * 9 / 10);
QPoint center = geom.center() - rect().center();
if (window_id_ == 0) {
move(center);
} else {
// Cascade secondary windows so they don't stack exactly
// on top of the primary when multiple windows fall back
// to the same screen (e.g. external monitors disconnected).
int offset = window_id_ * 30;
QPoint pos = center + QPoint(offset, offset);
pos.setX(std::max(pos.x(), geom.x()));
pos.setY(std::max(pos.y(), geom.y()));
pos.setX(std::min(pos.x(), geom.right() - width()));
pos.setY(std::min(pos.y(), geom.bottom() - height()));
move(pos);
}
}
}
// Restore always-on-top before the first show() so the OS hint is
// applied cleanly. Cannot use set_always_on_top() here — it would call
// show() which only works after the widget has a fully built-out layout.
always_on_top_ = SessionManager::instance().load_window_flag(window_id_, "always_on_top", false);
if (always_on_top_)
setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
// Bootstrap pin_gate_cleared_ from the process-wide locked flag. Without
// this, opening a second WindowFrame (--new-window IPC) while the user is
// already PIN-unlocked would treat the new window as un-gated and force
// a redundant PIN re-entry. The singleton flag is the source of truth for
// "user has cleared the PIN gate this session"; the per-window field is
// a cache so on_auth_state_changed() can skip re-prompting.
pin_gate_cleared_ = !auth::InactivityGuard::instance().is_terminal_locked() &&
auth::AuthManager::instance().is_authenticated() && auth::PinManager::instance().has_pin();
auto* master_stack = new QStackedWidget;
// ── Auth stack ───────────────────────────────────────────────────────────
auth_stack_ = new QStackedWidget;
setup_auth_screens();
master_stack->addWidget(auth_stack_);
// ── Chat Mode ─────────────────────────────────────────────────────────────
chat_mode_screen_ = new chat_mode::ChatModeScreen;
// ── Lock Screen ─────────────────────────────────────────────────────────
// Phase 1c lift: LockOverlayController owns LockScreen widgets. The
// frame asks for its widget via the controller; master_stack reparents
// it via addWidget() below. WindowFrame keeps a non-owning pointer for
// the existing apply_lock_state / show_unlock / show_setup paths that
// already exist (preserving security-audit invariants — see
// auth/lock/LockOverlayController.h).
lock_screen_ = auth::LockOverlayController::instance().lock_screen_for(this);
// ── ADS Docking mode ─────────────────────────────────────────────────────
setup_docking_mode();
master_stack->addWidget(dock_manager_->parentWidget()); // index 1 — dock_wrapper
master_stack->addWidget(chat_mode_screen_); // index 2
master_stack->addWidget(lock_screen_); // index 3 — lock/PIN screen
connect(chat_mode_screen_, &chat_mode::ChatModeScreen::exit_requested, this, &WindowFrame::toggle_chat_mode);
// Lock screen signals
connect(lock_screen_, &screens::LockScreen::unlocked, this, &WindowFrame::on_terminal_unlocked);
connect(lock_screen_, &screens::LockScreen::reauth_requested, this, []() {
// Max PIN attempts exceeded — wipe the PIN (this is the ONLY path
// that should clear it) and force a full re-login so the server
// re-validates the user before they can configure a new PIN.
auth::PinManager::instance().clear_pin();
auth::AuthManager::instance().logout();
});
// Inactivity guard → lock screen. The originator window handles
// lock_requested by flipping the process-wide locked flag; the
// terminal_locked_changed signal then drives every WindowFrame
// (including this one, idempotently) to apply the lock UI. Without
// this lock-step, a secondary window would keep showing live data
// behind the back of the lock screen on the primary.
connect(&auth::InactivityGuard::instance(), &auth::InactivityGuard::lock_requested, this,
&WindowFrame::show_lock_screen);
connect(&auth::InactivityGuard::instance(), &auth::InactivityGuard::terminal_locked_changed, this,
&WindowFrame::apply_lock_state);
setCentralWidget(master_stack);
dock_toolbar_ = new ui::DockToolBar(this);
addToolBar(Qt::TopToolBarArea, dock_toolbar_);
// Pushpin chips are embedded directly inside the main toolbar (see
// ToolBar::ToolBar). Visibility/enabled state now follows the parent
// toolbar — no explicit gating needed.
pushpin_bar_ = dock_toolbar_->inner()->pushpin_bar();
dock_status_bar_ = new ui::DockStatusBar(this);
setStatusBar(dock_status_bar_);
stack_ = master_stack;
auto* toolbar = dock_toolbar_->inner();
// ── Window registry wiring ──────────────────────────────────────────────
// Layout/workspace persistence lives in core/layout (LayoutCatalog +
// WorkspaceShell + WorkspaceSnapshotRing). Title bar reads the active
// layout name from WorkspaceShell::current_name() inside
// update_window_title(), so no signal wiring is needed here.
WindowCycler::instance().register_window(this);
connect(this, &QObject::destroyed, this, [this]() { WindowCycler::instance().unregister_window(this); });
dock_router_ = new DockScreenRouter(dock_manager_, this);
setup_dock_screens();
// Tab bar navigation: open the selected screen exclusively — closes all other
// panels and fills the full area. Each tab is a fresh independent screen,
// not nested into whatever was previously open.
connect(tab_bar_, &ui::TabBar::tab_changed, this, [this](const QString& id) {
if (!locked_)
dock_router_->navigate(id, true);
});
connect(dock_router_, &DockScreenRouter::screen_changed, tab_bar_, &ui::TabBar::set_active);
// Update the main window title bar to reflect the current screen name.
connect(dock_router_, &DockScreenRouter::screen_changed, this, [this](const QString&) { update_window_title(); });
// Per-screen tool filter wiring removed (Tool RAG / Tier-0 model).
// The LLM now sees a 6-tool Tier-0 prefix on every turn and discovers
// the rest via tool_list — making per-screen scoping unnecessary and
// counterproductive (it would prevent the LLM from finding tools the
// user might want regardless of which screen happens to be active).
// Chat bubble — floats over dock_manager_ content area
chat_bubble_ = new AiChatBubble(dock_manager_);
{
auto r = SettingsRepository::instance().get("appearance.show_chat_bubble");
bool show = !r.is_ok() || r.value() != "false";
chat_bubble_->setVisible(show);
if (show)
chat_bubble_->raise();
}
// Re-raise and reposition the bubble after each navigation — dock geometry
// shifts when panels open/close, so the bubble needs to re-anchor itself.
connect(dock_router_, &DockScreenRouter::screen_changed, this, [this](const QString&) {
if (!chat_bubble_)
return;
auto r = SettingsRepository::instance().get("appearance.show_chat_bubble");
bool show = !r.is_ok() || r.value() != "false";
chat_bubble_->setVisible(show);
if (show) {
chat_bubble_->reposition();
chat_bubble_->raise();
}
});
// Apply "Show AI Chat Bubble" the moment it changes instead of waiting for the
// next screen change. settings.changed is published by whoever writes the
// setting (e.g. the MCP set_setting tool) and may arrive from a worker
// thread, so re-read and apply on the GUI thread. Every frame owns a bubble,
// so unlike the navigation events below this one is applied by all frames.
EventBus::instance().subscribe(this, "settings.changed", [this](const QVariantMap& d) {
const QString key = d.value("key").toString();
if (!key.isEmpty() && key != QLatin1String("appearance.show_chat_bubble"))
return;
QMetaObject::invokeMethod(
this,
[this]() {
// Chat mode hides the bubble on purpose; leaving it re-applies the setting.
if (!chat_bubble_ || chat_mode_)
return;
auto r = SettingsRepository::instance().get("appearance.show_chat_bubble");
const bool show = !r.is_ok() || r.value() != "false";
chat_bubble_->setVisible(show);
if (show) {
chat_bubble_->reposition();
chat_bubble_->raise();
}
},
Qt::QueuedConnection);
});
connect(toolbar, &ui::ToolBar::chat_mode_toggled, this, &WindowFrame::toggle_chat_mode);
connect(toolbar, &ui::ToolBar::navigate_to, this, [this](const QString& id) {
if (!locked_)
dock_router_->navigate(id, true);
});
// Debounced dock-layout save: ADS emits a burst of signals during
// add/replace/remove; coalesce into one write ~500 ms after the last change
// so rapid edits don't hammer QSettings and so crashes preserve layout.
dock_layout_save_timer_ = new QTimer(this);
dock_layout_save_timer_->setSingleShot(true);
dock_layout_save_timer_->setInterval(500);
connect(dock_layout_save_timer_, &QTimer::timeout, this, [this]() {
if (!dock_manager_)
return;
// Drop hidden/closed panels before serialising so the saved layout is
// exactly the visible grid — otherwise closed areas accumulate into
// dozens of phantom splits that corrupt the restored arrangement.
// prune emits dockWidgetRemoved/viewToggled (→ schedule_dock_layout_save);
// suppress that re-entrant restart while we save the freshly-pruned tree.
suppress_layout_save_ = true;
if (dock_router_)
dock_router_->prune_hidden_panels();
suppress_layout_save_ = false;
// SessionManager.save_dock_layout fans out to WorkspaceSnapshotRing
// (60s rate-limited auto snapshot). That covers what the legacy
// 5-min WorkspaceManager autosave used to do, with better cadence.
SessionManager::instance().save_dock_layout(window_id_, dock_manager_->saveState());
});
connect(toolbar, &ui::ToolBar::dock_command, this,
[this](const QString& action, const QString& primary, const QString& secondary) {
if (locked_)
return;
if (action == "add")
dock_router_->add_alongside(primary, secondary);
else if (action == "remove")
dock_router_->remove_screen(primary);
else if (action == "replace")
dock_router_->replace_screen(primary, secondary);
schedule_dock_layout_save();
});
// MCP navigation tool → dock_router (cross-thread safe)
//
// The three app-wide subscriptions below (nav.switch_screen,
// equity.open_order_ticket, nav.open_symbol) are registered by EVERY frame, so
// each queued handler first asks wf_app_event_target() whether it is the one
// frame that should act — otherwise one publish would act in all open windows.
EventBus::instance().subscribe(this, "nav.switch_screen", [this](const QVariantMap& nav_data) {
QString screen_id = nav_data["screen_id"].toString();
// Optional: callers that want a clean "take me there" switch (replace the
// current view) rather than the default auto-tiled split set exclusive=true.
const bool exclusive = nav_data.value("exclusive", false).toBool();
if (!screen_id.isEmpty())
QMetaObject::invokeMethod(
dock_router_,
[this, screen_id, exclusive]() {
if (locked_ || wf_app_event_target() != this)
return;
dock_router_->navigate(screen_id, exclusive);
},
Qt::QueuedConnection);
});
// Equity Research "BUY/SELL" → reuse the Equity Trading order ticket without
// leaving Research. We materialise the trading screen (hidden — no tab switch)
// if it doesn't exist yet, then open its app-modal ticket, which pops over the
// current tab. The trading screen owns the form + the paper/live placement path.
EventBus::instance().subscribe(this, "equity.open_order_ticket", [this](const QVariantMap& d) {
const QString symbol = d.value("symbol").toString();
if (symbol.isEmpty())
return;
const QString exchange = d.value("exchange").toString();
const QStringList match_exchanges = d.value("match_exchanges").toStringList();
const bool is_buy = d.value("is_buy").toBool();
const double price = d.value("price").toDouble();
QMetaObject::invokeMethod(
this,
[this, symbol, exchange, match_exchanges, is_buy, price]() {
if (locked_ || !dock_router_ || wf_app_event_target() != this)
return;
const QString id = QStringLiteral("equity_trading");
if (!dock_router_->screen_widget(id))
dock_router_->materialize_now(id); // create hidden, don't raise
if (auto* trading = qobject_cast<screens::EquityTradingScreen*>(dock_router_->screen_widget(id)))
trading->open_external_order_ticket(symbol, exchange, match_exchanges, is_buy, price);
},
Qt::QueuedConnection);
});
// "Open this symbol in <screen>" — the reliable way for one panel to hand a
// ticker to another. Publishing nav.switch_screen followed by a screen's own
// load event loses the symbol whenever the target hasn't been constructed
// yet: nav.switch_screen navigates on a queued call, so the second publish
// runs before the target exists to receive it. Here navigate() runs first
// (it materialises the screen synchronously), then the symbol is delivered
// through IGroupLinked — the same entry point symbol-group linking uses.
// Payload: screen_id, symbol (both required); asset_class (default
// "equity"; crypto_trading only accepts "crypto"), exchange, exclusive.
EventBus::instance().subscribe(this, "nav.open_symbol", [this](const QVariantMap& d) {
const QString screen_id = d.value("screen_id").toString();
SymbolRef ref;
ref.symbol = d.value("symbol").toString().trimmed();
ref.asset_class = d.value("asset_class", QStringLiteral("equity")).toString();
ref.exchange = d.value("exchange").toString();
const bool exclusive = d.value("exclusive", false).toBool();
if (screen_id.isEmpty() || !ref.is_valid())
return;
QMetaObject::invokeMethod(
this,
[this, screen_id, ref, exclusive]() {
// Only the target frame (see wf_app_event_target) acts; the other
// frames' copies of this handler are no-ops.
if (locked_ || !dock_router_ || wf_app_event_target() != this)
return;
dock_router_->navigate(screen_id, exclusive);
auto* linked = dynamic_cast<IGroupLinked*>(dock_router_->screen_widget(screen_id));
if (!linked) {
LOG_WARN("WindowFrame",
QString("nav.open_symbol: '%1' does not accept a symbol (no IGroupLinked)").arg(screen_id));
return;
}
linked->on_group_symbol_changed(ref);
},
Qt::QueuedConnection);
});
// ── Keyboard shortcuts via ActionRegistry (Phase 4) ───────────────────────
//
// Every global action is now defined once in core/actions/builtin_actions.cpp
// and registered with ActionRegistry. KeyConfigManager still owns the
// QAction-per-KeyAction (so live re-binding via Settings → Keybindings
// continues to work), but each frame routes the QAction's `triggered`
// signal through ActionRegistry::invoke(action_id, ctx) instead of the
// pre-Phase-4 captured-`this` lambdas.
//
// The captured-`this` form had a latent bug in multi-window setups: an
// action triggered from frame B would still execute against frame A's
// state (locked_, focus_mode_, etc.) because `this` was fixed at bind
// time. The registry resolves the focused frame live at invoke time.
auto& km = KeyConfigManager::instance();
auto& reg = ActionRegistry::instance();
QSet<QString> key_bound_ids; // registry ids whose hotkey is owned by a KeyAction
for (KeyAction a : km.all_actions()) {
const QString action_id = actions::action_id_for(a);
if (action_id.isEmpty())
continue; // per-screen action; handled elsewhere
if (!reg.contains(action_id)) {
LOG_WARN("WindowFrame",
QString("KeyAction → action_id mapping references unregistered id: %1").arg(action_id));
continue;
}
key_bound_ids.insert(action_id);
auto* act = km.action(a);
if (!act)
continue;
// LockNow runs even when this frame isn't focused (e.g. user pressed
// it from a dialog) — it's a global "secure my session" command.
// Everything else is window-scoped so only the focused frame fires.
act->setShortcutContext(a == KeyAction::LockNow ? Qt::ApplicationShortcut : Qt::WindowShortcut);
addAction(act);
connect(act, &QAction::triggered, this, [this, action_id]() {
// KeyConfigManager owns ONE QAction per KeyAction and every frame
// connects to it, so a single key press reaches this lambda once per
// open window. Without this guard toggles (F11, F10, F9, always-on-top)
// cancelled themselves out and "new window" / "cycle windows" ran N
// times. Only the frame the action resolves to handles it.
WindowFrame* target = wf_app_event_target();
if (target != this)
return;
// Build a fresh context every invocation so the focused frame
// is resolved live rather than captured. This is the bug-fix
// that motivated the refactor.
CommandContext ctx;
ctx.shell = &TerminalShell::instance();
ctx.focused_frame = target;
// ctx.focused_panel left null — Phase 7 wires PanelRegistry's
// focused-panel lookup once panels are UUID-keyed.
auto r = ActionRegistry::instance().invoke(action_id, ctx);
if (r.is_err()) {
LOG_DEBUG("WindowFrame",
QString("Action %1 returned error: %2").arg(action_id, QString::fromStdString(r.error())));
}
});
}
// Registry actions that declare a default hotkey but have no KeyAction
// (cmdbar.toggle = Ctrl+\, palette.open = Ctrl+Shift+P). Nothing bound their
// ActionDef::default_hotkey, so the documented Ctrl+\ did nothing. Each frame
// owns its own QAction here with window scope, so only the active window fires.
for (const QString& action_id : reg.all_ids()) {
if (key_bound_ids.contains(action_id))
continue;
const ActionDef* def = reg.find(action_id);
if (!def || def->default_hotkey.isEmpty())
continue;
// Never share a sequence with a KeyAction: two QActions on one key in the
// same window make Qt treat the shortcut as ambiguous and fire neither.
bool clashes = false;
for (KeyAction a : km.all_actions()) {
if (km.key(a) == def->default_hotkey) {
clashes = true;
break;
}
}
if (clashes) {
LOG_WARN("WindowFrame", QString("Hotkey for %1 (%2) is already bound to a KeyAction — not binding it")
.arg(action_id, def->default_hotkey.toString()));
continue;
}
auto* hotkey_act = new QAction(this);
hotkey_act->setShortcut(def->default_hotkey);
hotkey_act->setShortcutContext(Qt::WindowShortcut);
addAction(hotkey_act);
connect(hotkey_act, &QAction::triggered, this, [this, action_id]() {
// Shell surfaces (command bar, palette): not on the login/lock/chat stacks.
if (locked_ || !stack_ || stack_->currentIndex() != 1)
return;
CommandContext ctx;
ctx.shell = &TerminalShell::instance();
ctx.focused_frame = this;
auto r = ActionRegistry::instance().invoke(action_id, ctx);
if (r.is_err()) {
LOG_DEBUG("WindowFrame",
QString("Action %1 returned error: %2").arg(action_id, QString::fromStdString(r.error())));
}
});
}
// Toolbar actions
connect(toolbar, &ui::ToolBar::action_triggered, this, [this](const QString& action) {
if (locked_)
return;
if (action == "browse_components") {
// Same path as the keyboard shortcut so the behavior stays in one
// place — the KeyConfigManager action will be triggered directly.
if (auto* act = KeyConfigManager::instance().action(KeyAction::BrowseComponents))
act->trigger();
return;
}
if (action == "new_window") {
// Ask the user which monitor when more than one is connected.
// pick() returns the only screen if there's just one, and
// nullptr if the user cancels the dialog — in which case no
// window is created.
QScreen* target = MonitorPickerDialog::pick(this, this->screen());
if (!target)
return;
auto* w = new WindowFrame(WindowFrame::next_window_id());
w->setAttribute(Qt::WA_DeleteOnClose);
const QRect sg = target->availableGeometry();
w->resize(sg.width() * 9 / 10, sg.height() * 9 / 10);
w->move(sg.center() - w->rect().center());
w->show();
w->raise();
w->activateWindow();
} else if (action == "close_window") {
// Same as the titlebar close button — WA_DeleteOnClose handles
// teardown, closeEvent persists this window's layout. If this is
// the last window, the app honours general.on_last_window_close
// (quit or surface the Launchpad), exactly like a manual close.
close();
} else if (action == "close_all_windows") {
// Snapshot the registry first: each close() schedules the frame's
// destruction (WA_DeleteOnClose → deleteLater) which unregisters it,
// so iterating the live registry would be unsafe. The copy is stable.
const auto frames = WindowRegistry::instance().frames();
for (WindowFrame* w : frames)
if (w)
w->close();
} else if (action.startsWith("move_to_monitor:")) {
// Move this window to the named monitor. We resolve by QScreen::name
// (not index) because index ordering flips on plug/unplug events.
const QString target_name = action.mid(QStringLiteral("move_to_monitor:").size());
QScreen* target = nullptr;
for (QScreen* s : QGuiApplication::screens()) {
if (s->name() == target_name) {
target = s;
break;
}
}
if (!target) {
LOG_WARN("WindowFrame", QString("Move to monitor: screen '%1' not found").arg(target_name));
return;
}
move_to_screen(target);
} else if (action.startsWith("panel_")) {
// Float a screen — in ADS mode, navigate dock_router; in legacy, spawn window
static const QMap<QString, QPair<QString, QString>> panel_map = {
{"panel_dashboard", {"Dashboard", "dashboard"}},
{"panel_watchlist", {"Watchlist", "watchlist"}},
{"panel_news", {"News Feed", "news"}},
{"panel_portfolio", {"Portfolio", "portfolio"}},
{"panel_markets", {"Markets", "markets"}},
{"panel_crypto", {"Crypto Trading", "crypto_trading"}},
{"panel_equity", {"Equity Trading", "equity_trading"}},
{"panel_algo", {"Algo Trading", "algo_trading"}},
{"panel_research", {"Equity Research", "equity_research"}},
{"panel_economics", {"Economics", "economics"}},
{"panel_geopolitics", {"Geopolitics", "geopolitics"}},
{"panel_ai_chat", {"AI Chat", "ai_chat"}},
};
if (panel_map.contains(action)) {
const auto [title, route] = panel_map[action];
if (dock_router_)
dock_router_->navigate(route);
}
} else if (action == "perspective_save") {
if (dock_manager_) {
bool ok = false;
const QString name = QInputDialog::getText(this, tr("Save Layout"), tr("Layout name:"),
QLineEdit::Normal, QString(), &ok);
if (ok && !name.trimmed().isEmpty()) {
dock_manager_->addPerspective(name.trimmed());
LOG_INFO("WindowFrame", QString("Saved perspective: %1").arg(name.trimmed()));
}
}
} else if (action.startsWith("perspective_")) {
// Quick Switch — navigate directly to a preset screen layout
// 2 screens = 1:1 side-by-side, 4 screens = 2x2 grid
static const QMap<QString, QStringList> view_screens = {
// Trading
{"perspective_trading", {"crypto_trading", "watchlist", "markets", "news"}},
{"perspective_equity", {"equity_trading", "watchlist"}},
{"perspective_algo", {"algo_trading", "backtesting"}},
// Research
{"perspective_research", {"equity_research", "markets", "screener", "news"}},
{"perspective_derivatives", {"derivatives", "surface_analytics"}},
{"perspective_fno", {"fno", "surface_analytics", "equity_trading"}},
{"perspective_ma", {"ma_analytics", "news"}},
// Portfolio
{"perspective_portfolio", {"portfolio", "markets", "watchlist", "news"}},
// News & Markets
{"perspective_news", {"news", "markets"}},
{"perspective_markets", {"markets", "watchlist"}},
// Economics & Data
{"perspective_economics", {"economics", "dbnomics", "gov_data", "asia_markets"}},
{"perspective_data", {"data_sources", "data_mapping"}},
// Geopolitics
{"perspective_geopolitics", {"geopolitics", "maritime", "relationship_map", "news"}},
// AI & Quant
{"perspective_quant", {"ai_quant_lab", "quantlib", "backtesting", "markets"}},
{"perspective_ai", {"ai_chat", "agent_config", "agent_workbench"}},
// Tools
{"perspective_tools", {"code_editor", "node_editor"}},
};
const auto it = view_screens.find(action);
if (it != view_screens.end() && dock_router_) {
const QStringList& screens = it.value();
if (!screens.isEmpty()) {
dock_router_->navigate(screens[0], true); // first exclusive
for (int i = 1; i < screens.size(); ++i)
dock_router_->navigate(screens[i]); // fill grid
}
LOG_INFO("WindowFrame", QString("Quick Switch: %1 (%2 panels)").arg(action).arg(screens.size()));
}
} else if (action == "logout") {
auth::AuthManager::instance().logout();
} else if (action == "fullscreen") {
if (isFullScreen())
showNormal();
else
showFullScreen();
} else if (action == "focus_mode") {
// Auth screens must never reveal the shell via focus-mode toggle.
if (stack_ && stack_->currentIndex() == 0)
return;
focus_mode_ = !focus_mode_;
if (dock_toolbar_)
dock_toolbar_->setVisible(!focus_mode_);
if (dock_status_bar_)
dock_status_bar_->setVisible(!focus_mode_);
} else if (action == "always_on_top") {
set_always_on_top(!always_on_top_);
} else if (action == "refresh") {
refresh_focused_panel(); // same path as the F5 shortcut
} else if (action == "layout_new" || action == "layout_save_as") {
// Both routes prompt for a name then save. layout.new = blank
// workspace under that name; layout.save_as = capture-current
// under that name. Handlers in builtin_actions distinguish.
ui::LayoutSaveAsDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
CommandContext ctx;
ctx.shell = &TerminalShell::instance();
ctx.focused_frame = this;
ctx.args.insert(QStringLiteral("name"), dlg.name());
const QString action_id =
(action == "layout_new") ? QStringLiteral("layout.new") : QStringLiteral("layout.save_as");
auto r = ActionRegistry::instance().invoke(action_id, ctx);
if (r.is_err())
LOG_WARN("WindowFrame", QString("%1 failed: %2").arg(action_id, QString::fromStdString(r.error())));
}
} else if (action == "layout_open") {
ui::LayoutOpenDialog dlg(this);
if (dlg.exec() == QDialog::Accepted && !dlg.selected_id().is_null()) {
CommandContext ctx;
ctx.shell = &TerminalShell::instance();
ctx.focused_frame = this;
ctx.args.insert(QStringLiteral("name"), dlg.selected_id().to_string());
auto r = ActionRegistry::instance().invoke(QStringLiteral("layout.switch"), ctx);
if (r.is_err())
LOG_WARN("WindowFrame", QString("layout.switch failed: %1").arg(QString::fromStdString(r.error())));
}
} else if (action == "layout_save") {
// If a layout is currently loaded, save under its name. Otherwise
// prompt for one (treat as save-as with no initial name).
const QString cur = layout::WorkspaceShell::current_name();
QString target = cur;
if (target.isEmpty()) {
ui::LayoutSaveAsDialog dlg(this);
if (dlg.exec() != QDialog::Accepted) {
return;
}
target = dlg.name();
}
CommandContext ctx;
ctx.shell = &TerminalShell::instance();
ctx.focused_frame = this;
ctx.args.insert(QStringLiteral("name"), target);
auto r = ActionRegistry::instance().invoke(QStringLiteral("layout.save"), ctx);
if (r.is_err())
LOG_WARN("WindowFrame", QString("layout.save failed: %1").arg(QString::fromStdString(r.error())));
} else if (action == "import_data") {
QString path = QFileDialog::getOpenFileName(this, tr("Import Layout"), QDir::homePath(),
tr("Fincept Layout (*.flayout *.fwsp);;All Files (*)"));
if (!path.isEmpty()) {
auto r = LayoutCatalog::instance().import_from(path);
if (r.is_err())
QMessageBox::warning(this, tr("Import Failed"), QString::fromStdString(r.error()));
}
} else if (action == "export_data") {
const LayoutId cur_id = layout::WorkspaceShell::current_id();
if (cur_id.is_null()) {
QMessageBox::information(this, tr("Export Layout"), tr("Open or save a layout first, then export it."));
} else {
QString path = QFileDialog::getSaveFileName(this, tr("Export Layout"), QDir::homePath(),
tr("Fincept Layout (*.flayout)"));
if (!path.isEmpty()) {
auto r = LayoutCatalog::instance().export_to(cur_id, path);
if (r.is_err())
QMessageBox::warning(this, tr("Export Failed"), QString::fromStdString(r.error()));
}
}
} else if (action == "check_updates") {
// Help ▸ Check for Updates. silent=false so the user gets a result
// either way — a menu-triggered check that says nothing reads as broken.
services::UpdateService::instance().check_for_updates(/*silent=*/false);
} else if (action == "screenshot") {
QScreen* scr = this->screen();
if (!scr)
scr = QApplication::primaryScreen();
QPixmap px = scr->grabWindow(winId());
QString path = QFileDialog::getSaveFileName(
this, tr("Save Screenshot"),
QDir::homePath() + "/fincept_" + QDateTime::currentDateTime().toString("yyyyMMdd_HHmmss") + ".png",
tr("PNG Images (*.png)"));
if (!path.isEmpty()) {
px.save(path, "PNG");
LOG_INFO("WindowFrame", QString("Screenshot saved: %1").arg(path));
}
}
});
// Toolbar logout
connect(toolbar, &ui::ToolBar::logout_clicked, this, []() { auth::AuthManager::instance().logout(); });
// Toolbar plan badge → Plans & Pricing (same path as the billing.plans
// action); the screen's BACK / CONTINUE WITH FREE returns to where the
// user was — dock UI or chat mode.
connect(toolbar, &ui::ToolBar::plan_clicked, this, &WindowFrame::show_pricing);
if (auto* pricing = auth_stack_->findChild<screens::PricingScreen*>(QString(), Qt::FindDirectChildrenOnly))
connect(pricing, &screens::PricingScreen::back_requested, this, &WindowFrame::leave_pricing);
// Toolbar ENTERPRISE → Fincept Terminal Enterprise (the private edition) dialog.
connect(toolbar, &ui::ToolBar::upgrade_clicked, this,
[this]() { ui::UpgradeDialog::show_now(this, QStringLiteral("toolbar")); });
// Auth state
connect(&auth::AuthManager::instance(), &auth::AuthManager::auth_state_changed, this,
&WindowFrame::on_auth_state_changed);
connect(&auth::AuthManager::instance(), &auth::AuthManager::logged_out, this, &WindowFrame::on_auth_state_changed);
// Restore window state (maximised, toolbar positions, etc.)
// Note: restoreState() also restores QToolBar visibility, which can
// hide the toolbar from stale/corrupt saved state. We force it visible
// afterward unless the user is intentionally in focus/chat mode.
const QByteArray saved_state = SessionManager::instance().load_state(window_id_);
if (!saved_state.isEmpty())
restoreState(saved_state);
// Toolbar/status bar visibility is controlled by set_shell_visible() based on
// auth state. Start hidden — on_auth_state_changed() will show them if the user
// is already authenticated and lands on the app stack.
if (dock_toolbar_)
dock_toolbar_->setVisible(false);
if (dock_status_bar_)
dock_status_bar_->setVisible(false);
// Restore ADS dock layout — must happen after all screens are registered
// but BEFORE the initial navigate, so we don't create a widget that
// conflicts with restoreState's layout.
// Layout version: bump this whenever the dock layout format changes to
// automatically discard stale/corrupt saved state from previous versions.
// v5: closed panels are now pruned before save (prune_hidden_panels), so
// pre-v5 blobs — bloated with dozens of phantom closed single-widget areas
// that reshuffle the restored grid — are discarded rather than restored.
static constexpr int kDockLayoutVersion = 5;
bool dock_restored = false;
if (dock_manager_) {
QSettings persp_settings;
SessionManager::instance().load_perspectives(persp_settings);
dock_manager_->loadPerspectives(persp_settings);
// Suppress the debounced dock-layout save during bulk registration
// and restoreState. These operations fire dockWidgetAdded and
// viewToggled dozens of times — each restarts the 500ms timer, and
// the eventual save would just re-write the state we're loading.
suppress_layout_save_ = true;
const int saved_version = SessionManager::instance().dock_layout_version(window_id_);
if (saved_version == kDockLayoutVersion) {
const QByteArray saved_dock = SessionManager::instance().load_dock_layout(window_id_);
if (!saved_dock.isEmpty()) {
dock_router_->ensure_all_registered();
// Also suppress screen construction during restoreState —
// ADS toggles each restored widget visible, which fires
// visibilityChanged→materialize_screen. Constructing all
// visible screens inline blocks the first paint for seconds.
// Screens are materialized progressively after show().
dock_router_->set_suppress_materialize(true);
dock_restored = dock_manager_->restoreState(saved_dock);
dock_router_->set_suppress_materialize(false);
// Sanity check: a genuinely corrupt blob restores into dozens of
// areas (the pre-prune bug produced 28-33). A legit layout now
// tops out around the 4-panel auto-grid plus a few floating /
// torn-off panels, so 6 was too tight — it would nuke a valid
// grid+float layout. prune_hidden_panels() keeps saved blobs at
// visible-panel count, so this is only a backstop for true bloat.
if (dock_restored && dock_manager_->openedDockAreas().size() > 16) {
LOG_WARN("WindowFrame", QString("Dock layout corrupt: %1 open areas — resetting")
.arg(dock_manager_->openedDockAreas().size()));
dock_restored = false;
}
}
} else if (saved_version != 0) {
LOG_INFO("WindowFrame", QString("Dock layout version mismatch (saved %1, expected %2) — resetting")
.arg(saved_version)
.arg(kDockLayoutVersion));
}
if (!dock_restored) {
// Close all dock widgets that may have been opened by a failed restore
for (auto* dw : dock_manager_->dockWidgetsMap())
dw->toggleView(false);
}
suppress_layout_save_ = false;
// Save the current version so next startup knows the format.
SessionManager::instance().set_dock_layout_version(window_id_, kDockLayoutVersion);
}
// Show the app or auth stack based on authentication state.
// If dock layout was restored, the saved tabs are already visible.
// Otherwise, navigate to dashboard as default.
auto& auth_mgr = auth::AuthManager::instance();
if (auth_mgr.is_authenticated() || auth_mgr.is_loading()) {
// If user is authenticated and has a PIN, show lock screen first —
// UNLESS this is an additional window opened while an existing
// window has already cleared the PIN gate this session.
// pin_gate_cleared_ was bootstrapped above from the process-wide
// InactivityGuard flag (which is the single source of truth for
// "is the terminal locked?"); skipping the prompt here just
// mirrors the unlocked state into the new frame.
if (auth_mgr.is_authenticated() && auth::PinManager::instance().has_pin() && !pin_gate_cleared_) {
LOG_INFO("WindowFrame", "Session restored — showing PIN unlock");
lock_screen_->show_unlock();
locked_ = true;
set_shell_visible(false);
stack_->setCurrentIndex(3);
} else if (auth_mgr.is_authenticated() && auth::PinManager::instance().has_pin()) {
LOG_INFO("WindowFrame", "Session already unlocked — skipping PIN prompt for additional window");
set_shell_visible(true);
stack_->setCurrentIndex(1);
} else if (auth_mgr.is_authenticated()) {
// Authenticated but no PIN yet — will be caught by on_auth_state_changed
on_auth_state_changed();
} else {
// Still loading — show app stack temporarily (loading state)
set_shell_visible(true);
stack_->setCurrentIndex(1);
}
// Recovery / "Continue from last session" path: WorkspaceShell::apply
// spawns this frame with a non-null adopted_uuid and will call
// apply_layout(fl) immediately after construction returns. Skip the
// default dashboard navigate so we don't (a) leave a stray dashboard
// dock widget for ADS restoreState to flag-as-unassigned, and
// (b) pay the cost of constructing DashboardScreen just to discard it.
// If apply_layout subsequently fails, the caller is responsible for
// falling back to a default screen.
if (!dock_restored && adopted_uuid.is_null()) {
// Defer navigation so the window can paint its chrome (toolbar,
// tab bar, status bar) before the first screen factory runs.
// DashboardScreen construction can take 200-500ms; without this
// the user sees a blank frame for that entire duration.
// Skip it when something has already been opened in the meantime —
// e.g. a panel torn off / moved into this brand-new window — so the
// user doesn't get an unrequested Dashboard tiled next to it.
QTimer::singleShot(0, this, [this]() {
if (dock_router_->current_screen_id().isEmpty())
dock_router_->navigate("dashboard");
});
LOG_INFO("WindowFrame", "Deferred default dashboard navigate to after first paint");
} else if (!dock_restored) {
LOG_INFO("WindowFrame", QString("Deferring default navigate — frame spawned with adopted uuid %1 "
"(apply_layout will populate)")
.arg(adopted_uuid.to_string()));
} else {
// Dock layout restored — tabs are positioned but screens are
// still placeholders (materialize was suppressed above). Defer
// construction: materialize the active panel first so the user
// sees content quickly, then fill in remaining visible panels.
const QString last = SessionManager::instance().last_screen(window_id_);
QTimer::singleShot(0, this, [this, last]() {
if (!dock_router_ || !dock_manager_)
return;
// Active panel first — user sees populated content immediately
if (!last.isEmpty()) {
dock_router_->materialize_now(last);
if (auto* dw = dock_router_->find_dock_widget(last)) {
if (!dw->isClosed()) {
dw->raise();
dw->setAsCurrentTab();
}
}
tab_bar_->set_active(last);
}
// Remaining visible panels — ONE PER EVENT-LOOP TURN. Doing the
// whole loop in a single tick re-froze the window the instant
// the first panel painted: a 4-panel layout constructed three
// heavy screens back to back with no chance to repaint between
// them. Snapshot the ids first so the walk is stable while the
// dock map changes underneath it.
QStringList pending;
for (const auto& entry : dock_manager_->dockWidgetsMap().toStdMap()) {
if (entry.first == last)
continue;
if (entry.second && !entry.second->isClosed())
pending << entry.first;
}
if (pending.isEmpty())
return;
// Copyable, self-rescheduling functor: materialise the head,
// then post itself again with the tail. QPointer + the `frame`
// context object mean a closed window simply drops the rest.
struct MaterialiseWalk {
QPointer<WindowFrame> frame;
QStringList todo;
void operator()() const {
if (!frame || todo.isEmpty())
return;
auto* router = frame->dock_router();
if (!router)
return;
// The user may have closed this panel on an earlier tick.
if (auto* dw = router->find_dock_widget(todo.front()); dw && !dw->isClosed())
router->materialize_now(todo.front());
const QStringList rest = todo.mid(1);
if (!rest.isEmpty())
QTimer::singleShot(0, frame.data(), MaterialiseWalk{frame, rest});
}
};
QTimer::singleShot(0, this, MaterialiseWalk{this, pending});
});
}
} else {
on_auth_state_changed();
}
// Periodic refresh of user credits/plan (every 3 minutes). Skip while
// the terminal is locked — we shouldn't be making authenticated API
// calls behind the back of the PIN gate, and the user can't see the
// refreshed data anyway.
user_refresh_timer_ = new QTimer(this);
user_refresh_timer_->setInterval(3 * 60 * 1000);
connect(user_refresh_timer_, &QTimer::timeout, this, []() {
auto& auth = auth::AuthManager::instance();
if (!auth.is_authenticated())
return;
if (auth::InactivityGuard::instance().is_terminal_locked())
return;
auth.refresh_user_data();
});
// §P3: no timer->start() in a constructor. Starting it here made every
// window fire an authenticated network refresh every 3 minutes for the
// whole process lifetime — including windows that were minimised or never
// shown. WindowFrame's header is shared with the multi-window shell, so
// rather than add showEvent/hideEvent overrides to it we gate the timer
// with an event filter that owns exactly the same lifecycle (and also
// covers minimise, which sends WindowStateChange rather than Hide).
installEventFilter(new VisibilityTimerGate(user_refresh_timer_, this));
// Confetti overlay (parented to central widget so it covers the whole app)
// Refresh user data when app regains focus (updates toolbar credits/plan)
connect(qApp, &QApplication::applicationStateChanged, this, [](Qt::ApplicationState state) {
if (state == Qt::ApplicationActive) {
auto& auth = auth::AuthManager::instance();
// Skip refresh while locked — same reason as the periodic
// timer above. check_for_resume_lock() below still runs so
// a wall-clock-elapsed lock fires immediately on wake.
if (auth.is_authenticated() && !auth::InactivityGuard::instance().is_terminal_locked())
auth.refresh_user_data();
// Resume-from-sleep lock: QTimer pauses during OS suspend, so a
// 5-minute timer can carry 4:59 of remaining time across a
// 30-minute nap. Ask the guard to check wall-clock delta and
// force a lock if the user was effectively idle for the full
// timeout. No-op when the guard is disabled or already locked.
auth::InactivityGuard::instance().check_for_resume_lock();
}
});
}
void WindowFrame::set_shell_visible(bool visible) {
if (dock_toolbar_)
dock_toolbar_->setVisible(visible && !focus_mode_ && !chat_mode_);
if (dock_status_bar_)
dock_status_bar_->setVisible(visible && !focus_mode_ && !chat_mode_);
if (!visible) {
// Reset title to plain app name — no screen suffix while on auth screens
const QString profile = ProfileManager::instance().active();
setWindowTitle(profile == "default" ? QStringLiteral("Fincept Terminal")
: QStringLiteral("Fincept Terminal [%1]").arg(profile));
}
}
void WindowFrame::update_window_title() {
// Brand stays in English; only the workspace/screen suffix (translated
// via DockScreenRouter::title_for_id) responds to language changes.
QString title = QStringLiteral("Fincept Terminal");
const QString profile = ProfileManager::instance().active();
if (profile != "default")
title += QStringLiteral(" [%1]").arg(profile);
// Workspace / screen name must never appear in the title while the user
// is on the auth or lock stack — that would leak the last-visited screen
// to an unauthenticated viewer.
const bool shell_visible = stack_ && stack_->currentIndex() == 1;
if (shell_visible) {
// Layout name set by WorkspaceShell::apply on every successful
// layout switch / cold-boot restore. Empty until first apply.
const QString ws = layout::WorkspaceShell::current_name();
if (!ws.isEmpty())
title += QString(" — %1").arg(ws);
if (dock_router_) {
const QString id = dock_router_->current_screen_id();
if (!id.isEmpty())
title += QString(" — %1").arg(DockScreenRouter::title_for_id(id));
}
}
setWindowTitle(title);
}
void WindowFrame::set_always_on_top(bool on) {
if (always_on_top_ == on)
return;
always_on_top_ = on;
Qt::WindowFlags flags = windowFlags();
if (on)
flags |= Qt::WindowStaysOnTopHint;
else
flags &= ~Qt::WindowStaysOnTopHint;
setWindowFlags(flags);
// setWindowFlags hides the window on most platforms; re-show it so the
// change is visible. Preserve maximised/fullscreen state across the toggle.
if (isVisible() || true) // always re-show; isVisible is false after the flag change
show();
SessionManager::instance().save_window_flag(window_id_, "always_on_top", on);
LOG_INFO("WindowFrame", QString("Window %1 always-on-top = %2").arg(window_id_).arg(on ? "on" : "off"));
}
void WindowFrame::move_to_screen(QScreen* target) {
if (!target || screen() == target)
return;
// Preserve maximised/fullscreen state across the move: Qt can't directly
// relocate a maximised window to a different screen, so we restore →
// move → re-apply the state.
const bool was_maximised = isMaximized();
const bool was_fullscreen = isFullScreen();
if (was_maximised || was_fullscreen)
showNormal();
const QRect sg = target->availableGeometry();
QSize new_size = size();
if (new_size.width() > sg.width() || new_size.height() > sg.height())
new_size = QSize(sg.width() * 9 / 10, sg.height() * 9 / 10);
resize(new_size);
move(sg.center() - QPoint(new_size.width() / 2, new_size.height() / 2));
if (was_fullscreen)
showFullScreen();
else if (was_maximised)
showMaximized();
LOG_INFO("WindowFrame", QString("Moved window %1 to monitor '%2'").arg(window_id_).arg(target->name()));
}
WindowId WindowFrame::frame_uuid() const {
if (frame_uuid_.is_null())
frame_uuid_ = WindowId::generate();
return frame_uuid_;
}
void WindowFrame::adopt_frame_uuid(const WindowId& id) {
if (id.is_null()) {
LOG_WARN("WindowFrame", "adopt_frame_uuid: null id ignored");
return;
}
if (!frame_uuid_.is_null() && frame_uuid_ != id) {
// The frame already minted (or adopted) a different UUID — too late,
// any panels created so far carry the old frame_id. Log and bail
// rather than corrupting the PanelRegistry view.
LOG_WARN("WindowFrame", QString("adopt_frame_uuid: refusing to overwrite existing %1 with %2")
.arg(frame_uuid_.to_string(), id.to_string()));
return;
}
frame_uuid_ = id;
}
// ── Phase 6 final: capture / apply layout ───────────────────────────────────
bool WindowFrame::is_active_for_work() const {
// Only isMinimized() drives the active/inactive flag. The previous
// isVisible() check fired false-positives during window construction:
// Qt sends a WindowStateChange BEFORE show() returns, at which point
// isVisible() is still false. changeEvent() then flips
// fincept.active_for_work to false, and any DataHub topic with
// pause_when_inactive=true (market:quote:*, market:sparkline:*)
// silently drops slot fan-out for newly-subscribed dashboard widgets.
// The watchdog then renders "No data yet" even though publishes are
// arriving. Navigating away and back works around it because by then
// the window is visible and the property is true again.
//
// Everything else (virtual-desktop occupancy, occlusion by other apps,
// alt-tab status) is intentionally NOT detected — platform-specific and
// unreliable.
return !isMinimized();
}
namespace {
// Phase 8 / decision 9.2: DataHub reads this dynamic property via
// QObject::property() to decide whether to fan out pause_when_inactive
// topics. Using a dynamic property (rather than a typed accessor) keeps
// the datahub layer free of any "app/WindowFrame.h" include — DataHub
// only needs Qt and the property name.
constexpr const char* kActiveForWorkProp = "fincept.active_for_work";
} // namespace
void WindowFrame::closeEvent(QCloseEvent* event) {
// Synchronously persist every open tab's UI state BEFORE anything else.
// Panels visible at quit never get visibilityChanged(false), so their
// per-screen save would otherwise never fire — and an async save here
// would race process exit. This guarantees each tab reopens with the
// exact config it had (FNO underlying/expiry/broker, equity symbol/
// watchlist, active sub-tab, …).
if (dock_router_)
dock_router_->flush_all_screen_states();
// Force an immediate snapshot bypassing the 60s rate limit so a real
// shutdown always has fresh state to restore from. Per Phase 6 the
// legacy WorkspaceManager autosave is gone — the snapshot ring is the
// single persistence path.
SessionManager::instance().flush_snapshot_now();
SessionManager::instance().save_geometry(window_id_, saveGeometry(), saveState());
// Record the monitor this window is currently on so startup can place
// it back on the same screen even if saveGeometry's absolute coordinates
// would otherwise land off-screen (e.g. monitor disconnected, DPI changed).
if (QScreen* scr = screen())
SessionManager::instance().save_screen_name(window_id_, scr->name());
if (dock_manager_) {
// Persist only the visible grid — drop closed panels so the saved
// layout doesn't carry phantom areas that corrupt the restored
// arrangement (see DockScreenRouter::prune_hidden_panels).
suppress_layout_save_ = true;
if (dock_router_)
dock_router_->prune_hidden_panels();
suppress_layout_save_ = false;
SessionManager::instance().save_dock_layout(window_id_, dock_manager_->saveState());
QSettings tmp;
dock_manager_->savePerspectives(tmp);
SessionManager::instance().save_perspectives(tmp);
}
// ── Persist the window set for next launch ─────────────────────────────
//
// During app quit, multiple closeEvents fire before any window is
// destroyed (WA_DeleteOnClose uses deleteLater). If each saves "all
// except self", the last writer wins with an arbitrary subset — e.g.
// window 0 saves [1,2], then window 2 saves [0,1], and on restart
// main.cpp creates window 0 (unconditional) + 0,1 from the list =
// phantom window. Fix: accumulate closing window IDs in a process-
// level batch; a deferred handler runs after all closeEvents in the
// current event-loop iteration and saves the correct surviving set.
//
// Synchronous fallback: save all IDs (including self) immediately so
// that if the deferred timer doesn't fire during shutdown, we still
// have a complete session snapshot. The deferred handler overwrites
// with the precise surviving set if it does fire.
{
static QSet<int> s_closing_batch;
static bool s_drain_queued = false;
s_closing_batch.insert(window_id_);
QList<int> all_ids = WindowRegistry::instance().frame_ids();
std::sort(all_ids.begin(), all_ids.end());
SessionManager::instance().save_window_ids(all_ids);
if (!s_drain_queued) {
s_drain_queued = true;
QTimer::singleShot(0, qApp, []() {
s_drain_queued = false;
QList<int> all = WindowRegistry::instance().frame_ids();
QList<int> surviving;
for (int id : all) {
if (!s_closing_batch.contains(id))
surviving.append(id);
}
// All windows closing (app quit) → save the full set so
// next launch can restore the complete session.
if (surviving.isEmpty())
surviving = all;
std::sort(surviving.begin(), surviving.end());
SessionManager::instance().save_window_ids(surviving);
s_closing_batch.clear();
});
}
}
// Phase 2: force a workspace snapshot at close. The save_* calls above
// each request a snapshot but the ring rate-limits to 60s — closing a
// window after rapid changes could otherwise miss the latest state.
// Forced flush bypasses the rate limit. Cheap (one INSERT).
SessionManager::instance().flush_snapshot_now();
event->accept();
}
void WindowFrame::resizeEvent(QResizeEvent* event) {
QMainWindow::resizeEvent(event);
if (chat_bubble_)
chat_bubble_->reposition();
if (debug_overlay_ && debug_overlay_->isVisible())
debug_overlay_->reposition();
}
void WindowFrame::changeEvent(QEvent* event) {
QMainWindow::changeEvent(event);
// Refresh the title bar when the active translator changes, so the
// workspace/screen suffix picks up the new locale immediately.
if (event->type() == QEvent::LanguageChange) {
update_window_title();
return;
}
// Remember the frame the user last worked in — the fallback target for
// app-wide events published while no frame is the active window.
if (event->type() == QEvent::ActivationChange) {
if (isActiveWindow())
wf_last_active_frame() = this;
return;
}
if (event->type() != QEvent::WindowStateChange)
return;
// Phase 8 / decision 9.1: emit active_for_work_changed when the flag
// actually flips. Fires on minimise (true → false) AND restore
// (false → true), so DataHub (and any other subscriber) can flush
// pending updates when the user brings the window forward. We compute
// is_active_for_work() now — Qt has already updated windowState by
// the time WindowStateChange fires.
{
const bool now_active = is_active_for_work();
if (now_active != last_active_for_work_) {
last_active_for_work_ = now_active;
// Update the dynamic property DataHub reads. Setting it BEFORE
// emitting the signal so any DataHub subscriber that reacts to
// the signal sees the up-to-date property.
setProperty(kActiveForWorkProp, now_active);
emit active_for_work_changed(now_active);
}
}
if (!(windowState() & Qt::WindowMinimized))
return;
// Only lock if the user opted in and we are actually in an authenticated
// session with a configured PIN — otherwise there is nothing to lock.
auto& auth = auth::AuthManager::instance();
if (!auth.is_authenticated() || !auth::PinManager::instance().has_pin())
return;
auto r = SettingsRepository::instance().get("security.lock_on_minimize");
const bool lock_on_min = r.is_ok() && r.value() == "true";
if (!lock_on_min)
return;
// Multi-window correctness (decision 8.8): minimising one window in a
// multi-window setup is normal user behaviour, not a "walked away from
// desk" event. Only trigger the lock when EVERY frame is minimised.
//
// Qt fires WindowStateChange before the frame is actually marked as
// minimised in some platform queues, so re-check via WindowRegistry
// *after* the next event-loop tick — at that point all minimisations
// queued together (Win+M, "Show desktop") have been applied. The 200ms
// delay also rides through transient lid-close/wake cycles where
// Qt sees a minimise then immediately a restore.
QTimer::singleShot(200, &auth::InactivityGuard::instance(), []() {
if (WindowRegistry::instance().all_minimised())
auth::InactivityGuard::instance().trigger_manual_lock();
});
}
} // namespace fincept