Allow special characters in Actor node group names

Relying on the command system's string processing syntax prevents certain names from being used. This converts the AdjustNodeGroup command to be directly invokable, so that arguments can be passed directly, instead of going through the CommandLine string parsing. Signed-off-by: Chris Burel <burelc@amazon.com>
2021-07-20 13:37:58 -07:00
parent 02c16a318e
commit 3a95243df5
6 changed files with 186 additions and 268 deletions
@@ -20,208 +20,147 @@ namespace CommandSystem
    //--------------------------------------------------------------------------------
    // CommandAdjustNodeGroup
    //--------------------------------------------------------------------------------
+    AZ_CLASS_ALLOCATOR_IMPL(CommandAdjustNodeGroup, EMotionFX::CommandAllocator, 0)

-    // constructor
-    CommandAdjustNodeGroup::CommandAdjustNodeGroup(MCore::Command* orgCommand)
-        : MCore::Command("AdjustNodeGroup", orgCommand)
+    CommandAdjustNodeGroup::CommandAdjustNodeGroup(
+        MCore::Command* orgCommand,
+        uint32 actorId,
+        const AZStd::string& name,
+        AZStd::optional<AZStd::string> newName,
+        AZStd::optional<bool> enabledOnDefault,
+        AZStd::optional<AZStd::vector<AZStd::string>> nodeNames,
+        AZStd::optional<NodeAction> nodeAction
+    )
+        : MCore::Command(s_commandName.data(), orgCommand)
+        , EMotionFX::ParameterMixinActorId(actorId)
+        , m_name(name)
+        , m_newName(AZStd::move(newName))
+        , m_enabledOnDefault(enabledOnDefault)
+        , m_nodeNames(AZStd::move(nodeNames))
+        , m_nodeAction(nodeAction)
    {
    }


    // execute
