include/HTMLRenderer/TableLayout.hpp

Go to the documentation of this file.

#ifndef hpp_TableLayout_hpp
#define hpp_TableLayout_hpp

// We need DOM declaration, as we will render a DOM
#include "../HTMLParser/DOM.hpp"
// We need container classes (to be confirmed if it is really needed)
#include "../Containers/Container.hpp"
// We need the box hierarchy model
#include "BoxHierarchy.hpp"

namespace HTML
{
    namespace Renderer
    {
        class TableLayout
        {
            // Types
        public:
            struct Cell
            {
            public:
                enum { NoWidthDeclared = (uint32)-1 };
                uint32      width;
                uint32      horizontalSpan;
                uint32      verticalSpan;

                const void *    userData;

                void *      userData2;
                uint32      minimumWidth;
                uint32      maximumWidth;

                Cell(const uint32 _width = NoWidthDeclared, const uint32 hspan = 1, const uint32 vspan = 1, const void * user = 0) : width(_width), horizontalSpan(hspan), verticalSpan(vspan), userData(user), userData2(0) {}
            };

            struct Row
            {
            public:
                Container::PlainOldData<Cell>::Array    cellArray;
                enum RowType
                {
                    Header   = 0,   
                    Data     = 1,   
                    Footer   = 2,   
                }       rowType;

                // Interface
            public:
                inline Cell & operator[] (const uint32 index) { return cellArray[index]; }

                inline Cell * getCellOnColumn(int32 index) 
                { 
                    if (index > (int32)cellArray.getSize()) return 0;
                    for (uint32 i = 0; index > 0 && i < cellArray.getSize(); i++)
                    {
                        uint32 hspan = cellArray[i].horizontalSpan;
                        if (hspan > (uint32)index) return &cellArray[i];
                        index -=  hspan;
                    }
                    return 0;
                }

                inline const uint32 cellCount() const { return cellArray.getSize(); }
                inline const RowType getRowType() const { return rowType; }

                inline void appendCell(const Cell & cell) { cellArray.Append(cell); }
                inline void ensureSize(const uint32 size, const bool multipleCells = true)    
                {
                    if (size <= cellCount()) return;
                    uint32 nbMissing = size - cellCount();
                    if (multipleCells) while (nbMissing--) appendCell(Cell()); else appendCell(Cell(Cell::NoWidthDeclared, nbMissing));
                }

                Row(const RowType type = Data) : rowType(Data) {}
            };

            struct Column
            {
                enum WidthType 
                { 
                    Fixed       = 1,    
                    Percentage  = 2,    
                    Multiple    = 3,    
                }           widthType;
                uint32      width;
                uint32      span;

                uint32      maximumWidth;
                uint32      minimumWidth;

                Column(const WidthType type = Multiple, const uint32 _width = 1, const uint32 _span = 1) : widthType(type), width(_width), span(_span), maximumWidth(0), minimumWidth(-1) {} 
            };

            typedef Container::WithCopyConstructor<Row>::Array    RowArray;
            typedef Container::WithCopyConstructor<Column>::Array ColumnArray;


            // Members
        private:
            Cell ***        cellMap;
            uint32          cellMapWidth;
            uint32          cellMapHeight;

            RowArray        rowArray;
            ColumnArray     columnArray;

        public:
            uint32          maximumWidth;
            uint32          minimumWidth;

            // Helpers
        private:
            inline const uint32 typedRowCount(const Row::RowType type) const 
            {
                uint32 count = 0;
                for (uint32 i = 0; i < rowArray.getSize(); i++)
                    count += rowArray[i].getRowType() == type;
                return count;
            }
            
            inline void cleanCellMap() 
            {
                if (cellMap) { for (uint32 i = 0; i < cellMapHeight; i++) delete[] cellMap[i]; }
                delete[] cellMap; cellMap = 0;
                cellMapWidth = cellMapHeight = 0;
            }

