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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
PPDrawManager.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：46k
源码类别：

CA认证

开发平台：

Visual C++

PPDrawManager.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "PPDrawManager.h"
  4. /*
  5. #ifdef _DEBUG
  6. #undef THIS_FILE
  7. static char THIS_FILE[]=__FILE__;
  8. #define new DEBUG_NEW
  9. #endif
  10. */
  12. /*
  13. DIBs use RGBQUAD format:
  14. 0xbb 0xgg 0xrr 0x00
  15. */
  16. #ifndef CLR_TO_RGBQUAD
  17. #define CLR_TO_RGBQUAD(clr)     (RGB(GetBValue(clr), GetGValue(clr), GetRValue(clr)))
  18. #endif
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  24. CPPDrawManager::CPPDrawManager()
  25. {
  27. }
  29. CPPDrawManager::~CPPDrawManager()
  30. {
  32. }
  34. void CPPDrawManager::GetSizeOfIcon(HICON hIcon, LPSIZE pSize) const
  35. {
  36. pSize->cx = 0;
  37. pSize->cy = 0;
  38. if (hIcon != NULL)
  39. {
  40. ICONINFO ii;
  41. // Gets icon dimension
  42. ::ZeroMemory(&ii, sizeof(ICONINFO));
  43. if (::GetIconInfo(hIcon, &ii))
  44. {
  45. pSize->cx = (DWORD)(ii.xHotspot * 2);
  46. pSize->cy = (DWORD)(ii.yHotspot * 2);
  47. //release icon mask bitmaps
  48. if(ii.hbmMask)
  49. ::DeleteObject(ii.hbmMask);
  50. if(ii.hbmColor)
  51. ::DeleteObject(ii.hbmColor);
  52. } //if
  53. } //if
  54. } //End GetSizeOfIcon
  56. void CPPDrawManager::GetSizeOfBitmap(HBITMAP hBitmap, LPSIZE pSize) const
  57. {
  58. pSize->cx = 0;
  59. pSize->cy = 0;
  60. if (hBitmap != NULL)
  61. {
  62. BITMAP csBitmapSize;
  63. // Get bitmap size
  64. int nRetValue = ::GetObject(hBitmap, sizeof(csBitmapSize), &csBitmapSize);
  65. if (nRetValue)
  66. {
  67. pSize->cx = (DWORD)csBitmapSize.bmWidth;
  68. pSize->cy = (DWORD)csBitmapSize.bmHeight;
  69. } //if
  70. } //if
  71. } //End GetSizeOfBitmap
  73. void CPPDrawManager::AlphaBitBlt(HDC hDestDC, int nDestX, int nDestY, DWORD dwWidth, DWORD dwHeight, HDC hSrcDC, int nSrcX, int nSrcY, int percent /* = 100 */)
  74. {
  75. _ASSERT ((NULL != hDestDC) || (NULL != hSrcDC));
  77. if (percent >= 100)
  78. {
  79. ::BitBlt(hDestDC, nDestX, nDestY, dwWidth, dwHeight, hSrcDC, nSrcX, nSrcY, SRCCOPY);
  80. return;
  81. } //if
  83. HDC hTempDC = ::CreateCompatibleDC(hDestDC);
  84. if (NULL == hTempDC)
  85. return;
  87. //Creates Source DIB
  88. LPBITMAPINFO lpbiSrc;
  89. // Fill in the BITMAPINFOHEADER
  90. lpbiSrc = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  91. lpbiSrc->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  92. lpbiSrc->bmiHeader.biWidth = dwWidth;
  93. lpbiSrc->bmiHeader.biHeight = dwHeight;
  94. lpbiSrc->bmiHeader.biPlanes = 1;
  95. lpbiSrc->bmiHeader.biBitCount = 32;
  96. lpbiSrc->bmiHeader.biCompression = BI_RGB;
  97. lpbiSrc->bmiHeader.biSizeImage = dwWidth * dwHeight;
  98. lpbiSrc->bmiHeader.biXPelsPerMeter = 0;
  99. lpbiSrc->bmiHeader.biYPelsPerMeter = 0;
  100. lpbiSrc->bmiHeader.biClrUsed = 0;
  101. lpbiSrc->bmiHeader.biClrImportant = 0;
  103. COLORREF* pSrcBits = NULL;
  104. HBITMAP hSrcDib = CreateDIBSection (
  105. hSrcDC, lpbiSrc, DIB_RGB_COLORS, (void **)&pSrcBits,
  106. NULL, NULL);
  108. if ((NULL != hSrcDib) && (NULL != pSrcBits))
  109. {
  110. HBITMAP hOldTempBmp = (HBITMAP)::SelectObject (hTempDC, hSrcDib);
  111. ::BitBlt (hTempDC, 0, 0, dwWidth, dwHeight, hSrcDC, nSrcX, nSrcY, SRCCOPY);
  112. ::SelectObject (hTempDC, hOldTempBmp);
  114. //Creates Destination DIB
  115. LPBITMAPINFO lpbiDest;
  116. // Fill in the BITMAPINFOHEADER
  117. lpbiDest = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  118. lpbiDest->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  119. lpbiDest->bmiHeader.biWidth = dwWidth;
  120. lpbiDest->bmiHeader.biHeight = dwHeight;
  121. lpbiDest->bmiHeader.biPlanes = 1;
  122. lpbiDest->bmiHeader.biBitCount = 32;
  123. lpbiDest->bmiHeader.biCompression = BI_RGB;
  124. lpbiDest->bmiHeader.biSizeImage = dwWidth * dwHeight;
  125. lpbiDest->bmiHeader.biXPelsPerMeter = 0;
  126. lpbiDest->bmiHeader.biYPelsPerMeter = 0;
  127. lpbiDest->bmiHeader.biClrUsed = 0;
  128. lpbiDest->bmiHeader.biClrImportant = 0;
  130. COLORREF* pDestBits = NULL;
  131. HBITMAP hDestDib = CreateDIBSection (
  132. hDestDC, lpbiDest, DIB_RGB_COLORS, (void **)&pDestBits,
  133. NULL, NULL);
  135. if ((NULL != hDestDib) && (NULL != pDestBits))
  136. {
  137. ::SelectObject (hTempDC, hDestDib);
  138. ::BitBlt (hTempDC, 0, 0, dwWidth, dwHeight, hDestDC, nDestX, nDestY, SRCCOPY);
  139. ::SelectObject (hTempDC, hOldTempBmp);
  141. double src_darken = (double)percent / 100.0;
  142. double dest_darken = 1.0 - src_darken;
  144. for (DWORD pixel = 0; pixel < dwWidth * dwHeight; pixel++, pSrcBits++, pDestBits++)
  145. {
  146. *pDestBits = PixelAlpha(*pSrcBits, src_darken, *pDestBits, dest_darken);
  147. } //for
  149. ::SelectObject (hTempDC, hDestDib);
  150. ::BitBlt (hDestDC, nDestX, nDestY, dwWidth, dwHeight, hTempDC, 0, 0, SRCCOPY);
  151. ::SelectObject (hTempDC, hOldTempBmp);
  153. delete lpbiDest;
  154. ::DeleteObject(hDestDib);
  155. } //if
  156. delete lpbiSrc;
  157. ::DeleteObject(hSrcDib);
  158. } //if
  160. ::DeleteDC(hTempDC);
  161. } //End AlphaBitBlt
  163. void CPPDrawManager::AlphaChannelBitBlt(HDC hDestDC, int nDestX, int nDestY, DWORD dwWidth, DWORD dwHeight, HDC hSrcDC, int nSrcX, int nSrcY)
  164. {
  165. _ASSERT ((NULL != hDestDC) || (NULL != hSrcDC));
  167. HDC hTempDC = ::CreateCompatibleDC(hDestDC);
  168. if (NULL == hTempDC)
  169. return;
  171. //Creates Source DIB
  172. LPBITMAPINFO lpbiSrc;
  173. // Fill in the BITMAPINFOHEADER
  174. lpbiSrc = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  175. lpbiSrc->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  176. lpbiSrc->bmiHeader.biWidth = dwWidth;
  177. lpbiSrc->bmiHeader.biHeight = dwHeight;
  178. lpbiSrc->bmiHeader.biPlanes = 1;
  179. lpbiSrc->bmiHeader.biBitCount = 32;
  180. lpbiSrc->bmiHeader.biCompression = BI_RGB;
  181. lpbiSrc->bmiHeader.biSizeImage = dwWidth * dwHeight;
  182. lpbiSrc->bmiHeader.biXPelsPerMeter = 0;
  183. lpbiSrc->bmiHeader.biYPelsPerMeter = 0;
  184. lpbiSrc->bmiHeader.biClrUsed = 0;
  185. lpbiSrc->bmiHeader.biClrImportant = 0;
  187. COLORREF* pSrcBits = NULL;
  188. HBITMAP hSrcDib = CreateDIBSection (
  189. hSrcDC, lpbiSrc, DIB_RGB_COLORS, (void **)&pSrcBits,
  190. NULL, NULL);
  192. if ((NULL != hSrcDib) && (NULL != pSrcBits))
  193. {
  194. HBITMAP hOldTempBmp = (HBITMAP)::SelectObject (hTempDC, hSrcDib);
  195. ::BitBlt (hTempDC, 0, 0, dwWidth, dwHeight, hSrcDC, nSrcX, nSrcY, SRCCOPY);
  196. ::SelectObject (hTempDC, hOldTempBmp);
  198. //Creates Destination DIB
  199. LPBITMAPINFO lpbiDest;
  200. // Fill in the BITMAPINFOHEADER
  201. lpbiDest = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  202. lpbiDest->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  203. lpbiDest->bmiHeader.biWidth = dwWidth;
  204. lpbiDest->bmiHeader.biHeight = dwHeight;
  205. lpbiDest->bmiHeader.biPlanes = 1;
  206. lpbiDest->bmiHeader.biBitCount = 32;
  207. lpbiDest->bmiHeader.biCompression = BI_RGB;
  208. lpbiDest->bmiHeader.biSizeImage = dwWidth * dwHeight;
  209. lpbiDest->bmiHeader.biXPelsPerMeter = 0;
  210. lpbiDest->bmiHeader.biYPelsPerMeter = 0;
  211. lpbiDest->bmiHeader.biClrUsed = 0;
  212. lpbiDest->bmiHeader.biClrImportant = 0;
  214. COLORREF* pDestBits = NULL;
  215. HBITMAP hDestDib = CreateDIBSection (
  216. hDestDC, lpbiDest, DIB_RGB_COLORS, (void **)&pDestBits,
  217. NULL, NULL);
  219. if ((NULL != hDestDib) && (NULL != pDestBits))
  220. {
  221. ::SelectObject (hTempDC, hDestDib);
  222. ::BitBlt (hTempDC, 0, 0, dwWidth, dwHeight, hDestDC, nDestX, nDestY, SRCCOPY);
  223. ::SelectObject (hTempDC, hOldTempBmp);
  225. double src_darken;
  226. BYTE nAlpha;
  228. for (DWORD pixel = 0; pixel < dwWidth * dwHeight; pixel++, pSrcBits++, pDestBits++)
  229. {
  230. nAlpha = LOBYTE(*pSrcBits >> 24);
  231. src_darken = (double)nAlpha / 255.0;
  232. *pDestBits = PixelAlpha(*pSrcBits, src_darken, *pDestBits, 1.0 - src_darken);
  233. } //for
  235. ::SelectObject (hTempDC, hDestDib);
  236. ::BitBlt (hDestDC, nDestX, nDestY, dwWidth, dwHeight, hTempDC, 0, 0, SRCCOPY);
  237. ::SelectObject (hTempDC, hOldTempBmp);
  239. delete lpbiDest;
  240. ::DeleteObject(hDestDib);
  241. } //if
  242. delete lpbiSrc;
  243. ::DeleteObject(hSrcDib);
  244. } //if
  246. ::DeleteDC(hTempDC);
  247. } //End of AlphaChannelBitBlt
  249. HBITMAP CPPDrawManager::CreateImageEffect(HBITMAP hBitmap, DWORD dwWidth, DWORD dwHeight, DWORD dwEffect, BOOL bUseMask /* = TRUE */, COLORREF clrMask /* = RGB(255, 0, 255) */, COLORREF clrMono /* = RGB(255, 255, 255) */)
  250. {
  251. HBITMAP hOldSrcBmp = NULL;
  252. HBITMAP hOldResBmp = NULL;  
  253. HDC hMainDC = NULL;
  254. HDC hSrcDC = NULL;
  255. HDC hResDC = NULL;
  257. hMainDC = ::GetDC(NULL);
  258. hSrcDC = ::CreateCompatibleDC(hMainDC);
  259. hResDC = ::CreateCompatibleDC(hMainDC);
  261. hOldSrcBmp = (HBITMAP)::SelectObject(hSrcDC, hBitmap);
  263. LPBITMAPINFO lpbi;
  265. // Fill in the BITMAPINFOHEADER
  266. lpbi = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  267. lpbi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  268. lpbi->bmiHeader.biWidth = dwWidth;
  269. lpbi->bmiHeader.biHeight = dwHeight;
  270. lpbi->bmiHeader.biPlanes = 1;
  271. lpbi->bmiHeader.biBitCount = 32;
  272. lpbi->bmiHeader.biCompression = BI_RGB;
  273. lpbi->bmiHeader.biSizeImage = dwWidth * dwHeight;
  274. lpbi->bmiHeader.biXPelsPerMeter = 0;
  275. lpbi->bmiHeader.biYPelsPerMeter = 0;
  276. lpbi->bmiHeader.biClrUsed = 0;
  277. lpbi->bmiHeader.biClrImportant = 0;
  279. COLORREF* pBits = NULL;
  280. HBITMAP hDibBmp = CreateDIBSection (
  281. hSrcDC, lpbi, DIB_RGB_COLORS, (void **)&pBits,
  282. NULL, NULL);
  284. if (hDibBmp == NULL || pBits == NULL)
  285. {
  286. delete lpbi;
  287. _ASSERT (FALSE);
  288. return NULL;
  289. } //if
  291. hOldResBmp = (HBITMAP)::SelectObject (hResDC, hDibBmp);
  292. ::BitBlt (hResDC, 0, 0, dwWidth, dwHeight, hSrcDC, 0, 0, SRCCOPY);
  294. clrMask = CLR_TO_RGBQUAD(clrMask);
  295. clrMono = CLR_TO_RGBQUAD(clrMono);
  297. DWORD dwAlpha;
  298. for (DWORD pixel = 0; pixel < dwWidth * dwHeight; pixel++, *pBits++)
  299. {
  300. COLORREF color = (COLORREF)*pBits;
  301. //ENG: Extract an original alpha value
  302. dwAlpha = color & 0xFF000000;
  303. if (dwAlpha != 0) 
  304. m_bIsAlpha = TRUE;
  305. if (bUseMask && (color == clrMask))
  306. {
  307. //This is transparent area
  308. color = RGB(0, 0, 0);
  309. }
  310. else 
  311. {
  312. //ENG: Color conversion
  313. if (dwEffect & IMAGE_EFFECT_GRAYEN) color = GrayMirrorColor(color);
  314. if (dwEffect & IMAGE_EFFECT_DARKEN) color = DarkenColor(color, 0.75);
  315. if (dwEffect & IMAGE_EFFECT_LIGHTEN) color = LightenColor(color, 0.25);
  316. if (dwEffect & IMAGE_EFFECT_MONOCHROME) color = clrMono;
  317. } //if
  318. if (dwEffect & IMAGE_EFFECT_INVERT) color = InvertColor(color);
  319. //ENG: Merges a color with an original alpha value
  320. *pBits = (color | dwAlpha);
  321. } //for
  323. ::SelectObject(hSrcDC, hOldSrcBmp);
  324. ::SelectObject(hResDC, hOldResBmp);
  325. ::DeleteDC(hSrcDC);
  326. ::DeleteDC(hResDC);
  327. ::ReleaseDC(NULL, hMainDC);
  329. delete lpbi;
  331. return hDibBmp;
  332. } //End CreateImageEffect
  334. //----------------------------------------------------------
  335. // CPPDrawManager::GrayMirrorColor()
  336. // Graying color in RGBQUAD format
  337. //----------------------------------------------------------
  338. // Parameter:
  339. // clrColor - RGBQUAD value from DIB
  340. // Return value:
  341. // A grayed color in the RGBQUAD format
  342. //----------------------------------------------------------
  343. COLORREF CPPDrawManager::GrayMirrorColor(COLORREF clrColor)
  344. {
  345. BYTE nGrayColor = (BYTE)((GetBValue(clrColor) * 0.299) + (GetGValue(clrColor) * 0.587) + (GetRValue(clrColor) * 0.114));
  347. return RGB(nGrayColor, nGrayColor, nGrayColor);
  348. } //End of GrayMirrorColor
  350. COLORREF CPPDrawManager::GrayColor(COLORREF clrColor)
  351. {
  352. BYTE nGrayColor = (BYTE)((GetRValue(clrColor) * 0.299) + (GetGValue(clrColor) * 0.587) + (GetBValue(clrColor) * 0.114));
  354. return RGB(nGrayColor, nGrayColor, nGrayColor);
  355. } //End GrayColor
  357. COLORREF CPPDrawManager::InvertColor(COLORREF clrColor)
  358. {
  359. return RGB(255 - GetRValue(clrColor), 255 - GetGValue(clrColor), 255 - GetBValue(clrColor));
  360. } //End InvertColor
  362. COLORREF CPPDrawManager::DarkenColor(COLORREF clrColor, double darken)
  363. {
  364. if (darken >= 0.0 && darken < 1.0)
  365. {
  366. BYTE color_r, color_g, color_b;
  367. color_r = (BYTE)(GetRValue(clrColor) * darken);
  368. color_g = (BYTE)(GetGValue(clrColor) * darken);
  369. color_b = (BYTE)(GetBValue(clrColor) * darken);
  370. clrColor = RGB(color_r, color_g, color_b);
  371. } //if
  373. return clrColor;
  374. } //End DarkenColor
  376. COLORREF CPPDrawManager::LightenColor(COLORREF clrColor, double lighten)
  377. {
  378. if (lighten > 0.0 && lighten <= 1.0)
  379. {
  380. BYTE color_r, color_g, color_b;
  382. lighten += 1.0;
  383. color_r = (BYTE)min((DWORD)GetRValue(clrColor) * lighten, 255.0);
  384. color_g = (BYTE)min((DWORD)GetGValue(clrColor) * lighten, 255.0);
  385. color_b = (BYTE)min((DWORD)GetBValue(clrColor) * lighten, 255.0);
  386. clrColor = RGB(color_r, color_g, color_b);
  387. /*
  388. lighten *= 255
  389. color_r = (BYTE)max(0, min(255, (int)((color_r - 128) * 2.0 + 128 + lighten)));
  390. color_g = (BYTE)max(0, min(255, (int)((color_g - 128) * 2.0 + 128 + lighten)));
  391. color_b = (BYTE)max(0, min(255, (int)((color_b - 128) * 2.0 + 128 + lighten)));
  392. clrColor = RGB(color_r, color_g, color_b);
  393. */
  394. } //if
  396. return clrColor;
  397. } //End LightenColor
  399. COLORREF CPPDrawManager::PixelAlpha(COLORREF clrSrc, double src_darken, COLORREF clrDest, double dest_darken)
  400. {
  401. return RGB (GetRValue (clrSrc) * src_darken + GetRValue (clrDest) * dest_darken, 
  402. GetGValue (clrSrc) * src_darken + GetGValue (clrDest) * dest_darken, 
  403. GetBValue (clrSrc) * src_darken + GetBValue (clrDest) * dest_darken);
  405. } //End PixelAlpha
  407. HICON CPPDrawManager::StretchIcon(HICON hIcon, DWORD dwWidth, DWORD dwHeight)
  408. {
  409. HICON hStretchedIcon = NULL;
  410. HDC   hMainDC = NULL;
  411. HDC   hSrcDC = NULL;
  412. HDC   hDestDC = NULL;
  413. BITMAP bmp;
  414. HBITMAP hOldSrcBitmap = NULL;
  415. HBITMAP hOldDestBitmap = NULL;
  416. ICONINFO csOriginal, csStretched;
  418. if (!::GetIconInfo(hIcon, &csOriginal))
  419. return FALSE;
  421. hMainDC = ::GetDC(NULL);
  422. hSrcDC = ::CreateCompatibleDC(hMainDC);
  423. hDestDC = ::CreateCompatibleDC(hMainDC);
  425. if ((NULL == hMainDC) || (NULL == hSrcDC) || (NULL == hDestDC))
  426. return NULL;
  428. if (::GetObject(csOriginal.hbmColor, sizeof(BITMAP), &bmp))
  429. {
  430. DWORD dwWidthOrg = csOriginal.xHotspot * 2;
  431. DWORD dwHeightOrg = csOriginal.yHotspot * 2;
  433. csStretched.hbmColor = ::CreateBitmap(dwWidth, dwHeight, bmp.bmPlanes, bmp.bmBitsPixel, NULL);
  434. if (NULL != csStretched.hbmColor)
  435. {
  436. hOldSrcBitmap = (HBITMAP)::SelectObject(hSrcDC, csOriginal.hbmColor);
  437. hOldDestBitmap = (HBITMAP)::SelectObject(hDestDC, csStretched.hbmColor);
  438. ::StretchBlt(hDestDC, 0, 0, dwWidth, dwHeight, hSrcDC, 0, 0, dwWidthOrg, dwHeightOrg, SRCCOPY);
  439. if (::GetObject(csOriginal.hbmMask, sizeof(BITMAP), &bmp))
  440. {
  441. csStretched.hbmMask = ::CreateBitmap(dwWidth, dwHeight, bmp.bmPlanes, bmp.bmBitsPixel, NULL);
  442. if (NULL != csStretched.hbmMask)
  443. {
  444. ::SelectObject(hSrcDC, csOriginal.hbmMask);
  445. ::SelectObject(hDestDC, csStretched.hbmMask);
  446. ::StretchBlt(hDestDC, 0, 0, dwWidth, dwHeight, hSrcDC, 0, 0, dwWidthOrg, dwHeightOrg, SRCCOPY);
  447. } //if
  448. } //if
  449. ::SelectObject(hSrcDC, hOldSrcBitmap);
  450. ::SelectObject(hDestDC, hOldDestBitmap);
  451. csStretched.fIcon = TRUE;
  452. hStretchedIcon = ::CreateIconIndirect(&csStretched);
  453. } //if
  454. ::DeleteObject(csStretched.hbmColor);
  455. ::DeleteObject(csStretched.hbmMask);
  456. } //if
  458. ::DeleteObject(csOriginal.hbmColor);
  459. ::DeleteObject(csOriginal.hbmMask);
  460. ::DeleteDC(hSrcDC);
  461. ::DeleteDC(hDestDC);
  462. ::ReleaseDC(NULL, hMainDC);
  464. return hStretchedIcon;
  465. } //End StretchIcon
  467. void CPPDrawManager::FillGradient (HDC hDC, LPCRECT lpRect, 
  468. COLORREF colorStart, COLORREF colorFinish, 
  469. BOOL bHorz/* = TRUE*/)
  470. {
  471.     // this will make 2^6 = 64 fountain steps
  472.     int nShift = 6;
  473.     int nSteps = 1 << nShift;
  475. RECT r2;
  476. r2.top = lpRect->top;
  477. r2.left = lpRect->left;
  478. r2.right = lpRect->right;
  479. r2.bottom = lpRect->bottom;
  481. int nHeight = lpRect->bottom - lpRect->top;
  482. int nWidth = lpRect->right - lpRect->left;
  484. for (int i = 0; i < nSteps; i++)
  485.     {
  486.         // do a little alpha blending
  487.         BYTE bR = (BYTE) ((GetRValue(colorStart) * (nSteps - i) +
  488.                    GetRValue(colorFinish) * i) >> nShift);
  489.         BYTE bG = (BYTE) ((GetGValue(colorStart) * (nSteps - i) +
  490.                    GetGValue(colorFinish) * i) >> nShift);
  491.         BYTE bB = (BYTE) ((GetBValue(colorStart) * (nSteps - i) +
  492.                    GetBValue(colorFinish) * i) >> nShift);
  494. HBRUSH hBrush = ::CreateSolidBrush(RGB(bR, bG, bB));
  496.         // then paint with the resulting color
  498.         if (!bHorz)
  499.         {
  500.             r2.top = lpRect->top + ((i * nHeight) >> nShift);
  501.             r2.bottom = lpRect->top + (((i + 1) * nHeight) >> nShift);
  502.             if ((r2.bottom - r2.top) > 0)
  503.                 ::FillRect(hDC, &r2, hBrush);
  504.         }
  505.         else
  506.         {
  507.             r2.left = lpRect->left + ((i * nWidth) >> nShift);
  508.             r2.right = lpRect->left + (((i + 1) * nWidth) >> nShift);
  509.             if ((r2.right - r2.left) > 0)
  510.                 ::FillRect(hDC, &r2, hBrush);
  511.         } //if
  513. if (NULL != hBrush)
  514. {
  515. ::DeleteObject(hBrush);
  516. hBrush = NULL;
  517. } //if
  518.     } //for
  519. } //End FillGradient
  521. #ifdef USE_SHADE
  522. void CPPDrawManager::SetShade(LPCRECT lpRect, UINT shadeID /* = 0 */, BYTE granularity /* = 8 */, 
  523.   BYTE coloring /* = 0 */, COLORREF hicr /* = 0 */, COLORREF midcr /* = 0 */, COLORREF locr /* = 0 */)
  524. {
  525. long sXSize,sYSize,bytes,j,i,k,h;
  526. BYTE *iDst ,*posDst;
  528. sYSize = lpRect->bottom - lpRect->top; 
  529. sXSize = lpRect->right - lpRect->left; 
  531. m_dNormal.Create(sXSize,sYSize,8); //create the default bitmap
  533. long r,g,b; //build the shaded palette
  534. for(i = 0; i < 129; i++)
  535. {
  536. r=((128-i)*GetRValue(locr)+i*GetRValue(midcr))/128;
  537. g=((128-i)*GetGValue(locr)+i*GetGValue(midcr))/128;
  538. b=((128-i)*GetBValue(locr)+i*GetBValue(midcr))/128;
  539. m_dNormal.SetPaletteIndex((BYTE)i,(BYTE)r,(BYTE)g,(BYTE)b);
  540. } //for
  541. for(i=1;i<129;i++){
  542. r=((128-i)*GetRValue(midcr)+i*GetRValue(hicr))/128;
  543. g=((128-i)*GetGValue(midcr)+i*GetGValue(hicr))/128;
  544. b=((128-i)*GetBValue(midcr)+i*GetBValue(hicr))/128;
  545. m_dNormal.SetPaletteIndex((BYTE)(i+127),(BYTE)r,(BYTE)g,(BYTE)b);
  546. } //for
  548. m_dNormal.BlendPalette(hicr,coloring); //color the palette
  550. bytes = m_dNormal.GetLineWidth();
  551. iDst = m_dNormal.GetBits();
  552. posDst =iDst;
  553. long a,x,y,d,xs,idxmax,idxmin;
  555. int grainx2 = RAND_MAX/(max(1,2*granularity));
  556. idxmax=255-granularity;
  557. idxmin=granularity;
  559. switch (shadeID)
  560. {
  561. //----------------------------------------------------
  562. case EFFECT_METAL:
  563. m_dNormal.Clear();
  564. // create the strokes
  565. k=40; //stroke granularity
  566. for(a=0;a<200;a++){
  567. x=rand()/(RAND_MAX/sXSize); //stroke postion
  568. y=rand()/(RAND_MAX/sYSize); //stroke position
  569. xs=rand()/(RAND_MAX/min(sXSize,sYSize))/2; //stroke lenght
  570. d=rand()/(RAND_MAX/k); //stroke color
  571. for(i=0;i<xs;i++){
  572. if (((x-i)>0)&&((y+i)<sYSize))
  573. m_dNormal.SetPixelIndex(x-i,y+i,(BYTE)d);
  574. if (((x+i)<sXSize)&&((y-i)>0))
  575. m_dNormal.SetPixelIndex(sXSize-x+i,y-i,(BYTE)d);
  576. } //for
  577. } //for
  578. //blend strokes with SHS_DIAGONAL
  579. posDst =iDst;
  580. a=(idxmax-idxmin-k)/2;
  581. for(i = 0; i < sYSize; i++) {
  582. for(j = 0; j < sXSize; j++) {
  583. d=posDst[j]+((a*i)/sYSize+(a*(sXSize-j))/sXSize);
  584. posDst[j]=(BYTE)d;
  585. posDst[j]+=rand()/grainx2;
  586. } //for
  587. posDst+=bytes;
  588. } //for
  590. break;
  591. //----------------------------------------------------
  592. case EFFECT_HARDBUMP: // 
  593. //set horizontal bump
  594. for(i = 0; i < sYSize; i++) {
  595. k=(255*i/sYSize)-127;
  596. k=(k*(k*k)/128)/128;
  597. k=(k*(128-granularity*2))/128+128;
  598. for(j = 0; j < sXSize; j++) {
  599. posDst[j]=(BYTE)k;
  600. posDst[j]+=rand()/grainx2-granularity;
  601. } //for
  602. posDst+=bytes;
  603. } //for
  604. //set vertical bump
  605. d=min(16,sXSize/6); //max edge=16
  606. a=sYSize*sYSize/4;
  607. posDst =iDst;
  608. for(i = 0; i < sYSize; i++) {
  609. y=i-sYSize/2;
  610. for(j = 0; j < sXSize; j++) {
  611. x=j-sXSize/2;
  612. xs=sXSize/2-d+(y*y*d)/a;
  613. if (x>xs) posDst[j]=(BYTE)idxmin+(BYTE)(((sXSize-j)*128)/d);
  614. if ((x+xs)<0) posDst[j]=(BYTE)idxmax-(BYTE)((j*128)/d);
  615. posDst[j]+=rand()/grainx2-granularity;
  616. } //for
  617. posDst+=bytes;
  618. } //for
  619. break;
  620. //----------------------------------------------------
  621. case EFFECT_SOFTBUMP: //
  622. for(i = 0; i < sYSize; i++) {
  623. h=(255*i/sYSize)-127;
  624. for(j = 0; j < sXSize; j++) {
  625. k=(255*(sXSize-j)/sXSize)-127;
  626. k=(h*(h*h)/128)/128+(k*(k*k)/128)/128;
  627. k=k*(128-granularity)/128+128;
  628. if (k<idxmin) k=idxmin;
  629. if (k>idxmax) k=idxmax;
  630. posDst[j]=(BYTE)k;
  631. posDst[j]+=rand()/grainx2-granularity;
  632. } //for
  633. posDst+=bytes;
  634. } //for
  635. break;
  636. //----------------------------------------------------
  637. case EFFECT_VBUMP: // 
  638. for(j = 0; j < sXSize; j++) {
  639. k=(255*(sXSize-j)/sXSize)-127;
  640. k=(k*(k*k)/128)/128;
  641. k=(k*(128-granularity))/128+128;
  642. for(i = 0; i < sYSize; i++) {
  643. posDst[j+i*bytes]=(BYTE)k;
  644. posDst[j+i*bytes]+=rand()/grainx2-granularity;
  645. } //for
  646. } //for
  647. break;
  648. //----------------------------------------------------
  649. case EFFECT_HBUMP: //
  650. for(i = 0; i < sYSize; i++) {
  651. k=(255*i/sYSize)-127;
  652. k=(k*(k*k)/128)/128;
  653. k=(k*(128-granularity))/128+128;
  654. for(j = 0; j < sXSize; j++) {
  655. posDst[j]=(BYTE)k;
  656. posDst[j]+=rand()/grainx2-granularity;
  657. } //for
  658. posDst+=bytes;
  659. } //for
  660. break;
  661. //----------------------------------------------------
  662. case EFFECT_DIAGSHADE: //
  663. a=(idxmax-idxmin)/2;
  664. for(i = 0; i < sYSize; i++) {
  665. for(j = 0; j < sXSize; j++) {
  666. posDst[j]=(BYTE)(idxmin+a*i/sYSize+a*(sXSize-j)/sXSize);
  667. posDst[j]+=rand()/grainx2-granularity;
  668. } //for
  669. posDst+=bytes;
  670. } //for
  671. break;
  672. //----------------------------------------------------
  673. case EFFECT_HSHADE: //
  674. a=idxmax-idxmin;
  675. for(i = 0; i < sYSize; i++) {
  676. k=a*i/sYSize+idxmin;
  677. for(j = 0; j < sXSize; j++) {
  678. posDst[j]=(BYTE)k;
  679. posDst[j]+=rand()/grainx2-granularity;
  680. } //for
  681. posDst+=bytes;
  682. } //for
  683. break;
  684. //----------------------------------------------------
  685. case EFFECT_VSHADE: //:
  686. a=idxmax-idxmin;
  687. for(j = 0; j < sXSize; j++) {
  688. k=a*(sXSize-j)/sXSize+idxmin;
  689. for(i = 0; i < sYSize; i++) {
  690. posDst[j+i*bytes]=(BYTE)k;
  691. posDst[j+i*bytes]+=rand()/grainx2-granularity;
  692. } //for
  693. } //for
  694. break;
  695. //----------------------------------------------------
  696. case EFFECT_NOISE:
  697. for(i = 0; i < sYSize; i++) {
  698. for(j = 0; j < sXSize; j++) {
  699. posDst[j]=128+rand()/grainx2-granularity;
  700. } //for
  701. posDst+=bytes;
  702. } //for
  703. } //switch
  704. //----------------------------------------------------
  705. } //End SetShade
  706. #endif
  708. void CPPDrawManager::FillEffect(HDC hDC, DWORD dwEffect, LPCRECT lpRect, COLORREF clrBegin, COLORREF clrMid /* = 0 */, COLORREF clrEnd /* = 0 */,  BYTE granularity /* = 0 */, BYTE coloring /* = 0 */)
  709. {
  710. HBRUSH hBrush = NULL;
  712. RECT rect;
  713. rect.left = lpRect->left;
  714. rect.top = lpRect->top;
  715. rect.right = lpRect->right;
  716. rect.bottom = lpRect->bottom;
  718. int nHeight = rect.bottom - rect.top;
  719. int nWidth = rect.right - rect.left;
  721. switch (dwEffect)
  722. {
  723. default:
  724. hBrush = ::CreateSolidBrush(clrBegin);
  725. ::FillRect(hDC, lpRect, hBrush);
  726. break;
  727. case EFFECT_HGRADIENT:
  728. FillGradient(hDC, lpRect, clrBegin, clrEnd, TRUE);
  729. break;
  730. case EFFECT_VGRADIENT:
  731. FillGradient(hDC, lpRect, clrBegin, clrEnd, FALSE);
  732. break;
  733. case EFFECT_HCGRADIENT:
  734. rect.right = rect.left + nWidth / 2;
  735. FillGradient(hDC, &rect, clrBegin, clrEnd, TRUE);
  736. rect.left = rect.right;
  737. rect.right = lpRect->right;
  738. FillGradient(hDC, &rect, clrEnd, clrBegin, TRUE);
  739. break;
  740. case EFFECT_3HGRADIENT:
  741. rect.right = rect.left + nWidth / 2;
  742. FillGradient(hDC, &rect, clrBegin, clrMid, TRUE);
  743. rect.left = rect.right;
  744. rect.right = lpRect->right;
  745. FillGradient(hDC, &rect, clrMid, clrEnd, TRUE);
  746. break;
  747. case EFFECT_VCGRADIENT:
  748. rect.bottom = rect.top + nHeight / 2;
  749. FillGradient(hDC, &rect, clrBegin, clrEnd, FALSE);
  750. rect.top = rect.bottom;
  751. rect.bottom = lpRect->bottom;
  752. FillGradient(hDC, &rect, clrEnd, clrBegin, FALSE);
  753. break;
  754. case EFFECT_3VGRADIENT:
  755. rect.bottom = rect.top + nHeight / 2;
  756. FillGradient(hDC, &rect, clrBegin, clrMid, FALSE);
  757. rect.top = rect.bottom;
  758. rect.bottom = lpRect->bottom;
  759. FillGradient(hDC, &rect, clrMid, clrEnd, FALSE);
  760. break;
  761. #ifdef USE_SHADE
  762. case EFFECT_NOISE:
  763. case EFFECT_DIAGSHADE:
  764. case EFFECT_HSHADE:
  765. case EFFECT_VSHADE:
  766. case EFFECT_HBUMP:
  767. case EFFECT_VBUMP:
  768. case EFFECT_SOFTBUMP:
  769. case EFFECT_HARDBUMP:
  770. case EFFECT_METAL:
  771. rect.left = 0;
  772. rect.top = 0;
  773. rect.right = nWidth;
  774. rect.bottom = nHeight;
  775. SetShade(&rect, dwEffect, granularity, coloring, clrBegin, clrMid, clrEnd);
  776. m_dNormal.Draw(hDC, lpRect->left, lpRect->top);
  777. break; 
  778. #endif
  779. } //switch
  781. if (NULL != hBrush)
  782. {
  783. ::DeleteObject(hBrush);
  784. hBrush = NULL;
  785. } //if
  786. } //End FillEffect
  788. void CPPDrawManager::MultipleCopy(HDC hDestDC, int nDestX, int nDestY, DWORD dwDestWidth, DWORD dwDestHeight, 
  789. HDC hSrcDC, int nSrcX, int nSrcY, DWORD dwSrcWidth, DWORD dwSrcHeight)
  790. {
  791. // Horizontal copying
  792. int right, bottom;
  793. int nDestRight = (int)(nDestX + dwDestWidth);
  794. int nDestBottom = (int)(nDestY + dwDestHeight);
  795. for (int x = nDestX; x < nDestRight; x+= dwSrcWidth)
  796. {
  797. right = min (x + (int)dwSrcWidth, nDestRight);
  798. // Vertical copying
  799. for (int y = nDestY; y < nDestBottom; y+= dwSrcHeight)
  800. {
  801. bottom = min (y + (int)dwSrcHeight, nDestBottom);
  802. ::BitBlt(hDestDC, x, y, right - x, bottom - y, hSrcDC, nSrcX, nSrcY, SRCCOPY);
  803. } //for
  804. } //for
  805. } //End MultipleCopy
  807. void CPPDrawManager::DrawBitmap(HDC hDC, int x, int y, DWORD dwWidth, DWORD dwHeight, HBITMAP hSrcBitmap,
  808. BOOL bUseMask, COLORREF crMask, 
  809. DWORD dwEffect /* = IMAGE_EFFECT_NONE */, 
  810. BOOL bShadow /* = FALSE */, 
  811. DWORD dwCxShadow /* = PPDRAWMANAGER_SHADOW_XOFFSET */, 
  812. DWORD dwCyShadow /* = PPDRAWMANAGER_SHADOW_YOFFSET */,
  813. DWORD dwCxDepth /* = PPDRAWMANAGER_SHADOW_XDEPTH */, 
  814. DWORD dwCyDepth /* = PPDRAWMANAGER_SHADOW_YDEPTH */,
  815. COLORREF clrShadow /* = PPDRAWMANAGER_SHADOW_COLOR */)
  816. {
  817. m_bIsAlpha = FALSE;
  818. if (NULL == hSrcBitmap)
  819. return;
  821. SIZE sz;
  822. GetSizeOfBitmap(hSrcBitmap, &sz);
  824. HDC hSrcDC = ::CreateCompatibleDC(hDC);
  825. HDC hDestDC = ::CreateCompatibleDC(hDC);
  827. HBITMAP hBitmapTemp = ::CreateCompatibleBitmap(hDC, dwWidth, dwHeight);
  829. HBITMAP hOldSrcBitmap = (HBITMAP)::SelectObject(hSrcDC, hSrcBitmap);
  830. HBITMAP hOldDestBitmap = (HBITMAP)::SelectObject(hDestDC, hBitmapTemp);
  832. //Scales a bitmap if need
  833. if (((DWORD)sz.cx != dwWidth) || ((DWORD)sz.cy != dwHeight))
  834. ::StretchBlt(hDestDC, 0, 0, dwWidth, dwHeight, hSrcDC, 0, 0, sz.cx, sz.cy, SRCCOPY);
  835. else
  836. ::BitBlt(hDestDC, 0, 0, dwWidth, dwHeight, hSrcDC, 0, 0, SRCCOPY);
  838. ::SelectObject(hDestDC, hOldDestBitmap);
  840. HBITMAP hMaskBmp = CreateImageEffect(hBitmapTemp, dwWidth, dwHeight, IMAGE_EFFECT_MASK, bUseMask, crMask);
  841. HBITMAP hBitmap = CreateImageEffect(hBitmapTemp, dwWidth, dwHeight, dwEffect, bUseMask, crMask, clrShadow);
  843. if (bShadow)
  844. {
  845. if (dwEffect & IMAGE_EFFECT_SHADOW)
  846. {
  847. POINT ptShadow;
  848. ptShadow.x = x + dwCxShadow;
  849. ptShadow.y = y + dwCyShadow;
  850. HBITMAP hShadowBmp =  CreateImageEffect(hBitmapTemp, dwWidth, dwHeight, IMAGE_EFFECT_MASK, bUseMask, crMask, InvertColor(clrShadow));
  851. DrawShadow(hDC, ptShadow.x, ptShadow.y, dwWidth, dwHeight, hShadowBmp, dwEffect & IMAGE_EFFECT_GRADIENT_SHADOW, dwCxDepth, dwCyDepth);
  852. ::DeleteObject(hShadowBmp);
  853. }
  854. else
  855. {
  856. x += dwCxShadow;
  857. y += dwCyShadow;
  858. } //if
  859. } //if
  861. if (m_bIsAlpha)
  862. {
  863. ::SelectObject(hSrcDC, hBitmap);
  864. AlphaChannelBitBlt(hDC, x, y, dwWidth, dwHeight, hSrcDC, 0, 0);
  865. }
  866. else
  867. {
  868. //Merge the image mask with background
  869. ::SelectObject(hSrcDC, hMaskBmp);
  870. ::BitBlt(hDC, x, y, dwWidth, dwHeight, hSrcDC, 0, 0, SRCAND);
  872. //Draw the image
  873. ::SelectObject(hSrcDC, hBitmap);
  874. ::BitBlt(hDC, x, y, dwWidth, dwHeight, hSrcDC, 0, 0, SRCPAINT);
  875. }
  877. ::SelectObject(hSrcDC, hOldSrcBitmap);
  879. ::DeleteDC(hDestDC);
  880. ::DeleteDC(hSrcDC);
  882. ::DeleteObject(hBitmap);
  883. ::DeleteObject(hMaskBmp);
  884. ::DeleteObject(hBitmapTemp);
  885. } //End DrawBitmap
  887. void CPPDrawManager::DrawIcon(HDC hDC, int x, int y, DWORD dwWidth, DWORD dwHeight, HICON hSrcIcon,
  888.    DWORD dwEffect /* = IMAGE_EFFECT_NONE */, 
  889. BOOL bShadow /* = FALSE */, 
  890. DWORD dwCxShadow /* = PPDRAWMANAGER_SHADOW_XOFFSET */, 
  891. DWORD dwCyShadow /* = PPDRAWMANAGER_SHADOW_YOFFSET */,
  892. DWORD dwCxDepth /* = PPDRAWMANAGER_SHADOW_XDEPTH */, 
  893. DWORD dwCyDepth /* = PPDRAWMANAGER_SHADOW_YDEPTH */,
  894. COLORREF clrShadow /* = PPDRAWMANAGER_SHADOW_COLOR */)
  895. {
  896. m_bIsAlpha = FALSE;
  897. if (NULL == hSrcIcon)
  898. return;
  900. SIZE sz;
  901. GetSizeOfIcon(hSrcIcon, &sz);
  903. HICON hIcon = NULL;
  905. if (((DWORD)sz.cx == dwWidth) && ((DWORD)sz.cy == dwHeight))
  906. hIcon = ::CopyIcon(hSrcIcon);
  907. else hIcon = StretchIcon(hSrcIcon, dwWidth, dwHeight);
  909. ICONINFO csOriginal;
  911. if (!::GetIconInfo(hIcon, &csOriginal))
  912. return;
  914. HDC hSrcDC = ::CreateCompatibleDC(hDC);
  916. HBITMAP hBitmap;
  917. if (dwEffect & IMAGE_EFFECT_MONOCHROME)
  918. hBitmap = CreateImageEffect(csOriginal.hbmMask, dwWidth, dwHeight, dwEffect, TRUE, RGB(255, 255, 255), clrShadow);
  919. else
  920. hBitmap = CreateImageEffect(csOriginal.hbmColor, dwWidth, dwHeight, dwEffect, TRUE, RGB(0, 0, 0), clrShadow);
  921. HBITMAP hOldSrcBitmap = (HBITMAP)::SelectObject(hSrcDC, hBitmap);
  923. if (bShadow)
  924. {
  925. if (dwEffect & IMAGE_EFFECT_SHADOW)
  926. {
  927. POINT ptShadow;
  928. ptShadow.x = x + dwCxShadow;
  929. ptShadow.y = y + dwCyShadow;
  930. HBITMAP hShadowBmp =  CreateImageEffect(csOriginal.hbmMask, dwWidth, dwHeight, IMAGE_EFFECT_MASK, TRUE, RGB(255, 255, 255), InvertColor(clrShadow));
  931. DrawShadow(hDC, ptShadow.x, ptShadow.y, dwWidth, dwHeight, hShadowBmp, dwEffect & IMAGE_EFFECT_GRADIENT_SHADOW, dwCxDepth, dwCyDepth);
  932. ::DeleteObject(hShadowBmp);
  933. }
  934. else
  935. {
  936. x += dwCxShadow;
  937. y += dwCyShadow;
  938. } //if
  939. } //if
  941. if (m_bIsAlpha)
  942. {
  943. // ::SelectObject(hSrcDC, hBitmap);
  944. AlphaChannelBitBlt(hDC, x, y, dwWidth, dwHeight, hSrcDC, 0, 0);
  945. }
  946. else
  947. {
  948. //-------------------------------------------------------------------
  949. // !!! ATTENTION !!!
  950. // I don't know why a icon uses text's color
  951. // Therefore I change a text's color to BLACK and after draw I restore
  952. // original color
  953. //-------------------------------------------------------------------
  954. COLORREF crOldColor = ::SetTextColor(hDC, RGB(0, 0, 0));
  955. //Merge the image mask with background
  956. ::SelectObject(hSrcDC, csOriginal.hbmMask);
  957. ::BitBlt(hDC, x, y, dwWidth, dwHeight, hSrcDC, 0, 0, SRCAND);
  958. //Draw the image
  959. ::SelectObject(hSrcDC, hBitmap);
  960. ::BitBlt(hDC, x, y, dwWidth, dwHeight, hSrcDC, 0, 0, SRCPAINT);
  961. ::SetTextColor(hDC, crOldColor);
  962. } //if
  964. ::SelectObject(hSrcDC, hOldSrcBitmap);
  965. ::DeleteDC(hSrcDC);
  966. ::DeleteObject(hBitmap);
  967. ::DestroyIcon(hIcon);
  969. ::DeleteObject(csOriginal.hbmColor);
  970. ::DeleteObject(csOriginal.hbmMask);
  971. } //End DrawIcon
  973. void CPPDrawManager::DrawShadow(HDC hDestDC, int nDestX, int nDestY, DWORD dwWidth, DWORD dwHeight, HBITMAP hMask, BOOL bGradient /* = FALSE */, DWORD dwDepthX /* = PPDRAWMANAGER_SHADOW_YOFFSET */, DWORD dwDepthY /* = PPDRAWMANAGER_SHADOW_XOFFSET */)
  974. {
  975. HDC hSrcDC = ::CreateCompatibleDC(hDestDC);
  976. if (NULL == hSrcDC)
  977. return;
  979. HDC hTempDC = ::CreateCompatibleDC(hDestDC);
  980. if (NULL == hTempDC)
  981. {
  982. ::DeleteDC(hSrcDC);
  983. return;
  984. } // if
  986. //Creates Source DIB
  987. LPBITMAPINFO lpbiSrc;
  988. // Fill in the BITMAPINFOHEADER
  989. lpbiSrc = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  990. lpbiSrc->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  991. lpbiSrc->bmiHeader.biWidth = dwWidth;
  992. lpbiSrc->bmiHeader.biHeight = dwHeight;
  993. lpbiSrc->bmiHeader.biPlanes = 1;
  994. lpbiSrc->bmiHeader.biBitCount = 32;
  995. lpbiSrc->bmiHeader.biCompression = BI_RGB;
  996. lpbiSrc->bmiHeader.biSizeImage = dwWidth * dwHeight;
  997. lpbiSrc->bmiHeader.biXPelsPerMeter = 0;
  998. lpbiSrc->bmiHeader.biYPelsPerMeter = 0;
  999. lpbiSrc->bmiHeader.biClrUsed = 0;
  1000. lpbiSrc->bmiHeader.biClrImportant = 0;
  1002. COLORREF* pSrcBits = NULL;
  1003. HBITMAP hSrcDib = CreateDIBSection (
  1004. hSrcDC, lpbiSrc, DIB_RGB_COLORS, (void **)&pSrcBits,
  1005. NULL, NULL);
  1007. if ((NULL != hSrcDib) && (NULL != pSrcBits))
  1008. {
  1009. HBITMAP hOldSrcBmp = (HBITMAP)::SelectObject (hSrcDC, hSrcDib);
  1010. HBITMAP hOldTempBmp = (HBITMAP)::SelectObject (hTempDC, hMask);
  1011. if (bGradient)
  1012. {
  1013. if (!(dwDepthX & 0x1)) dwDepthX++;
  1014. if (!(dwDepthY & 0x1)) dwDepthY++;
  1015. ::BitBlt(hSrcDC, 0, 0, dwWidth, dwHeight, hTempDC, 0, 0, WHITENESS);
  1016. ::StretchBlt (hSrcDC, dwDepthX / 2, dwDepthY / 2, dwWidth - dwDepthX, dwHeight - dwDepthY, hTempDC, 0, 0, dwWidth, dwHeight, SRCCOPY);
  1017. }
  1018. else
  1019. {
  1020. ::BitBlt(hSrcDC, 0, 0, dwWidth, dwHeight, hTempDC, 0, 0, SRCCOPY);
  1021. } //if
  1022. ::SelectObject (hTempDC, hOldTempBmp);
  1023. ::SelectObject (hSrcDC, hOldSrcBmp);
  1025. //Creates Destination DIB
  1026. LPBITMAPINFO lpbiDest;
  1027. // Fill in the BITMAPINFOHEADER
  1028. lpbiDest = (LPBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
  1029. lpbiDest->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  1030. lpbiDest->bmiHeader.biWidth = dwWidth;
  1031. lpbiDest->bmiHeader.biHeight = dwHeight;
  1032. lpbiDest->bmiHeader.biPlanes = 1;
  1033. lpbiDest->bmiHeader.biBitCount = 32;
  1034. lpbiDest->bmiHeader.biCompression = BI_RGB;
  1035. lpbiDest->bmiHeader.biSizeImage = dwWidth * dwHeight;
  1036. lpbiDest->bmiHeader.biXPelsPerMeter = 0;
  1037. lpbiDest->bmiHeader.biYPelsPerMeter = 0;
  1038. lpbiDest->bmiHeader.biClrUsed = 0;
  1039. lpbiDest->bmiHeader.biClrImportant = 0;
  1041. COLORREF* pDestBits = NULL;
  1042. HBITMAP hDestDib = CreateDIBSection (
  1043. hDestDC, lpbiDest, DIB_RGB_COLORS, (void **)&pDestBits,
  1044. NULL, NULL);
  1046. if ((NULL != hDestDib) && (NULL != pDestBits))
  1047. {
  1048. ::SelectObject (hTempDC, hDestDib);
  1049. ::BitBlt (hTempDC, 0, 0, dwWidth, dwHeight, hDestDC, nDestX, nDestY, SRCCOPY);
  1050. ::SelectObject (hTempDC, hOldTempBmp);
  1052. if (bGradient)
  1053. {
  1054. double * depth = new double [dwWidth * dwHeight];
  1055. SmoothMaskImage(dwWidth, dwHeight, pSrcBits, dwDepthX, dwDepthY, depth);
  1056. for(DWORD pixel = 0; pixel < dwWidth * dwHeight; pixel++, pDestBits++)
  1057. *pDestBits = DarkenColor(*pDestBits, *(depth + pixel));
  1058. delete [] depth;
  1059. }
  1060. else
  1061. {
  1062. for(DWORD pixel = 0; pixel < dwWidth * dwHeight; pixel++, pSrcBits++, pDestBits++)
  1063. *pDestBits = DarkenColor(*pDestBits, (double)GetRValue(*pSrcBits) / 255.0);
  1064. } //if
  1067. ::SelectObject (hTempDC, hDestDib);
  1068. ::BitBlt (hDestDC, nDestX, nDestY, dwWidth, dwHeight, hTempDC, 0, 0, SRCCOPY);
  1069. ::SelectObject (hTempDC, hOldTempBmp);
  1071. delete lpbiDest;
  1072. ::DeleteObject(hDestDib);
  1073. } //if
  1074. delete lpbiSrc;
  1075. ::DeleteObject(hSrcDib);
  1076. } //if
  1077. ::DeleteDC(hTempDC);
  1078. ::DeleteDC(hSrcDC);
  1079. } //End DrawIcon
  1081. void CPPDrawManager::DrawImageList(HDC hDC, int x, int y, DWORD dwWidth, DWORD dwHeight, HBITMAP hSrcBitmap,
  1082. int nIndex, int cx, int cy,
  1083. BOOL bUseMask, COLORREF crMask, 
  1084. DWORD dwEffect /*= IMAGE_EFFECT_NONE*/, 
  1085. BOOL bShadow /*= FALSE*/, 
  1086. DWORD dwCxShadow /*= PPDRAWMANAGER_SHADOW_XOFFSET*/, 
  1087. DWORD dwCyShadow /*= PPDRAWMANAGER_SHADOW_YOFFSET*/,
  1088. DWORD dwCxDepth /*= PPDRAWMANAGER_SHADOW_XDEPTH*/, 
  1089. DWORD dwCyDepth /*= PPDRAWMANAGER_SHADOW_YDEPTH*/,
  1090. COLORREF clrShadow /*= PPDRAWMANAGER_SHADOW_COLOR*/)
  1091. {
  1092. if ((NULL == hSrcBitmap) || !cx || !cy)
  1093. return;
  1095. SIZE sz;
  1096. GetSizeOfBitmap(hSrcBitmap, &sz);
  1098. //ENG: Gets a max columns and rows of the images on the bitmap
  1099. //RUS: 项塍鬣屐 爨犟桁嚯