UIComponent.hpp

#pragma once

#include "Component.hpp"

namespace Showcase
{

  class ContentNode;
  class ScheduleComponent;

  class SHOWCASE_API UIComponentInstance : public ComponentInstance
  {
  public:
    UIComponentInstance(std::shared_ptr<Component> component);

    virtual void setContent(const QByteArray& slotName, std::shared_ptr<ContentNode> content);

    virtual void removeContent(const QByteArray& slotName, std::shared_ptr<ContentNode> content);

    virtual void contentNodeFound(std::shared_ptr<ContentNode> node,
                                  std::shared_ptr<ContentNode> parent=nullptr);
    virtual void contentNodeLost(std::shared_ptr<ContentNode> node,
                                 std::shared_ptr<ContentNode> parent=nullptr);

    virtual void contentNodeLostProperty(std::shared_ptr<ContentNode> contentNode,
                                         const Property& prop);
    virtual void contentNodeReceivedProperty(std::shared_ptr<ContentNode> contentNode,
                                             const Property& prop);

    virtual void componentAddedToSlot(const QByteArray& slotName,
                                      std::shared_ptr<Component> comp);
    virtual void componentRemovedFromSlot(const QByteArray& slotName,
                                          std::shared_ptr<Component> comp);

  protected:
    virtual void removeInstance() override {}

  };
  typedef std::shared_ptr<UIComponentInstance> UIComponentInstancePtr;

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

  class UIComponent;
  typedef std::unordered_map<Slot, std::vector<std::shared_ptr<UIComponent>>, Slot::Hasher> SlotAssignments;

  class SHOWCASE_API UIComponent : public Component
  {
  public:
    UIComponent(CachedGraphPtr uiGraph=nullptr);
    virtual ~UIComponent();

    std::vector<std::shared_ptr<UIComponent>> assignments(const QByteArray& slot) const;

    const Slots& componentSlots() const;

    const std::unordered_set<QByteArray>& roles() const;

    QByteArray subtype() const;

    UIComponentInstancePtr createInstance(const QByteArray& role);

    void assignToSlot(const QByteArray& slotName, std::shared_ptr<UIComponent> comp);

    void componentAddedToSlot(const QByteArray& slotName, std::shared_ptr<UIComponent> comp);
    void componentRemovedFromSlot(const QByteArray& slotName, std::shared_ptr<UIComponent> comp);

    bool slotsFulfilled(const std::unique_lock<std::mutex>& lock=std::unique_lock<std::mutex>()) const;

    void setOnSlotsFulfilled(std::function<void(void)>&& f);
    void setOnSlotsUnfulfilled(std::function<void(void)>&& f);

    void removeFromSlots(const NodeId& id);

    void initializeContentSlot(const Slot& slot, const Property& property);

    void removeContentSlot(const Slot& slot);

    bool enabled() const;
    void setEnabled(bool enabled);

  protected:
    bool acceptContentProperty(const PropertyKey& key) const;

    virtual void placeholderStatusChanged(const NodeId &id) override;
    virtual void initPlaceholder(ComponentPlaceholderPtr placeholder) override;
    void assignSlotsToInstance(UIComponentInstancePtr instance);

    virtual void propertyReceived(const Property &property) override;
    virtual void propertyLost(const Property& property) override;


    virtual void contentNodeReceivedProperty(std::shared_ptr<ContentNode> node, const Property& prop,
                                             bool eventWasPending = false);
    virtual void contentNodeLostProperty(std::shared_ptr<ContentNode> node, const Property& prop,
                                         bool eventWasPending = false);

    virtual void contentNodeFound(std::shared_ptr<ContentNode> node,
                                  std::shared_ptr<ContentNode> parent=nullptr,
                                  bool eventWasPending = false);
    virtual void contentNodeLost(std::shared_ptr<ContentNode> node,
                                 std::shared_ptr<ContentNode> parent=nullptr,
                                 bool eventWasPending = false);

    virtual ComponentInstancePtr instanceImpl() override;


  private:
    enum class ContentEventType
    {
      NodeFound,
      NodeLost,
      PropertyFound,
      PropertyLost
    };

    struct ContentEvent
    {
      std::shared_ptr<ContentNode> node;
      std::shared_ptr<ContentNode> parent;
      Property prop;
      ContentEventType type;
    };

    void contentComplete(const QByteArray & slotName);
    void contentIncomplete(const QByteArray & slotName);

    void checkSlotsFulfilled();

    void setContentToInstance(UIComponentInstancePtr instance,
                              const QByteArray & slotName,
                              std::shared_ptr<ContentNode> node);
    void addContentNodeChildren(UIComponentInstancePtr instance,
                                std::shared_ptr<ContentNode> node);

    void handlePendingEvents();
    void queueEvent(ContentEvent event);

    void scheduleComponentAdded(const QByteArray & slotName,
                                std::shared_ptr<ScheduleComponent> comp);

    mutable std::mutex m_slotMutex;
    SlotAssignments m_slots;

    std::mutex m_contentSlotMutex;
    typedef std::unordered_map<Slot, std::shared_ptr<ContentNode>, Slot::Hasher> ContentSlots;
    ContentSlots m_contentSlots;

    bool m_slotsFulfilledCalled = false;
    bool m_slotsUnfulfilledCalled = false;

    std::function<void(void)> m_onSlotsFulfilled;
    std::function<void(void)> m_onSlotsUnfulfilled;

    std::atomic<bool> m_settingContent;
    std::mutex m_contentEventMutex;
    std::queue<ContentEvent> m_pendingEvents;

    std::atomic<bool> m_enabled;

    friend class ContentNode;
  };
  typedef std::shared_ptr<UIComponent> UIComponentPtr;
  typedef std::weak_ptr<UIComponent> UIComponentWeakPtr;

}