////////////////////////////////////////////////////////////////
// MSDN Magazine -- April 2004
// If this code works, it was written by Paul DiLascia.
// If not, I don't know who wrote it.
// Compiles with Visual Studio .NET on Windows XP. Tab size=3.
//
#include "StdAfx.h"
#include "IMAPITools.h"

//////////////////
// Get supported formats as an array. There are currently only two, so
// why bother wrapping IEnumDiscMasterFormats just for this?
//
int CDiscMaster::GetSupportedFormats(IID* buf, int len)
{
	ULONG nActual=0;
	CComPtr<IEnumDiscMasterFormats> it;
	m_hr = (*this)->EnumDiscMasterFormats(&it);
	if (SUCCEEDED(m_hr))
		m_hr = it->Next(len, buf, &nActual);
	return SUCCEEDED(m_hr) ? nActual : 0;
}

//////////////////
// If CDiscMaster specified in ctor, get default recorder = 1st in enum
//
CDiscRecorder::CDiscRecorder(CDiscMaster& dm)
{
	CDiscRecorderIterator it(dm);
	it.Next(*this);
}

//////////////////
// Get display names for vendor, product and revision
//
BOOL CDiscRecorder::GetDisplayNames(DISPLAYNAMES& dn)
{
	CComBSTR v(256),p(256),r(256);
	m_hr = (*this)->GetDisplayNames(&v,&p,&r);
	TRACEHR(_T("CDiscRecorder::GetDisplayNames"),m_hr);
	if (SUCCEEDED(m_hr)) {
		dn.vendor = v;
		dn.product = p;
		dn.revision = r;
		return TRUE;
	}
	return FALSE;
}

//////////////////
// Helper to get human-readable format name from IID
//
LPCTSTR IMAPITools::GetFormatName(const IID& iid)
{
	if (iid==IID_IRedbookDiscMaster) {
		return _T("Redbook (audio)");
	} else if (iid==IID_IJolietDiscMaster) {
		return _T("Joliet (data)");
	} else if (iid==IID_NULL) {
		return _T("<none>");
	}
	return(_T("unknown"));
}

LPCTSTR IMAPITools::GetRecorderTypeName(long type)
{
	return type==RECORDER_CDR ? _T("RECORDER_CDR") :
		type==RECORDER_CDRW ? _T("RECORDER_CDRW") : _T("");
}

LPCTSTR IMAPITools::GetRecorderStateName(ULONG state)
{
	const struct {
		ULONG state;
		LPCTSTR name;
	} StateNames[] = {
		{RECORDER_DOING_NOTHING,_T("RECORDER_DOING_NOTHING")},
		{RECORDER_OPENED,       _T("RECORDER_OPENED")},
		{RECORDER_BURNING,      _T("RECORDER_BURNING")},
		{0,NULL}
	};
	for (int i=0; StateNames[i].name; i++) {
		if (state==StateNames[i].state)
			return StateNames[i].name;
	}
	static TCHAR buf[16];
	_stprintf(buf,_T("0x%08x"),state);
	return buf;
}

LPCTSTR IMAPITools::GetMediaTypeName(long type)
{
	const struct {
		long type;
		LPCTSTR name;
	} TypeNames[] = {
		{ 0,_T("[empty]") },
		{ MEDIA_CDDA_CDROM,_T("MEDIA_CDDA_CDROM") },
		{ MEDIA_CD_ROM_XA,_T("MEDIA_CD_ROM_XA") },
		{ MEDIA_CD_I,_T("MEDIA_CD_I") },
		{ MEDIA_CD_EXTRA,_T("MEDIA_CD_EXTRA") },
		{ MEDIA_CD_OTHER,_T("MEDIA_CD_OTHER") },
		{ MEDIA_SPECIAL,_T("MEDIA_SPECIAL") },
		{ 0,NULL }
	};
	for (int i=0; TypeNames[i].name; i++) {
		if (type==TypeNames[i].type)
			return TypeNames[i].name;
	}
	static TCHAR buf[16];
	_stprintf(buf,_T("%d"),type);
	return buf;
}

LPCTSTR IMAPITools::GetMediaFlagsName(long flags)
{
	if (flags==0)
		return _T("[empty]");

	const struct {
		long flag;
		LPCTSTR name;
	} FlagNames[] = {
		{ MEDIA_BLANK,_T("MEDIA_BLANK") },
		{ MEDIA_RW,_T("MEDIA_RW") },
		{ MEDIA_WRITABLE,_T("MEDIA_WRITABLE") },
		{ MEDIA_FORMAT_UNUSABLE_BY_IMAPI,_T("MEDIA_FORMAT_UNUSABLE_BY_IMAPI") },
		{ 0,NULL }
	};
	BOOL first = TRUE;
	static TCHAR buf[256]={0};
	for (int i=0; FlagNames[i].name; i++) {
		if (flags & FlagNames[i].flag) {
			if (first)
				first = FALSE;
			else
				_tcscat(buf,_T("|"));
			_tcscat(buf,FlagNames[i].name);
		}
	}
	return buf;
}

