YiLayout.h

Go to the documentation of this file.

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

#include "binding/YiScriptableRTTIObject.h"
#include "framework/YiPredef.h"
#include "layout/YiLayoutConfig.h"
#include "view/YiSceneView.h"

class CYILayoutState;

class CYILayout : public CYIScriptableRTTIObject
{
public:
    enum POSITIONING_MODE
    {
        SET_POSITION_DIRECTLY,

        DO_NOT_SET_POSITION_DIRECTLY
    };

    typedef CYILayoutConfig::CubeOffset Padding;

    CYILayout();
    virtual ~CYILayout();

    void AttachTo(CYISceneView *pView);

    void ConfigureFromAttachedNode();

    void DetachFromNode();

    CYISceneNode *GetAssociatedSceneNode() const;

    void Measure(const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec);

    void ApplyMeasurements();

    void SetPositioningMode(POSITIONING_MODE ePositioningMode);

    POSITIONING_MODE GetPositioningMode() const;

    virtual void ChildAdded(CYISceneNode *pChild);

    virtual void ChildRemoved(CYISceneNode *pChild);

    virtual void ChildVisibilityChanged(CYISceneNode *pChild);

    
    void SetPadding(const Padding &padding);

    const Padding &GetPadding() const;
    
    void SetUseReverseChildrenOrder(bool bUseReverseChildrenOrder);
    
    bool IsUsingReverseChildrenOrder() const;

    void SetGravity(const glm::vec3 &vLayoutGravity);

    void SetGravity(CYILayoutConfig::GRAVITY eGravity);

    const glm::vec3 &GetGravity() const;


    static void RegisterAllLayouts();

    static bool IsLayoutable(const CYISceneNode *pNode);

    static glm::vec3 GetDefaultSize(const CYISceneNode *pNode, const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec);

    static void UpdateMeasuredSizeForFitContent(const CYISceneNode *pNode, glm::vec3 *pMeasuredSize, const glm::vec3 &contentSize, const Padding &padding, const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec);

    static void UnscaleMeasureSpecs(const glm::vec3 &vScale, CYISceneNode::MeasureSpec *pWidthSpec, CYISceneNode::MeasureSpec *pHeightSpec, CYISceneNode::MeasureSpec *pDepthSpec);

    static float CalculateDimension(const CYISceneNode::MeasureSpec &spec, const CYILayoutConfig::SizeConstraint &constraint, float fCurrentValue);

protected:
    virtual void Configure();
    
    virtual void OnSceneViewAttached();

    virtual void OnMeasure(const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec) = 0;

    virtual void OnApplyMeasurements() = 0;

    virtual void OnMeasurementsCalculated(const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec);

    virtual void OnMeasurementsApplied();

    virtual const CYIRuntimeTypeInfo &GetLayoutConfigType() const;

    virtual std::unique_ptr<CYILayoutState> CreateLayoutStateInstance() const;

    virtual void ApplyPosition(CYISceneNode *pChild, const glm::vec3 &vPosition);

    virtual void ApplySize(CYISceneNode *pChild, const glm::vec3 &vSize);

    static void MeasureChildWithMargins(CYISceneNode *pChild, const CYISceneNode::MeasureSpec &parentWidthSpec, const CYISceneNode::MeasureSpec &parentHeightSpec, const CYISceneNode::MeasureSpec &parentDepthSpec, const Padding &padding);

    static void MeasureChildWithMargins(CYISceneNode *pChild, const CYISceneNode::MeasureSpec &parentWidthSpec, const CYISceneNode::MeasureSpec &parentHeightSpec, const CYISceneNode::MeasureSpec &parentDepthSpec, const Padding &padding, const glm::vec3 &vChildScale);

    static CYISceneNode::MeasureSpec CalculateChildMeasureSpec(const CYISceneNode::MeasureSpec &parentMeasureSpec, float fPadding, const CYILayoutConfig::SizeConstraint &childConstraint, float fChildScale);

