OperatorComponent.hpp

#ifndef OPERATORCOMPONENT_HPP
#define OPERATORCOMPONENT_HPP

#include "Showcase.hpp"
#include "UIComponent.hpp"

namespace Showcase
{
  class SHOWCASE_API OperatorInstance : public UIComponentInstance
  {
  public:
    typedef std::weak_ptr<MultiWidgets::Operator> OperatorWeakPtr;

    OperatorInstance(ComponentPtr comp, MultiWidgets::OperatorPtr instance);
    virtual ~OperatorInstance();

    virtual void removeInstance() override;

    virtual MultiWidgets::OperatorPtr operatorInstance(MultiWidgets::Widget & host,
                                                       bool immediate = false) override;

    virtual void propertyReceived(const PropertyKey &key,
                                  const PropertyValue &value) override;
    virtual void propertyLost(const PropertyKey &key,
                              const PropertyValue &value) override;

  private:
    OperatorWeakPtr m_instanceOperator;
    MultiWidgets::OperatorPtr m_strongRef;

    MultiWidgets::WidgetWeakPtr m_hostWidget;
  };

  class SHOWCASE_API OperatorComponent : public UIComponent
  {
  public:
    OperatorComponent(std::function<MultiWidgets::OperatorPtr(void)> create);
    MultiWidgets::OperatorPtr createOperator();

  protected:
    virtual ComponentInstancePtr instanceImpl() override;

  private:
    std::function<MultiWidgets::OperatorPtr(void)> m_createFunc;
  };

  typedef std::shared_ptr<OperatorComponent> OperatorComponentPtr;
  typedef std::weak_ptr<OperatorComponent> OperatorComponentWeakPtr;
}

#define SHOWCASE_OPERATOR_COMPONENT(name, type) \
namespace {\
Showcase::FactoryRegistrant<Showcase::OperatorComponent> MW_PLUGIN_CONCAT(component, __LINE__) \
(name, [] { return std::make_shared<Showcase::OperatorComponent>(\
             [] { return std::make_shared<type>(); } ); }); \
}

#endif // OPERATORCOMPONENT_HPP