/*
* The ManaPlus Client
* Copyright (C) 2007-2009 The Mana World Development Team
* Copyright (C) 2009-2010 The Mana Developers
* Copyright (C) 2011-2014 The ManaPlus Developers
*
* This file is part of The ManaPlus Client.
*
* 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; either version 2 of the License, or
* any later version.
*
* 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, see .
*/
#include "gui/widgets/layout.h"
#include "logger.h"
#include "gui/base/widgets/container.hpp"
#include
#include "debug.h"
ContainerPlacer ContainerPlacer::at(const int x, const int y)
{
return ContainerPlacer(mContainer, &mCell->at(x, y));
}
LayoutCell &ContainerPlacer::operator()
(const int x, const int y, gcn::Widget *const wg, const int w, const int h)
{
mContainer->add(wg);
return mCell->place(wg, x, y, w, h);
}
LayoutCell::~LayoutCell()
{
if (mType == ARRAY)
{
delete mArray;
mArray = nullptr;
}
}
LayoutArray &LayoutCell::getArray()
{
assert(mType != WIDGET);
if (mType == ARRAY)
return *mArray;
mArray = new LayoutArray;
mType = ARRAY;
mExtent[0] = 1;
mExtent[1] = 1;
mHPadding = 0;
mVPadding = 0;
mAlign[0] = FILL;
mAlign[1] = FILL;
return *mArray;
}
void LayoutCell::reflow(int nx, int ny, int nw, int nh)
{
if (mType == NONE)
return;
nx += mHPadding;
ny += mVPadding;
nw -= 2 * mHPadding;
nh -= 2 * mVPadding;
if (mType == ARRAY)
mArray->reflow(nx, ny, nw, nh);
else
mWidget->setDimension(Rectangle(nx, ny, nw, nh));
}
void LayoutCell::computeSizes()
{
if (mType != ARRAY)
return;
std::vector >::const_iterator
i = mArray->mCells.begin();
const std::vector >::const_iterator
i_end = mArray->mCells.end();
while (i != i_end)
{
std::vector ::const_iterator j = i->begin();
while (j != i->end())
{
LayoutCell *const cell = *j;
if (cell && cell->mType == ARRAY)
cell->computeSizes();
++j;
}
++i;
}
mSize[0] = mArray->getSize(0);
mSize[1] = mArray->getSize(1);
}
LayoutArray::LayoutArray():
mCells(),
mSpacing(4)
{
}
LayoutArray::~LayoutArray()
{
std::vector >::iterator
i = mCells.begin();
const std::vector >::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;
}
}
LayoutCell &LayoutArray::at(const int x, const int y,
const int w, const int h)
{
resizeGrid(x + w, y + h);
LayoutCell *&cell = mCells[y][x];
if (!cell)
cell = new LayoutCell;
return *cell;
}
void LayoutArray::resizeGrid(int w, const int h)
{
const bool extW = w && w > static_cast(mSizes[0].size());
const bool extH = h && h > static_cast(mSizes[1].size());
if (!extW && !extH)
return;
if (extH)
{
mSizes[1].resize(h, Layout::AUTO_DEF);
mCells.resize(h);
if (!extW)
w = static_cast(mSizes[0].size());
}
if (extW)
mSizes[0].resize(w, Layout::AUTO_DEF);
std::vector >::iterator
i = mCells.begin();
const std::vector >::iterator
i_end = mCells.end();
while (i != i_end)
{
i->resize(w, nullptr);
++i;
}
}
void LayoutArray::setColWidth(const int n, const int w)
{
resizeGrid(n + 1, 0);
mSizes[0][n] = w;
}
void LayoutArray::setRowHeight(const int n, const int h)
{
resizeGrid(0, n + 1);
mSizes[1][n] = h;
}
void LayoutArray::matchColWidth(const int n1, const int n2)
{
resizeGrid(std::max(n1, n2) + 1, 0);
const std::vector widths = getSizes(0, Layout::AUTO_DEF);
const int s = std::max(widths[n1], widths[n2]);
mSizes[0][n1] = s;
mSizes[0][n2] = s;
}
void LayoutArray::extend(const int x, const int y, const int w, const int h)
{
LayoutCell &cell = at(x, y, w, h);
cell.mExtent[0] = w;
cell.mExtent[1] = h;
}
LayoutCell &LayoutArray::place(gcn::Widget *const widget, const int x,
const int y, const int w, const int h)
{
LayoutCell &cell = at(x, y, w, h);
assert(cell.mType == LayoutCell::NONE);
cell.mType = LayoutCell::WIDGET;
cell.mWidget = widget;
if (widget)
{
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][x], &rs = mSizes[1][y];
if (cs == Layout::AUTO_DEF && w == 1)
cs = 0;
if (rs == Layout::AUTO_DEF && h == 1)
rs = 0;
return cell;
}
void LayoutArray::align(int &restrict pos, int &restrict size, const int dim,
LayoutCell const &restrict cell,
const int *restrict const sizes,
const int sizeCount) const
{
if (dim < 0 || dim >= 2)
return;
int size_max = sizes[0];
int cnt = cell.mExtent[dim];
if (sizeCount && cell.mExtent[dim] > sizeCount)
cnt = sizeCount;
for (int i = 1; i < cnt; ++i)
size_max += sizes[i] + mSpacing;
size = std::min(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;
}
}
std::vector LayoutArray::getSizes(const int dim, int upp) const
{
if (dim < 0 || dim >= 2)
return mSizes[1];
const int gridW = static_cast(mSizes[0].size());
const int gridH = static_cast(mSizes[1].size());
std::vector 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[gridY][gridX];
if (!cell || 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[n])
sizes[n] = s;
}
}
}
if (upp == Layout::AUTO_DEF)
return sizes;
// Compute the FILL sizes.
const int nb = static_cast(sizes.size());
int nbFill = 0;
for (int i = 0; i < nb; ++i)
{
if (mSizes[dim][i] <= Layout::AUTO_DEF)
{
++nbFill;
if (mSizes[dim][i] == Layout::AUTO_SET ||
sizes[i] <= Layout::AUTO_DEF)
{
sizes[i] = 0;
}
}
upp -= sizes[i] + mSpacing;
}
upp = upp + mSpacing;
if (nbFill == 0)
return sizes;
for (int i = 0; i < nb; ++i)
{
if (mSizes[dim][i] > Layout::AUTO_DEF)
continue;
const int s = upp / nbFill;
sizes[i] += s;
upp -= s;
--nbFill;
}
return sizes;
}
int LayoutArray::getSize(const int dim) const
{
std::vector sizes = getSizes(dim, Layout::AUTO_DEF);
int size = 0;
const int nb = static_cast(sizes.size());
for (int i = 0; i < nb; ++i)
{
if (sizes[i] > Layout::AUTO_DEF)
size += sizes[i];
size += mSpacing;
}
return size - mSpacing;
}
void LayoutArray::reflow(const int nx, const int ny,
const int nw, const int nh)
{
const int gridW = static_cast(mSizes[0].size());
const int gridH = static_cast(mSizes[1].size());
std::vector widths = getSizes(0, nw);
std::vector heights = getSizes(1, nh);
const int szW = static_cast(widths.size());
const int szH = static_cast(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[gridY][gridX];
if (cell && cell->mType != LayoutCell::NONE)
{
int dx = x, dy = y, dw = 0, dh = 0;
align(dx, dw, 0, *cell, &widths[gridX], szW - gridX);
align(dy, dh, 1, *cell, &heights[gridY], szH - gridY);
cell->reflow(dx, dy, dw, dh);
}
x += widths[gridX] + mSpacing;
}
y += heights[gridY] + mSpacing;
}
}
Layout::Layout() :
LayoutCell(),
mComputed(false)
{
getArray();
setPadding(6);
}
void Layout::reflow(int &restrict nw, int &restrict nh)
{
if (!mComputed)
{
computeSizes();
mComputed = true;
}
nw = (nw == 0 ? mSize[0] + 2 * mHPadding : nw);
nh = (nh == 0 ? mSize[1] + 2 * mVPadding : nh);
LayoutCell::reflow(0, 0, nw, nh);
}