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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPGraphicBitmapPng.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：8k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPGraphicBitmapPng.cpp：源码内容
  1. // XTPGraphicBitmapPng.cpp : implementation of the CXTPGraphicBitmapPng class.
  2. //
  3. // This file is a part of the XTREME TOOLKITPRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "libpngpng.h"
  25. #include "XTPGraphicBitmapPng.h"
  28. //////////////////////////////////////////////////////////////////////////
  29. // CXTPGraphicBitmapPng
  31. CXTPGraphicBitmapPng::CXTPGraphicBitmapPng()
  32. {
  33. m_bAlpha = FALSE;
  34. }
  36. static void PNGAPI png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
  37. {
  38. CFile* pFile = (CFile*)png_ptr->io_ptr;
  40. png_size_t sizeRead = (png_size_t)pFile->Read(data, (UINT)length);
  42. if (sizeRead != length)
  43. {
  44. AfxThrowFileException(CFileException::endOfFile);
  45. }
  46. }
  48. static void png_cexcept_error(png_structp /*png_ptr*/, png_const_charp /*msg*/)
  49. {
  50. AfxThrowFileException(CFileException::badSeek);
  51. }
  53. BOOL PngLoadImage(CFile* pFile, png_byte **ppbImageData,
  54. png_uint_32 *piWidth, png_uint_32 *piHeight, int *piChannels, png_color *pBkgColor)
  55. {
  56. png_byte            pbSig[8];
  57. int                 iBitDepth;
  58. int                 iColorType;
  59. double              dGamma;
  60. png_color_16       *pBackground;
  61. png_uint_32         ulChannels;
  62. png_uint_32         ulRowBytes;
  63. png_byte           *pbImageData = *ppbImageData;
  64. png_byte          **ppbRowPointers = NULL;
  65. png_uint_32         i;
  66. png_structp         png_ptr = NULL;
  67. png_infop           info_ptr = NULL;
  69. // open the PNG input file
  71. if (!pFile)
  72. {
  73. *ppbImageData = pbImageData = NULL;
  74. return FALSE;
  75. }
  77. pFile->Read(pbSig, 8);
  79. if (!png_check_sig(pbSig, 8))
  80. {
  81. *ppbImageData = pbImageData = NULL;
  82. return FALSE;
  83. }
  85. // create the two png(-info) structures
  87. png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
  88. (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
  89. if (!png_ptr)
  90. {
  91. *ppbImageData = pbImageData = NULL;
  92. return FALSE;
  93. }
  95. info_ptr = png_create_info_struct(png_ptr);
  96. if (!info_ptr)
  97. {
  98. png_destroy_read_struct(&png_ptr, NULL, NULL);
  99. *ppbImageData = pbImageData = NULL;
  100. return FALSE;
  101. }
  103. TRY
  104. {
  106. // initialize the png structure
  108. png_set_read_fn(png_ptr, (png_voidp)pFile, png_read_data);
  110. png_set_sig_bytes(png_ptr, 8);
  112. // read all PNG info up to image data
  114. png_read_info(png_ptr, info_ptr);
  116. // get width, height, bit-depth and color-type
  118. png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
  119. &iColorType, NULL, NULL, NULL);
  121. // expand images of all color-type and bit-depth to 3x8 bit RGB images
  122. // let the library process things like alpha, transparency, background
  124. if (iBitDepth == 16)
  125. png_set_strip_16(png_ptr);
  126. if (iColorType == PNG_COLOR_TYPE_PALETTE)
  127. png_set_expand(png_ptr);
  128. if (iBitDepth < 8)
  129. png_set_expand(png_ptr);
  130. if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
  131. png_set_expand(png_ptr);
  132. if (iColorType == PNG_COLOR_TYPE_GRAY ||
  133. iColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
  134. png_set_gray_to_rgb(png_ptr);
  136. // set the background color to draw transparent and alpha images over.
  137. if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
  138. {
  139. png_set_background(png_ptr, pBackground, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
  140. pBkgColor->red   = (byte) pBackground->red;
  141. pBkgColor->green = (byte) pBackground->green;
  142. pBkgColor->blue  = (byte) pBackground->blue;
  143. }
  144. else
  145. {
  146. pBkgColor = NULL;
  147. }
  149. // if required set gamma conversion
  150. if (png_get_gAMA(png_ptr, info_ptr, &dGamma))
  151. png_set_gamma(png_ptr, (double) 2.2, dGamma);
  153. // after the transformations have been registered update info_ptr data
  155. png_read_update_info(png_ptr, info_ptr);
  157. // get again width, height and the new bit-depth and color-type
  159. png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
  160. &iColorType, NULL, NULL, NULL);
  163. // row_bytes is the width x number of channels
  165. ulRowBytes = png_get_rowbytes(png_ptr, info_ptr);
  166. ulChannels = png_get_channels(png_ptr, info_ptr);
  168. *piChannels = ulChannels;
  170. // now we can allocate memory to store the image
  172. if (pbImageData)
  173. {
  174. free (pbImageData);
  175. pbImageData = NULL;
  176. }
  178. pbImageData = (png_byte*)malloc(ulRowBytes * (*piHeight) * sizeof(png_byte));
  180. if (pbImageData == NULL)
  181. {
  182. AfxThrowFileException(CFileException::badSeek);
  183. }
  184. *ppbImageData = pbImageData;
  186. // and allocate memory for an array of row-pointers
  187. ppbRowPointers = (png_bytepp)malloc((*piHeight) * sizeof(png_bytep));
  189. if (ppbRowPointers == NULL)
  190. {
  191. AfxThrowFileException(CFileException::badSeek);
  192. }
  194. // set the individual row-pointers to point at the correct offsets
  196. for (i = 0; i < (*piHeight); i++)
  197. ppbRowPointers[i] = pbImageData + i * ulRowBytes;
  199. // now we can go ahead and just read the whole image
  201. png_read_image(png_ptr, ppbRowPointers);
  203. // read the additional chunks in the PNG file (not really needed)
  205. png_read_end(png_ptr, NULL);
  207. // and we're done
  209. free (ppbRowPointers);
  210. ppbRowPointers = NULL;
  212. // yepp, done
  213. }
  214. CATCH (CFileException, e)
  215. {
  216. png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
  218. *ppbImageData = pbImageData = NULL;
  220. if (ppbRowPointers)
  221. free (ppbRowPointers);
  223. return FALSE;
  224. }
  225. END_CATCH
  227. png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
  229. return TRUE;
  230. }
  232. HBITMAP CXTPGraphicBitmapPng::ConvertToBitmap(BYTE* pbImage, CSize szImage,  int cImgChannels) const
  233. {
  234. LONG xImg, yImg;
  235. BYTE *src, *dst;
  236. BYTE r, g, b, a;
  237. BITMAPINFO bmi;
  238. LPBYTE pBits;
  239. HBITMAP hbm;
  240. const int cDIChannels = 4;
  241. UINT wImgRowBytes;
  242. UINT wDIRowBytes;
  244. // Initialize header to 0s.
  245. ZeroMemory(&bmi, sizeof(bmi));
  247. // Fill out the fields you care about.
  248. bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  249. bmi.bmiHeader.biWidth = szImage.cx;
  250. bmi.bmiHeader.biHeight = -szImage.cy;
  251. bmi.bmiHeader.biPlanes = 1;
  252. bmi.bmiHeader.biBitCount = 32;
  253. bmi.bmiHeader.biCompression = BI_RGB;
  255. hbm = CreateDIBSection(NULL, &bmi, DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);
  257. if (!hbm || !pBits)
  258. {
  259. return NULL;
  260. }
  261. wImgRowBytes = cImgChannels * szImage.cx;
  262. wDIRowBytes = cDIChannels * szImage.cx;
  264. // copy image to screen
  266. for (yImg = 0; yImg < szImage.cy; yImg++)
  267. {
  268. src = pbImage + yImg * wImgRowBytes;
  269. dst = pBits + yImg * wDIRowBytes;
  271. for (xImg = 0; xImg < szImage.cx; xImg++)
  272. {
  273. r = *src++;
  274. g = *src++;
  275. b = *src++;
  276. *dst++ = b;
  277. *dst++ = g;
  278. *dst++ = r;
  279. a = 0;
  281. if (cImgChannels == 4)
  282. {
  283. a = *src++;
  284. }
  285. *dst++ = a;
  286. }
  287. }
  289. return hbm;
  290. }
  292. BOOL CXTPGraphicBitmapPng::LoadFromFile(LPCTSTR lpszFileName)
  293. {
  294. m_bAlpha = FALSE;
  295. DeleteObject();
  297. CFile file;
  298. if (!file.Open(lpszFileName, CFile::modeRead))
  299. {
  300. return FALSE;
  301. }
  303. return LoadFromFile(&file);
  304. }
  306. BOOL CXTPGraphicBitmapPng::LoadFromResource(HMODULE hModule, HRSRC hRes)
  307. {
  308. m_bAlpha = FALSE;
  309. DeleteObject();
  311. if (!hRes)
  312. return FALSE;
  314. DWORD nBufferSize = ::SizeofResource(hModule, hRes);
  315. HGLOBAL hMem= ::LoadResource(hModule, hRes);
  316. if (!hMem)
  317. return FALSE;
  319. LPBYTE lpBuffer = (LPBYTE)LockResource(hMem);
  320. if (!lpBuffer || nBufferSize < 10)
  321. return FALSE;
  323. CMemFile file(lpBuffer, nBufferSize);
  325. return LoadFromFile(&file);
  326. }
  328. BOOL CXTPGraphicBitmapPng::LoadFromFile(CFile* pFile)
  329. {
  330. m_bAlpha = FALSE;
  331. DeleteObject();
  333. BYTE* pbImage = NULL;
  334. png_uint_32 cxImgSize, cyImgSize;
  335. int cImgChannels;
  336. png_color bkgColor =  {127, 127, 127};
  338. if (!pFile)
  339. return FALSE;
  341. if (!PngLoadImage(pFile, &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
  342. {
  343. if (pbImage)
  344. {
  345. free(pbImage);
  346. return FALSE;
  347. }
  348. }
  350. if (!pbImage)
  351. return FALSE;
  353. HBITMAP hBitmap = ConvertToBitmap(pbImage, CSize(cxImgSize, cyImgSize), cImgChannels);
  355. free(pbImage);
  357. if (!hBitmap)
  358. return FALSE;
  360. m_bAlpha = (cImgChannels == 4);
  361. Attach(hBitmap);
  363. return TRUE;
  364. }