/*
 * Copyright 2001-2009, Stephan Aßmus <superstippi@gmx.de>
 * Copyright 2001-2009, Ingo Weinhold <ingo_weinhold@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT license.
 */


#include "SeparatorView.h"

#include <new>

#include <math.h>
#include <stdio.h>

#include <ControlLook.h>
#include <LayoutUtils.h>
#include <Region.h>


static const float kMinBorderLength = 5.0f;


// TODO: Actually implement alignment support!
// TODO: More testing, especially archiving.


BSeparatorView::BSeparatorView(orientation orientation, border_style border)
	:
	BView(NULL, B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE)
{
	_Init(NULL, NULL, orientation, BAlignment(B_ALIGN_HORIZONTAL_CENTER,
		B_ALIGN_VERTICAL_CENTER), border);
}


BSeparatorView::BSeparatorView(const char* name, const char* label,
	orientation orientation, border_style border, const BAlignment& alignment)
	:
	BView(name, B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE)
{
	_Init(label, NULL, orientation, alignment, border);
}


BSeparatorView::BSeparatorView(const char* name, BView* labelView,
	orientation orientation, border_style border, const BAlignment& alignment)
	:
	BView(name, B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE)
{
	_Init(NULL, labelView, orientation, alignment, border);
}


BSeparatorView::BSeparatorView(const char* label,
	orientation orientation, border_style border, const BAlignment& alignment)
	:
	BView("", B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE)
{
	_Init(label, NULL, orientation, alignment, border);
}


BSeparatorView::BSeparatorView(BView* labelView,
	orientation orientation, border_style border, const BAlignment& alignment)
	:
	BView("", B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE)
{
	_Init(NULL, labelView, orientation, alignment, border);
}


BSeparatorView::BSeparatorView(BMessage* archive)
	:
	BView(archive),
	fLabel(),
	fLabelView(NULL),
	fOrientation(B_HORIZONTAL),
	fAlignment(BAlignment(B_ALIGN_HORIZONTAL_CENTER,
		B_ALIGN_VERTICAL_CENTER)),
	fBorder(B_FANCY_BORDER)
{
	// NULL archives will be caught by BView.

	const char* label;
	if (archive->FindString("_labelview", &label) == B_OK) {
		fLabelView = FindView(label);
	} else if (archive->FindString("_label", &label) == B_OK) {
		fLabel.SetTo(label);
	}

	int32 orientation;
	if (archive->FindInt32("_orientation", &orientation) == B_OK)
		fOrientation = (enum orientation)orientation;

	int32 hAlignment;
	int32 vAlignment;
	if (archive->FindInt32("_halignment", &hAlignment) == B_OK
		&& archive->FindInt32("_valignment", &vAlignment) == B_OK) {
		fAlignment.horizontal = (alignment)hAlignment;
		fAlignment.vertical = (vertical_alignment)vAlignment;
	}

	int32 borderStyle;
	if (archive->FindInt32("_border", &borderStyle) != B_OK)
		fBorder = (border_style)borderStyle;
}


BSeparatorView::~BSeparatorView()
{
}


// #pragma mark - Archiving


BArchivable*
BSeparatorView::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "BSeparatorView"))
		return new (std::nothrow) BSeparatorView(archive);

	return NULL;
}


status_t
BSeparatorView::Archive(BMessage* into, bool deep) const
{
	// TODO: Test this.
	status_t result = BView::Archive(into, deep);
	if (result != B_OK)
		return result;

	if (fLabelView != NULL)
		result = into->AddString("_labelview", fLabelView->Name());
	else
		result = into->AddString("_label", fLabel.String());

	if (result == B_OK)
		result = into->AddInt32("_orientation", fOrientation);

	if (result == B_OK)
		result = into->AddInt32("_halignment", fAlignment.horizontal);

	if (result == B_OK)
		result = into->AddInt32("_valignment", fAlignment.vertical);

	if (result == B_OK)
		result = into->AddInt32("_border", fBorder);

	return result;
}


// #pragma mark -


