diff --git a/CMakeLists.txt b/CMakeLists.txt
index f1fa7797f..4904a6631 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -242,5 +242,17 @@ if(BUILD_CAPI)
dasher_add_test(dasher_deterministic_tests test_deterministic.cpp)
dasher_add_test(dasher_training_tests test_training.cpp)
dasher_add_test(dasher_node_tree_tests test_node_tree.cpp)
+
+ # Control action system tests — needs internal DasherCore classes (ActionRegistry)
+ # AND C API functions, so we compile CAPI.cpp directly and link DasherCore
+ add_executable(dasher_control_action_tests
+ ${CMAKE_CURRENT_LIST_DIR}/tests/test_control_actions.cpp
+ ${CMAKE_CURRENT_LIST_DIR}/src/CAPI.cpp)
+ target_include_directories(dasher_control_action_tests PRIVATE
+ ${CMAKE_CURRENT_LIST_DIR}/src/
+ ${CMAKE_CURRENT_LIST_DIR}/tests/)
+ target_link_libraries(dasher_control_action_tests PRIVATE DasherCore pugixml)
+ target_compile_definitions(dasher_control_action_tests PRIVATE TEST_DATA_DIR="${TEST_DATA_DIR}")
+ add_test(NAME dasher_control_action_tests COMMAND dasher_control_action_tests)
endif()
endif()
diff --git a/Data/control/control.dtd b/Data/control/control.dtd
new file mode 100644
index 000000000..5458f93c6
--- /dev/null
+++ b/Data/control/control.dtd
@@ -0,0 +1,37 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Data/control/control.xml b/Data/control/control.xml
new file mode 100644
index 000000000..1ea2526ac
--- /dev/null
+++ b/Data/control/control.xml
@@ -0,0 +1,218 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ [)
+ std::set allTemplates;
+ if (m_pRoot) {
+ std::deque queue;
+ allTemplates.insert(m_pRoot);
+ queue.push_back(m_pRoot);
+ while (!queue.empty()) {
+ NodeTemplate* head = queue.front();
+ queue.pop_front();
+ for (auto* child : head->successors) {
+ if (child && allTemplates.find(child) == allTemplates.end()) {
+ allTemplates.insert(child);
+ queue.push_back(child);
+ }
+ }
+ }
+ }
+ for (auto* tmpl : allTemplates)
+ delete tmpl;
+}
+
+void CControlManager::registerBuiltinActions() {
+ // Simple actions (no parameters)
+ m_registry.registerFactory("stop", [](const auto&) { return new StopAction(); });
+ m_registry.registerFactory("pause", [](const auto&) { return new PauseAction(); });
+ m_registry.registerFactory("speak_cancel", [](const auto&) { return new SpeakCancelAction(); });
+
+ // Move/delete with dist + forward attributes
+ auto distFactory = [](auto createDist) -> ActionFactory {
+ return [createDist](const std::map& attrs) -> ControlAction* {
+ auto it = attrs.find("dist");
+ if (it == attrs.end()) {
+ it = attrs.find("distance");
+ if (it == attrs.end()) return nullptr;
+ }
+
+ // Parse "dist" value. Old control.xml uses: char, word, sentence, paragraph, page, all
+ // Alphabet XML uses: nextChar, previousChar, nextWord, etc.
+ std::string distStr = it->second;
+ bool forwards = true;
+ EditDistance dist = EDIT_CHAR;
+
+ // Check for "next"/"previous" prefix (alphabet XML style)
+ if (distStr.rfind("next", 0) == 0) {
+ forwards = true;
+ distStr = distStr.substr(4); // remove "next"
+ } else if (distStr.rfind("previous", 0) == 0) {
+ forwards = false;
+ distStr = distStr.substr(8); // remove "previous"
+ } else {
+ // control.xml style: check explicit forward attribute
+ auto fwdIt = attrs.find("forward");
+ if (fwdIt != attrs.end()) forwards = (fwdIt->second == "yes" || fwdIt->second == "true");
+ }
+
+ // Parse distance type
+ if (distStr == "Char" || distStr == "char")
+ dist = EDIT_CHAR;
+ else if (distStr == "Word" || distStr == "word")
+ dist = EDIT_WORD;
+ else if (distStr == "Line" || distStr == "line")
+ dist = EDIT_LINE;
+ else if (distStr == "Sent." || distStr == "Sentence" || distStr == "sentence")
+ dist = EDIT_SENTENCE;
+ else if (distStr == "Para." || distStr == "Paragraph" || distStr == "paragraph")
+ dist = EDIT_PARAGRAPH;
+ else if (distStr == "Page" || distStr == "page")
+ dist = EDIT_PAGE;
+ else if (distStr == "All" || distStr == "all")
+ dist = EDIT_FILE;
+ else
+ return nullptr;
+
+ return createDist(forwards, dist);
+ };
+ };
+
+ m_registry.registerFactory(
+ "move", distFactory([](bool f, EditDistance d) -> ControlAction* { return new MoveAction(f, d); }));
+
+ m_registry.registerFactory(
+ "delete", distFactory([](bool f, EditDistance d) -> ControlAction* { return new DeleteAction(f, d); }));
+
+ // Speak/copy with "what" attribute
+ auto textActionFactory = [](char mode) -> ActionFactory {
+ // mode: 's' = speak, 'c' = copy
+ return [mode](const std::map& attrs) -> ControlAction* {
+ auto it = attrs.find("what");
+ if (it == attrs.end()) it = attrs.find("context");
+
+ if (it == attrs.end()) return nullptr;
+
+ std::string what = it->second;
+
+ if (what == "cancel") return mode == 's' ? static_cast(new SpeakCancelAction()) : nullptr;
+
+ if (what == "new")
+ return mode == 's' ? static_cast(new SpeakAction(TextActionBase::NewText, EDIT_NONE))
+ : static_cast(new CopyAction(TextActionBase::NewText, EDIT_NONE));
+
+ if (what == "repeat")
+ return mode == 's' ? static_cast(new SpeakAction(TextActionBase::Repeat, EDIT_NONE))
+ : static_cast(new CopyAction(TextActionBase::Repeat, EDIT_NONE));
+
+ // Distance-based: all, page, paragraph, sentence, line, word
+ EditDistance dist = EDIT_FILE;
+ if (what == "all")
+ dist = EDIT_FILE;
+ else if (what == "page")
+ dist = EDIT_PAGE;
+ else if (what == "paragraph")
+ dist = EDIT_PARAGRAPH;
+ else if (what == "sentence")
+ dist = EDIT_SENTENCE;
+ else if (what == "line")
+ dist = EDIT_LINE;
+ else if (what == "word")
+ dist = EDIT_WORD;
+ else
+ return nullptr;
+
+ return mode == 's' ? static_cast(new SpeakAction(TextActionBase::Distance, dist))
+ : static_cast(new CopyAction(TextActionBase::Distance, dist));
+ };
+ };
+
+ m_registry.registerFactory("speak", textActionFactory('s'));
+ m_registry.registerFactory("copy", textActionFactory('c'));
+
+ // Alphabet XML action names (for backward compat with existing alphabets)
+ m_registry.registerFactory("textCharAction", [](const auto& attrs) -> ControlAction* {
+ // TextCharAction outputs the symbol text. The text is set later
+ // by AlphIO when it knows the symbol's output text.
+ return nullptr; // handled specially in AlphIO
+ });
+
+ m_registry.registerFactory("stopDasherAction", [](const auto&) -> ControlAction* { return new StopAction(); });
+ m_registry.registerFactory("pauseDasherAction", [](const auto&) -> ControlAction* { return new PauseAction(); });
+ m_registry.registerFactory("stopTTSAction", [](const auto&) -> ControlAction* { return new SpeakCancelAction(); });
+ m_registry.registerFactory("fixedTTSAction", [](const auto& attrs) -> ControlAction* {
+ auto it = attrs.find("text");
+ if (it == attrs.end()) return nullptr;
+ return new FixedSpeakAction(it->second);
+ });
+}
+
+CDasherNode* CControlManager::GetRoot(CDasherNode* pContext, int iOffset) {
+ if (!m_pRoot) return nullptr;
+ return new CContNode(iOffset, getColour(m_pRoot, pContext), m_pRoot, this);
+}
+
+void CControlManager::ChangeScreen(CDasherScreen* pScreen) {
+ if (m_pScreen == pScreen) return;
+ m_pScreen = pScreen;
+
+ // Walk the template graph and create/update labels
+ std::deque templateQueue;
+ if (m_pRoot) templateQueue.push_back(m_pRoot);
+ std::set allTemplates(templateQueue.begin(), templateQueue.end());
+
+ while (!templateQueue.empty()) {
+ NodeTemplate* head = templateQueue.front();
+ templateQueue.pop_front();
+ delete head->m_pLabel;
+ head->m_pLabel = pScreen->MakeLabel(head->m_strLabel);
+ for (auto* child : head->successors) {
+ if (!child) continue;
+ if (allTemplates.find(child) == allTemplates.end()) {
+ allTemplates.insert(child);
+ templateQueue.push_back(child);
+ }
+ }
+ }
+}
+
+int CControlManager::getColour(NodeTemplate* pTemplate, CDasherNode* pParent) {
+ if (pTemplate->m_iColour != -1) return pTemplate->m_iColour;
+ if (pParent) return (pParent->ChildCount() % 99) + 11;
+ return 11;
+}
+
+void CControlManager::updateActions() {
+ m_pRoot->successors.clear();
+ for (auto* pNode : m_parsedNodes)
+ m_pRoot->successors.push_back(pNode);
+
+ if (m_pRoot->successors.empty()) {
+ m_pMsgs->Message("Control box is empty.", false);
+ m_pRoot->successors.push_back(nullptr); //
+ m_pRoot->successors.push_back(m_pRoot); // loop back
+ }
+
+ if (m_pScreen) {
+ CDasherScreen* scr = m_pScreen;
+ m_pScreen = nullptr;
+ ChangeScreen(scr);
+ }
+}
+
+// ── XML parsing ────────────────────────────────────────────────────────────
+
+bool CControlManager::Parse(pugi::xml_document& document, const std::string filePath, bool bUser) {
+ m_parsedNodes.clear();
+
+ std::map namedNodes;
+ std::vector::iterator, std::string>> unresolvedRefs;
+ std::vector nodeStack;
+
+ std::function&)> processElement =
+ [&](pugi::xml_node& xmlNode, std::list& parentSuccessors) {
+ std::string name = xmlNode.name();
+
+ if (name == "node") {
+ std::string label, nodeName;
+ int color = -1;
+ for (pugi::xml_attribute attr : xmlNode.attributes()) {
+ std::string attrName = attr.name();
+ if (attrName == "name")
+ nodeName = attr.value();
+ else if (attrName == "label")
+ label = attr.value();
+ else if (attrName == "color")
+ color = std::atoi(attr.value());
+ }
+
+ auto* n = new NodeTemplate(label, color);
+ parentSuccessors.push_back(n);
+ nodeStack.push_back(n);
+ if (!nodeName.empty()) namedNodes[nodeName] = n;
+
+ for (pugi::xml_node child : xmlNode.children())
+ processElement(child, n->successors);
+
+ nodeStack.pop_back();
+ } else if (name == "ref") {
+ std::string target;
+ for (pugi::xml_attribute attr : xmlNode.attributes()) {
+ if (std::string(attr.name()) == "name") target = attr.value();
+ }
+ auto it = namedNodes.find(target);
+ if (it != namedNodes.end()) {
+ parentSuccessors.push_back(it->second);
+ } else {
+ parentSuccessors.push_back(nullptr);
+ unresolvedRefs.emplace_back(std::prev(parentSuccessors.end()), target);
+ }
+ } else if (name == "alph") {
+ parentSuccessors.push_back(nullptr); // escape
+ } else if (name == "root") {
+ parentSuccessors.push_back(m_pRoot); // loop back to root
+ } else if (m_registry.hasAction(name)) {
+ // Action element — add to current node's action list
+ if (!nodeStack.empty()) {
+ std::map attrs;
+ for (pugi::xml_attribute attr : xmlNode.attributes())
+ attrs[attr.name()] = attr.value();
+
+ ControlAction* action = m_registry.create(name, attrs);
+ if (action) {
+ nodeStack.back()->m_actions.push_back(action);
+ } else {
+ m_pMsgs->Message("Failed to create action: " + name, false);
+ }
+ }
+ }
+ // Unknown elements are silently ignored
+ };
+
+ pugi::xml_node controlElem = document.child("control");
+ if (!controlElem) controlElem = document.root().first_child();
+
+ if (controlElem) {
+ for (pugi::xml_node child : controlElem.children())
+ processElement(child, m_parsedNodes);
+ }
+
+ // Resolve forward references
+ for (auto& ref : unresolvedRefs) {
+ auto target = namedNodes.find(ref.second);
+ if (target != namedNodes.end()) *(ref.first) = target->second;
+ }
+
+ updateActions();
+ return true;
+}
diff --git a/src/DasherCore/ControlManager.h b/src/DasherCore/ControlManager.h
new file mode 100644
index 000000000..fcf430f1e
--- /dev/null
+++ b/src/DasherCore/ControlManager.h
@@ -0,0 +1,386 @@
+// ControlManager.h
+//
+// Unified action system + control node tree for Dasher.
+//
+// This file replaces the old Actions.h / ActionManager.h system with a single,
+// generic, extensible action framework. Both alphabet symbol nodes and control
+// nodes create and execute actions through the same ActionRegistry.
+//
+// Copyright (c) 2007-2024 The Dasher Team
+//
+// This file is part of Dasher. Dasher is free software; you can redistribute
+// it and/or modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the License,
+// or (at your option) any later version.
+
+#pragma once
+
+#include "AbstractXMLParser.h"
+#include "DasherNode.h"
+#include "NodeManager.h"
+#include "Parameters.h"
+#include "SettingsStore.h"
+
+#include
+#include ]
+#include