YiScrollingView.h

Go to the documentation of this file.

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

#include "signal/YiSignal.h"
#include "view/YiSceneView.h"
#include "view/YiScrollController.h"

class CYIMagnetScrollController;
class CYIParallelTimelineGroup;
class CYIPerspectiveCameraSceneNode;

class CYIScrollingView : public CYISceneView, public CYIScrollController::ScrollListener
{
public:
    enum OVERPULL_RULE
    {
        OVERPULL_ALWAYS,         
        OVERPULL_IF_OVERFLOWING  
    };

    enum LAYOUT_MODE
    {
        LAYOUT_FIT_CONTENT,                
        LAYOUT_FIT_CONTENT_IF_OVERFLOWING, 
        LAYOUT_FILL_VIEW                   
    };

    enum CAROUSEL_RULE
    {
        CAROUSEL_NEVER,                      
        CAROUSEL_ALWAYS,                     
        CAROUSEL_IF_OVERFLOWING              
    };

    enum TIMELINE_TYPE
    {
        TIMELINE_IN,    
        TIMELINE_OUT    
    };

    enum MAGNETS_TYPE
    {
        MAGNETS_NONE,    
        MAGNETS_EDGES,   
        MAGNETS_CENTER,  
        MAGNETS_BEGIN,   
        MAGNETS_END      
    };

    struct Magnets
    {
        static Magnets CreateNone();

        static Magnets CreateCenter(float fCenterOffset);

        static Magnets CreateBegin(float fBeginningOffset);

        static Magnets CreateEnd(float fEndOffset);

        static Magnets CreateEdges(float fBeginningOffset, float fEndOffset);

        const MAGNETS_TYPE eType; 
        const float fBeginningOffset; 
        const float fCenterOffset; 
        const float fEndOffset; 

    private:
        Magnets(MAGNETS_TYPE eType, float fBeginningOffset, float fCenterOffset, float fEndOffset);
    };

    CYIScrollingView();
    virtual ~CYIScrollingView();

    virtual bool Init() override;

    void ScrollToHorizontalPosition(float fNormalizedPosition, uint32_t uDurationMs, CYITimeInterpolator *pInterpolator = nullptr);

    void ScrollToHorizontalPosition(float fNormalizedPosition);

    void ScrollToVerticalPosition(float fNormalizedPosition, uint32_t uDurationMs, CYITimeInterpolator *pInterpolator = nullptr);

    void ScrollToVerticalPosition(float fNormalizedPosition);

    void ScrollToPosition(const glm::vec2 &fNormalizedPositions, uint32_t uDurationMs = 0, CYITimeInterpolator *pInterpolator = nullptr);

    float GetHorizontalPosition() const;

    float GetVerticalPosition() const;

    void Reveal(CYISceneNode *pNode, uint32_t uDurationMs, CYITimeInterpolator *pInterpolator = nullptr);

    void DisableHorizontalScrolling();

    void EnableHorizontalScrolling();

    void SetHorizontalScrollingEnabled(bool bEnabled);

    bool IsHorizontalScrollingEnabled() const;

    void DisableVerticalScrolling();

    void EnableVerticalScrolling();

    void SetVerticalScrollingEnabled(bool bEnabled);

    bool IsVerticalScrollingEnabled() const;

    void SetHorizontalOverpullDistance(float fDistance);

    float GetHorizontalOverpullDistance() const;

    void SetVerticalOverpullDistance(float fDistance);

    float GetVerticalOverpullDistance() const;

    void SetHorizontalOverpullRule(OVERPULL_RULE eRule);

    void SetVerticalOverpullRule(OVERPULL_RULE eRule);

    OVERPULL_RULE GetHorizontalOverpullRule() const;

    OVERPULL_RULE GetVerticalOverpullRule() const;

    void SetHorizontalScrollingAreaLayoutMode(LAYOUT_MODE eMode);

    void SetVerticalScrollingAreaLayoutMode(LAYOUT_MODE eMode);

    LAYOUT_MODE GetHorizontalScrollingAreaLayoutMode() const;

    LAYOUT_MODE GetVerticalScrollingAreaLayoutMode() const;

    bool HasHorizontalOverflow() const;

    bool HasVerticalOverflow() const;

    const CYIAABB &GetScrollableRegion() const;

    void StopScrolling();