void
BSeparatorView::Draw(BRect updateRect)
{
	rgb_color bgColor = ui_color(B_PANEL_BACKGROUND_COLOR);
	rgb_color highColor = ui_color(B_PANEL_TEXT_COLOR);

	if (BView* parent = Parent()) {
		if (parent->ViewColor() != B_TRANSPARENT_COLOR) {
			bgColor = parent->ViewColor();
			highColor = parent->HighColor();
		}
	}

	BRect labelBounds;
	if (fLabelView != NULL) {
		labelBounds = fLabelView->Frame();
	} else if (fLabel.CountChars() > 0) {
		labelBounds = _MaxLabelBounds();
		float labelWidth = StringWidth(fLabel.String());
		if (fOrientation == B_HORIZONTAL) {
			switch (fAlignment.horizontal) {
				case B_ALIGN_LEFT:
				default:
					labelBounds.right = labelBounds.left + labelWidth;
					break;

				case B_ALIGN_RIGHT:
					labelBounds.left = labelBounds.right - labelWidth;
					break;

				case B_ALIGN_CENTER:
					labelBounds.left = (labelBounds.left + labelBounds.right
						- labelWidth) / 2;
					labelBounds.right = labelBounds.left + labelWidth;
					break;
			}
		} else {
			switch (fAlignment.vertical) {
				case B_ALIGN_TOP:
				default:
					labelBounds.bottom = labelBounds.top + labelWidth;
					break;

				case B_ALIGN_BOTTOM:
					labelBounds.top = labelBounds.bottom - labelWidth;
					break;

				case B_ALIGN_MIDDLE:
					labelBounds.top = (labelBounds.top + labelBounds.bottom
						- labelWidth) / 2;
					labelBounds.bottom = labelBounds.top + labelWidth;
					break;
			}
		}
	}

	BRect bounds = Bounds();
	BRegion region(bounds);
	if (labelBounds.IsValid()) {
		region.Exclude(labelBounds);
		ConstrainClippingRegion(&region);
	}

	float borderSize = _BorderSize();
	if (borderSize > 0.0f) {
		if (fOrientation == B_HORIZONTAL) {
			bounds.top = floorf((bounds.top + bounds.bottom + 1 - borderSize)
				/ 2);
			bounds.bottom = bounds.top + borderSize - 1;
			region.Exclude(bounds);
			be_control_look->DrawBorder(this, bounds, updateRect, bgColor,
				fBorder, 0, BControlLook::B_TOP_BORDER);
		} else {
			bounds.left = floorf((bounds.left + bounds.right + 1 - borderSize)
				/ 2);
			bounds.right = bounds.left + borderSize - 1;
			region.Exclude(bounds);
			be_control_look->DrawBorder(this, bounds, updateRect, bgColor,
				fBorder, 0, BControlLook::B_LEFT_BORDER);
		}
		if (labelBounds.IsValid())
			region.Include(labelBounds);

		ConstrainClippingRegion(&region);
	}

	SetLowColor(bgColor);
	FillRect(updateRect, B_SOLID_LOW);

	if (fLabel.CountChars() > 0) {
		font_height fontHeight;
		GetFontHeight(&fontHeight);

		SetHighColor(highColor);

		if (fOrientation == B_HORIZONTAL) {
			DrawString(fLabel.String(), BPoint(labelBounds.left,
				labelBounds.top + ceilf(fontHeight.ascent)));
		} else {
			DrawString(fLabel.String(), BPoint(labelBounds.left
				+ ceilf(fontHeight.ascent), labelBounds.bottom));
		}
	}
}


void
BSeparatorView::GetPreferredSize(float* _width, float* _height)
{
	float width = 0.0f;
	float height = 0.0f;

	if (fLabelView != NULL) {
		fLabelView->GetPreferredSize(&width, &height);
	} else if (fLabel.CountChars() > 0) {
		width = StringWidth(fLabel.String());
		font_height fontHeight;
		GetFontHeight(&fontHeight);
		height = ceilf(fontHeight.ascent) + ceilf(fontHeight.descent);
		if (fOrientation == B_VERTICAL) {
			// swap width and height
			float temp = height;
			height = width;
			width = temp;
		}
	}

	float borderSize = _BorderSize();

	// Add some room for the border
	if (fOrientation == B_HORIZONTAL) {
		width += kMinBorderLength * 2.0f;
		height = max_c(height, borderSize - 1.0f);
	} else {
		height += kMinBorderLength * 2.0f;
		width = max_c(width, borderSize - 1.0f);
	}

	if (_width != NULL)
		*_width = width;

	if (_height != NULL)
		*_height = height;
}


