API — ICoreSDK/ICoreStudio/Commands

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

ICoreAutoArrange.h#

src/ICoreSDK/ICoreStudio/Commands/AutoArrange/ICoreAutoArrange.h

ICoreAutoArrange#

ICoreAutoArrange.h:13 · class · 1 declaration(s)

Auto-arranges a subsystem's blocks into a clean left-to-right layered diagram.

class ICoreAutoArrange {
public:
    // Re-positions every child block of `treeNode` on its canvas. No-op for a null node or a
    // node with no blocks. Links are re-routed afterwards so the wiring follows the new layout.
    static void arrange(ICoreSubsystemTreeNode* treeNode);
};
};

ICoreBlockComment.h#

src/ICoreSDK/ICoreStudio/Commands/BlockAppearance/ICoreBlockComment.h

Comments out (or uncomments) every selected block. Per-block model state, so it is captured in the recipe and survives undo/redo and a save/reload.

ICoreBlockComment#

ICoreBlockComment.h:6 · class · 1 declaration(s)

class ICoreBlockComment {
public:
    // Comments out (or uncomments) every selected block. Per-block model state, so it is
    // captured in the recipe and survives undo/redo and a save/reload.
    static void setSelectionCommentedOut(ICoreCanvasSelectionModel* selectionModel, bool commentedOut);

};
};

ICoreBlockRename.h#

src/ICoreSDK/ICoreStudio/Commands/BlockAppearance/ICoreBlockRename.h

ICoreBlockRename#

ICoreBlockRename.h:13 · class · 2 declaration(s)

Shows/hides the name labels of the blocks in a canvas selection.

class ICoreBlockRename {
public:
    // Sets every selected block's name label to `visible`. Non-block members of the selection
    // (links, areas, notes, images) are left alone. No-op for a null model or a selection
    // holding no blocks.
    static void setSelectionNameLabelsVisible(ICoreCanvasSelectionModel* selectionModel, bool visible);

    // Flips the selection as a whole rather than block by block: if any selected block still shows
    // its label, all of them are hidden; otherwise all are shown. This leaves a mixed selection
    // uniform, so repeating the command alternates instead of shuffling.
    static void toggleSelectionNameLabels(ICoreCanvasSelectionModel* selectionModel);

};
};

ICoreCutCopyPaste.h#

src/ICoreSDK/ICoreStudio/Commands/ClipboardCommands/ICoreCutCopyPaste.h

ICoreCutCopyPaste#

ICoreCutCopyPaste.h:8 · class · 3 declaration(s)

class ICoreCutCopyPaste {
public:
    static void cutToClipboard(ICoreCanvasSelectionModel* selectionModel);
    static void copyToClipboard(ICoreCanvasSelectionModel* selectionModel);
    static void pasteFromClipboard(ICoreSubsystemTreeNode* destination, const ICorePoint& newPosOnCanvas);

};
};

ICoreObjectsDuplication.h#

src/ICoreSDK/ICoreStudio/Commands/ClipboardCommands/ICoreObjectsDuplication.h

ICoreObjectsDuplication#

ICoreObjectsDuplication.h:15 · class · 1 declaration(s)

class ICoreObjectsDuplication {
public:
    static void duplicateSelectedObjects(ICoreCanvasSelectionModel* selectionModel, ICoreSubsystemTreeNode* destination, const ICorePoint& positionOffset);
};
};

ICoreObjectsMigration.h#

src/ICoreSDK/ICoreStudio/Commands/ClipboardCommands/ICoreObjectsMigration.h

ICoreObjectsMigration#

ICoreObjectsMigration.h:16 · class · 1 declaration(s)

class ICoreObjectsMigration {
public:
    static void migrateSelectedObjects(ICoreCanvasSelectionModel* selectionModel, ICoreSubsystemTreeNode* destination, const ICorePoint& positionOffset);
};
};

ICoreLinkBranchImage.h#

src/ICoreSDK/ICoreStudio/Commands/ClipboardCommands/Objects/ICoreLinkBranchImage.h

ICoreLinkBranchImage#

ICoreLinkBranchImage.h:21 · class · pImpl · 9 declaration(s)

A clipboard snapshot of one link branch.

class ICoreLinkBranchImage {
public:
    explicit ICoreLinkBranchImage(const ICoreLinkBranch* originalBranch);
    void assignImageToLinkBranch(ICoreLinkBranch* branchToAssignImageTo);
    std::string getType();

