HapticUnitGuiPlugin.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 "HapticUnitGuiPlugin.h"
 
#include <IceUtil/Time.h>
 
#include <ArmarXCore/core/system/ArmarXDataPath.h>
#include <ArmarXCore/observers/variant/SingleTypeVariantList.h>
#include <ArmarXCore/observers/variant/TimestampVariant.h>
#include <ArmarXCore/util/variants/eigen3/MatrixVariant.h>
 
#include <RobotAPI/gui-plugins/HapticUnitPlugin/ui_HapticUnitConfigDialog.h>
 
#include "HapticUnitConfigDialog.h"
 
 
// Qt headers
#include <QComboBox>
#include <QInputDialog>
#include <QMenu>
#include <QPushButton>
#include <Qt>
#include <QtGlobal>
 
namespace armarx
{
    HapticUnitGuiPlugin::HapticUnitGuiPlugin()
    {
        addWidget<HapticUnitWidget>();
    }
 
    HapticUnitWidget::HapticUnitWidget()
    {
        // init gui
        ui.setupUi(getWidget());
        //ui.stateOpen->setChecked(true);
        hapticObserverProxyName = "HapticUnitObserver";
        hapticUnitProxyName = "WeissHapticUnit";
 
        updateTimer = new QTimer(this);
    }
 
    void
    HapticUnitWidget::onInitComponent()
    {
        usingProxy(hapticObserverProxyName);
        usingProxy(hapticUnitProxyName);
    }
 
    void
    HapticUnitWidget::onConnectComponent()
    {
        hapticObserverProxy = getProxy<ObserverInterfacePrx>(hapticObserverProxyName);
        weissHapticUnit = getProxy<WeissHapticUnitInterfacePrx>(hapticUnitProxyName);
 
        connectSlots();
        createMatrixWidgets();
        updateTimer->start(25); // 50 Hz
    }
 
    void
    HapticUnitWidget::onExitComponent()
    {
        updateTimer->stop();
    }
 
    void
    HapticUnitWidget::onDisconnectComponent()
    {
        updateTimer->stop();
    }
 
    QPointer<QDialog>
    HapticUnitWidget::getConfigDialog(QWidget* parent)
    {
        if (!dialog)
        {
            dialog = new HapticUnitConfigDialog(parent);
        }
 
        return qobject_cast<HapticUnitConfigDialog*>(dialog);
    }
 
    void
    HapticUnitWidget::configured()
    {
    }
 
    void
    HapticUnitWidget::updateData()
    {
 
        for (std::pair<std::string, MatrixDatafieldDisplayWidget*> pair : matrixDisplays)
        {
            //MatrixFloatPtr matrix = VariantPtr::dynamicCast(hapticObserverProxy->getDataField(new DataFieldIdentifier(hapticObserverProxyName, pair.first, "matrix")))->get<MatrixFloat>();
            std::string name = hapticObserverProxy
                                   ->getDataField(new DataFieldIdentifier(
                                       hapticObserverProxyName, pair.first, "name"))
                                   ->getString();
            std::string deviceName = hapticObserverProxy
                                         ->getDataField(new DataFieldIdentifier(
                                             hapticObserverProxyName, pair.first, "device"))
                                         ->getString();
            //float rate = hapticObserverProxy->getDataField(new DataFieldIdentifier(hapticObserverProxyName, pair.first, "rate"))->getFloat();
            TimestampVariantPtr timestamp =
                VariantPtr::dynamicCast(hapticObserverProxy->getDataField(new DataFieldIdentifier(
                                            hapticObserverProxyName, pair.first, "timestamp")))
                    ->get<TimestampVariant>();
            MatrixDatafieldDisplayWidget* matrixDisplay = pair.second;
            matrixDisplay->setInfoOverlay(QString::fromStdString(deviceName) + ": " +
                                          QString::fromStdString(name) + "\n" +
                                          QString::fromStdString(timestamp->toTime().toDateTime()));
            matrixDisplay->invokeUpdate();
        }
    }
 
