gdiplustestdoc.cpp

GDI编程的参考资料

// 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