www.pudn.com > GdiplusTest16.zip > GdiplusTestDoc.cpp

// GdiplusTestDoc.cpp : implementation of the CGdiplusTestDoc class 
// 
 
#include "stdafx.h" 
#include "GdiplusTest.h" 
 
#include "GdiplusTestDoc.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// CGdiplusTestDoc 
 
IMPLEMENT_DYNCREATE(CGdiplusTestDoc, CDocument) 
 
BEGIN_MESSAGE_MAP(CGdiplusTestDoc, CDocument) 
	//{{AFX_MSG_MAP(CGdiplusTestDoc) 
		// NOTE - the ClassWizard will add and remove mapping macros here. 
		//    DO NOT EDIT what you see in these blocks of generated code! 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CGdiplusTestDoc construction/destruction 
 
CGdiplusTestDoc::CGdiplusTestDoc() 
{ 
	// TODO: add one-time construction code here 
	m_pImage=NULL; 
} 
 
CGdiplusTestDoc::~CGdiplusTestDoc() 
{ 
} 
 
BOOL CGdiplusTestDoc::OnNewDocument() 
{ 
	if (!CDocument::OnNewDocument()) 
		return FALSE; 
 
	// TODO: add reinitialization code here 
	// (SDI documents will reuse this document) 
	   if (m_pImage!=NULL) 
	   { 
		   delete m_pImage; 
		   m_pImage=NULL; 
	   } 
 
	return TRUE; 
} 
 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CGdiplusTestDoc serialization 
 
void CGdiplusTestDoc::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{ 
		// TODO: add storing code here 
		HGLOBAL m_hMem = GlobalAlloc(GMEM_MOVEABLE, 0); 
		IStream *pstm=NULL; 
		CreateStreamOnHGlobal(m_hMem, TRUE, &pstm); 
		CLSID clsid; 
		USES_CONVERSION; 
		GetCodecClsid(A2W("image/jpeg"), &clsid); 
		m_pImage->Save(pstm,&clsid,NULL); 
		if (pstm==NULL) 
			return; 
		LARGE_INTEGER liBeggining = { 0 }; 
		pstm->Seek(liBeggining, STREAM_SEEK_SET, NULL); 
		DWORD wTemp=GlobalSize(m_hMem); 
		LPBYTE lpData = (LPBYTE)GlobalLock(m_hMem); 
	    ar << wTemp;  
        ar.Write(lpData,wTemp); 
		pstm->Release(); 
		GlobalUnlock(m_hMem); 
	} 
	else 
	{ 
		// TODO: add loading code here 
		DWORD wTemp; 
	    ar >> wTemp;  
		HGLOBAL m_hMem = GlobalAlloc(GMEM_FIXED, wTemp); 
	    if (m_hMem == NULL) 
			return; 
		IStream *pstm=NULL; 
		CreateStreamOnHGlobal(m_hMem,FALSE,&pstm); 
		if (pstm==NULL) 
			return; 
		BYTE* pmem = (BYTE*)GlobalLock(m_hMem); 
		ar.Read(pmem,wTemp); 
	    if (m_pImage) { 
			delete m_pImage; 
			m_pImage = NULL; 
	   } 
       using namespace Gdiplus;  
	   if (m_pImage!=NULL) 
	   { 
		   delete m_pImage; 
		   m_pImage=NULL; 
	   } 
	   m_pImage = Image::FromStream(pstm, FALSE); 
		pstm->Release(); 
		GlobalUnlock(m_hMem); 
	} 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CGdiplusTestDoc diagnostics 
 
#ifdef _DEBUG 
void CGdiplusTestDoc::AssertValid() const 
{ 
	CDocument::AssertValid(); 
} 
 
void CGdiplusTestDoc::Dump(CDumpContext& dc) const 
{ 
	CDocument::Dump(dc); 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CGdiplusTestDoc commands 
 
int CGdiplusTestDoc::GetCodecClsid(const WCHAR* format, CLSID* pClsid) 
{ 
   UINT  num = 0;          // number of image encoders 
   UINT  size = 0;         // size of the image encoder array in bytes 
   using namespace Gdiplus;  
   ImageCodecInfo* pImageCodecInfo = NULL; 
   GetImageEncodersSize(&num, &size); 
   if(size == 0) 
      return -1;  // Failure 
   pImageCodecInfo = (ImageCodecInfo*)(malloc(size)); 
   if(pImageCodecInfo == NULL) 
      return -1;  // Failure 
   GetImageEncoders(num, size, pImageCodecInfo); 
   for(UINT j = 0; j < num; ++j) 
   { 
      if( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 ) 
      { 
         *pClsid = pImageCodecInfo[j].Clsid; 
         return j;  // Success 
      }     
   } // for 
   return -1;  // Failure 
} // GetCodecClsid