LayoutArray Class Reference

#include <layoutarray.h>

Public Member Functions
	LayoutArray ()
	~LayoutArray ()
LayoutCell &	at (const int x, const int y, const int w, const int h)
LayoutCell &	place (Widget *const widget, const int x, const int y, const int w, const int h)
void	setColWidth (const int n, const int w)
void	setRowHeight (const int n, const int h)
void	matchColWidth (const int n1, const int n2)
void	extend (const int x, const int y, const int w, const int h)
void	reflow (const int nX, const int nY, const int nW, const int nH)

Private Member Functions
	LayoutArray (LayoutArray const &)
LayoutArray &	operator= (LayoutArray const &)
void	align (int &pos, int &size, const int dim, LayoutCell const &cell, const int *const sizes, const int sizeCount) const
void	resizeGrid (int w, const int h)
std::vector< int >	getSizes (const int dim, int upp) const
int	getSize (const int dim) const

Private Attributes
std::vector< int >	mSizes [2]
std::vector< std::vector< LayoutCell * > >	mCells
int	mSpacing

Friends
class	LayoutCell

Detailed Description

This class contains a rectangular array of cells.

Definition at line 37 of file layoutarray.h.

Constructor & Destructor Documentation

LayoutArray() [1/2]

LayoutArray::LayoutArray

(

)

Definition at line 35 of file layoutarray.cpp.

                         :
    mCells(),
    mSpacing(4)
{
}

~LayoutArray()

LayoutArray::~LayoutArray

(

)

Definition at line 41 of file layoutarray.cpp.

{
    STD_VECTOR <STD_VECTOR <LayoutCell *> >::iterator
        i = mCells.begin();
    const STD_VECTOR <STD_VECTOR <LayoutCell *> >::iterator
        i_end = mCells.end();
    while (i != i_end)
    {
        STD_VECTOR< LayoutCell * >::iterator j = i->begin();
        const STD_VECTOR< LayoutCell * >::iterator j_end = i->end();
        while (j != j_end)
        {
            delete *j;
            ++j;
        }
        ++i;
    }
}

References mCells.

LayoutArray() [2/2]

LayoutArray::LayoutArray ( LayoutArray const &  )

explicitprivate

Member Function Documentation

align()

void LayoutArray::align ( int &  pos, int &  size, const int  dim, LayoutCell const &  cell, const int *const  sizes, const int  sizeCount  ) const

private

Gets the position and size of a widget along a given axis

Definition at line 161 of file layoutarray.cpp.

{
    if (dim < 0 || dim >= 2)
        return;
    int size_max = sizes[0];
    int cnt = cell.mExtent[dim];
    if ((sizeCount != 0) && cell.mExtent[dim] > sizeCount)
        cnt = sizeCount;
 
    for (int i = 1; i < cnt; ++i)
        size_max += sizes[i] + mSpacing;
    size = std::min<int>(cell.mSize[dim], size_max);
 
    switch (cell.mAlign[dim])
    {
        case LayoutCell::LEFT:
            return;
        case LayoutCell::RIGHT:
            pos += size_max - size;
            return;
        case LayoutCell::CENTER:
            pos += (size_max - size) / 2;
            return;
        case LayoutCell::FILL:
            size = size_max;
            return;
        default:
            logger->log1("LayoutArray::align unknown layout");
            return;
    }
}

References LayoutCell::CENTER, LayoutCell::FILL, LayoutCell::LEFT, Logger::log1(), logger, mSpacing, LayoutCell::RIGHT, and EmoteDB::size().

Referenced by reflow().

at()

LayoutCell & LayoutArray::at	(	const int	x,
		const int	y,
		const int	w,
		const int	h
	)

Returns a reference on the cell at given position.

Definition at line 60 of file layoutarray.cpp.

{
    resizeGrid(x + w, y + h);
    LayoutCell *&cell = mCells[CAST_SIZE(y)][static_cast<size_t>(x)];
    if (cell == nullptr)
        cell = new LayoutCell;
    return *cell;
}

