dashboardRadioButton

📄Description

Selects one of several values with a group of radio buttons.

Module	`nflow_blocks`
Library	Dashboard blocks
Type	`dashboardRadioButton`
Label	Radio Button

Description

The Radio Button block presents a group of mutually exclusive options and writes the value of the selected option to the bound parameter.

Ports

Input(s)

This block declares no input ports.

Output(s)

This block declares no output ports.

Parameters

Parameter	Default value
`LabelPosition`	Top
`Binding`
`ShowInitialText`	on
`ButtonGroupName`	Group
`States`	[{"Value": 0, "Label": "Label1"}, {"Value": 1, "Label": "Label2"}, {"Value": 2, "Label": "Label3"}]
`UseEnumeratedDataType`	off
`EnumeratedDataType`
`Opacity`	1

Inspector Keys

These serialized keys are exposed by the block inspector.

LabelPosition
Binding
ShowInitialText
ButtonGroupName
States
UseEnumeratedDataType
EnumeratedDataType
Opacity

Block Characteristics

Block type	dashboardRadioButton
Family	Dashboard blocks
Rendered size	135 x 115
Phases	none
Direct feedthrough	see Algorithms
Internal state or history	no
Signal data type	double numeric values

Algorithms

The block declares no simulation phases; it is driven by the dashboard, not by the solver.
User interaction writes the selected value to the bound parameter before or during the run.
The block declares no input or output signal ports.

Extended Capabilities

This page describes the native runtime behavior observed in the module C++ sources. Declared phases indicate when the simulation engine calls the block.

Code generation: supported for C and Rust.

Implementation Sources

Manifestmodules/nflow_blocks/libraries/dashboard/library.json

