开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
atlimage.h
资源名称：CreatBMP.rar　[点击查看]
上传用户：hfwmdy
上传日期：2016-01-14
资源大小：83k
文件大小：44k
源码类别：

GDI/图象编程

开发平台：

Visual C++

atlimage.h：源码内容
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  11. #ifndef __ATLIMAGE_H__
  12. #define __ATLIMAGE_H__
  14. #pragma once
  16. #include <atldef.h>
  17. #include <atlbase.h>
  18. #include <atlstr.h>
  19. #include <atlsimpcoll.h>
  20. #include <atltypes.h>
  22. #ifndef _ATL_NO_PRAGMA_WARNINGS
  23. #pragma warning (push)
  24. #pragma warning(disable : 4820) // padding added after member
  25. #endif //!_ATL_NO_PRAGMA_WARNINGS
  27. #pragma warning( push, 3 )
  28. #pragma push_macro("new")
  29. #undef new
  30. #include <gdiplus.h>
  31. #pragma pop_macro("new")
  32. #pragma warning( pop )
  34. #include <shlwapi.h>
  36. #ifndef _ATL_NO_DEFAULT_LIBS
  37. #pragma comment(lib, "gdi32.lib")
  38. #pragma comment(lib, "shlwapi.lib")
  39. #pragma comment(lib, "gdiplus.lib")
  40. #if WINVER >= 0x0500
  41. #pragma comment(lib, "msimg32.lib")
  42. #endif  // WINVER >= 0x0500
  43. #endif  // !_ATL_NO_DEFAULT_LIBS
  45. #pragma pack(push, _ATL_PACKING)
  47. namespace ATL
  48. {
  50. const int CIMAGE_DC_CACHE_SIZE = 4;
  52. class CImage;
  54. class CImageDC
  55. {
  56. public:
  57. CImageDC( const CImage& image ) throw( ... );
  58. ~CImageDC() throw();
  60. operator HDC() const throw();
  62. private:
  63. const CImage& m_image;
  64. HDC m_hDC;
  65. };
  67. class CImage
  68. {
  69. private:
  70. class CDCCache
  71. {
  72. public:
  73. CDCCache() throw();
  74. ~CDCCache() throw();
  76. HDC GetDC() throw();
  77. void ReleaseDC( HDC ) throw();
  79. private:
  80. HDC m_ahDCs[CIMAGE_DC_CACHE_SIZE];
  81. };
  83. class CInitGDIPlus
  84. {
  85. public:
  86. CInitGDIPlus() throw();
  87. ~CInitGDIPlus() throw();
  89. bool Init() throw();
  90. void ReleaseGDIPlus() throw();
  91. void IncreaseCImageCount() throw();
  92. void DecreaseCImageCount() throw();
  94. private:
  95. ULONG_PTR m_dwToken;
  96. CRITICAL_SECTION m_sect;
  97. LONG m_nCImageObjects;
  98. };
  100. public:
  101. static const DWORD createAlphaChannel = 0x01;
  103. static const DWORD excludeGIF = 0x01;
  104. static const DWORD excludeBMP = 0x02;
  105. static const DWORD excludeEMF = 0x04;
  106. static const DWORD excludeWMF = 0x08;
  107. static const DWORD excludeJPEG = 0x10;
  108. static const DWORD excludePNG = 0x20;
  109. static const DWORD excludeTIFF = 0x40;
  110. static const DWORD excludeIcon = 0x80;
  111. static const DWORD excludeOther = 0x80000000;
  112. static const DWORD excludeDefaultLoad = 0;
  113. static const DWORD excludeDefaultSave = excludeIcon|excludeEMF|excludeWMF;
  114. static const DWORD excludeValid = 0x800000ff;
  116. enum DIBOrientation
  117. {
  118. DIBOR_DEFAULT,
  119. DIBOR_TOPDOWN,
  120. DIBOR_BOTTOMUP
  121. };
  123. public:
  124. CImage() throw();
  125. virtual ~CImage() throw();
  127. operator HBITMAP() const throw();
  128. #if WINVER >= 0x0500
  129. BOOL AlphaBlend( HDC hDestDC, int xDest, int yDest, BYTE bSrcAlpha = 0xff, 
  130. BYTE bBlendOp = AC_SRC_OVER ) const throw();
  131. BOOL AlphaBlend( HDC hDestDC, const POINT& pointDest, BYTE bSrcAlpha = 0xff, 
  132. BYTE bBlendOp = AC_SRC_OVER ) const throw();
  133. BOOL AlphaBlend( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  134. int nDestHeight, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, 
  135. BYTE bSrcAlpha = 0xff, BYTE bBlendOp = AC_SRC_OVER ) const throw();
  136. BOOL AlphaBlend( HDC hDestDC, const RECT& rectDest, const RECT& rectSrc, 
  137. BYTE bSrcAlpha = 0xff, BYTE bBlendOp = AC_SRC_OVER ) const throw();
  138. #endif  // WINVER >= 0x0500
  139. void Attach( HBITMAP hBitmap, DIBOrientation eOrientation = DIBOR_DEFAULT ) throw();
  140. BOOL BitBlt( HDC hDestDC, int xDest, int yDest, DWORD dwROP = SRCCOPY ) const throw();
  141. BOOL BitBlt( HDC hDestDC, const POINT& pointDest, DWORD dwROP = SRCCOPY ) const throw();
  142. BOOL BitBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  143. int nDestHeight, int xSrc, int ySrc, DWORD dwROP = SRCCOPY ) const throw();
  144. BOOL BitBlt( HDC hDestDC, const RECT& rectDest, const POINT& pointSrc, 
  145. DWORD dwROP = SRCCOPY ) const throw();
  146. BOOL Create( int nWidth, int nHeight, int nBPP, DWORD dwFlags = 0 ) throw();
  147. BOOL CreateEx( int nWidth, int nHeight, int nBPP, DWORD eCompression, 
  148. const DWORD* pdwBitmasks = NULL, DWORD dwFlags = 0 ) throw();
  149. void Destroy() throw();
  150. HBITMAP Detach() throw();
  151. BOOL Draw( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  152. int nDestHeight, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight ) const throw();
  153. BOOL Draw( HDC hDestDC, const RECT& rectDest, const RECT& rectSrc ) const throw();
  154. BOOL Draw( HDC hDestDC, int xDest, int yDest ) const throw();
  155. BOOL Draw( HDC hDestDC, const POINT& pointDest ) const throw();
  156. BOOL Draw( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  157. int nDestHeight ) const throw();
  158. BOOL Draw( HDC hDestDC, const RECT& rectDest ) const throw();
  159. const void* GetBits() const throw();
  160. void* GetBits() throw();
  161. int GetBPP() const throw();
  162. void GetColorTable( UINT iFirstColor, UINT nColors, RGBQUAD* prgbColors ) const throw();
  163. HDC GetDC() const throw();
  164. static HRESULT GetExporterFilterString( CSimpleString& strExporters, 
  165. CSimpleArray< GUID >& aguidFileTypes, LPCTSTR pszAllFilesDescription = NULL, 
  166. DWORD dwExclude = excludeDefaultSave, TCHAR chSeparator = _T( '|' ) );
  167. static HRESULT GetImporterFilterString( CSimpleString& strImporters, 
  168. CSimpleArray< GUID >& aguidFileTypes, LPCTSTR pszAllFilesDescription = NULL, 
  169. DWORD dwExclude = excludeDefaultLoad, TCHAR chSeparator = _T( '|' ) );
  170. int GetHeight() const throw();
  171. int GetMaxColorTableEntries() const throw();
  172. int GetPitch() const throw();
  173. const void* GetPixelAddress( int x, int y ) const throw();
  174. void* GetPixelAddress( int x, int y ) throw();
  175. COLORREF GetPixel( int x, int y ) const throw();
  176. LONG GetTransparentColor() const throw();
  177. int GetWidth() const throw();
  178. bool IsDIBSection() const throw();
  179. bool IsIndexed() const throw();
  180. bool IsNull() const throw();
  181. HRESULT Load( LPCTSTR pszFileName ) throw();
  182. HRESULT Load( IStream* pStream ) throw();
  183. void LoadFromResource( HINSTANCE hInstance, LPCTSTR pszResourceName ) throw();
  184. void LoadFromResource( HINSTANCE hInstance, UINT nIDResource ) throw();
  185. BOOL MaskBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  186. int nDestHeight, int xSrc, int ySrc, HBITMAP hbmMask, int xMask, 
  187. int yMask, DWORD dwROP = SRCCOPY ) const throw();
  188. BOOL MaskBlt( HDC hDestDC, const RECT& rectDest, const POINT& pointSrc, 
  189. HBITMAP hbmMask, const POINT& pointMask, DWORD dwROP = SRCCOPY ) const throw();
  190. BOOL MaskBlt( HDC hDestDC, int xDest, int yDest, HBITMAP hbmMask, 
  191. DWORD dwROP = SRCCOPY ) const throw();
  192. BOOL MaskBlt( HDC hDestDC, const POINT& pointDest, HBITMAP hbmMask, 
  193. DWORD dwROP = SRCCOPY ) const throw();
  194. BOOL PlgBlt( HDC hDestDC, const POINT* pPoints, HBITMAP hbmMask = NULL ) const throw();
  195. BOOL PlgBlt( HDC hDestDC, const POINT* pPoints, int xSrc, int ySrc, 
  196. int nSrcWidth, int nSrcHeight, HBITMAP hbmMask = NULL, int xMask = 0, 
  197. int yMask = 0 ) const throw();
  198. BOOL PlgBlt( HDC hDestDC, const POINT* pPoints, const RECT& rectSrc, 
  199. HBITMAP hbmMask = NULL, const POINT& pointMask = CPoint( 0, 0 ) ) const throw();
  200. void ReleaseDC() const throw();
  201. HRESULT Save( IStream* pStream, REFGUID guidFileType ) const throw();
  202. HRESULT Save( LPCTSTR pszFileName, REFGUID guidFileType = GUID_NULL ) const throw();
  203. void SetColorTable( UINT iFirstColor, UINT nColors, 
  204. const RGBQUAD* prgbColors ) throw();
  205. void SetPixel( int x, int y, COLORREF color ) throw();
  206. void SetPixelIndexed( int x, int y, int iIndex ) throw();
  207. void SetPixelRGB( int x, int y, BYTE r, BYTE g, BYTE b ) throw();
  208. LONG SetTransparentColor( LONG iTransparentColor ) throw();
  209. BOOL StretchBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  210. int nDestHeight, DWORD dwROP = SRCCOPY ) const throw();
  211. BOOL StretchBlt( HDC hDestDC, const RECT& rectDest, DWORD dwROP = SRCCOPY ) const throw();
  212. BOOL StretchBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  213. int nDestHeight, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight,
  214. DWORD dwROP = SRCCOPY ) const throw();
  215. BOOL StretchBlt( HDC hDestDC, const RECT& rectDest, const RECT& rectSrc,
  216. DWORD dwROP = SRCCOPY ) const throw();
  217. #if WINVER >= 0x0500
  218. BOOL TransparentBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  219. int nDestHeight, UINT crTransparent = CLR_INVALID ) const throw();
  220. BOOL TransparentBlt( HDC hDestDC, const RECT& rectDest, 
  221. UINT crTransparent = CLR_INVALID ) const throw();
  222. BOOL TransparentBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth,
  223. int nDestHeight, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight,
  224. UINT crTransparent = CLR_INVALID ) const throw();
  225. BOOL TransparentBlt( HDC hDestDC, const RECT& rectDest, const RECT& rectSrc,
  226. UINT crTransparent = CLR_INVALID ) const throw();
  227. #endif  // WINVER >= 0x0500
  229. static BOOL IsTransparencySupported() throw();
  231. private:
  232. HBITMAP m_hBitmap;
  233. void* m_pBits;
  234. int m_nWidth;
  235. int m_nHeight;
  236. int m_nPitch;
  237. int m_nBPP;
  238. bool m_bIsDIBSection;
  239. bool m_bHasAlphaChannel;
  240. LONG m_iTransparentColor;
  242. static CInitGDIPlus s_initGDIPlus;
  244. public:
  245. inline static void ReleaseGDIPlus() { s_initGDIPlus.ReleaseGDIPlus(); }
  248. // Implementation
  249. private:
  250. static CLSID FindCodecForExtension( LPCTSTR pszExtension, const Gdiplus::ImageCodecInfo* pCodecs, UINT nCodecs );
  251. static CLSID FindCodecForFileType( REFGUID guidFileType, const Gdiplus::ImageCodecInfo* pCodecs, UINT nCodecs );
  252. static void BuildCodecFilterString( const Gdiplus::ImageCodecInfo* pCodecs, UINT nCodecs, 
  253. CSimpleString& strFilter, CSimpleArray< GUID >& aguidFileTypes, LPCTSTR pszAllFilesDescription, DWORD dwExclude, TCHAR chSeparator );
  254. static bool ShouldExcludeFormat( REFGUID guidFileType, DWORD dwExclude ) throw();
  255. void UpdateBitmapInfo( DIBOrientation eOrientation );
  256. HRESULT CreateFromGdiplusBitmap( Gdiplus::Bitmap& bmSrc ) throw();
  258. static bool InitGDIPlus() throw();
  260. static int ComputePitch( int nWidth, int nBPP )
  261. {
  262. return( (((nWidth*nBPP)+31)/32)*4 );
  263. }
  264. static void GenerateHalftonePalette( LPRGBQUAD prgbPalette );
  265. COLORREF GetTransparentRGB() const;
  267. private:
  268. mutable HDC m_hDC;
  269. mutable int m_nDCRefCount;
  270. mutable HBITMAP m_hOldBitmap;
  272. static CDCCache s_cache;
  273. };
  275. inline CImageDC::CImageDC( const CImage& image ) throw( ... ) :
  276. m_image( image ),
  277. m_hDC( image.GetDC() )
  278. {
  279. if( m_hDC == NULL )
  280. {
  281. AtlThrow( E_OUTOFMEMORY );
  282. }
  283. }
  285. inline CImageDC::~CImageDC() throw()
  286. {
  287. m_image.ReleaseDC();
  288. }
  290. inline CImageDC::operator HDC() const throw()
  291. {
  292. return( m_hDC );
  293. }
  295. inline CImage::CInitGDIPlus::CInitGDIPlus() throw() :
  296. m_dwToken( 0 ), m_nCImageObjects( 0 )
  297. {
  298. __try
  299. {
  300. InitializeCriticalSection(&m_sect);
  301. }
  302. __except( STATUS_NO_MEMORY == GetExceptionCode() )
  303. {
  304. AtlThrow( E_OUTOFMEMORY );
  305. }
  306. }
  308. inline CImage::CInitGDIPlus::~CInitGDIPlus() throw()
  309. {
  310. ReleaseGDIPlus();
  311. DeleteCriticalSection(&m_sect);
  312. }
  314. inline bool CImage::CInitGDIPlus::Init() throw()
  315. {
  316. EnterCriticalSection(&m_sect);
  317. bool fRet = true;
  318. if( m_dwToken == 0 )
  319. {
  320. Gdiplus::GdiplusStartupInput input;
  321. Gdiplus::GdiplusStartupOutput output;
  322. Gdiplus::Status status = Gdiplus::GdiplusStartup( &m_dwToken, &input, &output );
  323. if( status != Gdiplus::Ok )
  324. fRet = false;
  325. }
  326. LeaveCriticalSection(&m_sect);
  327. return fRet;
  328. }
  330. inline void CImage::CInitGDIPlus::ReleaseGDIPlus() throw()
  331. {
  332. EnterCriticalSection(&m_sect);
  333. if( m_dwToken != 0 )
  334. {
  335. Gdiplus::GdiplusShutdown( m_dwToken );
  336. }
  337. m_dwToken = 0;
  338. LeaveCriticalSection(&m_sect);
  339. }
  341. inline void CImage::CInitGDIPlus::IncreaseCImageCount() throw()
  342. {
  343. EnterCriticalSection(&m_sect);
  344. m_nCImageObjects++;
  345. LeaveCriticalSection(&m_sect);
  346. }
  348. inline void CImage::CInitGDIPlus::DecreaseCImageCount() throw()
  349. {
  350. EnterCriticalSection(&m_sect);
  351. if( --m_nCImageObjects == 0 )
  352. ReleaseGDIPlus();
  353. LeaveCriticalSection(&m_sect);
  354. }
  356. inline CImage::CDCCache::CDCCache() throw()
  357. {
  358. int iDC;
  360. for( iDC = 0; iDC < CIMAGE_DC_CACHE_SIZE; iDC++ )
  361. {
  362. m_ahDCs[iDC] = NULL;
  363. }
  364. }
  366. inline CImage::CDCCache::~CDCCache() throw()
  367. {
  368. int iDC;
  370. for( iDC = 0; iDC < CIMAGE_DC_CACHE_SIZE; iDC++ )
  371. {
  372. if( m_ahDCs[iDC] != NULL )
  373. {
  374. ::DeleteDC( m_ahDCs[iDC] );
  375. }
  376. }
  377. }
  379. inline HDC CImage::CDCCache::GetDC() throw()
  380. {
  381. HDC hDC;
  383. for( int iDC = 0; iDC < CIMAGE_DC_CACHE_SIZE; iDC++ )
  384. {
  385. hDC = static_cast< HDC >( InterlockedExchangePointer( reinterpret_cast< void** >(&m_ahDCs[iDC]), NULL ) );
  386. if( hDC != NULL )
  387. {
  388. return( hDC );
  389. }
  390. }
  392. hDC = ::CreateCompatibleDC( NULL );
  394. return( hDC );
  395. }
  397. inline void CImage::CDCCache::ReleaseDC( HDC hDC ) throw()
  398. {
  399. for( int iDC = 0; iDC < CIMAGE_DC_CACHE_SIZE; iDC++ )
  400. {
  401. HDC hOldDC;
  403. hOldDC = static_cast< HDC >( InterlockedExchangePointer( reinterpret_cast< void** >(&m_ahDCs[iDC]), hDC ) );
  404. if( hOldDC == NULL )
  405. {
  406. return;
  407. }
  408. else
  409. {
  410. hDC = hOldDC;
  411. }
  412. }
  413. if( hDC != NULL )
  414. {
  415. ::DeleteDC( hDC );
  416. }
  417. }
  419. inline CImage::CImage() throw() :
  420. m_hBitmap( NULL ),
  421. m_pBits( NULL ),
  422. m_hDC( NULL ),
  423. m_nDCRefCount( 0 ),
  424. m_hOldBitmap( NULL ),
  425. m_nWidth( 0 ),
  426. m_nHeight( 0 ),
  427. m_nPitch( 0 ),
  428. m_nBPP( 0 ),
  429. m_iTransparentColor( -1 ),
  430. m_bHasAlphaChannel( false ),
  431. m_bIsDIBSection( false )
  432. {
  433. s_initGDIPlus.IncreaseCImageCount();
  434. }
  436. inline CImage::~CImage() throw()
  437. {
  438. Destroy();
  439. s_initGDIPlus.DecreaseCImageCount();
  440. }
  442. inline CImage::operator HBITMAP() const throw()
  443. {
  444. return( m_hBitmap );
  445. }
  447. #if WINVER >= 0x0500
  448. inline BOOL CImage::AlphaBlend( HDC hDestDC, int xDest, int yDest, 
  449. BYTE bSrcAlpha, BYTE bBlendOp ) const throw()
  450. {
  451. return( AlphaBlend( hDestDC, xDest, yDest, m_nWidth, m_nHeight, 0, 0, 
  452. m_nWidth, m_nHeight, bSrcAlpha, bBlendOp ) );
  453. }
  455. inline BOOL CImage::AlphaBlend( HDC hDestDC, const POINT& pointDest, 
  456.    BYTE bSrcAlpha, BYTE bBlendOp ) const throw()
  457. {
  458. return( AlphaBlend( hDestDC, pointDest.x, pointDest.y, m_nWidth, m_nHeight, 
  459. 0, 0, m_nWidth, m_nHeight, bSrcAlpha, bBlendOp ) );
  460. }
  462. inline BOOL CImage::AlphaBlend( HDC hDestDC, int xDest, int yDest, 
  463. int nDestWidth, int nDestHeight, int xSrc, int ySrc, int nSrcWidth, 
  464. int nSrcHeight, BYTE bSrcAlpha, BYTE bBlendOp ) const throw()
  465. {
  466. BLENDFUNCTION blend;
  467. BOOL bResult;
  469. blend.SourceConstantAlpha = bSrcAlpha;
  470. blend.BlendOp = bBlendOp;
  471. blend.BlendFlags = 0;
  472. if( m_bHasAlphaChannel )
  473. {
  474. blend.AlphaFormat = AC_SRC_ALPHA;
  475. }
  476. else
  477. {
  478. blend.AlphaFormat = 0;
  479. }
  481. GetDC();
  483. bResult = ::AlphaBlend( hDestDC, xDest, yDest, nDestWidth, nDestHeight, m_hDC, 
  484. xSrc, ySrc, nSrcWidth, nSrcHeight, blend );
  486. ReleaseDC();
  488. return( bResult );
  489. }
  491. inline BOOL CImage::AlphaBlend( HDC hDestDC, const RECT& rectDest, 
  492. const RECT& rectSrc, BYTE bSrcAlpha, BYTE bBlendOp ) const throw()
  493. {
  494. return( AlphaBlend( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  495. rectDest.left, rectDest.bottom-rectDest.top, rectSrc.left, rectSrc.top, 
  496. rectSrc.right-rectSrc.left, rectSrc.bottom-rectSrc.top, bSrcAlpha, 
  497. bBlendOp ) );
  498. }
  499. #endif  // WINVER >= 0x0500
  501. inline void CImage::Attach( HBITMAP hBitmap, DIBOrientation eOrientation ) throw()
  502. {
  503. ATLASSUME( m_hBitmap == NULL );
  504. ATLASSERT( hBitmap != NULL );
  506. m_hBitmap = hBitmap;
  508. UpdateBitmapInfo( eOrientation );
  509. }
  511. inline BOOL CImage::BitBlt( HDC hDestDC, int xDest, int yDest, DWORD dwROP ) const throw()
  512. {
  513. return( BitBlt( hDestDC, xDest, yDest, m_nWidth, m_nHeight, 0, 0, dwROP ) );
  514. }
  516. inline BOOL CImage::BitBlt( HDC hDestDC, const POINT& pointDest, DWORD dwROP ) const throw()
  517. {
  518. return( BitBlt( hDestDC, pointDest.x, pointDest.y, m_nWidth, m_nHeight,
  519. 0, 0, dwROP ) );
  520. }
  522. inline BOOL CImage::BitBlt( HDC hDestDC, int xDest, int yDest, int nDestWidth, 
  523. int nDestHeight, int xSrc, int ySrc, DWORD dwROP ) const throw()
  524. {
  525. BOOL bResult;
  527. ATLASSUME( m_hBitmap != NULL );
  528. ATLASSERT( hDestDC != NULL );
  530. GetDC();
  532. bResult = ::BitBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, m_hDC, 
  533. xSrc, ySrc, dwROP );
  535. ReleaseDC();
  537. return( bResult );
  538. }
  540. inline BOOL CImage::BitBlt( HDC hDestDC, const RECT& rectDest, 
  541. const POINT& pointSrc, DWORD dwROP ) const throw()
  542. {
  543. return( BitBlt( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  544. rectDest.left, rectDest.bottom-rectDest.top, pointSrc.x, pointSrc.y, 
  545. dwROP ) );
  546. }
  548. inline BOOL CImage::Create( int nWidth, int nHeight, int nBPP, DWORD dwFlags ) throw()
  549. {
  550. return( CreateEx( nWidth, nHeight, nBPP, BI_RGB, NULL, dwFlags ) );
  551. }
  553. inline BOOL CImage::CreateEx( int nWidth, int nHeight, int nBPP, DWORD eCompression, 
  554. const DWORD* pdwBitfields, DWORD dwFlags ) throw()
  555. {
  556. USES_ATL_SAFE_ALLOCA;
  557. LPBITMAPINFO pbmi;
  558. HBITMAP hBitmap;
  560. ATLASSERT( (eCompression == BI_RGB) || (eCompression == BI_BITFIELDS) );
  561. if( dwFlags&createAlphaChannel )
  562. {
  563. ATLASSERT( (nBPP == 32) && (eCompression == BI_RGB) );
  564. }
  566. pbmi = (LPBITMAPINFO)_ATL_SAFE_ALLOCA(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*256, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
  567. if( pbmi == NULL )
  568. return FALSE;
  570. memset( &pbmi->bmiHeader, 0, sizeof( pbmi->bmiHeader ) );
  571. pbmi->bmiHeader.biSize = sizeof( pbmi->bmiHeader );
  572. pbmi->bmiHeader.biWidth = nWidth;
  573. pbmi->bmiHeader.biHeight = nHeight;
  574. pbmi->bmiHeader.biPlanes = 1;
  575. pbmi->bmiHeader.biBitCount = USHORT( nBPP );
  576. pbmi->bmiHeader.biCompression = eCompression;
  577. if( nBPP <= 8 )
  578. {
  579. ATLASSERT( eCompression == BI_RGB );
  580. #pragma warning(push)
  581. #pragma warning(disable:4068) //Disable unknown pragma warning that prefast pragma causes.
  582. #pragma prefast(push)
  583. #pragma prefast(disable:203, "no buffer overrun here, buffer was alocated properly")
  584. memset( pbmi->bmiColors, 0, 256*sizeof( RGBQUAD ) );
  585. #pragma prefast(pop)
  586. #pragma warning(pop)
  587. }
  589. else 
  590. {
  591. if( eCompression == BI_BITFIELDS )
  592. {
  593. ATLASSERT( pdwBitfields != NULL );
  594. Checked::memcpy_s(pbmi->bmiColors, 3*sizeof( DWORD ), pdwBitfields, 3*sizeof( DWORD ));
  595. }
  596. }
  598. hBitmap = ::CreateDIBSection( NULL, pbmi, DIB_RGB_COLORS, &m_pBits, NULL,
  599. 0 );
  600. if( hBitmap == NULL )
  601. {
  602. return( FALSE );
  603. }
  605. Attach( hBitmap, (nHeight < 0) ? DIBOR_TOPDOWN : DIBOR_BOTTOMUP );
  607. if( dwFlags&createAlphaChannel )
  608. {
  609. m_bHasAlphaChannel = true;
  610. }
  612. return( TRUE );
  613. }
  615. inline void CImage::Destroy() throw()
  616. {
  617. HBITMAP hBitmap;
  619. if( m_hBitmap != NULL )
  620. {
  621. hBitmap = Detach();
  622. ::DeleteObject( hBitmap );
  623. }
  624. }
  626. inline HBITMAP CImage::Detach() throw()
  627. {
  628. HBITMAP hBitmap;
  630. ATLASSUME( m_hBitmap != NULL );
  631. ATLASSUME( m_hDC == NULL );
  633. hBitmap = m_hBitmap;
  634. m_hBitmap = NULL;
  635. m_pBits = NULL;
  636. m_nWidth = 0;
  637. m_nHeight = 0;
  638. m_nBPP = 0;
  639. m_nPitch = 0;
  640. m_iTransparentColor = -1;
  641. m_bHasAlphaChannel = false;
  642. m_bIsDIBSection = false;
  644. return( hBitmap );
  645. }
  647. inline BOOL CImage::Draw( HDC hDestDC, const RECT& rectDest ) const throw()
  648. {
  649. return( Draw( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  650. rectDest.left, rectDest.bottom-rectDest.top, 0, 0, m_nWidth, 
  651. m_nHeight ) );
  652. }
  654. inline BOOL CImage::Draw( HDC hDestDC, int xDest, int yDest, int nDestWidth, int nDestHeight ) const throw()
  655. {
  656. return( Draw( hDestDC, xDest, yDest, nDestWidth, nDestHeight, 0, 0, m_nWidth, m_nHeight ) );
  657. }
  659. inline BOOL CImage::Draw( HDC hDestDC, const POINT& pointDest ) const throw()
  660. {
  661. return( Draw( hDestDC, pointDest.x, pointDest.y, m_nWidth, m_nHeight, 0, 0, m_nWidth, m_nHeight ) );
  662. }
  664. inline BOOL CImage::Draw( HDC hDestDC, int xDest, int yDest ) const throw()
  665. {
  666. return( Draw( hDestDC, xDest, yDest, m_nWidth, m_nHeight, 0, 0, m_nWidth, m_nHeight ) );
  667. }
  669. inline BOOL CImage::Draw( HDC hDestDC, const RECT& rectDest, const RECT& rectSrc ) const throw()
  670. {
  671. return( Draw( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  672. rectDest.left, rectDest.bottom-rectDest.top, rectSrc.left, rectSrc.top, 
  673. rectSrc.right-rectSrc.left, rectSrc.bottom-rectSrc.top ) );
  674. }
  676. inline BOOL CImage::Draw( HDC hDestDC, int xDest, int yDest, int nDestWidth,
  677. int nDestHeight, int xSrc, int ySrc, int nSrcWidth, int nSrcHeight ) const throw()
  678. {
  679. BOOL bResult;
  681. ATLASSUME( m_hBitmap != NULL );
  682. ATLASSERT( hDestDC != NULL );
  683. ATLASSERT( nDestWidth > 0 );
  684. ATLASSERT( nDestHeight > 0 );
  685. ATLASSERT( nSrcWidth > 0 );
  686. ATLASSERT( nSrcHeight > 0 );
  688. GetDC();
  690. #if WINVER >= 0x0500
  691. if( (m_iTransparentColor != -1) && IsTransparencySupported() )
  692. {
  693. bResult = ::TransparentBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight,
  694. m_hDC, xSrc, ySrc, nSrcWidth, nSrcHeight, GetTransparentRGB() );
  695. }
  696. else if( m_bHasAlphaChannel && IsTransparencySupported() )
  697. {
  698. BLENDFUNCTION bf;
  700. bf.BlendOp = AC_SRC_OVER;
  701. bf.BlendFlags = 0;
  702. bf.SourceConstantAlpha = 0xff;
  703. bf.AlphaFormat = AC_SRC_ALPHA;
  704. bResult = ::AlphaBlend( hDestDC, xDest, yDest, nDestWidth, nDestHeight, 
  705. m_hDC, xSrc, ySrc, nSrcWidth, nSrcHeight, bf );
  706. }
  707. else
  708. #endif  // WINVER >= 0x0500
  709. {
  710. bResult = ::StretchBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, 
  711. m_hDC, xSrc, ySrc, nSrcWidth, nSrcHeight, SRCCOPY );
  712. }
  714. ReleaseDC();
  716. return( bResult );
  717. }
  719. inline const void* CImage::GetBits() const throw()
  720. {
  721. ATLASSUME( m_hBitmap != NULL );
  722. ATLASSERT( IsDIBSection() );
  724. return( m_pBits );
  725. }
  727. inline void* CImage::GetBits() throw()
  728. {
  729. ATLASSUME( m_hBitmap != NULL );
  730. ATLASSERT( IsDIBSection() );
  732. return( m_pBits );
  733. }
  735. inline int CImage::GetBPP() const throw()
  736. {
  737. ATLASSUME( m_hBitmap != NULL );
  739. return( m_nBPP );
  740. }
  742. inline void CImage::GetColorTable( UINT iFirstColor, UINT nColors, 
  743. RGBQUAD* prgbColors ) const throw()
  744. {
  745. ATLASSUME( m_hBitmap != NULL );
  746. ATLASSUME( m_pBits != NULL );
  747. ATLASSERT( IsIndexed() );
  749. GetDC();
  751. ::GetDIBColorTable( m_hDC, iFirstColor, nColors, prgbColors );
  753. ReleaseDC();
  754. }
  756. inline HDC CImage::GetDC() const throw()
  757. {
  758. ATLASSUME( m_hBitmap != NULL );
  760. m_nDCRefCount++;
  761. if( m_hDC == NULL )
  762. {
  763. m_hDC = s_cache.GetDC();
  764. m_hOldBitmap = HBITMAP( ::SelectObject( m_hDC, m_hBitmap ) );
  765. }
  767. return( m_hDC );
  768. }
  770. inline bool CImage::ShouldExcludeFormat( REFGUID guidFileType, DWORD dwExclude ) throw()
  771. {
  772. static const GUID* apguidFormats[] =
  773. {
  774. &Gdiplus::ImageFormatGIF,
  775. &Gdiplus::ImageFormatBMP,
  776. &Gdiplus::ImageFormatEMF,
  777. &Gdiplus::ImageFormatWMF,
  778. &Gdiplus::ImageFormatJPEG,
  779. &Gdiplus::ImageFormatPNG,
  780. &Gdiplus::ImageFormatTIFF,
  781. &Gdiplus::ImageFormatIcon,
  782. NULL
  783. };
  785. ATLASSERT( (dwExclude|excludeValid) == excludeValid );
  786. for( int iFormat = 0; apguidFormats[iFormat] != NULL; iFormat++ )
  787. {
  788. if( guidFileType == *apguidFormats[iFormat] )
  789. {
  790. return( (dwExclude&(1<<iFormat)) != 0 );
  791. }
  792. }
  794. return( (dwExclude&excludeOther) != 0 );
  795. }
  797. inline void CImage::BuildCodecFilterString( const Gdiplus::ImageCodecInfo* pCodecs, UINT nCodecs,
  798. CSimpleString& strFilter, CSimpleArray< GUID >& aguidFileTypes, LPCTSTR pszAllFilesDescription, 
  799. DWORD dwExclude, TCHAR chSeparator )
  800. {
  801. if( pszAllFilesDescription != NULL )
  802. {
  803. aguidFileTypes.Add( GUID_NULL );
  804. }
  806. CString strAllExtensions;
  807. CString strTempFilter;
  808. for( UINT iCodec = 0; iCodec < nCodecs; iCodec++ )
  809. {
  810. const Gdiplus::ImageCodecInfo* pCodec = &pCodecs[iCodec];
  812. if( !ShouldExcludeFormat( pCodec->FormatID, dwExclude ) )
  813. {
  814. CW2CT pwszFilenameExtension( pCodec->FilenameExtension );
  815. strTempFilter += CW2CT( pCodec->FormatDescription );
  816. strTempFilter += _T( " (" );
  817. strTempFilter += pwszFilenameExtension;
  818. strTempFilter += _T( ")" );
  819. strTempFilter += chSeparator;
  820. strTempFilter += pwszFilenameExtension;
  821. strTempFilter += chSeparator;
  823. aguidFileTypes.Add( pCodec->FormatID );
  825. if( !strAllExtensions.IsEmpty() )
  826. {
  827. strAllExtensions += _T( ";" );
  828. }
  829. strAllExtensions += pwszFilenameExtension;
  830. }
  831. }
  833. if( pszAllFilesDescription != NULL )
  834. {
  835. strFilter += pszAllFilesDescription;
  836. strFilter += chSeparator;
  837. strFilter += strAllExtensions;
  838. strFilter += chSeparator;
  839. }
  840. strFilter += strTempFilter;
  842. strFilter += chSeparator;
  843. if( aguidFileTypes.GetSize() == 0 )
  844. {
  845. strFilter += chSeparator;
  846. }
  847. }
  849. inline HRESULT CImage::GetImporterFilterString( CSimpleString& strImporters, 
  850. CSimpleArray< GUID >& aguidFileTypes, LPCTSTR pszAllFilesDescription /* = NULL */,
  851. DWORD dwExclude /* = excludeDefaultLoad */, TCHAR chSeparator /* = '|' */ )
  852. {
  853. if( !InitGDIPlus() )
  854. {
  855. return( E_FAIL );
  856. }
  858. UINT nCodecs;
  859. UINT nSize;
  860. Gdiplus::Status status;
  861. Gdiplus::ImageCodecInfo* pCodecs;
  863. status = Gdiplus::GetImageDecodersSize( &nCodecs, &nSize );
  864. USES_ATL_SAFE_ALLOCA;
  865. pCodecs = static_cast< Gdiplus::ImageCodecInfo* >( _ATL_SAFE_ALLOCA(nSize, _ATL_SAFE_ALLOCA_DEF_THRESHOLD) );
  867. if( pCodecs == NULL )
  868. return E_OUTOFMEMORY;
  870. status = Gdiplus::GetImageDecoders( nCodecs, nSize, pCodecs );
  871. BuildCodecFilterString( pCodecs, nCodecs, strImporters, aguidFileTypes, pszAllFilesDescription, dwExclude, chSeparator );
  873. return( S_OK );
  874. }
  876. inline HRESULT CImage::GetExporterFilterString( CSimpleString& strExporters, 
  877. CSimpleArray< GUID >& aguidFileTypes, LPCTSTR pszAllFilesDescription /* = NULL */,
  878. DWORD dwExclude /* = excludeDefaultSave */, TCHAR chSeparator /* = '|' */ )
  879. {
  880. if( !InitGDIPlus() )
  881. {
  882. return( E_FAIL );
  883. }
  885. UINT nCodecs;
  886. UINT nSize;
  887. Gdiplus::Status status;
  888. Gdiplus::ImageCodecInfo* pCodecs;
  890. status = Gdiplus::GetImageDecodersSize( &nCodecs, &nSize );
  891. USES_ATL_SAFE_ALLOCA;
  892. pCodecs = static_cast< Gdiplus::ImageCodecInfo* >( _ATL_SAFE_ALLOCA(nSize, _ATL_SAFE_ALLOCA_DEF_THRESHOLD) );
  894. if( pCodecs == NULL )
  895. return E_OUTOFMEMORY;
  897. status = Gdiplus::GetImageDecoders( nCodecs, nSize, pCodecs );
  898. BuildCodecFilterString( pCodecs, nCodecs, strExporters, aguidFileTypes, pszAllFilesDescription, dwExclude, chSeparator );
  900. return( S_OK );
  901. }
  903. inline int CImage::GetHeight() const throw()
  904. {
  905. ATLASSUME( m_hBitmap != NULL );
  907. return( m_nHeight );
  908. }
  910. inline int CImage::GetMaxColorTableEntries() const throw()
  911. {
  912. ATLASSUME( m_hBitmap != NULL );
  913. ATLASSERT( IsDIBSection() );
  915. if( IsIndexed() )
  916. {
  917. return( 1<<m_nBPP );
  918. }
  919. else
  920. {
  921. return( 0 );
  922. }
  923. }
  925. inline int CImage::GetPitch() const throw()
  926. {
  927. ATLASSUME( m_hBitmap != NULL );
  928. ATLASSERT( IsDIBSection() );
  930. return( m_nPitch );
  931. }
  933. inline COLORREF CImage::GetPixel( int x, int y ) const throw()
  934. {
  935. ATLASSUME( m_hBitmap != NULL );
  936. ATLASSERT( (x >= 0) && (x < m_nWidth) );
  937. ATLASSERT( (y >= 0) && (y < m_nHeight) );
  939. GetDC();
  941. COLORREF clr = ::GetPixel( m_hDC, x, y );
  943. ReleaseDC();
  945. return( clr );
  946. }
  948. inline const void* CImage::GetPixelAddress( int x, int y ) const throw()
  949. {
  950. ATLASSUME( m_hBitmap != NULL );
  951. ATLASSERT( IsDIBSection() );
  952. ATLASSERT( (x >= 0) && (x < m_nWidth) );
  953. ATLASSERT( (y >= 0) && (y < m_nHeight) );
  955. return( LPBYTE( m_pBits )+(y*m_nPitch)+((x*m_nBPP)/8) );
  956. }
  958. inline void* CImage::GetPixelAddress( int x, int y ) throw()
  959. {
  960. ATLASSUME( m_hBitmap != NULL );
  961. ATLASSERT( IsDIBSection() );
  962. ATLASSERT( (x >= 0) && (x < m_nWidth) );
  963. ATLASSERT( (y >= 0) && (y < m_nHeight) );
  965. return( LPBYTE( m_pBits )+(y*m_nPitch)+((x*m_nBPP)/8) );
  966. }
  968. inline LONG CImage::GetTransparentColor() const throw()
  969. {
  970. ATLASSUME( m_hBitmap != NULL );
  971. ATLASSERT( (m_nBPP == 4) || (m_nBPP == 8) );
  973. return( m_iTransparentColor );
  974. }
  976. inline int CImage::GetWidth() const throw()
  977. {
  978. ATLASSUME( m_hBitmap != NULL );
  980. return( m_nWidth );
  981. }
  983. inline bool CImage::IsDIBSection() const throw()
  984. {
  985. return( m_bIsDIBSection );
  986. }
  988. inline bool CImage::IsIndexed() const throw()
  989. {
  990. ATLASSUME( m_hBitmap != NULL );
  991. ATLASSERT( IsDIBSection() );
  993. return( m_nBPP <= 8 );
  994. }
  996. inline bool CImage::IsNull() const throw()
  997. {
  998. return( m_hBitmap == NULL );
  999. }
  1001. inline HRESULT CImage::Load( IStream* pStream ) throw()
  1002. {
  1003. if( !InitGDIPlus() )
  1004. {
  1005. return( E_FAIL );
  1006. }
  1008. Gdiplus::Bitmap bmSrc( pStream );
  1009. if( bmSrc.GetLastStatus() != Gdiplus::Ok )
  1010. {
  1011. return( E_FAIL );
  1012. }
  1014. return( CreateFromGdiplusBitmap( bmSrc ) );
  1015. }
  1017. inline HRESULT CImage::Load( LPCTSTR pszFileName ) throw()
  1018. {
  1019. if( !InitGDIPlus() )
  1020. {
  1021. return( E_FAIL );
  1022. }
  1024. Gdiplus::Bitmap bmSrc( (CT2W)pszFileName );
  1025. if( bmSrc.GetLastStatus() != Gdiplus::Ok )
  1026. {
  1027. return( E_FAIL );
  1028. }
  1030. return( CreateFromGdiplusBitmap( bmSrc ) );
  1031. }
  1033. inline HRESULT CImage::CreateFromGdiplusBitmap( Gdiplus::Bitmap& bmSrc ) throw()
  1034. {
  1035. Gdiplus::PixelFormat eSrcPixelFormat = bmSrc.GetPixelFormat();
  1036. UINT nBPP = 32;
  1037. DWORD dwFlags = 0;
  1038. Gdiplus::PixelFormat eDestPixelFormat = PixelFormat32bppRGB;
  1039. if( eSrcPixelFormat&PixelFormatGDI )
  1040. {
  1041. nBPP = Gdiplus::GetPixelFormatSize( eSrcPixelFormat );
  1042. eDestPixelFormat = eSrcPixelFormat;
  1043. }
  1044. if( Gdiplus::IsAlphaPixelFormat( eSrcPixelFormat ) )
  1045. {
  1046. nBPP = 32;
  1047. dwFlags |= createAlphaChannel;
  1048. eDestPixelFormat = PixelFormat32bppARGB;
  1049. }
  1051. BOOL bSuccess = Create( bmSrc.GetWidth(), bmSrc.GetHeight(), nBPP, dwFlags );
  1052. if( !bSuccess )
  1053. {
  1054. return( E_FAIL );
  1055. }
  1056. USES_ATL_SAFE_ALLOCA;
  1057. Gdiplus::ColorPalette* pPalette = NULL;
  1058. if( Gdiplus::IsIndexedPixelFormat( eSrcPixelFormat ) )
  1059. {
  1060. UINT nPaletteSize = bmSrc.GetPaletteSize();
  1061. pPalette = static_cast< Gdiplus::ColorPalette* >( _ATL_SAFE_ALLOCA(nPaletteSize, _ATL_SAFE_ALLOCA_DEF_THRESHOLD) );
  1063. if( pPalette == NULL )
  1064. return E_OUTOFMEMORY;
  1066. bmSrc.GetPalette( pPalette, nPaletteSize );
  1068. RGBQUAD argbPalette[256];
  1069. ATLASSERT( (pPalette->Count > 0) && (pPalette->Count <= 256) );
  1070. for( UINT iColor = 0; iColor < pPalette->Count; iColor++ )
  1071. {
  1072. Gdiplus::ARGB color = pPalette->Entries[iColor];
  1073. argbPalette[iColor].rgbRed = (BYTE)( (color>>RED_SHIFT) & 0xff );
  1074. argbPalette[iColor].rgbGreen = (BYTE)( (color>>GREEN_SHIFT) & 0xff );
  1075. argbPalette[iColor].rgbBlue = (BYTE)( (color>>BLUE_SHIFT) & 0xff );
  1076. argbPalette[iColor].rgbReserved = 0;
  1077. }
  1079. SetColorTable( 0, pPalette->Count, argbPalette );
  1080. }
  1082. if( eDestPixelFormat == eSrcPixelFormat )
  1083. {
  1084. // The pixel formats are identical, so just memcpy the rows.
  1085. Gdiplus::BitmapData data;
  1086. Gdiplus::Rect rect( 0, 0, GetWidth(), GetHeight() );
  1087. if(bmSrc.LockBits( &rect, Gdiplus::ImageLockModeRead, eSrcPixelFormat, &data )!=Gdiplus::Ok)
  1088. {
  1089. return E_OUTOFMEMORY;
  1090. }
  1092. size_t nBytesPerRow = AtlAlignUp( nBPP*GetWidth(), 8 )/8;
  1093. BYTE* pbDestRow = static_cast< BYTE* >( GetBits() );
  1094. BYTE* pbSrcRow = static_cast< BYTE* >( data.Scan0 );
  1095. for( int y = 0; y < GetHeight(); y++ )
  1096. {
  1097. Checked::memcpy_s(pbDestRow, nBytesPerRow, pbSrcRow, nBytesPerRow);
  1098. pbDestRow += GetPitch();
  1099. pbSrcRow += data.Stride;
  1100. }
  1102. bmSrc.UnlockBits( &data );
  1103. }
  1104. else
  1105. {
  1106. // Let GDI+ work its magic
  1107. Gdiplus::Bitmap bmDest( GetWidth(), GetHeight(), GetPitch(), eDestPixelFormat, static_cast< BYTE* >( GetBits() ) );
  1108. Gdiplus::Graphics gDest( &bmDest );
  1110. gDest.DrawImage( &bmSrc, 0, 0 );
  1111. }
  1113. return( S_OK );
  1114. }
  1116. inline void CImage::LoadFromResource( HINSTANCE hInstance, LPCTSTR pszResourceName ) throw()
  1117. {
  1118. HBITMAP hBitmap;
  1120. hBitmap = HBITMAP( ::LoadImage( hInstance, pszResourceName, IMAGE_BITMAP, 0, 
  1121. 0, LR_CREATEDIBSECTION ) );
  1123. Attach( hBitmap );
  1124. }
  1126. inline void CImage::LoadFromResource( HINSTANCE hInstance, UINT nIDResource ) throw()
  1127. {
  1128. LoadFromResource( hInstance, MAKEINTRESOURCE( nIDResource ) );
  1129. }
  1131. inline BOOL CImage::MaskBlt( HDC hDestDC, int xDest, int yDest, int nWidth, 
  1132. int nHeight, int xSrc, int ySrc, HBITMAP hbmMask, int xMask, int yMask,
  1133. DWORD dwROP ) const throw()
  1134. {
  1135. BOOL bResult;
  1137. ATLASSUME( m_hBitmap != NULL );
  1138. ATLASSERT( hDestDC != NULL );
  1140. GetDC();
  1142. bResult = ::MaskBlt( hDestDC, xDest, yDest, nWidth, nHeight, m_hDC, xSrc, 
  1143. ySrc, hbmMask, xMask, yMask, dwROP );
  1145. ReleaseDC();
  1147. return( bResult );
  1148. }
  1150. inline BOOL CImage::MaskBlt( HDC hDestDC, const RECT& rectDest, 
  1151. const POINT& pointSrc, HBITMAP hbmMask, const POINT& pointMask, 
  1152. DWORD dwROP ) const throw()
  1153. {
  1154. return( MaskBlt( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  1155. rectDest.left, rectDest.bottom-rectDest.top, pointSrc.x, pointSrc.y, 
  1156. hbmMask, pointMask.x, pointMask.y, dwROP ) );
  1157. }
  1159. inline BOOL CImage::MaskBlt( HDC hDestDC, int xDest, int yDest, HBITMAP hbmMask, 
  1160. DWORD dwROP ) const throw()
  1161. {
  1162. return( MaskBlt( hDestDC, xDest, yDest, m_nWidth, m_nHeight, 0, 0, hbmMask, 
  1163. 0, 0, dwROP ) );
  1164. }
  1166. inline BOOL CImage::MaskBlt( HDC hDestDC, const POINT& pointDest, HBITMAP hbmMask,
  1167. DWORD dwROP ) const throw()
  1168. {
  1169. return( MaskBlt( hDestDC, pointDest.x, pointDest.y, m_nWidth, m_nHeight, 0, 
  1170. 0, hbmMask, 0, 0, dwROP ) );
  1171. }
  1173. inline BOOL CImage::PlgBlt( HDC hDestDC, const POINT* pPoints, int xSrc, 
  1174. int ySrc, int nSrcWidth, int nSrcHeight, HBITMAP hbmMask, int xMask, 
  1175. int yMask ) const throw()
  1176. {
  1177. BOOL bResult;
  1179. ATLASSUME( m_hBitmap != NULL );
  1180. ATLASSERT( hDestDC != NULL );
  1182. GetDC();
  1184. bResult = ::PlgBlt( hDestDC, pPoints, m_hDC, xSrc, ySrc, nSrcWidth, 
  1185. nSrcHeight, hbmMask, xMask, yMask );
  1187. ReleaseDC();
  1189. return( bResult );
  1190. }
  1192. inline BOOL CImage::PlgBlt( HDC hDestDC, const POINT* pPoints, 
  1193. const RECT& rectSrc, HBITMAP hbmMask, const POINT& pointMask ) const throw()
  1194. {
  1195. return( PlgBlt( hDestDC, pPoints, rectSrc.left, rectSrc.top, rectSrc.right-
  1196. rectSrc.left, rectSrc.bottom-rectSrc.top, hbmMask, pointMask.x, 
  1197. pointMask.y ) );
  1198. }
  1200. inline BOOL CImage::PlgBlt( HDC hDestDC, const POINT* pPoints, 
  1201. HBITMAP hbmMask ) const throw()
  1202. {
  1203. return( PlgBlt( hDestDC, pPoints, 0, 0, m_nWidth, m_nHeight, hbmMask, 0, 
  1204. 0 ) );
  1205. }
  1207. inline void CImage::ReleaseDC() const throw()
  1208. {
  1209. HBITMAP hBitmap;
  1211. ATLASSUME( m_hDC != NULL );
  1213. m_nDCRefCount--;
  1214. if( m_nDCRefCount == 0 )
  1215. {
  1216. hBitmap = HBITMAP( ::SelectObject( m_hDC, m_hOldBitmap ) );
  1217. ATLASSERT( hBitmap == m_hBitmap );
  1218. s_cache.ReleaseDC( m_hDC );
  1219. m_hDC = NULL;
  1220. }
  1221. }
  1223. inline CLSID CImage::FindCodecForExtension( LPCTSTR pszExtension, const Gdiplus::ImageCodecInfo* pCodecs, UINT nCodecs )
  1224. {
  1225. CT2CW pszExtensionW( pszExtension );
  1227. for( UINT iCodec = 0; iCodec < nCodecs; iCodec++ )
  1228. {
  1229. CStringW strExtensions( pCodecs[iCodec].FilenameExtension );
  1231. int iStart = 0;
  1232. do
  1233. {
  1234. CStringW strExtension = ::PathFindExtensionW( strExtensions.Tokenize( L";", iStart ) );
  1235. if( iStart != -1 )
  1236. {
  1237. if( strExtension.CompareNoCase( pszExtensionW ) == 0 )
  1238. {
  1239. return( pCodecs[iCodec].Clsid );
  1240. }
  1241. }
  1242. } while( iStart != -1 );
  1243. }
  1245. return( CLSID_NULL );
  1246. }
  1248. inline CLSID CImage::FindCodecForFileType( REFGUID guidFileType, const Gdiplus::ImageCodecInfo* pCodecs, UINT nCodecs )
  1249. {
  1250. for( UINT iCodec = 0; iCodec < nCodecs; iCodec++ )
  1251. {
  1252. if( pCodecs[iCodec].FormatID == guidFileType )
  1253. {
  1254. return( pCodecs[iCodec].Clsid );
  1255. }
  1256. }
  1258. return( CLSID_NULL );
  1259. }
  1261. inline HRESULT CImage::Save( IStream* pStream, REFGUID guidFileType ) const throw()
  1262. {
  1263. if( !InitGDIPlus() )
  1264. {
  1265. return( E_FAIL );
  1266. }
  1268. UINT nEncoders;
  1269. UINT nBytes;
  1270. Gdiplus::Status status;
  1272. status = Gdiplus::GetImageEncodersSize( &nEncoders, &nBytes );
  1273. if( status != Gdiplus::Ok )
  1274. {
  1275. return( E_FAIL );
  1276. }
  1278. USES_ATL_SAFE_ALLOCA;
  1279. Gdiplus::ImageCodecInfo* pEncoders = static_cast< Gdiplus::ImageCodecInfo* >( _ATL_SAFE_ALLOCA(nBytes, _ATL_SAFE_ALLOCA_DEF_THRESHOLD) );
  1281. if( pEncoders == NULL )
  1282. return E_OUTOFMEMORY;
  1284. status = Gdiplus::GetImageEncoders( nEncoders, nBytes, pEncoders );
  1285. if( status != Gdiplus::Ok )
  1286. {
  1287. return( E_FAIL );
  1288. }
  1290. CLSID clsidEncoder = FindCodecForFileType( guidFileType, pEncoders, nEncoders );
  1291. if( clsidEncoder == CLSID_NULL )
  1292. {
  1293. return( E_FAIL );
  1294. }
  1296. if( m_bHasAlphaChannel )
  1297. {
  1298. ATLASSUME( m_nBPP == 32 );
  1299. Gdiplus::Bitmap bm( m_nWidth, m_nHeight, m_nPitch, PixelFormat32bppARGB, static_cast< BYTE* >( m_pBits ) );
  1300. status = bm.Save( pStream, &clsidEncoder, NULL );
  1301. if( status != Gdiplus::Ok )
  1302. {
  1303. return( E_FAIL );
  1304. }
  1305. }
  1306. else
  1307. {
  1308. Gdiplus::Bitmap bm( m_hBitmap, NULL );
  1309. status = bm.Save( pStream, &clsidEncoder, NULL );
  1310. if( status != Gdiplus::Ok )
  1311. {
  1312. return( E_FAIL );
  1313. }
  1314. }
  1316. return( S_OK );
  1317. }
  1319. inline HRESULT CImage::Save( LPCTSTR pszFileName, REFGUID guidFileType ) const throw()
  1320. {
  1321. if( !InitGDIPlus() )
  1322. {
  1323. return( E_FAIL );
  1324. }
  1326. UINT nEncoders;
  1327. UINT nBytes;
  1328. Gdiplus::Status status;
  1330. status = Gdiplus::GetImageEncodersSize( &nEncoders, &nBytes );
  1331. if( status != Gdiplus::Ok )
  1332. {
  1333. return( E_FAIL );
  1334. }
  1336. USES_CONVERSION_EX;
  1337. Gdiplus::ImageCodecInfo* pEncoders = static_cast< Gdiplus::ImageCodecInfo* >( _ATL_SAFE_ALLOCA(nBytes, _ATL_SAFE_ALLOCA_DEF_THRESHOLD) );
  1339. if( pEncoders == NULL )
  1340. return E_OUTOFMEMORY;
  1342. status = Gdiplus::GetImageEncoders( nEncoders, nBytes, pEncoders );
  1343. if( status != Gdiplus::Ok )
  1344. {
  1345. return( E_FAIL );
  1346. }
  1348. CLSID clsidEncoder = CLSID_NULL;
  1349. if( guidFileType == GUID_NULL )
  1350. {
  1351. // Determine clsid from extension
  1352. clsidEncoder = FindCodecForExtension( ::PathFindExtension( pszFileName ), pEncoders, nEncoders );
  1353. }
  1354. else
  1355. {
  1356. // Determine clsid from file type
  1357. clsidEncoder = FindCodecForFileType( guidFileType, pEncoders, nEncoders );
  1358. }
  1359. if( clsidEncoder == CLSID_NULL )
  1360. {
  1361. return( E_FAIL );
  1362. }
  1364. LPCWSTR pwszFileName = T2CW_EX( pszFileName, _ATL_SAFE_ALLOCA_DEF_THRESHOLD );
  1365. #ifndef _UNICODE
  1366. if( pwszFileName == NULL )
  1367. return E_OUTOFMEMORY;
  1368. #endif // _UNICODE
  1369. if( m_bHasAlphaChannel )
  1370. {
  1371. ATLASSUME( m_nBPP == 32 );
  1372. Gdiplus::Bitmap bm( m_nWidth, m_nHeight, m_nPitch, PixelFormat32bppARGB, static_cast< BYTE* >( m_pBits ) );
  1373. status = bm.Save( pwszFileName, &clsidEncoder, NULL );
  1374. if( status != Gdiplus::Ok )
  1375. {
  1376. return( E_FAIL );
  1377. }
  1378. }
  1379. else
  1380. {
  1381. Gdiplus::Bitmap bm( m_hBitmap, NULL );
  1382. status = bm.Save( pwszFileName, &clsidEncoder, NULL );
  1383. if( status != Gdiplus::Ok )
  1384. {
  1385. return( E_FAIL );
  1386. }
  1387. }
  1389. return( S_OK );
  1390. }
  1392. inline void CImage::SetColorTable( UINT iFirstColor, UINT nColors, 
  1393. const RGBQUAD* prgbColors ) throw()
  1394. {
  1395. ATLASSUME( m_hBitmap != NULL );
  1396. ATLASSERT( IsDIBSection() );
  1397. ATLASSERT( IsIndexed() );
  1399. GetDC();
  1401. ::SetDIBColorTable( m_hDC, iFirstColor, nColors, prgbColors );
  1403. ReleaseDC();
  1404. }
  1406. inline void CImage::SetPixel( int x, int y, COLORREF color ) throw()
  1407. {
  1408. ATLASSUME( m_hBitmap != NULL );
  1409. ATLASSERT( (x >= 0) && (x < m_nWidth) );
  1410. ATLASSERT( (y >= 0) && (y < m_nHeight) );
  1412. GetDC();
  1414. ::SetPixel( m_hDC, x, y, color );
  1416. ReleaseDC();
  1417. }
  1419. inline void CImage::SetPixelIndexed( int x, int y, int iIndex ) throw()
  1420. {
  1421. SetPixel( x, y, PALETTEINDEX( iIndex ) );
  1422. }
  1424. inline void CImage::SetPixelRGB( int x, int y, BYTE r, BYTE g, BYTE b ) throw()
  1425. {
  1426. SetPixel( x, y, RGB( r, g, b ) );
  1427. }
  1429. inline LONG CImage::SetTransparentColor( LONG iTransparentColor ) throw()
  1430. {
  1431. LONG iOldTransparentColor;
  1433. ATLASSUME( m_hBitmap != NULL );
  1434. ATLASSERT( (m_nBPP == 4) || (m_nBPP == 8) );
  1435. ATLASSERT( iTransparentColor < GetMaxColorTableEntries() );
  1436. ATLASSERT( iTransparentColor >= -1 );
  1438. iOldTransparentColor = m_iTransparentColor;
  1439. m_iTransparentColor = iTransparentColor;
  1441. return( iOldTransparentColor );
  1442. }
  1444. inline BOOL CImage::StretchBlt( HDC hDestDC, int xDest, int yDest, 
  1445. int nDestWidth, int nDestHeight, DWORD dwROP ) const throw()
  1446. {
  1447. return( StretchBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, 0, 0, 
  1448. m_nWidth, m_nHeight, dwROP ) );
  1449. }
  1451. inline BOOL CImage::StretchBlt( HDC hDestDC, const RECT& rectDest, 
  1452. DWORD dwROP ) const throw()
  1453. {
  1454. return( StretchBlt( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  1455. rectDest.left, rectDest.bottom-rectDest.top, 0, 0, m_nWidth, m_nHeight, 
  1456. dwROP ) );
  1457. }
  1459. inline BOOL CImage::StretchBlt( HDC hDestDC, int xDest, int yDest, 
  1460. int nDestWidth, int nDestHeight, int xSrc, int ySrc, int nSrcWidth, 
  1461. int nSrcHeight, DWORD dwROP ) const throw()
  1462. {
  1463. BOOL bResult;
  1465. ATLASSUME( m_hBitmap != NULL );
  1466. ATLASSERT( hDestDC != NULL );
  1468. GetDC();
  1470. bResult = ::StretchBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, m_hDC,
  1471. xSrc, ySrc, nSrcWidth, nSrcHeight, dwROP );
  1473. ReleaseDC();
  1475. return( bResult );
  1476. }
  1478. inline BOOL CImage::StretchBlt( HDC hDestDC, const RECT& rectDest, 
  1479. const RECT& rectSrc, DWORD dwROP ) const throw()
  1480. {
  1481. return( StretchBlt( hDestDC, rectDest.left, rectDest.top, rectDest.right-
  1482. rectDest.left, rectDest.bottom-rectDest.top, rectSrc.left, rectSrc.top, 
  1483. rectSrc.right-rectSrc.left, rectSrc.bottom-rectSrc.top, dwROP ) );
  1484. }
  1486. #if WINVER >= 0x0500
  1487. inline BOOL CImage::TransparentBlt( HDC hDestDC, int xDest, int yDest, 
  1488. int nDestWidth, int nDestHeight, UINT crTransparent ) const throw()
  1489. {
  1490. return( TransparentBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight, 0, 
  1491. 0, m_nWidth, m_nHeight, crTransparent ) );
  1492. }
  1494. inline BOOL CImage::TransparentBlt( HDC hDestDC, const RECT& rectDest, 
  1495. UINT crTransparent ) const throw()
  1496. {
  1497. return( TransparentBlt( hDestDC, rectDest.left, rectDest.top, 
  1498. rectDest.right-rectDest.left, rectDest.bottom-rectDest.top, 
  1499. crTransparent ) );
  1500. }
  1502. inline BOOL CImage::TransparentBlt( HDC hDestDC, int xDest, int yDest, 
  1503. int nDestWidth, int nDestHeight, int xSrc, int ySrc, int nSrcWidth, 
  1504. int nSrcHeight, UINT crTransparent ) const throw()
  1505. {
  1506. BOOL bResult;
  1508. ATLASSUME( m_hBitmap != NULL );
  1509. ATLASSERT( hDestDC != NULL );
  1511. GetDC();
  1513. if( crTransparent == CLR_INVALID )
  1514. {
  1515. crTransparent = GetTransparentRGB();
  1516. }
  1518. bResult = ::TransparentBlt( hDestDC, xDest, yDest, nDestWidth, nDestHeight,
  1519. m_hDC, xSrc, ySrc, nSrcWidth, nSrcHeight, crTransparent );
  1521. ReleaseDC();
  1523. return( bResult );
  1524. }
  1526. inline BOOL CImage::TransparentBlt( HDC hDestDC, const RECT& rectDest, 
  1527. const RECT& rectSrc, UINT crTransparent ) const throw()
  1528. {
  1529. return( TransparentBlt( hDestDC, rectDest.left, rectDest.top, 
  1530. rectDest.right-rectDest.left, rectDest.bottom-rectDest.top, rectSrc.left, 
  1531. rectSrc.top, rectSrc.right-rectSrc.left, rectSrc.bottom-rectSrc.top, 
  1532. crTransparent ) );
  1533. }
  1534. #endif  // WINVER >= 0x0500
  1536. inline BOOL CImage::IsTransparencySupported() throw()
  1537. {
  1538. #if WINVER >= 0x0500
  1539. return( _AtlBaseModule.m_bNT5orWin98 );
  1540. #else  // WINVER < 0x0500
  1541. return( FALSE );
  1542. #endif  // WINVER >= 0x0500
  1543. }
  1545. inline void CImage::UpdateBitmapInfo( DIBOrientation eOrientation )
  1546. {
  1547. DIBSECTION dibsection;
  1548. int nBytes;
  1550. nBytes = ::GetObject( m_hBitmap, sizeof( DIBSECTION ), &dibsection );
  1551. if( nBytes == sizeof( DIBSECTION ) )
  1552. {
  1553. m_bIsDIBSection = true;
  1554. m_nWidth = dibsection.dsBmih.biWidth;
  1555. m_nHeight = abs( dibsection.dsBmih.biHeight );
  1556. m_nBPP = dibsection.dsBmih.biBitCount;
  1557. m_nPitch = ComputePitch( m_nWidth, m_nBPP );
  1558. m_pBits = dibsection.dsBm.bmBits;
  1559. if( eOrientation == DIBOR_DEFAULT )
  1560. {
  1561. eOrientation = (dibsection.dsBmih.biHeight > 0) ? DIBOR_BOTTOMUP : DIBOR_TOPDOWN;
  1562. }
  1563. if( eOrientation == DIBOR_BOTTOMUP )
  1564. {
  1565. m_pBits = LPBYTE( m_pBits )+((m_nHeight-1)*m_nPitch);
  1566. m_nPitch = -m_nPitch;
  1567. }
  1568. }
  1569. else
  1570. {
  1571. // Non-DIBSection
  1572. ATLASSERT( nBytes == sizeof( BITMAP ) );
  1573. m_bIsDIBSection = false;
  1574. m_nWidth = dibsection.dsBm.bmWidth;
  1575. m_nHeight = dibsection.dsBm.bmHeight;
  1576. m_nBPP = dibsection.dsBm.bmBitsPixel;
  1577. m_nPitch = 0;
  1578. m_pBits = 0;
  1579. }
  1580. m_iTransparentColor = -1;
  1581. m_bHasAlphaChannel = false;
  1582. }
  1584. inline void CImage::GenerateHalftonePalette( LPRGBQUAD prgbPalette )
  1585. {
  1586. int r;
  1587. int g;
  1588. int b;
  1589. int gray;
  1590. LPRGBQUAD prgbEntry;
  1592. prgbEntry = prgbPalette;
  1593. for( r = 0; r < 6; r++ )
  1594. {
  1595. for( g = 0; g < 6; g++ )
  1596. {
  1597. for( b = 0; b < 6; b++ )
  1598. {
  1599. prgbEntry->rgbBlue = BYTE( b*255/5 );
  1600. prgbEntry->rgbGreen = BYTE( g*255/5 );
  1601. prgbEntry->rgbRed = BYTE( r*255/5 );
  1602. prgbEntry->rgbReserved = 0;
  1604. prgbEntry++;
  1605. }
  1606. }
  1607. }
  1609. for( gray = 0; gray < 20; gray++ )
  1610. {
  1611. prgbEntry->rgbBlue = BYTE( gray*255/20 );
  1612. prgbEntry->rgbGreen = BYTE( gray*255/20 );
  1613. prgbEntry->rgbRed = BYTE( gray*255/20 );
  1614. prgbEntry->rgbReserved = 0;
  1616. prgbEntry++;
  1617. }
  1618. }
  1620. inline COLORREF CImage::GetTransparentRGB() const
  1621. {
  1622. RGBQUAD rgb;
  1624. ATLASSUME( m_hDC != NULL );  // Must have a DC
  1625. ATLASSUME( m_iTransparentColor != -1 );
  1627. ::GetDIBColorTable( m_hDC, m_iTransparentColor, 1, &rgb );
  1629. return( RGB( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue ) );
  1630. }
  1632. inline bool CImage::InitGDIPlus() throw()
  1633. {
  1634. bool bSuccess = s_initGDIPlus.Init();
  1635. return( bSuccess );
  1636. }
  1638. };  // namespace ATL
  1640. #pragma pack(pop)
  1642. #ifndef _ATL_NO_PRAGMA_WARNINGS
  1643. #pragma warning (pop)
  1644. #endif
  1646. #endif  // __ATLIMAGE_H__