    enum DIMENSIONS
    {
        DIMENSIONS_NONE = 0x0,
        DIMENSIONS_X = 0x1,
        DIMENSIONS_Y = 0x2,
        DIMENSIONS_Z = 0x4,
        DIMENSIONS_ALL_BUT_X = DIMENSIONS_Y | DIMENSIONS_Z,
        DIMENSIONS_ALL_BUT_Y = DIMENSIONS_X | DIMENSIONS_Z,
        DIMENSIONS_ALL_BUT_Z = DIMENSIONS_X | DIMENSIONS_Y,
        DIMENSIONS_ALL = DIMENSIONS_X | DIMENSIONS_Y | DIMENSIONS_Z,
    };

    static bool UpdateMeasureSpecsForFitContent(const CYISceneNode *pNode, CYISceneNode::MeasureSpec *widthSpec, CYISceneNode::MeasureSpec *heightSpec, CYISceneNode::MeasureSpec *depthSpec);

    static void RemeasureChildrenForFillParent(const CYISceneNode *pNode, const glm::vec3 &vParentMeasuredSize, const Padding &padding, DIMENSIONS eDimensionsToRemeasure);

    void CreateLayoutObjectsFor(CYISceneNode *pNode) const;
    
    CYISceneNode *GetChild(uint32_t uIndex) const;

    static glm::vec3 GetAdjustedPosition(const glm::vec3 &vDesiredTopLeftPosition, const CYISceneNode *pChild);

    static glm::vec3 GetUnadjustedPosition(const glm::vec3 &vCurrentTopLeftPosition, const CYISceneNode *pChild);
    
    static glm::vec3 GetAdjustedMeasuredSize(const CYISceneNode *pChild);

    static glm::vec3 GetTopLeftPositionWithGravity(const glm::vec3 &vLayoutGravity, const glm::vec3 &vChildGravity, const glm::vec3 &vContainerTopLeft, const glm::vec3 &vContainerSize, const CYILayout::Padding &padding, const glm::vec3 &vChildSize, const CYILayoutConfig::Margin &margin, const glm::vec3 &vCurrentChildPosition);

    static void MeasureBackgroundChildren(CYISceneNode *pNode, const glm::vec3 &vSize);
    
    void ApplyMeasurementsToBackgroundChildren();

    const Padding &GetPaddingForChild(const CYISceneNode *pChild) const;

    CYISceneView *m_pNode; 
    Padding m_padding;
    bool m_bReverseChildrenOrder;
    glm::vec3 m_vGravity;
    POSITIONING_MODE m_ePositioningMode;

private:
    bool m_bBaseConfigureCalled;
    
    YI_DISALLOW_COPY_AND_ASSIGN(CYILayout)

    YI_TYPE_BASES_WITH_SCRIPTABLE_BASE(CYILayout)
};

inline CYISceneNode *CYILayout::GetAssociatedSceneNode() const
{
    return m_pNode;
}

inline glm::vec3 CYILayout::GetUnadjustedPosition(const glm::vec3 &vCurrentTopLeftPosition, const CYISceneNode *pChild)
{
    return vCurrentTopLeftPosition - pChild->GetAnchorPoint();
}

inline glm::vec3 CYILayout::GetAdjustedMeasuredSize(const CYISceneNode *pChild)
{
    return pChild->GetMeasuredSize() * pChild->GetScale();
}

inline bool CYILayout::IsLayoutable(const CYISceneNode *pNode)
{
    // Non-visible items are not considered for laying-out
    if (!pNode->IsVisible())
    {
        return false;
    }

    const CYILayoutConfig *pConfig = pNode->GetLayoutConfig(CYISceneNode::LAYOUT_CONFIG_DO_NOT_LAZY_INSTANTIATE);
    if (!pConfig)
    {
        // Nodes without layout objects can be laid out. This is to support applying measurements to scene node outside of layouts.
        return true;
    }

    return pConfig->IsLayoutable();
}

inline const CYILayout::Padding &CYILayout::GetPaddingForChild(const CYISceneNode *pChild) const
{
    const CYILayoutConfig *pConfig = pChild->GetLayoutConfig();
    if (pConfig->IsBackground())
    {
        return Padding::zeroInstance;
    }
    return m_padding;
}

#endif // _YI_LAYOUT_H_