API — ICoreBlocks/ICoreStudio/Commands

The public contract of 19 header(s) under src/ICoreBlocks/ICoreStudio/Commands — 19 class/struct definition(s), 73 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/ICoreBlocks/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/ICoreBlocks/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 · 2 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);

    // Ctrl+Shift+X, as Simulink has it: uncomments the selection when every selected
    // block is already commented out, and comments all of it out otherwise -- so a
    // mixed selection comes out uniform and pressing it again undoes it.
    static void toggleSelectionCommentedOut(ICoreCanvasSelectionModel* selectionModel);

};
};

ICoreBlockRename.h#

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

ICoreBlockRename#

ICoreBlockRename.h:13 · class · 3 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);

    // F2: opens the name of the ONE selected block for typing. False, and nothing
    // opened, when the selection holds no block or more than one, or when that
    // block's name is not showing -- there would be nothing on screen to type into.
    static bool beginRenamingSelection(ICoreCanvasSelectionModel* selectionModel);

};
};

ICoreBlockRotate.h#

src/ICoreBlocks/ICoreStudio/Commands/BlockAppearance/ICoreBlockRotate.h

Turns every selected block by degrees (positive is clockwise on screen, as the rotate handle turns), the way the handle and the recipe's .rotate() commit a rotation: about the block's centre, with its ports re-seated and their links re-planned. One undo step for the whole selection, and none when it holds no block.

ICoreBlockRotate#

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

class ICoreBlockRotate {
public:
    // Turns every selected block by `degrees` (positive is clockwise on screen, as the
    // rotate handle turns), the way the handle and the recipe's `.rotate()` commit a
    // rotation: about the block's centre, with its ports re-seated and their links
    // re-planned. One undo step for the whole selection, and none when it holds no block.
    static void rotateSelection(ICoreCanvasSelectionModel* selectionModel, double degrees);

};
};

ICoreCutCopyPaste.h#

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

ICoreCutCopyPaste#

ICoreCutCopyPaste.h:26 · class · 4 declaration(s)

Edit > Cut, Copy and Paste on a diagram, through the SYSTEM clipboard.

class ICoreCutCopyPaste {
public:
    // Copy, then remove the selection as Delete does -- one undo step.
    static void cutToClipboard(ICoreCanvasSelectionModel* selectionModel);
    // An empty selection leaves the clipboard alone.
    static void copyToClipboard(ICoreCanvasSelectionModel* selectionModel);
    // `newPosOnCanvas` is in SCENE coordinates.
    static void pasteFromClipboard(ICoreSubsystemTreeNode* destination, const ICorePoint& newPosOnCanvas);

    // The same three steps with the clipboard taken out, for a caller that has
    // the content in hand -- and for the suites, because a process with no
    // desktop session (a CI runner, an agent shell) cannot open the system
    // clipboard at all, and every decision here is worth testing without one.
    //
    // The text Copy writes for `selectionModel`; empty for an empty selection.
    static ICoreString selectionAsText(ICoreCanvasSelectionModel* selectionModel);
    // Step 2 then step 3: a recipe becomes objects, anything else a note.
    static void pasteText(ICoreSubsystemTreeNode* destination, const ICorePoint& newPosOnCanvas,
                          const ICoreString& text);
    // Step 1: `picture` becomes an image.
    static void pastePicture(ICoreSubsystemTreeNode* destination, const ICorePoint& newPosOnCanvas,
                             const ICorePixmap& picture);

};
};

ICoreObjectsDuplication.h#

src/ICoreBlocks/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/ICoreBlocks/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/ICoreBlocks/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/ICoreBlocks/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/ICoreBlocks/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/ICoreBlocks/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);
};
};

ICoreAutoReduction.h#

src/ICoreBlocks/ICoreStudio/Commands/ModelReduction/ICoreAutoReduction.h

ICoreAutoReduction#

ICoreAutoReduction.h:28 · class · nested Result · 2 declaration(s)

Finds the reductions a diagram level allows and applies them, so the user does not have to select each pair, trio or loop by hand.

