Slnkdwf/SlnkDWFCom/ImageConvert.cpp

// ImageConvert.cpp : Implementation of CImageConvert

#include "stdafx.h"
#include "ImageConvert.h"


// CImageConvert

STDMETHODIMP CImageConvert::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] =
	{
		&IID_IImageConvert
	};

	for (int i=0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

CString FindExtension(const CString& name)
{
	int len = name.GetLength();
	int i;
	for (i = len-1; i >= 0; i--){
		if (name[i] == '.'){
			return name.Mid(i+1);
		}
	}
	return CString("");
}

int FindFormat(const CString& ext)
{
	int type = 0;
	if (ext == "bmp")					type = CXIMAGE_FORMAT_BMP;
#if CXIMAGE_SUPPORT_JPG
	else if (ext=="jpg"||ext=="jpeg")	type = CXIMAGE_FORMAT_JPG;
#endif
#if CXIMAGE_SUPPORT_GIF
	else if (ext == "gif")				type = CXIMAGE_FORMAT_GIF;
#endif
#if CXIMAGE_SUPPORT_PNG
	else if (ext == "png")				type = CXIMAGE_FORMAT_PNG;
#endif
#if CXIMAGE_SUPPORT_MNG
	else if (ext=="mng"||ext=="jng")	type = CXIMAGE_FORMAT_MNG;
#endif
#if CXIMAGE_SUPPORT_ICO
	else if (ext == "ico")				type = CXIMAGE_FORMAT_ICO;
#endif
#if CXIMAGE_SUPPORT_TIF
	else if (ext=="tiff"||ext=="tif")	type = CXIMAGE_FORMAT_TIF;
#endif
#if CXIMAGE_SUPPORT_TGA
	else if (ext=="tga")				type = CXIMAGE_FORMAT_TGA;
#endif
#if CXIMAGE_SUPPORT_PCX
	else if (ext=="pcx")				type = CXIMAGE_FORMAT_PCX;
#endif
#if CXIMAGE_SUPPORT_WBMP
	else if (ext=="wbmp")				type = CXIMAGE_FORMAT_WBMP;
#endif
#if CXIMAGE_SUPPORT_WMF
	else if (ext=="wmf"||ext=="emf")	type = CXIMAGE_FORMAT_WMF;
#endif
#if CXIMAGE_SUPPORT_J2K
	else if (ext=="j2k"||ext=="jp2")	type = CXIMAGE_FORMAT_J2K;
#endif
#if CXIMAGE_SUPPORT_JBG
	else if (ext=="jbg")				type = CXIMAGE_FORMAT_JBG;
#endif
#if CXIMAGE_SUPPORT_JP2
	else if (ext=="jp2"||ext=="j2k")	type = CXIMAGE_FORMAT_JP2;
#endif
#if CXIMAGE_SUPPORT_JPC
	else if (ext=="jpc"||ext=="j2c")	type = CXIMAGE_FORMAT_JPC;
#endif
#if CXIMAGE_SUPPORT_PGX
	else if (ext=="pgx")				type = CXIMAGE_FORMAT_PGX;
#endif
#if CXIMAGE_SUPPORT_RAS
	else if (ext=="ras")				type = CXIMAGE_FORMAT_RAS;
#endif
#if CXIMAGE_SUPPORT_PNM
	else if (ext=="pnm"||ext=="pgm"||ext=="ppm") type = CXIMAGE_FORMAT_PNM;
#endif
	else type = CXIMAGE_FORMAT_UNKNOWN;

	return type;
}


// Extra Open wrapper om met __try een eventuele Win32 exception ook op te vangen
STDMETHODIMP CImageConvert::Open(BSTR IMGPath)
{
	myTRACE("\nAbout to Open %ls", (LPCTSTR)IMGPath);

	__try {
		return Open2(IMGPath);
	}
	__except (EXCEPTION_EXECUTE_HANDLER)
	{
		DWORD exCode = GetExceptionCode();
		myDoTRACE("\nUnhandled Win32 exception 0x%x in CImageConvert::Open", exCode);

		return myAtlReportError(GetObjectCLSID(), "CImageConvert::Open('%ls')\nUnhandled Win32 exception 0x%x", (LPCSTR)IMGPath, exCode);
	}
}

STDMETHODIMP CImageConvert::Open2(BSTR IMGPath)
{
	CString filein(IMGPath);
	CString extin(FindExtension(filein));
	extin.MakeLower();
	int typein = FindFormat(extin);
	if (typein == CXIMAGE_FORMAT_UNKNOWN) {
		return myAtlReportError (GetObjectCLSID(), "Unknown extension loading %s", filein);
	}

	try
	{
		if (!m_image.Load(filein, typein)) {
			return myAtlReportError(GetObjectCLSID(), "Error loading %s\n%s", filein, m_image.GetLastError());
		}
	}
	catch (const char* const err)
	{
		return myAtlReportError(GetObjectCLSID(), "Error loading %s\n%s", filein, err);
	}

	m_height = m_image.GetHeight();
	m_width = m_image.GetWidth();
	return S_OK;
}

STDMETHODIMP CImageConvert::SaveAs(BSTR IMGPath)
{
	if (m_height != m_image.GetHeight() ||
		m_width != m_image.GetWidth())
	{
	    // Eerst croppen indien nodig, we doen niet aan distortion
		// myDoTRACE("\nSaveAs h=%d, w=%d, H=%d, W=%d", m_height, m_width, m_image.GetHeight(), m_image.GetWidth());
	    if (m_height * m_image.GetWidth() != m_width * m_image.GetHeight())
        {
	        int left, top, right, bottom;
			if (m_height * m_image.GetWidth() > m_width * m_image.GetHeight())
			{	// smaller maken
				int diff = m_image.GetWidth() - m_width * m_image.GetHeight() / m_height;
				left = diff / 2;
				top = 0;
			}
			else
			{	// lager maken
				int diff = m_image.GetHeight() - m_height * m_image.GetWidth() / m_width;
				top = diff / 2;
				left = 0;
			}
			right = m_image.GetWidth() - left;
    		bottom = m_image.GetHeight() - top;
			// myDoTRACE("\nSaveAs crop to l=%d, t=%d, r=%d, b=%d", left, top, right, bottom);
    		if (!m_image.Crop(left, top, right, bottom))
    			return myAtlReportError (GetObjectCLSID(), "Error cropping to l=%d, t=%d, r=%d, b=%d\n%s",
    					left, top, right, bottom, m_image.GetLastError());
		}

		// mode 1 for fast (nearest pixel) method, or 2 for accurate (bicubic spline interpolation) method.
//		if (!m_image.Resample(m_width, m_height, /*mode*/ 2))
//			return myAtlReportError (GetObjectCLSID(), "Error resizing to w=%d, h=%d\n%s",
//					m_height, m_width, m_image.GetLastError());

		// Die IM_GAUSSIAN wordt alleen gebruikt bij vergroten wat wij nooit doen eigenlijk
		if (!m_image.Resample2(m_width, m_height, /*mode*/ CxImage::IM_GAUSSIAN))
			return myAtlReportError(GetObjectCLSID(), "Error resizing to w=%d, h=%d\n%s",
				m_height, m_width, m_image.GetLastError());
	}

	CString fileout(IMGPath);
	CString extout(FindExtension(fileout));
	extout.MakeLower();
	int typeout = FindFormat(extout);
	if (typeout == CXIMAGE_FORMAT_UNKNOWN) {
		return myAtlReportError (GetObjectCLSID(), "Unknown extension saving %s", fileout);
	}

	if (!m_image.Save(fileout,typeout)){
		return myAtlReportError (GetObjectCLSID(), "Error saving %s\n%s", fileout, m_image.GetLastError());
	}

	return S_OK;
}

STDMETHODIMP CImageConvert::get_Height(LONG* pVal)
{
	*pVal = m_height;

	return S_OK;
}

STDMETHODIMP CImageConvert::put_Height(LONG newVal)
{
	m_height = newVal;

	return S_OK;
}

STDMETHODIMP CImageConvert::get_Width(LONG* pVal)
{
	*pVal = m_width;

	return S_OK;
}

STDMETHODIMP CImageConvert::put_Width(LONG newVal)
{
	m_width = newVal;

	return S_OK;
}