    void StopHorizontalScrolling();

    void StopVerticalScrolling();

    void SetHorizontalCarouselRule(CAROUSEL_RULE eCarouselRule);

    void SetVerticalCarouselRule(CAROUSEL_RULE eCarouselRule);

    CAROUSEL_RULE GetHorizontalCarouselRule() const;

    CAROUSEL_RULE GetVerticalCarouselRule() const;

    void SetCascadeTimelineGroupDelay(uint32_t uDelayMs);

    uint32_t GetCascadeTimelineGroupDelay() const;

    CYITimelineGroup *GetCascadeTimelineGroup(TIMELINE_TYPE eType = TIMELINE_IN);

    bool IsInVisibleRegion(CYISceneNode *pCandidate) const;

    void SetHorizontalMagnets(const Magnets &magnets);

    void RemoveHorizontalMagnets();

    Magnets GetHorizontalMagnets() const;

    void SetHorizontalSwipeOneItemEnabled(bool bSwipeOneItem);

    bool IsHorizontalSwipeOneItemEnabled() const;

    void SetVerticalMagnets(const Magnets &magnets);

    void RemoveVerticalMagnets();

    Magnets GetVerticalMagnets() const;

    void SetVerticalSwipeOneItemEnabled(bool bSwipeOneItem);

    bool IsVerticalSwipeOneItemEnabled() const;

    void EnableMagnetism(CYISceneNode *pNode);

    void DisableMagnetism(CYISceneNode *pChild);

    bool IsMagnetic(const CYISceneNode *pNode) const;

    bool IsScrollingHorizontally() const;
    
    bool IsScrollingVertically() const;

    float GetHorizontalTrackpadLeaveFriction() const;

    void SetHorizontalTrackpadLeaveFriction(float fFriction);

    float GetVerticalTrackpadLeaveFriction() const;

    void SetVerticalTrackpadLeaveFriction(float fFriction);

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

    virtual bool HandlesFocusInDescendants() const override;

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

    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()) override;

    virtual CYISceneView *FindNextFocusInDescendants(const CYISceneView *pCurrentFocusView, CYIFocus::FOCUS_DIRECTION eDirection, CYIAABB &screenSpaceFocusRegion, const CYIFocusSearchOptions &options = CYIFocusSearchOptions()) const override;

    virtual void FocusChangedInDescendants() override;

    virtual void FocusGainedInDescendants() override;

    CYISignal<> InteractionBegan; 
    CYISignal<> HorizontalScrollingBegan; 
    CYISignal<> VerticalScrollingBegan; 
    CYISignal<float> HorizontalPositionChanged; 
    CYISignal<float> VerticalPositionChanged; 
    CYISignal<> InteractionEnded; 
    CYISignal<> HorizontalScrollingEnded; 
    CYISignal<> VerticalScrollingEnded; 
    CYISignal<bool> HorizontalOverflowChanged; 
    CYISignal<bool> VerticalOverflowChanged; 
    CYISignal<CYISceneNode*> ChildEnteredVisibleRegion; 
    CYISignal<CYISceneNode*> ChildLeftVisibleRegion; 