-    bool CommandAdjustNodeGroup::Execute(const MCore::CommandLine& parameters, AZStd::string& outResult)
+    bool CommandAdjustNodeGroup::Execute(const MCore::CommandLine&, AZStd::string& outResult)
    {
-        AZStd::string valueString;
-
-        // get the motion id and the corresponding motion pointer
-        const int32 actorID = parameters.GetValueAsInt("actorID", this);
-        parameters.GetValue("name", this, &valueString);
-
        // get the actor
-        EMotionFX::Actor* actor = EMotionFX::GetActorManager().FindActorByID(actorID);
+        EMotionFX::Actor* actor = EMotionFX::GetActorManager().FindActorByID(m_actorId);
        if (actor == nullptr)
        {
-            outResult = AZStd::string::format("Cannot adjust node group. Actor with id='%i' does not exist.", actorID);
+            outResult = AZStd::string::format("Cannot adjust node group. Actor with id='%i' does not exist.", m_actorId);
            return false;
        }

        // get the node group
-        EMotionFX::NodeGroup* nodeGroup = actor->FindNodeGroupByNameNoCase(valueString.c_str());
+        EMotionFX::NodeGroup* nodeGroup = actor->FindNodeGroupByNameNoCase(m_name.c_str());
        if (nodeGroup == nullptr)
        {
-            outResult = AZStd::string::format("Cannot adjust node group. Node group with name='%s' does not exist.", valueString.c_str());
+            outResult = AZStd::string::format("Cannot adjust node group. Node group with name='%s' does not exist.", m_name.c_str());
            return false;
        }

-        mOldNodeGroup = AZStd::make_unique<EMotionFX::NodeGroup>(*nodeGroup);
+        m_oldNodeGroup = AZStd::make_unique<EMotionFX::NodeGroup>(*nodeGroup);

        // check if newName is set and apply new name
-        if (parameters.CheckIfHasParameter("newName"))
+        if (m_newName.has_value())
        {
-            parameters.GetValue("newName", this, &valueString);
-            nodeGroup->SetName(valueString.c_str());
+            nodeGroup->SetName(*m_newName);
        }

        // check if parameter disabledOnDefault is set and adjust it
-        if (parameters.CheckIfHasParameter("enabledOnDefault"))
+        if (m_enabledOnDefault.has_value())
        {
-            const bool enabledOnDefault = parameters.GetValueAsBool("enabledOnDefault", this);
-            nodeGroup->SetIsEnabledOnDefault(enabledOnDefault);
+            nodeGroup->SetIsEnabledOnDefault(*m_enabledOnDefault);
        }

        // check if parametes nodeNames is set
-        if (parameters.CheckIfHasParameter("nodeNames"))
+        if (m_nodeNames.has_value())
        {
-            // get the node action
-            AZStd::string nodeAction;
-            parameters.GetValue("nodeAction", this, &valueString);
-
-            // get the node names and split the string
-            AZStd::string nodeNameString;
-            parameters.GetValue("nodeNames", this, &nodeNameString);
-
-            // get the individual node names
-            AZStd::vector<AZStd::string> nodeNames;
-            AzFramework::StringFunc::Tokenize(nodeNameString.c_str(), nodeNames, MCore::CharacterConstants::semiColon, true /* keep empty strings */, true /* keep space strings */);
-
-            // get the number of nodes
-            const size_t numNodes = nodeNames.size();
-
-            // remove the selected nodes from the node group
-            if (AzFramework::StringFunc::Equal(valueString.c_str(), "remove", false /* no case */))
+            if (*m_nodeAction == NodeAction::Replace)
            {
-                for (size_t i = 0; i < numNodes; ++i)
-                {
-                    // get the node
-                    EMotionFX::Node* node = actor->GetSkeleton()->FindNodeByName(nodeNames[i].c_str());
-                    if (node == nullptr)
-                    {
-                        continue;
-                    }
-
-                    // remove the node
-                    nodeGroup->RemoveNodeByNodeIndex((uint16)node->GetNodeIndex());
-                }
-            }
-            else if (AzFramework::StringFunc::Equal(valueString.c_str(), "add", false /* no case */)) // add the selected nodes to the node group
-            {
-                for (size_t i = 0; i < numNodes; ++i)
-                {
-                    // get the node
-                    EMotionFX::Node* node = actor->GetSkeleton()->FindNodeByName(nodeNames[i].c_str());
-                    if (node == nullptr)
-                    {
-                        continue;
-                    }
-
-                    // add the node
-                    uint16 nodeIndex = (uint16)node->GetNodeIndex();
-                    nodeGroup->RemoveNodeByNodeIndex(nodeIndex);
-                    nodeGroup->AddNode(nodeIndex);
-                }
-            }
-            else // selected nodes form the new node group
-            {
-                // clear previous nodes
                nodeGroup->GetNodeArray().Clear();
-
-                // add all nodes to the group
-                for (size_t i = 0; i < numNodes; ++i)
+            }
+            for (const AZStd::string& nodeName : *m_nodeNames)
+            {
+                EMotionFX::Node* node = actor->GetSkeleton()->FindNodeByName(nodeName);
+                if (!node)
                {
-                    // get the node
-                    EMotionFX::Node* node = actor->GetSkeleton()->FindNodeByName(nodeNames[i].c_str());
+                    continue;
+                }

-                    // check if node exists
-                    if (node == nullptr)
-                    {
-                        continue;
-                    }
-
-                    // add the node
-                    nodeGroup->AddNode((uint16)node->GetNodeIndex());
+                uint16 nodeIndex = (uint16)node->GetNodeIndex();
+                nodeGroup->RemoveNodeByNodeIndex(nodeIndex);
+                if (*m_nodeAction == NodeAction::Add || *m_nodeAction == NodeAction::Replace)
+                {
+                    nodeGroup->AddNode(nodeIndex);
                }
            }
        }

        // save the current dirty flag and tell the actor that something got changed
-        mOldDirtyFlag = actor->GetDirtyFlag();
+        m_oldDirtyFlag = actor->GetDirtyFlag();
        actor->SetDirtyFlag(true);
        return true;
    }


    // undo the command
