YiSceneView.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2020. All rights reserved.
#ifndef _YI_SCENE_VIEW_H_
#define _YI_SCENE_VIEW_H_

#include "animation/YiMarkerData.h"
#include "event/YiEventHandler.h"
#include "focus/YiFocus.h"
#include "framework/YiPredef.h"
#include "scenetree/YiSceneManager.h"
#include "scenetree/YiSceneNode.h"

class CYIAbstractCameraSceneNode;
class CYIAbstractTimeline;
class CYIActionEvent;
class CYIAssetViewTemplate;
class CYILayout;
class CYIParallelTimelineGroup;
class CYIPooledViewRecycler;
class CYITimeline;
class CYITimelineGroup;
enum class EYIAnchorType;

class CYISceneView : public CYISceneNode, public CYIEventHandler
{
    friend class CYISceneViewPriv;

public:
    struct YI_ANCHOR_DATA
    {
        CYISceneNode *pAnchor;
        glm::vec3 originalScale;

        YI_ANCHOR_DATA()
            : pAnchor(nullptr)
        {
        }
    };

    typedef struct
    {
        enum class Type
        {
            RequiresNode, 
            RequiresTimeline 
        };

        Type assetRequirementType;
        const char *pRequiredName;
        CYIMarkerData::ID requiredMarkerID;

    } AssetRequirement;

    enum class TimelineGetMode
    {
        GetDefault, 
        GetTimeline, 
        GetTimelineGroup, 
        GetComponentOfTimelineGroup 
    };

    enum class InitialFocusLifetime
    {
        Persistent, 
        ClearOnEntry 
    };

    CYISceneView();
    virtual ~CYISceneView();

    bool BuildFromTemplate(CYISceneManager *pSceneManager, const std::shared_ptr<CYIAssetViewTemplate> &pAssetViewTemplate, CYISceneManager::MissingClassHandlingMode missingHandlingMode = CYISceneManager::MissingClassHandlingMode::Abort);

    virtual bool Init() override;

    bool IsInitialized() const;

    void SetClippingAreaNode(CYISceneNode *pClippingNode);

    virtual CYIOptional<CYIStringView> GetProperty(CYIStringView propertyName) const override;

    bool GetProperty(CYIStringView propertyName, CYIString *pValue) const;

    virtual std::map<CYIString, CYIString> GetProperties() const override;

    virtual void ForEachProperty(const std::function<void(const CYIString & /* propertyName */, const CYIString & /* propertyValue */)> &action) const override;

    virtual bool HasProperties() const override;

    void EnableDefaultHitZone();

    bool IsResponsiveLayoutEnabled() const;

    void EnableResponsiveLayout();

    void DisableResponsiveLayout();

    void AddAnchor(EYIAnchorType anchorType);

    YI_ANCHOR_DATA GetAnchor(EYIAnchorType anchorType) const;

    static void RegisterAllViews();

    virtual const CYISceneView::AssetRequirement *GetAssetRequirements(uint32_t *pRequirementCount);

    CYIAbstractTimeline *GetInTimeline() const;

    CYIAbstractTimeline *GetOutTimeline() const;

    CYIAbstractTimeline *GetFocusInTimeline() const;

    CYIAbstractTimeline *GetFocusOutTimeline() const;

    virtual bool HandlesFocusInDescendants() const;

    virtual bool RequestFocus(CYIFocus::Direction direction = CYIFocus::Direction::Forward, CYIFocus::FocusRootRule focusRootRule = CYIFocus::FocusRootRule::DescendantsUpdateContext, const CYIAABB &previousFocusRect = CYIAABB(), const CYIFocusSearchOptions &options = CYIFocusSearchOptions());

    bool HasFocus() const;

    void SetFocusable(bool focusable);

    bool IsFocusable() const;

    bool CanBeFocused() const;

    void SetNextFocus(CYISceneView *pView, CYIFocus::Direction direction);

    CYISceneView *GetNextFocus(CYIFocus::Direction direction) const;

    void SetInitiallyFocusedView(CYISceneView *pView, InitialFocusLifetime initialFocusLifetime = InitialFocusLifetime::Persistent);

    CYISceneView *GetInitiallyFocusedView() const;