            inline bool createCellMap()
            {
                cleanCellMap();
                cellMap = new Cell ** [rowArray.getSize()];
                if (!cellMap) return false;
                
                cellMapHeight = rowArray.getSize();
                cellMapWidth  = realColumnCount();
                uint32 i = 0;
                for (; i < cellMapHeight; i++)
                {
                    cellMap[i] = new Cell* [cellMapWidth];
                    if (!cellMap[i]) { cleanCellMap(); return false; }
                    memset(cellMap[i], 0, sizeof(cellMap[i][0]) * cellMapWidth);
                }

                for (i = 0; i < cellMapHeight; i++)
                {
                    Row & row = rowArray[i];
                    uint32 j = 0; uint32 index = 0;
                    while (j < cellMapWidth && index < row.cellCount())
                    {   
                        Cell & cell = row[index++];
                        uint32 z = 0, t = 0;
                        // If some previous row spanned on us, skip them
                        while (cellMap[i][j] && j < cellMapWidth) j+=cellMap[i][j]->horizontalSpan;
                        for (; z < cell.verticalSpan && (i+z) < cellMapHeight; z++)  
                        {   // Fill the grid vertically
                            for (t = 0; t < cell.horizontalSpan && (j+t) < cellMapWidth; t++) 
                            {
                                // Fill horizontally 
                                if (!cellMap[i+z][j+t]) cellMap[i+z][j+t] = &cell;
                            }
                        }

                        j += cell.horizontalSpan;
                    }
                }
                return true;
            }

            // Interface
        public:
            inline Row & operator[](const uint32 index) { return rowArray[index]; } 
            inline const uint32 dataRowCount() const { return typedRowCount(Row::Data); }
            inline const uint32 headerRowCount() const { return typedRowCount(Row::Header); }
            inline const uint32 footerRowCount() const { return typedRowCount(Row::Footer); }
            inline const uint32 rowCount() const { return rowArray.getSize(); }

            inline const uint32 realColumnCount() const 
            {
                uint32 count = 0;
                for (uint32 i = 0; i < columnArray.getSize(); i++) { count += columnArray[i].span; } 
                return count; 
            }

            inline void appendColumn(const Column & col) 
            { 
                columnArray.Append(col); 
//                uint32 columnCount = realColumnCount();
//                for (uint32 i = 0; i < rowArray.getSize(); i++)
//                    rowArray[i].ensureSize(columnCount);
                cleanCellMap();
            }

            inline void appendMultipleColumns(uint32 count, const Column & col) 
            { 
                while (count--) columnArray.Append(col); 
//                uint32 columnCount = realColumnCount();
//                for (uint32 i = 0; i < rowArray.getSize(); i++)
//                    rowArray[i].ensureSize(columnCount);
                cleanCellMap();
            }


            inline void updateRowAt(const uint32 index, const Row & row)
            {
                if (index < rowCount()) { rowArray[index] = row; }
                else if (index == rowCount()) { rowArray.Append(row); cleanCellMap(); }
            }

            inline Column * columnAt(const uint32 index) { if (index < realColumnCount()) return &columnArray[index]; return 0; }
            inline Column & unsafeColumnAt(const uint32 index) { return columnArray[index]; }

            inline Cell * findCell(const void * data, const bool findFirstData = true)
            {
                for (uint32 i = 0; i < rowArray.getSize(); i++)
                {
                    Row & row = rowArray[i];
                    for (uint32 j = 0; j < row.cellCount(); j++)
                    {
                        if ((findFirstData && row[j].userData == data) || (!findFirstData && row[j].userData2 == data) ) return &row[j];
                    }
                }
                return 0;
            }

            inline Cell * findCellAt(const uint32 rowIndex, const uint32 colIndex)
            {
                // Check out-of-bound indexes
                uint32 maxColumnCount = realColumnCount();
                if (rowIndex >= rowArray.getSize() || colIndex >= maxColumnCount) return 0;
                if (!cellMap) 
                    if (!createCellMap()) return 0;
                return cellMap[rowIndex][colIndex];
            }
            
            // Construction and destruction
        public:
            TableLayout() : cellMap(0) {}
            ~TableLayout() { cleanCellMap(); }
        };


    }
}

#endif

(C) An X-Ryl669 project 2007

This document describes Unlimited Zooming Interface source code. UZI stands for Unlimited Zooming Interface, and source code license is