References CAST_SIZE, LayoutCell, mCells, resizeGrid(), x, and y.

Referenced by LayoutCell::at(), extend(), and place().

extend()

void LayoutArray::extend	(	const int	x,
		const int	y,
		const int	w,
		const int	h
	)

Spawns a cell over several columns/rows.

Definition at line 122 of file layoutarray.cpp.

{
    LayoutCell &cell = at(x, y, w, h);
    cell.mExtent[0] = w;
    cell.mExtent[1] = h;
}

References at(), LayoutCell::mExtent, x, and y.

Referenced by LayoutCell::extend().

getSize()

int LayoutArray::getSize ( const int  dim ) const

private

Gets the total size along a given axis.

Definition at line 268 of file layoutarray.cpp.

{
    STD_VECTOR<int> sizes = getSizes(dim, LayoutType::DEF);
    int size = 0;
    const int nb = CAST_S32(sizes.size());
    for (int i = 0; i < nb; ++i)
    {
        if (sizes[CAST_SIZE(i)] > LayoutType::DEF)
            size += sizes[CAST_SIZE(i)];
        size += mSpacing;
    }
    return size - mSpacing;
}

References CAST_S32, CAST_SIZE, LayoutType::DEF, getSizes(), mSpacing, and EmoteDB::size().

Referenced by LayoutCell::computeSizes().

getSizes()

std::vector< int > LayoutArray::getSizes ( const int  dim, int  upp  ) const

private

Gets the column/row sizes along a given axis.

Parameters

upp	target size for the array. Ignored if AUTO_DEF.

Definition at line 196 of file layoutarray.cpp.

{
    if (dim < 0 || dim >= 2)
        return mSizes[1];
 
    const int gridW = CAST_S32(mSizes[0].size());
    const int gridH = CAST_S32(mSizes[1].size());
    STD_VECTOR<int> sizes = mSizes[dim];
 
    // Compute minimum sizes.
    for (int gridY = 0; gridY < gridH; ++gridY)
    {
        for (int gridX = 0; gridX < gridW; ++gridX)
        {
            const LayoutCell *const cell = mCells[CAST_SIZE(gridY)]
                [CAST_SIZE(gridX)];
            if ((cell == nullptr) || cell->mType == LayoutCell::NONE)
                continue;
 
            if (cell->mExtent[dim] == 1)
            {
                const int n = (dim == 0 ? gridX : gridY);
                const int s = cell->mSize[dim] + cell->mVPadding * 2;
                if (s > sizes[CAST_SIZE(n)])
                    sizes[CAST_SIZE(n)] = s;
            }
        }
    }
 
    if (upp == LayoutType::DEF)
        return sizes;
 
    // Compute the FILL sizes.
    const int nb = CAST_S32(sizes.size());
    int nbFill = 0;
    for (int i = 0; i < nb; ++i)
    {
        if (mSizes[CAST_SIZE(dim)][static_cast<size_t>(i)]
            <= LayoutType::DEF)
        {
            ++nbFill;
            if (mSizes[CAST_SIZE(dim)][static_cast<size_t>(i)] ==
                LayoutType::SET ||
                sizes[CAST_SIZE(i)] <= LayoutType::DEF)
            {
                sizes[CAST_SIZE(i)] = 0;
            }
        }
        upp -= sizes[CAST_SIZE(i)] + mSpacing;
    }
    upp = upp + mSpacing;
 
    if (nbFill == 0)
        return sizes;
 
    for (int i = 0; i < nb; ++i)
    {
        if (mSizes[CAST_SIZE(dim)][static_cast<size_t>(i)] >
            LayoutType::DEF)
        {
            continue;
        }
 
        const int s = upp / nbFill;
        sizes[CAST_SIZE(i)] += s;
        upp -= s;
        --nbFill;
    }
 
    return sizes;
}

References CAST_S32, CAST_SIZE, LayoutType::DEF, mCells, LayoutCell::mExtent, LayoutCell::mSize, mSizes, mSpacing, LayoutCell::mType, LayoutCell::mVPadding, LayoutCell::NONE, LayoutType::SET, and EmoteDB::size().

