added commands diagnostic

framework/diagnostics/internal/diagnosticsactions.cpp

@@ -96,6 +96,12 @@ const UiActionList DiagnosticsActions::m_actions = {
              TranslatableString("action", "Show &actions list"),
              TranslatableString("action", "Show actions list")
              ),
+    UiAction("diagnostic-show-rcommands",
+             muse::ui::UiCtxAny,
+             muse::shortcuts::CTX_DISABLED,
+             TranslatableString("action", "Show &rcommands list"),
+             TranslatableString("action", "Show rcommands list")
+             ),
     UiAction("action://diagnostic/actions/query",
              muse::ui::UiCtxAny,
              muse::shortcuts::CTX_DISABLED,

framework/diagnostics/internal/diagnosticsactionscontroller.cpp

@@ -41,6 +41,7 @@ static const muse::UriQuery ENGRAVING_ELEMENTS_URI("musescore://diagnostics/engr
 static const muse::UriQuery ENGRAVING_UNDOSTACK_URI("musescore://diagnostics/engraving/undostack?modal=false&floating=true");
 static const muse::UriQuery ENGRAVING_STYLE_URI("musescore://diagnostics/engraving/style?modal=false&floating=true");
 static const muse::UriQuery ACTIONS_LIST_URI("muse://diagnostics/actions/list?modal=false&floating=true");
+static const muse::UriQuery RCOMMAND_LIST_URI("muse://diagnostics/rcommand/list?modal=false&floating=true");
 
 void DiagnosticsActionsController::init()
 {
@@ -55,6 +56,7 @@ void DiagnosticsActionsController::init()
     dispatcher()->reg(this, "diagnostic-show-engraving-style", [this]() { openUri(ENGRAVING_STYLE_URI, false); });
     dispatcher()->reg(this, "diagnostic-save-diagnostic-files", this, &DiagnosticsActionsController::saveDiagnosticFiles);
     dispatcher()->reg(this, "diagnostic-show-actions", [this]() { openUri(ACTIONS_LIST_URI); });
+    dispatcher()->reg(this, "diagnostic-show-rcommands", [this]() { openUri(RCOMMAND_LIST_URI); });
 
     dispatcher()->reg(this, ActionQuery("action://diagnostic/actions/query"), this, &DiagnosticsActionsController::onActionQuery);
     dispatcher()->reg(this, ActionQuery("action://diagnostic/actions/query_params1"), this, &DiagnosticsActionsController::onActionQuery);

framework/rcommand/CMakeLists.txt

@@ -1,10 +1,7 @@
 # SPDX-License-Identifier: GPL-3.0-only
-# MuseScore-Studio-CLA-applies
+# MuseScore/Audacity CLA applies
 #
-# MuseScore Studio
-# Music Composition & Notation
-#
-# Copyright (C) 2026 MuseScore Limited and others
+# Copyright (C) MuseScore/Audacity and others
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
@@ -24,16 +21,25 @@ target_sources(muse_rcommand PRIVATE
     rcommandmodule.cpp
     rcommandmodule.h
     icommanddispatcher.h
-    imodulecommands.h
+    icommandsregister.h
+    imodulecommandsregister.h
+    icommandsstate.h
+    imodulecommandsstate.h
     commandable.h
     commandtypes.h
 
     internal/commanddispatcher.cpp
     internal/commanddispatcher.h
     internal/commandsregister.cpp
     internal/commandsregister.h
+    internal/commandsstate.cpp
+    internal/commandsstate.h
 )
 
+if (MUSE_MODULE_RCOMMAND_QML)
+    add_subdirectory(qml/Muse/RCommand)
+endif()
+
 #if (MUSE_MODULE_RCOMMAND_TESTS)
 #    add_subdirectory(tests)
 #endif()

framework/rcommand/commandtypes.h

@@ -89,6 +89,27 @@ struct CommandInfo
     Decoration decoration;
 };
 
+struct CommandState {
+    bool enabled = false;
+    bool checked = false;
+
+    CommandState() = default;
+    CommandState(bool enabled, bool checked)
+        : enabled(enabled), checked(checked) {}
+    CommandState(bool enabled)
+        : enabled(enabled), checked(false) {}
+
+    bool operator==(const CommandState& other) const
+    {
+        return enabled == other.enabled && checked == other.checked;
+    }
+
+    bool operator!=(const CommandState& other) const
+    {
+        return !this->operator==(other);
+    }
+};
+
 // Call
 
 using CallId = uint64_t;

framework/rcommand/icommanddispatcher.h

@@ -43,5 +43,10 @@ class ICommandDispatcher : MODULE_CONTEXT_INTERFACE
     {
         return dispatch(make_request(query));
     }
+
+    async::Promise<Response> dispatch(const Command& query)
+    {
+        return dispatch(CommandQuery(query));
+    }
 };
 }

