YiSceneView.h

Go to the documentation of this file.

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

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

class CYIActionEvent;

class CYIAbstractCameraSceneNode;
class CYIAbstractTimeline;
class CYIAssetViewTemplate;
class CYILayout;
class CYISceneViewPriv;
class CYITimeline;
class CYITimelineGroup;
class CYIParallelTimelineGroup;

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

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

        YI_ANCHOR_DATA() :
            pAnchor(nullptr)
        {
        }
    };
    
    enum ASSET_REQUIREMENT_TYPE
    {
        REQUIRES_NODE,      
        REQUIRES_TIMELINE   
    };

    typedef struct
    {
        ASSET_REQUIREMENT_TYPE      assetRequirementType;
        const char *pRequiredName;
        CYIMarkerData::MARKER_ID    requiredMarkerID;

    } AssetRequirement;

    enum TIMELINE_GET_MODE
    {
        GET_DEFAULT, 
        GET_TIMELINE, 
        GET_TIMELINE_GROUP, 
        GET_COMPONENT_OF_TIMELINE_GROUP 
    };

    CYISceneView();
    virtual ~CYISceneView();

    bool BuildFromTemplate(CYISceneManager *pSceneManager, const std::shared_ptr<CYIAssetViewTemplate> &pAssetViewTemplate, CYISceneManager::MISSING_CLASS_HANDLING_MODE eMissingHandlingMode = CYISceneManager::ABORT);

    virtual bool Init() override;

    bool IsInitialized() const;

    void SetClippingAreaNode(CYISceneNode *pClippingNode);

    virtual bool GetProperty(const CYIString &propertyName, CYIString *pValue) const override;
    
    void EnableDefaultHitZone();

    bool IsResponsiveLayoutEnabled() const;

    void EnableResponsiveLayout();

    void DisableResponsiveLayout();

    void AddAnchor(YI_ANCHOR_TYPE anchorType);

    YI_ANCHOR_DATA GetAnchor(YI_ANCHOR_TYPE 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::FOCUS_DIRECTION eDirection = CYIFocus::FOCUS_FORWARD, CYIFocus::FOCUS_ROOT_RULE eFocusRootRule = CYIFocus::FOCUS_ROOT_DESCENDANTS_UPDATE_CONTEXT, const CYIAABB &previousFocusRect = CYIAABB(), const CYIFocusSearchOptions &options = CYIFocusSearchOptions());

    bool HasFocus() const;

    void SetFocusable(bool bFocusable);

    bool IsFocusable() const;

    bool CanBeFocused() const;
    
    void SetNextFocus(CYISceneView *pView, CYIFocus::FOCUS_DIRECTION eDirection);

    CYISceneView *GetNextFocus(CYIFocus::FOCUS_DIRECTION eDirection) const;

    void SetInitiallyFocusedView(CYISceneView *pView);

    CYISceneView *GetInitiallyFocusedView() const;
    
    CYISceneView *FindNextFocus(CYIFocus::FOCUS_DIRECTION eDirection, const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const;
    
    CYISceneView *FindNextFocus(CYIFocus::FOCUS_DIRECTION eDirection, CYIAABB &screenSpaceFocusRegion, const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const;

    virtual CYISceneView *FindNextFocusInDescendants(const CYISceneView *pCurrentFocusView, CYIFocus::FOCUS_DIRECTION eDirection, 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();

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

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

    virtual CYIAbstractTimeline *GetTimeline(const CYIString &rMarkerName, TIMELINE_GET_MODE eMode = GET_DEFAULT);

    CYIAbstractTimeline *GetTimeline(CYIMarkerData::MARKER_ID eID, TIMELINE_GET_MODE eMode = GET_DEFAULT);

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

    bool FindTimeline(CYIAbstractTimeline *&pTimeline, const CYIString &markerName, FETCH_TYPE eType, const CYIString &tag = "", TIMELINE_GET_MODE eMode = GET_DEFAULT);

    CYITimelineGroup *GetTimelineGroup(const CYIString &markerName);

    std::unique_ptr<CYITimelineGroup> BuildTimelineGroup(const CYIString &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_bStopEventPropagation;
    bool                                m_bResponsiveLayoutEnabled;
    bool                                m_bSceneTreeBuilt;
    bool                                m_bInAnimatedPosition;
    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;

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

private:
    static void RecursivelyAddTimelinesToGroup(CYISceneNode *pNode, CYITimelineGroup *pTimelineGroup, const CYIString &markerName);

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

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

    std::unique_ptr<CYISceneViewPriv> m_pPriv;

    CYIAbstractTimeline                *m_pInTimeline;
    CYIAbstractTimeline                *m_pOutTimeline;

    std::shared_ptr<CYISceneNodeProxy> m_pNextFocusView[CYIFocus::FOCUS_MAX];
    bool m_bFocusable;

    bool m_bInitCalled;

    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_