StateEditorController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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 <http://www.gnu.org/licenses/>.
 *
 * @package
 * @author
 * @date
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
#include "StateEditorController.h"
 
#include <QMenu>
#include <QMessageBox>
 
#include <ArmarXGui/gui-plugins/StatechartEditorPlugin/view/dialogs/SetSupportPointDialog.h>
#include <ArmarXGui/gui-plugins/StatechartViewerPlugin/view/StateItem.h>
#include <ArmarXGui/gui-plugins/StatechartViewerPlugin/view/StateTabWidget.h>
#include <ArmarXGui/gui-plugins/StatechartViewerPlugin/view/TransitionItem.h>
 
#include "../StatechartViewerPlugin/model/stateinstance/DynamicRemoteState.h"
#include "../StatechartViewerPlugin/model/stateinstance/RemoteState.h"
#include "../StatechartViewerPlugin/view/StatechartView.h"
#include "StateTreeController.h"
#include "view/dialogs/StateDialog.h"
#include "view/dialogs/TransitionDialog.h"
 
namespace armarx
{
 
    StateEditorController::StateEditorController(StatechartEditorMainWindow* mainWindow,
                                                 StateTreeControllerPtr treeController,
                                                 Ice::CommunicatorPtr communicator,
                                                 VariantInfoPtr variantInfo,
                                                 StatechartProfilePtr currentProfile,
                                                 QPointer<TipDialog> tipDialog,
                                                 QObject* parent) :
        QObject(parent),
        mainWindow(mainWindow),
        treeController(treeController),
        communicator(communicator),
        variantInfo(variantInfo),
        currentProfile(currentProfile),
        tipDialog(tipDialog)
    {
        if (mainWindow)
        {
            connect(mainWindow->getStateTabWidget(),
                    SIGNAL(currentChanged(int)),
                    this,
                    SLOT(connectToStateTab(int)));
        }
        else
        {
            ARMARX_ERROR_S << "mainwindow ptr must not be NULL";
        }
 
        editState = menu.addAction(QIcon(":/icons/accessories-text-editor-6.ico"), "");
        deleteState = menu.addAction(QIcon(":/icons/delete.ico"), "Delete State");
        layoutState = menu.addAction(QIcon(":/icons/magic-wand-icon.png"), "Layout State");
        setstartstate = menu.addAction("Set as initial State");
 
        newEndstate =
            menu.addAction(QIcon(":/statechart-editor/new-endstate.svg"), "Insert new Endstate");
        replaceState = menu.addAction("Replace State");
        openCode = menu.addAction(QIcon(":/icons/cpp.svg"), "Open C++ Code");
        findStateInTree = menu.addAction(QIcon(":/icons/search.svg"), "Find State in Tree");
        for (QAction* a : menu.actions())
        {
            a->setIconVisibleInMenu(true);
        }
        connect(mainWindow->ui->actionEdit_State_Properties,
                SIGNAL(triggered(bool)),
                this,
                SLOT(editSelectedState()));
    }
 
    void
    StateEditorController::stateDialogAccepted(statechartmodel::StateInstancePtr stateInstance,
                                               const StateDialog& d)
    {
        statechartmodel::StatePtr state = stateInstance->getStateClass();
 
        if (stateInstance->getParent())
        {
            stateInstance->getParent()->renameSubstate(stateInstance->getInstanceName(),
                                                       d.getStateInstanceName());
        }
 
        if (state)
        {
            //                ARMARX_INFO_S << "setting class params";
            //                state->setStateName(d.getStateName());
 
            state->setDescription(d.getDescription());
            state->setOutgoingEvents(d.getOutgoingEvents());
            state->setInputParameters(d.getInputParams());
            state->setLocalParameters(d.getLocalParams());
            state->setOutputParameters(d.getOutputParams());
        }
 
        statechartmodel::RemoteStatePtr remoteState =
            std::dynamic_pointer_cast<statechartmodel::RemoteState>(stateInstance);
 
        if (remoteState)
        {
            remoteState->proxyName = d.getProxyName();
        }
 
        statechartmodel::EndStatePtr endstate =
            std::dynamic_pointer_cast<statechartmodel::EndState>(stateInstance);
 
        if (endstate)
        {
            endstate->setEventName(d.getStateInstanceName());
        }
    }
 
