haiku.git

/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <ViewPort.h>

#include <algorithm>

#include <AbstractLayout.h>
#include <ScrollBar.h>

#include "ViewLayoutItem.h"


namespace BPrivate {


// #pragma mark - ViewPortLayout


class BViewPort::ViewPortLayout : public BAbstractLayout {
public:
	ViewPortLayout(BViewPort* viewPort)
		:
		BAbstractLayout(),
		fViewPort(viewPort),
		fHasViewChild(false),
		fIsCacheValid(false),
		fMin(),
		fMax(),
		fPreferred()
	{
	}

	BView* ChildView() const
	{
		if (!fHasViewChild)
			return NULL;
		if (BViewLayoutItem* item = dynamic_cast<BViewLayoutItem*>(ItemAt(0)))
			return item->View();
		return NULL;
	}

	void SetChildView(BView* view)
	{
		_UnsetChild();

		if (view != NULL && AddView(0, view) != NULL)
			fHasViewChild = true;
	}

	BLayoutItem* ChildItem() const
	{
		return ItemAt(0);
	}

	void SetChildItem(BLayoutItem* item)
	{
		_UnsetChild();

		if (item != NULL)
			AddItem(0, item);
	}

	virtual BSize BaseMinSize()
	{
		_ValidateMinMax();
		return fMin;
	}

	virtual BSize BaseMaxSize()
	{
		_ValidateMinMax();
		return fMax;
	}

	virtual BSize BasePreferredSize()
	{
		_ValidateMinMax();
		return fPreferred;
	}

	virtual BAlignment BaseAlignment()
	{
		return BAbstractLayout::BaseAlignment();
	}

	virtual bool HasHeightForWidth()
	{
		_ValidateMinMax();
		return false;
		// TODO: Support height-for-width!
	}

	virtual void GetHeightForWidth(float width, float* min, float* max,
		float* preferred)
	{
		if (!HasHeightForWidth())
			return;

		// TODO: Support height-for-width!
	}

	virtual void LayoutInvalidated(bool children)
	{
		fIsCacheValid = false;
	}

	virtual void DoLayout()
	{
		_ValidateMinMax();

		BLayoutItem* child = ItemAt(0);
		if (child == NULL)
			return;

		// Determine the layout area: LayoutArea() will only give us the size
		// of the view port's frame.
		BSize viewSize = LayoutArea().Size();
		BSize layoutSize = viewSize;

		BSize childMin = child->MinSize();
		BSize childMax = child->MaxSize();

		// apply the maximum constraints
		layoutSize.width = std::min(layoutSize.width, childMax.width);
		layoutSize.height = std::min(layoutSize.height, childMax.height);

		// apply the minimum constraints
		layoutSize.width = std::max(layoutSize.width, childMin.width);
		layoutSize.height = std::max(layoutSize.height, childMin.height);

		// TODO: Support height-for-width!

		child->AlignInFrame(BRect(BPoint(0, 0), layoutSize));

		_UpdateScrollBar(fViewPort->ScrollBar(B_HORIZONTAL), viewSize.width,
			layoutSize.width);
		_UpdateScrollBar(fViewPort->ScrollBar(B_VERTICAL), viewSize.height,
			layoutSize.height);
	}

private:
	void _UnsetChild()
	{
		if (CountItems() > 0) {
			BLayoutItem* item = RemoveItem((int32)0);
			if (fHasViewChild)
				delete item;
			fHasViewChild = false;
		}
	}

	void _ValidateMinMax()
	{
		if (fIsCacheValid)
			return;

		if (BLayoutItem* child = ItemAt(0)) {
			fMin = child->MinSize();
			if (_IsHorizontallyScrollable())
				fMin.width = -1;
			if (_IsVerticallyScrollable())
				fMin.height = -1;
			fMax = child->MaxSize();
			fPreferred = child->PreferredSize();
			// TODO: Support height-for-width!
		} else {
			fMin.Set(-1, -1);
			fMax.Set(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED);
			fPreferred.Set(20, 20);
		}

		fIsCacheValid = true;
	}

	bool _IsHorizontallyScrollable() const
	{
		return fViewPort->ScrollBar(B_HORIZONTAL) != NULL;
	}

	bool _IsVerticallyScrollable() const
	{
		return fViewPort->ScrollBar(B_VERTICAL) != NULL;
	}

	void _UpdateScrollBar(BScrollBar* scrollBar, float viewPortSize,
		float dataSize)
	{
		if (scrollBar == NULL)
			return;

		if (viewPortSize < dataSize) {
			scrollBar->SetRange(0, dataSize - viewPortSize);
			scrollBar->SetProportion(viewPortSize / dataSize);
			float smallStep;
			scrollBar->GetSteps(&smallStep, NULL);
			scrollBar->SetSteps(smallStep, viewPortSize);
		} else {
			scrollBar->SetRange(0, 0);
			scrollBar->SetProportion(1);
		}
	}

private:
	BViewPort*	fViewPort;
	bool		fHasViewChild;
	bool		fIsCacheValid;
	BSize		fMin;
	BSize		fMax;
	BSize		fPreferred;
};


// #pragma mark - BViewPort


BViewPort::BViewPort(BView* child)
	:
	BView(NULL, 0),
	fChild(NULL)
{
	_Init();
	SetChildView(child);
}


BViewPort::BViewPort(BLayoutItem* child)
	:
	BView(NULL, 0),
	fChild(NULL)
{
	_Init();
	SetChildItem(child);
}


BViewPort::BViewPort(const char* name, BView* child)
	:
	BView(name, 0),
	fChild(NULL)
{
	_Init();
	SetChildView(child);
}


BViewPort::BViewPort(const char* name, BLayoutItem* child)
	:
	BView(name, 0),
	fChild(NULL)
{
	_Init();
	SetChildItem(child);
}


BViewPort::~BViewPort()
{
}


BView*
BViewPort::ChildView() const
{
	return fLayout->ChildView();
}


void
BViewPort::SetChildView(BView* child)
{
	fLayout->SetChildView(child);
	InvalidateLayout();
}


BLayoutItem*
BViewPort::ChildItem() const
{
	return fLayout->ChildItem();
}


void
BViewPort::SetChildItem(BLayoutItem* child)
{
	fLayout->SetChildItem(child);
	InvalidateLayout();
}


void
BViewPort::_Init()
{
	fLayout = new ViewPortLayout(this);
	SetLayout(fLayout);
}


}	// namespace BPrivate


using ::BPrivate::BViewPort;