    void printImage() const;

    void resetToInitialState(const ICoreLinkBranch* newOriginalBranch);
    void kill();
    void setAlive();
    bool isAlive() const;

    ~ICoreLinkBranchImage();

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

ICoreLinkImage.h#

src/ICoreSDK/ICoreStudio/Commands/ClipboardCommands/Objects/ICoreLinkImage.h

ICoreLinkImage#

ICoreLinkImage.h:16 · class · pImpl · 9 declaration(s)

A clipboard snapshot of one link and its whole branch tree.

class ICoreLinkImage {
public:
    explicit ICoreLinkImage(ICoreLink* originalLink);
    void assignImageToLink(ICoreLink* linkToAssignImageTo) const;
    std::string getType();

    void printImage() const;

    void resetToInitialState(ICoreLink* originalLink);
    void kill();
    void setAlive();
    bool isAlive() const;

    ~ICoreLinkImage();

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

ICorePortImage.h#

src/ICoreSDK/ICoreStudio/Commands/ClipboardCommands/Objects/ICorePortImage.h

ICorePortImage#

ICorePortImage.h:14 · class · pImpl · 7 declaration(s)

A clipboard snapshot of one port's presentation state.

class ICorePortImage {
public:
    explicit ICorePortImage(const ICorePort* originalPort);
    void assignImageToPort(ICorePort* portToAssignImageTo) const;
    void resetToInitialState(const ICorePort* originalPort);
    void kill();
    void setAlive();
    bool isAlive() const;
    ~ICorePortImage();

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

ICoreAutoLinkConnector.h#

src/ICoreSDK/ICoreStudio/Commands/ConnectionsManager/ICoreAutoLinkConnector.h

ICorePoint is passed BY VALUE below, so the complete type is required. Relying on include order delivering it happens to work today only because every current includer sees the Geometry header first; don't thin this to a forward declaration.

ICoreAutoLinkConnector#

ICoreAutoLinkConnector.h:15 · class · 8 declaration(s)

class ICoreAutoLinkConnector {
public:
    static ICoreLink* generateLink_Port_Port(ICoreSubsystemTreeNode* treeNode, const std::string& linkType, ICorePort* tailPort, ICorePort* headPort);
    static ICoreLink* generateLink_Port_Null(ICoreSubsystemTreeNode* treeNode, const std::string& linkType, ICorePort* tailPort, ICorePoint headCoordination);
    static ICoreLink* generateLink_Null_Port(ICoreSubsystemTreeNode* treeNode, const std::string& linkType, ICorePoint tailCoordination, ICorePort* headPort);
    static ICoreLink* generateLink_Null_Null(ICoreSubsystemTreeNode* treeNode, const std::string& linkType, ICorePoint tailCoordination, ICorePoint headCoordination);

    static ICoreLinkBranch* generateLinkBranch_Link_Null_FromTailCoords(ICoreLink* link, ICorePoint tailCoordination, ICorePoint headCoordination);
    static ICoreLinkBranch* generateLinkBranch_Link_Port_FromTailCoords(ICoreLink* link, ICorePoint tailCoordination, ICorePort* headPort);
    static ICoreLinkBranch* generateLinkBranch_Link_Port(ICoreLink* link, ICorePort* headPort);