-    bool CommandAdjustNodeGroup::Undo(const MCore::CommandLine& parameters, AZStd::string& outResult)
+    bool CommandAdjustNodeGroup::Undo(const MCore::CommandLine&, AZStd::string& outResult)
    {
        // return if no information about the previous node group was stored
-        if (!mOldNodeGroup)
+        if (!m_oldNodeGroup)
        {
            return false;
        }

-        // get the motion id and the corresponding motion pointer
-        int32   actorID = parameters.GetValueAsInt("actorID", this);
-
-        // get the name
-        AZStd::string name;
-        if (parameters.CheckIfHasParameter("newName"))
-        {
-            parameters.GetValue("newName", this, &name);
-        }
-        else
-        {
-            parameters.GetValue("name", this, &name);
-        }
-
-        // get the actor
-        EMotionFX::Actor* actor = EMotionFX::GetActorManager().FindActorByID(actorID);
+        EMotionFX::Actor* actor = EMotionFX::GetActorManager().FindActorByID(m_actorId);

        // return error if actor was not found
        if (actor == nullptr)
        {
-            outResult = AZStd::string::format("Cannot adjust node group. Actor with id='%i' does not exist.", actorID);
+            outResult = AZStd::string::format("Cannot adjust node group. Actor with id='%i' does not exist.", m_actorId);
            return false;
        }

-        // get the node group
-        EMotionFX::NodeGroup* nodeGroup = actor->FindNodeGroupByNameNoCase(name.c_str());
+        EMotionFX::NodeGroup* nodeGroup = actor->FindNodeGroupByNameNoCase(m_newName.has_value() ? m_newName->c_str() : m_name.c_str());

-        // return error if node group name is not set
-        if (nodeGroup == nullptr)
+        if (!nodeGroup)
        {
-            outResult = AZStd::string::format("Cannot adjust node group. Node group with name='%s' does not exist.", name.c_str());
+            outResult = AZStd::string::format("Cannot adjust node group. Node group with name='%s' does not exist.", m_newName.has_value() ? m_newName->c_str() : m_name.c_str());
            return false;
        }

        // reset the old values
-        if (parameters.CheckIfHasParameter("enabledOnDefault"))
+        if (m_enabledOnDefault.has_value())
        {
-            nodeGroup->SetIsEnabledOnDefault(mOldNodeGroup->GetIsEnabledOnDefault());
+            nodeGroup->SetIsEnabledOnDefault(m_oldNodeGroup->GetIsEnabledOnDefault());
        }

-        if (parameters.CheckIfHasParameter("newName"))
+        if (m_newName.has_value())
        {
-            nodeGroup->SetName(mOldNodeGroup->GetName());
+            nodeGroup->SetName(m_oldNodeGroup->GetName());
        }

-        if (parameters.CheckIfHasParameter("nodeNames"))
+        if (m_nodeNames.has_value())
        {
            // clear previous nodes
            nodeGroup->GetNodeArray().Clear();
-            const uint32 numNodes = mOldNodeGroup->GetNumNodes();
-            nodeGroup->SetNumNodes(static_cast<uint16>(numNodes));
+            const uint16 numNodes = m_oldNodeGroup->GetNumNodes();
+            nodeGroup->SetNumNodes(numNodes);

            // add all nodes to the group
-            for (uint32 i = 0; i < numNodes; ++i)
+            for (uint16 i = 0; i < numNodes; ++i)
            {
-                nodeGroup->SetNode(static_cast<uint16>(i), mOldNodeGroup->GetNode(static_cast<uint16>(i)));
+                nodeGroup->SetNode(i, m_oldNodeGroup->GetNode(i));
            }
        }

-        mOldNodeGroup = nullptr;
+        m_oldNodeGroup = nullptr;

        // set the dirty flag back to the old value
-        actor->SetDirtyFlag(mOldDirtyFlag);
+        actor->SetDirtyFlag(m_oldDirtyFlag);
        return true;
    }

@@ -230,7 +169,7 @@ namespace CommandSystem
    void CommandAdjustNodeGroup::InitSyntax()
    {
        GetSyntax().ReserveParameters(6);
-        GetSyntax().AddRequiredParameter("actorID",          "The id of the actor the node group belongs to.",               MCore::CommandSyntax::PARAMTYPE_INT);
+        EMotionFX::ParameterMixinActorId::InitSyntax(GetSyntax(), /*isParameterRequired=*/ true);
        GetSyntax().AddRequiredParameter("name",             "The name of the node group to adjust.",                        MCore::CommandSyntax::PARAMTYPE_STRING);
        GetSyntax().AddParameter("newName",          "The new name of the node group.",                              MCore::CommandSyntax::PARAMTYPE_STRING,     "");
        GetSyntax().AddParameter("enabledOnDefault", "The enabled on default flag.",                                 MCore::CommandSyntax::PARAMTYPE_BOOLEAN,    "false");
@@ -239,6 +178,45 @@ namespace CommandSystem
    }


