WidgetComponent.hpp

#pragma once

#include "OperatorComponent.hpp"
#include "Showcase.hpp"
#include "UIComponent.hpp"
#include "ui/PinnableWidget.hpp"

#include <MultiWidgets/Plugins.hpp>

namespace Showcase
{
  class WidgetInstance;

  typedef std::shared_ptr<WidgetInstance> WidgetInstancePtr;
  typedef std::weak_ptr<WidgetInstance> WidgetInstanceWeakPtr;

  class SHOWCASE_API WidgetInstance : public UIComponentInstance
  {
  public:
    typedef QPair<MultiWidgets::WidgetWeakPtr, WidgetInstanceWeakPtr> Source;
    typedef QMap<Valuable::Node::Uuid, Source> Sources;
    typedef QMap<QByteArray, Sources> EventSources;
    typedef std::function<void(QByteArray, WidgetInstance&, MultiWidgets::Widget&)> EventFoundFunc;
    typedef std::function<void(QByteArray, MultiWidgets::Widget&)> EventLostFunc;

    WidgetInstance(ComponentPtr comp, MultiWidgets::WidgetPtr instance);
    virtual ~WidgetInstance();

    virtual void removeInstance() override;

    void init();

    virtual MultiWidgets::WidgetPtr widgetInstance() override;
    MultiWidgets::WidgetPtr widgetInstanceWeak();

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

    virtual void componentAddedToSlot(const QByteArray& slotName,
                                      std::shared_ptr<Component> comp) override;
    MultiWidgets::WidgetPtr createInstanceWidget(const QByteArray& slotName,
                                                 std::shared_ptr<Component> comp,
                                                 bool addToThisWidget = true);
    virtual void componentRemovedFromSlot(const QByteArray& slotName,
                                          std::shared_ptr<Component> comp) override;

    virtual void operatorFound(const QByteArray& slotName,
                               std::shared_ptr<OperatorComponent> comp);
    virtual void operatorLost(const QByteArray& slotName,
                              std::shared_ptr<OperatorComponent> comp);

    //-------------- Event passing functions ---------------------------------

    void setupEvents(WidgetInstance & instance, MultiWidgets::Widget & source);
    void removeEvents(WidgetInstance & instance, MultiWidgets::Widget & source);

    void eventFound(const QByteArray & event, WidgetInstance & instance,
                    MultiWidgets::Widget & source, EventDirection type);
    void eventLost(const QByteArray & event, MultiWidgets::Widget & source,
                   EventDirection type);

    void setOnEventFound(EventFoundFunc && func,EventDirection type);
    void setOnEventLost(EventLostFunc && func,EventDirection type);

    Events allEvents(EventDirection type) const;
    Events localEvents(EventDirection type) const;

    bool passEvents(EventDirection type) const;
    bool isLocalEvent(const QByteArray & event, EventDirection type) const;

    static void setupEvents(MultiWidgets::Widget & host,
                            MultiWidgets::Widget & child);

  private:
    void setupEvents(WidgetInstance & instance, MultiWidgets::Widget & source,
                     EventDirection type);
    void removeEvents(WidgetInstance & instance, MultiWidgets::Widget & source,
                      EventDirection type);

    void applyProperty(MultiWidgets::WidgetPtr w, const PropertyKey & key,
                       const PropertyValue & value);
    void clearProperty(MultiWidgets::WidgetPtr w, const PropertyKey & key,
                       const PropertyValue & value);

    MultiWidgets::WidgetWeakPtr m_instanceWidget;
    Valuable::Node::Uuid m_instanceWidgetId;
    MultiWidgets::WidgetPtr m_strongRef;

    EventSources m_externEventsIn;
    EventSources m_externEventsOut;

    EventFoundFunc m_onEventInFound;
    EventFoundFunc m_onEventOutFound;

    EventLostFunc m_onEventInLost;
    EventLostFunc m_onEventOutLost;

    std::set<QByteArray> m_lazyAttributes;
  };

  //------------------------------------------------------------------------

  class SHOWCASE_API WidgetComponent : public UIComponent
  {
  public:
    WidgetComponent(std::function<MultiWidgets::WidgetPtr(void)> create);

    MultiWidgets::WidgetPtr createWidget();

  protected:
    virtual ComponentInstancePtr instanceImpl() override;

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

  // ------------------------------------------------------------------

  class SHOWCASE_API CustomWidgetInstanceComponent : public WidgetComponent
  {
  public:
    typedef std::function<WidgetInstancePtr(ComponentPtr, MultiWidgets::WidgetPtr)> InstanceFunc;

    CustomWidgetInstanceComponent(std::function<MultiWidgets::WidgetPtr(void)> createWidget,
                                  InstanceFunc createInst);

  protected:
    virtual ComponentInstancePtr instanceImpl() override;

  private:
    std::function<MultiWidgets::WidgetPtr(void)> m_createFunc;
    InstanceFunc m_createInstanceFunc;
  };

}

#define EXPORT_CORNERSTONE_PLUGIN(name, pluginName) \
namespace {\
  Showcase::FactoryRegistrant<Showcase::UIComponent> MW_PLUGIN_CONCAT(component, __LINE__) \
  (name, [] { return std::make_shared<Showcase::WidgetComponent>(\
               [] { return MultiWidgets::Plugins::instance()->createPluginWidget(pluginName); } ); }); \
}

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

#define SHOWCASE_CUSTOM_WIDGET_INSTANCE_COMPONENT(name, type, instanceType) \
namespace {\
Showcase::FactoryRegistrant<Showcase::CustomWidgetInstanceComponent> MW_PLUGIN_CONCAT(component, __LINE__) \
(name, [] { return std::make_shared<Showcase::CustomWidgetInstanceComponent>(\
             [] { return MultiWidgets::create<type>(); },\
             [] (Showcase::ComponentPtr c, MultiWidgets::WidgetPtr w){\
                  return std::make_shared<instanceType>(c,w);\
                 });\
           });\
}

inline Radiant::IntrusivePtr<Showcase::PinnableWidget> createPinnableWidgetFromPlugin(const QString & pluginName)
{
  auto child = MultiWidgets::Plugins::instance()->createPluginWidget(pluginName);
  if (!child)
    return nullptr;

  return MultiWidgets::create<Showcase::PinnableWidget>(child);
}

#define EXPORT_CORNERSTONE_PLUGIN_AS_PINNABLE(name, pluginName) \
namespace {\
  Showcase::FactoryRegistrant<Showcase::UIComponent> MW_PLUGIN_CONCAT(component, __LINE__) \
  (name, [] { return std::make_shared<Showcase::WidgetComponent>(\
               [] { return createPinnableWidgetFromPlugin(pluginName); });\
            }); \
}

#define SHOWCASE_WIDGET_COMPONENT_AS_PINNABLE(name, type) \
namespace {\
  Showcase::FactoryRegistrant<Showcase::UIComponent> MW_PLUGIN_CONCAT(component, __LINE__) \
  (name, [] { return std::make_shared<Showcase::WidgetComponent>(\
               [] { return MultiWidgets::create<Showcase::PinnableWidget>(MultiWidgets::create<type>()); });\
            });\
}