    static void mergeLinksInFirst_DeleteSecond(ICoreLinkBranch* firstLinkBranch, ICoreLinkBranch* secondLinkBranch);
};
};

ICoreFeedbackReduction.h#

src/ICoreSDK/ICoreStudio/Commands/ModelReduction/ICoreFeedbackReduction.h

Reduces a closed loop into a single Control_Systems/Continues/State_Space block. The selection is either:

• Two blocks: the plant block G and a plain two-input Sum block, with G's output wired

directly back into one of the Sum's two inputs (an "empty"/unity feedback path — no feedback block in the loop): e = r + y, y = G(e).

• Three blocks: G, a feedback block H, and the Sum block, wired Sum->G->H->Sum: e = r +

H(y), y = G(e). G (and H, if present) must each expose a valid, linear, SISO continuous state space through their ICoreBlockSolverEnvironment (ICoreBlockSolverEnvironment::hasValidStateSpace_cont). The Sum's other input is the external reference (may be unconnected). G's output may drive more than just the loop-closing target — feeding an external consumer (a Scope, say) alongside the feedback path is normal — any such consumers are reconnected onto the merged block's output. The Sum block (and the feedback block, if any) and the internal links between the selected blocks are deleted; the external reference (if any) is reconnected in place onto the merged

ICoreFeedbackReduction#

ICoreFeedbackReduction.h:8 · class · 1 declaration(s)

class ICoreFeedbackReduction {
public:
    // Reduces a closed loop into a single Control_Systems/Continues/State_Space block. The
    // selection is either:
    //   - Two blocks: the plant block G and a plain two-input Sum block, with G's output wired
    //     directly back into one of the Sum's two inputs (an "empty"/unity feedback path — no
    //     feedback block in the loop): e = r + y, y = G(e).
    //   - Three blocks: G, a feedback block H, and the Sum block, wired Sum->G->H->Sum: e = r +
    //     H(y), y = G(e).
    // G (and H, if present) must each expose a valid, linear, SISO continuous state space through
    // their ICoreBlockSolverEnvironment (ICoreBlockSolverEnvironment::hasValidStateSpace_cont). The
    // Sum's other input is the external reference (may be unconnected). G's output may drive more
    // than just the loop-closing target — feeding an external consumer (a Scope, say) alongside the
    // feedback path is normal — any such consumers are reconnected onto the merged block's output.
    // The Sum block (and the feedback block, if any) and the internal links between the selected
    // blocks are deleted; the external reference (if any) is reconnected in place onto the merged
    // block's input, preserving its drawn routing. Returns false and leaves the model untouched if
    // the selection doesn't satisfy these preconditions (including if the closed loop is
    // algebraically unresolvable — see ICoreBlocksMerging::mergeInFeedback/mergeInUnityFeedback).
    static bool reduceFeedbackSelection(ICoreCanvasSelectionModel* selectionModel);
};
};

ICoreParallelReduction.h#

src/ICoreSDK/ICoreStudio/Commands/ModelReduction/ICoreParallelReduction.h

Reduces the three selected blocks — two single-input/single-output blocks connected in parallel (both fed by the same source port, both outputs feeding the third selected block, a plain two-input Sum) — into a single Control_Systems/Continues/State_Space block, provided the two SISO blocks expose a valid, linear, SISO continuous state space through their ICoreBlockSolverEnvironment (ICoreBlockSolverEnvironment::hasValidStateSpace_cont). The Sum block and the two internal links from the blocks into it are deleted; the shared upstream source and whatever the Sum's output drove are reconnected in place onto the merged block (preserving their drawn routing) rather than rebuilt from scratch. Returns false and leaves the model untouched if the selection doesn't satisfy these preconditions.

ICoreParallelReduction#

ICoreParallelReduction.h:8 · class · 1 declaration(s)

class ICoreParallelReduction {
public:
    // Reduces the three selected blocks — two single-input/single-output blocks connected in
    // parallel (both fed by the same source port, both outputs feeding the third selected block,
    // a plain two-input Sum) — into a single Control_Systems/Continues/State_Space block, provided
    // the two SISO blocks expose a valid, linear, SISO continuous state space through their
    // ICoreBlockSolverEnvironment (ICoreBlockSolverEnvironment::hasValidStateSpace_cont). The Sum
    // block and the two internal links from the blocks into it are deleted; the shared upstream
    // source and whatever the Sum's output drove are reconnected in place onto the merged block
    // (preserving their drawn routing) rather than rebuilt from scratch. Returns false and leaves
    // the model untouched if the selection doesn't satisfy these preconditions.
    static bool reduceParallelSelection(ICoreCanvasSelectionModel* selectionModel);
};
};

ICoreSeriesReduction.h#

src/ICoreSDK/ICoreStudio/Commands/ModelReduction/ICoreSeriesReduction.h

Reduces exactly two selected, single-input/single-output blocks connected in series (one's output feeding the other's input directly) into a single Control_Systems/Continues/State_Space block, provided both blocks expose a valid, linear, SISO continuous state space through their ICoreBlockSolverEnvironment (ICoreBlockSolverEnvironment::hasValidStateSpace_cont). The link between the two originals is deleted; whatever fed the first block's input and whatever the second block's output drove are reconnected in place onto the merged block (preserving their drawn routing) rather than rebuilt from scratch. Returns false and leaves the model untouched if the selection doesn't satisfy these preconditions.