    CYISceneView *FindNextFocus(CYIFocus::Direction direction, const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const;

    CYISceneView *FindNextFocus(CYIFocus::Direction direction, CYIAABB &screenSpaceFocusRegion, const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const;

    virtual CYISceneView *FindNextFocusInDescendants(const CYISceneView *pCurrentFocusView, CYIFocus::Direction direction, CYIAABB &screenSpaceFocusRegion, const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const;

    const CYISceneNode *GetFocusRoot() const;

    CYISceneView *GetFocusHandler() const;

    virtual void OnFocusGained();

    virtual void FocusGained();

    virtual void OnFocusLost();

    virtual void FocusLost();

    virtual void FocusGainedInDescendants() override;

    virtual bool ContainsFocusableDescendant(const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const override;

    const std::shared_ptr<CYIAssetViewTemplate> &GetViewTemplate() const;

    const std::vector<CYIString> &GetChildTemplateNames();

    virtual CYIAbstractTimeline *GetTimeline(CYIStringView markerName, TimelineGetMode mode = TimelineGetMode::GetDefault);

    CYIAbstractTimeline *GetTimeline(CYIMarkerData::ID id, TimelineGetMode mode = TimelineGetMode::GetDefault);

    std::map<CYIString, CYITimeline *> GetTimelines() const;

    bool FindTimeline(CYIAbstractTimeline *&pTimeline, CYIStringView markerName, FetchType type, const CYIString &tag = "", TimelineGetMode mode = TimelineGetMode::GetDefault);

    CYITimelineGroup *GetTimelineGroup(CYIStringView markerName);

    std::unique_ptr<CYITimelineGroup> BuildTimelineGroup(CYIStringView markerName);

    void BuildAnchorList();

    virtual void Reset() {}

    void SetLayout(std::unique_ptr<CYILayout> pLayout);

    const CYILayout *GetLayout() const;

    CYILayout *GetLayout();

    virtual void Measure(const MeasureSpec &widthSpec, const MeasureSpec &heightSpec, const MeasureSpec &depthSpec) override;

    virtual void ApplyMeasurements() override;

    virtual void BuildDrawList(std::vector<IYIRenderer::Command> &children, CYIAbstractCameraSceneNode *pCameraToDrawWith = nullptr) override;

    CYISignal<CYISceneView *> GainedFocus; 
    CYISignal<CYISceneView *> LostFocus; 

protected:
    void UpdateClipping();

    virtual void WorldScaleUpdated() override;
    virtual void WorldBoundingBoxUpdated() override;

    virtual void OnViewReflowed(const glm::vec3 &worldScale);

    virtual void ViewReflowed(const glm::vec3 &worldScale);

    virtual bool HandleEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;
    virtual bool ProcessEvent(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) override;

    void UpdateResponsiveLayoutAnchors();

    virtual void SizeChanged() override;

    virtual void ChildNeedsLayout() override;

    virtual void LayoutDirtied() override;

    virtual void ChildAdded(CYISceneNode *pChild) override;

    virtual void ChildRemoved(CYISceneNode *pChild) override;

    virtual void ChildVisibilityChanged(CYISceneNode *pChild) override;

    void OnViewIsInAnimatedPosition();

    /*
     \copydoc OnViewIsInAnimatedPosition()
    */
    void OnViewIsGoingOutOfAnimatedPosition();

    void SetInTimeline(CYIAbstractTimeline *pTimeline);

    void SetOutTimeline(CYIAbstractTimeline *pTimeline);

    virtual void OnInit();

    bool TryRequestFocusOnInitiallyFocusedView();

    bool m_stopEventPropagation;
    bool m_responsiveLayoutEnabled;
    bool m_sceneTreeBuilt;
    bool m_inAnimatedPosition;
    CYISceneNode *m_pClippingNode;
    CYIAbstractTimeline *m_pFocusInTimeline;
    CYIAbstractTimeline *m_pFocusOutTimeline;
    std::unique_ptr<CYILayout> m_pLayout;
    std::shared_ptr<CYIAssetViewTemplate> m_pAssetViewTemplate;
    std::shared_ptr<CYISceneNodeProxy> m_pInitiallyFocusedView;
    InitialFocusLifetime m_initialFocusLifetime;

    std::multimap<EYIAnchorType, YI_ANCHOR_DATA> m_anchors;
    std::map<CYIString, std::unique_ptr<CYITimeline>, std::less<>> m_timelines;
    std::map<CYIString, std::unique_ptr<CYIParallelTimelineGroup>, std::less<>> m_timelineGroups;

private:
    static void RecursivelyAddTimelinesToGroup(CYISceneNode *pNode, CYITimelineGroup *pTimelineGroup, CYIStringView markerName);

    void SetLayout(std::unique_ptr<CYILayout> pLayout, bool configureFromProperties);

    void DescendantAdded(CYISceneNode *pDescendant);
    void DescendantRemoved(CYISceneNode *pDescendant);

#ifdef YI_DEBUG
    CYIPooledViewRecycler *m_pPooledViewRecycler;
#endif

    CYIAbstractTimeline *m_pInTimeline;
    CYIAbstractTimeline *m_pOutTimeline;

    std::shared_ptr<CYISceneNodeProxy> m_pNextFocusView[(size_t)CYIFocus::Direction::DirectionsCount];
    bool m_focusable;

    bool m_initCalled;

    YI_TYPE_BASES(CYISceneView, CYISceneNode)
    YI_DISALLOW_COPY_AND_ASSIGN(CYISceneView)
};

#ifdef YI_FUNCTION_SPECIALIZATION_FULLY_SUPPORTED
template<>
inline const CYISceneView *YiDynamicCast<CYISceneView>(const CYISceneNode *pObject)
{
    return pObject ? (pObject->CanCastTo<CYISceneView>() ? static_cast<const CYISceneView *>(pObject) : nullptr) : nullptr;
}
#endif

#endif // _YI_SCENE_VIEW_H_