UTLayoutView.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_LAYOUT_VIEW_H_
#define _UT_LAYOUT_VIEW_H_



//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTView.h"
#include "UTTask.h"
#include "UTMessageDestination.h"


//==================================================================================================
//=== Types and constants
//==================================================================================================

// \cond DOXYGEN_DOCUMENT_NEVER

struct RowOrColumnInfo_t
{
    float min_size;
    float size;
    float after_spacing;
    float start_position;
};

enum layout_vh_align_mode_t
{
    eLVHAM_align_start = 0,
    eLVHAM_center = 1,
    eLVHAM_align_end = 2
};

// \endcond


enum layout_h_align_mode_t
{
    eLHAM_align_left = 0,
    eLHAM_center = 1,
    eLHAM_align_right = 2
};


enum layout_v_align_mode_t
{
    eLVAM_align_top = 0,
    eLVAM_center = 1,
    eLVAM_align_bottom = 2
};

typedef int row_column_set_token_t;


//==================================================================================================
//=== Forward name declarations
//==================================================================================================

// \cond DOXYGEN_DOCUMENT_NEVER

class LayoutViewWeight_t;
class LayoutViewChildInfo_t;
class LayoutViewSameMinSet_t;

// \endcond


//==================================================================================================
class UTGUI_EXPORT LayoutView_t
//==================================================================================================
:   public View_t,
    public Task_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                            LayoutView_t();

    virtual                 ~LayoutView_t();

    void                    AddChild(   View_t* child,
                                        int grid_left,
                                        float left_min_spacing,
                                        int grid_top,
                                        float top_min_spacing,
                                        int grid_right,
                                        float right_min_spacing,
                                        int grid_bottom,
                                        float bottom_min_spacing,
                                        layout_h_align_mode_t h_align_mode = eLHAM_center,
                                        layout_v_align_mode_t v_align_mode = eLVAM_center );

    virtual void            AddChild(takes View_t* child);

    virtual gives View_t*   RemoveChild(View_t* child);

    void                    SetAbsoluteMinMaxSizeBehavior(  float absolute_min_width,
                                                            bool max_width_from_children,
                                                            float absolute_max_width,
                                                            float absolute_min_height,
                                                            bool max_height_from_children,
                                                            float absolute_max_height );

    void                    SetDefaultRowWeight(float row_weight);

    void                    SetDefaultColumnWeight(float column_weight);

    void                    SetRowWeight( int row_index, float row_weight );

    void                    SetColumnWeight( int column_index, float column_weight );

    void                    RemoveRowWeight(int row_index );

    void                    RemoveColumnWeight(int row_index );

    row_column_set_token_t  SetRowsUseSameMinHeight( int first_row_index, ... );

    row_column_set_token_t  SetRowsUseSameMinHeight( const int* row_indices, int num_row_indices );

    row_column_set_token_t  SetColumnsUseSameMinWidth( int first_column_index, ... );

    row_column_set_token_t  SetColumnsUseSameMinWidth(  const int* column_indices,
                                                        int num_column_indices );

    void                    RemoveRowsUseSameMinHeight( int first_row_index, ... );

    void                    RemoveColumnsUseSameMinWidth( int first_column_index, ... );

    void                    RemoveRowsUseSameMinHeight(row_column_set_token_t token);

    void                    RemoveColumnsUseSameMinWidth(row_column_set_token_t token);

    inline int              CountRows() const;

    inline float            RowHeight(int index) const;

    inline float            RowTop(int index) const;

    inline int              CountColumns() const;

    inline float            ColumnWidth(int index) const;

    inline float            ColumnLeft(int index) const;

    //----------------------------------------------------------------------------------------------
    protected:
    //----------------------------------------------------------------------------------------------
    virtual void            LBoundsChanged( const Rect_t& old_lbounds,
                                            const Rect_t& new_lbounds );

    virtual void            ChildMinMaxSizeChanged(View_t* child);

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    int                     ExtractRowColumnSameMinSet( int* stack_buffer,
                                                        int** indices,
                                                        int first_index,
                                                        va_list args );
    row_column_set_token_t  UniqueSameMinSetToken(OwnedLinkedList_t<LayoutViewSameMinSet_t>* sets);
    void                    RelayoutAsync();
    void                    RelayoutNow(bool size_decrease_allowed);
    void                    RelayoutNow( bool size_decrease_allowed, int recursion_depth );
    void                    CalculateGridSize();
    void                    SetupGridRowColumnBufs( byte* stack_buffer_grid,
                                                    int stack_buffer_grid_size );
    float                   CalculateRowWeight(int index);
    float                   CalculateColumnWeight(int index);
    void                    CollectFirstPassInfo();
    static void             ApplySameMinSizeRules(
                                            const OwnedLinkedList_t<LayoutViewSameMinSet_t>& rules,
                                            RowOrColumnInfo_t* states,
                                            int num_states );

    float                   CollectAllMultiColumnMinViewSizes(
                                            RowOrColumnInfo_t* states,
                                            int num_states,
                                            const OwnedLinkedList_t<LayoutViewSameMinSet_t>& rules,
                                            int orientation );
    void                    AddMultiColumnViewMinSize(  LayoutViewChildInfo_t* child,
                                                        RowOrColumnInfo_t* states,
                                                        int add_total_pixels,
                                                        int grid_start,
                                                        int grid_end,
                                                        int orientation );

    float                   CalculateMaxSize(   RowOrColumnInfo_t* states,
                                                int num_states,
                                                int orientation );
    float                   CalculatePixelsToAddForMaxSizeIteration(    RowOrColumnInfo_t* states,
                                                                        int num_states,
                                                                        int orientation );
    float                   CalculateChildViewPixelsToAddForMaxSize(
                                                                LayoutViewChildInfo_t* child_info,
                                                                RowOrColumnInfo_t* states,
                                                                int orientation,
                                                                int* child_grid_end );
    void                    DistributePixelsToStates(   float add_pixels,
                                                        RowOrColumnInfo_t* states,
                                                        int num_states,
                                                        int orientation );

    void                    ApplyMinMaxSizesIfNeeded(bool size_decrease_allowed);
    void                    InvalidateSkipRelayoutInfo();
    void                    FinishLVMinMaxSizeCalculations();

    void                    ApplyCurrentSize(int recursion_depth);
    void                    CalculateStartPositions(    float before_spacing,
                                                        RowOrColumnInfo_t* states,
                                                        int num_states );

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    float                                       m_absolute_min_width;
    float                                       m_absolute_max_width;
    float                                       m_absolute_min_height;
    float                                       m_absolute_max_height;

    bool                                        m_max_width_from_children;
    bool                                        m_max_height_from_children;

    float                                       m_unspecified_row_weight;
    OwnedBTree_t< LayoutViewWeight_t, int >     m_row_weights;
    float                                       m_unspecified_column_weight;
    OwnedBTree_t< LayoutViewWeight_t, int >     m_column_weights;
    OwnedLinkedList_t<LayoutViewSameMinSet_t>   m_row_same_min_sets;
    OwnedLinkedList_t<LayoutViewSameMinSet_t>   m_column_same_min_sets;
    row_column_set_token_t                      m_next_same_min_set_token;
    OwnedLinkedList_t<LayoutViewChildInfo_t>    m_children_info;
    BTree_t< LayoutViewChildInfo_t, View_t* >   m_children_info_by_view;

    // Persistent layout state information
    RowOrColumnInfo_t*                          m_rows;
    int                                         m_num_rows;
    int                                         m_num_allocated_row_infos;
    RowOrColumnInfo_t*                          m_columns;
    int                                         m_num_columns;
    int                                         m_num_allocated_column_infos;

    bool                                        m_max_width_from_children_applies;
    bool                                        m_max_height_from_children_applies;
    Rect_t                                      m_skip_relayout_old_lbounds;
    Rect_t                                      m_skip_relayout_new_lbounds;
    float                                       m_skip_relayout_lv_min_width;
    float                                       m_skip_relayout_lv_max_width;
    float                                       m_skip_relayout_lv_min_height;
    float                                       m_skip_relayout_lv_max_height;

    // Temporary relayout state information
    bool                                        m_async_relayout_queued;
    int                                         m_relayout_recursion_depth;
    LayoutViewChildInfo_t**                     m_grid;
    int                                         m_grid_allocated_size_bytes;
    void*                                       m_free_grid;
    float                                       m_left_spacing;
    float                                       m_top_spacing;
    float                                       m_lv_min_width;
    float                                       m_lv_max_width;
    float                                       m_lv_min_height;
    float                                       m_lv_max_height;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void RelayoutReceived(const Message_t* message);
    MessageReceiver_t< LayoutView_t, Message_t > m_RelayoutReceiver;
};


