API — ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels

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

ICoreCopilotFloatingButton.h#

src/ICoreSDK/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/ICoreSDK/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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/LeftFixedPanel/ICoreLeftFixedPanel.h

ICoreLeftFixedPanel#

ICoreLeftFixedPanel.h:60 · class · bases public ICoreWidget · pImpl · 30 declaration(s)

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

    // 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,
    };

    // 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;
    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;

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

ICoreLeftFixedPanelSpacer#

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

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

    ~ICoreLeftFixedPanelSpacer() override;
};
};

ICoreLeftFixedPanelMenuPanel.h#

src/ICoreSDK/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/ICoreSDK/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:33 · 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:44 · 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:58 · 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:69 · 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:86 · 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:97 · 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:108 · 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:125 · 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:136 · 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:147 · 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:158 · 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_RunDiagnosisButton#

ICoreLeftFixedPanelMainMenuButtons.h:169 · 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_TerminalButton#

ICoreLeftFixedPanelMainMenuButtons.h:180 · 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:194 · 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:205 · 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:222 · 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:233 · 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:244 · 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:255 · 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:266 · 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:277 · 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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/MenuPanels/ICoreFixedPanelMenuPanel.h

ICoreFixedPanelMenuPanel#

ICoreFixedPanelMenuPanel.h:34 · class · bases public ICoreWidget · pImpl · 15 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;

    ~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();

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

ICoreFixedPanelMenuPanel_PinButton#

ICoreFixedPanelMenuPanel.h:99 · 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:114 · 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;
};

ICoreDetachedPanelWindow.h#

src/ICoreSDK/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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/RightFixedPanel/MenuPanels/ICoreRightFixedPanelMenuPanel.h

ICoreRightFixedPanelMenuPanel#

ICoreRightFixedPanelMenuPanel.h:18 · class · final · bases public ICoreFixedPanelMenuPanel · pImpl · 8 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;

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

ICoreProgressDash.h#

src/ICoreSDK/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/ICoreSDK/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/ICoreSDK/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 · 10 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;

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

ICoreTimeLineDash.h#

src/ICoreSDK/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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TimeLine/ICoreTimeLineProgressBar.h

ICoreTimeLineProgressBar#

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

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

    void designDashes();

    void setProgressPercentage(const double& progress, const double& timeValue);
    void resetProgress() const;

    void startInfiniteProgressAnimation();
    void stopInfiniteProgressAnimation();

    ~ICoreTimeLineProgressBar() override;

protected:
    void paintContent(ICorePainter& painter) override;

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

ICoreDialogButtonBox.h#

src/ICoreSDK/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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/ICoreTopFixedPanel.h

Framed with the same outline a block carries on the canvas, so the window's chrome and the diagram inside it share one edge.

ICoreTopFixedPanel#

ICoreTopFixedPanel.h:19 · class · bases public ICoreWidget · pImpl · 6 declaration(s)

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

    void updateNavButtonsEnable() const;

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

    ~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;

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

ICoreNavBar.h#

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

ICoreNavBar#

ICoreNavBar.h:16 · class · bases public ICoreWidget · pImpl · 9 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();

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

    ~ICoreNavBar() override;

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

ICoreNavBarLineEdit.h#

src/ICoreSDK/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/ICoreSDK/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 · 7 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);

    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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/NavigationBar/ICoreNavBarQuickReachButtonContextMenu.h

ICoreNavBarQuickReachButtonContextMenu#

ICoreNavBarQuickReachButtonContextMenu.h:11 · class · bases public ICoreWidget · pImpl · 3 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:
    void showContextMenu() const;

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

ICoreNavBarQuickReachRootWidget.h#

src/ICoreSDK/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 · 14 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);

    ~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/ICoreSDK/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/ICoreSDK/ICoreStudio/StudioObjects/StudioSurface/FixedPanels/TopFixedPanel/TabHeadersBar/ICoreTabHeadersBar.h

ICoreTabHeadersBar#

ICoreTabHeadersBar.h:14 · class · bases public ICoreWidget · pImpl · 7 declaration(s)

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

    ICoreHBoxLayout* getTabBarLayout() const;
    ICoreStudioSurface* getParentStudioSurface() const;

    void setReceivingStyle();
    void resetReceivingStyle();

    ~ICoreTabHeadersBar() override;

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

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