API — ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels

The public contract of 25 header(s) under src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels — 48 class/struct definition(s), 288 declaration(s). Each section shows the header's banner and its public (and protected-virtual) surface exactly as the file writes it.

ICoreFixedPanelLayoutDebug.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/ICoreFixedPanelLayoutDebug.h

Declares no class of its own — see the file.

ICoreCopilotFloatingButton.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/CopilotButton/ICoreCopilotFloatingButton.h

ICoreCopilotFloatingButton#

ICoreCopilotFloatingButton.h:37 · class · final · bases public ICoreToolBar · pImpl · 12 declaration(s)

The Copilot launcher, pinned to the bottom-right corner of the block editor window.

class ICoreCopilotFloatingButton final : public ICoreToolBar {
public:
    explicit ICoreCopilotFloatingButton(ICoreWidget* parent, ICoreStudioSurface* parentStudioSurface);

    void showCopilot();
    void hideCopilot();

    // The log of past notifications, on the right-click of the chip. The bubbles
    // this corner speaks are transient, so the chip that said them is also where
    // you ask what it said — left-click for Copilot, right-click for the record.
    void showNotificationHistory();

    ICoreRightFixedPanelMenuPanel* getMenuPanel() const;

    // Vertical room the launcher claims in the corner, hover growth included.
    // The right menu panel stays clear of it, so the two never overlap.
    static int reservedCornerHeight();

    // Out of line: the animation unique_ptrs need the complete type there.
    ~ICoreCopilotFloatingButton() override;

protected:
    // ⚠ P5.8's "chained no-op calls" decision, resolved: the retired Qt bodies
    // each opened with ICoreToolBar::<handler>(event), and those calls really
    // were no-ops. ICoreToolBar overrides paintContent and NOTHING else, so
    // every one of them resolved to ICoreWidget's handler, which just runs an
    // empty hook. Dropping them changes no behaviour; keeping them as
    // ICoreToolBar::pointerEntered() etc. would have been four calls into empty
    // base hooks, written to look load-bearing.
    bool mousePressed(const ICoreMouseEvent& event) override;
    void shown() override;
    void pointerEntered() override;
    void pointerLeft() override;

    // Replaces the toolbar's raised surface + hairline with a plain brand-blue
    // chip, so the light logo sits on the royal fill with no border around it.
    // Deliberately does NOT call ICoreToolBar::paintContent — that one is not a
    // no-op, and not calling it is what "replaces" means here.
    void paintContent(ICorePainter& painter) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreLauncherActionRail.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/CopilotButton/ICoreLauncherActionRail.h

ICoreLauncherActionRail#

ICoreLauncherActionRail.h:29 · class · final · bases public ICoreWidget · pImpl · 8 declaration(s)

class ICoreLauncherActionRail final : public ICoreWidget {
public:
    explicit ICoreLauncherActionRail(ICoreWidget* host);

    // Fade in, cancelling any dismissal already on its way.
    void reveal();

    // Begin watching for the cursor to leave. Nothing happens while it is still
    // on the rail or on the chip — which is what lets it cross the gap between
    // them, in either direction, without the rail vanishing mid-reach.
    void dismissSoon();

    // Right edge against the anchor's left, centred on it. The anchor is
    // remembered: "has the cursor left?" is a question about the chip and the
    // rail together, and this class is the one holding both.
    void positionBeside(ICoreWidget* anchor);

    // Declared, defined in the .cpp: the residue at the bottom is a unique_ptr
    // to an Impl this header cannot see.
    ~ICoreLauncherActionRail() override;

    // ICore signals, not Qt ones: this class is an ICoreWidget, so its Qt
    // signals would not survive the pImpl conversion.
    ICoreSignal<> onCopilotRequested;
    ICoreSignal<> onNotificationsRequested;

    // The cursor has left the rail AND the chip. The chip listens for this to
    // know when to shrink back: its own leaveEvent fires the moment the cursor
    // steps across onto these buttons, which is not the same thing at all.
    ICoreSignal<> onDismissed;

protected:
    void pointerEntered() override;
    void pointerLeft() override;

    // The capsule the buttons sit in, painted in the chip's own material so the
    // pair reads as the chip having opened rather than as a menu arriving.
    void paintContent(ICorePainter& painter) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreLeftFixedPanel.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/LeftFixedPanel/ICoreLeftFixedPanel.h

How this rail's body gradient is spread. Published because the editor title bar continues it upward so the three read as one piece (A10.80): the title bar must use the SAME numbers, or a seam appears where they meet.

ICoreLeftFixedPanel#

ICoreLeftFixedPanel.h:62 · class · bases public ICoreWidget · pImpl · 38 declaration(s)

class ICoreLeftFixedPanel : public ICoreWidget {
public:
    // How this rail's body gradient is spread. Published because the editor
    // title bar continues it upward so the three read as one piece (A10.80):
    // the title bar must use the SAME numbers, or a seam appears where they meet.
    static constexpr ICoreGradientDirection kGradientDirection = ICoreGradientDirection::BottomLeftToTopRight;
    static constexpr double kGradientLitStrength = 0.6;

    // The rail's width, which is fixed and is also the left edge of the working
    // area for anything that has to centre itself over the CANVAS rather than
    // over the whole window.
    //
    // ⚠ PUBLISHED BECAUSE A SECOND PLACE NEEDS IT AND WAS GUESSING. The time
    // line anchors itself to the primary window with an x scale of 0.5, which
    // centres it on the WINDOW -- and the window includes this rail, so the bar
    // sat half the rail's width left of the canvas's centre. Measured: canvas
    // centre 886, bar centre 776, difference 110, which is exactly 220 / 2.
    // Naming the number here rather than writing 110 over there is what stops
    // the two drifting the next time the rail is resized.
    static constexpr int kRailWidth = 220;

    explicit ICoreLeftFixedPanel(ICoreWidget* parent, ICoreStudioSurface* parentStudioSurface);

    // A surface WITHOUT a rail -- a spawned editor window's; only the primary
    // window builds one (owner, 2026-09-25) -- still wants the rim this rail's
    // constructor runs under the title bar on either side of the top bar. This
    // builds the two strips, from the window's left edge to the top bar's
    // left fillet and from its right fillet to the window's right edge.
    static void addTitleBarGapBordersWithoutRail(ICoreStudioSurface* surface);

    // The rail's sliding menu panel -- the Library, the Subsystem Navigator and
    // the rest of the pages below.
    //
    // ⚠ IT IS PARENTED TO THE STUDIO SURFACE AND NOT TO THIS RAIL, so anything
    // asking "what floats over the canvas" has to be told about it separately:
    // walking out from the rail does not find it. Returned as ICoreWidget*
    // because every caller so far wants its geometry and its visibility, which
    // are the base's.
    [[nodiscard]] ICoreWidget* getMenuPanelWidget() const;

