haiku.git

// main.cpp

#include <stdio.h>

#include "Application.h"
#include "Message.h"
#include "Button.h"
#include "View.h"
#include "Window.h"

#define MSG_COPY_BITS 'cbts'

class TestView : public BView {

	enum {
		TRACKING_NONE,
		TRACKING_SOURCE,
		TRACKING_DEST
	};

 public:
					TestView(BRect frame, const char* name,
							  uint32 resizeFlags, uint32 flags)
						: BView(frame, name, resizeFlags, flags),
						  fTracking(TRACKING_NONE),
						  fCopyBitsJustCalled(false)
					{
						fSourceRect.Set(frame.left, frame.top,
									    (frame.left + frame.right) / 2,
									    frame.bottom);
						fDestRect.Set((frame.left + frame.right) / 2,
									  frame.top,
									  frame.right, frame.bottom);
						fSourceRect.InsetBy(10.0, 10.0);
						fDestRect.InsetBy(10.0, 10.0);

						SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
						SetLowUIColor(ViewUIColor());
					}

	virtual	void	MessageReceived(BMessage* message);

	virtual	void	Draw(BRect updateRect);

	virtual	void	MouseDown(BPoint where);
	virtual	void	MouseUp(BPoint where);
	virtual	void	MouseMoved(BPoint where, uint32 transit,
							   const BMessage* dragMessage);

 private:
			void	_TrackMouse(BPoint where);

			BRect	fSourceRect;
			BRect	fDestRect;

			uint32	fTracking;

			bool	fCopyBitsJustCalled;
};

// MessageReceived
void
TestView::MessageReceived(BMessage* message)
{
	if (message->what == MSG_COPY_BITS) {
		printf("MSG_COPY_BITS\n");
		fSourceRect.PrintToStream();
		fDestRect.PrintToStream();
		CopyBits(fSourceRect, fDestRect);
		fCopyBitsJustCalled = true;
	} else
		BView::MessageReceived(message);
}

// Draw
void
TestView::Draw(BRect updateRect)
{
	if (fCopyBitsJustCalled) {
		printf("TestView::Draw(%.1f, %.1f, %.1f, %.1f) after CopyBits()\n",
			   updateRect.left, updateRect.top, updateRect.right, updateRect.bottom);
		fCopyBitsJustCalled = false;
	}

	// background
//	SetHighColor(ui_color(B_PANEL_BACKGROUND_COLOR));
//	FillRect(updateRect);

	BRect r(Bounds());

	// draw some pattern with lines
	float width = r.Width();
	float height = r.Height();
	int32 lineCount = 20;
	SetPenSize(2.0);
	for (int32 i = 0; i < lineCount; i++) {
		SetHighColor(255, (255 / lineCount) * i, 255 - (255 / lineCount) * i);
		StrokeLine(BPoint(r.left + (width / lineCount) * i, r.top),
				   BPoint(r.left, r.top + (height / lineCount) * i));
		StrokeLine(BPoint(r.right - (width / lineCount) * i, r.bottom),
				   BPoint(r.right, r.bottom - (height / lineCount) * i));
	}
	StrokeLine(BPoint(r.left, r.bottom), BPoint(r.right, r.top));

	// source and dest rect
	SetPenSize(1.0);

	SetHighColor(0, 255, 0, 255);
	StrokeRect(fSourceRect);

	SetHighColor(0, 0, 255, 255);
	StrokeRect(fDestRect);

	// text
	SetHighColor(128, 0, 50, 255);

	const char* message = "Left-Click and drag";
	width = StringWidth(message);
	BPoint p(r.left + r.Width() / 2.0 - width / 2.0,
			 r.top + r.Height() / 2.0 - 50.0);

	DrawString(message, p);

	message = "to set source rect!";
	width = StringWidth(message);
	p.x = r.left + r.Width() / 2.0 - width / 2.0;
	p.y += 20;

	DrawString(message, p);

	message = "Right-Click and drag";
	width = StringWidth(message);
	p.x = r.left + r.Width() / 2.0 - width / 2.0;
	p.y += 30.0;

	DrawString(message, p);

	message = "to set destination rect!";
	width = StringWidth(message);
	p.x = r.left + r.Width() / 2.0 - width / 2.0;
	p.y += 20;

	DrawString(message, p);
}