framework/rcommand/icommandsregister.h

@@ -20,7 +20,9 @@
 #pragma once
 
 #include "modularity/imoduleinterface.h"
-#include "imodulecommands.h"
+
+#include "imodulecommandsregister.h"
+#include "commandtypes.h"
 
 namespace muse::rcommand {
 class ICommandsRegister : MODULE_GLOBAL_INTERFACE
@@ -29,9 +31,12 @@ class ICommandsRegister : MODULE_GLOBAL_INTERFACE
 public:
     virtual ~ICommandsRegister() = default;
 
-    virtual void reg(const IModuleCommandsPtr& module) = 0;
-    virtual void unreg(const IModuleCommandsPtr& module) = 0;
+    virtual void reg(const IModuleCommandsRegisterPtr& module) = 0;
+    virtual void unreg(const IModuleCommandsRegisterPtr& module) = 0;
+    virtual IModuleCommandsRegisterPtr moduleRegister(const std::string& moduleName) const = 0;
 
     virtual std::vector<CommandInfo> commandList() const = 0;
+
+    virtual const std::string& commandModuleName(const Command& command) const = 0;
 };
 }

framework/rcommand/icommandsstate.h

@@ -0,0 +1,43 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore/Audacity CLA applies
+ *
+ * Copyright (C) MuseScore/Audacity and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "modularity/imoduleinterface.h"
+
+#include "global/async/channel.h"
+
+#include "imodulecommandsstate.h"
+#include "commandtypes.h"
+
+namespace muse::rcommand {
+class ICommandsState : MODULE_CONTEXT_INTERFACE
+{
+    INTERFACE_ID(ICommandsState);
+
+public:
+    virtual ~ICommandsState() = default;
+
+    virtual void reg(const IModuleCommandsStatePtr& module) = 0;
+    virtual void unreg(const IModuleCommandsStatePtr& module) = 0;
+
+    virtual CommandState commandState(const Command& command) const = 0;
+    virtual async::Channel<Command, CommandState> commandStateChanged() const = 0;
+};
+}

framework/rcommand/imodulecommands.h → framework/rcommand/imodulecommandsregister.h

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#pragma once
+ #pragma once
 
 #include <string>
 #include <vector>
@@ -26,15 +26,17 @@
 #include "commandtypes.h"
 
 namespace muse::rcommand {
-class IModuleCommands
+class IModuleCommandsRegister
 {
 public:
 
-    virtual ~IModuleCommands() = default;
+    virtual ~IModuleCommandsRegister() = default;
 
     virtual std::string moduleName() const = 0;
-    virtual const std::vector<CommandInfo>& commandInfos() const = 0;
+
+    virtual const std::vector<Command>& commandList() const = 0;
+    virtual const std::vector<CommandInfo>& commandInfoList() const = 0;
 };
 
-using IModuleCommandsPtr = std::shared_ptr<IModuleCommands>;
+using IModuleCommandsRegisterPtr = std::shared_ptr<IModuleCommandsRegister>;
 }