+    bool CommandAdjustNodeGroup::SetCommandParameters(const MCore::CommandLine& parameters)
+    {
+        EMotionFX::ParameterMixinActorId::SetCommandParameters(parameters);
+
+        m_name = parameters.GetValue("name", this);
+        if (parameters.CheckIfHasParameter("newName"))
+        {
+            m_newName = parameters.GetValue("newName", this);
+        }
+        if (parameters.CheckIfHasParameter("enabledOnDefault"))
+        {
+            m_enabledOnDefault = parameters.GetValueAsBool("enabledOnDefault", this);
+        }
+        if (parameters.CheckIfHasParameter("nodeNames"))
+        {
+            m_nodeNames.emplace();
+            AzFramework::StringFunc::Tokenize(parameters.GetValue("nodeNames", this), m_nodeNames.value(), ";", false, true);
+        }
+        if (parameters.CheckIfHasParameter("nodeAction"))
+        {
+            const AZStd::string& nodeActionStr = parameters.GetValue("nodeAction", this);
+            if (nodeActionStr == "add")
+            {
+                m_nodeAction = NodeAction::Add;
+            }
+            else if (nodeActionStr == "remove")
+            {
+                m_nodeAction = NodeAction::Remove;
+            }
+            else if (nodeActionStr == "replace")
+            {
+                m_nodeAction = NodeAction::Replace;
+            }
+        }
+
+        return true;
+    }
+
+
    // get the description
    const char* CommandAdjustNodeGroup::GetDescription() const
    {
@@ -25,12 +25,33 @@ namespace CommandSystem
    // adjust a node group
    class CommandAdjustNodeGroup
        : public MCore::Command
+        , public EMotionFX::ParameterMixinActorId
    {
    public:
-        CommandAdjustNodeGroup(MCore::Command* orgCommand = nullptr);
+        AZ_CLASS_ALLOCATOR_DECL
+
+        enum class NodeAction
+        {
+            Add,
+            Remove,
+            Replace
+        };
+
+        static constexpr inline AZStd::string_view s_commandName = "AdjustNodeGroup";
+
+        CommandAdjustNodeGroup(
+            MCore::Command* orgCommand = nullptr,
+            uint32 actorId = MCORE_INVALIDINDEX32,
+            const AZStd::string& name = {},
+            AZStd::optional<AZStd::string> newName = AZStd::nullopt,
+            AZStd::optional<bool> enabledOnDefault = AZStd::nullopt,
+            AZStd::optional<AZStd::vector<AZStd::string>> nodeNames = AZStd::nullopt,
+            AZStd::optional<NodeAction> nodeAction = AZStd::nullopt
+        );
        bool Execute(const MCore::CommandLine& parameters, AZStd::string& outResult) override;
        bool Undo(const MCore::CommandLine& parameters, AZStd::string& outResult) override;
        void InitSyntax() override;
+        bool SetCommandParameters(const MCore::CommandLine& parameters) override;
        bool GetIsUndoable() const override
        {
            return true;
@@ -45,9 +66,15 @@ namespace CommandSystem
            return new CommandAdjustNodeGroup(this);
        }

-    protected:
-        bool mOldDirtyFlag = false;
-        AZStd::unique_ptr<EMotionFX::NodeGroup> mOldNodeGroup = nullptr;
+    private:
+        AZStd::string m_name;
+        AZStd::optional<AZStd::string> m_newName;
+        AZStd::optional<bool> m_enabledOnDefault;
+        AZStd::optional<AZStd::vector<AZStd::string>> m_nodeNames;
+        AZStd::optional<NodeAction> m_nodeAction;
+
+        bool m_oldDirtyFlag = false;
+        AZStd::unique_ptr<EMotionFX::NodeGroup> m_oldNodeGroup = nullptr;
    };

    // add node group
@@ -112,8 +112,13 @@ namespace EMStudio

        // execute the command
        AZStd::string outResult;
-        AZStd::string command = AZStd::string::format("AdjustNodeGroup -actorID %i -name \"%s\" -newName \"%s\"", mActor->GetID(), mNodeGroupName.c_str(), convertedNewName.c_str());
-        if (GetCommandManager()->ExecuteCommand(command.c_str(), outResult) == false)
+        auto* command = aznew CommandSystem::CommandAdjustNodeGroup(
+            GetCommandManager()->FindCommand(CommandSystem::CommandAdjustNodeGroup::s_commandName),
+            /*actorId=*/ mActor->GetID(),
+            /*name=*/ mNodeGroupName,
+            /*newName=*/ convertedNewName
+        );
+        if (GetCommandManager()->ExecuteCommand(command, outResult) == false)
        {
            AZ_Error("EMotionFX", false, outResult.c_str());
        }
@@ -362,98 +367,6 @@ namespace EMStudio
            mSelectedRow = MCORE_INVALIDINDEX32;
        }
    }
