haiku.git

/*
 * Copyright 2007, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include <stdio.h>
#include <stdlib.h>

#include <Application.h>
#include <Window.h>

#include "BoxTest.h"
#include "ButtonTest.h"
#include "CheckBox.h"
#include "CheckBoxTest.h"
#include "GroupView.h"
#include "ListViewTest.h"
#include "MenuBarTest.h"
#include "MenuFieldTest.h"
#include "MenuTest.h"
#include "RadioButtonTest.h"
#include "ScrollBarTest.h"
#include "SliderTest.h"
#include "StringView.h"
#include "Test.h"
#include "TextControlTest.h"
#include "TextViewTest.h"
#include "TwoDimensionalSliderView.h"
#include "View.h"
#include "ViewContainer.h"
#include "WrapperView.h"


// internal messages
enum {
	MSG_2D_SLIDER_VALUE_CHANGED		= '2dsv',
	MSG_UNLIMITED_MAX_SIZE_CHANGED	= 'usch',
};


struct test_info {
	const char*	name;
	Test*		(*create)();
};

const test_info kTestInfos[] = {
	{ "BBox",			BoxTest::CreateTest },
	{ "BButton",		ButtonTest::CreateTest },
	{ "BCheckBox",		CheckBoxTest::CreateTest },
	{ "BListView",		ListViewTest::CreateTest },
	{ "BMenu",			MenuTest::CreateTest },
	{ "BMenuBar",		MenuBarTest::CreateTest },
	{ "BMenuField",		MenuFieldTest::CreateTest },
	{ "BRadioButton",	RadioButtonTest::CreateTest },
	{ "BScrollBar",		ScrollBarTest::CreateTest },
	{ "BSlider",		SliderTest::CreateTest },
	{ "BTextControl",	TextControlTest::CreateTest },
	{ "BTextView",		TextViewTest::CreateTest },
	{ NULL, NULL }
};


// helpful operator
BPoint
operator+(const BPoint& p, const BSize& size)
{
	return BPoint(p.x + size.width, p.y + size.height);
}


// TestWindow
class TestWindow : public BWindow {
public:
	TestWindow(Test* test)
		: BWindow(BRect(50, 50, 750, 550), "Widget Layout",
			B_TITLED_WINDOW,
			B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE | B_NOT_RESIZABLE
			| B_NOT_ZOOMABLE),
		  fTest(test)
	{
		fViewContainer = new ViewContainer(Bounds());
		fViewContainer->View::SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
		AddChild(fViewContainer);

		// container view for the tested BView
		BRect rect(10, 10, 400, 400);
		View* view = new View(rect);
		fViewContainer->View::AddChild(view);
		view->SetViewColor((rgb_color){200, 200, 240, 255});

		// container for the test's controls
		fTestControlsView = new View(BRect(410, 10, 690, 400));
		fTestControlsView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
		fViewContainer->View::AddChild(fTestControlsView);

		// wrapper view
		fWrapperView = new WrapperView(fTest->GetView());
		fWrapperView->SetLocation(BPoint(10, 10));
		view->AddChild(fWrapperView);
		fWrapperView->SetSize(fWrapperView->PreferredSize());

		// slider view
		fSliderView = new TwoDimensionalSliderView(
			new BMessage(MSG_2D_SLIDER_VALUE_CHANGED), this);
		fSliderView->SetLocationRange(BPoint(0, 0), BPoint(0, 0));
		view->AddChild(fSliderView);

		_UpdateSliderConstraints();

		// size views
		GroupView* sizeViewsGroup = new GroupView(B_VERTICAL, 6);
		sizeViewsGroup->SetSpacing(0, 8);
		fViewContainer->View::AddChild(sizeViewsGroup);

		// min
		_CreateSizeViews(sizeViewsGroup, "min:  ", fMinWidthView,
			fMinHeightView);

		// max (with checkbox)
		fUnlimitedMaxSizeCheckBox = new LabeledCheckBox("override",
			new BMessage(MSG_UNLIMITED_MAX_SIZE_CHANGED), this);

		_CreateSizeViews(sizeViewsGroup, "max:  ", fMaxWidthView,
			fMaxHeightView, fUnlimitedMaxSizeCheckBox);

		// preferred
		_CreateSizeViews(sizeViewsGroup, "preferred:  ", fPreferredWidthView,
			fPreferredHeightView);

		// current
		_CreateSizeViews(sizeViewsGroup, "current:  ", fCurrentWidthView,
			fCurrentHeightView);

		sizeViewsGroup->SetFrame(BRect(BPoint(rect.left, rect.bottom + 10),
			sizeViewsGroup->PreferredSize()));

		_UpdateSizeViews();

		// activate test
		AddHandler(fTest);
		fTest->ActivateTest(fTestControlsView);
	}

	virtual void DispatchMessage(BMessage* message, BHandler* handler)
	{
		switch (message->what) {
			case B_LAYOUT_WINDOW:
				if (!fWrapperView->GetView()->IsLayoutValid()) {
					_UpdateSliderConstraints();
					_UpdateSizeViews();
				}
				break;
		}

		BWindow::DispatchMessage(message, handler);
	}

	virtual void MessageReceived(BMessage* message)
	{
		switch (message->what) {
			case MSG_2D_SLIDER_VALUE_CHANGED:
			{
				BPoint sliderLocation(fSliderView->Location());
				BPoint wrapperLocation(fWrapperView->Location());
				BSize size(sliderLocation.x - wrapperLocation.x - 1,
					sliderLocation.y - wrapperLocation.y - 1);
				fWrapperView->SetSize(size);
				_UpdateSizeViews();
				break;
			}

			case MSG_UNLIMITED_MAX_SIZE_CHANGED:
				if (fUnlimitedMaxSizeCheckBox->IsSelected())  {
					fWrapperView->GetView()->SetExplicitMaxSize(
						BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
				} else {
					fWrapperView->GetView()->SetExplicitMaxSize(
						BSize(B_SIZE_UNSET, B_SIZE_UNSET));
				}
				break;

			default:
				BWindow::MessageReceived(message);
				break;
		}
	}

private:
	void _UpdateSliderConstraints()
	{
		BPoint wrapperLocation(fWrapperView->Location());
		BSize minWrapperSize(fWrapperView->MinSize());
		BSize maxWrapperSize(fWrapperView->MaxSize());

		BPoint minSliderLocation = wrapperLocation + minWrapperSize
			+ BPoint(1, 1);
		BPoint maxSliderLocation = wrapperLocation + maxWrapperSize
			+ BPoint(1, 1);

		BSize sliderSize(fSliderView->Size());
		BSize parentSize(fSliderView->Parent()->Size());
		if (maxSliderLocation.x + sliderSize.width > parentSize.width)
			maxSliderLocation.x = parentSize.width - sliderSize.width;
		if (maxSliderLocation.y + sliderSize.height > parentSize.height)
			maxSliderLocation.y = parentSize.height - sliderSize.height;

		fSliderView->SetLocationRange(minSliderLocation, maxSliderLocation);
	}

	void _CreateSizeViews(View* group, const char* labelText,
		StringView*& widthView, StringView*& heightView,
		View* additionalView = NULL)
	{
		// label
		StringView* label = new StringView(labelText);
		label->SetAlignment(B_ALIGN_RIGHT);
		group->AddChild(label);

		// width view
		widthView = new StringView("9999999999.9");
		widthView->SetAlignment(B_ALIGN_RIGHT);
		group->AddChild(widthView);
		widthView->SetExplicitMinSize(widthView->PreferredSize());

		// "," label
		StringView* labelView = new StringView(",  ");
		group->AddChild(labelView);

		// height view
		heightView = new StringView("9999999999.9");
		heightView->SetAlignment(B_ALIGN_RIGHT);
		group->AddChild(heightView);
		heightView->SetExplicitMinSize(heightView->PreferredSize());

		// spacing
		group->AddChild(new HStrut(20));

		// glue or unlimited max size check box
		if (additionalView)
			group->AddChild(additionalView);
		else
			group->AddChild(new Glue());
	}

	void _UpdateSizeView(StringView* view, float size)
	{
		char buffer[32];
		if (size < B_SIZE_UNLIMITED) {
			sprintf(buffer, "%.1f", size);
			view->SetString(buffer);
		} else
			view->SetString("unlimited");
	}

	void _UpdateSizeViews(StringView* widthView, StringView* heightView,
		BSize size)
	{
		_UpdateSizeView(widthView, size.width);
		_UpdateSizeView(heightView, size.height);
	}

	void _UpdateSizeViews()
	{
		_UpdateSizeViews(fMinWidthView, fMinHeightView,
			fWrapperView->GetView()->MinSize());
		_UpdateSizeViews(fMaxWidthView, fMaxHeightView,
			fWrapperView->GetView()->MaxSize());
		_UpdateSizeViews(fPreferredWidthView, fPreferredHeightView,
			fWrapperView->GetView()->PreferredSize());
		_UpdateSizeViews(fCurrentWidthView, fCurrentHeightView,
			fWrapperView->GetView()->Frame().Size());
	}

private:
	Test*						fTest;
	ViewContainer*				fViewContainer;
	View*						fTestControlsView;
	WrapperView*				fWrapperView;
	TwoDimensionalSliderView*	fSliderView;
	StringView*					fMinWidthView;
	StringView*					fMinHeightView;
	StringView*					fMaxWidthView;
	StringView*					fMaxHeightView;
	StringView*					fPreferredWidthView;
	StringView*					fPreferredHeightView;
	StringView*					fCurrentWidthView;
	StringView*					fCurrentHeightView;
	LabeledCheckBox*			fUnlimitedMaxSizeCheckBox;
};


static void
print_test_list(bool error)
{
	FILE* out = (error ? stderr : stdout);

	fprintf(out, "available tests:\n");

	for (int32 i = 0; kTestInfos[i].name; i++)
		fprintf(out, "  %s\n", kTestInfos[i].name);
}


int
main(int argc, const char* const* argv)
{
	// get test name
	const char* testName;
	if (argc < 2) {
		fprintf(stderr, "Usage: %s <test name>\n", argv[0]);
		print_test_list(true);
		exit(1);
	}
	testName = argv[1];

	// create app
	BApplication app("application/x-vnd.haiku.widget-layout-test");

	// find and create the test
	Test* test = NULL;
	for (int32 i = 0; kTestInfos[i].name; i++) {
		if (strcmp(testName, kTestInfos[i].name) == 0) {
			test = (kTestInfos[i].create)();
			break;
		}
	}

	if (!test) {
		fprintf(stderr, "Error: Invalid test name: \"%s\"\n", testName);
		print_test_list(true);
		exit(1);
	}

	// show test window
	BWindow* window = new TestWindow(test);
	window->Show();

	app.Run();

	return 0;
}