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/WindowFrame_Layout.cpp
//
// Workspace layout serialization: capture_layout() walks the dock manager
// and built-in screens to snapshot a FrameLayout, apply_layout() restores
// one. Together they implement the WorkspaceShell ↔ WindowFrame contract.
//
// Part of the partial-class split of WindowFrame.cpp.
#include "app/DockScreenRouter.h"
#include "app/WindowFrame.h"
#include "core/layout/LayoutCatalog.h"
#include "core/layout/WorkspaceShell.h"
#include "core/logging/Logger.h"
#include "core/panel/PanelMaterialiser.h"
#include "core/symbol/IGroupLinked.h"
#include "screens/common/IStatefulScreen.h"
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QScreen>
#include <DockAreaWidget.h>
#include <DockManager.h>
#include <DockWidget.h>
#include <FloatingDockContainer.h>
#include <algorithm>
namespace fincept {
layout::FrameLayout WindowFrame::capture_layout() const {
layout::FrameLayout fl;
fl.window_id = frame_uuid();
fl.focus_mode = focus_mode_;
fl.always_on_top = always_on_top_;
fl.schema_version = layout::kFrameLayoutVersion;
if (!dock_manager_ || !dock_router_)
return fl;
// ADS dock state — opaque blob covering splits, tab order, sizes. Prune
// closed panels first so workspace snapshots capture only the visible grid
// and don't carry phantom areas that reshuffle the layout on restore. The
// session-layout timer keeps the live tree pruned continuously, so this is
// normally a no-op; it just guarantees a clean blob if a snapshot lands in
// the sub-500ms window after a layout change.
dock_router_->prune_hidden_panels();
fl.dock_state = dock_manager_->saveState();
// Active panel — whichever dock widget currently has focus.
if (auto* focused = dock_manager_->focusedDockWidget()) {
const QString id = focused->objectName();
const auto uuid = dock_router_->panel_uuid_for(id);
if (!uuid.is_null())
fl.active_panel = uuid;
}
// Per-panel state. Walk every dock widget the manager knows about,
// but skip the ones currently closed. The dock manager holds two
// populations:
// 1. Panels the user has actually opened (visible, or visible then
// user-closed).
// 2. Placeholder shells pre-registered by ensure_all_registered() so
// restoreState can match them by objectName — these sit as hidden
// tabs in a single shared dock area and were never user-opened.
//
// Capturing population (2) silently poisoned the autosave: on the next
// apply_layout() the placeholders were re-injected as visible tabs in
// the source window (Profile, About, etc. would all appear next to
// the user's actual panel). Per-panel state for genuinely user-closed
// tabs is already persisted via save_screen_state(), so dropping them
// here is non-destructive — reopen restores the screen state from disk.
for (const auto& entry : dock_manager_->dockWidgetsMap().toStdMap()) {
const QString& id = entry.first;
ads::CDockWidget* dw = entry.second;
if (!dw || dw->isClosed())
continue;
layout::PanelState ps;
ps.instance_id = dock_router_->panel_uuid_for(id);
ps.title = dw->windowTitle();
// Strip "#dupN" suffix from the type id so two watchlists share
// type_id="watchlist" but have 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);
ps.type_id = type_id;
// IGroupLinked screens carry a link group letter. SymbolGroup is
// a single-char enum class; we serialise as the letter.
if (auto* w = dw->widget()) {
if (auto* linked = dynamic_cast<IGroupLinked*>(w)) {
const SymbolGroup g = linked->group();
if (g != SymbolGroup::None)
ps.link_group = QString(QChar(symbol_group_letter(g)));
}
if (auto* stateful = dynamic_cast<screens::IStatefulScreen*>(w)) {
stateful->flush_pending_state();
const QVariantMap state = stateful->save_state();
QJsonObject obj;
for (auto it = state.constBegin(); it != state.constEnd(); ++it)
obj.insert(it.key(), QJsonValue::fromVariant(it.value()));
ps.state_blob = QJsonDocument(obj).toJson(QJsonDocument::Compact);
ps.state_version = stateful->state_version();
}
}
ps.schema_version = layout::kPanelStateVersion;
fl.panels.append(ps);
}
LOG_INFO("WindowFrame", QString("capture_layout: window %1 -> %2 panels, dock_state=%3 bytes")
.arg(window_id_)
.arg(fl.panels.size())
.arg(fl.dock_state.size()));
return fl;
}
bool WindowFrame::apply_layout(const layout::FrameLayout& fl) {
if (!dock_manager_ || !dock_router_) {
LOG_WARN("WindowFrame", "apply_layout: dock manager/router not ready");
return false;
}
LOG_INFO("WindowFrame", QString("apply_layout: window %1, %2 panels, dock_state=%3 bytes")
.arg(window_id_)
.arg(fl.panels.size())
.arg(fl.dock_state.size()));
// Phase 8 staged materialisation (decision 9.3): split the per-panel
// work into a cheap "shell-only" pass that runs synchronously before
// ADS restoreState (which needs every dock widget to exist by
// objectName), and a "screen factory" pass that runs deferred via
// PanelMaterialiser so 50-panel workspaces don't freeze the UI.
// Phase 0: pre-create EVERY factory-registered dock widget into a single
// shared dock area. ADS's restoreState walks the blob and calls
// findDockWidget(name); when a referenced widget is not registered, ADS
// *silently skips it* (DockAreaWidget.cpp: `if (!DockWidget) continue;`)
// and deletes any dock area that ends up empty as a result. That is the
// recovery-bug path: closed-at-save tabs are in the dock_state blob but
// absent from fl.panels, so they were never pre-created — restore drops
// them and any tab group that contained only such widgets vanishes.
//
// ensure_all_registered is idempotent (skips widgets already in
// dock_widgets_), groups everything as hidden tabs in one CenterDockArea
// (vs. prepare_dock_widget's one-area-per-call), and is also what the
// constructor calls on the QSettings-restore path — same protection here.
// Suppress the debounced layout save during the bulk pre-create +
// restoreState pass. These operations fire dockWidgetAdded and
// viewToggled dozens of times; saving mid-restore would persist an
// incomplete intermediate state.
suppress_layout_save_ = true;
dock_router_->ensure_all_registered();
// Track each panel's resolved string id alongside its FrameLayout
// entry so the deferred pass doesn't have to recompute the
// dup_index suffix.
QList<QString> panel_ids;
panel_ids.reserve(fl.panels.size());
// Phase 1: pre-create dock widget shells (no screen factory call yet)
// and adopt the saved instance UUIDs. The shells are what ADS's
// restoreState matches by objectName; the heavy widget construction
// is deferred to Phase 5 below. Idempotent after Phase 0 for non-dup
// ids; still needed for "<type>#dup<n>" panels not in factories_.
for (const auto& ps : fl.panels) {
QString id = ps.type_id;
int dup_index = 0;
for (const auto& other : fl.panels) {
if (&other == &ps)
break;
if (other.type_id == ps.type_id)
++dup_index;
}
if (dup_index > 0)
id = QString("%1#dup%2").arg(ps.type_id).arg(dup_index + 1);
panel_ids.append(id);
dock_router_->prepare_dock_widget(id);
if (!ps.instance_id.is_null())
dock_router_->adopt_panel_instance(id, ps.instance_id);
// Re-apply the panel's saved colour link when its screen is built.
if (!ps.link_group.isEmpty())
dock_router_->set_pending_link_group(id, symbol_group_from_char(ps.link_group.at(0)));
}
// Phase 2: restore the ADS dock layout blob. CDockManager::restoreState
// returns false if the blob is incompatible (version mismatch, missing
// dock widgets). The caller (WorkspaceMatcher) decides whether to
// fall back to a default layout.
bool ok = true;
if (!fl.dock_state.isEmpty()) {
ok = dock_manager_->restoreState(fl.dock_state);
if (!ok) {
LOG_WARN("WindowFrame", "apply_layout: CDockManager::restoreState rejected dock blob");
suppress_layout_save_ = false;
return false;
}
}
suppress_layout_save_ = false;
// Phase 3: chrome flags.
if (focus_mode_ != fl.focus_mode)
toggle_focus_mode();
if (always_on_top_ != fl.always_on_top)
set_always_on_top(fl.always_on_top);
// Phase 4: materialise the active panel synchronously so the user sees
// populated content the moment the layout returns. Deferring this would
// briefly show an empty dock area while PanelMaterialiser drains.
QString active_id;
if (!fl.active_panel.is_null()) {
const auto map = dock_manager_->dockWidgetsMap();
for (auto it = map.constBegin(); it != map.constEnd(); ++it) {
if (dock_router_->panel_uuid_for(it.key()) == fl.active_panel) {
active_id = it.key();
break;
}
}
}
if (!active_id.isEmpty()) {
dock_router_->materialize_now(active_id);
if (auto* dw = dock_router_->find_dock_widget(active_id)) {
dw->raise();
dw->setAsCurrentTab();
}
}
// Phase 5: enqueue the remaining panels with PanelMaterialiser. Priority:
// 1 — currently-visible panels on a frame the user is looking at
// (foreground tab animation will fill in within ~16ms ticks)
// 2 — closed/hidden panels and anything on inactive frames (drained
// at lower urgency; the user can't see them anyway)
//
// Each enqueued item is owned by `this` (the WindowFrame). If the
// frame is destroyed mid-stage, PanelMaterialiser drops the items
// on next tick instead of waking up to run no-op lambdas. Note the
// owner check coexists with the QPointer<DockScreenRouter> guard
// inside the lambda — the guard handles "frame still alive but
// router torn down" (rare; same teardown order in practice).
QPointer<DockScreenRouter> router_guard(dock_router_);
const bool frame_active = is_active_for_work();
for (const QString& id : panel_ids) {
if (id == active_id)
continue; // already materialised synchronously above
auto* dw = dock_router_->find_dock_widget(id);
const bool currently_visible = dw && !dw->isClosed();
const int priority = (frame_active && currently_visible) ? 1 : 2;
PanelMaterialiser::instance().enqueue(
id,
[router_guard, id]() {
if (!router_guard)
return;
router_guard->materialize_now(id);
},
priority,
/*owner=*/this);
}
LOG_INFO("WindowFrame", QString("apply_layout: window %1 staged %2 panels (active='%3')")
.arg(window_id_)
.arg(panel_ids.size())
.arg(active_id));
return ok;
}
} // namespace fincept