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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 菜单 > 查看源码
SkinBase.cpp
资源名称：skinmenu_src.rar　[点击查看]
上传用户：weijiexitu
上传日期：2007-01-18
资源大小：54k
文件大小：35k
源码类别：

菜单

开发平台：

WINDOWS

SkinBase.cpp：源码内容
  1. // SkinBase.cpp: implementation of the CSkinBase class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "SkinBase.h"
  7. #include "wclassdefines.h"
  8. #include "winclasses.h"
  10. //#define ACTIVATE_VIEWER
  11. //#include "imageviewer.h"
  13. #include <afxpriv.h>
  15. #ifdef _DEBUG
  16. #undef THIS_FILE
  17. static char THIS_FILE[]=__FILE__;
  18. #define new DEBUG_NEW
  19. #endif
  21. // for transparency
  22. typedef BOOL (WINAPI *LPSetLayeredWindowAttributes)
  23. (
  24.   HWND hwnd,           // handle to the layered window
  25.   COLORREF crKey,      // specifies the color key
  26.   BYTE bAlpha,         // value for the blend function
  27.   DWORD dwFlags        // action
  28. );
  30. #ifndef SPI_SETMENUFADE
  31. #define SPI_GETMENUFADE 0x1012
  32. #define SPI_SETMENUFADE 0x1013
  33. #endif
  35. #ifndef WS_EX_LAYERED
  36. #define WS_EX_LAYERED           0x00080000
  38. // win 2000 layered windows support
  39. #define LWA_COLORKEY            0x00000001
  40. #define LWA_ALPHA               0x00000002
  42. #define ULW_COLORKEY            0x00000001
  43. #define ULW_ALPHA               0x00000002
  44. #define ULW_OPAQUE              0x00000004
  45. #endif
  47. //////////////////////////////////////////////////////////////////////
  48. // Construction/Destruction
  49. //////////////////////////////////////////////////////////////////////
  51. int CSkinBase::s_nOSVer = -1;
  52. PFNTRANSPARENTBLT CSkinBase::s_pfnFastTransparentBlt = NULL;
  53. PFNGRADIENTFILL CSkinBase::s_pfnFastGradientFill = NULL;
  54. BOOL CSkinBase::s_bThemingEnabled = (GetOS() >= SBOS_XP);
  56. // don't use fast trasparent blt on win95/98 because msimg32.dll has a resource leak
  57. BOOL CSkinBase::s_bSupportsFastTransparentBlt = (GetOS() < SBOS_ME) ? FALSE : -1;
  58. BOOL CSkinBase::s_bSupportsFastGradientFill = (GetOS() < SBOS_ME) ? FALSE : -1;
  60. CSkinBase::CSkinBase()
  61. {
  62. }
  64. CSkinBase::~CSkinBase()
  65. {
  66. }
  68. int CSkinBase::GetOS()
  69. {
  70. if (s_nOSVer == -1) // first time
  71. {
  72. OSVERSIONINFO vinfo;
  73. vinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  75. BOOL rslt = GetVersionEx(&vinfo);
  77. if (rslt)
  78. {
  79. switch (vinfo.dwPlatformId)
  80. {
  81. case VER_PLATFORM_WIN32_NT:
  82. switch (vinfo.dwMajorVersion)
  83. {
  84. case 3: // nt351
  85. ASSERT (0); // not supported
  86. break;
  88. case 4: // nt4
  89. s_nOSVer = SBOS_NT4;
  90. break;
  92. case 5: // >= w2k
  93. switch (vinfo.dwMinorVersion)
  94. {
  95. case 0: // w2k
  96. s_nOSVer = SBOS_2K;
  97. break;
  99. case 1: // xp
  100. s_nOSVer = SBOS_XP;
  101. break;
  103. default: // > xp
  104. s_nOSVer = SBOS_XPP;
  105. break;
  106. }
  107. break;
  109. default: // > xp
  110. s_nOSVer = SBOS_XPP;
  111. break;
  112. }
  113. break;
  115. case VER_PLATFORM_WIN32_WINDOWS:
  116. ASSERT (vinfo.dwMajorVersion == 4);
  118. switch (vinfo.dwMinorVersion)
  119. {
  120. case 0: // nt4
  121. s_nOSVer = SBOS_95;
  122. break;
  124. case 10: // xp
  125. s_nOSVer = SBOS_98;
  126. break;
  128. case 90: // > xp
  129. s_nOSVer = SBOS_ME;
  130. break;
  132. default:
  133. ASSERT (0);
  134. break;
  135. }
  136. break;
  138. default:
  139. ASSERT (0);
  140. break;
  141. }
  142. }
  143. }
  145. return s_nOSVer;
  146. }
  148. BOOL CSkinBase::SupportsFastTransparentBlt()
  149. {
  150. if (s_bSupportsFastTransparentBlt == -1) // first time
  151. {
  152. HINSTANCE hInst = LoadLibrary("msimg32.dll");
  154. if (hInst)
  155. {
  156. s_pfnFastTransparentBlt = (PFNTRANSPARENTBLT)GetProcAddress(hInst, "TransparentBlt");
  157. s_bSupportsFastTransparentBlt = (s_pfnFastTransparentBlt != NULL);
  158. }
  159. else
  160. s_bSupportsFastTransparentBlt = FALSE;
  161. }
  163. return s_bSupportsFastTransparentBlt;
  164. }
  166. BOOL CSkinBase::SupportsFastGradientFill()
  167. {
  168. if (s_bSupportsFastGradientFill == -1) // first time
  169. {
  170. HINSTANCE hInst = LoadLibrary("msimg32.dll");
  172. if (hInst)
  173. {
  174. s_pfnFastGradientFill = (PFNGRADIENTFILL)GetProcAddress(hInst, "GradientFill");
  175. s_bSupportsFastGradientFill = (s_pfnFastGradientFill != NULL);
  176. }
  177. else
  178. s_bSupportsFastGradientFill = FALSE;
  179. }
  181. return s_bSupportsFastGradientFill;
  182. }
  184. BOOL CSkinBase::GradientFill(CDC* pDCDest, LPRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz)
  185. {
  186. if (!lpRect)
  187. return FALSE;
  189. if (::IsRectEmpty(lpRect))
  190. return FALSE;
  192. if (crFrom == crTo)
  193. {
  194. pDCDest->FillSolidRect(lpRect, crFrom);
  195. return TRUE;
  196. }
  198. if (GradientFillFast(pDCDest, lpRect, crFrom, crTo, bHorz))
  199. return TRUE;
  201. // else
  202. return GradientFillSlow(pDCDest, lpRect, crFrom, crTo, bHorz);
  203. }
  205. BOOL CSkinBase::TransparentBlt(CDC* pDCDest, 
  206.    int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
  207.    CDC* pDCSrc, 
  208.    int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, 
  209.    UINT crTransparent)
  210. {
  211. if (nWidthDest < 1) 
  212. return FALSE;
  214. if (nWidthSrc < 1) 
  215. return FALSE; 
  217. if (nHeightDest < 1) 
  218. return FALSE;
  220. if (nHeightSrc < 1) 
  221. return FALSE;
  223. if (TransparentBltFast(pDCDest, 
  224. nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  225. pDCSrc, 
  226. nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,  
  227. crTransparent))
  228. return TRUE;
  230. // else 
  231. return TransparentBltSlow(pDCDest, 
  232. nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  233. pDCSrc, 
  234. nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,  
  235. crTransparent);
  236. }
  238. BOOL CSkinBase::TransparentBltFast(CDC* pDCDest, 
  239.    int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
  240.    CDC* pDCSrc,   
  241.    int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,  
  242.    UINT crTransparent) 
  243. {
  244. if (!SupportsFastTransparentBlt() || !s_pfnFastTransparentBlt)
  245. return FALSE;
  247. return s_pfnFastTransparentBlt(*pDCDest, 
  248. nXOriginDest, 
  249. nYOriginDest, 
  250. nWidthDest, 
  251. nHeightDest,
  252. *pDCSrc, 
  253. nXOriginSrc, 
  254. nYOriginSrc, 
  255. nWidthSrc, 
  256. nHeightSrc,    
  257. crTransparent);
  258. }
  260. BOOL CSkinBase::TransparentBltSlow(CDC* pDCDest, 
  261.    int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
  262.    CDC* pDCSrc,   
  263.    int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,  
  264.    UINT crTransparent) 
  265. {
  266. CDC dcMem, dcMask;
  268. dcMask.CreateCompatibleDC(pDCDest);
  269. dcMem.CreateCompatibleDC(pDCDest);
  271. CBitmap bmMask, bmMem;
  273. // copy src bitmap to mem dc
  274. bmMem.CreateCompatibleBitmap(pDCDest, nWidthSrc, nHeightSrc);
  276. CBitmap* pOldBMMem = dcMem.SelectObject(&bmMem);
  277. dcMem.BitBlt(0, 0, nWidthSrc, nHeightSrc, pDCSrc, nXOriginSrc, nYOriginSrc, SRCCOPY);
  279. // ShowDC(dcMem);
  281. // Create monochrome bitmap for the mask
  282. bmMask.CreateBitmap(nWidthSrc, nHeightSrc, 1, 1, NULL);
  283. CBitmap* pOldBMMask = dcMask.SelectObject(&bmMask);
  284. dcMem.SetBkColor(crTransparent);
  286. // Create the mask from the memory DC
  287. dcMask.BitBlt(0, 0, nWidthSrc, nHeightSrc, &dcMem, 0, 0, SRCCOPY);
  289. // ShowDC(dcMask);
  291. // Set the background in dcMem to black. Using SRCPAINT with black
  292. // and any other color results in the other color, thus making
  293. // black the transparent color
  294. dcMem.SetBkColor(RGB(0,0,0));
  295. dcMem.SetTextColor(RGB(255,255,255));
  296. dcMem.BitBlt(0, 0, nWidthSrc, nHeightSrc, &dcMask, 0, 0, SRCAND);
  298. // ShowDC(dcMem);
  300. // Set the foreground to black. See comment above.
  301. // pDCDest->SetStretchBltMode(COLORONCOLOR);
  302. pDCDest->SetStretchBltMode(HALFTONE);
  303. pDCDest->SetBkColor(RGB(255,255,255));
  304. pDCDest->SetTextColor(RGB(0,0,0));
  306. // CPoint ptOrg;
  307. // ::GetBrushOrgEx(*pDCDest, &ptOrg);
  308. // ::SetBrushOrgEx(*pDCDest, 0, 0, &ptOrg);
  310. if (nWidthDest == nWidthSrc && nHeightDest == nHeightSrc)
  311. {
  312. pDCDest->BitBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, &dcMask, 0, 0, SRCAND);
  313. // ShowDC(*pDCDest);
  314. }
  315. else
  316. {
  317. pDCDest->StretchBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, 
  318. &dcMask, 0, 0, nWidthSrc, nHeightSrc, SRCAND);
  319. // ShowDC(*pDCDest);
  320. }
  322. // Combine the foreground with the background
  323. if (nWidthDest == nWidthSrc && nHeightDest == nHeightSrc)
  324. {
  325. pDCDest->BitBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, &dcMem, 0, 0, SRCPAINT);
  326. // ShowDC(*pDCDest);
  327. }
  328. else
  329. {
  330. pDCDest->StretchBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, 
  331. &dcMem, 0, 0, nWidthSrc, nHeightSrc, SRCPAINT);
  332. // ShowDC(*pDCDest);
  333. }
  335. dcMask.SelectObject(pOldBMMask);
  336. dcMem.SelectObject(pOldBMMem);
  338. return TRUE;
  339. }
  340. /*
  341. BOOL CSkinBase::TransparentBltSlow(CDC* pDCDest, 
  342.    int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
  343.    CDC* pDCSrc,   
  344.    int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,  
  345.    UINT crTransparent) 
  346. {
  347. CDC dcMem, dcMask;
  349. dcMask.CreateCompatibleDC(pDCDest);
  350. dcMem.CreateCompatibleDC(pDCDest);
  352. CBitmap bmMask, bmMem;
  354. // copy src bitmap to mem dc
  355. bmMem.CreateCompatibleBitmap(pDCDest, nWidthDest, nHeightDest);
  357. CBitmap* pOldBMMem = dcMem.SelectObject(&bmMem);
  359. dcMem.SetStretchBltMode(HALFTONE);
  360. CPoint ptOrg;
  361. ::GetBrushOrgEx(dcMem, &ptOrg);
  362. ::SetBrushOrgEx(dcMem, 0, 0, &ptOrg);
  364. dcMem.StretchBlt(0, 0, nWidthDest, nHeightDest, 
  365. pDCSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY);
  367. // ShowDC(dcMem);
  369. // Create monochrome bitmap for the mask
  370. bmMask.CreateBitmap(nWidthDest, nHeightDest, 1, 1, NULL);
  371. CBitmap* pOldBMMask = dcMask.SelectObject(&bmMask);
  372. dcMem.SetBkColor(crTransparent);
  374. // Create the mask from the memory DC
  375. dcMask.BitBlt(0, 0, nWidthDest, nHeightDest, &dcMem, 0, 0, SRCCOPY);
  377. // ShowDC(dcMask);
  379. // Set the background in dcMem to black. Using SRCPAINT with black
  380. // and any other color results in the other color, thus making
  381. // black the transparent color
  382. dcMem.SetBkColor(RGB(0,0,0));
  383. dcMem.SetTextColor(RGB(255,255,255));
  384. dcMem.BitBlt(0, 0, nWidthDest, nHeightDest, &dcMask, 0, 0, SRCAND);
  386. // ShowDC(dcMem);
  388. // Set the foreground to black. See comment above.
  389. pDCDest->SetBkColor(RGB(255,255,255));
  390. pDCDest->SetTextColor(RGB(0,0,0));
  392. pDCDest->BitBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, &dcMask, 0, 0, SRCAND);
  393. // ShowDC(*pDCDest);
  395. // Combine the foreground with the background
  396. pDCDest->BitBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, &dcMem, 0, 0, SRCPAINT);
  397. // ShowDC(*pDCDest);
  399. dcMask.SelectObject(pOldBMMask);
  400. dcMem.SelectObject(pOldBMMem);
  402. return TRUE;
  403. }
  404. */
  406. BOOL CSkinBase::GradientFillFast(CDC* pDCDest, LPRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz)
  407. {
  408. if (!SupportsFastGradientFill() || !s_pfnFastGradientFill)
  409. return FALSE;
  411. TRIVERTEX vert[2];
  412. vert[0].x      = lpRect->left;
  413. vert[0].y      = lpRect->top;
  414. vert[0].Red    = GetRValue(crFrom) << 8;
  415. vert[0].Green  = GetGValue(crFrom) << 8;
  416. vert[0].Blue   = GetBValue(crFrom) << 8;
  417. vert[0].Alpha  = 0x0000;
  419. vert[1].x      = lpRect->right;
  420. vert[1].y      = lpRect->bottom; 
  421. vert[1].Red    = GetRValue(crTo) << 8;
  422. vert[1].Green  = GetGValue(crTo) << 8;
  423. vert[1].Blue   = GetBValue(crTo) << 8;
  424. vert[1].Alpha  = 0x0000;
  426. GRADIENT_RECT gRect = { 0, 1 };
  428. return s_pfnFastGradientFill(*pDCDest, 
  429. vert,
  430. 2,
  431. &gRect,
  432. 1,
  433. bHorz ? GRADIENT_FILL_RECT_H : GRADIENT_FILL_RECT_V);
  434. }
  436. BOOL CSkinBase::GradientFillSlow(CDC* pDCDest, LPRECT lpRect, COLORREF crFrom, COLORREF crTo, BOOL bHorz)
  437. {
  438. if (!pDCDest || !lpRect)
  439. return FALSE;
  441. int nWidth = lpRect->right - lpRect->left;
  442. int nHeight = lpRect->bottom - lpRect->top;
  444. if (bHorz)
  445. {
  446. for (int nX = lpRect->left; nX < lpRect->right; nX++)
  447. pDCDest->FillSolidRect(nX, lpRect->top, 1, nHeight, BlendColors(crFrom, crTo, (lpRect->right - nX) / (float)nWidth));
  448. }
  449. else
  450. {
  451. for (int nY = lpRect->top; nY < lpRect->bottom; nY++)
  452. pDCDest->FillSolidRect(lpRect->left, nY, nWidth, 1, BlendColors(crFrom, crTo, (lpRect->bottom - nY) / (float)nHeight));
  453. }
  455. return TRUE;
  456. }
  458. COLORREF CSkinBase::BlendColors(COLORREF crA, COLORREF crB, float fAmountA)
  459. {
  460. BYTE btRed = (BYTE)min(255, (int)(GetRValue(crA) * fAmountA + GetRValue(crB) * (1.0f - fAmountA)));
  461. BYTE btGreen = (BYTE)min(255, (int)(GetGValue(crA) * fAmountA + GetGValue(crB) * (1.0f - fAmountA)));
  462. BYTE btBlue = (BYTE)min(255, (int)(GetBValue(crA) * fAmountA + GetBValue(crB) * (1.0f - fAmountA)));
  464. return RGB(btRed, btGreen, btBlue);
  465. }
  467. COLORREF CSkinBase::VaryColor(COLORREF crColor, float fFactor)
  468. {
  469. BYTE btRed = (BYTE)min(255, (int)(GetRValue(crColor) * fFactor));
  470. BYTE btGreen = (BYTE)min(255, (int)(GetGValue(crColor) * fFactor));
  471. BYTE btBlue = (BYTE)min(255, (int)(GetBValue(crColor) * fFactor));
  473. return RGB(btRed, btGreen, btBlue);
  474. }
  476. HRGN CSkinBase::BitmapToRegion(CBitmap* pBmp, COLORREF color)
  477. {
  478. const DWORD RGNDATAHEADER_SIZE = sizeof(RGNDATAHEADER);
  479. const DWORD ADD_RECTS_COUNT  = 40; // number of rects to be appended
  481. // get image properties
  482. BITMAP BM = { 0 };
  483. pBmp->GetBitmap(&BM);
  485. // create temporary dc
  486. CBitmap bmpMem;
  487. CDC dc, dcMem1, dcMem2;
  488. CDC* pDC = CWnd::GetDesktopWindow()->GetDC();
  490. dcMem1.CreateCompatibleDC(pDC);
  491. dcMem2.CreateCompatibleDC(pDC);
  492. bmpMem.CreateCompatibleBitmap(pDC, BM.bmWidth, BM.bmHeight);
  494. CWnd::GetDesktopWindow()->ReleaseDC(pDC);
  496. CBitmap* pOldBM1 = dcMem1.SelectObject(pBmp);
  497. CBitmap* pOldBM2 = dcMem2.SelectObject(&bmpMem);
  499. // verify that the mask color is correct for the current bit depth
  500. color = dcMem2.SetPixel(0, 0, color);
  502. dcMem2.BitBlt(0, 0, BM.bmWidth, BM.bmHeight, &dcMem1, 0, 0, SRCCOPY);
  503. dcMem1.SelectObject(pOldBM1);
  504. dcMem1.DeleteDC();
  506. DWORD dwRectsCount = BM.bmHeight;  // number of rects in allocated buffer
  507. int  nY, nX;  // current position in mask image
  508. // where mask was found
  509. bool bWasMask; // set when mask has been found in current scan line
  510. bool bIsMask; // set when current color is mask color
  511. CRect rLine;
  513. // allocate memory for region data
  514. // region data here is set of regions that are rectangles with height 1 pixel (scan line)
  515. // that's why nRgnStart allocation is <bm.biHeight> RECTs - number of scan lines in image
  516. RGNDATAHEADER* pRgnData = (RGNDATAHEADER*)new BYTE[ RGNDATAHEADER_SIZE + dwRectsCount * sizeof(RECT) ];
  518. // get pointer to RECT table
  519. LPRECT pRects = (LPRECT)((LPBYTE)pRgnData + RGNDATAHEADER_SIZE);
  521. // zero region data header memory (header  part only)
  522. memset( pRgnData, 0, RGNDATAHEADER_SIZE + dwRectsCount * sizeof(RECT) );
  524. // fill it by default
  525. pRgnData->dwSize = RGNDATAHEADER_SIZE;
  526. pRgnData->iType  = RDH_RECTANGLES;
  528. for ( nY = 0; nY < BM.bmHeight; nY++ )
  529. {
  530. bWasMask = true;
  531. rLine.SetRect(0, nY, 0, nY + 1);
  533. for ( nX = 0; nX < BM.bmWidth; nX++ )
  534. {
  535. // get color
  536. COLORREF crPixel = dcMem2.GetPixel(nX, nY);
  537. bIsMask = (crPixel == color);
  539. if (!bIsMask && bWasMask) // start of the rgn
  540. {
  541. rLine.left = nX;
  542. bWasMask = FALSE;
  543. }
  545. if (!bWasMask && (bIsMask || nX == BM.bmWidth - 1)) // end of rgn
  546. {
  547. bWasMask = true;
  548. rLine.right = bIsMask ? nX : nX + 1;
  550. // save current RECT
  551. // if this was a full line append to the last if it was full too
  552. BOOL bAdded = FALSE;
  554. if (pRgnData->nCount)
  555. {
  556. LPRECT pLastRect = &pRects[ pRgnData->nCount - 1];
  558. if (!pLastRect->left && !rLine.left && 
  559. pLastRect->right == BM.bmWidth - 1 && rLine.right == BM.bmWidth - 1)
  560. {
  561. pLastRect->bottom = rLine.bottom;
  562. bAdded = TRUE;
  563. }
  564. }
  566. // else add as a new line
  567. if (!bAdded)
  568. {
  569. pRects[ pRgnData->nCount++ ] = rLine;
  571. // if buffer full reallocate it with more room
  572. if ( pRgnData->nCount >= dwRectsCount )
  573. {
  574. dwRectsCount += ADD_RECTS_COUNT;
  576. // allocate new buffer
  577. LPBYTE pRgnDataNew = new BYTE[ RGNDATAHEADER_SIZE + dwRectsCount * sizeof(RECT) ];
  579. // copy current region data to it
  580. memcpy( pRgnDataNew, pRgnData, RGNDATAHEADER_SIZE + pRgnData->nCount * sizeof(RECT) );
  582. // delte old region data buffer
  583. delete pRgnData;
  585. // set pointer to new regiondata buffer to current
  586. pRgnData = (RGNDATAHEADER*)pRgnDataNew;
  588. // correct pointer to RECT table
  589. pRects = (LPRECT)((LPBYTE)pRgnData + RGNDATAHEADER_SIZE);
  590. }
  591. }
  592. }
  593. }
  594. }
  596. // create region
  597. HRGN hRgn = ExtCreateRegion( NULL, RGNDATAHEADER_SIZE + pRgnData->nCount * sizeof(RECT), (LPRGNDATA)pRgnData );
  598. CRect rBox;
  600. ::GetRgnBox(hRgn, rBox);
  602. // release region data
  603. delete pRgnData;
  605. dcMem2.SelectObject(pOldBM2);
  606. dcMem2.DeleteDC();
  607. bmpMem.DeleteObject();
  609. return hRgn;
  610. }
  612. HMENU CSkinBase::MakeMenuCopy(const CMenu* pSrc)
  613. {
  614. if (!pSrc)
  615. return NULL;
  617. CMenu menu;
  619. VERIFY (menu.CreatePopupMenu());
  620. ASSERT (::IsMenu(menu.m_hMenu));
  622. int nNumItems = pSrc->GetMenuItemCount();
  623. CString sLabel;
  625. MENUITEMINFO mii;
  626. ZeroMemory(&mii, sizeof(mii));
  627. mii.cbSize = sizeof(mii); // must fill up this field
  628. mii.fMask = MIIM_STATE | MIIM_DATA;  // get the state of the menu item
  630. for (int nItem = 0; nItem < nNumItems; nItem++)
  631. {
  632. UINT uIDItem = pSrc->GetMenuItemID(nItem);
  633. pSrc->GetMenuString(nItem, sLabel, MF_BYPOSITION);
  634. UINT uFlags = (uIDItem == 0) ? MF_SEPARATOR : (uIDItem == (UINT)-1) ? MF_POPUP : MF_STRING;
  636. // special case: if a popup menu we must copy it too
  637. if (uFlags == MF_POPUP)
  638. {
  639. HMENU hPopup = MakeMenuCopy(pSrc->GetSubMenu(nItem));
  640. ASSERT (hPopup);
  642. uIDItem = (UINT)hPopup;
  643. }
  645. menu.AppendMenu(uFlags, uIDItem, sLabel);
  647. // make sure we copy the state too
  648. ::GetMenuItemInfo(*pSrc, nItem, TRUE, &mii);
  649. ::SetMenuItemInfo(menu, nItem, TRUE, &mii);
  650. }
  652. return menu.Detach();
  653. }
  655. // this one copies the menu without deleting the root
  656. BOOL CSkinBase::CopyMenu(const CMenu* pSrc, CMenu* pDest)
  657. {
  658. ASSERT (::IsMenu(pDest->m_hMenu));
  660. if (!::IsMenu(pDest->m_hMenu))
  661. return FALSE;
  663. ASSERT (::IsMenu(pSrc->m_hMenu));
  665. if (!::IsMenu(pSrc->m_hMenu))
  666. return FALSE;
  668. // delete all the existing items
  669. while (pDest->GetMenuItemCount())
  670. pDest->DeleteMenu(0, MF_BYPOSITION);
  672. // copy across
  673. int nNumItems = pSrc->GetMenuItemCount();
  674. CString sLabel;
  676. MENUITEMINFO mii;
  677. ZeroMemory(&mii, sizeof(mii));
  678. mii.cbSize = sizeof(mii); // must fill up this field
  679. mii.fMask = MIIM_STATE | MIIM_DATA;  // get the state of the menu item
  681. for (int nItem = 0; nItem < nNumItems; nItem++)
  682. {
  683. UINT uIDItem = pSrc->GetMenuItemID(nItem);
  684. pSrc->GetMenuString(nItem, sLabel, MF_BYPOSITION);
  685. UINT uFlags = (uIDItem == 0) ? MF_SEPARATOR : (uIDItem == (UINT)-1) ? MF_POPUP : MF_STRING;
  687. // special case: if a popup menu we must copy it too
  688. if (uFlags == MF_POPUP)
  689. {
  690. HMENU hPopup = MakeMenuCopy(pSrc->GetSubMenu(nItem));
  691. ASSERT (hPopup);
  693. uIDItem = (UINT)hPopup;
  694. }
  696. pDest->AppendMenu(uFlags, uIDItem, sLabel);
  698. // make sure we copy the state too
  699. ::GetMenuItemInfo(*pSrc, nItem, TRUE, &mii);
  700. ::SetMenuItemInfo(*pDest, nItem, TRUE, &mii);
  701. }
  703. return TRUE;
  704. }
  706. BOOL CSkinBase::CopyBitmap(const CBitmap* pSrc, CBitmap* pDest)
  707. {
  708. ASSERT (pDest);
  710. if (!pDest)
  711. return FALSE;
  713. pDest->DeleteObject();
  715. if (!pSrc || !pSrc->GetSafeHandle())
  716. return FALSE;
  718. CDC* pDC = CWnd::GetDesktopWindow()->GetDC();
  719. CDC dcMem1, dcMem2;
  720. BOOL bRes = FALSE;
  722. if (dcMem1.CreateCompatibleDC(pDC) && dcMem2.CreateCompatibleDC(pDC))
  723. {
  724. BITMAP bm;
  725. ((CBitmap*)pSrc)->GetBitmap(&bm);
  727. if (pDest->CreateCompatibleBitmap(pDC, bm.bmWidth, bm.bmHeight))
  728. {
  729. ASSERT (CBitmap::FromHandle((HBITMAP)pDest->GetSafeHandle()) == pDest);
  731. CBitmap* pOldBM1 = dcMem1.SelectObject((CBitmap*)pSrc);
  732. CBitmap* pOldBM2 = dcMem2.SelectObject(pDest);
  734. dcMem2.BitBlt(0, 0, bm.bmWidth, bm.bmHeight, &dcMem1, 0, 0, SRCCOPY);
  735. bRes = TRUE;
  737. dcMem1.SelectObject(pOldBM1);
  738. dcMem2.SelectObject(pOldBM2);
  740. }
  741. }
  743. dcMem1.DeleteDC();
  744. dcMem2.DeleteDC();
  746. CWnd::GetDesktopWindow()->ReleaseDC(pDC);
  748. ASSERT (CBitmap::FromHandle((HBITMAP)pDest->GetSafeHandle()) == pDest);
  749. HANDLE* ph = (HANDLE*)((BYTE*)pDest + 4);  // after CObject
  750. ASSERT (ph[0] == pDest->GetSafeHandle());
  752. return bRes;
  753. }
  755. BOOL CSkinBase::ExtractResource(UINT nID, LPCTSTR szType, CString& sTempFilePath, HINSTANCE hInst)
  756. {
  757. if (!hInst)
  758. hInst = AfxFindResourceHandle(MAKEINTRESOURCE(nID), szType);
  760. if (!hInst)
  761. return FALSE;
  763. // compare time with that of module from which it was loaded
  764. CString sTempPath;
  765. CFileStatus fsRes, fsModule;
  766. CString sModulePath;
  767. ::GetModuleFileName(hInst, sModulePath.GetBuffer(MAX_PATH + 1), MAX_PATH);
  768. sModulePath.ReleaseBuffer();
  770. if (!CFile::GetStatus(sModulePath, fsModule))
  771. return FALSE;
  773. // create temp filename
  774. ::GetTempPath(MAX_PATH, sTempPath.GetBuffer(MAX_PATH));
  775. sTempPath.ReleaseBuffer();
  776. sTempFilePath.Format("%s%s_skin_%d.tmp", sTempPath, szType, nID);
  778. // see if the file has been created before
  779. if (!CFile::GetStatus(sTempFilePath, fsRes) || fsRes.m_mtime < fsModule.m_mtime)
  780. {
  781. // Load the resource into memory
  782. HRSRC hRes = FindResource(hInst, (LPCSTR)nID, szType);
  784. if (!hRes) 
  785. {
  786. TRACE("Couldn't find %s resource %d!n", szType, nID);
  787. return FALSE;
  788. }
  790. DWORD len = SizeofResource(hInst, hRes);
  792. BYTE* lpRes = (BYTE*)LoadResource(hInst, hRes);
  793. ASSERT(lpRes);
  795. CFile file;
  797. if (file.Open(sTempFilePath, CFile::modeCreate | CFile::modeWrite))
  798. {
  799. file.Write(lpRes, len);
  800. file.Close();
  801. FreeResource((HANDLE)lpRes);
  802. }
  803. else
  804. {
  805. FreeResource((HANDLE)lpRes);
  806. return FALSE;
  807. }
  808. }
  810. return TRUE;
  811. }
  813. CWnd* CSkinBase::GetChildWnd(CWnd* pParent, LPCTSTR szClass, int nID)
  814. {
  815. CWnd* pChild = pParent->GetWindow(GW_CHILD); 
  817. while (pChild)   
  818. {
  819. if (CWinClasses::IsClass(*pChild, szClass))
  820. {
  821. if (nID == -1 || pChild->GetDlgCtrlID() == nID)
  822. return pChild;
  823. }
  824. pChild = pChild->GetNextWindow();
  825. }
  827. return NULL;
  828. }
  830. BOOL CSkinBase::BitBlt(CDC* pDCDest, 
  831.    int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
  832.    CDC* pDCSrc, int nXOriginSrc, int nYOriginSrc, 
  833.    UINT uROP,    
  834.    COLORREF crTransparent)
  835. {
  836. if (crTransparent != (COLORREF)-1)
  837. {
  838. return TransparentBlt(pDCDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  839. pDCSrc, nXOriginSrc, nYOriginSrc, nWidthDest, nHeightDest, crTransparent);
  840. }
  841. else
  842. {
  843. return pDCDest->BitBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  844. pDCSrc, nXOriginSrc, nYOriginSrc, uROP);
  845. }
  847. return TRUE;
  848. }
  850. BOOL CSkinBase::StretchBlt(CDC* pDCDest, 
  851.    int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
  852.    CDC* pDCSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,   
  853.    UINT uROP,    
  854.    COLORREF crTransparent)
  855. {
  856. // check to see if this is really just a BitBlt
  857. if (nWidthDest == nWidthSrc && nHeightDest == nHeightSrc)
  858. {
  859. return BitBlt(pDCDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  860.    pDCSrc, nXOriginSrc, nYOriginSrc, uROP, crTransparent);
  861. }
  863. // else pick whether its transparent or not
  864. if (crTransparent != (COLORREF)-1)
  865. {
  866. return TransparentBlt(pDCDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  867. pDCSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, crTransparent);
  868. }
  869. else
  870. {
  871. return pDCDest->StretchBlt(nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
  872. pDCSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, uROP);
  873. }
  875. return TRUE;
  876. }
  878. CString CSkinBase::GetTipText(LPCTSTR szText, BOOL bToolbar)
  879. {
  880. CString sText(szText), sTip;
  882. if (sText.IsEmpty())
  883. return "";
  885. // tip text starts at 'n' 
  886. int nStartTip = bToolbar ? sText.Find('n') : -1;
  888. if (bToolbar && nStartTip == -1) // no tip
  889. return "";
  891. sText = sText.Right(sText.GetLength() - nStartTip - 1);
  893. // strip '&' and '...' if present
  894. int nLen = sText.GetLength();
  895. sTip.Empty();
  897. for (int nPos = 0; nPos < nLen; nPos++)
  898. {
  899. if (sText[nPos] != '&' && sText[nPos] != '.')
  900. sTip += sText[nPos];
  901. }
  903. return sTip;
  904. }
  906. BOOL CSkinBase::ConvertToGrayScale(CBitmap* pBitmap, COLORREF crMask)
  907. {
  908. CDC dcTemp;
  909. dcTemp.CreateCompatibleDC(NULL);
  911. BITMAP BM;
  912. pBitmap->GetBitmap(&BM);
  914. CBitmap* pBMOld = dcTemp.SelectObject(pBitmap);
  916. // now iterate all the pixels, converting each to grayscale
  917. // a bit daggy, but....
  918. int nXPixel = BM.bmWidth;
  919. COLORREF crPixel;
  921. while (nXPixel--)
  922. {
  923. int nYPixel = BM.bmHeight;
  925. while (nYPixel--)
  926. {
  927. crPixel = dcTemp.GetPixel(nXPixel, nYPixel);
  929. // leave the mask color as-is
  930. if (crPixel == crMask)
  931. continue;
  933. const BYTE btRed = GetRValue(crPixel);
  934. const BYTE btGreen = GetGValue(crPixel);
  935. const BYTE btBlue = GetBValue(crPixel);
  937. // if gray already goto next
  938. if (btRed == btGreen && btGreen == btBlue)
  939. continue;
  941. const BYTE btGray = (BYTE)((btRed / 3) + (btGreen / 2) + (btBlue / 4));
  943. // note: SetPixelV() quicker than SetPixel()
  944. dcTemp.SetPixelV(nXPixel, nYPixel, RGB(btGray, btGray, btGray));
  945. }
  946. }
  948. dcTemp.SelectObject(pBMOld);
  949. dcTemp.DeleteDC();
  951. return TRUE;
  952. }
  954. BOOL CSkinBase::DoSysMenu(CWnd* pWnd, CPoint ptCursor, LPRECT prExclude, BOOL bCopy)
  955. {
  956. CMenu* pMenu = pWnd->GetSystemMenu(FALSE);
  957. ASSERT (pMenu);
  959. if (pMenu)
  960. {
  961. TPMPARAMS tpmp;
  962. tpmp.cbSize = sizeof(tpmp);
  964. if (prExclude)
  965. tpmp.rcExclude = *prExclude;
  966. else
  967. SetRectEmpty(&tpmp.rcExclude);
  969. UINT uAlignFlags = TPM_LEFTALIGN | TPM_TOPALIGN | TPM_VERTICAL | TPM_RIGHTBUTTON | TPM_RETURNCMD;
  970. UINT uID = 0;
  972. if (bCopy) // skinning
  973. {
  974. HMENU hSysMenu = CSkinBase::MakeMenuCopy(pMenu);
  975. ASSERT (hSysMenu);
  977. if (hSysMenu)
  978. {
  979. InitSysMenu(CMenu::FromHandle(hSysMenu), pWnd);
  980. uID = ::TrackPopupMenuEx(hSysMenu, uAlignFlags, 
  981. ptCursor.x, ptCursor.y, *pWnd, &tpmp);
  983. ::DestroyMenu(hSysMenu); // cleanup
  984. }
  985. }
  986. else
  987. {
  988. InitSysMenu(pMenu, pWnd);
  989. uID = ::TrackPopupMenuEx(pMenu->GetSafeHmenu(), uAlignFlags, 
  990. ptCursor.x, ptCursor.y, *pWnd, &tpmp);
  991. }
  993. if (uID & 0xf000) // syscommand
  994. {
  995. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  997. // always post this command to allow this function to unwind
  998. // correctly before the command is handled
  999. pWnd->PostMessage(WM_SYSCOMMAND, (uID & 0xfff0), MAKELPARAM(curMsg.pt.x, curMsg.pt.y));
  1000. }
  1001. }
  1003. return TRUE;
  1004. }
  1006. void CSkinBase::InitSysMenu(CMenu* pMenu, CWnd* pWnd)
  1007. {
  1008. // iterate all the menu items looking for something resembling a sys menu item
  1009. int nItem = pMenu->GetMenuItemCount();
  1011. while (nItem--)
  1012. {
  1013. UINT uID = pMenu->GetMenuItemID(nItem);
  1015. if (uID >= 0xF000)
  1016. {
  1017. BOOL bEnable = TRUE;
  1019. switch (uID & 0xFFF0)
  1020. {
  1021. case SC_MINIMIZE:
  1022. bEnable = (pWnd->GetStyle() & WS_MINIMIZEBOX) && !pWnd->IsIconic();
  1023. break;
  1025. case SC_MAXIMIZE:
  1026. bEnable = (pWnd->GetStyle() & WS_MAXIMIZEBOX) && !pWnd->IsZoomed();
  1027. break;
  1029. case SC_RESTORE:
  1030. bEnable = pWnd->IsIconic() || pWnd->IsZoomed();
  1031. break;
  1033. case SC_MOVE:
  1034. case SC_SIZE:
  1035. bEnable = !pWnd->IsIconic() && !pWnd->IsZoomed();
  1036. break;
  1037. }
  1039. pMenu->EnableMenuItem(uID, bEnable ? MF_ENABLED : MF_GRAYED);
  1040. }
  1041. }
  1043. // set close as default item
  1044. pMenu->SetDefaultItem(SC_CLOSE);
  1045. }
  1047. CSize CSkinBase::GetTextExtent(CDC* pDC, LPCTSTR szText)
  1048. {
  1049. ASSERT (pDC && szText);
  1051. if (pDC && szText)
  1052. {
  1053. CRect rText(0, 0, 0, SHRT_MAX);
  1054. pDC->DrawText(szText, rText, DT_SINGLELINE | DT_CALCRECT);
  1055. return rText.Size();
  1056. }
  1058. // else
  1059. return 0;
  1060. }
  1062. const LPCTSTR WORDBREAK = "_-+=,.:;n";
  1063. const int CHUNK = 32;
  1065. int CSkinBase::FormatText(CDC* pDC, CString& sText, CRect& rect, UINT uDTFlags)
  1066. {
  1067. CString sOrgText(sText);
  1068. sText.Empty();
  1070. int nPos = 0, nLinePos = 0, nLen = sOrgText.GetLength();
  1071. int nLastWhiteSpace = -1;
  1072. int nHeight = 0;
  1073. const int LINEHEIGHT = pDC->GetTextExtent("W").cy;
  1074. int nLongestLine = 0;
  1076. // we always allow at least one line of text
  1077. BOOL bSingleLine = (uDTFlags & DT_SINGLELINE);
  1078. BOOL bCalcRect = (uDTFlags & DT_CALCRECT);
  1079. BOOL bEllipsis = (uDTFlags & DT_END_ELLIPSIS);
  1080. BOOL bModString = (uDTFlags & DT_MODIFYSTRING);
  1082. BOOL bFinished = FALSE;
  1083. const int CHUNK = 32;
  1085. char* pBuffer = sOrgText.GetBuffer(sOrgText.GetLength() + 1);
  1087. while (!bFinished)
  1088. {
  1089. int nChunk = CHUNK;
  1090. BOOL bLonger = TRUE;
  1092. int nLinePos = 0;
  1093. int nPrevPos = 0;
  1095. char* pLine = pBuffer + nPos;
  1097. // add chunks till we go over 
  1098. BOOL bContinue = TRUE;
  1099. int nWidth = 0;
  1101. while (bContinue)
  1102. {
  1103. nChunk = min(nChunk, nLen - (nPos + nLinePos));
  1104. nLinePos += nChunk;
  1106. nWidth = pDC->GetTextExtent(pLine, nLinePos).cx;
  1107. bContinue = (nChunk == CHUNK && nWidth < rect.Width());
  1108. }
  1110. // then iterate back and forth with sub chunks till we are just under
  1111. for (int i = 0; i < 5; i++)
  1112. {
  1113. nChunk /= 2;
  1115. if (nWidth == rect.Width())
  1116. break;
  1117. else if (nWidth > rect.Width())
  1118. nLinePos -= nChunk;
  1119. else
  1120. nLinePos += nChunk;
  1122. nWidth = pDC->GetTextExtent(pLine, nLinePos).cx;
  1123. }
  1125. // one final check to see we haven't ended up over 
  1126. if (nWidth > rect.Width())
  1127. nLinePos--;
  1129. // then work back to the previous word break
  1130. int nSavePos = nLinePos;
  1132. while (nLinePos)
  1133. {
  1134. // we word break either if the current character is whitespace or
  1135. // if the preceding character is a wordbreak character
  1136. // or we've reached the end of the string
  1137. BOOL bWordBreak = (nLinePos == nLen) || _istspace(pLine[nLinePos]) ||
  1138. (strchr(WORDBREAK, pLine[nLinePos - 1]) != NULL);
  1140. if (bWordBreak)
  1141. break;
  1143. nLinePos--;
  1144. }
  1146. if (!nLinePos)
  1147. nLinePos = nSavePos; // single word spans entire line
  1149. nWidth = pDC->GetTextExtent(pLine, nLinePos).cx;
  1151. // check for last line and add ellipsis if required
  1152. nHeight += LINEHEIGHT;
  1153. BOOL bAddEllipsis = FALSE;
  1155. if (nHeight + LINEHEIGHT > rect.Height() || bSingleLine)
  1156. {
  1157. if (bEllipsis && nPos + nLinePos < nLen - 1)
  1158. {
  1159. const int LEN_ELLIPSIS = pDC->GetTextExtent("...", 3).cx;
  1161. // modify the last line to add ellipsis
  1162. while (nLinePos)
  1163. {
  1164. nWidth = pDC->GetTextExtent(pLine, nLinePos).cx + LEN_ELLIPSIS;
  1166. if (nWidth > rect.Width())
  1167. nLinePos--;
  1168. else
  1169. break;
  1170. }
  1172. bAddEllipsis = TRUE;
  1173. }
  1175. sText += sOrgText.Mid(nPos, nLinePos);
  1177. if (bAddEllipsis)
  1178. sText += "...";
  1180. nLongestLine = max(nLongestLine, nWidth);
  1181. break;
  1182. }
  1184. sText += sOrgText.Mid(nPos, nLinePos);
  1185. sText += 'n';
  1187. nPos += nLinePos;
  1189. bFinished = (nPos >= nLen - 1 || nHeight + LINEHEIGHT > rect.Height());
  1190. nLongestLine = max(nLongestLine, nWidth);
  1192. // jump white space at the start of the next line
  1193. if (!bFinished)
  1194. {
  1195. while (nPos < nLen - 1)
  1196. {
  1197. if (!_istspace(pBuffer[nPos]))
  1198. break;
  1200. // else
  1201. nPos++;
  1202. }
  1203. }
  1204. }
  1206. sOrgText.ReleaseBuffer();
  1208. if (!bModString)
  1209. sText = sOrgText;
  1211. if (bCalcRect)
  1212. {
  1213. rect.right = rect.left + nLongestLine;
  1214. rect.bottom = rect.top + nHeight;
  1215. }
  1217. return nHeight;
  1218. }
  1220. //////////////////////////////
  1222. //////////////////////////////
  1224. int CALLBACK CheckFontProc(ENUMLOGFONTEX *lpelfe, NEWTEXTMETRICEX *lpntme, DWORD FontType, LPARAM lParam)
  1225. {
  1226. BOOL* pPresent = (BOOL*)lParam;
  1227. ASSERT (pPresent);
  1229. if (pPresent && FontType == TRUETYPE_FONTTYPE) // only TT accepted for now
  1230. *pPresent = TRUE; // at least one font found to match facename
  1232. return 0;
  1233. }
  1235. BOOL CSkinBase::FontIsPresent(LPCTSTR szFaceName)
  1236. {
  1237. LOGFONT lf;
  1239. HDC hdc = ::GetDC(NULL);
  1240. lf.lfCharSet = DEFAULT_CHARSET;
  1241. lf.lfPitchAndFamily = 0;
  1243. lstrcpy(lf.lfFaceName, szFaceName);
  1245. BOOL bPresent = FALSE;
  1246. EnumFontFamiliesEx(hdc, &lf, (FONTENUMPROC)CheckFontProc, (LPARAM)&bPresent, 0);
  1248. ::ReleaseDC(NULL, hdc);
  1250. return bPresent;
  1251. }
  1253. //////////////////////////////////
  1254. // theming
  1256. #ifndef STAP_ALLOW_NONCLIENT
  1257. #define STAP_ALLOW_NONCLIENT    (1 << 0)
  1258. #define STAP_ALLOW_CONTROLS     (1 << 1)
  1259. #define STAP_ALLOW_WEBCONTENT   (1 << 2)
  1260. #endif
  1263. typedef void (STDAPICALLTYPE* SETTHEMEAPPPROPERTIES)(DWORD);
  1265. void CSkinBase::EnableTheming(BOOL bEnable)
  1266. {
  1267. if (GetOS() < SBOS_XP || bEnable == s_bThemingEnabled)
  1268. return;
  1270. static HMODULE hUXTheme = ::LoadLibrary("UXTheme.dll");
  1272. if (hUXTheme)
  1273. {
  1274. SETTHEMEAPPPROPERTIES SetThemeAppProperties = 
  1275. (SETTHEMEAPPPROPERTIES)GetProcAddress(hUXTheme, "SetThemeAppProperties");
  1277. if (SetThemeAppProperties)
  1278. {
  1279. SetThemeAppProperties(bEnable ? 
  1280. STAP_ALLOW_NONCLIENT | STAP_ALLOW_CONTROLS | STAP_ALLOW_WEBCONTENT :
  1281. 0);
  1282. s_bThemingEnabled = bEnable;
  1283. }
  1284. }
  1285. }
  1287. BOOL CSkinBase::CreateThemeManifest(LPCTSTR szName, LPCTSTR szDescription)
  1288. {
  1289. // if (GetOS() < SBOS_XP)
  1290. // return FALSE;
  1292. // create the manifest only if one does not exist
  1293. CString sFilePath;
  1294. ::GetModuleFileName(NULL, sFilePath.GetBuffer(MAX_PATH + 1), MAX_PATH);
  1295. sFilePath.ReleaseBuffer();
  1297. sFilePath += ".Manifest";
  1299. CFileStatus fs;
  1301. if (CFile::GetStatus(sFilePath, fs))
  1302. return TRUE; // already exists
  1304. ASSERT (szName && strlen(szName) && szDescription && strlen(szDescription));
  1306. if (!(szName && strlen(szName) && szDescription && strlen(szDescription)))
  1307. return FALSE;
  1309. LPCTSTR szManifestFmt = " 
  1310. <?xml version='1.0' encoding='UTF-8' standalone='yes'?> 
  1311. <assembly 
  1312.     xmlns='urn:schemas-microsoft-com:asm.v1' 
  1313.     manifestVersion='1.0'> 
  1315.     <assemblyIdentity 
  1316.         version='1.0.0.0' 
  1317.         processorArchitecture='X86' 
  1318.         name='%s' 
  1319.         type='win32' 
  1320.     /> 
  1321.     <description>%s</description> 
  1322.     <dependency> 
  1323.         <dependentAssembly> 
  1324.             <assemblyIdentity 
  1325.                 type='win32' 
  1326.                 name='Microsoft.Windows.Common-Controls' 
  1327.                 version='6.0.0.0' 
  1328.                 processorArchitecture='X86' 
  1329.                 publicKeyToken='6595b64144ccf1df' 
  1330.                 language='*' 
  1331.             /> 
  1332.         </dependentAssembly> 
  1333.     </dependency> 
  1334. </assembly> ";
  1336. CString sManifest;
  1337. sManifest.Format(szManifestFmt, szName, szDescription);
  1339. CStdioFile file;
  1341. if (!file.Open(sFilePath, CFile::modeCreate | CFile::modeWrite | CFile::typeText))
  1342. return FALSE;
  1344. file.WriteString(sManifest);
  1345. file.Close();
  1347. return TRUE;
  1348. }
  1350. //////////////////////////////////////////////////////////////////////////////////////////
  1352. HICON CSkinBase::GetWindowIcon(CWnd* pWnd)
  1353. {
  1354. ASSERT (pWnd);
  1356. if (!pWnd)
  1357. return NULL;
  1359. HICON hIcon = pWnd->GetIcon(FALSE); // small icon
  1361. if (!hIcon)
  1362. hIcon = pWnd->GetIcon(TRUE); // large icon
  1364. if (!hIcon)
  1365. {
  1366. WNDCLASS wndcls;
  1367. CString sClass(CWinClasses::GetClass(*pWnd));
  1369. if (GetClassInfo(AfxGetInstanceHandle(), sClass, &wndcls))
  1370. hIcon = wndcls.hIcon;
  1371. }
  1373. return hIcon;
  1374. }