baseobjectselectionmixin.h

Go to the documentation of this file.

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
 
#include <disptb/mixin/baseobjectmixin.h>
#include <adtfui/adtf_ui.h>
#include <adtfucom3/adtf_ucom3.h>
#include <disptb/mixin/viewer_intf.h>
 
#include <QObject>
#include <QGroupBox>
#include <QLabel>
 
namespace adtf
{
 
namespace disptb
{
 
namespace mixinlib
{
 
namespace endor
{

class cBaseObjectSelectionMixin : public QObject, public adtf::ui::qt_ui_filter<cBaseObjectMixin>
{
    // Removed Q_OBJECT for switch to interface library
public:
    cBaseObjectSelectionMixin()
    {
    }
 
    ~cBaseObjectSelectionMixin() override
    {
    }
 
public: // overwrite cMixin
    QWidget* CreateView() override
    {
        // create the base widget
        QWidget* pWidget = new QWidget;
        pWidget->setLayout(new QVBoxLayout);
 
        AttachItemsToWidget(pWidget);
 
        return pWidget;
    }

    tVoid ReleaseView() override
    {
    }

    tResult InitScene() override
    {
        RETURN_IF_FAILED(cBaseObjectMixin::InitScene());
        RETURN_IF_FAILED(GetSceneGraph().GetObject(m_pViewer));
 
        RETURN_NOERROR;
    }

    tResult ProcessInput(adtf::streaming::flash::ISampleReader* pReader,
                         const adtf::ucom::ant::iobject_ptr<const adtf::streaming::ant::ISample>& pSample) override
    {
        cBaseObjectScene* pScene = nullptr;
        if (IS_OK(GetScene(pReader, &pScene)))
        {
            RETURN_IF_FAILED(UpdateScene(pScene, pSample));
 
            // check if our selected object still exists in the scene
            if (m_pSelectedObject && m_pSelectedScene == pScene)
            {
                cBaseObject* pBaseObj = nullptr;
                if (IS_FAILED(m_pSelectedScene->GetObject(m_pSelectedObject->GetId(), &pBaseObj)))
                {
                    m_pSelectedObject = nullptr; // delete it (ref ptr)
                    m_pSelectedScene = nullptr;
                }
            }
        }
 
        RETURN_NOERROR;
    }

    tResult OnIdle() override
    {
        if (!m_pViewer)
        {
            // if viewer is not initialized, there is nothing to do.
            RETURN_NOERROR;
        }
 
        // We lock the viewer to access m_pSelectedObject.
        // See the documentation of cMixin for more information on locking the viewer.
        m_pViewer->Lock();
 
        // update all widgets
        tResult nResult = UpdateWidgets(m_pSelectedScene, m_pSelectedObject);
 
        // release the viewer lock
        m_pViewer->Unlock();
 
        return nResult;
    }
 
public: // overwrite cBaseObjectMixin
    tResult OnObjectPick(cBaseObjectScene* pScene,
                         cBaseObject* pObj,
                         tInt /*nPosX*/,
                         tInt /*nPosY*/,
                         tUInt32 /*nFlags*/,
                         const tNodePath& /*sNodePath*/) override
    {
        // we do not call the base method since it always toggles the selection state of the picked object.
 
        // unselect a previously selected object
        if (m_pSelectedObject)
        {
            m_pSelectedObject->SetSelected(tFalse);
        }
 
        if (m_pSelectedObject != pObj)
        {
            // select this object
            pObj->SetSelected(tTrue);
            // and store a reference
            m_pSelectedObject = pObj;
            m_pSelectedScene = pScene;
        }
        else
        {
            m_pSelectedObject = nullptr;
            m_pSelectedScene = nullptr;
        }
        RETURN_NOERROR;
    }
 
protected:
    virtual void AttachItemsToWidget(QWidget* pWidget)
    {
        QGroupBox* pSelectedGroup = new QGroupBox("Selected Object");
        pWidget->layout()->addWidget(pSelectedGroup);
        pWidget->layout()->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding));
        QGridLayout* pGrid = new QGridLayout;
        pSelectedGroup->setLayout(pGrid);
 