    // Seats `footer` at the foot of the rail, BELOW and OUTSIDE the scroll pane
    // that holds the buttons, so it stays put however far the list scrolls --
    // the licence badge (ICoreLicenseStateLabel, owner 2026-09-25). `footer`
    // must be built with this rail as its parent. Hidden, it takes no height.
    void addFooterWidget(ICoreWidget* footer) const;

    // The pages the rail can put into the sliding menu panel. Only the ones that
    // are menu pages: Home retargets the canvas, and Script Runner and Code
    // Export Verification open windows of their own.
    enum class MenuPage {
        Library,
        SubsystemNavigator,
        SolverConfiguration,
        Settings,
        Variables,
        PointerInspector,
        QuickCode,
        Deploy,
        Git,
        RunDiagnosis,
        Terminal,
        FFT,
        SystemIdentification,
        Quaternion,
        Spline,
        ClassicalControlAnalysis,
        FilterDesign,
        Toolchains,
    };

    // Opens `page` in a window of its own, leaving the docked panel alone. This
    // is what the menu bar's View > Tool Panels entries do — unlike the rail
    // buttons, which slide the page out of the panel.
    void openMenuPageInSeparateWindow(MenuPage page) const;

    void hideMenuPanel() const;

    // The toggle half of a rail button's click: a button whose page is the one
    // already on show folds the panel away and reports true, so the caller stops
    // short of the requestToShowMenu_* call that would re-open it.
    //
    // Only the rail buttons go through here. Everything else that reaches a page
    // — the menu bar, the global search dialog, a run alert — asks for it by
    // name and means show it, not toggle it.
    bool closeMenuPanelIfShowing(MenuPage page) const;

    void requestToShowMenu_Library() const;
    // The library panel, toggled to its My Blocks page (the user block
    // library). The My Blocks quick-reach button lands here.
    void requestToShowMenu_MyBlocks() const;
    void requestToShowMenu_SolverConfiguration() const;
    void requestToShowMenu_Settings() const;
    void requestToShowMenu_Variables() const;
    void requestToShowMenu_QuickCode() const;
    void requestToShowMenu_Deploy() const;
    void requestToShowMenu_Git() const;
    void requestToShowMenu_RunDiagnosis() const;
    void requestToShowMenu_Terminal() const;
    // Which Python, compilers and simulators the app runs (toolchains row TC3.1).
    void requestToShowMenu_Toolchains() const;
    void requestToShowMenu_PointerInspector() const;
    void requestToShowMenu_SubsystemNavigator() const;
    void openCommandScriptWindow();

    // Model navigation, shared by the Subsystem Navigator double-click and the
    // global search dialog: paths are resolved through the registry at call
    // time, so a stale path is a no-op instead of a dangling pointer.
    void navigateToTreeNodePath(const ICoreString& treeNodePath) const;
    void navigateToBlockPath(const ICoreString& blockPath) const;

    // Subsystem Navigator right-click menu. A tree node can only be loaded into
    // one canvas at a time, so both fall back to focusing the existing tab when
    // the subsystem is already open somewhere.
    void openTreeNodePathInNewTab(const ICoreString& treeNodePath) const;
    void openTreeNodePathInNewWindow(const ICoreString& treeNodePath) const;

    void requestToShowMenu_FFT() const;
    void requestToShowMenu_SystemIdentification() const;
    void requestToShowMenu_Quaternion() const;
    void requestToShowMenu_Spline() const;
    void requestToShowMenu_ClassicalControlAnalysis() const;
    void requestToShowMenu_FilterDesign() const;

    ICoreStudioSurface* getParentStudioSurface() const;

    ~ICoreLeftFixedPanel() override;

protected:
    // Framed with the same outline a block carries on the canvas, so the
    // window's chrome and the diagram inside it share one edge.
    ICoreColor borderColor() const override;

    // ⚠⚠ A FLOATING PANEL IS OPAQUE TO THE POINTER, AND DECLINING WAS NOT THE
    // SAME AS BEING OPAQUE. These panels are laid over the canvas rather than
    // beside it, so every one of these hooks reaching its default -- which
    // RETURNS FALSE -- meant the gesture carried on past the panel: on the
    // AppKit seat a declined press is handed to `[super mouseDown:]` and a
    // declined wheel to `[super scrollWheel:]`, each of which walks the
    // responder chain, and on Qt an ignored event propagates the same way. The
    // owner's report is what that looks like from the front: a click or a wheel
    // on the chrome pans, zooms or deselects the diagram underneath it.
    //
    // ⚠ TRUE ON THE PANEL ITSELF COSTS ITS CONTENTS NOTHING. Every control on
    // these panels is a child widget with its own view, and a child is offered
    // the gesture BEFORE its parent -- so a button, a field or a scrolled list
    // still answers exactly as before, and only a gesture that landed on the
    // bare panel is stopped here. That gesture had nowhere useful to go anyway.
    bool mousePressed(const ICoreMouseEvent& event) override;
    bool mouseReleased(const ICoreMouseEvent& event) override;
    bool mouseDoubleClicked(const ICoreMouseEvent& event) override;
    bool wheelScrolled(const ICoreWheelEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreLeftFixedPanelSpacer#

ICoreLeftFixedPanel.h:222 · class · bases public ICoreWidget · 2 declaration(s)

class ICoreLeftFixedPanelSpacer : public ICoreWidget {
public:
    explicit ICoreLeftFixedPanelSpacer(double height = 10);

    ~ICoreLeftFixedPanelSpacer() override;
};
};

ICoreLeftFixedPanelMenuPanel.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/LeftFixedPanel/ICoreLeftFixedPanelMenuPanel.h

ICoreLeftFixedPanelMenuPanel#

ICoreLeftFixedPanelMenuPanel.h:15 · class · final · bases public ICoreFixedPanelMenuPanel · 6 declaration(s)

The menu panel of the left fixed panel: slides out to the right of the left button rail, so its top-left corner is a fixed offset that clears both the left rail and the top panel.

class ICoreLeftFixedPanelMenuPanel final : public ICoreFixedPanelMenuPanel {
public:
    explicit ICoreLeftFixedPanelMenuPanel(ICoreStudioSurface* parent = nullptr);

    ~ICoreLeftFixedPanelMenuPanel() override;

protected:
    void anchorToParent() override;
    ICoreSizeF openSize(int targetWidth) const override;
    ICoreSizeF closedSize() const override;
    void handleParentResize() override;