class ICoreAutoReduction {
public:
    struct Result {
        int series = 0;              // reductions applied, by kind
        int parallel = 0;
        int feedback = 0;
        int refused = 0;             // candidates the LAST pass found and could not reduce
        bool stopped = false;        // a reduction was taken back after it had edited the diagram
        std::string lastRefusal;     // why the last of those was refused, if one was
    };

    // One reduction: the first candidate, in the order series, parallel, feedback, that
    // reduces. `selection` may be null (no restriction, nothing to clear).
    static Result reduceOneStep(ICoreSubsystemTreeNode* level, ICoreCanvasSelectionModel* selection);

    // Steps until none is left. Stops early -- and says so -- if a reduction had to be
    // taken back after it had edited the diagram, because the level has then been
    // rebuilt and nothing found before it can be trusted.
    static Result reduceFully(ICoreSubsystemTreeNode* level, ICoreCanvasSelectionModel* selection);
};
};

ICoreFeedbackReduction.h#

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

Reduces a closed loop into a single Control_Systems/Continuous/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/Continuous/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/ICoreBlocks/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/Continuous/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/Continuous/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);
};
};

ICoreReductionVerifier.h#

src/ICoreBlocks/ICoreStudio/Commands/ModelReduction/ICoreReductionVerifier.h

ICoreReductionVerifier#

ICoreReductionVerifier.h:38 · class · pImpl · 9 declaration(s)

Proves a model reduction right before it is allowed to stand.

class ICoreReductionVerifier {
public:
    ICoreReductionVerifier();
    ~ICoreReductionVerifier();
    ICoreReductionVerifier(const ICoreReductionVerifier&) = delete;
    ICoreReductionVerifier& operator=(const ICoreReductionVerifier&) = delete;

    // Reads the region: `blocks` are every block the merged block replaces,
    // `inputPorts` the ports of those blocks that the region's one external input
    // drives, and `outputPort` the region port whose signal the merged block's
    // output takes over. Refreshes each block's configuration first (the step a
    // run's pre-start takes) and snapshots the diagram, so restoreDiagram() can put
    // it back. False -- and nothing edited -- when the region cannot be replaced by
    // one linear block: a signal inside it used outside it, a second external
    // input, a discrete, nonlinear or time-varying block, an unresolvable algebraic
    // loop, or blocks running at different sample times. `outReason` then says
    // which, in words for the user.
    bool captureRegion(const std::vector<ICoreBlock*>& blocks, const std::vector<ICorePort*>& inputPorts,
                       ICorePort* outputPort, std::string& outReason);

    // The state the merged block starts from: the initial states of `order`'s
    // blocks, stacked in that order -- the order the merge formula stacks their
    // states in. Each must be a block captureRegion() read.
    [[nodiscard]] ICoreMatrix stackedInitialState(const std::vector<ICoreBlock*>& order) const;

    // The configured sample time every block in the region shares, as the text to
    // write into the merged block's "Sampling Time (s)"; empty when they all
    // inherit (the merged block's default does too).
    [[nodiscard]] std::string commonSamplingTimeText() const;

    // Checks the merged candidate -- the merge formula's system and the initial
    // state it will be given -- against the region. Passes without comparing when
    // verification is switched off in the preferences.
    bool verifyCandidate(const ICoreStateSpace& merged, const ICoreMatrix& initialState, std::string& outReason) const;

    // Checks the block the reduction built, after it is wired in and the originals
    // are gone: its configuration is loaded, the block is identified from its own
    // simulation functions like the originals were, it must be fed by the region's
    // external source and feed exactly the ports the region's output fed, and its
    // responses must match the region's.
    bool verifyBuiltBlock(ICoreBlock* mergedBlock, std::string& outReason) const;