        // and add all our labels.
        tInt nRow = 0;
        pGrid->addWidget(new QLabel("Scene:"), nRow, 0);
        m_pSceneLabel = new QLabel("<na>");
        pGrid->addWidget(m_pSceneLabel, nRow, 1);
 
        ++nRow;
        pGrid->addWidget(new QLabel("Id:"), nRow, 0);
        m_pIdLabel = new QLabel("<na>");
        pGrid->addWidget(m_pIdLabel, nRow, 1);
 
        ++nRow;
        pGrid->addWidget(new QLabel("Position:"), nRow, 0);
        m_pPositionLabel = new QLabel("<na>");
        pGrid->addWidget(m_pPositionLabel, nRow, 1);
 
        ++nRow;
        pGrid->addWidget(new QLabel("Rotation:"), nRow, 0);
        m_pRotationLabel = new QLabel("<na>");
        pGrid->addWidget(m_pRotationLabel, nRow, 1);
 
        ++nRow;
        pGrid->addWidget(new QLabel("Dimensions:"), nRow, 0);
        m_pDimLabel = new QLabel("<na>");
        pGrid->addWidget(m_pDimLabel, nRow, 1);
 
        ++nRow;
        pGrid->addWidget(new QLabel("Motion Vector:"), nRow, 0);
        m_pMotionLabel = new QLabel("<na>");
        pGrid->addWidget(m_pMotionLabel, nRow, 1);
    }

    virtual tResult UpdateWidgets(cBaseObjectScene* pScene, cBaseObject* pObj)
    {
        if (pObj)
        {
            // if we have a selected object we update the labels.
            m_pSceneLabel->setText(pScene->GetName());
            m_pIdLabel->setText(QString::number(pObj->GetId()));
 
            const tChar* strFormat = "%.3f / %.3f / %.3f";
            osg::Vec3d vTmp = pObj->GetPosition();
            m_pPositionLabel->setText(adtf_util::cString::Format(strFormat, vTmp.x(), vTmp.y(), vTmp.z()).GetPtr());
            vTmp = pObj->GetRotation();
            m_pRotationLabel->setText(adtf_util::cString::Format(strFormat, vTmp.x(), vTmp.y(), vTmp.z()).GetPtr());
            vTmp = pObj->GetSize();
            m_pDimLabel->setText(adtf_util::cString::Format(strFormat, vTmp.x(), vTmp.y(), vTmp.z()).GetPtr());
            vTmp = pObj->GetMotion();
            m_pMotionLabel->setText(adtf_util::cString::Format(strFormat, vTmp.x(), vTmp.y(), vTmp.z()).GetPtr());
            m_bHadSelection = tTrue;
        }
        else
        {
            if (m_bHadSelection)
            {
                // reset all labels
                m_pSceneLabel->setText("<na>");
                m_pIdLabel->setText("<na>");
                m_pPositionLabel->setText("<na>");
                m_pRotationLabel->setText("<na>");
                m_pDimLabel->setText("<na>");
                m_pMotionLabel->setText("<na>");
            }
            m_bHadSelection = tFalse;
        }
 
        RETURN_NOERROR;
    }
 
protected:
    adtf::ucom::ant::object_ptr<IViewer> m_pViewer;

    QLabel* m_pSceneLabel;
    QLabel* m_pIdLabel;
    QLabel* m_pPositionLabel;
    QLabel* m_pRotationLabel;
    QLabel* m_pDimLabel;
    QLabel* m_pMotionLabel;

    tBool m_bHadSelection = false;

    osg::ref_ptr<cBaseObject> m_pSelectedObject;
    osg::ref_ptr<cBaseObjectScene> m_pSelectedScene;
};
 
} // namespace endor

using endor::cBaseObjectSelectionMixin;
 
} // namespace mixinlib
 
} // namespace disptb
 
} // namespace adtf