haiku.git

//--------------------------------------------------------------------
//	
//	ViewLayoutFactory.cpp
//
//	Written by: Owen Smith
//	
//--------------------------------------------------------------------

/*
	Copyright 1999, Be Incorporated.   All Rights Reserved.
	This file may be used under the terms of the Be Sample Code License.
*/

#include "ViewLayoutFactory.h"

#include <Button.h>
#include <CheckBox.h>
#include <TextControl.h>
#include <View.h>
#include <List.h>
#include <algorithm>
#include <assert.h>
#include <stdio.h>

template <class T>
inline T average(const T& x, const T& y)
{
	return (x + y) / 2;
}


//--------------------------------------------------------------------
//	ViewLayoutFactory factory generators

BButton* ViewLayoutFactory::MakeButton(const char* name, const char* label,
	uint32 msgID, BPoint pos, corner posRef)
{
	BRect dummyFrame(0,0,0,0);
	BButton* pButton = new BButton(dummyFrame, name, label, 
		new BMessage(msgID));
	pButton->ResizeToPreferred();
	MoveViewCorner(*pButton, pos, posRef);
	return pButton;
}

BCheckBox* ViewLayoutFactory::MakeCheckBox(const char* name,
	const char* label, uint32 msgID, BPoint pos, corner posRef)
{
	BRect dummyFrame(0,0,0,0);
	BCheckBox* pCheckBox = new BCheckBox(dummyFrame, name, label,
		new BMessage(msgID));
	pCheckBox->ResizeToPreferred();
	MoveViewCorner(*pCheckBox, pos, posRef);
	return pCheckBox;
}

BTextControl* ViewLayoutFactory::MakeTextControl(const char* name,
	const char* label, const char* text, BPoint pos, float controlWidth,
	corner posRef)
{
	// Note: this function is almost identical to the regular
	// BTextControl constructor, but it minimizes the label
	// width and maximizes the field width, instead of divvying
	// them up half-&-half or 2 : 3, and gives the standard
	// flexibility of corner positioning.
	BRect dummyFrame(0,0,0,0);
	BTextControl* pCtrl = new BTextControl(dummyFrame, name, label,
		text, NULL);
	LayoutTextControl(*pCtrl, pos, controlWidth, posRef);
	return pCtrl;
}

void ViewLayoutFactory::LayoutTextControl(BTextControl& control,
	BPoint pos, float controlWidth, corner posRef)
{
	control.ResizeToPreferred();
	BTextView* pTextView = control.TextView();
	float widthExpand = controlWidth;
	widthExpand -= control.Bounds().Width();
	if (widthExpand > 0) {
		control.ResizeBy(widthExpand, 0);
		pTextView->ResizeBy(widthExpand, 0);
	}
	MoveViewCorner(control, pos, posRef);
}



//--------------------------------------------------------------------
//	ViewLayoutFactory implementation member functions

void ViewLayoutFactory::MoveViewCorner(BView& view, BPoint pos, corner posRef)
{
	BRect frame = view.Frame();
	BPoint topLeft;
	switch (posRef) {
	case CORNER_TOPLEFT:
		topLeft = pos;
		break;
	case CORNER_BOTTOMLEFT:
		topLeft.x = pos.x;
		topLeft.y = pos.y - frame.Height();
		break;
	case CORNER_TOPRIGHT:
		topLeft.x = pos.x - frame.Width();
		topLeft.y = pos.y;
		break;
	case CORNER_BOTTOMRIGHT:
		topLeft.x = pos.x - frame.Width();
		topLeft.y = pos.y - frame.Height();
		break;
	}
	
	view.MoveTo(topLeft);			
}

