haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "AbstractModelLoader.h"

#include <AutoLocker.h>

#include "MessageCodes.h"


AbstractModelLoader::AbstractModelLoader(const BMessenger& target,
	void* targetCookie)
	:
	fLock("main model loader"),
	fTarget(target),
	fTargetCookie(targetCookie),
	fLoaderThread(-1),
	fLoading(false),
	fAborted(false)
{
}


AbstractModelLoader::~AbstractModelLoader()
{
}


status_t
AbstractModelLoader::StartLoading()
{
	// check initialization
	status_t error = fLock.InitCheck();
	if (error != B_OK)
		return error;

	AutoLocker<BLocker> locker(fLock);

	if (fLoading)
		return B_BAD_VALUE;

	// prepare for loading
	error = PrepareForLoading();
	if (error != B_OK)
		return error;

	// spawn the loader thread
	fLoaderThread = spawn_thread(&_LoaderEntry, "model loader",
		B_NORMAL_PRIORITY, this);
	if (fLoaderThread < 0)
		return fLoaderThread;

	fLoading = true;
	fAborted = false;

	resume_thread(fLoaderThread);

	return B_OK;
}


void
AbstractModelLoader::Abort(bool wait)
{
	AutoLocker<BLocker> locker(fLock);

	if (fLoaderThread < 0)
		return;

	thread_id thread = fLoaderThread;

	if (fLoading)
		fAborted = true;

	locker.Unlock();

	if (wait)
		wait_for_thread(thread, NULL);
}


void
AbstractModelLoader::Delete()
{
	Abort(true);
	delete this;
}


/*!	Called from StartLoading() with the lock held.
*/
status_t
AbstractModelLoader::PrepareForLoading()
{
	return B_OK;
}


status_t
AbstractModelLoader::Load()
{
	return B_OK;
}


/*!	Called after loading Load() is done with the lock held.
*/
void
AbstractModelLoader::FinishLoading(bool success)
{
}


void
AbstractModelLoader::NotifyTarget(bool success)
{
	BMessage message(success
		? MSG_MODEL_LOADED_SUCCESSFULLY
		: fAborted ? MSG_MODEL_LOADED_ABORTED : MSG_MODEL_LOADED_FAILED);

	message.AddPointer("loader", this);
	message.AddPointer("targetCookie", fTargetCookie);
	fTarget.SendMessage(&message);
}


/*static*/ status_t
AbstractModelLoader::_LoaderEntry(void* data)
{
	return ((AbstractModelLoader*)data)->_Loader();
}


status_t
AbstractModelLoader::_Loader()
{
	bool success = Load() == B_OK;

	// clean up and notify the target
	AutoLocker<BLocker> locker(fLock);

	FinishLoading(success);
	NotifyTarget(success);
	fLoading = false;

	return B_OK;

}