framework/rcommand/imodulecommandsstate.h

@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore/Audacity CLA applies
+ *
+ * Copyright (C) MuseScore/Audacity and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include "global/async/channel.h"
+
+#include "commandtypes.h"
+
+namespace muse::rcommand {
+class IModuleCommandsState
+{
+public:
+    virtual ~IModuleCommandsState() = default;
+
+    virtual std::string moduleName() const = 0;
+
+    virtual void init() = 0;
+    virtual void deinit() = 0;
+
+    virtual CommandState commandState(const Command& command) const = 0;
+    virtual async::Channel<Command, CommandState> commandStateChanged() const = 0;
+};
+
+using IModuleCommandsStatePtr = std::shared_ptr<IModuleCommandsState>;
+}

framework/rcommand/internal/commandsregister.cpp

@@ -24,7 +24,7 @@
 using namespace muse;
 using namespace muse::rcommand;
 
-void CommandsRegister::reg(const IModuleCommandsPtr& module)
+void CommandsRegister::reg(const IModuleCommandsRegisterPtr& module)
 {
     IF_ASSERT_FAILED(module) {
         return;
@@ -41,9 +41,13 @@ void CommandsRegister::reg(const IModuleCommandsPtr& module)
     }
 
     m_modules[moduleName] = module;
+
+    for (const auto& info : module->commandInfoList()) {
+        m_commandModuleNames[info.command] = moduleName;
+    }
 }
 
-void CommandsRegister::unreg(const IModuleCommandsPtr& module)
+void CommandsRegister::unreg(const IModuleCommandsRegisterPtr& module)
 {
     IF_ASSERT_FAILED(module) {
         return;
@@ -55,14 +59,39 @@ void CommandsRegister::unreg(const IModuleCommandsPtr& module)
     }
 
     m_modules.erase(moduleName);
+
+    for (const auto& info : module->commandInfoList()) {
+        m_commandModuleNames.erase(info.command);
+    }
+}
+
+IModuleCommandsRegisterPtr CommandsRegister::moduleRegister(const std::string& moduleName) const
+{
+    auto it = m_modules.find(moduleName);
+    if (it != m_modules.end()) {
+        return it->second;
+    }
+
+    return nullptr;
 }
 
 std::vector<CommandInfo> CommandsRegister::commandList() const
 {
     std::vector<CommandInfo> commands;
     for (const auto& module : m_modules) {
-        const auto& infos = module.second->commandInfos();
+        const auto& infos = module.second->commandInfoList();
         commands.insert(commands.end(), infos.begin(), infos.end());
     }
     return commands;
 }
+
+const std::string& CommandsRegister::commandModuleName(const Command& command) const
+{
+    auto it = m_commandModuleNames.find(command);
+    if (it != m_commandModuleNames.end()) {
+        return it->second;
+    }
+
+    static const std::string empty;
+    return empty;
+}

framework/rcommand/internal/commandsregister.h

@@ -29,11 +29,17 @@ class CommandsRegister : public ICommandsRegister
 public:
     CommandsRegister() = default;
 
-    void reg(const IModuleCommandsPtr& module) override;
-    void unreg(const IModuleCommandsPtr& module) override;
+    void reg(const IModuleCommandsRegisterPtr& module) override;
+    void unreg(const IModuleCommandsRegisterPtr& module) override;
+    IModuleCommandsRegisterPtr moduleRegister(const std::string& moduleName) const override;
+
     std::vector<CommandInfo> commandList() const override;
 
+    const std::string& commandModuleName(const Command& command) const override;
+
 private:
-    std::map<std::string, IModuleCommandsPtr> m_modules;
+    std::map<std::string, IModuleCommandsRegisterPtr> m_modules;
+
+    std::map<Command, std::string> m_commandModuleNames;
 };
 }