protected:
    enum DIRECTION
    {
        HORIZONTAL,
        VERTICAL,

        DIRECTION_MAX //Represents the size of the enum
    };

    enum SCROLL_DIRECTION
    {
        SCROLL_CLOSEST, 
        SCROLL_FORWARD, 
        SCROLL_REVERSE 
    };

    struct ViewAndDistance
    {
        CYISceneView *view;
        glm::vec2 distanceFromTopLeft;
    };

    CYIScrollController *GetScrollController(DIRECTION eDirection) const;

    void ConfigureScrollControllers();

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

    void ConfigureScrollingRange(DIRECTION eDirection, float fContentSize);
    void ConfigureOverpull(DIRECTION eDirection, float fViewSize);
    void ConfigureMagnets(DIRECTION eDirection, float fViewSize, float fOldViewSize);

    virtual void ParseProperties();

    virtual bool HandleEvent(const std::shared_ptr<CYIEventDispatcher> &pEventDispatcher, CYIEvent *pEvent) override;
    virtual void Measure(const MeasureSpec &widthSpec, const MeasureSpec &heightSpec, const MeasureSpec &depthSpec) override;
    virtual void ApplyMeasurements() override;
    virtual void SizeChanged() override;
    virtual void WorldBoundingBoxUpdated() override;

    virtual void ChildAdded(CYISceneNode *pChild) override;

    virtual void ChildRemoved(CYISceneNode *pChild) override;

    virtual void Reveal(CYISceneNode *pNode, uint32_t uDurationMs, SCROLL_DIRECTION eHorizontalDirection, SCROLL_DIRECTION eVerticalDirection, CYITimeInterpolator *pInterpolator = nullptr);

    virtual CYIAABB CalculateScrollableRegion() const;

    CYIAABB CalculateContentSize() const;

    bool IsInExpandedVisibleRegion(CYISceneNode *pCandidate, float fVisibleRegionMultiplier) const;

    void CheckAndNotifyVisibilityInVisibilityRegion(CYISceneNode *pChild);

    virtual void ChildVisibilityInVisibleRegionChanged(CYISceneNode *pChild, bool bIsInVisibleRegion);

    virtual void OnChildVisibilityInVisibleRegionChanged(CYISceneNode *pChild, bool bIsInVisibleRegion);

    virtual void ChildMovedInVisibleRegion(CYISceneNode *pChild, const glm::vec2 &normalizedPosition);
    virtual void OnChildMovedInVisibleRegion(CYISceneNode *pChild, const glm::vec2 &normalizedPosition);

    virtual void OnScrollAuto(CYIScrollController *pController) override;
    virtual void OnScrollStarted(CYIScrollController *pController) override;
    virtual void OnScrolled(CYIScrollController *pController, YI_SCROLLED_INFO scrolledInfo) override;
    virtual void OnScrollEnded(CYIScrollController *pController) override;

    virtual void UpdateEnd() override;

    bool IsCarouseling(DIRECTION eDirection) const;

    CYITimelineGroup *GetCascadeTimelineGroup(TIMELINE_TYPE eType, bool bUpdateTimeline);

    virtual CYIAbstractTimeline *GetCascadeTimelineFor(TIMELINE_TYPE eType, CYISceneView *pView);

    virtual std::map<CYISceneView *, uint64_t> GetTotalCascadeDelayFor(TIMELINE_TYPE eType, const std::vector<ViewAndDistance> &visibleViews);

    static const CYIString &DirectionToString(DIRECTION eDirection);

    uint32_t m_uFocusScrollDuration;