-    /*void NodeGroupManagementWidget::UpdateNodeGroupWidget(QTableWidgetItem* current, QTableWidgetItem* previous)
-    {
-        MCORE_UNUSED(previous);
-
-        // return if no node group widget is set
-        if (mNodeGroupWidget == nullptr)
-            return;
-
-        // set the node group widget to the actual selection
-        mNodeGroupWidget->SetActor( mActor );
-
-        if (current)
-        {
-            // set the current row
-            mSelectedRow = current->row();
-
-            // set the node group
-            NodeGroup* nodeGroup = mActor->FindNodeGroupByName( FromQtString(mNodeGroupsTable->item(current->row(), 1)->text()).c_str() );
-            mNodeGroupWidget->SetNodeGroup( nodeGroup );
-        }
-        else
-        {
-            mNodeGroupWidget->SetNodeGroup( nullptr );
-            mSelectedRow = MCORE_INVALIDINDEX32;
-        }
-    }*/
-
-
-    // called whenever a cell is changed
-    /*void NodeGroupManagementWidget::NodeGroupNamesChanged(const QString& text)
-    {
-        // get the sender widget
-        QWidget* senderWidget = (QWidget*)sender();
-
-        // check for duplicates
-        const int duplicateFound = SearchTableForString( mNodeGroupsTable, text );
-
-        // mark edit field in red, if entry already exists
-        if (duplicateFound >= 0)
-            GetManager()->SetWidgetAsInvalidInput( senderWidget );
-        else
-            senderWidget->setStyleSheet("");
-    }*/
-
-
-    // starts editing
-    /*void NodeGroupManagementWidget::NodeGroupeNameDoubleClicked(QTableWidgetItem* item)
-    {
-        // add new line edit for the selected widget
-        QLineEdit* lineEdit = new QLineEdit( mNodeGroupsTable->item(item->row(), 0)->text() );
-        mNodeGroupsTable->setCellWidget( item->row(), 0, lineEdit );
-
-        // jump into the edit field
-        lineEdit->selectAll();
-        lineEdit->setFocus();
-        mNodeGroupsTable->setCurrentCell( item->row(), 0 );
-
-        // connect slots for edit finishing and text change
-        connect( lineEdit, SIGNAL(editingFinished()), this, SLOT(NodeGroupNameEditingFinished()) );
-        connect( lineEdit, SIGNAL(textChanged(QString)), this, SLOT(NodeGroupNamesChanged(QString)) );
-    }*/
-
-
-    // called when editing is finished
-    /*void NodeGroupManagementWidget::NodeGroupNameEditingFinished()
-    {
-        // get the current item
-        QTableWidgetItem* item = mNodeGroupsTable->currentItem();
-
-        // get the sender widget
-        QLineEdit* senderWidget = (QLineEdit*)sender();
-
-        // return if one of the widgets does not exist
-        if (item == nullptr || senderWidget == nullptr)
-            return;
-
-        // call commands for name change if name does not exist yet
-        if (senderWidget->styleSheet() == "")
-        {
-            // call command for adding a new node group
-            String outResult;
-            String command;
-            command.Format( "AdjustNodeGroup -actorID %i -name \"%s\" -newName \"%s\"", mActor->GetID(), FromQtString(item->text()).c_str(), FromQtString(senderWidget->text()).c_str() );
-            if (EMStudio::GetCommandManager()->ExecuteCommand( command.c_str(), outResult ) == false)
-                LogError( outResult.c_str() );
-        }
-        else
-        {
-            // delete the line edit
-            mNodeGroupsTable->setCellWidget(item->row(), item->column(), nullptr);
-        }
-    }*/


    // function to add a new node group with the specified name
@@ -562,16 +475,20 @@ namespace EMStudio
            if (rowChechbox == senderCheckbox)
            {
                nodeGroupName = mNodeGroupsTable->item(i, 1)->text().toUtf8().data();
+                break;
            }
        }

        // execute the command
        AZStd::string outResult;