    void
    HapticUnitWidget::onContextMenu(QPoint point)
    {
        QMenu* contextMenu = new QMenu(getWidget());
        MatrixDatafieldDisplayWidget* matrixDisplay =
            qobject_cast<MatrixDatafieldDisplayWidget*>(sender());
 
        if (!matrixDisplay)
        {
            return;
        }
 
        QAction* setDeviceTag = contextMenu->addAction(tr("Set Device Tag"));
 
        QAction* action = contextMenu->exec(matrixDisplay->mapToGlobal(point));
 
        std::string channelName = channelNameReverseMap.at(matrixDisplay);
        std::string deviceName = deviceNameReverseMap.at(matrixDisplay);
 
        if (action == setDeviceTag)
        {
            std::string tag = hapticObserverProxy
                                  ->getDataField(new DataFieldIdentifier(
                                      hapticObserverProxyName, channelName, "name"))
                                  ->getString();
 
            bool ok;
            QString newTag = QInputDialog::getText(
                getWidget(),
                tr("Set Device Tag"),
                QString::fromStdString("New Tag for Device '" + deviceName + "'"),
                QLineEdit::Normal,
                QString::fromStdString(tag),
                &ok);
 
            if (ok && !newTag.isEmpty())
            {
                ARMARX_IMPORTANT_S << "requesting to set new device tag for " << deviceName << ": "
                                   << newTag.toStdString();
                weissHapticUnit->setDeviceTag(deviceName, newTag.toStdString());
            }
        }
 
        delete contextMenu;
    }
 
    void
    HapticUnitWidget::loadSettings(QSettings* settings)
    {
    }
 
    void
    HapticUnitWidget::saveSettings(QSettings* settings)
    {
    }
 
    void
    HapticUnitWidget::connectSlots()
    {
        connect(this,
                SIGNAL(doUpdateDisplayWidgets()),
                SLOT(updateDisplayWidgets()),
                Qt::QueuedConnection);
        connect(updateTimer, SIGNAL(timeout()), this, SLOT(updateData()));
        connect(ui.checkBoxOffsetFilter,
                SIGNAL(stateChanged(int)),
                this,
                SLOT(onCheckBoxOffsetFilterStateChanged(int)));
    }
 
    void
    HapticUnitWidget::createMatrixWidgets()
    {
        //ARMARX_LOG << "HapticUnitWidget::createMatrixWidgets()";
        emit doUpdateDisplayWidgets();
    }
 
    void
    HapticUnitWidget::updateDisplayWidgets()
    {
        QLayoutItem* child;
 
        while ((child = ui.gridLayoutDisplay->takeAt(0)) != 0)
        {
            delete child;
        }
 
        int i = 0;
        ChannelRegistry channels = hapticObserverProxy->getAvailableChannels(false);
 
        for (std::pair<std::string, ChannelRegistryEntry> pair : channels)
        {
            std::string channelName = pair.first;
            MatrixDatafieldDisplayWidget* matrixDisplay = new MatrixDatafieldDisplayWidget(
                new DatafieldRef(hapticObserverProxy, channelName, "matrix"),
                hapticObserverProxy,
                getWidget());
            matrixDisplay->setRange(0, 4095);
            matrixDisplay->setContextMenuPolicy(Qt::CustomContextMenu);
            connect(matrixDisplay,
                    SIGNAL(customContextMenuRequested(QPoint)),
                    this,
                    SLOT(onContextMenu(QPoint)));
            matrixDisplays.insert(std::make_pair(pair.first, matrixDisplay));
            std::string deviceName = hapticObserverProxy
                                         ->getDataField(new DataFieldIdentifier(
                                             hapticObserverProxyName, channelName, "device"))
                                         ->getString();
            channelNameReverseMap.insert(std::make_pair(matrixDisplay, channelName));
            deviceNameReverseMap.insert(std::make_pair(matrixDisplay, deviceName));
            ui.gridLayoutDisplay->addWidget(matrixDisplay, 0, i);
            i++;
        }
    }
 
    void
    HapticUnitWidget::onCheckBoxOffsetFilterStateChanged(int state)
    {
        //ARMARX_IMPORTANT << "onCheckBoxOffsetFilterToggled: " << state;
        for (std::pair<std::string, MatrixDatafieldDisplayWidget*> pair : matrixDisplays)
        {
            pair.second->enableOffsetFilter(ui.checkBoxOffsetFilter->isChecked());
        }
    }
} // namespace armarx