dotnetlike.h

Windows Mobile平台上使用GDI+。GDI+功能很强大

/////////////////////////////////////////////////////////////////////////////
// File name:      dotnetlike.h
// Author:         Vincent Richomme(vrichomme [AT] smartmobili [DOT] COM
// Created:        April 2009


#pragma once

#include "SmartPtr.h"
#include <list>
#include <vector>

// Wanted to use some smartpointers but get some crash
#if USEMARTPOINTER
typedef Loki::SmartPtr<Gdiplus::Graphics> GraphicsPtr ;
typedef Loki::SmartPtr<Gdiplus::GraphicsPath> GraphicsPathPtr ;
typedef Loki::SmartPtr<Gdiplus::Font> FontPtr ;
typedef Loki::SmartPtr<Gdiplus::PointF> PointFPtr;
typedef Loki::SmartPtr<Gdiplus::Image> ImagePtr ;
typedef Loki::SmartPtr<Gdiplus::Bitmap> BitmapPtr ;
typedef Loki::SmartPtr<Gdiplus::SolidBrush> SolidBrushPtr;
typedef Loki::SmartPtr<Gdiplus::Pen> PenPtr;
typedef Loki::SmartPtr<Gdiplus::TextureBrush> TextureBrushPtr;
typedef Loki::SmartPtr<Gdiplus::HatchBrush> HatchBrushPtr;
typedef Loki::SmartPtr<Gdiplus::LinearGradientBrush> LinearGradientBrushPtr;
typedef Loki::SmartPtr<Gdiplus::PathGradientBrush> PathGradientBrushPtr; 
#define DELETE_OBJ(oBJ) {}
#else
typedef Gdiplus::Graphics* GraphicsPtr ;
typedef Gdiplus::GraphicsPath* GraphicsPathPtr ;
typedef Gdiplus::Font* FontPtr ;
typedef Gdiplus::PointF* PointFPtr;
typedef Gdiplus::Image* ImagePtr ;
typedef Gdiplus::Bitmap* BitmapPtr ;
typedef Gdiplus::SolidBrush* SolidBrushPtr;
typedef Gdiplus::Pen* PenPtr;
typedef Gdiplus::TextureBrush* TextureBrushPtr;
typedef Gdiplus::HatchBrush* HatchBrushPtr;
typedef Gdiplus::LinearGradientBrush* LinearGradientBrushPtr;
typedef Gdiplus::PathGradientBrush* PathGradientBrushPtr; 


#define DELETE_OBJ(oBJ) {if(oBJ!=NULL){delete oBJ; oBJ = NULL;}}

#endif


//---------------------------------------------------------------------------
// class CStreamOnResource 
//

class CStreamOnResource : public IStream
{
	long m_cRef;
	DWORD m_dwPosition;
	HGLOBAL m_hBufferCE;
	BYTE* m_pResourceData;

public:
	CStreamOnResource(LPCTSTR lpResName):
		  m_cRef(1),
		  m_dwPosition(0),
		  m_hBufferCE(NULL),
		  m_pResourceData(NULL)
	  {
		  ATLTRACE(_T("CStreamOnResource()\r\n"));
		  Init(ModuleHelper::GetResourceInstance(), lpResName);

	  }

	  virtual ~CStreamOnResource()
	  {

	  }
	  // Implementation

	  bool Init(HINSTANCE hInstance, LPCTSTR lpResName)
	  {
		  //HRESULT hr;
		  //HBITMAP hbFromRes;
		  //HICON	hiFromRes;
		  //HGLOBAL hResData = NULL;
		  //HGLOBAL hBufferCE = NULL;
		  //HRSRC	hRsrc;
		  //DWORD	dwResLen = 0;

		  //// Normally I should implement EnumResourceTypes  ...
		  //typedef struct { LPCTSTR resType; LPCTSTR resTypeName;} ResSection;
		  //ResSection res_section[] = 
		  //{
			 // { (LPCTSTR) RT_BITMAP,		_T("BITMAP") },
			 // { (LPCTSTR) RT_GROUP_ICON,	_T("ICON")	},
			 // { (LPCTSTR) _T("PNG"),		_T("PNG")	},
			 // { (LPCTSTR) _T("JPEG"),		_T("JPEG")	},
			 // { (LPCTSTR) _T("GIF"),		_T("GIF")	},
		  //};

		  //int i;
		  //for (i = 0; i < _countof(res_section); i++)
		  //{
			 // if ((hRsrc = FindResource(hInstance, lpResName, res_section[i].resType)))
			 // {
				//  dwResLen = ::SizeofResource(hInstance,hRsrc);
				//  if (dwResLen > 0)
				//  {
				//	  hResData = ::LoadResource(hInstance, hRsrc);
				//	  if (hResData != NULL)
				//	  {
				//		  m_pResourceData = (BYTE*)::LockResource(hResData);
				//	  }
				//  }
				//  break;
			 // }
		  //}

		  //if (m_pResourceData)
		  //{
			 // if (i == 0)
			 // {
				//  // RT_BITMAP
				//  const BITMAPINFO* pBitmapInfo = (BITMAPINFO*)pResourceData;
				//  status = GdipCreateBitmapFromGdiDib(pBitmapInfo, (void*)(pBitmapInfo+sizeof(BITMAPINFO)), bitmap);

			 // }
			 // else if (i == 1)
			 // {
				//  //RT_GROUP_ICON - I suppose Gdiplus cannot support icon
				//  // in this case use LoadIcon
				//  status = NotImplemented;
			 // }
			 // else
			 // {
				//  // GIF, JPEG, PNG, ...

				//  m_hBufferCE = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, dwResLen);
				//  BYTE* pDest = reinterpret_cast<BYTE*> ( GlobalLock(hBufferCE) );
				//  if (pDest)
				//  {
				//	  CopyMemory(pDest, pResourceData, dwResLen);
				//	  FreeResource(hResData);

				//	  hr = CreateStreamOnHGlobal(hBufferCE,FALSE,&pImageStream);
				//	  if (hr == S_OK)
				//	  {
				//		  status = GdipCreateBitmapFromStreamICM(pImageStream, bitmap);
				//	  }

				//  } // pDest != NULL
			 // } //i > 1
		  //} // pResourceData
#if 0
#endif
	  }