{
  "id": "builtin.dashboard",
  "title": "Dashboard",
  "version": "1.0.0",
  "format": "nflow-2",
  "metadata": {
    "author": "Allan CORNET",
    "created": "2026-08-07",
    "tool": "Nelson nflow"
  },
  "comment": "Interactive controls and signal displays",
  "license": "LGPL-3.0",
  "builtin": true,
  "blocks": [
    {
      "type": "dashboardScope",
      "label": "Dashboard Scope",
      "icon": "dashboardScope.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 230,
      "height": 165,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "TimeSpan": "auto",
        "LegendPosition": "Top",
        "ScaleAtStop": "on",
        "UpdateMode": "Wrap",
        "NormalizeYAxis": "off",
        "TicksPosition": "Outside",
        "TickLabels": "All",
        "Grid": "All",
        "Border": "on",
        "Markers": "off",
        "FontColor": [
          0,
          0,
          0
        ],
        "YLimits": [
          -3,
          3
        ],
        "Colors": []
      },
      "render": {
        "type": "math",
        "formula": "Dashboard Scope"
      }
    },
    {
      "type": "dashboardDisplay",
      "label": "Display",
      "icon": "dashboardDisplay.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 180,
      "height": 40,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "Format": "short",
        "Alignment": "Center",
        "Opacity": "1",
        "Layout": "Preserve dimensions",
        "FormatString": "%d",
        "GridColor": [
          0.502,
          0.502,
          0.502
        ],
        "ShowGrid": "on"
      },
      "render": {
        "type": "math",
        "formula": "Display"
      }
    },
    {
      "type": "dashboardEdit",
      "label": "Edit",
      "icon": "dashboardEdit.svg",
      "phases": [],
      "width": 150,
      "height": 30,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "Alignment": "Center",
        "Opacity": "1"
      },
      "render": {
        "type": "math",
        "formula": "Edit"
      }
    },
    {
      "type": "dashboardGauge",
      "label": "Gauge",
      "icon": "dashboardGauge.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 125,
      "height": 140,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ScaleColors": [],
        "Limits": [
          0,
          -1,
          100
        ],
        "FontColor": [
          0,
          0,
          0
        ],
        "Opacity": "1",
        "ScaleDirection": "Clockwise"
      },
      "render": {
        "type": "math",
        "formula": "Gauge"
      }
    },
    {
      "type": "dashboardHalfGauge",
      "label": "Half Gauge",
      "icon": "dashboardHalfGauge.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 156,
      "height": 108,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ScaleColors": [],
        "Limits": [
          0,
          -1,
          100
        ],
        "FontColor": [
          0,
          0,
          0
        ],
        "Opacity": "1",
        "ScaleDirection": "Clockwise"
      },
      "render": {
        "type": "math",
        "formula": "Half Gauge"
      }
    },
    {
      "type": "dashboardKnob",
      "label": "Knob",
      "icon": "dashboardKnob.svg",
      "phases": [],
      "width": 110,
      "height": 115,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ScaleType": "Linear",
        "Limits": [
          0,
          -1,
          100
        ]
      },
      "render": {
        "type": "math",
        "formula": "Knob"
      }
    },
    {
      "type": "dashboardLamp",
      "label": "Lamp",
      "icon": "dashboardLamp.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 65,
      "height": 60,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "ColorDefault": [
          0.7529411764705882,
          0.7529411764705882,
          0.7529411764705882
        ],
        "StateColors": [
          {
            "Value": 0,
            "Color": [
              0.392156862745098,
              0.8313725490196079,
              0.07450980392156863
            ]
          }
        ],
        "Opacity": "1"
      },
      "render": {
        "type": "math",
        "formula": "Lamp"
      }
    },
    {
      "type": "dashboardLinearGauge",
      "label": "Linear Gauge",
      "icon": "dashboardLinearGauge.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 210,
      "height": 90,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ScaleColors": [],
        "Limits": [
          0,
          -1,
          100
        ],
        "FontColor": [
          0,
          0,
          0
        ],
        "Opacity": "1",
        "ScaleDirection": "Clockwise"
      },
      "render": {
        "type": "math",
        "formula": "Linear Gauge"
      }
    },
    {
      "type": "dashboardMultiStateImage",
      "label": "MultiStateImage",
      "icon": "dashboardMultiStateImage.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 190,
      "height": 180,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "States": [
          {
            "State": 0,
            "Size": [
              0,
              0
            ],
            "Image": "",
            "Thumbnail": ""
          }
        ],
        "DefaultImage": {
          "Size": [
            0,
            0
          ],
          "Image": "",
          "Thumbnail": ""
        },
        "ScaleMode": "Fill with fixed aspect ratio"
      },
      "render": {
        "type": "math",
        "formula": "MultiStateImage"
      }
    },
    {
      "type": "dashboardPushButton",
      "label": "Push Button",
      "icon": "dashboardPushButton.svg",
      "phases": [],
      "width": 91,
      "height": 44,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "ButtonText": "Button",
        "OnValue": "1",
        "Opacity": "1",
        "ButtonType": "Momentary",
        "Icon": "None",
        "CustomIcon": "",
        "IconAlignment": "Left",
        "IconOnColor": [
          0,
          0.392156862745098,
          0
        ],
        "IconOffColor": [
          0,
          1,
          0
        ],
        "IconColor": "Off"
      },
      "render": {
        "type": "math",
        "formula": "Push Button"
      }
    },
    {
      "type": "dashboardQuarterGauge",
      "label": "Quarter Gauge",
      "icon": "dashboardQuarterGauge.svg",
      "phases": [
        "INIT",
        "AFTER_STEP"
      ],
      "width": 140,
      "height": 160,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ScaleColors": [],
        "Limits": [
          0,
          -1,
          100
        ],
        "FontColor": [
          0,
          0,
          0
        ],
        "Opacity": "1",
        "ScaleDirection": "Clockwise"
      },
      "render": {
        "type": "math",
        "formula": "Quarter Gauge"
      }
    },
    {
      "type": "dashboardRadioButton",
      "label": "Radio Button",
      "icon": "dashboardRadioButton.svg",
      "phases": [],
      "width": 135,
      "height": 115,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ButtonGroupName": "Group",
        "States": [
          {
            "Value": 0,
            "Label": "Label1"
          },
          {
            "Value": 1,
            "Label": "Label2"
          },
          {
            "Value": 2,
            "Label": "Label3"
          }
        ],
        "UseEnumeratedDataType": "off",
        "EnumeratedDataType": "",
        "Opacity": "1"
      },
      "render": {
        "type": "math",
        "formula": "Radio Button"
      }
    },
    {
      "type": "dashboardRockerSwitch",
      "label": "Rocker Switch",
      "icon": "dashboardRockerSwitch.svg",
      "phases": [],
      "width": 55,
      "height": 100,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "States": [
          {
            "Value": 0,
            "Label": "Off"
          },
          {
            "Value": 1,
            "Label": "On"
          }
        ]
      },
      "render": {
        "type": "math",
        "formula": "Rocker Switch"
      }
    },
    {
      "type": "dashboardRotarySwitch",
      "label": "Rotary Switch",
      "icon": "dashboardRotarySwitch.svg",
      "phases": [],
      "width": 125,
      "height": 100,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "States": [
          {
            "Value": 0,
            "Label": "Off"
          },
          {
            "Value": 1,
            "Label": "Low"
          },
          {
            "Value": 2,
            "Label": "Medium"
          },
          {
            "Value": 3,
            "Label": "High"
          }
        ],
        "UseEnumeratedDataType": "off",
        "EnumeratedDataType": ""
      },
      "render": {
        "type": "math",
        "formula": "Rotary Switch"
      }
    },
    {
      "type": "dashboardSlider",
      "label": "Slider",
      "icon": "dashboardSlider.svg",
      "phases": [],
      "width": 200,
      "height": 90,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "ScaleType": "Linear",
        "Limits": [
          0,
          -1,
          100
        ]
      },
      "render": {
        "type": "math",
        "formula": "Slider"
      }
    },
    {
      "type": "dashboardSliderSwitch",
      "label": "Slider Switch",
      "icon": "dashboardSliderSwitch.svg",
      "phases": [],
      "width": 120,
      "height": 45,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "States": [
          {
            "Value": 0,
            "Label": "Off"
          },
          {
            "Value": 1,
            "Label": "On"
          }
        ]
      },
      "render": {
        "type": "math",
        "formula": "Slider Switch"
      }
    },
    {
      "type": "dashboardToggleSwitch",
      "label": "Toggle Switch",
      "icon": "dashboardToggleSwitch.svg",
      "phases": [],
      "width": 55,
      "height": 100,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "on",
        "States": [
          {
            "Value": 0,
            "Label": "Off"
          },
          {
            "Value": 1,
            "Label": "On"
          }
        ]
      },
      "render": {
        "type": "math",
        "formula": "Toggle Switch"
      }
    },
    {
      "type": "dashboardCallbackButton",
      "label": "Callback Button",
      "icon": "dashboardCallbackButton.svg",
      "phases": [],
      "width": 110,
      "height": 35,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Top",
        "Binding": null,
        "ShowInitialText": "off",
        "ButtonText": "Callback Button",
        "ButtonType": "Momentary",
        "ClickFcn": "",
        "OnValue": 1,
        "PressDelay": "500",
        "PressFcn": "",
        "RepeatInterval": "0",
        "AutoActivate": true,
        "fixedAspectRatio": "off"
      },
      "render": {
        "type": "math",
        "formula": "Callback Button"
      }
    },
    {
      "type": "dashboardCheckBox",
      "label": "Check Box",
      "icon": "dashboardCheckBox.svg",
      "phases": [],
      "width": 135,
      "height": 30,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "Label": "Label",
        "Values": [
          0,
          1
        ],
        "Opacity": "1"
      },
      "render": {
        "type": "math",
        "formula": "Check Box"
      }
    },
    {
      "type": "dashboardComboBox",
      "label": "Combo Box",
      "icon": "dashboardComboBox.svg",
      "phases": [],
      "width": 160,
      "height": 25,
      "inputs": [],
      "outputs": [],
      "defaultParams": {
        "LabelPosition": "Hide",
        "Binding": null,
        "ShowInitialText": "on",
        "States": [
          {
            "Value": 0,
            "Label": "Label1"
          },
          {
            "Value": 1,
            "Label": "Label2"
          },
          {
            "Value": 2,
            "Label": "Label3"
          }
        ],
        "UseEnumeratedDataType": "off",
        "EnumeratedDataType": "",
        "Opacity": "1"
      },
      "render": {
        "type": "math",
        "formula": "Combo Box"
      }
    }
  ]
}