// \cond DOXYGEN_DOCUMENT_NEVER


//==================================================================================================
class LayoutViewWeight_t
//==================================================================================================
: public BTreeNode_t< LayoutViewWeight_t, int >
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline      LayoutViewWeight_t( int row_column_index, float weight );

    inline int  Compare(int other_index) const;
    inline      operator int() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    int     m_row_column_index;
    float   m_weight;

    friend class LayoutView_t;
};


//==================================================================================================
struct VorHLayoutChildInfo_t
//==================================================================================================
{
    int                     grid_start;
    int                     grid_end;
    float                   before_spacing;
    float                   after_spacing;
    layout_vh_align_mode_t  align_mode;
};


//==================================================================================================
class LayoutViewChildInfo_t
//==================================================================================================
:   public LinkedListNode_t<LayoutViewChildInfo_t>,
    public BTreeNode_t< LayoutViewChildInfo_t, View_t* >
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                  LayoutViewChildInfo_t(  View_t* view,
                                                    int grid_left,
                                                    float left_min_spacing,
                                                    int grid_top,
                                                    float top_min_spacing,
                                                    int grid_right,
                                                    float right_min_spacing,
                                                    int grid_bottom,
                                                    float bottom_min_spacing,
                                                    layout_h_align_mode_t h_align_mode,
                                                    layout_v_align_mode_t v_align_mode );

    inline int              Compare(View_t* other_view) const;
    inline                  operator View_t*() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    View_t*                 m_view;
    VorHLayoutChildInfo_t   m_vh_info[2];
                                #define cLVHI_h 0
                                #define cLVHI_v 1

    friend class LayoutView_t;
};