	  STDMETHOD_(ULONG, AddRef)()
	  {
		  ATLTRACE(_T("CStreamOnResource::AddRef(Before Inc = %d)\r\n"), m_cRef);
		  InterlockedIncrement( &m_cRef );  
		  return m_cRef;
	  }
	  STDMETHOD_(ULONG, Release)()
	  {
		  ATLTRACE(_T("CStreamOnResource::Release(Before Dec = %d)\r\n"), m_cRef);
		  InterlockedDecrement(&m_cRef);  

		  LONG nRefCount = m_cRef;  
		  if (0 == m_cRef)  
			  delete this;  
		  return m_cRef;  
	  }
	  STDMETHOD(QueryInterface)(REFIID riid, LPVOID* ppvObj)
	  {
		  ATLTRACE(_T("CStreamOnResource::QueryInterface()\r\n"));
		  *ppvObj = NULL;  

		  if ( (IsEqualIID(IID_IUnknown, riid)) ||
			  (IsEqualIID(IID_IStream, riid))  ||
			  (IsEqualIID(IID_ISequentialStream, riid)))
			  *ppvObj = this;

		  if (NULL != *ppvObj)  
		  {  
			  AddRef();  
			  return S_OK;  
		  }  
		  else  
			  return E_NOINTERFACE;
	  }

	  STDMETHOD(Read)(void *pv, ULONG cb, ULONG *pcbRead)
	  {
		  ULONG ulRead = 0;
		  ATLTRACE(_T("CStreamOnResource::Read(cb=%d)\r\n"), cb);

		  return S_OK;
	  }
	  STDMETHOD(Write)(const void *pv, ULONG cb, ULONG *pcbWritten)
	  {
		  ATLTRACE(_T("CStreamOnResource::Write(cb=%d)\r\n"), cb);


		  return S_OK;
	  }

	  STDMETHOD(Seek)(LARGE_INTEGER uliOffset, DWORD dwOrigin, ULARGE_INTEGER* puliNew)
	  {
		  DWORD dwNewPos;
		  LONG lpDistHigh;
		  ATLTRACE(_T("CStreamOnResource::Seek(LowPart=%ul HighPart=%d, Origin=%d)\r\n"), 
			  uliOffset.LowPart, uliOffset.HighPart, dwOrigin);

		  if (puliNew != NULL) 
		  {
			  puliNew->LowPart = dwNewPos;
			  puliNew->HighPart = lpDistHigh;
		  }

		  return S_OK;
	  }

	  STDMETHOD(SetSize)(ULARGE_INTEGER ulSize) 
	  { 
		  ATLTRACE(_T("CStreamOnResource::SetSize(ulSize=%ul)\r\n"), ulSize.LowPart);
		  return S_OK; 
	  }

	  STDMETHOD(CopyTo)(LPSTREAM, ULARGE_INTEGER, ULARGE_INTEGER*,ULARGE_INTEGER*) { return E_NOTIMPL; }

	  STDMETHOD(Commit)(DWORD) { return E_NOTIMPL; }

	  STDMETHOD(Revert)() { return E_NOTIMPL; }

	  STDMETHOD(LockRegion)(ULARGE_INTEGER, ULARGE_INTEGER,DWORD) { return E_NOTIMPL; }

	  STDMETHOD(UnlockRegion)(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) { return E_NOTIMPL; }

	  STDMETHOD(Stat)(STATSTG *pstatstg, DWORD grfStatFlag) 
	  { 
		  if (pstatstg != NULL)
		  {
			  //pstatstg->cbSize.QuadPart = GetFileSize(m_hFile, NULL);
			  //pstatstg->grfLocksSupported = 0; 
		  }
		  return S_OK;
	  }

	  STDMETHOD(Clone)(LPSTREAM*) { return E_NOTIMPL; } 
};

//---------------------------------------------------------------------------
// class CStreamOnFile 
//