Referenced by getSize(), matchColWidth(), and reflow().

matchColWidth()

void LayoutArray::matchColWidth	(	const int	n1,
		const int	n2
	)

Sets the widths of two columns to the maximum of their widths.

Definition at line 112 of file layoutarray.cpp.

{
    resizeGrid(std::max(n1, n2) + 1, 0);
    const STD_VECTOR<int> widths = getSizes(0, LayoutType::DEF);
    const int s = std::max(widths[CAST_SIZE(n1)],
        widths[CAST_SIZE(n2)]);
    mSizes[0][CAST_SIZE(n1)] = s;
    mSizes[0][CAST_SIZE(n2)] = s;
}

References CAST_SIZE, LayoutType::DEF, getSizes(), mSizes, and resizeGrid().

Referenced by LayoutCell::matchColWidth().

operator=()

LayoutArray& LayoutArray::operator= ( LayoutArray const &  )

private

place()

LayoutCell & LayoutArray::place	(	Widget *const	widget,
		const int	x,
		const int	y,
		const int	w,
		const int	h
	)

Places a widget in a given cell.

Parameters

w	number of columns the widget spawns.
h	number of rows the widget spawns.

Note

When w is 1, the width of column x is reset to zero if it was AUTO_DEF. Similarly for h.

Definition at line 129 of file layoutarray.cpp.

{
    LayoutCell &cell = at(x, y, w, h);
    assert(cell.mType == LayoutCell::NONE);
    cell.mType = LayoutCell::WIDGET;
    cell.mWidget = widget;
    if (widget != nullptr)
    {
        cell.mSize[0] = w == 1 ? widget->getWidth() : 0;
        cell.mSize[1] = h == 1 ? widget->getHeight() : 0;
    }
    else
    {
        cell.mSize[0] = 1;
        cell.mSize[1] = 1;
    }
    cell.mExtent[0] = w;
    cell.mExtent[1] = h;
    cell.mHPadding = 0;
    cell.mVPadding = 0;
    cell.mAlign[0] = LayoutCell::FILL;
    cell.mAlign[1] = LayoutCell::FILL;
    int &cs = mSizes[0][CAST_SIZE(x)];
    int &rs = mSizes[1][CAST_SIZE(y)];
    if (cs == LayoutType::DEF && w == 1)
        cs = 0;
    if (rs == LayoutType::DEF && h == 1)
        rs = 0;
    return cell;
}

References at(), CAST_SIZE, LayoutType::DEF, LayoutCell::FILL, Widget::getHeight(), Widget::getWidth(), LayoutCell::mAlign, LayoutCell::mExtent, LayoutCell::mHPadding, LayoutCell::mSize, mSizes, LayoutCell::mType, LayoutCell::mVPadding, LayoutCell::mWidget, LayoutCell::NONE, LayoutCell::WIDGET, x, and y.

Referenced by LayoutCell::place().

reflow()

void LayoutArray::reflow	(	const int	nX,
		const int	nY,
		const int	nW,
		const int	nH
	)

Computes and sets the positions of all the widgets.

Parameters

nW	width of the array, used to resize the AUTO_ columns.
nH	height of the array, used to resize the AUTO_ rows.

Definition at line 282 of file layoutarray.cpp.

{
    const int gridW = CAST_S32(mSizes[0].size());
    const int gridH = CAST_S32(mSizes[1].size());
 
    STD_VECTOR<int> widths  = getSizes(0, nw);
    STD_VECTOR<int> heights = getSizes(1, nh);
 
    const int szW = CAST_S32(widths.size());
    const int szH = CAST_S32(heights.size());
    int y = ny;
    for (int gridY = 0; gridY < gridH; ++gridY)
    {
        int x = nx;
        for (int gridX = 0; gridX < gridW; ++gridX)
        {
            LayoutCell *const cell = mCells[CAST_SIZE(gridY)]
                [CAST_SIZE(gridX)];
            if ((cell != nullptr) && cell->mType != LayoutCell::NONE)
            {
                int dx = x;
                int dy = y;
                int dw = 0;
                int dh = 0;
                align(dx, dw, 0, *cell,
                    &widths[CAST_SIZE(gridX)], szW - gridX);
                align(dy, dh, 1, *cell,
                    &heights[CAST_SIZE(gridY)], szH - gridY);
                cell->reflow(dx, dy, dw, dh);
            }
            x += widths[CAST_SIZE(gridX)] + mSpacing;
        }
        y += heights[CAST_SIZE(gridY)] + mSpacing;
    }
}

