#ifndef _AVIFILE_AVITHREAD_HPP_
#define _AVIFILE_AVITHREAD_HPP_
#ifndef _THREAD_MESSAGETHREAD_HPP_
#include <thread/mthread.hpp>
#endif

class AVIThread : private MessageThread 
{
public:
	AVIThread(void);
	virtual ~AVIThread();
protected:
	enum AVIMessage{HeaderMessage,StreamMessage,MovieMessage,InfoMessage,UnknownMessage};
	virtual void processHeader(void);
	virtual void streamHeader(void);
	virtual void movieHeader(void);
	virtual void infoHeader(void);
	virtual void unknownHeader(void);
private:
  AVIThread(const AVIThread &someAVIThread);
	AVIThread &operator=(const AVIThread &someAVIThread);
	WORD operator==(const AVIThread &someAVIThread);
	DWORD aviThreadHandler(ThreadMessage &someThreadMessage);
  ThreadCallback<AVIThread> mThreadHandler;
};

AVIThread::AVIThread(void)
: mThreadHandler(this,&AVIThread::aviThreadHandler)
{
	insertHandler(&mThreadHandler);
}

AVIThread::AVIThread(const AVIThread &someAVIThread)
: mThreadHandler(this,&AVIThread::aviThreadHandler)
{
  insertHandler(&mThreadHandler);
}

AVIThread::~AVIThread()
{
	removeHandler(&mThreadHandler);
}

AVIThread &operator=(const AVIThread &/*someAVIThread*/)
{
  return *this;
}

WORD AVIThread::operator==(const AVIThread &/*someAVIThread*/)
{
  return FALSE;
}

DWORD AVIThread::aviThreadHandler(ThreadMessage &someThreadMessage)
{
	switch(someThreadMessage.message())
	{
		case ThreadMessage::TM_CREATE :
			break;
		case ThreadMessage::TM_DESTROY :
			break;
		case ThreadMessage::TM_USER :
			if(HeaderMessage==(AVIMessage)someThreadMessage.userDataOne())processHeader();
			else if(StreamMessage==(AVIMessage)someThreadMessage.userDataOne())streamHeader();
			else if(MovieMessage==(AVIMessage)someThreadMessage.userDataOne())movieHeader();
			else if(InfoMessage==(AVIMessage)someThreadMessage.userDataOne())infoMessge();
			else if(UnknownMessage==(AVIMessage)someThreadMessage.userDataOne())unknownHeader();
      break;
  }
}

void AVIThread::processHeader(void)
{
	return;
}

void AVIThread::streamHeader(void)
{
	return;
}

void AVIThread::movieHeader(void)
{
	return;
}

void AVIThread::infoHeader(void)
{
	return;
}

void AVIThread::unknownHeader(void)
{
  return;
}
#endif