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/actions/builtin_actions.h"
#include "app/DockScreenRouter.h"
#include "app/WindowFrame.h"
#include "auth/InactivityGuard.h"
#include "core/actions/ActionRegistry.h"
#include "core/debug/StressLoad.h"
#include "core/keys/KeyConfigManager.h"
#include "core/keys/WindowCycler.h"
#include "core/layout/LayoutCatalog.h"
#include "core/layout/LayoutTypes.h"
#include "core/layout/WorkspaceMatcher.h"
#include "core/layout/WorkspaceShell.h"
#include "core/logging/Logger.h"
#include "core/symbol/IGroupLinked.h"
#include "core/symbol/SymbolContext.h"
#include "core/symbol/SymbolGroup.h"
#include "core/symbol/SymbolGroupRegistry.h"
#include "core/symbol/SymbolRef.h"
#include "core/window/WindowRegistry.h"
#include "screens/launchpad/OnboardingTour.h"
#include "ui/widgets/EnterprisePromo.h"
#include <QApplication>
#include <QDateTime>
#include <QDir>
#include <QFileDialog>
#include <QGuiApplication>
#include <QPixmap>
#include <QScreen>
namespace fincept::actions {
namespace {
constexpr const char* kBuiltinTag = "BuiltinActions";
// ── Predicate helpers ────────────────────────────────────────────────────────
//
// Predicates are invoked by every surface that displays or routes the action
// (palette grey-out, hotkey gate, menu enable). They must be cheap and pure.
ActionPredicate require_focused_frame() {
return [](const CommandContext& ctx) { return ctx.focused_frame != nullptr; };
}
ActionPredicate require_unlocked_frame() {
// A focused frame in the locked state still receives events but actions
// should be inert. The lock-on-minimise flow and PIN gate set
// `WindowFrame::is_locked() == true` while the lock overlay is visible.
return [](const CommandContext& ctx) { return ctx.focused_frame && !ctx.focused_frame->is_locked(); };
}
ActionPredicate require_more_than_one_window() {
return [](const CommandContext&) { return WindowRegistry::instance().frame_count() > 1; };
}
ActionPredicate require_more_than_one_monitor() {
return [](const CommandContext&) { return QGuiApplication::screens().size() > 1; };
}
// ── Handler helpers ──────────────────────────────────────────────────────────
Result<void> handler_toggle_chat(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok(); // inert
ctx.focused_frame->toggle_chat_mode_action();
return Result<void>::ok();
}
Result<void> handler_fullscreen(const CommandContext& ctx) {
if (!ctx.focused_frame)
return Result<void>::ok();
if (ctx.focused_frame->isFullScreen())
ctx.focused_frame->showNormal();
else
ctx.focused_frame->showFullScreen();
return Result<void>::ok();
}
Result<void> handler_focus_mode(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->toggle_focus_mode();
return Result<void>::ok();
}
Result<void> handler_refresh(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->refresh_focused_panel();
return Result<void>::ok();
}
Result<void> handler_screenshot(const CommandContext& ctx) {
if (!ctx.focused_frame)
return Result<void>::ok();
QScreen* scr = ctx.focused_frame->screen();
if (!scr)
scr = QApplication::primaryScreen();
if (!scr)
return Result<void>::err("No screen available for screenshot");
QPixmap px = scr->grabWindow(ctx.focused_frame->winId());
const QString path = QFileDialog::getSaveFileName(
ctx.focused_frame, "Save Screenshot",
QDir::homePath() + "/fincept_" + QDateTime::currentDateTime().toString("yyyyMMdd_HHmmss") + ".png",
"PNG Images (*.png)");
if (!path.isEmpty()) {
px.save(path, "PNG");
LOG_INFO(kBuiltinTag, QString("Screenshot saved: %1").arg(path));
}
return Result<void>::ok();
}
Result<void> handler_lock_now(const CommandContext&) {
// Lock is shell-level; deliberately ignores focused frame state.
auth::InactivityGuard::instance().trigger_manual_lock();
return Result<void>::ok();
}
Result<void> handler_always_on_top(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->set_always_on_top(!ctx.focused_frame->is_always_on_top());
return Result<void>::ok();
}
Result<void> handler_browse_components(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->open_component_browser();
return Result<void>::ok();
}
Result<void> handler_toggle_debug_overlay(const CommandContext& ctx) {
if (!ctx.focused_frame)
return Result<void>::ok();
ctx.focused_frame->toggle_debug_overlay();
return Result<void>::ok();
}
// ── Phase 6: layout.* actions ───────────────────────────────────────────────
Result<void> handler_layout_save(const CommandContext& ctx) {
const QString name = ctx.args.value(QStringLiteral("name")).toString().trimmed();
if (name.isEmpty())
return Result<void>::err("Missing 'name' argument");
// Phase 6 final: capture the live shell state via WorkspaceShell.
// If a layout with the same name already exists, preserve its UUID +
// variant history so the save is "add a new variant / refresh the
// frame snapshot," not a name collision.
layout::Workspace prev;
bool has_prev = false;
LayoutId existing_id = LayoutCatalog::instance().find_by_name(name);
if (!existing_id.is_null()) {
auto load_r = LayoutCatalog::instance().load_workspace(existing_id);
if (load_r.is_ok()) {
prev = load_r.value();
has_prev = true;
}
}
layout::Workspace w = layout::WorkspaceShell::capture(name, "user", has_prev ? &prev : nullptr);
auto r = LayoutCatalog::instance().save_workspace(w);
if (r.is_err())
return Result<void>::err(r.error());
LOG_INFO("BuiltinActions", QString("layout.save: '%1' saved as %2 (%3 frames, %4 variants)")
.arg(name, r.value().to_string())
.arg(w.frames.size())
.arg(w.variants.size()));
return Result<void>::ok();
}
Result<void> handler_layout_save_as(const CommandContext& ctx) {
return handler_layout_save(ctx); // identical for v1; UI will distinguish
}
Result<void> handler_layout_switch(const CommandContext& ctx) {
const QString name_or_id = ctx.args.value(QStringLiteral("name")).toString().trimmed();
if (name_or_id.isEmpty())
return Result<void>::err("Missing 'name' argument");
LayoutId id = LayoutCatalog::instance().find_by_name(name_or_id);
if (id.is_null())
id = LayoutId::from_string(name_or_id);
if (id.is_null())
return Result<void>::err(("No layout named " + name_or_id).toStdString());
auto r = LayoutCatalog::instance().load_workspace(id);
if (r.is_err())
return Result<void>::err(r.error());
// Phase 6 final: actually apply the workspace to live frames.
const int applied = layout::WorkspaceShell::apply(r.value());
LOG_INFO("BuiltinActions", QString("layout.switch: '%1' applied (%2/%3 frames restored)")
.arg(r.value().name)
.arg(applied)
.arg(r.value().frames.size()));
return Result<void>::ok();
}
Result<void> handler_layout_new(const CommandContext& ctx) {
// "New" = save the current state under a fresh name, blank Workspace.
layout::Workspace w;
w.name = ctx.args.value(QStringLiteral("name")).toString().trimmed();
if (w.name.isEmpty())
w.name = QStringLiteral("New Layout");
w.kind = "user";
w.created_at_unix = QDateTime::currentSecsSinceEpoch();
w.updated_at_unix = w.created_at_unix;
auto r = LayoutCatalog::instance().save_workspace(w);
if (r.is_err())
return Result<void>::err(r.error());
return Result<void>::ok();
}
Result<void> handler_layout_export(const CommandContext& ctx) {
const QString name = ctx.args.value(QStringLiteral("name")).toString().trimmed();
const QString path = ctx.args.value(QStringLiteral("path")).toString().trimmed();
if (name.isEmpty() || path.isEmpty())
return Result<void>::err("layout.export needs 'name' and 'path' arguments");
LayoutId id = LayoutCatalog::instance().find_by_name(name);
if (id.is_null())
return Result<void>::err(("No layout named " + name).toStdString());
auto r = LayoutCatalog::instance().export_to(id, path);
if (r.is_err())
return Result<void>::err(r.error());
LOG_INFO("BuiltinActions", QString("layout.export: '%1' → %2").arg(name, path));
return Result<void>::ok();
}
Result<void> handler_layout_import(const CommandContext& ctx) {
const QString path = ctx.args.value(QStringLiteral("path")).toString().trimmed();
if (path.isEmpty())
return Result<void>::err("layout.import needs 'path' argument");
auto r = LayoutCatalog::instance().import_from(path);
if (r.is_err())
return Result<void>::err(r.error());
LOG_INFO("BuiltinActions", QString("layout.import: %1 → uuid %2").arg(path, r.value().to_string()));
return Result<void>::ok();
}
Result<void> handler_layout_tile_2x2(const CommandContext& ctx) {
// Decision 5.5: tile current frame's panels into a 2x2 grid across the
// active monitor. Implementation in DockScreenRouter::tile_2x2.
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
if (auto* router = ctx.focused_frame->dock_router())
router->tile_2x2();
return Result<void>::ok();
}
Result<void> handler_panel_fullscreen_toggle(const CommandContext& ctx) {
// Decision 5.10: focused panel takes over its frame, chrome hides.
// Wire to WindowFrame::toggle_focus_mode for v1 (which already hides
// the toolbar/status/pushpin chrome). The "panel takes over" half is
// a Phase 6 polish (needs router-level "show only this panel" mode).
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->toggle_focus_mode();
return Result<void>::ok();
}
Result<void> handler_cmdbar_toggle(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->toggle_command_bar();
return Result<void>::ok();
}
Result<void> handler_palette_open(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
ctx.focused_frame->open_command_palette();
return Result<void>::ok();
}
Result<void> handler_debug_stress(const CommandContext& ctx) {
// Args: n (frames), m (panels per frame), k (ticks/sec). Defaults
// mirror the design doc 9.10 example: `debug stress 4 16 256`.
bool ok = false;
int n = ctx.args.value(QStringLiteral("n")).toInt(&ok);
if (!ok || n <= 0)
n = 4;
int m = ctx.args.value(QStringLiteral("m")).toInt(&ok);
if (!ok || m <= 0)
m = 16;
int k = ctx.args.value(QStringLiteral("k")).toInt(&ok);
if (!ok || k <= 0)
k = 256;
if (debug_tools::StressLoad::instance().is_running())
debug_tools::StressLoad::instance().stop();
else
debug_tools::StressLoad::instance().start(n, m, k);
return Result<void>::ok();
}
// ── Phase 5: tear-off + move-to-window ──────────────────────────────────────
QString focused_panel_id_(WindowFrame* frame) {
// Resolve the panel id of whichever dock widget is currently focused
// in the frame. The router's current_screen_id is the most-recently-
// navigated panel which usually matches focus, but ADS lets the user
// click another panel to focus it without going through navigate().
// Fall back to current_screen_id if no focused dock widget.
if (!frame || !frame->dock_router())
return {};
// Reach into the router via its public dock_widgets_ accessor — none
// exists, so we use current_screen_id as the v1 approximation. A future
// helper on DockScreenRouter could expose the focused panel id directly.
return frame->dock_router()->current_screen_id();
}
Result<void> handler_tear_off(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
auto* router = ctx.focused_frame->dock_router();
if (!router)
return Result<void>::err("Focused frame has no dock router");
const QString id = focused_panel_id_(ctx.focused_frame);
if (id.isEmpty())
return Result<void>::err("No focused panel to tear off");
return router->tear_off_to_new_frame(id) ? Result<void>::ok()
: Result<void>::err("tear_off_to_new_frame returned false");
}
// ── Phase 7 polish: link.* actions ──────────────────────────────────────────
//
// These wrap IGroupLinked operations on whichever panel is currently focused
// in the active frame. Discoverability is via the right-click menu on the
// panel tab (already present); the actions exist so command-bar / palette
// surfaces (Phase 9) can reach them too. Parameter slots designed so a
// command like `link group red` resolves to set_group(SymbolGroup::A) etc.
IGroupLinked* focused_linked_(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked() || !ctx.focused_frame->dock_router())
return nullptr;
auto* router = ctx.focused_frame->dock_router();
const QString id = router->current_screen_id();
if (id.isEmpty())
return nullptr;
auto* dw = router->find_dock_widget(id);
if (!dw || !dw->widget())
return nullptr;
return dynamic_cast<IGroupLinked*>(dw->widget());
}
SymbolGroup parse_group_arg_(const QVariant& v) {
// Accept either a single letter ("A".."J", case-insensitive, "None") or
// an int (0=None, 1=A, ..., 10=J). Returns SymbolGroup::None for
// unrecognised input — predicate-checked at call time.
if (v.typeId() == QMetaType::Int) {
const int i = v.toInt();
if (i <= 0 || i > 10)
return SymbolGroup::None;
return symbol_group_from_char(QChar('A' + (i - 1)));
}
const QString s = v.toString().trimmed();
if (s.isEmpty() || s.compare("none", Qt::CaseInsensitive) == 0)
return SymbolGroup::None;
return symbol_group_from_char(s.at(0).toUpper());
}
Result<void> handler_link_set_group(const CommandContext& ctx) {
auto* linked = focused_linked_(ctx);
if (!linked)
return Result<void>::err("Focused panel does not support linking");
const SymbolGroup g = parse_group_arg_(ctx.args.value(QStringLiteral("group")));
if (g == SymbolGroup::None)
return Result<void>::err("Missing or invalid 'group' argument (expect A..J)");
if (!SymbolGroupRegistry::instance().enabled(g))
return Result<void>::err(QString("Group %1 is disabled").arg(symbol_group_letter(g)).toStdString());
linked->set_group(g);
dock_router_link_defaults::mark_user_configured_links();
// Mirror the right-click flow: if the group already has a symbol, push it
// immediately; otherwise seed the group from the panel's current symbol.
const SymbolRef group_sym = SymbolContext::instance().group_symbol(g);
if (group_sym.is_valid()) {
linked->on_group_symbol_changed(group_sym);
} else {
const SymbolRef own = linked->current_symbol();
if (own.is_valid())
SymbolContext::instance().set_group_symbol(g, own, dynamic_cast<QObject*>(linked));
}
return Result<void>::ok();
}
Result<void> handler_link_clear_group(const CommandContext& ctx) {
auto* linked = focused_linked_(ctx);
if (!linked)
return Result<void>::err("Focused panel does not support linking");
linked->set_group(SymbolGroup::None);
dock_router_link_defaults::mark_user_configured_links();
return Result<void>::ok();
}
Result<void> handler_link_publish_to_group(const CommandContext& ctx) {
// Used by the command bar to broadcast a symbol into a colour group from
// anywhere — does not require a focused linked panel. Args:
// group: A..J or None
// symbol: ticker string (asset_class/exchange not supplied via this
// action; SymbolRef defaults match the most common case).
const SymbolGroup g = parse_group_arg_(ctx.args.value(QStringLiteral("group")));
if (g == SymbolGroup::None)
return Result<void>::err("Missing or invalid 'group' argument");
const QString symbol = ctx.args.value(QStringLiteral("symbol")).toString().trimmed();
if (symbol.isEmpty())
return Result<void>::err("Missing 'symbol' argument");
SymbolRef ref;
ref.symbol = symbol.toUpper();
// asset_class/exchange omitted — consumers default to equity behaviour.
SymbolContext::instance().set_group_symbol(g, ref, nullptr);
return Result<void>::ok();
}
Result<void> handler_move_to_frame(const CommandContext& ctx) {
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok();
auto* router = ctx.focused_frame->dock_router();
if (!router)
return Result<void>::err("Focused frame has no dock router");
const QString id = focused_panel_id_(ctx.focused_frame);
if (id.isEmpty())
return Result<void>::err("No focused panel to move");
// The action expects a frame_index parameter (1-based, mirroring
// Ctrl+1..9 ergonomics). Resolve the target frame; refuse if it's
// the same as the focused frame.
bool ok = false;
const int frame_index = ctx.args.value(QStringLiteral("frame_index")).toInt(&ok);
if (!ok || frame_index < 1)
return Result<void>::err("Missing or invalid frame_index argument");
const auto frames = WindowRegistry::instance().frames();
if (frame_index > frames.size())
return Result<void>::err("frame_index out of range");
auto* target_frame = frames.at(frame_index - 1);
if (!target_frame || target_frame == ctx.focused_frame)
return Result<void>::err("Target frame is the same as the focused frame");
if (!target_frame->dock_router())
return Result<void>::err("Target frame has no dock router");
return router->move_panel_to_frame(id, target_frame->dock_router())
? Result<void>::ok()
: Result<void>::err("move_panel_to_frame returned false");
}
Result<void> handler_focus_window_n(int n, const CommandContext&) {
WindowCycler::instance().focus_window_by_index(n);
return Result<void>::ok();
}
Result<void> handler_cycle_windows(bool forward, const CommandContext&) {
WindowCycler::instance().cycle_windows(forward);
return Result<void>::ok();
}
Result<void> handler_cycle_panels(bool forward, const CommandContext&) {
WindowCycler::instance().cycle_panels_in_current_window(forward);
return Result<void>::ok();
}
Result<void> handler_new_window_next_monitor(const CommandContext&) {
WindowCycler::instance().new_window_on_next_monitor();
return Result<void>::ok();
}
Result<void> handler_move_window_to_monitor(int n, const CommandContext&) {
WindowCycler::instance().move_current_window_to_monitor(n);
return Result<void>::ok();
}
Result<void> handler_replay_tour(const CommandContext& ctx) {
// Reset the seen-flag so subsequent launches also replay until the
// user finishes the tour, then surface it now over the focused frame
// (or with no parent if no frame is currently focused — the tour
// window-manages itself).
fincept::screens::OnboardingTour::reset_seen();
QWidget* parent = nullptr;
if (ctx.focused_frame)
parent = ctx.focused_frame;
fincept::screens::OnboardingTour::show_for(parent);
return Result<void>::ok();
}
Result<void> handler_billing_plans(const CommandContext& ctx) {
// The single entry point to Plans & Pricing: the toolbar plan badge,
// Profile → Billing and every low-credit prompt route here too.
if (!ctx.focused_frame || ctx.focused_frame->is_locked())
return Result<void>::ok(); // inert
ctx.focused_frame->show_pricing();
return Result<void>::ok();
}
Result<void> handler_help_enterprise(const CommandContext& ctx) {
QWidget* parent = ctx.focused_frame;
if (!parent)
parent = WindowCycler::instance().focused_frame();
if (auto* frame = qobject_cast<WindowFrame*>(parent); frame && frame->is_locked())
return Result<void>::ok(); // never over the lock screen
fincept::ui::UpgradeDialog::show_now(parent, QStringLiteral("palette"));
return Result<void>::ok();
}
// ── Mapping from KeyAction enum to action id strings ──────────────────────
//
// The id is what the registry, command bar, and hotkey-binding layer use.
// Pre-Phase 4 the only handle on an action was the KeyAction enum value;
// post-Phase 4 the id string is the canonical form. KeyConfigManager
// continues to own user-bound QKeySequence persistence — we just look up
// the current binding via `KeyConfigManager::key(action)` when registering.
QKeySequence current_key_for(KeyAction a) {
return KeyConfigManager::instance().key(a);
}
void register_one(const ActionDef& def) {
ActionRegistry::instance().register_action(def);
}
} // namespace
void register_builtins() {
auto& reg = ActionRegistry::instance();
if (reg.size() > 0) {
LOG_DEBUG(kBuiltinTag, "register_builtins called twice — skipping");
return;
}
// ── Frame-level chrome / view actions ──────────────────────────────────
register_one(ActionDef{
/*id*/ "frame.toggle_chat_mode",
/*display*/ "Toggle Chat Mode",
/*category*/ "Frame",
/*aliases*/ {"chat", "toggle chat"},
/*default_hotkey*/ current_key_for(KeyAction::ToggleChat),
/*predicate*/ require_unlocked_frame(),
/*handler*/ &handler_toggle_chat,
/*parameter_slots*/ {},
});
register_one(ActionDef{
"frame.toggle_fullscreen",
"Toggle Fullscreen",
"Frame",
{"fullscreen"},
current_key_for(KeyAction::Fullscreen),
require_focused_frame(),
&handler_fullscreen,
{},
});
register_one(ActionDef{
"frame.toggle_focus_mode",
"Toggle Focus Mode",
"Frame",
{"focus mode", "distraction free"},
current_key_for(KeyAction::FocusMode),
require_unlocked_frame(),
&handler_focus_mode,
{},
});
register_one(ActionDef{
"frame.toggle_always_on_top",
"Toggle Always On Top",
"Frame",
{"always on top", "pin window"},
current_key_for(KeyAction::ToggleAlwaysOnTop),
require_unlocked_frame(),
&handler_always_on_top,
{},
});
register_one(ActionDef{
"frame.screenshot",
"Save Screenshot",
"Frame",
{"screenshot", "capture"},
current_key_for(KeyAction::Screenshot),
require_focused_frame(),
&handler_screenshot,
{},
});
register_one(ActionDef{
"frame.browse_components",
"Browse Components",
"Frame",
{"components", "screen browser"},
current_key_for(KeyAction::BrowseComponents),
require_unlocked_frame(),
&handler_browse_components,
{},
});
// Phase 10 trim: debug overlay toggle. No default hotkey — discoverable
// via command bar. Frame-level so each frame has its own overlay (the
// user can leave it on for the frame they're tuning and off elsewhere).
register_one(ActionDef{
"debug.overlay",
"Toggle Debug Overlay",
"Debug",
{"debug", "overlay", "stats"},
QKeySequence(),
require_focused_frame(),
&handler_toggle_debug_overlay,
{},
});
// ── Phase 6: layout.* actions ─────────────────────────────────────────
register_one(ActionDef{
"layout.save",
"Save Current Layout",
"Layout",
{"save layout", "save workspace"},
QKeySequence(),
/*predicate*/ {},
&handler_layout_save,
{ParameterSlot{"name", "Layout name", "string", true, "", {}}},
});
register_one(ActionDef{
"layout.save_as",
"Save Layout As…",
"Layout",
{"save as", "save workspace as"},
QKeySequence(),
/*predicate*/ {},
&handler_layout_save_as,
{ParameterSlot{"name", "Layout name", "string", true, "", {}}},
});
register_one(ActionDef{
"layout.switch",
"Switch Layout",
"Layout",
{"switch layout", "load layout"},
QKeySequence(),
/*predicate*/ {},
&handler_layout_switch,
{ParameterSlot{"name", "Layout name or UUID", "string", true, "layout_name", {}}},
});
register_one(ActionDef{
"layout.new",
"New Layout",
"Layout",
{"new layout"},
QKeySequence(),
/*predicate*/ {},
&handler_layout_new,
{ParameterSlot{"name", "Layout name", "string", false, "", "New Layout"}},
});
register_one(ActionDef{
"layout.export",
"Export Layout",
"Layout",
{"export layout"},
QKeySequence(),
/*predicate*/ {},
&handler_layout_export,
{
ParameterSlot{"name", "Layout name", "string", true, "layout_name", {}},
ParameterSlot{"path", "Export path", "string", true, "", {}},
},
});
register_one(ActionDef{
"layout.import",
"Import Layout",
"Layout",
{"import layout"},
QKeySequence(),
/*predicate*/ {},
&handler_layout_import,
{ParameterSlot{"path", "Import path", "string", true, "", {}}},
});
register_one(ActionDef{
"layout.tile_2x2",
"Tile Current Layout 2x2",
"Layout",
{"tile", "2x2"},
QKeySequence(),
require_unlocked_frame(),
&handler_layout_tile_2x2,
{},
});
register_one(ActionDef{
"panel.fullscreen_toggle",
"Fullscreen Focused Panel",
"Panel",
{"panel fullscreen", "zoom panel"},
QKeySequence(),
require_unlocked_frame(),
&handler_panel_fullscreen_toggle,
{},
});
// ── Phase 9: command bar + palette ──────────────────────────────────────
register_one(ActionDef{
"cmdbar.toggle",
"Toggle Command Bar",
"Command",
{"command bar", "show command bar"},
QKeySequence(QStringLiteral("Ctrl+\\")),
require_unlocked_frame(),
&handler_cmdbar_toggle,
{},
});
register_one(ActionDef{
"palette.open",
"Open Command Palette",
"Command",
{"palette", "command palette"},
// Ctrl+K is KeyAction::BrowseComponents (documented, user-rebindable and
// persisted under keybindings.*); sharing it made the shortcut ambiguous.
// Ctrl+Shift+P is the conventional palette key and is unused elsewhere.
QKeySequence(QStringLiteral("Ctrl+Shift+P")),
require_unlocked_frame(),
&handler_palette_open,
{},
});
register_one(ActionDef{
"debug.stress",
"Toggle Stress Load (N frames × M panels × K ticks/sec)",
"Debug",
{"stress", "synthetic load", "perf test"},
QKeySequence(),
/*predicate*/ {},
&handler_debug_stress,
{
ParameterSlot{"n", "Frame count", "int", false, "", 4},
ParameterSlot{"m", "Panels per frame", "int", false, "", 16},
ParameterSlot{"k", "Ticks per second", "int", false, "", 256},
},
});
// ── Panel-level actions ────────────────────────────────────────────────
register_one(ActionDef{
"panel.refresh",
"Refresh Focused Panel",
"Panel",
{"refresh", "reload"},
current_key_for(KeyAction::Refresh),
require_unlocked_frame(),
&handler_refresh,
{},
});
register_one(ActionDef{
"panel.cycle_forward",
"Cycle Panels Forward",
"Panel",
{"next panel"},
current_key_for(KeyAction::CyclePanelsForward),
require_unlocked_frame(),
[](const CommandContext& ctx) { return handler_cycle_panels(true, ctx); },
{},
});
register_one(ActionDef{
"panel.cycle_back",
"Cycle Panels Back",
"Panel",
{"previous panel"},
current_key_for(KeyAction::CyclePanelsBack),
require_unlocked_frame(),
[](const CommandContext& ctx) { return handler_cycle_panels(false, ctx); },
{},
});
// Phase 5: tear off the focused panel into a brand-new window. No
// default hotkey — discoverability via the right-click menu and the
// command bar (when Phase 9 lands).
register_one(ActionDef{
"panel.tear_off",
"Tear off panel into new window",
"Panel",
{"tear off", "panel popout", "popout panel"},
QKeySequence(),
require_unlocked_frame(),
&handler_tear_off,
{},
});
// Phase 5: move the focused panel to another frame by display number.
// Parameter slot frame_index (1-based) drives the target lookup. The
// command-bar parser populates it from typed args; the right-click
// menu invokes move_panel_to_frame directly without going through
// the registry, so this entry is mostly for command-bar / future
// palette discoverability.
// ── Phase 7 polish: link.* actions ─────────────────────────────────────
//
// Discoverability is via the right-click panel menu (already present);
// these registrations expose the same operations to the command bar and
// palette (Phase 9 consumers).
register_one(ActionDef{
"link.set_group",
"Link Panel to Group",
"Link",
{"link", "link to group", "set group"},
QKeySequence(),
require_unlocked_frame(),
&handler_link_set_group,
{
ParameterSlot{
/*name*/ "group",
/*display*/ "Group letter (A..J or None)",
/*type*/ "string",
/*required*/ true,
/*suggestion_source*/ "link_groups",
/*default_value*/ {},
},
},
});
register_one(ActionDef{
"link.clear_group",
"Unlink Panel",
"Link",
{"unlink", "clear link"},
QKeySequence(),
require_unlocked_frame(),
&handler_link_clear_group,
{},
});
register_one(ActionDef{
"link.publish_to_group",
"Publish Symbol to Group",
"Link",
{"publish", "broadcast"},
QKeySequence(),
/*predicate*/ {}, // works without a focused panel — broadcasts globally
&handler_link_publish_to_group,
{
ParameterSlot{"group", "Group letter (A..J)", "string", true, "link_groups", {}},
ParameterSlot{"symbol", "Symbol ticker", "string", true, "symbol", {}},
},
});
register_one(ActionDef{
"panel.move_to_frame",
"Move panel to window…",
"Panel",
{"move panel", "send to window"},
QKeySequence(),
require_more_than_one_window(),
&handler_move_to_frame,
// parameter_slots
{
ParameterSlot{
/*name*/ "frame_index",
/*display*/ "Window number",
/*type*/ "int",
/*required*/ true,
/*suggestion_source*/ "open_frames",
/*default_value*/ {},
},
},
});
// ── Window-level actions (cross-frame) ─────────────────────────────────
register_one(ActionDef{
"window.cycle_forward",
"Cycle Windows Forward",
"Window",
{"next window"},
current_key_for(KeyAction::CycleWindowsForward),
require_more_than_one_window(),
[](const CommandContext& ctx) { return handler_cycle_windows(true, ctx); },
{},
});
register_one(ActionDef{
"window.cycle_back",
"Cycle Windows Back",
"Window",
{"previous window"},
current_key_for(KeyAction::CycleWindowsBack),
require_more_than_one_window(),
[](const CommandContext& ctx) { return handler_cycle_windows(false, ctx); },
{},
});
register_one(ActionDef{
"window.new_on_next_monitor",
"New Window on Next Monitor",
"Window",
{"new window", "spawn window"},
current_key_for(KeyAction::NewWindowNextMonitor),
/*predicate*/ {}, // always available — works on any monitor count
&handler_new_window_next_monitor,
{},
});
// FocusWindow1..9 — generated via a loop because the only difference is
// the index. Each registers as window.focus_1, window.focus_2, etc.
{
const KeyAction focus_keys[9] = {
KeyAction::FocusWindow1, KeyAction::FocusWindow2, KeyAction::FocusWindow3,
KeyAction::FocusWindow4, KeyAction::FocusWindow5, KeyAction::FocusWindow6,
KeyAction::FocusWindow7, KeyAction::FocusWindow8, KeyAction::FocusWindow9,
};
for (int i = 0; i < 9; ++i) {
register_one(ActionDef{
QString("window.focus_%1").arg(i + 1),
QString("Focus Window %1").arg(i + 1),
"Window",
{QString("window %1").arg(i + 1)},
current_key_for(focus_keys[i]),
/*predicate*/ {}, // no-op if index out of range — registry layer doesn't need to know
[i](const CommandContext& ctx) { return handler_focus_window_n(i, ctx); },
{},
});
}
}
// MoveWindowToMonitor1..9 — same pattern.
{
const KeyAction move_keys[9] = {
KeyAction::MoveWindowToMonitor1, KeyAction::MoveWindowToMonitor2, KeyAction::MoveWindowToMonitor3,
KeyAction::MoveWindowToMonitor4, KeyAction::MoveWindowToMonitor5, KeyAction::MoveWindowToMonitor6,
KeyAction::MoveWindowToMonitor7, KeyAction::MoveWindowToMonitor8, KeyAction::MoveWindowToMonitor9,
};
for (int i = 0; i < 9; ++i) {
register_one(ActionDef{
QString("window.move_to_monitor_%1").arg(i + 1),
QString("Move Window to Monitor %1").arg(i + 1),
"Window",
{QString("monitor %1").arg(i + 1)},
current_key_for(move_keys[i]),
require_more_than_one_monitor(),
[i](const CommandContext& ctx) { return handler_move_window_to_monitor(i, ctx); },
{},
});
}
}
// ── Terminal-level actions (shell-scoped, ignore focused frame) ────────
register_one(ActionDef{
"terminal.lock_now",
"Lock Terminal",
"Terminal",
{"lock", "lock now"},
current_key_for(KeyAction::LockNow),
/*predicate*/ {}, // always available
&handler_lock_now,
{},
});
// ── Help-level actions ──────────────────────────────────────────────────
register_one(ActionDef{
"help.replay_tour",
"Replay Welcome Tour",
"Help",
{"tour", "replay tour", "onboarding"},
QKeySequence{}, // no default hotkey — discoverable via palette
/*predicate*/ {},
&handler_replay_tour,
{},
});
register_one(ActionDef{
"help.enterprise",
"Fincept Terminal Enterprise",
"Help",
{"enterprise", "private edition", "upgrade", "demo", "firm"},
QKeySequence{},
/*predicate*/ {},
&handler_help_enterprise,
{},
});
// ── Account-level actions ───────────────────────────────────────────────
register_one(ActionDef{
"billing.plans",
"Plans & Pricing",
"Account",
{"plans", "pricing", "upgrade", "pro", "billing"},
QKeySequence{},
require_unlocked_frame(),
&handler_billing_plans,
{},
});
LOG_INFO(kBuiltinTag, QString("Registered %1 builtin actions").arg(ActionRegistry::instance().size()));
}
QString action_id_for(KeyAction a) {
// Kept in sync with the register_one() calls above. Per-screen
// KeyActions (NavNext, NewsOpen, RunCell, etc.) intentionally return
// empty — those bind directly inside their owning screens, not via
// the global ActionRegistry.
switch (a) {
case KeyAction::Refresh:
return QStringLiteral("panel.refresh");
case KeyAction::ToggleChat:
return QStringLiteral("frame.toggle_chat_mode");
case KeyAction::FocusMode:
return QStringLiteral("frame.toggle_focus_mode");
case KeyAction::Fullscreen:
return QStringLiteral("frame.toggle_fullscreen");
case KeyAction::Screenshot:
return QStringLiteral("frame.screenshot");
case KeyAction::LockNow:
return QStringLiteral("terminal.lock_now");
case KeyAction::ToggleAlwaysOnTop:
return QStringLiteral("frame.toggle_always_on_top");
case KeyAction::BrowseComponents:
return QStringLiteral("frame.browse_components");
case KeyAction::CyclePanelsForward:
return QStringLiteral("panel.cycle_forward");
case KeyAction::CyclePanelsBack:
return QStringLiteral("panel.cycle_back");
case KeyAction::CycleWindowsForward:
return QStringLiteral("window.cycle_forward");
case KeyAction::CycleWindowsBack:
return QStringLiteral("window.cycle_back");
case KeyAction::NewWindowNextMonitor:
return QStringLiteral("window.new_on_next_monitor");
case KeyAction::FocusWindow1:
return QStringLiteral("window.focus_1");
case KeyAction::FocusWindow2:
return QStringLiteral("window.focus_2");
case KeyAction::FocusWindow3:
return QStringLiteral("window.focus_3");
case KeyAction::FocusWindow4:
return QStringLiteral("window.focus_4");
case KeyAction::FocusWindow5:
return QStringLiteral("window.focus_5");
case KeyAction::FocusWindow6:
return QStringLiteral("window.focus_6");
case KeyAction::FocusWindow7:
return QStringLiteral("window.focus_7");
case KeyAction::FocusWindow8:
return QStringLiteral("window.focus_8");
case KeyAction::FocusWindow9:
return QStringLiteral("window.focus_9");
case KeyAction::MoveWindowToMonitor1:
return QStringLiteral("window.move_to_monitor_1");
case KeyAction::MoveWindowToMonitor2:
return QStringLiteral("window.move_to_monitor_2");
case KeyAction::MoveWindowToMonitor3:
return QStringLiteral("window.move_to_monitor_3");
case KeyAction::MoveWindowToMonitor4:
return QStringLiteral("window.move_to_monitor_4");
case KeyAction::MoveWindowToMonitor5:
return QStringLiteral("window.move_to_monitor_5");
case KeyAction::MoveWindowToMonitor6:
return QStringLiteral("window.move_to_monitor_6");
case KeyAction::MoveWindowToMonitor7:
return QStringLiteral("window.move_to_monitor_7");
case KeyAction::MoveWindowToMonitor8:
return QStringLiteral("window.move_to_monitor_8");
case KeyAction::MoveWindowToMonitor9:
return QStringLiteral("window.move_to_monitor_9");
// Per-screen actions — not in ActionRegistry yet.
case KeyAction::NavNext:
case KeyAction::NavPrev:
case KeyAction::NavAccept:
case KeyAction::NavEscape:
case KeyAction::NewsNext:
case KeyAction::NewsPrev:
case KeyAction::NewsOpen:
case KeyAction::NewsClose:
case KeyAction::RunCell:
case KeyAction::RunAndNext:
case KeyAction::RenameCell:
return {};
}
return {};
}
} // namespace fincept::actions