-        const AZStd::string command = AZStd::string::format("AdjustNodeGroup -actorID %i -name \"%s\" -enabledOnDefault \"%s\"", 
-            mActor->GetID(), 
-            nodeGroupName.c_str(), 
-            AZStd::to_string(checked).c_str());
-        if (EMStudio::GetCommandManager()->ExecuteCommand(command.c_str(), outResult) == false)
+        auto* command = aznew CommandSystem::CommandAdjustNodeGroup(
+            GetCommandManager()->FindCommand(CommandSystem::CommandAdjustNodeGroup::s_commandName),
+            /*actorId=*/ mActor->GetID(),
+            /*name=*/ nodeGroupName,
+            /*newName=*/ AZStd::nullopt,
+            /*enabledOnDefault=*/ checked
+        );
+        if (EMStudio::GetCommandManager()->ExecuteCommand(command, outResult) == false)
        {
            AZ_Error("EMotionFX", false, outResult.c_str());
        }
@@ -35,7 +35,6 @@ namespace EMStudio
        mNodeTable                  = nullptr;
        mSelectNodesButton          = nullptr;
        mNodeGroup                  = nullptr;
-        mNodeAction                 = "";

        // init the widget
        Init();
@@ -254,11 +253,11 @@ namespace EMStudio
        QWidget* senderWidget = (QWidget*)sender();
        if (senderWidget == mAddNodesButton)
        {
-            mNodeAction = "add";
+            mNodeAction = CommandSystem::CommandAdjustNodeGroup::NodeAction::Add;
        }
        else
        {
-            mNodeAction = "select";
+            mNodeAction = CommandSystem::CommandAdjustNodeGroup::NodeAction::Replace;
        }

        // get the selected actorinstance
@@ -293,46 +292,37 @@ namespace EMStudio
    // remove nodes
    void NodeGroupWidget::RemoveNodesButtonPressed()
    {
-        // generate node list string
-        AZStd::string nodeList;
-        uint32 lowestSelectedRow = MCORE_INVALIDINDEX32;
-        const uint32 numTableRows = mNodeTable->rowCount();
-        for (uint32 i = 0; i < numTableRows; ++i)
-        {
-            // get the current table item
-            QTableWidgetItem* item = mNodeTable->item(i, 0);
-            if (item == nullptr)
-            {
-                continue;
-            }
-
-            // add the item to remove list, if it's selected
-            if (item->isSelected())
-            {
-                nodeList += AZStd::string::format("%s;", item->text().toUtf8().data());
-                if ((uint32)item->row() < lowestSelectedRow)
-                {
-                    lowestSelectedRow = (uint32)item->row();
-                }
-            }
-        }
-
-        // stop here if nothing selected
-        if (nodeList.empty())
+        if (mNodeTable->selectedItems().empty())
        {
            return;
        }

-        // call command for adjusting disable on default flag
+        // generate node list string
+        AZStd::vector<AZStd::string> nodeList;
+        int lowestSelectedRow = AZStd::numeric_limits<int>::max();
+        for (const QTableWidgetItem* item : mNodeTable->selectedItems())
+        {
+            nodeList.emplace_back(FromQtString(item->text()));
+            lowestSelectedRow = AZStd::min(lowestSelectedRow, item->row());
+        }
+
        AZStd::string outResult;
-        AZStd::string command = AZStd::string::format("AdjustNodeGroup -actorID %i -name \"%s\" -nodeAction \"remove\" -nodeNames \"%s\"", mActor->GetID(), mNodeGroup->GetName(), nodeList.c_str());
+        auto* command = aznew CommandSystem::CommandAdjustNodeGroup(
+            GetCommandManager()->FindCommand(CommandSystem::CommandAdjustNodeGroup::s_commandName),
+            /*actorId=*/ mActor->GetID(),
+            /*name=*/ mNodeGroup->GetName(),
+            /*newName=*/ AZStd::nullopt,
+            /*enabledOnDefault=*/ AZStd::nullopt,
+            /*nodeNames=*/ AZStd::move(nodeList),
+            /*nodeAction=*/ CommandSystem::CommandAdjustNodeGroup::NodeAction::Remove
+        );
        if (EMStudio::GetCommandManager()->ExecuteCommand(command, outResult) == false)
        {
            AZ_Error("EMotionFX", false, outResult.c_str());
        }

        // selected the next row
-        if (lowestSelectedRow > ((uint32)mNodeTable->rowCount() - 1))
+        if (lowestSelectedRow > (mNodeTable->rowCount() - 1))
        {
            mNodeTable->selectRow(lowestSelectedRow - 1);
        }
@@ -353,19 +343,23 @@ namespace EMStudio
        }

        // generate node list string