    void
    StateEditorController::showStateContextMenu(statechartmodel::StateInstancePtr stateInstance,
                                                QPoint mouseScreenPos,
                                                QPointF mouseItemPos)
    {
        if (!stateInstance)
        {
            return;
        }
        bool editable = true;
        if (stateInstance && stateInstance->getStateClass() &&
            !stateInstance->getStateClass()->isEditable())
        {
            editable = false;
        }
 
 
        statechartmodel::StatePtr parentState = stateInstance->getParent();
        StateTreeNodePtr node = treeController->getNodeByState(stateInstance->getStateClass());
        editState->setText("Edit State " + stateInstance->getInstanceName());
        deleteState->setEnabled(!!parentState && parentState->isEditable());
        setstartstate->setEnabled(!!parentState && parentState->isEditable());
 
        replaceState->setEnabled(editable);
 
 
        openCode->setEnabled(!(!stateInstance->getStateClass() || (node && !node->getCppExists())));
 
 
        newEndstate->setEnabled(!(stateInstance->getType() == eFinalState ||
                                  stateInstance->getType() == eDynamicRemoteState) &&
                                stateInstance->getStateClass() &&
                                stateInstance->getStateClass()->isEditable());
 
 
        layoutState->setEnabled(!(stateInstance->getType() == eFinalState ||
                                  stateInstance->getType() == eDynamicRemoteState ||
                                  !stateInstance->getStateClass() ||
                                  stateInstance->getStateClass()->getSubstates().size() <= 1));
 
 
        replaceState->setEnabled(false);
 
        QAction* result = menu.exec(mouseScreenPos);
 
        if (result == editState)
        {
            StateDialog d(stateInstance,
                          communicator,
                          variantInfo,
                          currentProfile,
                          lockRemoteStates && stateInstance->getType() == eRemoteState ? true
                                                                                       : false,
                          !editable,
                          tipDialog);
 
            if (d.exec() == QDialog::Accepted)
            {
                stateDialogAccepted(stateInstance, d);
            }
        }
        else if (result == deleteState)
        {
            if (QMessageBox::question(0,
                                      "State deletion",
                                      "Do you really want to delete state '" +
                                          stateInstance->getInstanceName() + "'?",
                                      QMessageBox::Yes,
                                      QMessageBox::No) == QMessageBox::Yes)
            {
                parentState->removeSubstate(stateInstance);
            }
        }
        else if (result == layoutState)
        {
            mainWindow->layoutState();
        }
        else if (result == setstartstate)
        {
            parentState->setStartState(stateInstance);
        }
        else if (result == newEndstate)
        {
            ARMARX_INFO_S << "Inserting endstate";
            statechartmodel::StatePtr state = stateInstance->getStateClass();
            int i = 2;
            const QString newStateNameBase = "MyEndState";
            QString newStateName = newStateNameBase;
 
            while (!state->addEndSubstate(newStateName, newStateName, mouseItemPos))
            {
                newStateName = newStateNameBase + "_" + QString::number(i);
                i++;
            }
        }
        else if (result == openCode && stateInstance->getStateClass())
        {
            StateTreeNodePtr node = treeController->getNodeByState(stateInstance->getStateClass());
            treeController->openStateCPP(node);
        }
        else if (result == findStateInTree && stateInstance->getStateClass())
        {
            treeController->selectNodeByState(stateInstance->getStateClass());
        }
    }
 