void ViewLayoutFactory::Align(BList& viewList, align_side side,
	float alignLen)
{
	int32 i, len = viewList.CountItems();
	if (len <= 1) {
		return;
	}

	// make sure alignment is recognized
	if ((side != ALIGN_LEFT) && (side != ALIGN_TOP)
		&& (side != ALIGN_RIGHT) && (side != ALIGN_BOTTOM)
		&& (side != ALIGN_HCENTER) && (side != ALIGN_VCENTER))
	{
		return;
	}
	
	// find initial location for placement, based on head item
	BPoint viewLoc;
	BView* pView = reinterpret_cast<BView*>(viewList.ItemAt(0));
	if (! pView) {
		return;
	}
	
	BRect frame = pView->Frame();
	switch (side) {
	case ALIGN_LEFT:
	case ALIGN_TOP:
		viewLoc.Set(frame.left, frame.top);
		break;
	case ALIGN_RIGHT:
		viewLoc.Set(frame.right, frame.top);
		break;
	case ALIGN_BOTTOM:
		viewLoc.Set(frame.left, frame.bottom);
		break;
	case ALIGN_HCENTER:
		viewLoc.Set(frame.left, average(frame.top, frame.bottom));
		break;
	case ALIGN_VCENTER:
		viewLoc.Set(average(frame.left, frame.right), frame.top);
		printf("Aligning along vcenter\nInitial position: ");
		viewLoc.PrintToStream();
		break;
	}

	// align items relative to head item
	for (i=1; i<len; i++) {
		BView* pView = reinterpret_cast<BView*>(viewList.ItemAt(i));
		if (pView) {
			switch (side) {
			case ALIGN_LEFT:
				viewLoc.y += alignLen;
				MoveViewCorner(*pView, viewLoc, CORNER_TOPLEFT);
				break;
			case ALIGN_TOP:
				viewLoc.x += alignLen;
				MoveViewCorner(*pView, viewLoc, CORNER_TOPLEFT);
				break;
			case ALIGN_RIGHT:
				viewLoc.y += alignLen;
				MoveViewCorner(*pView, viewLoc, CORNER_TOPRIGHT);
				break;
			case ALIGN_BOTTOM:
				viewLoc.x += alignLen;
				MoveViewCorner(*pView, viewLoc, CORNER_BOTTOMLEFT);
				break;
			case ALIGN_HCENTER:
				{
					viewLoc.x += alignLen;
					BPoint moveLoc = viewLoc;
					BRect r = pView->Frame();
					moveLoc.y -= (r.bottom - r.top) / 2;
					MoveViewCorner(*pView, moveLoc, CORNER_TOPLEFT);
					break;
				}
			case ALIGN_VCENTER:
				{
					viewLoc.y += alignLen;
					BPoint moveLoc = viewLoc;
					BRect r = pView->Frame();
					moveLoc.x -= (r.right - r.left) / 2;
					MoveViewCorner(*pView, moveLoc, CORNER_TOPLEFT);
					break;
				}
			}
		}
	}
}

void ViewLayoutFactory::ResizeToListMax(BList& viewList, rect_dim resizeDim,
	corner anchor)
{
	int32 i, len = viewList.CountItems();
	float maxWidth = 0.0f, maxHeight = 0.0f;
	float curWidth = 0.0f, curHeight = 0.0f;

	// find maximum dimensions
	for (i=0; i<len; i++) {
		BView* pView = reinterpret_cast<BView*>(viewList.ItemAt(i));
		if (pView) {
			BRect frame = pView->Frame();
			curWidth = frame.Width();
			curHeight = frame.Height();
			if (curWidth > maxWidth) {
				maxWidth = curWidth;
			}
			if (curHeight > maxHeight) {
				maxHeight = curHeight;
			}
		}
	}

	// now resize everything in the list based on selected dimension
	for (i=0; i<len; i++) {
		BView* pView = reinterpret_cast<BView*>(viewList.ItemAt(i));
		if (pView) {
			float newWidth, newHeight;
			BRect frame = pView->Frame();
			newWidth = (resizeDim & RECT_WIDTH)
				? maxWidth : frame.Width();
			newHeight = (resizeDim & RECT_HEIGHT)
				? maxHeight : frame.Height();
			pView->ResizeTo(newWidth, newHeight);
		}
	}
}

void ViewLayoutFactory::ResizeAroundChildren(BView& view, BPoint margin)
{
	float fMax_x = 0.0f, fMax_y = 0.0f;
	int32 numChild = view.CountChildren();
	for (int32 i = 0; i < numChild; i++)
	{
		BView* childView = view.ChildAt(i);
		if (childView) {
			BRect r = childView->Frame();
			fMax_x = std::max(fMax_x, r.right);
			fMax_y = std::max(fMax_y, r.bottom);
		}
	}
	
	fMax_x += margin.x;
	fMax_y += margin.y;
	view.ResizeTo(fMax_x, fMax_y);
}