-        AZStd::string nodeList;
-        nodeList.reserve(16448);
-        const uint32 numSelectedNodes = selectionList.GetLength();
-        for (uint32 i = 0; i < numSelectedNodes; ++i)
+        AZStd::vector<AZStd::string> nodeList;
+        const uint32 selectionListSize = selectionList.GetLength();
+        for (uint32 i = 0; i < selectionListSize; ++i)
        {
-            nodeList += selectionList[i].GetNodeName();
-            nodeList += ";";
+            nodeList.emplace_back(selectionList[i].GetNodeName());
        }
-        AzFramework::StringFunc::Strip(nodeList, MCore::CharacterConstants::semiColon, true /* case sensitive */, false /* beginning */, true /* ending */);

-        // call command for adjusting disable on default flag
        AZStd::string outResult;
-        AZStd::string command = AZStd::string::format("AdjustNodeGroup -actorID %i -name \"%s\" -nodeAction \"%s\" -nodeNames \"%s\"", mActor->GetID(), mNodeGroup->GetName(), mNodeAction.c_str(), nodeList.c_str());
+        auto* command = aznew CommandSystem::CommandAdjustNodeGroup(
+            GetCommandManager()->FindCommand(CommandSystem::CommandAdjustNodeGroup::s_commandName),
+            /*actorId=*/ mActor->GetID(),
+            /*name=*/ mNodeGroup->GetName(),
+            /*newName=*/ AZStd::nullopt,
+            /*enabledOnDefault=*/ AZStd::nullopt,
+            /*nodeNames=*/ AZStd::move(nodeList),
+            /*nodeAction=*/ mNodeAction
+        );
        if (EMStudio::GetCommandManager()->ExecuteCommand(command, outResult) == false)
        {
            AZ_Error("EMotionFX", false, outResult.c_str());
@@ -13,6 +13,7 @@
 #include <MysticQt/Source/DialogStack.h>
 #include "../../../../EMStudioSDK/Source/DockWidgetPlugin.h"
 #include "../../../../EMStudioSDK/Source/NodeSelectionWindow.h"
+#include <EMotionFX/CommandSystem/Source/NodeGroupCommands.h>
 #endif

 QT_FORWARD_DECLARE_CLASS(QLineEdit)
@@ -58,7 +59,7 @@ namespace EMStudio
        CommandSystem::SelectionList    mNodeSelectionList;
        EMotionFX::NodeGroup*           mNodeGroup;
        uint16                          mNodeGroupIndex;
-        AZStd::string                   mNodeAction;
+        CommandSystem::CommandAdjustNodeGroup::NodeAction mNodeAction;

        // widgets
        QTableWidget*                   mNodeTable;
@@ -11,6 +11,7 @@
 #include "../../../../EMStudioSDK/Source/EMStudioCore.h"
 #include <MCore/Source/LogManager.h>
 #include <EMotionFX/CommandSystem/Source/CommandManager.h>
+#include <EMotionFX/CommandSystem/Source/NodeGroupCommands.h>
 #include "../../../../EMStudioSDK/Source/EMStudioManager.h"

 // include qt headers
@@ -99,7 +100,7 @@ namespace EMStudio
        GetCommandManager()->RegisterCommandCallback("Select", mSelectCallback);
        GetCommandManager()->RegisterCommandCallback("Unselect", mUnselectCallback);
        GetCommandManager()->RegisterCommandCallback("ClearSelection", mClearSelectionCallback);
-        GetCommandManager()->RegisterCommandCallback("AdjustNodeGroup", mAdjustNodeGroupCallback);
+        GetCommandManager()->RegisterCommandCallback(CommandSystem::CommandAdjustNodeGroup::s_commandName.data(), mAdjustNodeGroupCallback);
        GetCommandManager()->RegisterCommandCallback("AddNodeGroup", mAddNodeGroupCallback);
        GetCommandManager()->RegisterCommandCallback("RemoveNodeGroup", mRemoveNodeGroupCallback);