source/viewer/IpsaDialog.cpp

Go to the documentation of this file.

/*
 *  IpsaDialog.cpp
 *
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 * Copyright (c) 2012, Karlsruhe Institute of Technology (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Created by Manfred Kroehnert on 28.11.2008.
 */

#ifndef USE_SOWIN

#include "../include/IPSA/ipsaclasses.h"
#include "../include/IPSA/IpsaSimulator.h"
#include "../include/IPSA/viewer/IpsaDialog.h"
#include "../include/IPSA/viewer/instructions/NVInstructions.h"

#include <qpushbutton.h>
#include <qlabel.h>
#include <qlineedit.h>
#include <qcombobox.h>
#include <qlayout.h>
#include <qtooltip.h>
#include <qwhatsthis.h>

#include <sstream>


#if IS_QT4
IpsaDialog::IpsaDialog(IpsaSimulator* simulator, QWidget* parent, const char* name, bool modal, Qt::WindowFlags fl)
: QDialog(parent, fl),
#else
IpsaDialog::IpsaDialog(IpsaSimulator* simulator,  QWidget* parent, const char* name, bool modal, WFlags fl )
: QDialog(parent, name, modal, fl),
#endif
ipsaSimulator(simulator),
bodySelectionName(QString("body")),
jointSelectionName(QString("joint"))
{
                if ( !name )
                                setName( "IpsaDialog" );
                this->buildGui();

                commandMap = NVInstructions::CreateInstructionMap(ipsaSimulator);

#if IS_QT4
                modeSelector->addItem( bodySelectionName );
                modeSelector->addItem( jointSelectionName );
#else
                modeSelector->insertItem( bodySelectionName );
                modeSelector->insertItem( jointSelectionName );
#endif

                reloadData();
}


IpsaDialog::~IpsaDialog()
{
                // no need to delete child widgets, Qt does it all for us
}


void IpsaDialog::getSetValue()
{
                Instruction* instr = commandMap[currentCommand.latin1()];
                if (NULL == instr)
                                return;

                // create parameter vector for command
                static std::vector<std::string> commandParameters;
                commandParameters.clear();

    const unsigned int PARAMETER_COUNT = instr->getCommandParameterCount();

                commandParameters.push_back(currentCommand.latin1());
                if (PARAMETER_COUNT > 0)
                                commandParameters.push_back(currentNode.latin1());
                if (PARAMETER_COUNT > 1)
                                commandParameters.push_back(value1->text().latin1());
                if (PARAMETER_COUNT > 2)
                                commandParameters.push_back(value2->text().latin1());
                if (PARAMETER_COUNT > 3)
                                commandParameters.push_back(value3->text().latin1());

                // execute command
                std::ostringstream answer;
                unsigned int numberOfReturnValues;
                instr->findAndExecute(commandParameters, answer, numberOfReturnValues);
                this->evaluateAnswer(answer, numberOfReturnValues);
}


void IpsaDialog::evaluateAnswer(const std::ostringstream& answer, unsigned int numberOfReturnValues)
{
                if (answer.str().empty())
                                return;

                std::vector<float> resultVector(numberOfReturnValues, 0.0f);
                if(convertAnswerToVector(answer.str(), resultVector, numberOfReturnValues))
                                convertAnswerToType<float>(answer.str(), resultVector.at(0));

                QString floatString;
                if (1 <= numberOfReturnValues)
                {
                    floatString.setNum(resultVector.at(0));
                    value1->setText(floatString);
                }
    if (2 <= numberOfReturnValues)
    {
        floatString.setNum(resultVector.at(1));
        value2->setText(floatString);
    }
    if (3 <= numberOfReturnValues)
    {
        floatString.setNum(resultVector.at(2));
        value3->setText(floatString);
    }
}


