#ifndef _AVIFILE_AVIMAINHEADER_HPP_
#define _AVIFILE_AVIMAINHEADER_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_FILE_HPP_
#include <common/file.hpp>
#endif
#ifndef _AVIFILE_AVIDEFS_HPP_
#include <avifile/avidefs.hpp>
#endif

class AVIMainHeader : private MainAVIHeader 
{
public:
	AVIMainHeader(void);
	AVIMainHeader(const AVIMainHeader &someAVIMainHeader);
	virtual ~AVIMainHeader();
  bool read(File &inFile);
	bool write(File &outFile);
	AVIMainHeader &operator=(const AVIMainHeader &someAVIMainHeader);
  WORD operator==(const AVIMainHeader &someAVIMainHeader)const;
	DWORD microSecondsPerFrame(void)const;
	void microSecondsPerFrame(DWORD microSecondsPerFrame);
	DWORD maxBytesPerSecond(void)const;
	void maxBytesPerSecond(DWORD maxBytesPerSecond);
  DWORD granularity(void)const;
  void granularity(DWORD granularity);
	DWORD flags(void)const;
	void flags(DWORD flags);
	DWORD totalFrames(void)const;
	void totalFrames(DWORD totalFrames);
	DWORD initialFrames(void)const;
	void initialFrames(DWORD initialFrames);
	DWORD streams(void)const;
	void streams(DWORD streams);
	DWORD suggestedBufferSize(void)const;
	void suggestedBufferSize(DWORD suggestedBufferSize);
	DWORD width(void)const;
	void width(DWORD width);
	DWORD height(void)const;
	void height(DWORD height);
	bool hasIndex(void)const;
	void hasIndex(bool hasIndex);
	bool mustUseIndex(void)const;
	void mustUseIndex(bool mustUseIndex);
	bool isInterleaved(void)const;
	void isInterleaved(bool isInterleaved);
	bool wasCaptureFile(void)const;
	void wasCaptureFile(bool wasCaptureFile);
	bool isCopyrighted(void)const;
	void isCopyrighted(bool isCopyrighted);
	String toString(void)const;
private:
  void setZero(void);
};

inline
AVIMainHeader::AVIMainHeader(void)
{
  setZero();
}

inline
AVIMainHeader::AVIMainHeader(const AVIMainHeader &someAVIMainHeader)
{
	*this=someAVIMainHeader;
}

inline
AVIMainHeader::~AVIMainHeader()
{
}

inline
DWORD AVIMainHeader::microSecondsPerFrame(void)const
{
  return MainAVIHeader::dwMicroSecPerFrame;
}

inline
void AVIMainHeader::microSecondsPerFrame(DWORD msPerFrame)
{
  MainAVIHeader::dwMicroSecPerFrame=msPerFrame;
}

inline
DWORD AVIMainHeader::maxBytesPerSecond(void)const
{
  return MainAVIHeader::dwMaxBytesPerSec;
}

inline
void AVIMainHeader::maxBytesPerSecond(DWORD maxBytesPerSecond)
{
	MainAVIHeader::dwMaxBytesPerSec=maxBytesPerSecond;
}

inline
DWORD AVIMainHeader::granularity(void)const
{
	return MainAVIHeader::dwPaddingGranularity;
}

inline
void AVIMainHeader::granularity(DWORD granularity)
{
	MainAVIHeader::dwPaddingGranularity=granularity;
}

inline
DWORD AVIMainHeader::flags(void)const
{
  return MainAVIHeader::dwFlags;
}

inline
void AVIMainHeader::flags(DWORD flags)
{
  MainAVIHeader::dwFlags=flags;
}

inline
DWORD AVIMainHeader::totalFrames(void)const
{
  return MainAVIHeader::dwTotalFrames;
}

inline
void AVIMainHeader::totalFrames(DWORD totalFrames)
{
  MainAVIHeader::dwTotalFrames=totalFrames;
}

inline
DWORD AVIMainHeader::initialFrames(void)const
{
  return MainAVIHeader::dwInitialFrames;
}

inline
void AVIMainHeader::initialFrames(DWORD initialFrames)
{
  MainAVIHeader::dwInitialFrames=initialFrames;
}

inline
DWORD AVIMainHeader::streams(void)const
{
  return MainAVIHeader::dwStreams;
}

inline
void AVIMainHeader::streams(DWORD streams)
{
  MainAVIHeader::dwStreams=streams;
}

inline
DWORD AVIMainHeader::suggestedBufferSize(void)const
{
  return MainAVIHeader::dwSuggestedBufferSize;
}

inline
void AVIMainHeader::suggestedBufferSize(DWORD suggestedBufferSize)
{
	MainAVIHeader::dwSuggestedBufferSize=suggestedBufferSize;
}

inline
DWORD AVIMainHeader::width(void)const
{
	return MainAVIHeader::dwWidth;
}

inline
void AVIMainHeader::width(DWORD width)
{
	MainAVIHeader::dwWidth=width;
}

inline
DWORD AVIMainHeader::height(void)const
{
  return MainAVIHeader::dwHeight;
}

inline
void AVIMainHeader::height(DWORD height)
{
  MainAVIHeader::dwHeight=height;
}

inline
bool AVIMainHeader::hasIndex(void)const
{
	return (MainAVIHeader::dwFlags&AVIF_HASINDEX);
}

inline
void AVIMainHeader::hasIndex(bool hasIndex)
{
  if(hasIndex)MainAVIHeader::dwFlags|=AVIF_HASINDEX;
	else MainAVIHeader::dwFlags^=AVIF_HASINDEX;
}

inline
bool AVIMainHeader::mustUseIndex(void)const
{
	return (MainAVIHeader::dwFlags&AVIF_MUSTUSEINDEX);
}

inline
void AVIMainHeader::mustUseIndex(bool mustUseIndex)
{
  if(mustUseIndex)MainAVIHeader::dwFlags|=AVIF_MUSTUSEINDEX;
	else MainAVIHeader::dwFlags^=AVIF_MUSTUSEINDEX;
}

inline
bool AVIMainHeader::isInterleaved(void)const
{
	return (MainAVIHeader::dwFlags&AVIF_ISINTERLEAVED);
}

inline
void AVIMainHeader::isInterleaved(bool isInterleaved)
{
  if(isInterleaved)MainAVIHeader::dwFlags|=AVIF_ISINTERLEAVED;
	else MainAVIHeader::dwFlags^=AVIF_ISINTERLEAVED;
}

inline
bool AVIMainHeader::wasCaptureFile(void)const
{
	return (MainAVIHeader::dwFlags&AVIF_WASCAPTUREFILE);
}

inline
void AVIMainHeader::wasCaptureFile(bool wasCaptureFile)
{
  if(wasCaptureFile)MainAVIHeader::dwFlags|=AVIF_WASCAPTUREFILE;
	else MainAVIHeader::dwFlags^=AVIF_WASCAPTUREFILE;
}

inline
bool AVIMainHeader::isCopyrighted(void)const
{
	return (MainAVIHeader::dwFlags&AVIF_COPYRIGHTED);
}

inline
void AVIMainHeader::isCopyrighted(bool isCopyrighted)
{
  if(isCopyrighted)MainAVIHeader::dwFlags|=AVIF_COPYRIGHTED;
	else MainAVIHeader::dwFlags^=AVIF_COPYRIGHTED;
}

inline
void AVIMainHeader::setZero(void)
{
  ::memset(&((MainAVIHeader&)*this),0,sizeof(MainAVIHeader));
}
#endif