haiku.git

// main.cpp

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

#include <Application.h>
#include <Archivable.h>
#include <Dragger.h>
#include <File.h>
#include <Message.h>
#include <View.h>
#include <Window.h>

static const char* kAppSignature = "application/x.vnd-Haiku.ArchivedView";

class TestView : public BView {

 public:
							TestView(BRect frame, const char* name,
									 uint32 resizeFlags, uint32 flags);

							TestView(BMessage* archive);

	virtual	status_t		Archive(BMessage* into, bool deep = true) const;

	static	BArchivable*	Instantiate(BMessage* archive);

	virtual	void			AttachedToWindow();
	virtual	void			DetachedFromWindow();

	virtual	void			Draw(BRect updateRect);

 private:
			int32			fData;
};


// constructor
TestView::TestView(BRect frame, const char* name,
				   uint32 resizeFlags, uint32 flags)
	: BView(frame, name, resizeFlags, flags),
	  fData(42)
{
	SetViewColor(216, 216, 216);

	BRect r = Bounds();
	r.top = r.bottom - 7;
	r.left = r.right - 7;
	BDragger *dw = new BDragger(r, this, 0);
	AddChild(dw);
}

// constructor
TestView::TestView(BMessage* archive)
	: BView(archive)
{
	if (archive->FindInt32("data", &fData) < B_OK)
		fData = 5;

	printf("data: %ld\n", fData);
}

// AttachedToWindow
void
TestView::AttachedToWindow()
{
}

// DetachedFromWindow
void
TestView::DetachedFromWindow()
{
	BFile file("/tmp/archived_view",
			   B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY);
	status_t err = file.InitCheck();
	if (err != B_OK) {
		printf("error creating file for archiving: %s\n", strerror(err));
		return;
	}
	BMessage archive;
	err = Archive(&archive);
	if (err != B_OK) {
		printf("error archiving: %s\n", strerror(err));
		return;
	}
	err = archive.Flatten(&file);
	if (err != B_OK) {
		printf("error flattening: %s\n", strerror(err));
		return;
	}
}

// Draw
void
TestView::Draw(BRect updateRect)
{
printf("TestView::Draw(");
updateRect.PrintToStream();
	BRect r(Bounds());

	rgb_color light = tint_color(ViewColor(), B_LIGHTEN_2_TINT);
	rgb_color shadow = tint_color(ViewColor(), B_DARKEN_2_TINT);

	BeginLineArray(4);
		AddLine(r.LeftTop(), r.RightTop(), light);
		AddLine(r.RightTop(), r.RightBottom(), shadow);
		AddLine(r.RightBottom(), r.LeftBottom(), shadow);
		AddLine(r.LeftBottom(), r.LeftTop(), light);
	EndLineArray();
}

// Archive
status_t
TestView::Archive(BMessage* into, bool deep) const
{
	status_t ret = BView::Archive(into, deep);

	if (ret == B_OK)
		ret = into->AddInt32("data", fData);

	if (ret == B_OK)
		ret = into->AddString("add_on", kAppSignature);

	if (ret == B_OK)
		ret = into->AddString("class", "TestView");

	return ret;
}

// Instantiate
BArchivable *
TestView::Instantiate(BMessage* archive)
{
	if (!validate_instantiation(archive , "TestView"))
		return NULL;

	return new TestView(archive);
}

// #pragma mark -

// 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 = NULL;
	BFile file("/tmp/archived_view", B_READ_ONLY);
	if (file.InitCheck() == B_OK) {
		printf("found archive file\n");
		BMessage archive;
		if (archive.Unflatten(&file) == B_OK) {
			printf("unflattened archive message\n");
			BArchivable* archivable = instantiate_object(&archive);
			view = dynamic_cast<BView*>(archivable);
			if (view)
				printf("instatiated BView\n");
		}
	}

	if (!view)
		view = new TestView(window->Bounds(), "test", B_FOLLOW_ALL, B_WILL_DRAW);

	window->Show();

	window->Lock();
	window->AddChild(view);
	window->Unlock();
}

// main
int
main(int argc, char** argv)
{
	BApplication* app = new BApplication(kAppSignature);

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

	app->Run();

	delete app;
	return 0;
}