#ifndef _AVIFILE_ICMOPEN_HPP_
#define _AVIFILE_ICMOPEN_HPP_
#ifndef _AVIFILE_AVIDEFS_HPP_
#include <avifile/avidefs.hpp>
#endif

class ICMOpen : private ICOPEN
{
public:
	enum Flags{Compress=ICMODE_COMPRESS,DeCompress=ICMODE_DECOMPRESS,
						 FastDecompress=ICMODE_FASTDECOMPRESS,Query=ICMODE_QUERY,
						 Draw=ICMODE_DRAW};
	ICMOpen(void);
	ICMOpen(const ICMOpen &someICMOpen);
	virtual ~ICMOpen();
	ICMOpen &operator=(const ICMOpen &someICMOpen);
	WORD operator==(const ICMOpen &someICMOpen);
	operator ICOPEN(void);
	DWORD fccType(void)const;
	void fccType(DWORD fccType);
	DWORD fccHandler(void)const;
	void fccHandler(DWORD fccHandler);
	DWORD version(void)const;
	void version(DWORD version);
	Flags flags(void)const;
	void flags(Flags flags);
	DWORD error(void)const;
	void error(DWORD error);
private:
};

inline
ICMOpen::ICMOpen(void)
{
	ICOPEN::dwSize=sizeof(ICOPEN);
	ICOPEN::fccType=0;
	ICOPEN::fccHandler=0;
	ICOPEN::dwVersion=0;
	ICOPEN::dwFlags=0;
	ICOPEN::dwError=0;
}

inline
ICMOpen::ICMOpen(const ICMOpen &someICMOpen)
{
	ICOPEN::dwSize=sizeof(ICOPEN);
	*this=someICMOpen;
}

inline
ICMOpen::~ICMOpen()
{
}

inline
ICMOpen &ICMOpen::operator=(const ICMOpen &someICMOpen)
{
	fccType(someICMOpen.fccType());
	fccHandler(someICMOpen.fccHandler());
	version(someICMOpen.version());
	flags(someICMOpen.flags());
	error(someICMOpen.error());
  return *this;
}

inline
WORD ICMOpen::operator==(const ICMOpen &someICMOpen)
{
	return (fccType()==someICMOpen.fccType()&&
					fccHandler()==someICMOpen.fccHandler()&&
					version()==someICMOpen.version()&&
					flags()==someICMOpen.flags()&&
					error()==someICMOpen.error());
}

inline
ICMOpen::operator ICOPEN(void)
{
	return (ICOPEN&)*this;
}

inline
DWORD ICMOpen::fccType(void)const
{
	return ICOPEN::fccType;
}

inline
void ICMOpen::fccType(DWORD fccType)
{
	ICOPEN::fccType=fccType;
}

inline
DWORD ICMOpen::fccHandler(void)const
{
	return ICOPEN::fccHandler;
}

inline
void ICMOpen::fccHandler(DWORD fccHandler)
{
	ICOPEN::fccHandler=fccHandler;
}

inline
DWORD ICMOpen::version(void)const
{
	return ICOPEN::dwVersion;
}

inline
void ICMOpen::version(DWORD version)
{
	ICOPEN::dwVersion=version;
}

inline
ICMOpen::Flags ICMOpen::flags(void)const
{
	return (Flags)ICOPEN::dwFlags;
}

inline
void ICMOpen::flags(Flags flags)
{
	ICOPEN::dwFlags=(DWORD)flags;
}

inline
DWORD ICMOpen::error(void)const
{
	return ICOPEN::dwError;
}

inline
void ICMOpen::error(DWORD error)
{
	ICOPEN::dwError=error;
}
#endif