    void
    StateEditorController::showTransitionContextMenu(statechartmodel::TransitionCPtr transition,
                                                     statechartmodel::StatePtr state,
                                                     QPoint mouseScreenPos,
                                                     QPointF mouseItemPos)
    {
        ARMARX_DEBUG_S << "pos: " << mouseItemPos;
        QMenu menu;
        QAction* editTransition = menu.addAction("Edit Transition " + transition->eventName);
        QAction* enableTransitionCode =
            menu.addAction("Enable Transition Hook for " + transition->eventName);
        enableTransitionCode->setCheckable(true);
        enableTransitionCode->setChecked(transition->transitionUserCode);
 
        StateTreeNodePtr node = treeController->getNodeByState(state);
 
 
        if (!transition->destinationState || !transition->destinationState->getStateClass() ||
            !node || !node->getCppExists() || !transition->sourceState)
        {
            if (!node->getCppExists())
            {
                enableTransitionCode->setText(enableTransitionCode->text() + " (no parent cpp)");
            }
            else if (!transition->sourceState)
            {
                enableTransitionCode->setText("Transition code unavailable for initial transition");
            }
            else if (transition->destinationState && !transition->destinationState->getStateClass())
            {
                enableTransitionCode->setText(enableTransitionCode->text() +
                                              " (final or unloaded destination state)");
            }
            enableTransitionCode->setEnabled(false);
        }
 
        QAction* detach = menu.addAction("Detach Transition");
        //QAction* insertPoint = menu.addAction("Insert Support Point");
        //insertPoint->setEnabled(false);
 
        if (!transition->sourceState || !transition->destinationState)
        {
            detach->setEnabled(false);
        }
 
        QAction* setSupportPoint{nullptr};
        std::map<QAction*, int> bendMap;
 
        if (transition->sourceState && transition->destinationState)
        {
            menu.addSeparator();
            bendMap.insert(std::make_pair(menu.addAction("Straighten"), 0));
            QMenu* bend = menu.addMenu("Bend");
            bendMap.insert(std::make_pair(bend->addAction("Bend Left 10%"), 10));
            bendMap.insert(std::make_pair(bend->addAction("Bend Left 25%"), 25));
            bendMap.insert(std::make_pair(bend->addAction("Bend Left 50%"), 50));
            bendMap.insert(std::make_pair(bend->addAction("Bend Left 100%"), 100));
            bendMap.insert(std::make_pair(bend->addAction("Bend Right 10%"), -10));
            bendMap.insert(std::make_pair(bend->addAction("Bend Right 25%"), -25));
            bendMap.insert(std::make_pair(bend->addAction("Bend Right 50%"), -50));
            bendMap.insert(std::make_pair(bend->addAction("Bend Right 100%"), -100));
            setSupportPoint = menu.addAction("Set Support Point");
        }
 
        QAction* result = menu.exec(mouseScreenPos);
 
 
        if (result == editTransition)
        {
            if (transition->destinationState &&
                transition->destinationState->getType() != eFinalState &&
                !transition->destinationState->getStateClass())
            {
                QMessageBox::warning(mainWindow,
                                     "Transition Editing Error",
                                     "Transition editing not possible because destination state is "
                                     "not loaded - load statechart group of destination state.");
            }
            else
            {
 
                TransitionDialog d(
                    transition, state, getRelevantProfiles(), communicator, variantInfo);
 
                if (d.exec() == QDialog::Accepted)
                {
                    state->setTransitionMapping(transition,
                                                d.getMappingToNextStateInput(),
                                                d.getMappingToParentStateLocal(),
                                                d.getMappingToParentStateOutput());
                }
            }
        }
        else if (result == detach)
        {
            state->detachTransitionDestination(transition);
        }
        //    else if(result == insertPoint)
        //    {
        //        state->addSupportPoint(transition, mouseItemPos);
        //    }
        else if (bendMap.find(result) != bendMap.end())
        {
            state->bendTransition(transition, 50, bendMap[result]);
        }
        else if (result == setSupportPoint)
        {
            SetSupportPointDialog d;
 
            if (d.exec() == QDialog::Accepted)
            {
                state->bendTransition(transition, d.getU(), d.getV());
            }
        }
        else if (result == enableTransitionCode)
        {
            state->setTransitionUserCodeEnabled(transition, result->isChecked());
            if (result->isChecked())
            {
                tipDialog->showMessage(
                    "Transition functions enable you to execute user code during a transition. "
                    "This is designated for parameter conversion or minor calculations. Do NOT "
                    "execute long running operations in transition functions.\n"
                    "On next saving of the statecharts a pure virtual function will be generated "
                    "in the state of this transition. You need to implement this function. "
                    "Otherwise a compilation error will occur.",
                    "Transition Function",
                    "TransitionFunction");
            }
        }
    }
 