    // Puts the diagram back as captureRegion() found it, keeping every subsystem's
    // id so per-subsystem undo history still applies. Every block, port and link
    // pointer taken before is stale afterwards. False when the replay failed.
    bool restoreDiagram() const;

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

ICoreSeriesReduction.h#

src/ICoreBlocks/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/Continuous/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/Continuous/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/ICoreBlocks/ICoreStudio/Commands/ModelReduction/ICoreStateSpaceReductionHelpers.h

ICoreStateSpaceReductionHelpers#

ICoreStateSpaceReductionHelpers.h:16 · class · 11 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);

    // Brings `block`'s published continuous state space up to date with its configuration by
    // running its own loadBlockConfig() -- the step a simulation's pre-start takes. Without it a
    // reduction merges whatever the block last published: its construction default on a diagram
    // not run since it was loaded or edited, which is a wrong answer and no error. Refused while a
    // run is live (the worker owns the blocks), and false when the configuration does not load;
    // `outReason` then holds a user-facing explanation. Call before isMergeableSISO.
    static bool refreshStateSpaceFromConfig(ICoreBlock* block, std::string& outReason);

    // Creates a Control_Systems/Continuous/State_Space block at `destination`/`atPosition`
    // configured with `ss`'s A/Bu/C/Du, starting from `initialState` (the merged blocks' own
    // initial states, stacked as the merge stacked their states -- see
    // ICoreReductionVerifier::stackedInitialState). `samplingTimeText` goes into its
    // "Sampling Time (s)" unless it is empty, which keeps the block's inheriting default.
    static ICoreBlock* buildStateSpaceBlock(ICoreSubsystemTreeNode* destination, const ICoreStateSpace& ss,
                                            const ICoreMatrix& initialState, const std::string& samplingTimeText,
                                            const ICorePoint& atPosition);

    // True when `fullType` is a combining-junction block ICoreParallelReduction/
    // ICoreFeedbackReduction know how to fold into a merge: a Sum block, or a Subtract block
    // (which IS a Sum that starts "+ -").
    static bool isCombinerBlockType(const std::string& fullType);

    // The sign `inputPort` contributes with at `combinerBlock` (a Sum or Subtract block, per
    // isCombinerBlockType): -1 when the port's label is "-", +1 otherwise -- the rule the
    // block's own compute_h applies (ICoreBlock_0_Control_Systems_1_Base_Blocks_2_Sum::isNegated).
    // Both blocks let the user retype any sign, so neither type nor position decides it.
    // Assumes inputPort actually belongs to combinerBlock.
    static double combinerInputSign(ICoreBlock* combinerBlock, const ICorePort* inputPort);

    // The last step of every reduction, once the diagram has been edited: the merged block as
    // built must pass ICoreReductionVerifier::verifyBuiltBlock. When it does not, the diagram is
    // put back as the verifier captured it and the user is told why under `notificationTitle`.
    // True when the merged block stands. Every pointer the caller holds is stale after a false.
    static bool confirmOrTakeBack(const ICoreReductionVerifier& verifier, ICoreBlock* mergedBlock,
                                  const std::string& notificationTitle);

    // ---- Auto reduction (ICoreAutoReduction) drives the three commands many times over.
    // While it is in progress, each command's own notifications are held back -- one
    // attempt per candidate would bury the user in them, so the auto run reports once --
    // and every reduction is VERIFIED whatever the "Verify Reductions" preference says.
    static void setAutoReductionInProgress(const bool& inProgress);
    [[nodiscard]] static bool isAutoReductionInProgress();

    // How every reduction command tells the user it refused, or merged. Held back while an
    // auto reduction is in progress; the refusal is remembered either way.
    static void notifyRefusal(const std::string& notificationTitle, const std::string& message);
    static void notifySuccess(const std::string& notificationTitle, const std::string& message);

    // The outcome of the reductions since clearLastOutcome(): the most recent refusal, in
    // the words the notification used, and whether a reduction was TAKEN BACK after it had
    // edited the diagram (confirmOrTakeBack) -- after which every block pointer is stale.
    static void clearLastOutcome();
    [[nodiscard]] static std::string lastRefusal();
    [[nodiscard]] static bool wasReductionTakenBack();

};
};

ICoreObjectsDeletion.h#

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

ICoreObjectsDeletion#

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

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

};
};

ICoreSubsystemCreation.h#

src/ICoreBlocks/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
};
};