void IpsaDialog::modeSelected(const QString& mode)
{
                static std::map<std::string, std::string> BodyMap;
                BodyMap.clear();
                nodeList->clear();
                commandList->clear();

                if (mode.contains(bodySelectionName))
                                BodyMap = Instruction::GetAllNodesOfTypeFromViewer<SoPhysics>(ipsaSimulator);
                else
                                BodyMap = Instruction::GetAllNodesOfTypeFromViewer<SoJoint>(ipsaSimulator);

                // create list of nodes
                for (std::map<std::string, std::string>::iterator it = BodyMap.begin(); it != BodyMap.end(); it++)
                {
#if IS_QT4
                                nodeList->addItem( it->first.c_str() );
#else
                                nodeList->insertItem( it->first.c_str() );
#endif
                }

                // create list of commands
                for (std::map<std::string, Instruction*>::iterator it = commandMap.begin(); it != commandMap.end(); it++)
                {
                                if (std::string::npos != it->first.find(mode.latin1()))
                                {
#if IS_QT4
                                                commandList->addItem( it->first.c_str() );
#else
                                                commandList->insertItem( it->first.c_str() );
#endif
                                }
                }

                this->nodeSelected(nodeList->currentText());
                this->commandSelected(commandList->currentText());
}


void IpsaDialog::nodeSelected(const QString& node)
{
                currentNode = node;
}


void IpsaDialog::commandSelected(const QString& command)
{
                currentCommand = command;

                unsigned int parameterCount = commandMap[currentCommand.latin1()]->getCommandParameterCount();
                // enable/disable necessary fields
                value1->setEnabled(1 < parameterCount);
                value2->setEnabled(2 < parameterCount);
                value3->setEnabled(3 < parameterCount);
                // reset field value
                value1->setText("0");
                value2->setText("0");
                value3->setText("0");
}


void IpsaDialog::reloadData()
{
                modeSelected(modeSelector->currentText());
}


void IpsaDialog::buildGui()
{
                setSizeGripEnabled( TRUE );

                QWidget* privateLayoutWidget = new QWidget( this, "Layout5" );
                privateLayoutWidget->setGeometry( QRect( 500, 30, 84, 180 ) );
                Layout5 = new QVBoxLayout( privateLayoutWidget, 0, 6, "Layout5");

                value1label = new QLabel( this, "value1label" );
                value1label->setGeometry( QRect( 40, 70, 90, 21 ) );

                value2lable = new QLabel( this, "value2lable" );
                value2lable->setGeometry( QRect( 40, 100, 90, 21 ) );

                value3label = new QLabel( this, "value3label" );
                value3label->setGeometry( QRect( 40, 130, 90, 21 ) );

                value1 = new QLineEdit( this, "value1" );
                value1->setGeometry( QRect( 165, 70, 160, 20 ) );
                value1->setText("0");

                value2 = new QLineEdit( this, "value2" );
                value2->setGeometry( QRect( 165, 100, 160, 20 ) );
                value2->setText("0");

                value3 = new QLineEdit( this, "value3" );
                value3->setGeometry( QRect( 165, 130, 160, 20 ) );
                value3->setText("0");

                modeSelector = new QComboBox( FALSE, this, "modeSelector" );
                modeSelector->setGeometry( QRect( 40, 30, 100, 21 ) );

                nodeList = new QComboBox( FALSE, this, "nodeList" );
                nodeList->setGeometry( QRect( 160, 30, 330, 21 ) );

                commandList = new QComboBox( FALSE, this, "commandList" );
                commandList->setGeometry( QRect( 350, 70, 140, 20 ) );

                action = new QPushButton( this, "apply" );
                action->setGeometry( QRect( 30, 170, 441, 41 ) );
                languageChange();
                resize( QSize(605, 238).expandedTo(minimumSizeHint()) );

                // signals and slots connections
                connect( action, SIGNAL( clicked() ), this, SLOT( getSetValue() ) );
                connect( modeSelector, SIGNAL( activated(const QString&) ), this, SLOT( modeSelected(const QString&) ) );
                connect( nodeList, SIGNAL( activated(const QString&) ), this, SLOT( nodeSelected(const QString&) ) );
                connect( commandList, SIGNAL( activated(const QString&) ), this, SLOT( commandSelected(const QString&) ) );

                // tab order
                setTabOrder( modeSelector, nodeList );
                setTabOrder( nodeList, value1 );
                setTabOrder( value1, value2 );
                setTabOrder( value2, value3 );
                setTabOrder( value3, action );
                setTabOrder( action, commandList );
}


void IpsaDialog::languageChange()
{
                setCaption( tr( "Get And Set IPSA Values" ) );
                value1label->setText( tr( "X" ) );
                value2lable->setText( tr( "Y" ) );
                value3label->setText( tr( "Z" ) );
                commandList->clear();
                action->setText( tr( "Apply" ) );
}

#endif

---