ContentNode.hpp

#pragma once

#include "GraphTypes.hpp"
#include "Slot.hpp"

#include "UIComponent.hpp"

namespace Showcase
{
  class SHOWCASE_API ContentNode : public std::enable_shared_from_this<ContentNode>
  {
  public:
    enum class Source
    {
      SELF = 0,
      HOST_UI_NODE,
      DEFAULT
    };

    typedef std::vector<std::shared_ptr<ContentNode> > Nodes;
    typedef QList<MultiWidgets::OperatorPtr> Operators;

    ContentNode(const GraphNode& node, UIComponentWeakPtr parentUiComponent,
                const QByteArray & slotNameInUiComponent, bool contentRoot=false);

    virtual ~ContentNode();

    bool operator==(const ContentNode & node) const;
    bool operator<(const ContentNode & node) const;

    void setSlots(const Slots& slot);

    void init();

    NodeId nodeId() const;

    bool isReady() const;

    bool isSlotReady(const QByteArray & slotName);

    QString componentName(const QByteArray & slotName) const;

    MultiWidgets::WidgetPtr createWidgetInstance(const QByteArray & slotName,
                                                 Valuable::Node::Uuid loggedParentId = 0);

    MultiWidgets::OperatorPtr createOperatorInstance(const QByteArray & slotName,
                                                     MultiWidgets::Widget & widget);

    Operators createOperatorInstancesForSlot(const QByteArray & slotName,
                                             MultiWidgets::Widget & widget);

    Nodes children() const;

    float order() const;

    static QByteArray defaultContentNodeIdPrefix();

    void rewritePropertyKey(PropertyKey& key) const;

    void notifyCachedProperties(std::shared_ptr<UIComponentInstance> instance);

    void addListenerInstance(UIComponentInstancePtr instance);

    PropertyValue propertyValue(const PropertyKey & key);

    QByteArray type() const;

  private:
    ComponentPtr createComponentWithoutLock(const QByteArray& slotName);

    MultiWidgets::OperatorPtr createOperatorInstanceWithoutLock(const QByteArray & slotName,
                                                                MultiWidgets::Widget & widget);

    void propertyReceived(const Property & property, Source source);
    void propertyLost(const Property & property, Source source);

    void childFound(const NodeId & id);
    void childLost(const NodeId & id);

    void childCompleted(const NodeId & id);
    void childIncompleted(const NodeId & id);

    void completed();
    void incompleted();

    void addEvents(CachedNodePtr node);
    void addUiNodeEvents(CachedNodePtr node);
    void addDefaultNodeEvents(CachedNodePtr node);

    ComponentPtr createComponent(const QByteArray & slotName);
    void removeComponent(const QByteArray & slotName);

    void checkComplete();

    void sortChildren();

    QByteArray propertyPrefix() const;

    void prepareParentUiNodeCache();
    void prepareOwnCache();
    void prepareDefaultsCache();

    bool checkFoundPropertyPriority(const QByteArray & slotName,
                                    const Property & property,
                                    Source source);
    bool checkLostPropertyPriority(const QByteArray & slotName,
                                   Source source);

    void propertyFoundToComponents(const Property & property);
    void propertyLostToComponents(const Property & property);

    void createPlaceholder(const QByteArray & slotName,
                           const Property & property);

    bool haveUiSlot(const QByteArray & name) const;

    void tryRestoreProperty(const QByteArray & slotName,
                            Source lostSource);
    bool tryRestorePropertyFromSource(const QByteArray & slotName,
                                      Source source);

    void applyCachedPropertiesToComponent(const Component & comp, ComponentInstance & instance);
    void applyProperty(const Component & comp, ComponentInstance & instance,
                             const QByteArray & key, const PropertyValue & value,
                             Source source);

    void notifyCachedPropertiesToUiParent(UIComponentPtr ui);

    struct ComponentData
    {
      UIComponentPtr uiComponent;
      ComponentPlaceholderPtr placeholder;
      CachedGraphPtr cachedGraph;
    };

    typedef std::unordered_map<QByteArray, ComponentData> SlotComponents;

    GraphNode m_node;

    UIComponentWeakPtr m_parentUiComponent;
    QByteArray m_slotNameInUiComponent;
    bool m_isGraphEntryPoint;

    Slots m_uiSlots;

    SlotComponents m_slotInstances;

    mutable std::mutex m_slotInstanceMutex;

    CachedNodePtr m_cachedNode;
    CachedNodePtr m_cachedParentUiNode;
    CachedNodePtr m_cachedDefaultsNode;

    mutable std::mutex m_childMutex;
    Nodes m_children;
    Nodes m_pendingChildren;

    bool m_isComplete;

    float m_order;

    QByteArray m_type;

    std::weak_ptr<ContentNode> m_parent;

    std::map<QByteArray, Source> m_activePropertySources;
    PropertyMap m_contentProperties;

    mutable std::mutex m_propertyMutex; 

    std::vector<std::weak_ptr<UIComponentInstance> > m_listenerInstances;
  };
  typedef std::shared_ptr<ContentNode> ContentNodePtr;
  typedef std::weak_ptr<ContentNode> ContentNodeWeakPtr;

}