//==================================================================================================
class LayoutViewSameMinSet_t
//==================================================================================================
: public LinkedListNode_t<LayoutViewSameMinSet_t>
{
    public:
                            LayoutViewSameMinSet_t( row_column_set_token_t token,
                                                    const int* indices,
                                                    int num_indices );
                            ~LayoutViewSameMinSet_t();

    bool                    Matches( const int* other_indices, int other_num_indices );

    row_column_set_token_t  token;
    int*                    indices;
    int                     num_indices;

    friend class LayoutView_t;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class LayoutView_t
//===
//==================================================================================================
//==================================================================================================
inline int
LayoutView_t::CountRows() const
{
    return m_num_rows;
}


inline float
LayoutView_t::RowHeight(int index) const
{
    assert(index < m_num_rows);
    return m_rows[index].size;
}


inline float
LayoutView_t::RowTop(int index) const
{
    assert(index < m_num_rows);
    return m_rows[index].start_position;
}


inline int
LayoutView_t::CountColumns() const
{
    return m_num_columns;
}


inline float
LayoutView_t::ColumnWidth(int index) const
{
    assert(index < m_num_columns);
    return m_columns[index].size;
}


inline float
LayoutView_t::ColumnLeft(int index) const
{
    assert(index < m_num_columns);
    return m_columns[index].start_position;
}


inline
LayoutViewWeight_t::LayoutViewWeight_t( int row_column_index, float weight )
{
    m_row_column_index = row_column_index;
    m_weight = weight;
}


inline int
LayoutViewWeight_t::Compare(int other_index) const
{
    return m_row_column_index - other_index;
}


inline
LayoutViewWeight_t::operator int() const
{
    return m_row_column_index;
}


inline
LayoutViewChildInfo_t::LayoutViewChildInfo_t(   View_t* view,
                                                int grid_left,
                                                float left_min_spacing,
                                                int grid_top,
                                                float top_min_spacing,
                                                int grid_right,
                                                float right_min_spacing,
                                                int grid_bottom,
                                                float bottom_min_spacing,
                                                layout_h_align_mode_t h_align_mode,
                                                layout_v_align_mode_t v_align_mode )
{
    m_view = view;

    m_vh_info[cLVHI_h].grid_start = grid_left;
    m_vh_info[cLVHI_h].grid_end = grid_right;
    m_vh_info[cLVHI_h].before_spacing = left_min_spacing;
    m_vh_info[cLVHI_h].after_spacing = right_min_spacing;
    m_vh_info[cLVHI_h].align_mode = static_cast<layout_vh_align_mode_t>(h_align_mode);

    m_vh_info[cLVHI_v].grid_start = grid_top;
    m_vh_info[cLVHI_v].grid_end = grid_bottom;
    m_vh_info[cLVHI_v].before_spacing = top_min_spacing;
    m_vh_info[cLVHI_v].after_spacing = bottom_min_spacing;
    m_vh_info[cLVHI_v].align_mode = static_cast<layout_vh_align_mode_t>(v_align_mode);
}


inline int
LayoutViewChildInfo_t::Compare(View_t* other_view) const
{
    if(m_view < other_view)
        return -1;
    else if(m_view > other_view)
        return 1;
    else
        return 0;
}


inline
LayoutViewChildInfo_t::operator View_t*() const
{
    return m_view;
}


// \endcond

#endif // _UT_LAYOUT_VIEW_H_