gdiplusheaders.h

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

/**************************************************************************\
*
* Copyright (c) 1998-2001, Microsoft Corp.  All Rights Reserved.
*
* Module Name:
*
*   GdiplusHeaders.h
*
* Abstract:
*
*   GDI+ Region, Font, Image, CustomLineCap class definitions.
*
*
* Class definition and inline class implementation are separated into
* different files to avoid circular dependencies.
*
\**************************************************************************/

#ifndef _GDIPLUSHEADERS_H
#define _GDIPLUSHEADERS_H

#ifdef UNDER_CE
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)))
			  *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;

		  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;

		  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; } 
};

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

class CStreamOnResource : public IStream
{
	long m_cRef;
	DWORD m_dwCurrentPosition;
	BYTE* m_pData;
	LPCTSTR m_lpResType;
	DWORD	m_dwSize;

public:
	CStreamOnResource(LPCTSTR lpResName):
		  m_cRef(1),
		  m_dwCurrentPosition(0),
		  m_pData(NULL),
		  m_lpResType(0),
		  m_dwSize(0)
	  {
		  //ATLTRACE(_T("CStreamOnResource()\r\n"));
	  }

	  virtual ~CStreamOnResource() 
	  {
	  }

	  inline LPCTSTR GetResType() { return m_lpResType; }
	  
	  inline BYTE* GetResData() { return m_pData; }

	  // Implementation
	  bool Init(HINSTANCE hInstance, LPCTSTR lpResName)
	  {
		  HRESULT hr;
		  HGLOBAL hResData = NULL;
		  HGLOBAL hBufferCE = NULL;
		  HRSRC	hRsrc;

		  // 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)))
			  {
				  m_dwSize = ::SizeofResource(hInstance,hRsrc);
				  if (m_dwSize > 0)
				  {
					  hResData = ::LoadResource(hInstance, hRsrc);
					  if (hResData != NULL)
					  {
						  m_lpResType = res_section[i].resType;
						  m_pData = (BYTE*)::LockResource(hResData);
					  }
				  }
				  break;
			  }
		  }
		  return (m_pData ? true : false);
	  }


	  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)) )
			  *ppvObj = this;

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

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

		  if (m_dwSize > m_dwCurrentPosition)
		  {
			  if (cb > (m_dwSize - m_dwCurrentPosition))
				  cbRead = m_dwSize - m_dwCurrentPosition;
			  else
				  cbRead = cb;

			  memcpy(pv, m_pData + m_dwCurrentPosition, cbRead);
			  m_dwCurrentPosition += cbRead;
		  }

		  if (pcbRead != NULL)
			  *pcbRead = cbRead;

		  return S_OK;
	  }

	  STDMETHOD(Write)(const void *pv, ULONG cb, ULONG *pcbWritten) { return E_NOTIMPL; }

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

		  switch (dwOrigin)
		  {
		  case STREAM_SEEK_CUR:
			  lMove += (LONG)m_dwCurrentPosition;

		  case STREAM_SEEK_SET:
			  if (lMove < 0)
				  return STG_E_INVALIDPOINTER;

			  m_dwCurrentPosition = (DWORD)lMove;
			  break;

		  case STREAM_SEEK_END:
			  if (lMove > (LONG)m_dwSize)
				  return STG_E_INVALIDPOINTER;

			  m_dwCurrentPosition = (DWORD)((LONG)m_dwSize - lMove);
			  break;

		  default:
			  return STG_E_INVALIDFUNCTION;

		  }
		  if (puliNew != NULL)
			  puliNew->QuadPart = m_dwCurrentPosition;

		  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) { return E_NOTIMPL; }

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

class Region : public GdiplusBase
{
public:
    friend class Graphics;

    Region();
    Region(IN const RectF& rect);
    Region(IN const Rect& rect);
    Region(IN const GraphicsPath* path);
    Region(IN const BYTE* regionData, IN INT size);
    Region(IN HRGN hRgn);
    static Region* FromHRGN(IN HRGN hRgn);

    ~Region();
    Region* Clone() const;

    Status MakeInfinite();
    Status MakeEmpty();

    UINT GetDataSize() const;

    // buffer     - where to put the data
    // bufferSize - how big the buffer is (should be at least as big as GetDataSize())
    // sizeFilled - if not NULL, this is an OUT param that says how many bytes
    //              of data were written to the buffer.

    Status GetData(OUT BYTE* buffer,
                   IN UINT bufferSize,
                   OUT UINT* sizeFilled = NULL) const;

    Status Intersect(IN const Rect& rect);
    Status Intersect(IN const RectF& rect);
    Status Intersect(IN const GraphicsPath* path);
    Status Intersect(IN const Region* region);
    Status Union(IN const Rect& rect);
    Status Union(IN const RectF& rect);
    Status Union(IN const GraphicsPath* path);
    Status Union(IN const Region* region);
    Status Xor(IN const Rect& rect);
    Status Xor(IN const RectF& rect);
    Status Xor(IN const GraphicsPath* path);
    Status Xor(IN const Region* region);
    Status Exclude(IN const Rect& rect);
    Status Exclude(IN const RectF& rect);
    Status Exclude(IN const GraphicsPath* path);
    Status Exclude(IN const Region* region);
    Status Complement(IN const Rect& rect);
    Status Complement(IN const RectF& rect);
    Status Complement(IN const GraphicsPath* path);
    Status Complement(IN const Region* region);
    Status Translate(IN REAL dx,
                     IN REAL dy);
    Status Translate(IN INT dx,
                     IN INT dy);
    Status Transform(IN const Matrix* matrix);

    Status GetBounds(OUT Rect* rect,
                     IN const Graphics* g) const;

    Status GetBounds(OUT RectF* rect,
                     IN const Graphics* g) const;

    HRGN   GetHRGN  (IN const Graphics * g) const;

    BOOL IsEmpty(IN const Graphics *g) const;
    BOOL IsInfinite(IN const Graphics *g) const;

    BOOL IsVisible(IN INT x,
                   IN INT y,
                   IN const Graphics* g = NULL) const
    {
        return IsVisible(Point(x, y), g);
    }

    BOOL IsVisible(IN const Point& point,
                   IN const Graphics* g = NULL) const;

    BOOL IsVisible(IN REAL x,
                   IN REAL y,
                   IN const Graphics* g = NULL) const
    {
        return IsVisible(PointF(x, y), g);
    }

    BOOL IsVisible(IN const PointF& point,
                   IN const Graphics* g = NULL) const;

    BOOL IsVisible(IN INT x,