BSize
BSeparatorView::MinSize()
{
	BSize size;
	GetPreferredSize(&size.width, &size.height);
	return BLayoutUtils::ComposeSize(ExplicitMinSize(), size);
}


BSize
BSeparatorView::MaxSize()
{
	BSize size(MinSize());
	if (fOrientation == B_HORIZONTAL)
		size.width = B_SIZE_UNLIMITED;
	else
		size.height = B_SIZE_UNLIMITED;

	return BLayoutUtils::ComposeSize(ExplicitMaxSize(), size);
}


BSize
BSeparatorView::PreferredSize()
{
	BSize size;
	GetPreferredSize(&size.width, &size.height);

	return BLayoutUtils::ComposeSize(ExplicitPreferredSize(), size);
}


// #pragma mark -


void
BSeparatorView::SetOrientation(orientation orientation)
{
	if (orientation == fOrientation)
		return;

	fOrientation = orientation;

	BFont font;
	GetFont(&font);
	if (fOrientation == B_VERTICAL)
		font.SetRotation(90.0f);

	SetFont(&font);

	Invalidate();
	InvalidateLayout();
}


void
BSeparatorView::SetAlignment(const BAlignment& aligment)
{
	if (aligment == fAlignment)
		return;

	fAlignment = aligment;

	Invalidate();
	InvalidateLayout();
}


void
BSeparatorView::SetBorderStyle(border_style border)
{
	if (border == fBorder)
		return;

	fBorder = border;

	Invalidate();
}


void
BSeparatorView::SetLabel(const char* label)
{
	if (label == NULL)
		label = "";

	if (fLabel == label)
		return;

	fLabel.SetTo(label);

	Invalidate();
	InvalidateLayout();
}


void
BSeparatorView::SetLabel(BView* view, bool deletePrevious)
{
	if (fLabelView == view)
		return;

	if (fLabelView != NULL) {
		fLabelView->RemoveSelf();
		if (deletePrevious)
			delete fLabelView;
	}

	fLabelView = view;

	if (fLabelView != NULL)
		AddChild(view);
}


status_t
BSeparatorView::Perform(perform_code code, void* data)
{
	return BView::Perform(code, data);
}


// #pragma mark - protected/private


void
BSeparatorView::DoLayout()
{
	BView::DoLayout();

	if (fLabelView == NULL)
		return;

	BRect bounds = _MaxLabelBounds();
	BRect frame = BLayoutUtils::AlignInFrame(bounds, fLabelView->MaxSize(),
		fAlignment);

	fLabelView->MoveTo(frame.LeftTop());
	fLabelView->ResizeTo(frame.Width(), frame.Height());
}


void
BSeparatorView::_Init(const char* label, BView* labelView,
	orientation orientation, BAlignment alignment, border_style border)
{
	fLabel = "";
	fLabelView = NULL;

	fOrientation = B_HORIZONTAL;
	fAlignment = alignment;
	fBorder = border;

	SetFont(be_bold_font);
	SetViewColor(B_TRANSPARENT_32_BIT);

	SetLabel(label);
	SetLabel(labelView, true);
	SetOrientation(orientation);
}


float
BSeparatorView::_BorderSize() const
{
	// TODO: Get these values from the BControlLook class.
	switch (fBorder) {
		case B_PLAIN_BORDER:
			return 1.0f;

		case B_FANCY_BORDER:
			return 2.0f;

		case B_NO_BORDER:
		default:
			return 0.0f;
	}
}


BRect
BSeparatorView::_MaxLabelBounds() const
{
	BRect bounds = Bounds();
	if (fOrientation == B_HORIZONTAL)
		bounds.InsetBy(kMinBorderLength, 0.0f);
	else
		bounds.InsetBy(0.0f, kMinBorderLength);

	return bounds;
}


// #pragma mark - FBC padding


void BSeparatorView::_ReservedSeparatorView1() {}
void BSeparatorView::_ReservedSeparatorView2() {}
void BSeparatorView::_ReservedSeparatorView3() {}
void BSeparatorView::_ReservedSeparatorView4() {}
void BSeparatorView::_ReservedSeparatorView5() {}
void BSeparatorView::_ReservedSeparatorView6() {}
void BSeparatorView::_ReservedSeparatorView7() {}
void BSeparatorView::_ReservedSeparatorView8() {}
void BSeparatorView::_ReservedSeparatorView9() {}
void BSeparatorView::_ReservedSeparatorView10() {}