* Copyright 2011, Haiku, Inc.
* All rights reserved. Distributed under the terms of the MIT License.
*/
#include "CollapsingLayouter.h"
#include "ComplexLayouter.h"
#include "OneElementLayouter.h"
#include "SimpleLayouter.h"
#include <ObjectList.h>
#include <Size.h>
class CollapsingLayouter::ProxyLayoutInfo : public LayoutInfo {
public:
ProxyLayoutInfo(LayoutInfo* target, int32 elementCount)
:
fTarget(target),
fElementCount(elementCount)
{
fElements = new int32[elementCount];
}
~ProxyLayoutInfo()
{
delete[] fElements;
delete fTarget;
}
void
LayoutTarget(Layouter* layouter, float size)
{
if (layouter)
layouter->Layout(fTarget, size);
}
void
SetElementPosition(int32 element, int32 position)
{
fElements[element] = position;
}
float
ElementLocation(int32 element)
{
if (element < 0 || element >= fElementCount || fElements[element] < 0)
return 0;
return fTarget->ElementLocation(fElements[element]);
}
float
ElementSize(int32 element)
{
if (element < 0 || element >= fElementCount || fElements[element] < 0)
return 0;
return fTarget->ElementSize(fElements[element]);
}
float
ElementRangeSize(int32 element, int32 length)
{
if (element < 0 || element >= fElementCount || fElements[element] < 0)
return 0;
return fTarget->ElementRangeSize(fElements[element], length);
}
private:
int32* fElements;
LayoutInfo* fTarget;
int32 fElementCount;
};
struct CollapsingLayouter::Constraint {
int32 length;
float min;
float max;
float preferred;
};
struct CollapsingLayouter::ElementInfo {
float weight;
int32 position;
bool valid;
BObjectList<Constraint, true> constraints;
ElementInfo()
:
weight(0),
position(-1),
valid(false),
constraints(5)
{
}
~ElementInfo()
{
}
void SetTo(const ElementInfo& other)
{
weight = other.weight;
position = other.position;
valid = other.valid;
for (int32 i = other.constraints.CountItems() - 1; i >= 0; i--)
constraints.AddItem(new Constraint(*other.constraints.ItemAt(i)));
}
};
CollapsingLayouter::CollapsingLayouter(int32 elementCount, float spacing)
:
fElementCount(elementCount),
fElements(new ElementInfo[elementCount]),
fValidElementCount(0),
fHaveMultiElementConstraints(false),
fSpacing(spacing),
fLayouter(NULL)
{
}
CollapsingLayouter::~CollapsingLayouter()
{
delete[] fElements;
delete fLayouter;
}
void
CollapsingLayouter::AddConstraints(int32 element, int32 length, float min,
float max, float preferred)
{
if (min == B_SIZE_UNSET && max == B_SIZE_UNSET)
return;
if (element < 0 || length <= 0 || element + length > fElementCount)
return;
Constraint* constraint = new Constraint();
constraint->length = length;
constraint->min = min;
constraint->max = max;
constraint->preferred = preferred;
if (length > 1)
fHaveMultiElementConstraints = true;
int32 validElements = fValidElementCount;
for (int32 i = element; i < element + length; i++) {
if (fElements[i].valid == false) {
fElements[i].valid = true;
fValidElementCount++;
}
}
fElements[element].constraints.AddItem(constraint);
if (fValidElementCount > validElements) {
delete fLayouter;
fLayouter = NULL;
}
if (fLayouter)
_AddConstraints(element, constraint);
}
void
CollapsingLayouter::SetWeight(int32 element, float weight)
{
if (element < 0 || element >= fElementCount)
return;
ElementInfo& elementInfo = fElements[element];
elementInfo.weight = weight;
if (fLayouter && elementInfo.position >= 0)
fLayouter->SetWeight(elementInfo.position, weight);
}
float
CollapsingLayouter::MinSize()
{
_ValidateLayouter();
return fLayouter ? fLayouter->MinSize() : 0;
}
float
CollapsingLayouter::MaxSize()
{
_ValidateLayouter();
return fLayouter ? fLayouter->MaxSize() : B_SIZE_UNLIMITED;
}
float
CollapsingLayouter::PreferredSize()
{
_ValidateLayouter();
return fLayouter ? fLayouter->PreferredSize() : 0;
}
LayoutInfo*
CollapsingLayouter::CreateLayoutInfo()
{
_ValidateLayouter();
LayoutInfo* info = fLayouter ? fLayouter->CreateLayoutInfo() : NULL;
return new ProxyLayoutInfo(info, fElementCount);
}
void
CollapsingLayouter::Layout(LayoutInfo* layoutInfo, float size)
{
_ValidateLayouter();
ProxyLayoutInfo* info = static_cast<ProxyLayoutInfo*>(layoutInfo);
for (int32 i = 0; i < fElementCount; i++) {
info->SetElementPosition(i, fElements[i].position);
}
info->LayoutTarget(fLayouter, size);
}
Layouter*
CollapsingLayouter::CloneLayouter()
{
CollapsingLayouter* clone = new CollapsingLayouter(fElementCount, fSpacing);
for (int32 i = 0; i < fElementCount; i++)
clone->fElements[i].SetTo(fElements[i]);
clone->fValidElementCount = fValidElementCount;
clone->fHaveMultiElementConstraints = fHaveMultiElementConstraints;
if (fLayouter)
clone->fLayouter = fLayouter->CloneLayouter();
return clone;
}
void
CollapsingLayouter::_ValidateLayouter()
{
if (fLayouter)
return;
_CreateLayouter();
_DoCollapse();
_AddConstraints();
_SetWeights();
}
Layouter*
CollapsingLayouter::_CreateLayouter()
{
if (fLayouter)
return fLayouter;
if (fValidElementCount == 0) {
fLayouter = NULL;
} else if (fValidElementCount == 1) {
fLayouter = new OneElementLayouter();
} else if (fHaveMultiElementConstraints) {
fLayouter = new ComplexLayouter(fValidElementCount, fSpacing);
} else {
fLayouter = new SimpleLayouter(fValidElementCount, fSpacing);
}
return fLayouter;
}
void
CollapsingLayouter::_DoCollapse()
{
int32 shift = 0;
for (int32 i = 0; i < fElementCount; i++) {
ElementInfo& element = fElements[i];
if (!element.valid) {
shift++;
element.position = -1;
continue;
} else {
element.position = i - shift;
}
}
}
void
CollapsingLayouter::_AddConstraints()
{
if (fLayouter == NULL)
return;
for (int32 i = 0; i < fElementCount; i++) {
ElementInfo& element = fElements[i];
for (int32 i = element.constraints.CountItems() - 1; i >= 0; i--)
_AddConstraints(element.position, element.constraints.ItemAt(i));
}
}
void
CollapsingLayouter::_AddConstraints(int32 position, const Constraint* c)
{
fLayouter->AddConstraints(position, c->length, c->min, c->max,
c->preferred);
}
void
CollapsingLayouter::_SetWeights()
{
if (!fLayouter)
return;
for (int32 i = 0; i < fElementCount; i++) {
fLayouter->SetWeight(fElements[i].position, fElements[i].weight);
}
}