    // This panel holds no state of its own, so it has no Impl. Its one private
    // helper -- the height it fits into -- is a file-static in the .cpp.
};
};

ICoreLeftFixedPanelMainMenuButtons.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/LeftFixedPanel/MainMenuButtons/ICoreLeftFixedPanelMainMenuButtons.h

All twenty buttons answer the press through ICoreWidget's mousePressed hook (P5.2) rather than overriding mousePressEvent.

⚠ EVERY ONE OF THEM RETURNS true, INCLUDING DOWN THE BRANCH THAT DOES NOTHING, and that is the faithful translation rather than a shortcut. None of the twenty called its base before the migration, so the press was consumed here in every case -- including the early return that means "the panel was already showing this page, so folding it away WAS the whole action". Under the hook, return false forwards to QWidget::mousePressEvent, which is a different behaviour and not the one being replaced. Same rule the scene tier recorded at P2.8; the trap is that false reads like the conservative choice and is not.

None of the twenty touched the event: no position, no button, no accept or

LeftFixedPanel_HomeButton#

ICoreLeftFixedPanelMainMenuButtons.h:35 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

///// ------------------------------ / / Quick Reach / /

class LeftFixedPanel_HomeButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_HomeButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_HomeButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_LibraryButton#

ICoreLeftFixedPanelMainMenuButtons.h:46 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_LibraryButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_LibraryButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_LibraryButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_MyBlocksButton#

ICoreLeftFixedPanelMainMenuButtons.h:60 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

Opens the library panel directly on its My Blocks page (the user block library, USER_BLOCK_WIZARD.md) — the Block Wizard's front door until the wizard window itself lands (board row W3.4 -> W4).

class LeftFixedPanel_MyBlocksButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_MyBlocksButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_MyBlocksButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_SubsystemNavigatorButton#

ICoreLeftFixedPanelMainMenuButtons.h:71 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_SubsystemNavigatorButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_SubsystemNavigatorButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_SubsystemNavigatorButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_SolverConfigButton#

ICoreLeftFixedPanelMainMenuButtons.h:88 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

///// ------------------------------ / / Configuration / /

class LeftFixedPanel_SolverConfigButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_SolverConfigButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_SolverConfigButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_SettingsButton#

ICoreLeftFixedPanelMainMenuButtons.h:99 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_SettingsButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_SettingsButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_SettingsButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_VariablesButton#

ICoreLeftFixedPanelMainMenuButtons.h:110 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_VariablesButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_VariablesButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_VariablesButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_QuickCodeButton#

ICoreLeftFixedPanelMainMenuButtons.h:127 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

///// ------------------------------ / / Tools / /

class LeftFixedPanel_QuickCodeButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_QuickCodeButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_QuickCodeButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_DeployButton#

ICoreLeftFixedPanelMainMenuButtons.h:138 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_DeployButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_DeployButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_DeployButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_CodeExportVerificationButton#

ICoreLeftFixedPanelMainMenuButtons.h:149 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_CodeExportVerificationButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_CodeExportVerificationButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_CodeExportVerificationButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_GitButton#

ICoreLeftFixedPanelMainMenuButtons.h:160 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_GitButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_GitButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_GitButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_ToolchainsButton#

ICoreLeftFixedPanelMainMenuButtons.h:173 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

Toolchains: which Python, compilers and simulators the app runs (toolchains row TC3.1).

class LeftFixedPanel_ToolchainsButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_ToolchainsButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_ToolchainsButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_RunDiagnosisButton#

ICoreLeftFixedPanelMainMenuButtons.h:184 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_RunDiagnosisButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_RunDiagnosisButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_RunDiagnosisButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_ToolWindowButton#

ICoreLeftFixedPanelMainMenuButtons.h:197 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

A module's own window (ICoreStudioRegistry::registerToolWindow, ICore 3D row ED8.2): its title and icon, and a press that opens it.

class LeftFixedPanel_ToolWindowButton : public ICoreHBoxButton {
public:
    LeftFixedPanel_ToolWindowButton(ICoreLeftFixedPanel* parent, const ICoreStudioToolWindow& entry);
    ~LeftFixedPanel_ToolWindowButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_TerminalButton#

ICoreLeftFixedPanelMainMenuButtons.h:208 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_TerminalButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_TerminalButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_TerminalButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_CommandScriptButton#

ICoreLeftFixedPanelMainMenuButtons.h:222 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

Copilot has no entry here: it is reached from ICoreCopilotFloatingButton in the bottom-right corner of the editor.

class LeftFixedPanel_CommandScriptButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_CommandScriptButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_CommandScriptButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_PointerInspectorButton#

ICoreLeftFixedPanelMainMenuButtons.h:233 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_PointerInspectorButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_PointerInspectorButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_PointerInspectorButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_FFTToolButton#

ICoreLeftFixedPanelMainMenuButtons.h:250 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

///// ------------------------------ / / Math Tools / /

class LeftFixedPanel_FFTToolButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_FFTToolButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_FFTToolButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_SystemIdentificationToolButton#

ICoreLeftFixedPanelMainMenuButtons.h:261 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_SystemIdentificationToolButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_SystemIdentificationToolButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_SystemIdentificationToolButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_QuaternionToolButton#

ICoreLeftFixedPanelMainMenuButtons.h:272 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_QuaternionToolButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_QuaternionToolButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_QuaternionToolButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_SplineToolButton#

ICoreLeftFixedPanelMainMenuButtons.h:283 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_SplineToolButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_SplineToolButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_SplineToolButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_ClassicalControlAnalysisToolButton#

ICoreLeftFixedPanelMainMenuButtons.h:294 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_ClassicalControlAnalysisToolButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_ClassicalControlAnalysisToolButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_ClassicalControlAnalysisToolButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

LeftFixedPanel_FilterDesignToolButton#

ICoreLeftFixedPanelMainMenuButtons.h:305 · class · bases public ICoreHBoxButton · pImpl · 3 declaration(s)

class LeftFixedPanel_FilterDesignToolButton : public ICoreHBoxButton {
public:
    explicit LeftFixedPanel_FilterDesignToolButton(ICoreLeftFixedPanel* parent);
    ~LeftFixedPanel_FilterDesignToolButton() override;
protected:
    bool mousePressed(const ICoreMouseEvent& event) override;
private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreFixedPanelMenuPanel.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/MenuPanels/ICoreFixedPanelMenuPanel.h

ICoreFixedPanelMenuPanel#

ICoreFixedPanelMenuPanel.h:33 · class · bases public ICoreWidget · pImpl · 20 declaration(s)

Shared behaviour of the sliding menu panels that float above the canvas: the title bar (open-in-window + pin), the page stack and the open/close size animation.

class ICoreFixedPanelMenuPanel : public ICoreWidget {
public:
    explicit ICoreFixedPanelMenuPanel(ICoreStudioSurface* parent = nullptr);

    // Builds a brand-new, independent instance of a page. Every caller of
    // loadContent should supply one: it is the only thing that lets the title
    // bar's window button hand out a copy instead of the panel's own page.
    using ContentFactory = std::function<ICoreWidget*()>;

    // `contentPaneToLoad` must be a widget already added to getContentLayout();
    // `detachedCopyFactory` builds an equivalent one from scratch, and the page
    // it returns is owned by the window that asked for it. Omitting the factory
    // leaves the window button inert for that page.
    void loadContent(const ICoreString& title, ICoreNativeWidget* contentPaneToLoad, ContentFactory detachedCopyFactory = {});

