FnViewerDelegateComponent.h

// Copyright (c) 2016 The Foundry Visionmongers Ltd. All Rights Reserved.

#ifndef FNVIEWER_VIEWERDELEGATECOMPONENT_H
#define FNVIEWER_VIEWERDELEGATECOMPONENT_H

#include <FnViewer/plugin/FnViewerDelegate.h>
#include <FnViewer/plugin/FnViewerLocationEvent.h>
#include <FnViewer/suite/FnViewerDelegateComponentSuite.h>

#include <FnPluginSystem/FnPluginSystem.h>
#include <FnPluginSystem/FnPlugin.h>
#include <FnAttribute/FnAttribute.h>

#include <string>
#include <vector>
#include <memory>

namespace Foundry
{
namespace Katana
{
namespace ViewerAPI
{

class ViewerDelegateComponentPluginBase
{
public:

    ViewerDelegateComponentPluginBase();

    virtual ~ViewerDelegateComponentPluginBase();

public: /* Methods to be called by the plugin. */

    ViewerDelegateWrapperPtr getViewerDelegate();

    FnAttribute::GroupAttribute getAttributes(const std::string& locationPath);

public:
    static FnPlugStatus setHost(FnPluginHost* host);
    static FnPluginHost* getHost();

protected:
    FnViewerDelegateComponentHostSuite_v2* m_hostSuite;
    FnViewerDelegateComponentHostHandle m_hostHandle;

    static FnPluginHost* m_host;

private:
    ViewerDelegateWrapperPtr m_viewerDelegateWrapper;

};


class ViewerDelegateComponent : public ViewerDelegateComponentPluginBase
{
public:
    ViewerDelegateComponent();
    virtual ~ViewerDelegateComponent();

public: /* Virtual functions to be extended by the plugin. */

    virtual void setup() = 0;

    virtual void cleanup() = 0;

    /* Scene Graph Events */

    virtual bool locationEvent(const ViewerLocationEvent& event,
            bool locationHandled) = 0;

    virtual void locationsSelected(
        const std::vector<std::string>& locationPaths) = 0;

    virtual bool isProcessing() const { return false; }

    static void flush() {}

    virtual void* getPrivateData(void* inputData) { return 0x0; }

    /* Options setting and getting. */

    virtual void setOption(OptionIdGenerator::value_type optionId,
                           FnAttribute::Attribute attr) {}

    virtual FnAttribute::Attribute getOption(
        OptionIdGenerator::value_type optionId);

    void setOption(const std::string& name, FnAttribute::Attribute attr);

    FnAttribute::Attribute getOption(const std::string& name);

    virtual FnAttribute::DoubleAttribute getBounds(
        const std::string& locationPath);

    virtual FnAttribute::DoubleAttribute computeExtent(
        const std::string& locationPath);

public:
    static FnViewerDelegateComponentPluginSuite_v2 createSuite(
        FnViewerDelegateComponentPluginHandle (*create)(
            FnViewerDelegateComponentHostHandle hostHandle));
    static FnViewerDelegateComponentPluginHandle newViewerDelegateComponentHandle(
        ViewerDelegateComponent* viewerDelegateComponent);

    static unsigned int _apiVersion;
    static const char*  _apiName;

    void setHostHandle(FnViewerDelegateComponentHostHandle m_hostHandle);
    FnViewerDelegateComponentHostHandle getHostHandle();

};


class ViewerDelegateComponentWrapper : public ViewerDelegateComponentPluginBase
{
public:
    ViewerDelegateComponentWrapper(
        FnPluginHost* host,
        FnViewerDelegateComponentHostHandle hostHandle,
        FnViewerDelegateComponentPluginHandle pluginHandle,
        FnViewerDelegateComponentPluginSuite_v2* pluginSuite);

    ~ViewerDelegateComponentWrapper();

    template<class T> T* getPluginInstance()
    {
        return dynamic_cast<T*>(getPluginPointer());
    }

    void setOption(OptionIdGenerator::value_type optionId,
        FnAttribute::Attribute attr);
    FnAttribute::Attribute getOption(OptionIdGenerator::value_type optionId);
    void setOption(const std::string& name, FnAttribute::Attribute attr);
    FnAttribute::Attribute getOption(const std::string& name);

    FnAttribute::DoubleAttribute getBounds(const std::string& location);
    FnAttribute::DoubleAttribute computeExtent(const std::string& location);

private:
    ViewerDelegateComponent* getPluginPointer();

    FnViewerDelegateComponentPluginSuite_v2* m_pluginSuite;
    FnViewerDelegateComponentPluginHandle m_pluginHandle;

};

typedef std::shared_ptr<ViewerDelegateComponentWrapper>
    ViewerDelegateComponentWrapperPtr;

} // ViewerAPI
} // Katana
} // Foundry




// Plugin-side structure to be pointed by the plugin handles.
struct FnViewerDelegateComponentPluginStruct
{
public:
    FnViewerDelegateComponentPluginStruct(
        Foundry::Katana::ViewerAPI::ViewerDelegateComponent* viewerDelegateComponent)
    : m_ViewerDelegateComponent(viewerDelegateComponent)
    { }

    ~FnViewerDelegateComponentPluginStruct()
    { }

    Foundry::Katana::ViewerAPI::ViewerDelegateComponent* getViewerDelegateComponent()
    {
        return m_ViewerDelegateComponent.get();
    }

private:
    std::shared_ptr<Foundry::Katana::ViewerAPI::ViewerDelegateComponent>
        m_ViewerDelegateComponent;
};

// Plugin Registering Macro.
#define DEFINE_VIEWER_DELEGATE_COMPONENT_PLUGIN(VIEWER_DELEGATE_COMPONENT_CLASS)        \
                                                                              \
    FnPlugin VIEWER_DELEGATE_COMPONENT_CLASS##_plugin;                        \
                                                                              \
    FnViewerDelegateComponentPluginHandle VIEWER_DELEGATE_COMPONENT_CLASS##_create(     \
        FnViewerDelegateComponentHostHandle hostHandle)                       \
    {                                                                         \
        Foundry::Katana::ViewerAPI::ViewerDelegateComponent* viewerDelegateComponent =  \
            VIEWER_DELEGATE_COMPONENT_CLASS::create();                        \
                                                                              \
        viewerDelegateComponent->setHostHandle(hostHandle);                   \
        return Foundry::Katana::ViewerAPI::ViewerDelegateComponent::newViewerDelegateComponentHandle( \
            viewerDelegateComponent);                                         \
    }                                                                         \
                                                                              \
    FnViewerDelegateComponentPluginSuite_v2                                   \
        VIEWER_DELEGATE_COMPONENT_CLASS##_suite =                             \
            Foundry::Katana::ViewerAPI::ViewerDelegateComponent::createSuite( \
                    VIEWER_DELEGATE_COMPONENT_CLASS##_create);                \
                                                                              \
    const void* VIEWER_DELEGATE_COMPONENT_CLASS##_getSuite()                  \
    {                                                                         \
        return &VIEWER_DELEGATE_COMPONENT_CLASS##_suite;                      \
    }


#endif