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 "core/layout/WorkspaceShell.h"
#include "app/TerminalShell.h"
#include "app/WindowFrame.h"
#include "core/identity/Uuid.h"
#include "core/layout/LayoutCatalog.h"
#include "core/layout/WorkspaceMatcher.h"
#include "core/logging/Logger.h"
#include "core/profile/ProfilePaths.h"
#include "core/screen/MonitorTopology.h"
#include "core/symbol/SymbolContext.h"
#include "core/window/WindowRegistry.h"
#include "storage/workspace/WorkspaceSnapshotRing.h"
#include <QApplication>
#include <QDateTime>
#include <QDir>
#include <QJsonDocument>
#include <QJsonParseError>
#include <QPixmap>
#include <QScreen>
#include <QSet>
#include <QWindow>
#include <DockManager.h>
namespace fincept::layout {
namespace {
constexpr const char* kShellTag = "WorkspaceShell";
// Process-wide state — there is exactly one shell, so a file-scope cache
// is fine. Updated only on the UI thread inside apply().
QString g_current_name;
LayoutId g_current_id;
// L7: ensure restored geometry lands somewhere visible. If the saved rect
// has no overlap with any connected screen (e.g. external monitor was
// disconnected since the layout was saved, or DPI/topology shifted the
// geometry off-screen), recenter the window on the primary screen with
// the saved size preserved. Conservative: we only intervene when the rect
// is *entirely* off-screen — partially-visible windows are left alone so
// users with intentional overflow placements aren't disrupted.
QRect ensure_on_screen(const QRect& saved) {
if (!saved.isValid() || saved.isEmpty())
return saved;
const auto screens = QGuiApplication::screens();
for (auto* s : screens) {
if (s && s->availableGeometry().intersects(saved))
return saved;
}
auto* primary = QGuiApplication::primaryScreen();
if (!primary)
return saved; // headless / boot race — let Qt handle it
const QRect avail = primary->availableGeometry();
QSize sz = saved.size();
// Clamp to the primary screen if the saved size is larger than the
// current display (downsizing monitor case).
if (sz.width() > avail.width())
sz.setWidth(avail.width());
if (sz.height() > avail.height())
sz.setHeight(avail.height());
return QRect(avail.center() - QPoint(sz.width() / 2, sz.height() / 2), sz);
}
} // namespace
QString WorkspaceShell::current_name() {
return g_current_name;
}
LayoutId WorkspaceShell::current_id() {
return g_current_id;
}
void WorkspaceShell::clear_current() {
g_current_name.clear();
g_current_id = LayoutId{};
}
Workspace WorkspaceShell::capture(const QString& name, const QString& kind, const Workspace* previous) {
Workspace w;
if (previous) {
// Preserve identity + variant history. Caller's intent: "save the
// current state as a new variant of this workspace."
w.id = previous->id;
w.created_at_unix = previous->created_at_unix;
w.variants = previous->variants;
w.author = previous->author;
w.description = previous->description;
w.thumbnail_path = previous->thumbnail_path;
} else {
w.id = LayoutId::generate();
w.created_at_unix = QDateTime::currentSecsSinceEpoch();
}
w.name = name;
w.kind = kind;
w.updated_at_unix = QDateTime::currentSecsSinceEpoch();
w.schema_version = kWorkspaceVersion;
// Capture each frame's layout.
const auto frames = fincept::WindowRegistry::instance().frames();
for (auto* frame : frames) {
if (!frame)
continue;
FrameLayout fl = frame->capture_layout();
w.frames.append(fl);
}
// Capture / update the topology variant for the current monitor set.
const MonitorTopologyKey current = fincept::MonitorTopology::current_key();
WorkspaceVariant variant;
variant.topology = current;
for (auto* frame : frames) {
if (!frame)
continue;
const WindowId id = frame->frame_uuid();
variant.frame_geometries.insert(id, frame->geometry());
if (auto* scr = frame->screen())
variant.frame_screens.insert(id, fincept::MonitorTopology::stable_id(scr));
}
// Replace any existing variant for this exact topology, else append.
bool replaced = false;
for (int i = 0; i < w.variants.size(); ++i) {
if (w.variants[i].topology == current) {
w.variants[i] = variant;
replaced = true;
break;
}
}
if (!replaced)
w.variants.append(variant);
// Snapshot per-link-group SymbolContext (red/green/yellow links) so the
// user's pinned symbols per group survive a layout switch / restart.
// Stored opaquely under "symbol_context" — SymbolContext owns the schema.
const QJsonObject ctx_json = SymbolContext::instance().to_json();
const QByteArray ctx_bytes = QJsonDocument(ctx_json).toJson(QJsonDocument::Compact);
w.link_state.insert(QStringLiteral("symbol_context"), ctx_bytes);
// Phase L5: thumbnail capture. Grab the first live frame's dock area as
// a 320×180 PNG under <profile>/layouts/thumbs/<uuid>.png. Path is
// stored relative so the layouts dir can be moved without breaking
// refs. Skipped silently if there's no live frame yet (capture from
// Launchpad-only state) or if grab() returns null. Also skipped for
// kind="auto" — those snapshots are throwaways trimmed by the ring,
// and the per-call grab+scale+PNG write is the dominant cost in the
// autosave hot path.
if (kind != QStringLiteral("auto") && !frames.isEmpty() && frames.first()) {
if (auto* dm = frames.first()->dock_manager()) {
const QPixmap shot = dm->grab().scaled(320, 180, Qt::KeepAspectRatio, Qt::SmoothTransformation);
if (!shot.isNull()) {
const QString thumb_dir = ProfilePaths::layouts_dir() + "/thumbs";
QDir().mkpath(thumb_dir);
const QString thumb_rel = QStringLiteral("thumbs/%1.png").arg(w.id.to_string());
const QString thumb_abs = ProfilePaths::layouts_dir() + "/" + thumb_rel;
if (shot.save(thumb_abs, "PNG"))
w.thumbnail_path = thumb_rel;
}
}
}
LOG_INFO(kShellTag, QString("capture: '%1' (uuid=%2) → %3 frames, %4 variants, topology=%5")
.arg(name, w.id.to_string())
.arg(w.frames.size())
.arg(w.variants.size())
.arg(current.value));
return w;
}
int WorkspaceShell::apply(const Workspace& workspace) {
if (workspace.frames.isEmpty()) {
LOG_INFO(kShellTag, QString("apply: workspace '%1' has no frames — nothing to do").arg(workspace.name));
return 0;
}
// Match the workspace's variants against the current topology to pick
// the best frame geometry set. Falls back to nullptr if no variant
// matches; we then apply layouts without geometry hints (frames keep
// their current size/position).
const MonitorTopologyKey current = fincept::MonitorTopology::current_key();
const WorkspaceVariant* variant = WorkspaceMatcher::match(workspace, current);
LOG_INFO(kShellTag, QString("apply: '%1' (uuid=%2) → %3 frames; matched variant: %4")
.arg(workspace.name, workspace.id.to_string())
.arg(workspace.frames.size())
.arg(variant ? variant->topology.value : QStringLiteral("(none)")));
int applied = 0;
auto frames_now = fincept::WindowRegistry::instance().frames();
QSet<fincept::WindowFrame*> bound; // frames already paired with a FrameLayout this call
for (const auto& fl : workspace.frames) {
// Find an existing frame matching this window_id (and not already
// claimed by an earlier FrameLayout in this same apply() call).
fincept::WindowFrame* target = nullptr;
bool spawned = false;
for (auto* f : frames_now) {
if (f && !bound.contains(f) && f->frame_uuid() == fl.window_id) {
target = f;
break;
}
}
if (!target) {
// Before spawning, reuse any existing unbound frame. Common
// after PIN unlock: main.cpp created the window with a fresh
// UUID that doesn't match the saved workspace's frame UUID.
// Without this, apply() spawns a duplicate window.
for (auto* f : frames_now) {
if (f && !bound.contains(f)) {
target = f;
break;
}
}
}
if (!target) {
// No existing frame to reuse — genuinely need a new window.
target = new fincept::WindowFrame(fincept::WindowFrame::next_window_id(),
/*parent=*/nullptr,
/*adopted_uuid=*/fl.window_id);
target->setAttribute(Qt::WA_DeleteOnClose);
target->show();
frames_now.append(target);
spawned = true;
}
bound.insert(target);
// Apply geometry from the matched variant — but ONLY when we just
// spawned the frame. For an already-live frame the user is looking
// at, its position was set by the WindowFrame constructor's
// QSettings restore (and the user may have moved it). Re-applying
// the workspace's saved screen here teleports the window mid-
// session — e.g. on PIN unlock, load_last_or_default() runs and
// would yank the window from monitor 1 (where the lock screen sat)
// to monitor 2 (where the snapshot says it lived last). The user
// experiences this as the app "jumping" to another monitor.
//
// Freshly-spawned frames need the geometry hint because their
// constructor had no QSettings row for the adopted UUID.
if (variant && spawned) {
const auto scr_it = variant->frame_screens.constFind(fl.window_id);
if (scr_it != variant->frame_screens.constEnd()) {
if (QScreen* saved_screen = fincept::MonitorTopology::find_screen_by_stable_id(scr_it.value())) {
if (auto* win = target->windowHandle()) {
if (win->screen() != saved_screen)
win->setScreen(saved_screen);
} else {
// No QWindow yet (frame not shown). Move to the
// saved screen's available area as a best-effort
// hint; the geometry call below refines this.
target->move(saved_screen->availableGeometry().topLeft());
}
}
}
const auto geo_it = variant->frame_geometries.constFind(fl.window_id);
if (geo_it != variant->frame_geometries.constEnd())
target->setGeometry(ensure_on_screen(geo_it.value()));
}
if (target->apply_layout(fl))
++applied;
}
LOG_INFO(kShellTag, QString("apply: %1/%2 frames restored cleanly").arg(applied).arg(workspace.frames.size()));
// Restore SymbolContext if the workspace carried one. Empty / missing
// is fine (older workspaces saved before Phase 5 shipped).
const auto ctx_it = workspace.link_state.constFind(QStringLiteral("symbol_context"));
if (ctx_it != workspace.link_state.constEnd() && !ctx_it.value().isEmpty()) {
QJsonParseError err{};
const auto ctx_doc = QJsonDocument::fromJson(ctx_it.value(), &err);
if (err.error == QJsonParseError::NoError && ctx_doc.isObject())
SymbolContext::instance().from_json(ctx_doc.object());
else
LOG_WARN(kShellTag, QString("apply: symbol_context parse failed: %1").arg(err.errorString()));
}
// Update process-wide state so the title bar + toolbar see the current
// layout. Pin non-auto layouts in LayoutCatalog so cold-boot can find
// them next session. Auto snapshots are throwaway — never pinned.
if (applied > 0) {
g_current_name = workspace.name;
g_current_id = workspace.id;
if (workspace.kind != QStringLiteral("auto") && !workspace.id.is_null()) {
auto pin_r = LayoutCatalog::instance().set_last_loaded_id(workspace.id);
if (pin_r.is_err())
LOG_WARN(kShellTag,
QString("Failed to pin last_loaded_id: %1").arg(QString::fromStdString(pin_r.error())));
}
}
return applied;
}
int WorkspaceShell::load_last_or_default() {
// Step 1: explicit last-loaded layout (set by apply() on every non-auto
// workspace). If the UUID is dead (file deleted out from under us),
// log + fall through.
auto last = LayoutCatalog::instance().last_loaded_id();
if (last.is_ok() && !last.value().is_null()) {
auto wr = LayoutCatalog::instance().load_workspace(last.value());
if (wr.is_ok()) {
const int n = apply(wr.value());
LOG_INFO(kShellTag, QString("load_last_or_default: restored '%1' (%2 frames)").arg(wr.value().name).arg(n));
return n;
}
LOG_WARN(kShellTag, QString("load_last_or_default: last_loaded_uuid=%1 unreadable: %2")
.arg(last.value().to_string(), QString::fromStdString(wr.error())));
}
// Step 2: most recent kind='auto' snapshot from the ring buffer. The
// shell owns the ring; if it's gone (early-init / shutdown teardown)
// we can't fall through any further.
auto* ring = TerminalShell::instance().snapshot_ring();
if (!ring) {
LOG_INFO(kShellTag, "load_last_or_default: snapshot ring unavailable; first run path");
return 0;
}
auto snaps = ring->latest_auto(/*limit=*/1);
if (snaps.is_ok() && !snaps.value().isEmpty()) {
auto payload = ring->load_payload(snaps.value().first().snapshot_id);
if (payload.is_ok() && !payload.value().isEmpty()) {
QJsonParseError err{};
const auto doc = QJsonDocument::fromJson(payload.value(), &err);
if (err.error == QJsonParseError::NoError && doc.isObject()) {
Workspace w = Workspace::from_json(doc.object());
// Force kind='auto' so apply() doesn't pin a snapshot as
// last_loaded_id (the next user save should be the pin).
w.kind = QStringLiteral("auto");
const int n = apply(w);
LOG_INFO(kShellTag, QString("load_last_or_default: restored auto snapshot (%1 frames)").arg(n));
return n;
}
LOG_WARN(kShellTag, QString("load_last_or_default: snapshot parse failed: %1").arg(err.errorString()));
}
}
LOG_INFO(kShellTag, "load_last_or_default: nothing to restore (first run / fresh profile)");
return 0;
}
} // namespace fincept::layout