    // Puts a FRESH copy of the page currently on show into a window of its own,
    // leaving this panel docked and untouched. Repeated calls each give another
    // independent window.
    void openCurrentPageInSeparateWindow();

    // The same, for a page the panel is not showing and does not have to load:
    // this is how a menu entry opens a panel straight into a window. Sized from
    // `preferredWidth` because a page the panel never opened cannot be measured
    // off the panel itself.
    void openPageInSeparateWindow(const ICoreString& title, const ContentFactory& factory, int preferredWidth);

    void setIsPinned(const bool& newIsPinnedToCanvas);

    // Appearing and disappearing animate the whole size, so a subclass whose
    // open and closed sizes differ in both dimensions unfolds out of the corner
    // that anchorToParent() pins.
    void animateOpenTo(int targetWidth);
    void animateClosed();

    ICoreStackedLayout* getContentLayout() const;
    bool getIsPinned() const;

    // The studio surface this panel is docked in -- the one it was constructed
    // with, so a subclass can place itself against its sibling panels. Null for
    // a panel built without one.
    [[nodiscard]] ICoreStudioSurface* dockedSurface() const;

    ~ICoreFixedPanelMenuPanel() override;

protected:
    // The parent window resized. Armed with watchParentResizes(true) in the
    // constructor -- Surface::Panel installs a filter on the parent for its own
    // snapping, but that does NOT arm this hook; the flag gates delivery.
    void parentResized(const ICoreSizeF& newParentSize) override;

    // Places the panel inside the studio window. Called on construction,
    // on every step of the size animation and whenever the parent resizes, so
    // an edge-anchored panel keeps its edge while its size changes.
    virtual void anchorToParent() = 0;

    // The size the panel animates to when it opens at targetWidth, and the one
    // it folds back to. Keep the same height in both to animate width only.
    virtual ICoreSizeF openSize(int targetWidth) const = 0;
    virtual ICoreSizeF closedSize() const = 0;

    // The parent window resized. The default only re-places the panel; override
    // to also make its size follow the window.
    virtual void handleParentResize();

