VisualizationView.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_VISUALIZATIONVIEW_H_
#define _MIRA_VISUALIZATIONVIEW_H_

#include <QBasicTimer>

#include <factory/NullClass.h>
#include <utils/Time.h>
#include <serialization/adapters/std/list>
#include <serialization/adapters/Qt/QAction>
#include <rcp/EditorPart.h>

#include <views/GuiViewsExports.h>
#include <fw/TransformProperty.h>
#include <visualization/VisualizationTool.h>

class QMimeData;
class QDragEnterEvent;
class QDropEvent;
class QFocusEvent;
class QBoxLayout;
class QToolBar;
class QToolButton;
class QButtonGroup;

namespace mira {


class Visualization;
class VisualizationTool;
class VisualizationControlPage;

class MIRA_GUI_VIEWS_EXPORT VisualizationView : public EditorPart
{
    Q_OBJECT
    MIRA_ABSTRACT_OBJECT(VisualizationView)

public:

    VisualizationView();
    virtual ~VisualizationView();


public:

    template <typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, EditorPart);
        r.member("Visualizations", mVisualizations, "The assigned visualizations");

        r.property("Update",
                   mUpdateInterval,
                   setter(&VisualizationView::setUpdateInterval,this),
                   "Update interval in ms",
                   40);

        r.property("WindowTitle",
                   getter(&VisualizationView::getWindowTitle,this),
                   setter(&VisualizationView::setWindowTitle,this),
                   "Title of window",
                   getClass().getMetaInfo("Name"));

        r.member("HideTools",
                 getter<bool>(boost::bind(actionGetter, mHideToolBar)),
                 setter<bool>(boost::bind(actionSetter, mHideToolBar, _1)),
                 "Hide tool bar with tools", false);

        r.property("Tools", mTools, "The used tools");
    }
    void reflect(XMLDeserializer& r);
    void reflect(XMLSerializer& r);

public:

    virtual void addVisualization(Visualization* vis);

    virtual void removeVisualization(Visualization* vis);

    virtual void moveUpVisualization(Visualization* vis);

    virtual void moveDownVisualization(Visualization* vis);

    const std::list<Visualization*>& getVisualizations() const;

    virtual void addTool(VisualizationTool* tool);

    const std::vector<VisualizationTool*>& getTools() const;

public:

    VisualizationControlPage* getControl();

public:

    virtual Object* getAdapter(const Class& adapter);

public:

    virtual const Class& supportedVisualizationClass() const = 0;

    virtual const Class& defaultVisualizationClass() const {
        return NullClass::null();
    }

    virtual const Class& supportedVisualizationToolClass() const {
        return NullClass::null();
    }

protected:

    virtual QWidget* createPartControl();

    virtual QWidget* createVisualizationPart() = 0;

    virtual void resetView();
    virtual void saveContentToFile();

protected:
    virtual void update(Duration dt) = 0;

public:

    void setUpdateInterval(int interval);
    int  getUpdateInterval();

public:

    VisualizationTool* getActiveTool() { return mActiveTool; }
    void activateTool(VisualizationTool* tool);

public:

    void setOfferAuxiliaryVisualizations(bool on) {
        mOfferAuxiliaryVisualizations = on;
    }

protected:

    void startUpdateTimer();

    virtual void timerEvent(QTimerEvent*);
    bool eventFilter(QObject *obj, QEvent *event);

    void keyPressEvent(QKeyEvent* event);
    void keyReleaseEvent(QKeyEvent* event);

    void focusOutEvent(QFocusEvent* event);

protected:

    std::string getChannelIDFromMimeData(const QMimeData* mimeData);
    std::list<ClassProxy> getVisualizationsFor(const std::string& channelID);
    void dragEnterEventImpl(QDragEnterEvent *event);
    void dropEventImpl(QDropEvent* event, QWidget* widget);

protected:
    void destroyVisualizations();
    void destroyTools();

private:
    void setToolbarArea(Qt::ToolBarArea area);
    void addToolButton(VisualizationTool* tool, const QString& name, const QString& category, const QString& description);

    // Will enable this tool as the currently active one in its category
    void switchToTool(VisualizationTool* tool, bool setChecked = false);

    // Returns the category of this tool, or the default category if none exists
    QString getCategory(VisualizationTool* tool) {
        return tool->getClass().getMetaInfo("Category").empty() ? DEFAULT_CATEGORY :
                QString::fromLocal8Bit(tool->getClass().getMetaInfo("Category").c_str());
    }

    void setWindowTitle( std::string const& title );
    std::string getWindowTitle() const;

private slots:
    void onToolAction();
    void onToolButton();
    void onHideToolbar(bool);

private:
    VisualizationControlPage* mControl;
    std::list<Visualization*> mVisualizations;

    std::vector<VisualizationTool*> mTools;
    XMLDom mToolsState;

    // Convenience mapping from tool id (<category>_<toolname>) to its tool.
    std::map<QString, VisualizationTool*> mIdToTool;

    // Stores the tool of each category that is currently in the top slot.
    std::map<QString, VisualizationTool*> mCurrentTool;

    // Convenience mapping from category string to the corresponding tool button.
    std::map<QString, QToolButton*> mCategoryToToolButton;

    // Currently active tool
    VisualizationTool* mActiveTool;

    // When e.g. CTRL is pressed, this will store the old tool while the new one is active.
    VisualizationTool* mDisplacedTool;

    // Manage our buttons, only one may be pressed at the same time
    QButtonGroup* mButtonGroup;

private:
    QBasicTimer mUpdateTimer;
    int mUpdateInterval;
    Time mLastUpdateTime;

    QBoxLayout* mLayout;
    QToolBar* mToolBar;
    QAction* mHideToolBar;
    QWidget* mVisualizationPart;
    Qt::ToolBarArea mCurrentToolboxArea;

    const QString DEFAULT_CATEGORY;

    bool mOfferAuxiliaryVisualizations;
};


class MIRA_GUI_VIEWS_EXPORT VisualizationViewTransformable : public VisualizationView
{
    Q_OBJECT
    MIRA_ABSTRACT_OBJECT(VisualizationViewTransformable)

public:

    VisualizationViewTransformable();
    virtual ~VisualizationViewTransformable();

public:

    template <typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, VisualizationView);
        r.property("Fixed Frame", mFixedFrame, "The reference frame used to denote the world frame. Should not be moving (e.g. map frame, etc.)", "");
        r.property("Camera Frame", mCameraFrame,
                   setter(&VisualizationViewTransformable::setCameraFrame, this),
                   "The frame where all other frames are transformed to for displaying the data", TransformProperty());
    }

protected:

    virtual void setCameraFrame(const TransformProperty& frame) { mCameraFrame = frame; }

protected:

    TransformProperty mFixedFrame;
    TransformProperty mCameraFrame;

private slots:

    void checkFrames();
    
private:

    std::string mLastAskedFixedFrame; // the fixed frame value, we have asked to set the frame automatically
    std::string mLastAskedCameraFrame; // the camera frame value, we have asked to set it automatically
    QTimer* mFrameCheckTimer;
};


}

#endif