    QList<QString>
    StateEditorController::getRelevantProfiles() const
    {
        if (!currentProfile)
        {
            return QList<QString>();
        }
 
        QList<QString> result{QString::fromUtf8(currentProfile->getName().c_str())};
        auto profile = currentProfile;
 
        while ((profile = profile->getParent()))
        {
            result.push_back(QString::fromUtf8(profile->getName().c_str()));
        }
 
        return result;
    }
 
    void
    StateEditorController::editSelectedState()
    {
        if (mainWindow->getStateTabWidget()->currentStateview() &&
            mainWindow->getStateTabWidget()->currentStateview()->getScene() &&
            mainWindow->getStateTabWidget()
                    ->currentStateview()
                    ->getScene()
                    ->selectedItems()
                    .size() > 0)
        {
            StateItem* item = dynamic_cast<StateItem*>(*mainWindow->getStateTabWidget()
                                                            ->currentStateview()
                                                            ->getScene()
                                                            ->selectedItems()
                                                            .begin());
 
            if (item)
            {
                StateDialog d(item->getStateInstance(),
                              communicator,
                              variantInfo,
                              currentProfile,
                              item->getStateInstance()->getType() == eRemoteState ? true : false,
                              !item->isEditable(),
                              tipDialog);
                if (d.exec() == QDialog::Accepted)
                {
                    stateDialogAccepted(item->getStateInstance(), d);
                }
            }
            else
            {
                TransitionItem* transitionItem =
                    dynamic_cast<TransitionItem*>(*mainWindow->getStateTabWidget()
                                                       ->currentStateview()
                                                       ->getScene()
                                                       ->selectedItems()
                                                       .begin());
                item = dynamic_cast<StateItem*>(transitionItem->parentItem());
                if (transitionItem && item)
                {
                    TransitionDialog d(transitionItem->getTransition(),
                                       item->getStateInstance()->getStateClass(),
                                       getRelevantProfiles(),
                                       communicator,
                                       variantInfo);
                    if (d.exec() == QDialog::Accepted)
                    {
                        item->getStateInstance()->getStateClass()->setTransitionMapping(
                            transitionItem->getTransition(),
                            d.getMappingToNextStateInput(),
                            d.getMappingToParentStateLocal(),
                            d.getMappingToParentStateOutput());
                    }
                }
            }
        }
    }
 
    void
    StateEditorController::setLockRemoteStatesByDefault(bool lock)
    {
        lockRemoteStates = lock;
    }
 
    void
    StateEditorController::connectToStateTab(int index)
    {
        if (index != -1 && mainWindow->getStateTabWidget()->currentStateview() &&
            mainWindow->getStateTabWidget()->currentStateview()->getScene())
        {
            connect(mainWindow->getStateTabWidget()->currentStateview()->getScene(),
                    SIGNAL(stateContextMenuRequested(
                        statechartmodel::StateInstancePtr, QPoint, QPointF)),
                    this,
                    SLOT(showStateContextMenu(statechartmodel::StateInstancePtr, QPoint, QPointF)),
                    Qt::UniqueConnection);
            connect(
                mainWindow->getStateTabWidget()->currentStateview()->getScene(),
                SIGNAL(transitionContextMenuRequested(
                    statechartmodel::TransitionCPtr, statechartmodel::StatePtr, QPoint, QPointF)),
                this,
                SLOT(showTransitionContextMenu(
                    statechartmodel::TransitionCPtr, statechartmodel::StatePtr, QPoint, QPointF)),
                Qt::UniqueConnection);
            connect(mainWindow->ui->actionShow_Subsubstates,
                    SIGNAL(toggled(bool)),
                    mainWindow->getStateTabWidget()->currentStateview(),
                    SLOT(showSubSubstates(bool)));
        }
    }
 
} // namespace armarx