    // ⚠⚠ A FLOATING PANEL IS OPAQUE TO THE POINTER, AND DECLINING WAS NOT THE
    // SAME AS BEING OPAQUE. These panels are laid over the canvas rather than
    // beside it, so every one of these hooks reaching its default -- which
    // RETURNS FALSE -- meant the gesture carried on past the panel: on the
    // AppKit seat a declined press is handed to `[super mouseDown:]` and a
    // declined wheel to `[super scrollWheel:]`, each of which walks the
    // responder chain, and on Qt an ignored event propagates the same way. The
    // owner's report is what that looks like from the front: a click or a wheel
    // on the chrome pans, zooms or deselects the diagram underneath it.
    //
    // ⚠ TRUE ON THE PANEL ITSELF COSTS ITS CONTENTS NOTHING. Every control on
    // these panels is a child widget with its own view, and a child is offered
    // the gesture BEFORE its parent -- so a button, a field or a scrolled list
    // still answers exactly as before, and only a gesture that landed on the
    // bare panel is stopped here. That gesture had nowhere useful to go anyway.
    bool mousePressed(const ICoreMouseEvent& event) override;
    bool mouseReleased(const ICoreMouseEvent& event) override;
    bool mouseDoubleClicked(const ICoreMouseEvent& event) override;
    bool wheelScrolled(const ICoreWheelEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreFixedPanelMenuPanel_PinButton#

ICoreFixedPanelMenuPanel.h:123 · class · bases public ICoreButton · pImpl · 3 declaration(s)

class ICoreFixedPanelMenuPanel_PinButton : public ICoreButton {
public:
    explicit ICoreFixedPanelMenuPanel_PinButton(ICoreFixedPanelMenuPanel* parent);
    ~ICoreFixedPanelMenuPanel_PinButton() override;

protected:
    bool mousePressed(const ICoreMouseEvent&) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreFixedPanelMenuPanel_OpenInSeparateWindow#

ICoreFixedPanelMenuPanel.h:138 · class · bases public ICoreButton · pImpl · 3 declaration(s)

class ICoreFixedPanelMenuPanel_OpenInSeparateWindow : public ICoreButton {
public:
    explicit ICoreFixedPanelMenuPanel_OpenInSeparateWindow(ICoreFixedPanelMenuPanel* parent);
    ~ICoreFixedPanelMenuPanel_OpenInSeparateWindow() override;

protected:
    bool mousePressed(const ICoreMouseEvent&) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreFixedPanelMenuPanelTrace.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/MenuPanels/ICoreFixedPanelMenuPanelTrace.h

W10.6's instrument, and it is a FREE FUNCTION rather than a member for a reason worth stating: a protected helper on ICoreFixedPanelMenuPanel is exactly what the header surface rule forbids, and the census caught it -- R4.2 ... [helper] protected function void traceGeometry. The numbers it prints are all reachable from inside any member of the panel or its subclasses, so nothing is lost by passing them in.

Off unless ICORE_PANEL_TRACE is set. One line per EVENT rather than a running total: there are two of these panels in an editor window, not five thousand, and each of the owner's questions -- "was anything opened", "what size did it end up", "where did it put itself" -- is answered by a single line at the moment it happens.

⚠ IT PRINTS THE PARENT'S SIZE ALONGSIDE THE PANEL'S OWN, because three

Declares no class of its own — see the file.

ICoreDetachedPanelWindow.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/MenuPanels/DetachedPanelWindow/ICoreDetachedPanelWindow.h

ICoreDetachedPanelWindow#

ICoreDetachedPanelWindow.h:19 · class · bases public ICoreWidget · 2 declaration(s)

A plain top-level window holding one menu-panel page.

class ICoreDetachedPanelWindow : public ICoreWidget {
public:
    // Takes ownership of `content` by reparenting it into the window.
    explicit ICoreDetachedPanelWindow(const ICoreString& title, ICoreWidget* content);

    ~ICoreDetachedPanelWindow() override;

};
};

ICoreRightFixedPanelMenuPanel.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/RightFixedPanel/MenuPanels/ICoreRightFixedPanelMenuPanel.h

ICoreRightFixedPanelMenuPanel#

ICoreRightFixedPanelMenuPanel.h:18 · class · final · bases public ICoreFixedPanelMenuPanel · pImpl · 9 declaration(s)

The right-hand counterpart of ICoreLeftFixedPanelMenuPanel.

class ICoreRightFixedPanelMenuPanel final : public ICoreFixedPanelMenuPanel {
public:
    explicit ICoreRightFixedPanelMenuPanel(ICoreStudioSurface* parent = nullptr);

    // Slides the panel in at its full width, or back out when it is already
    // showing. Returns true when the panel ended up open. The launcher is the
    // panel's only toggle, so closing this way overrides the pin — otherwise a
    // pinned panel could never be dismissed from the button that opened it.
    //
    // `detachedCopyFactory` is passed straight to loadContent — see there for
    // what the title bar's window button does with it.
    bool toggleOpen(const ICoreString& title, ICoreNativeWidget* contentPaneToShow, ContentFactory detachedCopyFactory = {});

    // Pass force to fold the panel away even while pinned. The pin itself is
    // left set, so reopening brings the panel back pinned.
    void close(bool force = false);

    bool getIsOpen() const;

    ~ICoreRightFixedPanelMenuPanel() override;

protected:
    void anchorToParent() override;
    ICoreSizeF openSize(int targetWidth) const override;
    ICoreSizeF closedSize() const override;

    // An open panel's size is capped by what the window can hold, so a window
    // resize changes its SIZE and not only its position. The base's version
    // only re-anchors, which leaves a shrunk window showing a panel sized for
    // the old one.
    void handleParentResize() override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICorePauseTargetDash.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICorePauseTargetDash.h

ICorePauseTargetDash#

ICorePauseTargetDash.h:15 · class · final · bases public ICoreWidget · pImpl · 3 declaration(s)

The fast-forward mark on the time line's ruler: where the solver's pause target sits (ICoreModelSimulator::setPauseTarget).

class ICorePauseTargetDash final : public ICoreWidget {
public:
    explicit ICorePauseTargetDash(ICoreWidget* parent = nullptr);
    ~ICorePauseTargetDash() override;

protected:
    void paintContent(ICorePainter& painter) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreProgressDash.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICoreProgressDash.h

ICoreProgressDash#

ICoreProgressDash.h:11 · class · final · bases public ICoreWidget · pImpl · 3 declaration(s)

class ICoreProgressDash final : public ICoreWidget {
public:
    explicit ICoreProgressDash(ICoreWidget* parent = nullptr);
    ~ICoreProgressDash() override;

protected:
    void paintContent(ICorePainter& painter) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreProgressPercentageLabel.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICoreProgressPercentageLabel.h

Floats directly above ICoreTimeLine while a run is in progress, so it takes the same ground that bar does rather than the raised surface every other tool bar uses.

ICoreProgressPercentageLabel#

ICoreProgressPercentageLabel.h:15 · class · bases public ICoreToolBar · pImpl · 4 declaration(s)

class ICoreProgressPercentageLabel : public ICoreToolBar {
public:
    explicit ICoreProgressPercentageLabel(ICoreWidget* parent = nullptr);

    ICoreLabel* getLabel() const;
    ~ICoreProgressPercentageLabel() override;

protected:
    // Floats directly above ICoreTimeLine while a run is in progress, so it
    // takes the same ground that bar does rather than the raised surface every
    // other tool bar uses.
    ICoreColor fillColor() const override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreTimeLine.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICoreTimeLine.h

Narrowed off ICoreAnyWidget at P5.10, which is what the previous note here was waiting for. It does NOT narrow to ICoreWidget* -- the caller parents this to an ICorePrimaryWindow, which reaches QMainWindow rather than ICoreWidget -- but ICorePrimaryWindow does implement ICoreNativeWidget, so the interface is the type that actually fits both this caller and ICoreToolBar's migrated constructor.

ICoreTimeLine#

ICoreTimeLine.h:15 · class · bases public ICoreToolBar · pImpl · 14 declaration(s)

class ICoreTimeLine : public ICoreToolBar {
public:
    // Narrowed off ICoreAnyWidget at P5.10, which is what the previous note
    // here was waiting for. It does NOT narrow to ICoreWidget* -- the caller
    // parents this to an ICorePrimaryWindow, which reaches QMainWindow rather
    // than ICoreWidget -- but ICorePrimaryWindow does implement
    // ICoreNativeWidget, so the interface is the type that actually fits both
    // this caller and ICoreToolBar's migrated constructor.
    explicit ICoreTimeLine(ICoreNativeWidget* parent = nullptr);

    void refreshStartTime() const;
    void refreshStopTime() const;

    void resetProgressBar();
    void startProgressUpdateTimer();
    void stopProgressUpdateTimer();
    void startInfiniteProgressAnimation();
    void stopInfiniteProgressAnimation();

    ~ICoreTimeLine() override;

protected:
    // This bar keeps the identity's near-black ground rather than the raised
    // surface every other tool bar takes.
    ICoreColor fillColor() const override;

    // ⚠⚠ A FLOATING PANEL IS OPAQUE TO THE POINTER, AND DECLINING WAS NOT THE
    // SAME AS BEING OPAQUE. These panels are laid over the canvas rather than
    // beside it, so every one of these hooks reaching its default -- which
    // RETURNS FALSE -- meant the gesture carried on past the panel: on the
    // AppKit seat a declined press is handed to `[super mouseDown:]` and a
    // declined wheel to `[super scrollWheel:]`, each of which walks the
    // responder chain, and on Qt an ignored event propagates the same way. The
    // owner's report is what that looks like from the front: a click or a wheel
    // on the chrome pans, zooms or deselects the diagram underneath it.
    //
    // ⚠ TRUE ON THE PANEL ITSELF COSTS ITS CONTENTS NOTHING. Every control on
    // these panels is a child widget with its own view, and a child is offered
    // the gesture BEFORE its parent -- so a button, a field or a scrolled list
    // still answers exactly as before, and only a gesture that landed on the
    // bare panel is stopped here. That gesture had nowhere useful to go anyway.
    bool mousePressed(const ICoreMouseEvent& event) override;
    bool mouseReleased(const ICoreMouseEvent& event) override;
    bool mouseDoubleClicked(const ICoreMouseEvent& event) override;
    bool wheelScrolled(const ICoreWheelEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreTimeLineDash.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICoreTimeLineDash.h

ICoreTimeLineDash#

ICoreTimeLineDash.h:11 · class · final · bases public ICoreWidget · pImpl · 4 declaration(s)

class ICoreTimeLineDash final : public ICoreWidget {
public:
    explicit ICoreTimeLineDash(ICoreWidget* parent, bool isMaxDash);
    ~ICoreTimeLineDash() override;

    void configureAsMinimalDash();

protected:
    void paintContent(ICorePainter& painter) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreTimeLineProgressBar.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICoreTimeLineProgressBar.h

Non-const since the elapsed fill: moving the progress dash back to the left edge changes what this bar paints behind it.

ICoreTimeLineProgressBar#

ICoreTimeLineProgressBar.h:14 · class · bases public ICoreWidget · pImpl · 10 declaration(s)

class ICoreTimeLineProgressBar : public ICoreWidget {
public:
    explicit ICoreTimeLineProgressBar(ICoreWidget* parent = nullptr);

    void designDashes();

    void setProgressPercentage(const double& progress, const double& timeValue);
    // Non-const since the elapsed fill: moving the progress dash back to the
    // left edge changes what this bar paints behind it.
    void resetProgress();

    // The fast-forward mark. Re-reads the simulator's pause target and the
    // configured start/stop times, moves the mark (or hides it) and refreshes
    // the tool tip. Called on every progress tick, so a target the kernel
    // consumed or dropped disappears within one tick, and whenever either time
    // field changes, so the mark follows the ruler it is drawn on.
    void refreshPauseTargetMark();

    void startInfiniteProgressAnimation();
    void stopInfiniteProgressAnimation();

    ~ICoreTimeLineProgressBar() override;

protected:
    void paintContent(ICorePainter& painter) override;
    // A left click ahead of the progress mark sets the solver's pause target at
    // the clicked time; a click on the mark clears it; a click behind the
    // progress mark (the solid part) does nothing. See ICoreModelSimulator.h.
    bool mousePressed(const ICoreMouseEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreDialogButtonBox.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/ICoreDialogButtonBox.h

ICoreDialogButtonBox#

ICoreDialogButtonBox.h:42 · class · bases public ICoreWidget · pImpl · 5 declaration(s)

class ICoreDialogButtonBox : public ICoreWidget {
public:
    // ICoreAnyWidget pending the ICoreEssentials reparenting: the caller
    // parents this to an ICoreDialog, which derives from the toolkit's
    // QDialog rather than from ICoreWidget. Narrow this to ICoreWidget*
    // once that base moves.
    // Q1.1 narrowed this: ICoreWidget's ctor takes the interface now, so an
    // ICoreAnyWidget (= QWidget) parent could only reach the base through
    // icoreNativeWidgetOf(), which is the silently-nullptr bridge.
    explicit ICoreDialogButtonBox(ICoreNativeWidget* parent = nullptr);

    // The affirmative. Wears ICoreButton::Variant::Primary and emits
    // accepted(). One per box; calling it twice returns the first.
    ICoreButton* addAcceptButton(const ICoreString& text);

    // The dismissive. Plain variant, emits rejected(). One per box.
    ICoreButton* addRejectButton(const ICoreString& text);

    ICoreButton* acceptButton() const;
    ICoreButton* rejectButton() const;

    // ICore signals, not Qt ones: this class is an ICoreWidget, so Qt signals
    // would not survive the pImpl conversion.
    ICoreSignal<> onAccepted;
    ICoreSignal<> onRejected;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreTopFixedPanel.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/ICoreTopFixedPanel.h

How this top bar's body gradient is spread. Published because the editor title bar continues it upward so the three read as one piece (A10.80): the title bar must use the SAME numbers, or a seam appears where they meet.

ICoreTopFixedPanel#

ICoreTopFixedPanel.h:23 · class · bases public ICoreWidget · pImpl · 17 declaration(s)

class ICoreTopFixedPanel : public ICoreWidget {
public:
    // How this top bar's body gradient is spread. Published because the editor
    // title bar continues it upward so the three read as one piece (A10.80):
    // the title bar must use the SAME numbers, or a seam appears where they meet.
    static constexpr ICoreGradientDirection kGradientDirection = ICoreGradientDirection::BottomRightToTopLeft;
    static constexpr double kGradientLitStrength = 0.6;

    // The bar's geometry (A10.81): the fillet radius (also the bar's corner
    // radius), the gap to the rail and to the window's right edge, and the
    // fixed height. See the constructor for what each one means. kCornerRadius
    // is also the rail's top-right fillet and where the title bar's hairline
    // over the left gap begins.
    static constexpr int kCornerRadius = 15;
    static constexpr int kSideGap = 60;
    static constexpr int kPanelHeight = 97;

    // What every bar in the upper row measures once takeTitleRow() has handed
    // it to the window's title bar: 36, and 32 on macOS, whose 40-high caption
    // strip left a 36 row nearly full-bleed (owner, 2026-09-25). Published
    // because the title bar centres the row on the SAME number.
    [[nodiscard]] static int titleRowHeight();

    explicit ICoreTopFixedPanel(ICoreWidget* parent, ICoreStudioSurface* parentStudioSurface);

    void updateNavButtonsEnable() const;

    // Puts the keyboard in the title bar's "Search Everywhere" field -- Edit > Find
    // (Ctrl+F). Typing there drops the results panel under it, as clicking it does.
    void focusSearch() const;

    ICoreNavBar* getNavigationBar() const;
    ICoreTabHeadersBar* getTabHeadersBar() const;

    // W10.126. The upper row -- menu-strip toggle, back/up, navigation bar,
    // import/export, templates, account and search -- handed to the window's
    // title bar. The row leaves this panel's layout with its margins zeroed
    // (the bar that adopts it places it), the caller parents it, and the panel
    // shrinks to the one row it has left. Asking twice answers null.
    [[nodiscard]] ICoreWidget* takeTitleRow();

    // The row's tool bars (seven; six in a spawned editor window): the parts
    // of it that take clicks, which a title bar declares interactive so the
    // gaps between them stay drag area.
    [[nodiscard]] std::vector<ICoreWidget*> titleRowControls() const;

    // Runs when something in that row changed SHAPE -- a bar shown or hidden,
    // the navigation bar re-sized to a new path. The title bar holding the row
    // re-cuts its click-through holes from it; nothing else listens.
    void setTitleRowChangedHook(std::function<void()> hook);

    // The row is going: the title bar that adopted it is about to be deleted
    // with its window, and the row with it. Forgets every pointer into the row
    // and the hook above, and stops the menu-toggle re-ask, so nothing this
    // panel still runs -- a timer, a resize, a tab's navigation -- reaches a
    // freed widget. Call it before the window's teardown.
    void releaseTitleRow();

    ~ICoreTopFixedPanel() override;

protected:
    // Framed with the same outline a block carries on the canvas, so the
    // window's chrome and the diagram inside it share one edge.
    ICoreColor borderColor() const override;

    // ⚠⚠ THE MENU-STRIP TOGGLE IS RE-DECIDED HERE, AND THE ONE-SHOT CHECK IT
    // REPLACES ANSWERED THE QUESTION TOO EARLY (W10.16). See
    // Impl::refreshMenuBarToggle in the .cpp for the measurement.
    void resized(const ICoreSizeF& newSize, const ICoreSizeF& oldSize) override;

    // ⚠⚠ A FLOATING PANEL IS OPAQUE TO THE POINTER, AND DECLINING WAS NOT THE
    // SAME AS BEING OPAQUE. These panels are laid over the canvas rather than
    // beside it, so every one of these hooks reaching its default -- which
    // RETURNS FALSE -- meant the gesture carried on past the panel: on the
    // AppKit seat a declined press is handed to `[super mouseDown:]` and a
    // declined wheel to `[super scrollWheel:]`, each of which walks the
    // responder chain, and on Qt an ignored event propagates the same way. The
    // owner's report is what that looks like from the front: a click or a wheel
    // on the chrome pans, zooms or deselects the diagram underneath it.
    //
    // ⚠ TRUE ON THE PANEL ITSELF COSTS ITS CONTENTS NOTHING. Every control on
    // these panels is a child widget with its own view, and a child is offered
    // the gesture BEFORE its parent -- so a button, a field or a scrolled list
    // still answers exactly as before, and only a gesture that landed on the
    // bare panel is stopped here. That gesture had nowhere useful to go anyway.
    bool mousePressed(const ICoreMouseEvent& event) override;
    bool mouseReleased(const ICoreMouseEvent& event) override;
    bool mouseDoubleClicked(const ICoreMouseEvent& event) override;
    bool wheelScrolled(const ICoreWheelEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreNavBar.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/NavigationBar/ICoreNavBar.h

W10.126. The bar AND the box inside it. The path field carries its own fixed height, so setFixedHeight() on the bar alone grows the background and leaves the box where it was -- which is what the owner saw when the row moved into the title bar: "nav bar only the background height changed. The box is still same height".

ICoreNavBar#

ICoreNavBar.h:18 · class · bases public ICoreWidget · pImpl · 15 declaration(s)

class ICoreNavBar : public ICoreWidget {
public:
    explicit ICoreNavBar(ICoreWidget *parent, ICoreStudioSurface* parentStudioSurface);

    void designLineTextField();
    void designQuickReachBar();

    void loadDirectory(const std::string& pathToLoad);
    void loadDirectoryToQuickReachBar(const std::string& pathToLoad);

    void clearQuickReachBar();

    // W10.126. The bar AND the box inside it. The path field carries its own
    // fixed height, so setFixedHeight() on the bar alone grows the background
    // and leaves the box where it was -- which is what the owner saw when the
    // row moved into the title bar: *"nav bar only the background height
    // changed. The box is still same height"*.
    void setBarHeight(int height);

    // W10.126. Stop expanding into whatever room the row has, and be as wide
    // as the path on screen -- the owner's rule for the title bar, where the
    // room the bar would have taken is the part of the strip the window is
    // dragged by: *"no need for the nav bar to always expand width to all the
    // empty area. Let its width just be the width of the loaded directory"*.
    // Re-applied on every directory load while it is on.
    void setWidthFollowsContent(bool follows);

    // The most the width above may reach -- the room the row has left for the
    // bar -- or 0 for no ceiling. Past it the crumbs scroll by wheel, with no
    // bar drawn. Set by the title row on every resize (owner, 2026-09-25:
    // *"expand to fill the title bar up to import/export toolbar minus 20px"*).
    void setWidthCeiling(int ceiling);

    // Runs when the width above actually changed. What a title bar needs in
    // order to re-cut the holes it gives the platform: the bar moved, so
    // everything after it in the row moved with it (W10.126).
    void setWidthChangedHook(std::function<void()> hook);

    // W10.126, TRIAL. False takes the bar's own ground AND the breadcrumb
    // box's chrome away at rest, so the title bar is seen through both.
    void setChromeVisibleAtRest(bool visible);

    void showLineTextEdit() const;
    void showQuickReachBar() const;

    ~ICoreNavBar() override;

protected:
    // The crumb strip or its viewport changed size: keep the level on screen
    // at the right-hand end (see Impl::scrollCurrentSegmentIntoView).
    void watchedResized(ICoreNativeWidget* watched, const ICoreSizeF& newSize) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreNavBarLineEdit.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/NavigationBar/ICoreNavBarLineEdit.h

ICoreNavBarLineEdit#

ICoreNavBarLineEdit.h:14 · class · bases public ICoreLineEdit · pImpl · 3 declaration(s)

Chrome::None: the whole appearance comes from getStyle_DirectoryTextField() below, so the field must not also paint ICoreLineEdit's rounded border on top of it.

class ICoreNavBarLineEdit : public ICoreLineEdit {
public:
    explicit ICoreNavBarLineEdit(ICoreWidget* parent = nullptr, ICoreNavBar* parentNavBar = nullptr);

    ~ICoreNavBarLineEdit() override;

protected:
    void focusLost(const ICoreFocusEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreNavBarQuickReachButton.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/NavigationBar/ICoreNavBarQuickReachButton.h

Whether this segment is the level actually on screen -- the last crumb of the path. It takes the primary ink; every ancestor above it stays on the secondary one, which is what makes the row read as a path rather than as a line of identical buttons. Off by default, and reset to off by resetToInitialState, so a recycled segment never keeps the emphasis it carried in its previous life.

ICoreNavBarQuickReachButton#

ICoreNavBarQuickReachButton.h:12 · class · bases public ICoreWidget · pImpl · 8 declaration(s)

class ICoreNavBarQuickReachButton : public ICoreWidget {
public:
    explicit ICoreNavBarQuickReachButton(ICoreWidget *parent, ICoreStudioSurface* parentStudioSurface, const std::string& path);

    void resetToInitialState(ICoreNativeWidget *parent, ICoreStudioSurface* parentStudioSurface, const std::string& path);

    // Whether this segment is the level actually on screen -- the last crumb of
    // the path. It takes the primary ink; every ancestor above it stays on the
    // secondary one, which is what makes the row read as a path rather than as
    // a line of identical buttons. Off by default, and reset to off by
    // resetToInitialState, so a recycled segment never keeps the emphasis it
    // carried in its previous life.
    void setCurrentSegment(bool isCurrent);

    // What this crumb wants to be: the caption's measured width plus the
    // chevron beside it. Answered from the number setFolderButtonText()
    // already worked out, so it is right BEFORE the crumb is laid out --
    // which is when ICoreNavBar has to add the row up (W10.126).
    [[nodiscard]] int contentWidth() const;

    void kill();
    void setAlive();
    bool isAlive() const;

    ~ICoreNavBarQuickReachButton() override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreNavBarQuickReachButtonContextMenu.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/NavigationBar/ICoreNavBarQuickReachButtonContextMenu.h

⚠⚠ private slots:\n void showContextMenu() const; STOOD HERE UNTIL 2026-08-23 (A9.7), AND IT WAS TWO RULE BREAKS IN ONE LINE.

1. slots is a Qt KEYWORD macro from <QObject>, in src/ICoreBlocks, which

R2.1 requires to include no Qt at all. It compiled only because the macro arrived through an accidental include chain; when A9.7 removed four Qt includes from Text/ICoreRegex.h that chain broke and this file failed with unknown type name 'slots', in a module with no connection to regexes. ⚠ The architecture census could not see it: R2.2 matches Q[A-Z]\w+ and slots is lower-case.

1. Spelling it private: instead then broke the HEADER SURFACE RULE --

a private helper function is not one of the two permitted private lines. The guard was right both times.

ICoreNavBarQuickReachButtonContextMenu#

ICoreNavBarQuickReachButtonContextMenu.h:11 · class · bases public ICoreWidget · pImpl · 2 declaration(s)

class ICoreNavBarQuickReachButtonContextMenu : public ICoreWidget {
public:
    explicit ICoreNavBarQuickReachButtonContextMenu(ICoreWidget* parent = nullptr,
        ICoreStudioSurface* grandparentStudioSurface = nullptr, const std::string& parentTreeNodePath = "ICoreBlocks");

    void populateContextMenu();

    void resetToInitialState(ICoreNativeWidget* parent = nullptr,
                             ICoreStudioSurface* grandparentStudioSurface = nullptr, const std::string& parentTreeNodePath = "ICoreBlocks");

    ~ICoreNavBarQuickReachButtonContextMenu() override;

    // ⚠⚠ `private slots:\n    void showContextMenu() const;` STOOD HERE UNTIL
    // 2026-08-23 (A9.7), AND IT WAS TWO RULE BREAKS IN ONE LINE.
    //
    // 1. `slots` is a Qt KEYWORD macro from <QObject>, in src/ICoreBlocks, which
    //    R2.1 requires to include no Qt at all. It compiled only because the
    //    macro arrived through an accidental include chain; when A9.7 removed
    //    four Qt includes from Text/ICoreRegex.h that chain broke and this file
    //    failed with `unknown type name 'slots'`, in a module with no
    //    connection to regexes. ⚠ **The architecture census could not see it**:
    //    R2.2 matches `Q[A-Z]\w+` and `slots` is lower-case.
    // 2. Spelling it `private:` instead then broke the HEADER SURFACE RULE --
    //    a private helper function is not one of the two permitted private
    //    lines. The guard was right both times.
    //
    // 📌 THE FIX IS THE ONE THE pImpl SHAPE ALREADY PRESCRIBED: the body only
    // ever touched `impl->menu` and `impl->arrowButton`, so it was never the
    // wrapper's method at all. It is `Impl::showContextMenu()` now. Nothing was
    // lost — this class carries no Q_OBJECT, declares no signal and is never
    // connected by name, so moc had never generated anything for it.

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreNavBarQuickReachRootWidget.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/NavigationBar/ICoreNavBarQuickReachRootWidget.h

The crumbs live inside a scroll pane rather than directly in this frame, so a deep path scrolls sideways instead of squeezing every segment. That puts content over most of this widget's own area, which would have cost the bar two behaviours it had when it was one flat surface: a press on the blank part opening the path editor, and the hover fade. Told which pane and which content widget, this class watches them and keeps both -- and turns a vertical wheel over the strip into horizontal travel.

ICoreNavBarQuickReachRootWidget#

ICoreNavBarQuickReachRootWidget.h:14 · class · bases public ICoreWidget · pImpl · 15 declaration(s)

class ICoreNavBarQuickReachRootWidget : public ICoreWidget {
public:
    explicit ICoreNavBarQuickReachRootWidget(ICoreWidget* parent = nullptr, ICoreNavBar* parentNavBar = nullptr);

    double bgOpacity() const;
    void setBgOpacity(double opacity);
    void animateBackgroundOpacity(double targetOpacity);

    // The crumbs live inside a scroll pane rather than directly in this frame,
    // so a deep path scrolls sideways instead of squeezing every segment. That
    // puts `content` over most of this widget's own area, which would have cost
    // the bar two behaviours it had when it was one flat surface: a press on
    // the blank part opening the path editor, and the hover fade. Told which
    // pane and which content widget, this class watches them and keeps both --
    // and turns a vertical wheel over the strip into horizontal travel.
    void attachScrolledContent(ICoreScrollPane* pane, ICoreWidget* content);

    // W10.126, TRIAL. False draws NOTHING at rest -- no body, no rim -- so the
    // strip behind the bar shows through, and fades the body and rim in with
    // the hover progress instead. The owner is looking at it before deciding
    // whether it stays.
    void setChromeVisibleAtRest(bool visible);

    ~ICoreNavBarQuickReachRootWidget() override;

protected:
    void paintContent(ICorePainter& painter) override;
    void pointerEntered() override;
    void pointerLeft() override;
    bool mousePressed(const ICoreMouseEvent& event) override;
    bool wheelScrolled(const ICoreWheelEvent& event) override;
    void watchedPointerPressed(ICoreNativeWidget* watched) override;
    void watchedPointerEntered(ICoreNativeWidget* watched) override;
    void watchedPointerLeft(ICoreNativeWidget* watched) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreProjectMenuButton.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/ProjectMenu/ICoreProjectMenuButton.h

ICoreProjectMenuButton#

ICoreProjectMenuButton.h:36 · class · final · bases public ICoreButton · pImpl · 3 declaration(s)

ICoreProjectMenuButton The project the editor is in, at the head of the top panel's first row, and the drop-down that changes it.

class ICoreProjectMenuButton final : public ICoreButton {
public:
    explicit ICoreProjectMenuButton(ICoreWidget* parent = nullptr);
    ~ICoreProjectMenuButton() override;

protected:
    void paintContent(ICorePainter& painter) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};

ICoreTabHeadersBar.h#

src/ICoreBlocks/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/TabHeadersBar/ICoreTabHeadersBar.h

ICoreTabHeadersBar#

ICoreTabHeadersBar.h:25 · class · bases public ICoreWidget · pImpl · 10 declaration(s)

The strip of tab headers at the top of an editor, and the ONE place that decides where a header sits in it (W10.123).

class ICoreTabHeadersBar : public ICoreWidget {
public:
    explicit ICoreTabHeadersBar(ICoreStudioSurface* parentStudioSurface = nullptr, ICoreWidget* parent = nullptr);

    ICoreStudioSurface* getParentStudioSurface() const;

    // ---- Placement -------------------------------------------------------
    //
    // Puts `header` in front of `before`, or at the end of the headers (just
    // before the "+" button) when `before` is null or not in this bar. A header
    // that is already in a bar -- this one or another window's -- is taken out
    // of it first, so migrating a tab between windows and reordering it inside
    // one window are the same call.
    void insertHeader(ICoreTabHeader* header, const ICoreTabHeader* before = nullptr);

    // Takes `header` out of the strip. A no-op for a header this bar does not
    // hold. The header is not hidden or reparented beyond what the layout does.
    void removeHeader(ICoreTabHeader* header);

    [[nodiscard]] bool holdsHeader(const ICoreTabHeader* header) const;

    // ---- Drop target -----------------------------------------------------
    //
    // Everything here is in DESKTOP space (ICoreWidget::mapToDesktop,
    // ICoreCursor::pos) because the question is asked by a drag that may have
    // started in another window.

    // Whether `desktopPoint` is over this bar, or within `slack` of it -- the
    // margin that lets a tab be dropped without aiming at a 40 px strip.
    [[nodiscard]] bool containsDesktopPoint(const ICorePoint& desktopPoint, double slack = 0.0) const;

    // Lights the bar as the drop target and draws the insertion caret in front
    // of `before` (at the end when null). Cheap to call on every drag tick: it
    // does nothing unless the target actually changed.
    void showDropTarget(const ICoreTabHeader* before);
    void clearDropTarget();

    ~ICoreTabHeadersBar() override;

protected:
    bool wheelScrolled(const ICoreWheelEvent& event) override;

private:
    class Impl;                    // the two-line residue; state lives here
    std::unique_ptr<Impl> impl;
};