drawer.h

Go to the documentation of this file.

#pragma once
 
#ifdef WIN32
    #include <windows.h>
#endif
 
#include <adtf_filtersdk.h>
#include <adtffiltersdk/filter.h>
#include <adtf_base.h>
 
#include <adtfdisplaytoolboxgraphics/gltexture.h>
#include <adtfdisplaytoolboxgraphics/color.h>
#include <adtfdisplaytoolboxdrawer/drawer_intf.h>
#include <adtfdisplaytoolboxdrawer/drawer_manager_intf.h>
#include <adtfdisplaytoolboxdrawer/drawer_manager.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace drawerlib
{
 
namespace detail
{
class cDrawerImplementation
{
protected:
    base::property_variable<tInt> m_nZOrder;
    base::property_variable<tBool> m_bVisible;
    base::property_variable<tFloat32> m_fTransX{0.0};
    base::property_variable<tFloat32> m_fTransY{0.0};
    base::property_variable<tFloat32> m_fScaleX{0.0};
    base::property_variable<tFloat32> m_fScaleY{0.0};
    base::property_variable<tFloat32> m_fRotate{0.0};
    ucom::ant::object_ptr<streaming::IBindingObject> m_pBindingClient;
    ucom::object_ptr<drawerlib::cDrawerManager> m_pDrawerManager;
 
protected:
    cDrawerImplementation(): m_nZOrder(1), m_bVisible(tTrue), m_pDrawerManager(ucom::make_object_ptr<cDrawerManager>())
    {
    }
 
    virtual ~cDrawerImplementation() = default;
 
protected:
    tInt GetZOrderImpl() const
    {
        return m_nZOrder;
    }

    tBool IsVisibleImpl() const
    {
        return m_bVisible;
    }
 
    tResult OnDrawImpl(dengar::IDrawer* pDrawer, const ucom::ant::iobject_ptr<graphicslib::ICanvas>& pCanvas)
    {
        pCanvas->PushMatrix();
        ApplyMatrix(pCanvas);
 
        tResult nResult = ERR_NOERROR;
 
        if (IsVisibleImpl())
        {
            nResult = pDrawer->Draw(pCanvas);
            if (IS_FAILED(nResult))
            {
                LogDrawerError(nResult, pDrawer);
            }
        }
 
        if (m_pDrawerManager->HasChildren())
        {
            for (auto* pChild : m_pDrawerManager->GetOrderedDrawerList())
            {
                nResult = pChild->OnDraw(pCanvas);
                if (IS_FAILED(nResult))
                {
                    LogDrawerError(nResult, pDrawer);
                }
            }
        }
 
        pCanvas->PopMatrix();
 
        RETURN_NOERROR;
    }
 
    tResult Register(dengar::IDrawer* pDrawer)
    {
        ucom::object_ptr<IDrawerManager> pDrawerManager = nullptr;
        if (IS_OK(m_pBindingClient->GetServerObject(pDrawerManager)))
        {
            pDrawerManager->RegisterManagedDrawer(pDrawer);
        }
        RETURN_NOERROR;
    }
 
    tVoid ClearChildren()
    {
        m_pDrawerManager->Clear();
    }
 
    static tVoid LogDrawerError(tResult nResult, dengar::IDrawer* pDrawer)
    {
        if (auto* pFilter = dynamic_cast<adtf::filter::cFilter*>(pDrawer))
        {
            util::cString strName{};
            pFilter->GetName(adtf_string_intf(strName));
            LOG_ERROR("Error %s:%s in Drawer %s", nResult.GetErrorString(), nResult.GetDescription(), strName.GetPtr());
        }
    }
 
public:
    tVoid ApplyMatrix(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& pCanvas)
    {
        pCanvas->Translate(m_fTransX, m_fTransY, 0.0f);
        pCanvas->Scale(m_fScaleX, m_fScaleY, 1.0f);
        pCanvas->Rotate(m_fRotate, 0.0f, 0.0f, 1.0f);
    }

    tVoid SetMatrix(tFloat32 fTransX, tFloat32 fTransY, tFloat32 fScaleX, tFloat32 fScaleY, tFloat32 fRotate)
    {
        m_fTransX = fTransX;
        m_fTransY = fTransY;
        m_fScaleX = fScaleX;
        m_fScaleY = fScaleY;
        m_fRotate = fRotate;
    }
};
} // namespace detail
 
namespace dengar
{

class cDrawer : public ucom::catwo::object<filter::ant::cFilter, dengar::IDrawer>, public detail::cDrawerImplementation
{
public:
    cDrawer()
    {
        SetMatrix(0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
        THROW_IF_FAILED_DESC(RegisterProperties(), "Failed to register properties")
        THROW_IF_FAILED(streaming::create_client<IDrawerManager>(*this, "drawer_manager"));
        THROW_IF_FAILED(FindBindingObject("drawer_manager", m_pBindingClient));
        THROW_IF_FAILED(streaming::create_server<IDrawerManager>(
            *this, "_drawer_manager", ucom::ucom_object_ptr_cast<IDrawerManager>(m_pDrawerManager)));
    }

    virtual ~cDrawer() = default;

    tResult RegisterProperties()
    {
        RETURN_IF_FAILED(RegisterPropertyVariable("Z-Order", m_nZOrder));
        RETURN_IF_FAILED(RegisterPropertyVariable("Visible", m_bVisible));
        RETURN_IF_FAILED(RegisterPropertyVariable("CS/TranslateX", m_fTransX));
        RETURN_IF_FAILED(RegisterPropertyVariable("CS/TranslateY", m_fTransY));
        RETURN_IF_FAILED(RegisterPropertyVariable("CS/ScaleX", m_fScaleX));
        RETURN_IF_FAILED(RegisterPropertyVariable("CS/ScaleY", m_fScaleY));
        RETURN_IF_FAILED(RegisterPropertyVariable("CS/Rotate", m_fRotate));
        RETURN_NOERROR;
    }

    tInt GetZOrder() const override
    {
        return GetZOrderImpl();
    }

    tBool IsVisible() const override
    {
        return IsVisibleImpl();
    }

    virtual tResult Draw(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& /*pCanvas*/) override
    {
        RETURN_NOERROR;
    }

    tResult OnDraw(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& pCanvas) override
    {
        return OnDrawImpl(this, pCanvas);
    }
 
protected:
    tResult Init(tInitStage eStage) override
    {
        if (eStage == tInitStage::StageGraphReady)
        {
            RETURN_IF_FAILED(Register(this));
        }
        RETURN_NOERROR;
    }
 
    tResult Shutdown(tInitStage eStage) override
    {
        if (eStage == tInitStage::StageGraphReady)
        {
            ClearChildren();
        }
        RETURN_NOERROR;
    }
};
 
} // namespace dengar
 
namespace florrum
{

class cDrawer : public ucom::catwo::object<filter::cFilter, florrum::IDrawer>, public detail::cDrawerImplementation
{
public:
    cDrawer()
    {
        SetMatrix(0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
 
        m_nZOrder.SetDescription("Value of the z-order.");
        RegisterPropertyVariable("Z-Order", m_nZOrder);
 
        m_bVisible.SetDescription("If enabled, drawer will be visible.");
        RegisterPropertyVariable("Visible", m_bVisible);
 
        m_fTransX.SetDescription("Value for the x-axis of the translation matrix to be multiplied with the current "
                                 "matrix (note: z-value = 0.0).");
        RegisterPropertyVariable("CS/TranslateX", m_fTransX);
 
        m_fTransY.SetDescription("Value for the y-axis of the translation matrix to be multiplied with the current "
                                 "matrix (note: z-value = 0.0).");
        RegisterPropertyVariable("CS/TranslateY", m_fTransY);
 
        m_fScaleX.SetDescription("Value for the uniform scale factor along the x-axis (note: z-value = 1.0).");
        RegisterPropertyVariable("CS/ScaleX", m_fScaleX);
 
        m_fScaleY.SetDescription("Value for the uniform scale factor along the y-axis (note: z-value = 1.0).");
        RegisterPropertyVariable("CS/ScaleY", m_fScaleY);
 
        m_fRotate.SetDescription("Value for the rotation angle degree around the vector x=0.0/y=0.0/z=1.0.");
        RegisterPropertyVariable("CS/Rotate", m_fRotate);
 
        THROW_IF_FAILED(streaming::create_client<IDrawerManager>(*this, "drawer_manager"));
        SetDescription("drawer_manager", "IDrawerManager interface (client).");
        THROW_IF_FAILED(FindBindingObject("drawer_manager", m_pBindingClient));
        THROW_IF_FAILED(streaming::create_server<IDrawerManager>(
            *this, "_drawer_manager", ucom::ucom_object_ptr_cast<IDrawerManager>(m_pDrawerManager)));
        SetDescription("_drawer_manager", "IDrawerManager interface (server).");
    }

    virtual ~cDrawer() = default;

    tInt GetZOrder() const override
    {
        return GetZOrderImpl();
    }

    tBool IsVisible() const override
    {
        return IsVisibleImpl();
    }

    virtual tResult Draw(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& /*pCanvas*/) override
    {
        RETURN_NOERROR;
    }

    tResult OnDraw(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& pCanvas) override
    {
        return OnDrawImpl(dynamic_cast<dengar::IDrawer*>(this), pCanvas);
    }

    virtual tResult ContextCreated(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& /*pCanvas*/) override
    {
        RETURN_NOERROR;
    }

    tResult OnCreateContext(const ucom::ant::iobject_ptr<graphicslib::dengar::ICanvas>& pCanvas) final override
    {
        tResult nResult = ERR_NOERROR;
        nResult = ContextCreated(pCanvas);
        if (IS_FAILED(nResult))
        {
            LogDrawerError(nResult, this);
        }
 
        // TODO Register could happen later than OnCreateContext
        //  In which case we will actually have to repeat this for yet unknown children at the time of OnDraw
        if (m_pDrawerManager->HasChildren())
        {
            for (auto* pChild : m_pDrawerManager->GetOrderedDrawerList())
            {
                if (auto* pNewChild = dynamic_cast<florrum::IDrawer*>(pChild))
                {
                    nResult = pNewChild->OnCreateContext(pCanvas);
                    if (IS_FAILED(nResult))
                    {
                        LogDrawerError(nResult, this);
                    }
                }
            }
        }
 
        RETURN_NOERROR;
    }

    virtual tResult ContextDestroyed() override
    {
        RETURN_NOERROR;
    }

    tResult OnDestroyContext() final
    {
        tResult nResult = ERR_NOERROR;
        nResult = ContextDestroyed();
        if (IS_FAILED(nResult))
        {
            LogDrawerError(nResult, this);
        }
 
        if (m_pDrawerManager->HasChildren())
        {
            for (auto* pChild : m_pDrawerManager->GetOrderedDrawerList())
            {
                if (auto* pNewChild = dynamic_cast<florrum::IDrawer*>(pChild))
                {
                    nResult = pNewChild->OnDestroyContext();
                    if (IS_FAILED(nResult))
                    {
                        LogDrawerError(nResult, this);
                    }
                }
            }
        }
 
        RETURN_NOERROR;
    }
 
protected:
    tResult Init(tInitStage eStage) override
    {
        if (eStage == tInitStage::StageGraphReady)
        {
            RETURN_IF_FAILED(Register(dynamic_cast<dengar::IDrawer*>(this)));
        }
        RETURN_NOERROR;
    }
 
    tResult Shutdown(tInitStage eStage) override
    {
        if (eStage == tInitStage::StageGraphReady)
        {
            ClearChildren();
        }
        RETURN_NOERROR;
    }
};
 
} // namespace florrum
 
using florrum::cDrawer;
 
} // namespace drawerlib
} // namespace disptb
} // namespace adtf