haiku.git


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

#include <Application.h>
#include <Box.h>
#include <OS.h>
#include <Screen.h>
#include <Window.h>


static BRect* sFrames = NULL;
static uint32 sNumFrames = 0;


class TestApp : public BApplication {
public:
								TestApp(uint32 numWindows, bool views);
	virtual						~TestApp();

	virtual	void				ReadyToRun();

private:
			void				_CreateFrames(uint32 numWindows);
			int32				_WindowCreator();
			static int32		_ThreadStarter(void* data);

private:
			uint32				fFrameNum;
			BRect				fScreenFrame;
			uint32				fNumWindows;
			uint32				fMaxWindows;
			bool				fTestViews;
};


class TestWindow : public BWindow {
public:
						TestWindow(BRect frame, bool createView);
	virtual				~TestWindow();
};


TestApp::TestApp(uint32 numWindows, bool views)
	:
	BApplication("application/x.vnd-Haiku.window-creation"),
	fScreenFrame(),
	fNumWindows(0),
	fMaxWindows(numWindows),
	fTestViews(views)

{
	fScreenFrame = BScreen().Frame();
	_CreateFrames(numWindows);
}


TestApp::~TestApp()
{
	delete[] sFrames;
}


void
TestApp::ReadyToRun()
{
	thread_id thread = spawn_thread(_ThreadStarter, "Window creator",
		B_NORMAL_PRIORITY, this);
	resume_thread(thread);		
}


void
TestApp::_CreateFrames(uint32 numWindows)
{
	BRect frame(0, 0, 50, 50);
	uint32 numHorizontal = (fScreenFrame.IntegerWidth() + 1)
		/ (frame.IntegerWidth() + 1);
	uint32 numVertical = (fScreenFrame.IntegerHeight() + 1)
		/ (frame.IntegerHeight() + 1);
	sNumFrames = numHorizontal * numVertical;
	sFrames = new BRect[sNumFrames];
	for (uint32 i = 0; i < sNumFrames; i++) {
		sFrames[i] = frame;	
		frame.OffsetBy(50, 0);
		if (!fScreenFrame.Contains(frame))
			frame.OffsetTo(0, frame.bottom + 1);
	}
}


int32
TestApp::_WindowCreator()
{
	bigtime_t startTime = system_time();
	
	while (fNumWindows < fMaxWindows) {
		if (fFrameNum >= sNumFrames)
			fFrameNum = 0;

		BWindow* window = new TestWindow(sFrames[fFrameNum++], fTestViews);
		window->Show();
		fNumWindows++;
	}

	bigtime_t endTime = system_time();
	
	printf("Test completed. %ld windows created in %lld usecs.\n", fNumWindows,
		endTime - startTime);

	PostMessage(B_QUIT_REQUESTED);
	return B_OK;
}


int32
TestApp::_ThreadStarter(void* data)
{
	return static_cast<TestApp*>(data)->_WindowCreator();
}


TestWindow::TestWindow(BRect frame, bool views)
	:
	BWindow(frame, "Test", B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS)
{
	if (views)
		AddChild(new BBox(Bounds())); 
}


TestWindow::~TestWindow()
{
}


int
main(int argc, char** argv)
{
	uint32 numWindows = 10;
	bool testViews = false;
	if (argc > 1)
		numWindows = atoi(argv[1]);

	if (argc > 2) {
		if (!strcmp(argv[2], "views"))
			testViews = true;
	}

	TestApp app(numWindows, testViews);
	app.Run();

	return 0;
}