private:
    enum CAMERAS
    {
        CAMERA_TOP_LEFT,
        CAMERA_TOP_RIGHT,
        CAMERA_BOTTOM_LEFT,
        CAMERA_BOTTOM_RIGHT,
        CAMERAS_MAX  //Represents the size of the enum
    };

    enum MAGNETS
    {
        LEFT,
        RIGHT,
        UP = LEFT,
        DOWN = RIGHT,
        POSITIVE = LEFT,
        NEGATIVE = RIGHT
    };

    void InitializeCameras();
    void PlaceCameras(const CYIAABB &scrollRegion);
    void UpdateCameraPerspectives(float cameraDistance, const glm::vec3 &viewSize);

    bool HasOverflow(DIRECTION eDirection) const;

    /*
        Camera placement and carousel handling
    */
    void InitializeScrollPosition();
    void OffsetCameraByRegionTopLeft();
    void CheckAndUpdateCameraRootPositionInDirection(DIRECTION eDirection);
    void CheckAndUpdateCarouselState();
    void EnableHorizontalCarousel();
    void EnableVerticalCarousel();
    void DisableHorizontalCarousel();
    void DisableVerticalCarousel();
    bool ShouldCarousel(DIRECTION eDirection) const;
    virtual void CarouselStatusChanged(DIRECTION eDirection, bool bIsCarousel);

    /*
        Scrolling Behaviour
    */
    void ScrollStart(const glm::vec3 &position, uint64_t uTimeMs, uint8_t uPointerID);
    void ScrollMove(const glm::vec3 &position, uint64_t uTimeMs, uint8_t uPointerID);
    void ScrollEnd(const glm::vec3 &position, uint64_t uTimeMs, uint8_t uPointerID);
    bool InterpretEventForScroll(CYIActionEvent *pEvent);

    void ScrollToHorizontalPosition(float fNormalizedPosition, uint32_t uDurationMs, SCROLL_DIRECTION eDirection, CYITimeInterpolator *pInterpolator = nullptr);
    void ScrollToVerticalPosition(float fNormalizedPosition, uint32_t uDurationMs, SCROLL_DIRECTION eDirection, CYITimeInterpolator *pInterpolator = nullptr);
    void ScrollToPosition(DIRECTION eDirection, float fNormalizedPosition, uint32_t uDurationMs, SCROLL_DIRECTION eScrollDirection, CYITimeInterpolator *pInterpolator = nullptr);

    void CheckAndNotifyOverflowChanged();

    void OnScrollRegionChanged();

    void ApplySnapBackInDirectionIfNecessary(DIRECTION eDirection);

    void NotifyPositionInVisibilityRegion();
    void NotifyPositionInVisibilityRegion(CYISceneNode *pNode);

    void UpdateMagneticPoints();
    void AddMagneticPoints(DIRECTION eDirection, CYISceneNode *pNode);

    glm::vec2 CalculateDistanceFromTopLeft(CYISceneNode *pChild) const;
    void InitializeTimelineGroups();
    void UpdateCascadeIn();
    void UpdateCascadeOut();

    bool FindFocusCandidatesInViewsScreenSpaceRegion(CYIFocus::FOCUS_DIRECTION eDirection, const CYIAABB &previousFocusRect, const CYIFocusSearchOptions &options, void *pFoundCandidates = nullptr) const;

    void SetSwipeOneItemEnabled(DIRECTION eDirection, bool bSwipeOneItem);
    bool IsSwipeOneItemEnabled(DIRECTION eDirection) const;

    static const float s_fDefaultScrollThreshold;
    static const uint32_t s_uDefaultFocusScrollDuration;

    bool m_bScrolling;
    bool m_bVisibilityCheckRequired;
    bool m_bMagnetSnapRequired;
    glm::vec3 m_DownPosition;
    glm::vec3 m_PreviousSize;
    bool m_bDown;
    float m_fHorizontalLeaveFriction;
    float m_fVerticalLeaveFriction;

    /*
        Scrolling View
    */
    bool m_bScrollingEnabled[DIRECTION_MAX]; 
    OVERPULL_RULE m_eOverpullRule[DIRECTION_MAX];
    float m_fOverpullDistance[DIRECTION_MAX];
    bool m_bOverflowState[DIRECTION_MAX]; 
    LAYOUT_MODE m_eLayoutMode[DIRECTION_MAX];
    glm::vec3 m_measuredScrollingArea;
    CYIAABB m_scrollRegion;

    CYIPerspectiveCameraSceneNode *m_pCameras[CAMERAS_MAX];
    CYISceneNode *m_pCameraRoot;
    CAROUSEL_RULE m_eCarouselRule[DIRECTION_MAX];
    bool m_bIsCarousel[DIRECTION_MAX]; 
    mutable SCROLL_DIRECTION m_eScrollDirectionsForReveal[DIRECTION_MAX];

    CYIMagnetScrollController *m_pScrollController[DIRECTION_MAX];

    MAGNETS_TYPE m_eCurrentMagnetTypes[DIRECTION_MAX];
    float m_fMagnetOffsets[DIRECTION_MAX][2]; //Offsets for {left, right} and {up, down} magnets

    std::set<CYISceneNode*> m_visibleChildren;

    CYITimelineGroup *m_pTimelineGroup[2];
    CYITimelineGroup *m_pCascadeTimeline[2];
    uint32_t m_uCascadeDelayMs;

    YI_TYPE_BASES(CYIScrollingView, CYISceneView)
};

inline bool operator==(const CYIScrollingView::Magnets &lhs, const CYIScrollingView::Magnets &rhs)
{
    return lhs.eType == rhs.eType &&
           glm::epsilonEqual(rhs.fCenterOffset, lhs.fCenterOffset, glm::epsilon<float>()) &&
           glm::epsilonEqual(rhs.fBeginningOffset, lhs.fBeginningOffset, glm::epsilon<float>()) &&
           glm::epsilonEqual(rhs.fEndOffset, lhs.fEndOffset, glm::epsilon<float>());
}

inline bool operator!=(const CYIScrollingView::Magnets &lhs, const CYIScrollingView::Magnets &rhs)
{
    return !(lhs == rhs);
}

#endif // _YI_SCROLLING_VIEW_H_