Runtimemodules/nflow_blocks/src/cpp/DashboardHandlers.cpp

//=============================================================================
// Copyright (c) 2026-present Allan CORNET (Nelson)
//=============================================================================
// This file is part of Nelson.
//=============================================================================
// LICENCE_BLOCK_BEGIN
// SPDX-License-Identifier: LGPL-3.0-or-later
// LICENCE_BLOCK_END
//=============================================================================
#include "BlockRegistry.hpp"
#include "SimEngineTypes.hpp"
#include <algorithm>
//=============================================================================
namespace Nelson::NFlow {
//=============================================================================
static bool
dashboardPath(const nlohmann::json& binding, std::vector<std::string>& path)
{
    path.clear();
    if (!binding.is_object() || !binding.contains("blockPath")) {
        return false;
    }
    const auto& value = binding["blockPath"];
    if (value.is_string()) {
        const std::string id = value.get<std::string>();
        if (!id.empty()) {
            path.push_back(id);
        }
    } else if (value.is_array()) {
        for (const auto& item : value) {
            if (item.is_string() && !item.get<std::string>().empty()) {
                path.push_back(item.get<std::string>());
            }
        }
    }
    return !path.empty();
}
//=============================================================================
static bool
readSubsystemOutput(const BlockState::SubsystemState& subsystem,
    const std::vector<std::string>& path, size_t pathIndex, int port, std::vector<double>& values,
    std::vector<double>& valuesImag, std::vector<long long>& valuesI64, int& exactType)
{
    if (pathIndex >= path.size()) {
        return false;
    }
    auto found = subsystem.nameToId.find(path[pathIndex]);
    if (found == subsystem.nameToId.end()) {
        return false;
    }
    const BlockId nid = found->second;
    if (nid < 0 || nid >= static_cast<BlockId>(subsystem.blocks.size())
        || nid >= static_cast<BlockId>(subsystem.blockStateVec.size())) {
        return false;
    }
    if (pathIndex + 1 < path.size()) {
        const auto& nested = subsystem.blockStateVec[nid].subsystem;
        return nested
            && readSubsystemOutput(
                *nested, path, pathIndex + 1, port, values, valuesImag, valuesI64, exactType);
    }

    const Block& source = subsystem.blocks[nid];
    if (port < 0 || port >= source.outputs) {
        return false;
    }
    int offset = -1;
    int width = 1;
    exactType = static_cast<int>(SigType::Double);
    if (!subsystem.portBase.empty() && nid < static_cast<BlockId>(subsystem.portBase.size())) {
        const int gpi = subsystem.portBase[nid] + port;
        if (gpi >= 0 && gpi < static_cast<int>(subsystem.sigs.size())) {
            const PortSig& sig = subsystem.sigs[gpi];
            offset = sig.offset;
            width = std::max(1, sig.width());
            exactType = static_cast<int>(sig.type);
            if (sig.isComplex && offset >= 0
                && offset + width <= static_cast<int>(subsystem.outputsImagVec.size())) {
                valuesImag.assign(subsystem.outputsImagVec.begin() + offset,
                    subsystem.outputsImagVec.begin() + offset + width);
            }
            if (portUsesI64(sig) && offset >= 0
                && offset + width <= static_cast<int>(subsystem.outputsI64Vec.size())) {
                valuesI64.assign(subsystem.outputsI64Vec.begin() + offset,
                    subsystem.outputsI64Vec.begin() + offset + width);
            }
        }
    }
    if (offset < 0 && nid < static_cast<BlockId>(subsystem.outputBase.size())) {
        offset = subsystem.outputBase[nid] + port;
    }
    if (offset < 0 || offset + width > static_cast<int>(subsystem.outputsVec.size())) {
        return false;
    }
    values.assign(
        subsystem.outputsVec.begin() + offset, subsystem.outputsVec.begin() + offset + width);
    return true;
}
//=============================================================================
static bool
readDashboardSignal(SimCtx& ctx, const nlohmann::json& binding, std::vector<double>& values,
    std::vector<double>& valuesImag, std::vector<long long>& valuesI64, int& exactType)
{
    if (!binding.is_object() || binding.value("kind", std::string()) != "signal") {
        return false;
    }
    std::vector<std::string> path;
    if (!dashboardPath(binding, path)) {
        return false;
    }
    auto found = ctx.nameToId.find(path.front());
    if (found == ctx.nameToId.end()) {
        return false;
    }
    const BlockId nid = found->second;
    const int port = std::max(1, binding.value("outputPortIndex", 1)) - 1;
    if (nid < 0 || nid >= static_cast<BlockId>(ctx.blocks.size())
        || port >= ctx.blocks[nid].outputs) {
        return false;
    }
    if (path.size() > 1) {
        const auto& subsystem = ctx.blockState[nid].subsystem;
        return subsystem
            && readSubsystemOutput(
                *subsystem, path, 1, port, values, valuesImag, valuesI64, exactType);
    }
    const int offset = slotOf(ctx, nid, port);
    const int width = outputWidth(ctx, nid, port);
    if (offset < 0 || width <= 0 || offset + width > static_cast<int>(ctx.outputs.size())) {
        return false;
    }
    values.assign(ctx.outputs.begin() + offset, ctx.outputs.begin() + offset + width);
    const PortSig* signal = portSigOf(ctx, nid, port);
    exactType = static_cast<int>(signal ? signal->type : SigType::Double);
    if (signal && signal->isComplex && ctx.outputsImag
        && offset + width <= static_cast<int>(ctx.outputsImag->size())) {
        valuesImag.assign(
            ctx.outputsImag->begin() + offset, ctx.outputsImag->begin() + offset + width);
    }
    if (signal && portUsesI64(*signal) && ctx.outputsI64
        && offset + width <= static_cast<int>(ctx.outputsI64->size())) {
        valuesI64.assign(
            ctx.outputsI64->begin() + offset, ctx.outputsI64->begin() + offset + width);
    }
    return true;
}
//=============================================================================
static bool
handleDashboardObserver(SimCtx& ctx, const Block& block, Phase phase)
{
    BlockState& state = getState(ctx, block.nid);
    if (phase == Phase::INIT) {
        state.scalar = 0.0;
        state.scalar2 = 0.0;
        state.displayValues.clear();
        state.displayValuesImag.clear();
        state.displayValuesI64.clear();
        state.scopeSeries.clear();
        state.scopeSeriesImag.clear();
        state.scopeSeriesI64.clear();
        state.xSeries.clear();
        state.scopeExactType = static_cast<int>(SigType::Double);
        state.dashboardTouched = false;
        state.dashboardError.clear();
        return false;
    }
    if (phase != Phase::AFTER_STEP) {
        return false;
    }
    const nlohmann::json binding = block.params.value("Binding", nlohmann::json());
    std::vector<double> values;
    std::vector<double> valuesImag;
    std::vector<long long> valuesI64;
    int exactType = static_cast<int>(SigType::Double);
    if (!readDashboardSignal(ctx, binding, values, valuesImag, valuesI64, exactType)) {
        state.scalar2 = 0.0;
        return false;
    }
    state.scalar2 = 1.0;
    state.scopeExactType = exactType;
    state.scalar = values.empty() ? 0.0 : values.front();
    state.displayValues = values;
    state.displayValuesImag = valuesImag;
    state.displayValuesI64 = valuesI64;
    state.dashboardTouched = true;
    if (block.type == "dashboardScope") {
        if (state.scopeSeries.size() != values.size()) {
            state.scopeSeries.assign(values.size(), std::vector<double> {});
        }
        if (!valuesImag.empty() && state.scopeSeriesImag.size() != valuesImag.size()) {
            state.scopeSeriesImag.assign(valuesImag.size(), std::vector<double> {});
        }
        if (!valuesI64.empty() && state.scopeSeriesI64.size() != valuesI64.size()) {
            state.scopeSeriesI64.assign(valuesI64.size(), std::vector<long long> {});
        }
        for (size_t i = 0; i < values.size(); ++i) {
            state.scopeSeries[i].push_back(values[i]);
        }
        for (size_t i = 0; i < valuesImag.size(); ++i) {
            state.scopeSeriesImag[i].push_back(valuesImag[i]);
        }
        for (size_t i = 0; i < valuesI64.size(); ++i) {
            state.scopeSeriesI64[i].push_back(valuesI64[i]);
        }
        state.xSeries.push_back(ctx.t);
    }
    return false;
}
//=============================================================================
static bool
handleDashboardControl(SimCtx&, const Block&, Phase)
{
    return false;
}
//=============================================================================
void
registerDashboardHandlers(BlockRegistry& registry)
{
    const char* observers[] = { "dashboardScope", "dashboardDisplay", "dashboardGauge",
        "dashboardHalfGauge", "dashboardQuarterGauge", "dashboardLinearGauge", "dashboardLamp",
        "dashboardMultiStateImage" };
    for (const char* type : observers) {
        registry.registerHandler(
            type, handleDashboardObserver, { Phase::INIT, Phase::AFTER_STEP }, "builtin.dashboard");
    }

    const char* controls[] = { "dashboardEdit", "dashboardKnob", "dashboardSlider",
        "dashboardPushButton", "dashboardRotarySwitch", "dashboardRadioButton", "dashboardComboBox",
        "dashboardCheckBox", "dashboardRockerSwitch", "dashboardSliderSwitch",
        "dashboardToggleSwitch", "dashboardCallbackButton" };
    BlockMetadata metadata;
    metadata.interactive = true;
    for (const char* type : controls) {
        registry.registerHandler(type, handleDashboardControl, {}, "builtin.dashboard", metadata);
    }
}
//=============================================================================
} // namespace Nelson::NFlow
//=============================================================================