class CStreamOnFile : public IStream
{
	long m_cRef;
	DWORD m_dwPosition;
	HANDLE m_hFile;

public:
	CStreamOnFile(LPCTSTR lpFileName):
	  m_cRef(1),
		  m_dwPosition(0),
		  m_hFile(NULL)
	  {
		  ATLTRACE(_T("CStreamOnFile()\r\n"));
		  m_hFile = CreateFile(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
			  FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_NORMAL, NULL);
	  }

	  virtual ~CStreamOnFile()
	  {
		  if (m_hFile) 
			  CloseHandle(m_hFile);
	  }
	  // Implementation

	  STDMETHOD_(ULONG, AddRef)()
	  {
		  ATLTRACE(_T("CStreamOnFile::AddRef(Before Inc = %d)\r\n"), m_cRef);
		  InterlockedIncrement( &m_cRef );  
		  return m_cRef;
	  }
	  STDMETHOD_(ULONG, Release)()
	  {
		  ATLTRACE(_T("CStreamOnFile::Release(Before Dec = %d)\r\n"), m_cRef);
		  InterlockedDecrement(&m_cRef);  

		  LONG nRefCount = m_cRef;  
		  if (0 == m_cRef)  
			  delete this;  
		  return m_cRef;  
	  }
	  STDMETHOD(QueryInterface)(REFIID riid, LPVOID* ppvObj)
	  {
		  ATLTRACE(_T("CStreamOnFile::QueryInterface()\r\n"));
		  *ppvObj = NULL;  

		  if ( (IsEqualIID(IID_IUnknown, riid)) ||
			  (IsEqualIID(IID_IStream, riid))  ||
			  (IsEqualIID(IID_ISequentialStream, riid)))
			  *ppvObj = this;

		  if (NULL != *ppvObj)  
		  {  
			  AddRef();  
			  return S_OK;  
		  }  
		  else  
			  return E_NOINTERFACE;
	  }

	  STDMETHOD(Read)(void *pv, ULONG cb, ULONG *pcbRead)
	  {
		  ULONG ulRead = 0;
		  ATLTRACE(_T("CStreamOnFile::Read(cb=%d)\r\n"), cb);
		  if(!ReadFile(m_hFile, pv, cb, pcbRead, NULL))
			  return E_FAIL;

		  /*if(pcbRead && *pcbRead <= 0)
		  return E_FAIL;*/

		  return S_OK;
	  }
	  STDMETHOD(Write)(const void *pv, ULONG cb, ULONG *pcbWritten)
	  {
		  ATLTRACE(_T("CStreamOnFile::Write(cb=%d)\r\n"), cb);
		  if(!WriteFile(m_hFile, pv, cb, pcbWritten, NULL))
			  return E_FAIL;

		  /*if(*pcbWritten <= 0)
		  return E_FAIL;*/

		  return S_OK;
	  }

	  STDMETHOD(Seek)(LARGE_INTEGER uliOffset, DWORD dwOrigin, ULARGE_INTEGER* puliNew)
	  {
		  DWORD dwNewPos;
		  LONG lpDistHigh;
		  ATLTRACE(_T("CStreamOnFile::Seek(LowPart=%ul HighPart=%d, Origin=%d)\r\n"), 
			  uliOffset.LowPart, uliOffset.HighPart, dwOrigin);

		  dwNewPos = SetFilePointer(m_hFile, uliOffset.LowPart, &lpDistHigh, dwOrigin);
		  if (puliNew != NULL) 
		  {
			  puliNew->LowPart = dwNewPos;
			  puliNew->HighPart = lpDistHigh;
		  }

		  return S_OK;
	  }

	  STDMETHOD(SetSize)(ULARGE_INTEGER ulSize) 
	  { 
		  ATLTRACE(_T("CStreamOnFile::SetSize(ulSize=%ul)\r\n"), ulSize.LowPart);
		  SetFilePointer(m_hFile, ulSize.LowPart, NULL, 0);
		  return S_OK; 
	  }

	  STDMETHOD(CopyTo)(LPSTREAM, ULARGE_INTEGER, ULARGE_INTEGER*,ULARGE_INTEGER*) { return E_NOTIMPL; }

	  STDMETHOD(Commit)(DWORD) { return E_NOTIMPL; }

	  STDMETHOD(Revert)() { return E_NOTIMPL; }

	  STDMETHOD(LockRegion)(ULARGE_INTEGER, ULARGE_INTEGER,DWORD) { return E_NOTIMPL; }

	  STDMETHOD(UnlockRegion)(ULARGE_INTEGER, ULARGE_INTEGER, DWORD) { return E_NOTIMPL; }

	  STDMETHOD(Stat)(STATSTG *pstatstg, DWORD grfStatFlag) 
	  { 
		  if (pstatstg != NULL)
		  {
			  pstatstg->cbSize.QuadPart = GetFileSize(m_hFile, NULL);
			  pstatstg->grfLocksSupported = 0; 
		  }
		  return S_OK;
	  }

	  STDMETHOD(Clone)(LPSTREAM*) { return E_NOTIMPL; } 
};