ICoreSeriesReduction#

ICoreSeriesReduction.h:7 · class · 1 declaration(s)

class ICoreSeriesReduction {
public:
    // Reduces exactly two selected, single-input/single-output blocks connected in series (one's
    // output feeding the other's input directly) into a single Control_Systems/Continues/State_Space
    // block, provided both blocks expose a valid, linear, SISO continuous state space through their
    // ICoreBlockSolverEnvironment (ICoreBlockSolverEnvironment::hasValidStateSpace_cont). The link
    // between the two originals is deleted; whatever fed the first block's input and whatever the
    // second block's output drove are reconnected in place onto the merged block (preserving their
    // drawn routing) rather than rebuilt from scratch. Returns false and leaves the model untouched
    // if the selection doesn't satisfy these preconditions.
    static bool reduceSeriesSelection(ICoreCanvasSelectionModel* selectionModel);
};
};

ICoreStateSpaceReductionHelpers.h#

src/ICoreSDK/ICoreStudio/Commands/ModelReduction/ICoreStateSpaceReductionHelpers.h

ICoreStateSpaceReductionHelpers#

ICoreStateSpaceReductionHelpers.h:14 · class · 4 declaration(s)

Shared building blocks for the block-diagram reduction commands (ICoreSeriesReduction, ICoreParallelReduction, ...): validating that a block's dynamics can feed ICoreBlocksMerging's series/parallel...

class ICoreStateSpaceReductionHelpers {
public:
    // True when `block` carries a valid, linear (Bf/Df all zero), SISO continuous state space —
    // the only shape ICoreBlocksMerging::mergeInSeries/mergeInParallel are defined for. On false,
    // `outReason` holds a user-facing explanation of which precondition failed.
    static bool isMergeableSISO(const ICoreBlock* block, std::string& outReason);

    // Creates a Control_Systems/Continues/State_Space block at `destination`/`atPosition`
    // configured with `ss`'s A/Bu/C/Du. The block starts at rest (zero initial state) — callers
    // merging existing blocks' own initial conditions into `ss` don't get them carried over.
    static ICoreBlock* buildStateSpaceBlock(ICoreSubsystemTreeNode* destination, const ICoreStateSpace& ss, const ICorePoint& atPosition);

    // True when `fullType` is a combining-junction block ICoreParallelReduction/
    // ICoreFeedbackReduction know how to fold into a merge: the plain (unconditionally additive)
    // Sum block, or the fixed two-input Subtract block.
    static bool isCombinerBlockType(const std::string& fullType);

    // The sign `inputPort` contributes with at `combinerBlock` (a Sum or Subtract block, per
    // isCombinerBlockType): always +1 for Sum, since every input adds regardless of position; for
    // Subtract, +1 for its first input port and -1 for its second (output = in0 - in1). Assumes
    // inputPort actually belongs to combinerBlock.
    static double combinerInputSign(ICoreBlock* combinerBlock, const ICorePort* inputPort);

};
};

ICoreObjectsDeletion.h#

src/ICoreSDK/ICoreStudio/Commands/ObjectsDeletion/ICoreObjectsDeletion.h

ICoreObjectsDeletion#

ICoreObjectsDeletion.h:7 · class · 1 declaration(s)

class ICoreObjectsDeletion {
public:
    static void deleteSelectedCanvasChildren(ICoreCanvasSelectionModel* selectionModel);

};
};

ICoreSubsystemCreation.h#

src/ICoreSDK/ICoreStudio/Commands/Subsystem/ICoreSubsystemCreation.h

The ICorePoint default argument below needs the COMPLETE type, not a forward declaration; without this include the header only parses when the includer happens to have seen the Geometry header first.

ICoreSubsystemCreation#

ICoreSubsystemCreation.h:12 · class · 1 declaration(s)

class ICoreSubsystemCreation {
public:
    static std::pair<bool, ICoreSubsystemTreeNode*> createNewEmptySubsystem(const std::string& parentPath);
    static std::pair<bool, ICoreSubsystemTreeNode*> createNewSubsystemAndMigrateSelection(const std::string& parentPath,
                                ICoreCanvasSelectionModel* selectionModel, ICorePoint subsystemPosIfSelectionModelEmpty = ICorePoint(10000, 10000)); // 10000 is the initial canvas origin
};
};