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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtSkinBitmap.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：19k
源码类别：

界面编程

开发平台：

Visual C++

ExtSkinBitmap.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "StdAfx.h"
  24. #if (!defined __PROF_SKIN_BITMAP_H)
  25. #include <../ProfSkin/ExtSkinBitmap.h>
  26. #endif
  28. #include <PNG.h>
  30. #ifdef _DEBUG
  31. #define new DEBUG_NEW
  32. #undef THIS_FILE
  33. static char THIS_FILE[] = __FILE__;
  34. #endif
  36. CExtSkinBitmap::CExtSkinBitmap()
  37. {
  38. }
  40. CExtSkinBitmap::CExtSkinBitmap(
  41. const CExtBitmap & other
  42. )
  43. : CExtBitmapCache( other )
  44. {
  45. }
  47. CExtSkinBitmap::~CExtSkinBitmap()
  48. {
  49. Empty();
  50. }
  52. bool CExtSkinBitmap::AssignFromOther(
  53. const CExtBitmap & other,
  54. bool bEnableThrowException // = false
  55. )
  56. {
  57. bool bRetVal =
  58. CExtBitmapCache::AssignFromOther(
  59. other,
  60. bEnableThrowException
  61. );
  62. return bRetVal;
  63. }
  65. void CExtSkinBitmap::Empty()
  66. {
  67. CExtBitmapCache::Empty();
  68. }
  70. bool CExtSkinBitmap::IsEmpty() const
  71. {
  72. bool bRetVal = CExtBitmapCache::IsEmpty();
  73. return bRetVal;
  74. }
  76. bool CExtSkinBitmap::LoadImage_File(
  77. __EXT_MFC_SAFE_LPCTSTR strFilePath,
  78. bool bMake32, //= false
  79. bool bEnableThrowException //= false
  80. )
  81. {
  82. if( !strFilePath || _tcslen( strFilePath ) == 0 )
  83. return false;
  85. TCHAR sExt[_MAX_EXT] = { 0 };
  86. __EXT_MFC_SPLITPATH( strFilePath, NULL, 0, NULL, 0, NULL, 0, sExt, _MAX_EXT );
  88. if( _tcsicmp( sExt, _T( ".png" ) ) == 0 )
  89. {
  90. if( ! LoadPNG_File( strFilePath, bMake32, bEnableThrowException ) )
  91. return false;
  93. return true;
  94. }
  95. else if( _tcsicmp( sExt, _T( ".bmp" ) ) == 0 )
  96. return LoadBMP_File( strFilePath, bMake32, bEnableThrowException );
  98. if( LoadPNG_File( strFilePath, bMake32, false ) )
  99. return true;
  101. if( LoadBMP_File( strFilePath, bMake32, false ) )
  102. return true;
  104. if( bEnableThrowException )
  105. AfxThrowUserException();
  107. return false;
  108. }
  110. bool CExtSkinBitmap::LoadPNG_Resource(
  111. HINSTANCE hInst,
  112. HRSRC hRsrc,
  113. bool bMake32, // = true
  114. bool bEnableThrowException // = false
  115. )
  116. {
  117. HGLOBAL hGlobal = ::LoadResource( hInst, hRsrc );
  118. if( hGlobal == NULL )
  119. {
  120. if( bEnableThrowException )
  121. ::AfxThrowUserException();
  122. return false;
  123. } // if( hGlobal == NULL )
  124. LPBYTE pData = (LPBYTE)::LockResource( hGlobal );
  125. DWORD dwResourceSize = ::SizeofResource( hInst, hRsrc );
  126. ASSERT( dwResourceSize > 0 );
  127. if( pData == NULL )
  128. {
  129. ::FreeResource( hGlobal );
  130. if( bEnableThrowException )
  131. ::AfxThrowUserException();
  132. return false;
  133. } // if( pData == NULL )
  134. try
  135. {
  136. CMemFile _file;
  137. _file.Attach( pData, dwResourceSize );
  138. _file.Seek( 0, CFile::begin );
  139. CArchive ar( &_file, CArchive::load );
  140. bool bRetVal =
  141. LoadPNG(
  142. ar,
  143. bMake32,
  144. bEnableThrowException
  145. );
  146. ::UnlockResource( hGlobal );
  147. ::FreeResource( hGlobal );
  148. return bRetVal;
  149. } // try
  150. catch( CException * pException )
  151. {
  152. ::UnlockResource( hGlobal );
  153. ::FreeResource( hGlobal );
  154. if( bEnableThrowException )
  155. throw;
  156. pException->Delete();
  157. } // catch( CException * pException )
  158. catch( ... )
  159. {
  160. ::UnlockResource( hGlobal );
  161. ::FreeResource( hGlobal );
  162. if( bEnableThrowException )
  163. throw;
  164. } // catch( ... )
  165. return false;
  166. }
  168. bool CExtSkinBitmap::LoadPNG_File(
  169. __EXT_MFC_SAFE_LPCTSTR strFilePath,
  170. bool bMake32, // = true
  171. bool bEnableThrowException // = false
  172. )
  173. {
  174. try
  175. {
  176. CFile _file(
  177. strFilePath,
  178. CFile::modeRead
  179. | CFile::typeBinary
  180. );
  181. return
  182. LoadPNG_File(
  183. _file,
  184. bMake32,
  185. bEnableThrowException
  186. );
  187. } // try
  188. catch( ... )
  189. {
  190. if( bEnableThrowException )
  191. throw;
  192. } // catch( ... )
  193. return false;
  194. }
  196. bool CExtSkinBitmap::LoadPNG_File(
  197. CFile & _file,
  198. bool bMake32, // = true
  199. bool bEnableThrowException // = false
  200. )
  201. {
  202. CArchive ar(
  203. &_file,
  204. CArchive::load
  205. );
  206. return
  207. LoadPNG(
  208. ar,
  209. bMake32,
  210. bEnableThrowException
  211. );
  212. }
  214. bool CExtSkinBitmap::LoadPNG(
  215. CArchive & ar,
  216. bool bMake32, // = true
  217. bool bEnableThrowException // = false
  218. )
  219. {
  220. ASSERT( ar.IsLoading() );
  221. Empty();
  222. m_pImageBuffer =
  223. stat_PngLoad(
  224. ar,
  225. bEnableThrowException
  226. );
  227. if( m_pImageBuffer == NULL )
  228. return false;
  229. OnLoad();
  230. if( bMake32 )
  231. return Make32( bEnableThrowException );
  232. return true;
  233. }
  235. bool CExtSkinBitmap::SavePNG_File(
  236. __EXT_MFC_SAFE_LPCTSTR strFilePath,
  237. bool bMake32, // = true
  238. bool bEnableThrowException // = false
  239. )
  240. {
  241. try
  242. {
  243. CFile _file(
  244. strFilePath,
  245. CFile::modeCreate
  246. | CFile::modeWrite
  247. | CFile::typeBinary
  248. );
  249. return
  250. SavePNG_File(
  251. _file,
  252. bMake32,
  253. bEnableThrowException
  254. );
  255. } // try
  256. catch( ... )
  257. {
  258. if( bEnableThrowException )
  259. throw;
  260. } // catch( ... )
  261. return false;
  262. }
  264. bool CExtSkinBitmap::SavePNG_File(
  265. CFile & _file,
  266. bool bMake32, // = true
  267. bool bEnableThrowException // = false
  268. )
  269. {
  270. CArchive ar(
  271. &_file,
  272. CArchive::store
  273. );
  274. return
  275. SavePNG(
  276. ar,
  277. bMake32,
  278. bEnableThrowException
  279. );
  280. }
  282. bool CExtSkinBitmap::SavePNG(
  283. CArchive & ar,
  284. bool bMake32, // = true
  285. bool bEnableThrowException // = false
  286. )
  287. {
  288. ASSERT( ar.IsStoring() );
  289. if( m_pImageBuffer == NULL )
  290. {
  291. ASSERT( FALSE );
  292. if( bEnableThrowException )
  293. ::AfxThrowUserException();
  294. return false;
  295. } // if( m_pImageBuffer == NULL )
  296. if( bMake32 )
  297. {
  298. if( ! Make32( bEnableThrowException ) )
  299. return false;
  300. } // if( bMake32 )
  301. return
  302. stat_PngSave(
  303. m_pImageBuffer,
  304. ar,
  305. bEnableThrowException
  306. );
  307. }
  309. void CExtSkinBitmap::stat_PngCallbackRead(
  310. LPVOID pCallbackData,
  311. LPBYTE pBuffer,
  312. size_t nSize
  313. )
  314. {
  315. ASSERT( pCallbackData != NULL );
  316. CArchive * pAr = (CArchive *)
  317. ::png_get_io_ptr(
  318. (png_structp) pCallbackData
  319. );
  320. ASSERT( pAr != NULL );
  321. pAr->Read( pBuffer, UINT(nSize) );
  322. }
  324. void CExtSkinBitmap::stat_PngCallbackWrite(
  325. LPVOID pCallbackData,
  326. LPBYTE pBuffer,
  327. size_t nSize
  328. )
  329. {
  330. ASSERT( pCallbackData != NULL );
  331. CArchive * pAr = (CArchive *)
  332. ::png_get_io_ptr(
  333. (png_structp) pCallbackData
  334. );
  335. ASSERT( pAr != NULL );
  336. pAr->Write( pBuffer, UINT(nSize) );
  337. }
  339. void CExtSkinBitmap::stat_PngCallbackFlush(
  340. LPVOID pCallbackData
  341. )
  342. {
  343. ASSERT( pCallbackData != NULL );
  344. CArchive * pAr = (CArchive *)
  345. ::png_get_io_ptr(
  346. (png_structp) pCallbackData
  347. );
  348. ASSERT( pAr != NULL );
  349. pAr->Flush();
  350. }
  352. void CExtSkinBitmap::stat_PngCallbackError(
  353. LPVOID pCallbackData,
  354. const char * strErrorDescription
  355. )
  356. {
  357. pCallbackData;
  358. strErrorDescription;
  359. ::AfxThrowUserException();
  360. }
  362. void CExtSkinBitmap::stat_PngCallbackWarning(
  363. LPVOID pCallbackData,
  364. const char * strWarningDescription
  365. )
  366. {
  367. pCallbackData;
  368. strWarningDescription;
  369. }
  371. bool CExtSkinBitmap::stat_PngCheckSwap32(
  372. LPBYTE pImageBuffer
  373. )
  374. {
  375. ASSERT( pImageBuffer != NULL );
  376. LPBITMAPINFOHEADER pBIH = stat_RcInfoHeader( pImageBuffer );
  377. if( pBIH->biBitCount == 32 || pBIH->biBitCount == 24 )
  378. {
  379. DWORD r = stat_MaskRed( pImageBuffer );
  380. DWORD g = stat_MaskGreen( pImageBuffer );
  381. DWORD b = stat_MaskBlue( pImageBuffer );
  382. if( r == 0x00ff0000
  383. && g == 0x0000ff00
  384. && b == 0x000000ff
  385. )
  386. {
  387. ULONG nScanLineSize = stat_RcScanLineSize( pBIH->biWidth, pBIH->biBitCount );
  388. INT x, y;
  389. for( y = 0; y < pBIH->biHeight; y++ )
  390. {
  391. LPBYTE pScanLine =
  392. stat_RcScanLine(
  393. pImageBuffer,
  394. ULONG( pBIH->biHeight - y - 1 ),
  395. nScanLineSize
  396. );
  397. COLORREF * ptrSrc = (COLORREF *)pScanLine;
  398. for( x = 0; x < pBIH->biWidth; x++ )
  399. {
  400. if( pBIH->biBitCount == 32 )
  401. {
  402. BYTE nSrcR = GetRValue( (*ptrSrc) );
  403. BYTE nSrcG = GetGValue( (*ptrSrc) );
  404. BYTE nSrcB = GetBValue( (*ptrSrc) );
  405. #define GetAValue__(rgb) ((BYTE)((rgb)>>24))
  406. BYTE nSrcA = GetAValue__( (*ptrSrc) );
  407. (*ptrSrc) = ( RGB( nSrcB, nSrcG, nSrcR ) | ( COLORREF(nSrcA) << 24 ) );
  408. ptrSrc++;
  409. } // pBIH->biBitCount == 32
  410. else
  411. {
  412. ASSERT( pBIH->biBitCount == 24 );
  413. LPBYTE ptr = (LPBYTE)ptrSrc;
  414. BYTE nTmp = ptr[0];
  415. ptr[0] = ptr[2];
  416. ptr[2] = nTmp;
  417. ptr += 3;
  418. ptrSrc = (COLORREF *)ptr;
  419. } // else from if( pBIH->biBitCount == 32 )
  420. } // for( x = 0; x < pBIH->biWidth; x++ )
  421. } // for( y = 0; y < pBIH->biHeight; y++ )
  422. return true;
  423. }
  424. } // if( pBIH->biBitCount == 32 || pBIH->biBitCount == 24 )
  425. return false;
  426. }
  428. LPBYTE CExtSkinBitmap::stat_PngLoad(
  429. CArchive & ar,
  430. bool bEnableThrowException
  431. )
  432. {
  433. ASSERT( ar.IsLoading() );
  434. png_structp pCallbackData = NULL;
  435. png_infop pInfoPNG = NULL;
  436. png_uint_32 nWidth, nHeight;
  437. png_colorp pPalettePNG;
  438. INT nColorType, nPaletteSize;
  439. INT nBitDepth, nPixelDepth;
  440. LPBYTE pImageBuffer = NULL;
  441. RGBQUAD * pPalette = NULL;
  442. png_bytepp pRows = NULL;
  443. try
  444. {
  445. BYTE png_check[8];
  446. ar.Read( png_check, 8 );
  447. if( ::png_sig_cmp(
  448. png_check,
  449. (png_size_t)0,
  450. 8
  451. ) != 0
  452. )
  453. ::AfxThrowUserException();
  454. pCallbackData =
  455. ::png_create_read_struct(
  456. PNG_LIBPNG_VER_STRING,
  457. (png_voidp)NULL,
  458. (png_error_ptr)stat_PngCallbackError,
  459. (png_error_ptr)stat_PngCallbackWarning
  460. );
  461. if( ! pCallbackData )
  462. ::AfxThrowUserException();
  463. pInfoPNG = ::png_create_info_struct( pCallbackData );
  464. if( ! pInfoPNG )
  465. {
  466. ::png_destroy_read_struct(
  467. &pCallbackData,
  468. (png_infopp)NULL,
  469. (png_infopp)NULL
  470. );
  471. ::AfxThrowUserException();
  472. }
  473. ::png_set_read_fn(
  474. pCallbackData,
  475. &ar,
  476. (png_rw_ptr)stat_PngCallbackRead
  477. );
  478. // disable warning 4611
  479. #pragma warning( push )
  480. #pragma warning ( disable : 4611 )
  481.         if( setjmp( png_jmpbuf( pCallbackData ) ) )
  482. {
  483. ::png_destroy_read_struct(
  484. &pCallbackData,
  485. &pInfoPNG,
  486. NULL
  487. );
  488. ::AfxThrowUserException();
  489. }
  490. // rollback warning 4611
  491. #pragma warning( pop )
  492. ::png_set_sig_bytes( pCallbackData, 8 );
  493. ::png_read_info( pCallbackData, pInfoPNG );
  494. ::png_get_IHDR(
  495. pCallbackData,
  496. pInfoPNG,
  497. &nWidth,
  498. &nHeight,
  499. &nBitDepth,
  500. &nColorType,
  501. NULL,
  502. NULL,
  503. NULL
  504. );
  505. nPixelDepth = pInfoPNG->pixel_depth;
  506. bool bAllocRGB = true;
  507. if( nBitDepth == 16 )
  508. {
  509. if( nPixelDepth == 16
  510. && nColorType == PNG_COLOR_TYPE_GRAY
  511. )
  512. bAllocRGB = false;
  513. else if( nPixelDepth == 48
  514. && nColorType == PNG_COLOR_TYPE_RGB
  515. )
  516. bAllocRGB = false;
  517. else
  518. {
  519. ::png_set_strip_16( pCallbackData );
  520. nBitDepth = 8;
  521. }
  522. } // if( nBitDepth == 16 )
  523. switch( nColorType )
  524. {
  525. case PNG_COLOR_TYPE_RGB:
  526. case PNG_COLOR_TYPE_RGB_ALPHA:
  527. break;
  528. case PNG_COLOR_TYPE_PALETTE:
  529. if( nPixelDepth == 2 )
  530. {
  531. ::png_set_packing( pCallbackData );
  532. nPixelDepth = 8;
  533. }
  534. break;
  535. case PNG_COLOR_TYPE_GRAY:
  536. if( nPixelDepth == 2 )
  537. {
  538. ::png_set_expand( pCallbackData );
  539. nPixelDepth = 8;
  540. }
  541. break;
  542. case PNG_COLOR_TYPE_GRAY_ALPHA:
  543. ::png_set_gray_to_rgb( pCallbackData );
  544. nPixelDepth = 32;
  545. break;
  546. default:
  547. ::AfxThrowUserException();
  548. } // switch( nColorType )
  549. ::png_read_update_info( pCallbackData, pInfoPNG );
  550. nColorType = ::png_get_color_type( pCallbackData, pInfoPNG );
  551. switch( nColorType )
  552. {
  553. case PNG_COLOR_TYPE_RGB:
  554. ::png_set_invert_alpha( pCallbackData );
  555. if( bAllocRGB )
  556. pImageBuffer =
  557. stat_AllocHL(
  558. nWidth,
  559. nHeight,
  560. 24,
  561. 0x00FF0000,
  562. 0x0000FF00,
  563. 0x000000FF,
  564. 0,
  565. 0
  566. );
  567. else
  568. pImageBuffer =
  569. stat_AllocHL(
  570. nWidth,
  571. nHeight,
  572. nPixelDepth,
  573. 0,
  574. 0,
  575. 0,
  576. 0,
  577. 0
  578. );
  579. break;
  580. case PNG_COLOR_TYPE_RGB_ALPHA:
  581. pImageBuffer =
  582. stat_AllocHL(
  583. nWidth,
  584. nHeight,
  585. 32,
  586. 0x00FF0000,
  587. 0x0000FF00,
  588. 0x000000FF,
  589. 0xFF000000,
  590. 0
  591. );
  592. break;
  593. case PNG_COLOR_TYPE_PALETTE:
  594. {
  595. pImageBuffer =
  596. stat_AllocHL(
  597. nWidth,
  598. nHeight,
  599. nPixelDepth,
  600. 0,
  601. 0,
  602. 0,
  603. 0,
  604. 0
  605. );
  606. ::png_get_PLTE(
  607. pCallbackData,
  608. pInfoPNG,
  609. &pPalettePNG,
  610. &nPaletteSize
  611. );
  612. pPalette = ( RGBQUAD * )
  613. ( pImageBuffer + sizeof( BITMAPINFOHEADER ) );
  614. INT nPaletteIndex;
  615. for( nPaletteIndex = 0; nPaletteIndex < nPaletteSize; nPaletteIndex++ )
  616. {
  617. pPalette[nPaletteIndex].rgbRed   = pPalettePNG[nPaletteIndex].red;
  618. pPalette[nPaletteIndex].rgbGreen = pPalettePNG[nPaletteIndex].green;
  619. pPalette[nPaletteIndex].rgbBlue  = pPalettePNG[nPaletteIndex].blue;
  620. } // for( nPaletteIndex = 0; nPaletteIndex < nPaletteSize; nPaletteIndex++ )
  621. }
  622. break;
  623. case PNG_COLOR_TYPE_GRAY:
  624. pImageBuffer =
  625. stat_AllocHL(
  626. nWidth,
  627. nHeight,
  628. nPixelDepth,
  629. 0,
  630. 0,
  631. 0,
  632. 0,
  633. 0
  634. );
  635. if( nPixelDepth <= 8 )
  636. {
  637. pPalette = ( RGBQUAD * )
  638. ( pImageBuffer + sizeof( BITMAPINFOHEADER ) );
  639. nPaletteSize = 1 << nPixelDepth;
  640. INT nPaletteIndex;
  641. for( nPaletteIndex = 0; nPaletteIndex < nPaletteSize; nPaletteIndex++ )
  642. {
  643. pPalette[nPaletteIndex].rgbRed
  644. = pPalette[nPaletteIndex].rgbGreen
  645. = pPalette[nPaletteIndex].rgbBlue
  646. = BYTE( ( nPaletteIndex * 255 ) / ( nPaletteSize - 1 ) );
  647. } // for( nPaletteIndex = 0; nPaletteIndex < nPaletteSize; nPaletteIndex++ )
  648. } // if( nPixelDepth <= 8 )
  649. break;
  650. default:
  651. ::AfxThrowUserException();
  652. } // switch( nColorType )
  653. LPBITMAPINFOHEADER pBIH = stat_RcInfoHeader( pImageBuffer );
  654. if( ::png_get_valid( pCallbackData, pInfoPNG, PNG_INFO_pHYs ) )
  655. {
  656. png_uint_32 nWidthPNG, nHeightPNG;
  657. int res_unit_type = 0;
  658. ::png_get_pHYs(
  659. pCallbackData,
  660. pInfoPNG,
  661. &nWidthPNG,
  662. &nHeightPNG,
  663. &res_unit_type
  664. );
  665. if( res_unit_type == 1 )
  666. {
  667. pBIH->biXPelsPerMeter = nWidthPNG;
  668. pBIH->biYPelsPerMeter = nHeightPNG;
  669. }
  670. } // if( ::png_get_valid( pCallbackData, pInfoPNG, PNG_INFO_pHYs ) )
  671. pRows = ( png_bytepp ) ::malloc( nHeight * sizeof(png_bytep) );
  672. if( ! pRows )
  673. {
  674. if( pPalette != NULL )
  675. ::png_free( pCallbackData, pPalette );
  676. ::png_destroy_read_struct(
  677. &pCallbackData,
  678. &pInfoPNG,
  679. NULL
  680. );
  681. stat_FreeHL( pImageBuffer );
  682. pImageBuffer = NULL;
  683. ::AfxThrowUserException();
  684. } // if( ! pRows )
  685. png_uint_32 nRow;
  686. for( nRow = 0; nRow < nHeight; nRow++)
  687. pRows[nHeight - 1 - nRow] =
  688. stat_RcScanLine(
  689. pImageBuffer,
  690. stat_RcScanLineSize(
  691. nWidth,
  692. pBIH->biBitCount
  693. ),
  694. nRow
  695. );
  697. ::png_read_image( pCallbackData, pRows );
  698. if( pRows )
  699. {
  700. ::free( pRows );
  701. pRows = NULL;
  702. }
  703. ::png_read_end( pCallbackData, pInfoPNG );
  704. if( pCallbackData )
  705. ::png_destroy_read_struct(
  706. &pCallbackData,
  707. &pInfoPNG,
  708. (png_infopp)NULL
  709. );
  710. stat_PngCheckSwap32( pImageBuffer );
  711. return pImageBuffer;
  712. } // try
  713. catch( CException * pException )
  714. {
  715. if( pCallbackData )
  716. ::png_destroy_read_struct(
  717. &pCallbackData,
  718. &pInfoPNG,
  719. (png_infopp)NULL
  720. );
  721. if( pRows )
  722. ::free( pRows );
  723. if( pImageBuffer )
  724. stat_FreeHL( pImageBuffer );
  725. if( bEnableThrowException )
  726. throw;
  727. pException->Delete();
  728. } // catch( CException * pException )
  729. catch( ... )
  730. {
  731. if( pCallbackData )
  732. ::png_destroy_read_struct(
  733. &pCallbackData,
  734. &pInfoPNG,
  735. (png_infopp)NULL
  736. );
  737. if( pRows )
  738. ::free( pRows );
  739. if( pImageBuffer )
  740. stat_FreeHL( pImageBuffer );
  741. if( bEnableThrowException )
  742. ::AfxThrowUserException();
  743. } // catch( ... )
  744. return NULL;
  745. }
  747. bool CExtSkinBitmap::stat_PngSave(
  748. LPBYTE pImageBuffer,
  749. CArchive & ar,
  750. bool bEnableThrowException
  751. )
  752. {
  753. ASSERT( pImageBuffer != NULL );
  754. ASSERT( ar.IsStoring() );
  755. png_structp pCallbackData = NULL;
  756. png_infop pInfoPNG = NULL;
  757. bool bCheckSwap32 = false;
  758. try
  759. {
  760. LPBITMAPINFOHEADER pBIH = stat_RcInfoHeader( pImageBuffer );
  761. if( pBIH->biBitCount != 32
  762. || stat_MaskAlpha( pImageBuffer ) == 0
  763. )
  764. ::AfxThrowUserException(); // not supported
  765. bCheckSwap32 = stat_PngCheckSwap32( pImageBuffer );
  766. INT nBitDepth = (pBIH->biBitCount > 8) ? 8 : pBIH->biBitCount;
  767. png_uint_32 nWidth = pBIH->biWidth;
  768. png_uint_32 nHeight = pBIH->biHeight;
  769. pCallbackData =
  770. ::png_create_write_struct(
  771. PNG_LIBPNG_VER_STRING,
  772. (png_voidp)NULL,
  773. (png_error_ptr)stat_PngCallbackError,
  774. (png_error_ptr)stat_PngCallbackWarning
  775. );
  776. if( ! pCallbackData )
  777. ::AfxThrowUserException();
  778. pInfoPNG = ::png_create_info_struct( pCallbackData );
  779. if( ! pInfoPNG )
  780. {
  781. ::png_destroy_write_struct(&pCallbackData,  (png_infopp)NULL);
  782. ::AfxThrowUserException();
  783. }
  784. // disable warning 4611
  785. #pragma warning( push )
  786. #pragma warning ( disable : 4611 )
  787. if( setjmp( png_jmpbuf( pCallbackData ) ) )
  788. {
  789. ::png_destroy_write_struct( &pCallbackData, &pInfoPNG );
  790. ::AfxThrowUserException();
  791. }
  792. // rollback warning 4611
  793. #pragma warning( pop )
  794. ::png_set_write_fn(
  795. pCallbackData,
  796. &ar,
  797. (png_rw_ptr)stat_PngCallbackWrite,
  798. (png_flush_ptr)stat_PngCallbackFlush
  799. );
  800. if( pBIH->biXPelsPerMeter > 0
  801. && pBIH->biXPelsPerMeter > 0
  802. )
  803. ::png_set_pHYs(
  804. pCallbackData,
  805. pInfoPNG,
  806. png_uint_32(pBIH->biXPelsPerMeter),
  807. png_uint_32(pBIH->biYPelsPerMeter),
  808. 1
  809. );
  810. ::png_set_IHDR(
  811. pCallbackData,
  812. pInfoPNG,
  813. nWidth,
  814. nHeight,
  815. nBitDepth, 
  816. PNG_COLOR_TYPE_RGBA,
  817. PNG_INTERLACE_NONE, 
  818. PNG_COMPRESSION_TYPE_BASE,
  819. PNG_FILTER_TYPE_BASE
  820. );
  821. ::png_write_info( pCallbackData, pInfoPNG );
  822. png_uint_32 nRow;
  823. for( nRow = 0; nRow < nHeight; nRow++ )
  824. {
  825. ::png_write_row(
  826. pCallbackData,
  827. stat_RcScanLine(
  828. pImageBuffer,
  829. stat_RcScanLineSize(
  830. nWidth,
  831. pBIH->biBitCount
  832. ),
  833. nHeight - nRow - 1
  834. )
  835. );
  836. }
  837. ::png_write_end( pCallbackData, pInfoPNG );
  838. ::png_destroy_write_struct( &pCallbackData, &pInfoPNG );
  839. if( bCheckSwap32 )
  840. stat_PngCheckSwap32( pImageBuffer );
  841. return true;
  842. } // try
  843. catch( CException * pException )
  844. {
  845. if( bCheckSwap32 )
  846. stat_PngCheckSwap32( pImageBuffer );
  847. if( pCallbackData )
  848. ::png_destroy_write_struct( &pCallbackData, &pInfoPNG );
  849. if( bEnableThrowException )
  850. throw;
  851. pException->Delete();
  852. } // catch( CException * pException )
  853. catch( ... )
  854. {
  855. if( bCheckSwap32 )
  856. stat_PngCheckSwap32( pImageBuffer );
  857. if( pCallbackData )
  858. ::png_destroy_write_struct( &pCallbackData, &pInfoPNG );
  859. if( bEnableThrowException )
  860. ::AfxThrowUserException();
  861. } // catch( ... )
  862. return false;
  863. }