baseobjectmixin.h

Go to the documentation of this file.

#pragma once
 
#include "mixin.h"
#include "baseobjectscene.h"
#include "baseobject.h"
 
#include "adtfstreaming3/samplereader.h"
 
namespace adtf
{
 
namespace disptb
{
 
namespace mixinlib
{
 
namespace endor
{

class cBaseObjectMixin : public cMixin
{
public:
    cBaseObjectMixin()
    {
    }

    ~cBaseObjectMixin() override
    {
    }

    virtual tResult AddScene(adtf::streaming::flash::ISampleReader* pSampleReader, cBaseObjectScene* pScene)
    {
        auto oScene = m_oScenes.find(pSampleReader);
        if (oScene != m_oScenes.end())
        {
            RETURN_ERROR_DESC(ERR_DEVICE_IN_USE, "The scene was already registered");
        }
        m_oScenes[pSampleReader] = pScene;
 
        GetRoot()->addChild(pScene);
 
        RETURN_NOERROR;
    }

    virtual tResult GetScene(adtf::streaming::flash::ISampleReader* pSampleReader, cBaseObjectScene** ppScene)
    {
        auto oScene = m_oScenes.find(pSampleReader);
        if (oScene == m_oScenes.end())
        {
            RETURN_ERROR(ERR_NOT_FOUND);
        }
 
        *ppScene = oScene->second;
        RETURN_NOERROR;
    }
 
public: // overrides cMixin
    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));
        }
 
        RETURN_NOERROR;
    }
 
    tResult OnPick(tInt32 nPosX, tInt32 nPosY, tUInt32 nFlags, const tNodePath& sNodePath) override
    {
        // walk through the path until we reach a cIdSwitch
        const cBaseObjectScene* pScene = nullptr;
 
        for (tSize nIndex = 0; nIndex < sNodePath.nCount; ++nIndex)
        {
            auto pNode = sNodePath.ppNodePath[nIndex];
            if (!pScene)
            {
                // remember the scene
                pScene = dynamic_cast<const cBaseObjectScene*>(pNode);
            }
 
            // we do a dynamic cast the see if it is a cIdSwitch
            auto pObj = dynamic_cast<const cBaseObject*>(pNode);
            if (pObj)
            {
                // we found and object so let it handle it
                // its ours so the const cast is ok
                RETURN_IF_FAILED(OnObjectPick(const_cast<cBaseObjectScene*>(pScene), const_cast<cBaseObject*>(pObj),
                                              nPosX, nPosY, nFlags, sNodePath));
                break;
            }
        }
 
        RETURN_NOERROR;
    }
 
protected:
    virtual tResult UpdateScene(cBaseObjectScene* pScene,
                                const adtf::ucom::ant::iobject_ptr<const adtf::streaming::ant::ISample>& pSample) = 0;

    virtual tResult OnObjectPick(cBaseObjectScene* /*pScene*/,
                                 cBaseObject* pObj,
                                 tInt /*nPosX*/,
                                 tInt /*nPosY*/,
                                 tUInt32 /*nFlags*/,
                                 const tNodePath& /*sNodePath*/)
    {
        RETURN_IF_FAILED(pObj->SetSelected(!pObj->IsSelected()));
        RETURN_NOERROR;
    }
 
protected:
    std::map<adtf::streaming::ISampleReader*, osg::ref_ptr<cBaseObjectScene>> m_oScenes;
};
 
} // namespace endor

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