#ifndef _AVIFILE_ICMINFO_HPP_
#define _AVIFILE_ICMINFO_HPP_
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif
#ifndef _AVIFILE_AVIDEFS_HPP_
#include <avifile/avidefs.hpp>
#endif

class ICMInfo : private ICINFO
{
public:
	enum Flags{Quality=VIDCF_QUALITY,Crunch=VIDCF_CRUNCH,Temporal=VIDCF_TEMPORAL,
						 Draw=VIDCF_DRAW,FastTemporalCompression=VIDCF_FASTTEMPORALC,
						 FastTemporalDecompression=VIDCF_FASTTEMPORALD,
						 CompressFrames=VIDCF_COMPRESSFRAMES};
	ICMInfo(void);
	ICMInfo(const ICMInfo &someICMInfo);
	~ICMInfo();
	ICMInfo &operator=(const ICMInfo &someICMInfo);
	WORD operator==(const ICMInfo &someICMInfo);
  WORD size(void)const;
	DWORD fccType(void)const;
	void fccType(DWORD fccType);
	DWORD fccHandler(void)const;
	void fccHandler(DWORD fccType);
	DWORD flags(void)const;
	void flags(DWORD flags);
	DWORD version(void)const;
	void version(DWORD version);
	DWORD versionICM(void)const;
	void versionICM(DWORD version);
	String name(void)const;
	void name(String name);
	String description(void)const;
	void description(String description);
	String driver(void)const;
	void driver(String driver);
	WORD hasQuality(void)const;
  WORD hasDraw(void)const;
	WORD hasCrunch(void)const;
	WORD hasTemporal(void)const;
	WORD hasFastTemporalCompression(void)const;
	WORD hasFastTemporalDeCompression(void)const;
  WORD hasCompressFrames(void)const;
private:
};

inline
ICMInfo::ICMInfo(void)
{
	ICINFO::dwSize=sizeof(ICINFO);
	fccType(0);
	fccHandler(0);
	flags(0);
	version(0);
	versionICM(0);
	::memset(ICINFO::szName,0,sizeof(ICINFO::szName));
	::memset(ICINFO::szDescription,0,sizeof(ICINFO::szDescription));
  ::memset(ICINFO::szDriver,0,sizeof(ICINFO::szDriver));
}

inline
ICMInfo::ICMInfo(const ICMInfo &someICMInfo)
{
	ICINFO::dwSize=sizeof(ICINFO);
	*this=someICMInfo;
}

inline
ICMInfo::~ICMInfo()
{
}

inline
ICMInfo &ICMInfo::operator=(const ICMInfo &someICMInfo)
{
	fccType(someICMInfo.fccType());
	fccHandler(someICMInfo.fccHandler());
	flags(someICMInfo.flags());
	version(someICMInfo.version());
	versionICM(someICMInfo.versionICM());
	name(someICMInfo.name());
	description(someICMInfo.description());
	driver(someICMInfo.driver());
  return *this;
}

inline
WORD ICMInfo::operator==(const ICMInfo &someICMInfo)
{
	return(fccType()==someICMInfo.fccType()&&
				 fccHandler()==someICMInfo.fccHandler()&&
				 flags()==someICMInfo.flags()&&
				 version()==someICMInfo.version()&&
				 versionICM()==someICMInfo.versionICM()&&
				 name()==someICMInfo.name()&&
				 description()==someICMInfo.name()&&
				 driver()==someICMInfo.driver());
}

inline
DWORD ICMInfo::fccType(void)const
{
	return ICINFO::fccType;
}

inline
void ICMInfo::fccType(DWORD fccType)
{
	ICINFO::fccType=fccType;
}

inline
DWORD ICMInfo::fccHandler(void)const
{
	return ICINFO::fccHandler;
}

inline
void ICMInfo::fccHandler(DWORD fccHandler)
{
	ICINFO::fccHandler=fccHandler;
}

inline
DWORD ICMInfo::flags(void)const
{
	return ICINFO::dwFlags;
}

inline
void ICMInfo::flags(DWORD flags)
{
	ICINFO::dwFlags=flags;
}

inline
DWORD ICMInfo::version(void)const
{
	return ICINFO::dwVersion;
}

inline
void ICMInfo::version(DWORD version)
{
	ICINFO::dwVersion=version;
}

inline
DWORD ICMInfo::versionICM(void)const
{
	return ICINFO::dwVersionICM;
}

inline
void ICMInfo::versionICM(DWORD version)
{
	ICINFO::dwVersionICM=version;
}

inline
String ICMInfo::name(void)const
{
	return String((char*)ICINFO::szName);
}

inline
String ICMInfo::description(void)const
{
	return String((char*)ICINFO::szDescription);
}

inline
String ICMInfo::driver(void)const
{
	return String((char*)ICINFO::szDriver);
}

inline
WORD ICMInfo::size(void)const
{
  return sizeof(ICINFO);
}

inline
WORD ICMInfo::hasQuality(void)const
{
  return flags()&Quality;
}

inline
WORD ICMInfo::hasCrunch(void)const
{
  return flags()&Crunch;
}

inline
WORD ICMInfo::hasDraw(void)const
{
  return flags()&Draw;
}

inline
WORD ICMInfo::hasTemporal(void)const
{
  return flags()&Temporal;
}

inline
WORD ICMInfo::hasFastTemporalCompression(void)const
{
  return flags()&FastTemporalCompression;
}

inline
WORD ICMInfo::hasFastTemporalDeCompression(void)const
{
  return flags()&FastTemporalDecompression;
}

inline
WORD ICMInfo::hasCompressFrames(void)const
{
  return flags()&CompressFrames;
}
#endif