//////////////////
// Helper function to get error name from HRESULT.
// These come from imapierror.h.
//
LPCTSTR IMAPITools::GetErrorName(HRESULT hr)
{
	const struct {
		HRESULT hr;
		LPCTSTR name;
	} ImapiErrors[] = {
		{IMAPI_S_PROPERTIESIGNORED,_T("IMAPI_S_PROPERTIESIGNORED")},
		{IMAPI_S_BUFFER_TO_SMALL,_T("IMAPI_S_BUFFER_TO_SMALL")},
		{IMAPI_E_NOTOPENED,_T("IMAPI_E_NOTOPENED")},
		{IMAPI_E_NOTINITIALIZED,_T("IMAPI_E_NOTINITIALIZED")},
		{IMAPI_E_USERABORT,_T("IMAPI_E_USERABORT")},
		{IMAPI_E_GENERIC,_T("IMAPI_E_GENERIC")},
		{IMAPI_E_MEDIUM_NOTPRESENT,_T("IMAPI_E_MEDIUM_NOTPRESENT")},
		{IMAPI_E_MEDIUM_INVALIDTYPE,_T("IMAPI_E_MEDIUM_INVALIDTYPE")},
		{IMAPI_E_DEVICE_NOPROPERTIES,_T("IMAPI_E_DEVICE_NOPROPERTIES")},
		{IMAPI_E_DEVICE_NOTACCESSIBLE,_T("IMAPI_E_DEVICE_NOTACCESSIBLE")},
		{IMAPI_E_DEVICE_NOTPRESENT,_T("IMAPI_E_DEVICE_NOTPRESENT")},
		{IMAPI_E_DEVICE_INVALIDTYPE,_T("IMAPI_E_DEVICE_INVALIDTYPE")},
		{IMAPI_E_INITIALIZE_WRITE,_T("IMAPI_E_INITIALIZE_WRITE")},
		{IMAPI_E_INITIALIZE_ENDWRITE,_T("IMAPI_E_INITIALIZE_ENDWRITE")},
		{IMAPI_E_FILESYSTEM,_T("IMAPI_E_FILESYSTEM")},
		{IMAPI_E_FILEACCESS,_T("IMAPI_E_FILEACCESS")},
		{IMAPI_E_DISCINFO,_T("IMAPI_E_DISCINFO")},
		{IMAPI_E_TRACKNOTOPEN,_T("IMAPI_E_TRACKNOTOPEN")},
		{IMAPI_E_TRACKOPEN,_T("IMAPI_E_TRACKOPEN")},
		{IMAPI_E_DISCFULL,_T("IMAPI_E_DISCFULL")},
		{IMAPI_E_BADJOLIETNAME,_T("IMAPI_E_BADJOLIETNAME")},
		{IMAPI_E_INVALIDIMAGE,_T("IMAPI_E_INVALIDIMAGE")},
		{IMAPI_E_NOACTIVEFORMAT,_T("IMAPI_E_NOACTIVEFORMAT")},
		{IMAPI_E_NOACTIVERECORDER,_T("IMAPI_E_NOACTIVERECORDER")},
		{IMAPI_E_WRONGFORMAT,_T("IMAPI_E_WRONGFORMAT")},
		{IMAPI_E_ALREADYOPEN,_T("IMAPI_E_ALREADYOPEN")},
		{IMAPI_E_WRONGDISC,_T("IMAPI_E_WRONGDISC")},
		{IMAPI_E_FILEEXISTS,_T("IMAPI_E_FILEEXISTS")},
		{IMAPI_E_STASHINUSE,_T("IMAPI_E_STASHINUSE")},
		{IMAPI_E_DEVICE_STILL_IN_USE,_T("IMAPI_E_DEVICE_STILL_IN_USE")},
		{IMAPI_E_LOSS_OF_STREAMING,_T("IMAPI_E_LOSS_OF_STREAMING")},
		{IMAPI_E_COMPRESSEDSTASH,_T("IMAPI_E_COMPRESSEDSTASH")},
		{IMAPI_E_ENCRYPTEDSTASH,_T("IMAPI_E_ENCRYPTEDSTASH")},
		{IMAPI_E_NOTENOUGHDISKFORSTASH,_T("IMAPI_E_NOTENOUGHDISKFORSTASH")},
		{IMAPI_E_REMOVABLESTASH,_T("IMAPI_E_REMOVABLESTASH")},
		{IMAPI_E_CANNOT_WRITE_TO_MEDIA,_T("IMAPI_E_CANNOT_WRITE_TO_MEDIA")},
		{IMAPI_E_TRACK_NOT_BIG_ENOUGH,_T("IMAPI_E_TRACK_NOT_BIG_ENOUGH")},
		{IMAPI_E_BOOTIMAGE_AND_NONBLANK_DISC,_T("IMAPI_E_BOOTIMAGE_AND_NONBLANK_DISC")},
		{0,NULL}
	};
	for (int i=0; ImapiErrors[i].hr; i++) {
		if (hr==ImapiErrors[i].hr)
			return ImapiErrors[i].name;
	}
	static TCHAR buf[16];
	_stprintf(buf,_T("0x%08x"),hr);
	return buf;
}