// MouseDown
void
TestView::MouseDown(BPoint where)
{
	BMessage* message = Window()->CurrentMessage();
	uint32 buttons;
	if (message && message->FindInt32("buttons", (int32*)&buttons) >= B_OK) {
		if (buttons & B_PRIMARY_MOUSE_BUTTON) {
			fTracking = TRACKING_SOURCE;
			fSourceRect.left = where.x;
			fSourceRect.top = where.y;
		}
		if (buttons & B_SECONDARY_MOUSE_BUTTON) {
			fTracking = TRACKING_DEST;
			fDestRect.left = where.x;
			fDestRect.top = where.y;
		}
		Invalidate();
		_TrackMouse(where);
	}
}

// MouseUp
void
TestView::MouseUp(BPoint where)
{
	fTracking = TRACKING_NONE;
}

// MouseMoved
void
TestView::MouseMoved(BPoint where, uint32 transit,
					 const BMessage* dragMessage)
{
	if (fTracking > TRACKING_NONE) {
		_TrackMouse(where);
	}
}

float
min4(float a, float b, float c, float d)
{
	return min_c(a, min_c(b, min_c(c, d)));
}

float
max4(float a, float b, float c, float d)
{
	return max_c(a, max_c(b, max_c(c, d)));
}

// _TrackMouse
void
TestView::_TrackMouse(BPoint where)
{
	BRect before;
	BRect after;
	bool invalidate = false;
	switch (fTracking) {
		case TRACKING_SOURCE:
			before = fSourceRect;
			fSourceRect.right = where.x;
			fSourceRect.bottom = where.y;
			after = fSourceRect;
			invalidate = true;
			break;
		case TRACKING_DEST:
			before = fDestRect;
			fDestRect.right = where.x;
			fDestRect.bottom = where.y;
			after = fDestRect;
			invalidate = true;
			break;
	}
	if (invalidate) {
		BRect dirty(min4(before.left, before.right, after.left, after.right),
					min4(before.top, before.bottom, after.top, after.bottom),
					max4(before.left, before.right, after.left, after.right),
					max4(before.top, before.bottom, after.top, after.bottom));
		Invalidate(dirty);
	}
}


// show_window
void
show_window(BRect frame, const char* name)
{
	BWindow* window = new BWindow(frame, name,
								  B_TITLED_WINDOW,
								  B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE);

	BView* view = new TestView(window->Bounds(), "test", B_FOLLOW_ALL,
							   B_WILL_DRAW/* | B_FULL_UPDATE_ON_RESIZE*/);

	window->AddChild(view);
	BRect b(0.0, 0.0, 50.0, 15.0);
	b.OffsetTo(5.0, view->Bounds().bottom - (b.Height() + 15.0));
	BButton* control = new BButton(b, "button", "Copy", new BMessage(MSG_COPY_BITS));
	view->AddChild(control);
	control->SetTarget(view);

	// test CopyBits() on top of children
	b = BRect(80, 130, 130, 160);
	BView* child = new BView(b, "some child", B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, 0);
	child->SetViewColor(255, 0, 0);
	view->AddChild(child);

	b = BRect(136, 127, 158, 140);
	child = new BView(b, "some other child", B_FOLLOW_RIGHT | B_FOLLOW_BOTTOM, 0);
	child->SetViewColor(255, 255, 0);
	view->AddChild(child);

	window->Show();
}

// main
int
main(int argc, char** argv)
{
	BApplication* app = new BApplication("application/x.vnd-Haiku.CopyBits");

	BRect frame(50.0, 50.0, 300.0, 250.0);
	show_window(frame, "CopyBits Test");

	app->Run();

	delete app;
	return 0;
}