References align(), CAST_S32, CAST_SIZE, getSizes(), mCells, mSizes, mSpacing, LayoutCell::mType, LayoutCell::NONE, LayoutCell::reflow(), EmoteDB::size(), x, and y.

Referenced by LayoutCell::reflow().

resizeGrid()

void LayoutArray::resizeGrid ( int  w, const int  h  )

private

Ensures the private vectors are large enough.

Definition at line 70 of file layoutarray.cpp.

{
    const bool extW = (w != 0) && w > CAST_S32(mSizes[0].size());
    const bool extH = (h != 0) && h > CAST_S32(mSizes[1].size());
 
    if (!extW && !extH)
        return;
 
    if (extH)
    {
        mSizes[1].resize(CAST_SIZE(h), LayoutType::DEF);
        mCells.resize(CAST_SIZE(h));
        if (!extW)
            w = CAST_S32(mSizes[0].size());
    }
 
    if (extW)
        mSizes[0].resize(CAST_SIZE(w), LayoutType::DEF);
 
    STD_VECTOR <STD_VECTOR <LayoutCell *> >::iterator
        i = mCells.begin();
    const STD_VECTOR <STD_VECTOR <LayoutCell *> >::iterator
        i_end = mCells.end();
    while (i != i_end)
    {
        i->resize(CAST_SIZE(w), nullptr);
        ++i;
    }
}

References CAST_S32, CAST_SIZE, LayoutType::DEF, mCells, mSizes, and EmoteDB::size().

Referenced by at(), matchColWidth(), setColWidth(), and setRowHeight().

setColWidth()

void LayoutArray::setColWidth	(	const int	n,
		const int	w
	)

Sets the minimum width of a column.

Definition at line 100 of file layoutarray.cpp.

{
    resizeGrid(n + 1, 0);
    mSizes[0U][CAST_SIZE(n)] = w;
}

References CAST_SIZE, mSizes, and resizeGrid().

Referenced by LayoutCell::setColWidth().

setRowHeight()

void LayoutArray::setRowHeight	(	const int	n,
		const int	h
	)

Sets the minimum height of a row.

Definition at line 106 of file layoutarray.cpp.

{
    resizeGrid(0, n + 1);
    mSizes[1][CAST_SIZE(n)] = h;
}

References CAST_SIZE, mSizes, and resizeGrid().

Referenced by LayoutCell::setRowHeight().

Friends And Related Function Documentation

LayoutCell

friend class LayoutCell

friend

Definition at line 39 of file layoutarray.h.

Referenced by at().

Field Documentation

mCells

std::vector< std::vector < LayoutCell * > > LayoutArray::mCells

private

Definition at line 128 of file layoutarray.h.

Referenced by at(), LayoutCell::computeSizes(), getSizes(), reflow(), resizeGrid(), and ~LayoutArray().

mSizes

std::vector<int> LayoutArray::mSizes[2]

private

Definition at line 127 of file layoutarray.h.

Referenced by getSizes(), matchColWidth(), place(), reflow(), resizeGrid(), setColWidth(), and setRowHeight().

mSpacing

int LayoutArray::mSpacing

private

Definition at line 130 of file layoutarray.h.

Referenced by align(), getSize(), getSizes(), and reflow().

---

The documentation for this class was generated from the following files:

• src/gui/widgets/layoutarray.h (986a3bf)
• src/gui/widgets/layoutarray.cpp (986a3bf)