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

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

对话框与窗口

开发平台：

Visual C++

XTPSkinManager.cpp：源码内容
  1. // XTPSkinManager.cpp: implementation of the CXTPSkinManager class.
  2. //
  3. // This file is a part of the XTREME SKINFRAMEWORK 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 "Common/XTPWinThemeWrapper.h"
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPSystemHelpers.h"
  27. #include "XTPSkinManager.h"
  28. #include "XTPSkinImage.h"
  29. #include "XTPSkinManagerResource.h"
  30. #include "XTPSkinObject.h"
  31. #include "XTPSkinObjectFrame.h"
  32. #include "XTPSkinManagerSchema.h"
  33. #include "XTPSkinManagerApiHook.h"
  34. #include "XTPSkinManagerModuleList.h"
  36. #ifdef _DEBUG
  37. #undef THIS_FILE
  38. static char THIS_FILE[]=__FILE__;
  39. #define new DEBUG_NEW
  40. #endif
  42. #define EVENT_OBJECT_REORDER 0x8004
  44. CXTPSkinManagerMetrics::CXTPSkinManagerMetrics(CXTPSkinManager* pManager)
  45. {
  46. m_pManager = pManager;
  48. m_brushDialog = NULL;
  49. m_brushTabControl = NULL;
  51. ZeroMemory(m_brTheme, sizeof(m_brTheme));
  52. memset(m_clrTheme, -1, sizeof(m_clrTheme));
  54. m_cyCaption = m_cySmallCaption = m_cyOsCaption = m_cyOsSmallCaption = 0;
  55. }
  57. CXTPSkinManagerMetrics::~CXTPSkinManagerMetrics()
  58. {
  59. if (m_brushDialog)
  60. {
  61. DeleteObject(m_brushDialog);
  62. }
  63. if (m_brushTabControl)
  64. {
  65. DeleteObject(m_brushTabControl);
  66. }
  68. for (int iColorId = 0; iColorId < XTP_SKINMETRICS_COLORTABLESIZE; iColorId++)
  69. {
  70. if (m_brTheme[iColorId])
  71. DeleteObject(m_brTheme[iColorId]);
  72. }
  73. }
  75. COLORREF CXTPSkinManagerMetrics::GetColor(int nIndex) const
  76. {
  77. return nIndex < XTP_SKINMETRICS_COLORTABLESIZE ? m_clrTheme[nIndex] : 0;
  78. }
  80. BOOL CXTPSkinManagerMetrics::IsMetricObject(HGDIOBJ hObject) const
  81. {
  82. if (hObject == 0)
  83. return FALSE;
  85. if (GetObjectType(hObject) != OBJ_BRUSH)
  86. return FALSE;
  88. for (int i = 0; i < XTP_SKINMETRICS_COLORTABLESIZE; i++)
  89. {
  90. if (hObject == m_brTheme[i])
  91. return TRUE;
  92. }
  93. return FALSE;
  94. }
  96. void CXTPSkinManagerMetrics::DestroyMetrics()
  97. {
  98. m_fntCaption.DeleteObject();
  99. m_fntSmCaption.DeleteObject();
  100. m_fntMenu.DeleteObject();
  102. for (int iColorId = 0; iColorId < XTP_SKINMETRICS_COLORTABLESIZE; iColorId++)
  103. {
  104. HBRUSH hBrush = m_brTheme[iColorId];
  105. m_brTheme[iColorId] = NULL;
  107. if (hBrush)
  108. DeleteObject(hBrush);
  109. }
  111. if (m_brushDialog)
  112. {
  113. DeleteObject(m_brushDialog);
  114. m_brushDialog = NULL;
  115. }
  117. if (m_brushTabControl)
  118. {
  119. DeleteObject(m_brushTabControl);
  120. m_brushTabControl = NULL;
  121. }
  123. }
  125. void CXTPSkinManagerMetrics::RefreshMetrics()
  126. {
  127. static const COLORREF defColors[XTP_SKINMETRICS_COLORTABLESIZE] =
  128. {
  129. RGB(192, 192, 192),
  130. RGB( 58, 110, 165),
  131. RGB(  0,   0, 128),
  132. RGB(128, 128, 128),
  133. RGB(192, 192, 192),
  134. RGB(255, 255, 255),
  135. RGB(  0,   0,   0),
  136. RGB(  0,   0,   0),
  137. RGB(  0,   0,   0),
  138. RGB(255, 255, 255),
  139. RGB(192, 192, 192),
  140. RGB(192, 192, 192),
  141. RGB(128, 128, 128),
  142. RGB(  0,   0, 128),
  143. RGB(255, 255, 255),
  144. RGB(192, 192, 192),
  145. RGB(128, 128, 128),
  146. RGB(128, 128, 128),
  147. RGB(  0,   0,   0),
  148. RGB(192, 192, 192),
  149. RGB(255, 255, 255),
  150. RGB(  0,   0,   0),
  151. RGB(223, 223, 223),
  152. RGB(  0,   0,   0),
  153. RGB(255, 255, 225),
  154. RGB(180, 180, 180),
  155. RGB(  0,   0, 255),
  156. RGB( 16, 132, 208),
  157. RGB(181, 181, 181),
  158. RGB(  0,   0, 128),
  159. RGB(192, 192, 192)
  160. };
  161. CXTPSkinManagerSchema* pSchema = m_pManager->GetSchema();
  162. if (!pSchema)
  163. {
  164. for (int iColorId = 0; iColorId < XTP_SKINMETRICS_COLORTABLESIZE; iColorId++)
  165. {
  166. m_clrTheme[iColorId] = GetSysColor(iColorId);
  168. HBRUSH hBrush = m_brTheme[iColorId];
  169. m_brTheme[iColorId] = NULL;
  171. if (hBrush)
  172. DeleteObject(hBrush);
  173. }
  174. return;
  175. }
  176. UINT nSysMetrics = pSchema->GetClassCode(_T("SYSMETRICS"));
  178. NONCLIENTMETRICS ncm;
  179. ZeroMemory(&ncm, sizeof(NONCLIENTMETRICS));
  180. ncm.cbSize = sizeof(NONCLIENTMETRICS);
  181. VERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0));
  183. m_fntCaption.DeleteObject();
  184. m_fntCaption.CreateFontIndirect(&ncm.lfCaptionFont);
  186. m_fntSmCaption.DeleteObject();
  187. m_fntSmCaption.CreateFontIndirect(&ncm.lfSmCaptionFont);
  189. m_fntMenu.DeleteObject();
  190. m_fntMenu.CreateFontIndirect(&ncm.lfMenuFont);
  192. m_nBorderSize = 1;
  193. SystemParametersInfo(SPI_GETBORDER, 0, &m_nBorderSize, FALSE);
  195. m_cxBorder = GetSystemMetrics(SM_CXBORDER);
  196. m_cyBorder = GetSystemMetrics(SM_CYBORDER);
  197. m_cxEdge = GetSystemMetrics(SM_CXEDGE);
  198. m_cyEdge = GetSystemMetrics(SM_CYEDGE);
  200. m_cxHScroll = GetSystemMetrics(SM_CXHSCROLL);
  201. m_cyHScroll = GetSystemMetrics(SM_CYHSCROLL);
  202. m_cxVScroll = GetSystemMetrics(SM_CXVSCROLL);
  203. m_cyVScroll = GetSystemMetrics(SM_CYVSCROLL);
  205. BOOL bApplyMetrics = m_pManager->GetApplyOptions() & xtpSkinApplyMetrics;
  207. m_cyOsCaption = m_cyCaption = GetSystemMetrics(SM_CYCAPTION);
  208. m_cyOsSmallCaption = m_cySmallCaption = GetSystemMetrics(SM_CYSMCAPTION);
  210. if (bApplyMetrics)
  211. {
  212. pSchema->GetIntProperty(nSysMetrics, 0, 0, TMT_CAPTIONBARHEIGHT, m_cyCaption);
  213. m_cyCaption++;
  215. pSchema->GetIntProperty(nSysMetrics, 0, 0, TMT_SMCAPTIONBARHEIGHT, m_cySmallCaption);
  216. m_cySmallCaption++;
  218. int nScrollbarWidth = 0, nScrollbarHeight = 0;
  219. if (SUCCEEDED(pSchema->GetIntProperty(nSysMetrics, 0, 0, TMT_SCROLLBARWIDTH, nScrollbarWidth)) && nScrollbarWidth > 0)
  220. {
  221. m_cxHScroll = m_cxVScroll = nScrollbarWidth;
  222. }
  223. if (SUCCEEDED(pSchema->GetIntProperty(nSysMetrics, 0, 0, TMT_SCROLLBARHEIGHT, nScrollbarHeight)) && nScrollbarHeight > 0)
  224. {
  225. m_cyHScroll = m_cyVScroll = nScrollbarHeight;
  226. }
  228. LOGFONT lfCaption, lfSmCaption;
  229. if (SUCCEEDED(pSchema->GetFontProperty(nSysMetrics, 0, 0, TMT_CAPTIONFONT, lfCaption)))
  230. {
  231. m_fntCaption.DeleteObject();
  232. m_fntCaption.CreateFontIndirect(&lfCaption);
  233. }
  235. if (SUCCEEDED(pSchema->GetFontProperty(nSysMetrics, 0, 0, TMT_SMALLCAPTIONFONT, lfSmCaption)))
  236. {
  237. m_fntSmCaption.DeleteObject();
  238. m_fntSmCaption.CreateFontIndirect(&lfSmCaption);
  239. }
  240. }
  242. for (int iColorId = 0; iColorId < XTP_SKINMETRICS_COLORTABLESIZE; iColorId++)
  243. {
  244. COLORREF clrOld = m_clrTheme[iColorId];
  245. m_clrTheme[iColorId] = (COLORREF)-1;
  247. COLORREF clrVal;
  249. if (FAILED(pSchema->GetColorProperty(nSysMetrics, 0, 0, iColorId + TMT_FIRSTCOLOR, clrVal)))
  250. {
  251. clrVal = defColors[iColorId];
  253. m_pManager->ApplyColorFilter(clrVal);
  254. }
  256. m_clrTheme[iColorId] = clrVal;
  258. if ((clrOld != clrVal) || (m_brTheme[iColorId] == NULL))
  259. {
  260. HBRUSH hBrush = m_brTheme[iColorId];
  261. m_brTheme[iColorId] = NULL;
  263. if (hBrush)
  264. DeleteObject(hBrush);
  266. m_brTheme[iColorId] = CreateSolidBrush(clrVal);
  267. }
  268. }
  270. m_clrEdgeHighLight = m_clrTheme[COLOR_BTNHIGHLIGHT];
  271. m_clrEdgeShadow = m_clrTheme[COLOR_BTNSHADOW];
  272. m_clrEdgeLight = m_clrTheme[COLOR_3DLIGHT];
  273. m_clrEdgeDkShadow = m_clrTheme[COLOR_3DDKSHADOW];
  276. if (m_brushDialog)
  277. {
  278. DeleteObject(m_brushDialog);
  279. }
  280. m_brushDialog = ::CreateSolidBrush(m_clrTheme[COLOR_3DFACE]);
  282. if (m_brushTabControl)
  283. {
  284. DeleteObject(m_brushTabControl);
  285. m_brushTabControl = NULL;
  286. }
  288. }
  291. //////////////////////////////////////////////////////////////////////
  292. // Construction/Destruction
  293. //////////////////////////////////////////////////////////////////////
  295. //////////////////////////////////////////////////////////////////////////
  296. // CXTPSkinManager
  298. class XTP_SKINAMANGER_THREAD_STATE : public CNoTrackObject
  299. {
  300. public:
  301. XTP_SKINAMANGER_THREAD_STATE();
  302. virtual ~XTP_SKINAMANGER_THREAD_STATE();
  304. public:
  305. HHOOK m_hHookOldCbtFilter;
  306. };
  308. XTP_SKINAMANGER_THREAD_STATE::XTP_SKINAMANGER_THREAD_STATE()
  309. {
  310. m_hHookOldCbtFilter = 0;
  311. }
  313. XTP_SKINAMANGER_THREAD_STATE::~XTP_SKINAMANGER_THREAD_STATE()
  314. {
  315. if (m_hHookOldCbtFilter)
  316. {
  317. UnhookWindowsHookEx(m_hHookOldCbtFilter);
  318. }
  319. }
  323. THREAD_LOCAL(XTP_SKINAMANGER_THREAD_STATE, _xtpSkinManagerThreadState)
  326. CXTPSkinManager::CXTPSkinManager()
  327. {
  328. m_pSchema = NULL;
  329. m_pMetrics = new CXTPSkinManagerMetrics(this);
  330. m_bEnabled = FALSE;
  332. m_pResourceFile = new CXTPSkinManagerResourceFile();
  333. m_pResourceFile->m_pManager = this;
  335. m_pClassMap = new CXTPSkinObjectClassMap();
  336. m_pClassMap->AddStandardClasses();
  338. m_mapObjects.InitHashTable(199, FALSE);
  340. m_bAutoApplyWindows = TRUE;
  341. m_bAutoApplyThreads = TRUE;
  342. m_dwApplyOptions = xtpSkinApplyFrame | xtpSkinApplyColors | xtpSkinApplyMetrics;
  344. m_dwComCtrl = XTPSystemVersion()->GetComCtlVersion();
  346. m_bWin9x = XTPSystemVersion()->IsWin9x();
  348. m_hWinEventHook = NULL;
  349. m_pSetWinEventHook = NULL;
  350. m_pUnhookWinEvent = NULL;
  352. CXTPSkinManagerApiHook* pApiHook = CXTPSkinManagerApiHook::GetInstance();
  353. pApiHook;
  355. HMODULE hLib = GetModuleHandle(_T("USER32"));
  356. if (hLib)
  357. {
  358. m_pSetWinEventHook = (LPFNSETWINEVENTHOOK)GetProcAddress(hLib, "SetWinEventHook");
  359. m_pUnhookWinEvent = (LPFNUNHOOKWINEVENT)GetProcAddress(hLib, "UnhookWinEvent");
  361. if (m_pSetWinEventHook && m_pUnhookWinEvent)
  362. {
  363. m_hWinEventHook = m_pSetWinEventHook(EVENT_OBJECT_REORDER, EVENT_OBJECT_REORDER, NULL,
  364. &CXTPSkinManager::WinEventProc, GetCurrentProcessId(), 0, 0);
  365. }
  366. }
  367. EnableCurrentThread();
  368. }
  370. void CXTPSkinManager::EnableCurrentThread()
  371. {
  372. DWORD dwThread = ::GetCurrentThreadId();
  374. XTP_SKINAMANGER_THREAD_STATE* pThreadState = _xtpSkinManagerThreadState.GetData();
  375. if (pThreadState)
  376. {
  377. if (pThreadState->m_hHookOldCbtFilter == 0)
  378. {
  379. pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT, CbtFilterHook, NULL, dwThread);
  380. }
  381. }
  382. }
  385. CXTPSkinManager::~CXTPSkinManager()
  386. {
  387. FreeSkinData();
  388. RemoveColorFilters();
  390. POSITION pos = m_mapClasses.GetStartPosition();
  391. CString strClassName;
  392. CXTPSkinManagerClass* pClass;
  393. while (pos != NULL)
  394. {
  395. m_mapClasses.GetNextAssoc( pos, strClassName, (void*&)pClass);
  396. delete pClass;
  397. }
  398. m_mapClasses.RemoveAll();
  400. SAFE_DELETE(m_pSchema);
  401. SAFE_DELETE(m_pMetrics);
  402. SAFE_DELETE(m_pResourceFile);
  403. SAFE_DELETE(m_pClassMap);
  405. RemoveAll();
  407. CXTPSkinManagerApiHook* pApiHook = CXTPSkinManagerApiHook::GetInstance();
  408. pApiHook->FinalizeHookManagement();
  410. HMODULE hLib = GetModuleHandle(_T("USER32"));
  411. if (m_hWinEventHook && hLib && m_pUnhookWinEvent)
  412. {
  413. m_pUnhookWinEvent(m_hWinEventHook);
  414. }
  415. }
  417. BOOL CXTPSkinManager::IsColorFilterExists() const
  418. {
  419. return m_arrFilters.GetSize() > 0;
  420. }
  422. void CXTPSkinManager::RemoveColorFilters()
  423. {
  424. for (int i = 0; i < (int)m_arrFilters.GetSize(); i++)
  425. {
  426. delete m_arrFilters[i];
  427. }
  428. m_arrFilters.RemoveAll();
  429. }
  431. void CXTPSkinManager::AddColorFilter(CXTPSkinManagerColorFilter* pFilter)
  432. {
  433. m_arrFilters.Add(pFilter);
  434. }
  436. void CXTPSkinManager::RedrawAllControls()
  437. {
  438. if (!m_bEnabled)
  439. return;
  441. POSITION pos = m_mapClasses.GetStartPosition();
  442. CString strClassName;
  443. CXTPSkinManagerClass* pClass;
  444. while (pos != NULL)
  445. {
  446. m_mapClasses.GetNextAssoc( pos, strClassName, (void*&)pClass);
  447. pClass->GetImages()->RemoveAll();
  448. }
  450. m_pMetrics->RefreshMetrics();
  451. XTPColorManager()->RefreshColors();
  453. OnSkinChanged(TRUE, TRUE);
  454. }
  456. void CXTPSkinManager::ApplyColorFilter(COLORREF& clr)
  457. {
  458. for (int i = 0; i < (int)m_arrFilters.GetSize(); i++)
  459. {
  460. m_arrFilters[i]->ApplyColorFilter(clr);
  461. }
  462. }
  464. BOOL CXTPSkinManager::LoadSkin(LPCTSTR lpszResourcePath, LPCTSTR lpszIniFileName)
  465. {
  466. SAFE_DELETE(m_pSchema);
  468. CXTPSkinManagerApiHook* pApiHook = CXTPSkinManagerApiHook::GetInstance();
  469. pApiHook->FinalizeHookManagement();
  471. BOOL bEnabled = m_bEnabled;
  473. if (XTPColorManager()->IsLowResolution() ||
  474. !CXTPSkinManagerModuleList::IsEnumeratorExists() ||
  475. !ReadSkinData(lpszResourcePath, lpszIniFileName))
  476. {
  477. m_bEnabled = FALSE;
  479. SAFE_DELETE(m_pSchema);
  481. m_pMetrics->RefreshMetrics();
  482. XTPColorManager()->RefreshColors();
  484. OnSkinChanged(bEnabled, m_bEnabled);
  486. return FALSE;
  487. }
  489. m_bEnabled = TRUE;
  491. pApiHook->InitializeHookManagement();
  493. m_pMetrics->RefreshMetrics();
  494. m_pSchema->RefreshMetrcis();
  495. XTPColorManager()->RefreshColors();
  497. OnSkinChanged(bEnabled, m_bEnabled);
  499. return TRUE;
  500. }
  502. CXTPSkinManagerClass* CXTPSkinManager::FromHandle(HTHEME hTheme)
  503. {
  504. POSITION pos = m_mapClasses.GetStartPosition();
  505. CString strClassName;
  506. CXTPSkinManagerClass* pClass;
  508. while (pos != NULL)
  509. {
  510. m_mapClasses.GetNextAssoc( pos, strClassName, (void*&)pClass);
  511. if (pClass == (CXTPSkinManagerClass*)hTheme)
  512. return pClass;
  513. }
  515. return NULL;
  516. }
  518. void CXTPSkinManager::ExcludeModule(LPCTSTR lpszModule)
  519. {
  520. CXTPSkinManagerApiHook* pApiHook = CXTPSkinManagerApiHook::GetInstance();
  521. pApiHook->ExcludeModule(lpszModule, FALSE);
  522. }
  524. void CXTPSkinManager::SetApplyOptions(DWORD dwOptions)
  525. {
  526. m_dwApplyOptions = dwOptions;
  528. if (!m_bEnabled)
  529. return;
  531. CXTPSkinManagerApiHook* pApiHook = CXTPSkinManagerApiHook::GetInstance();
  533. pApiHook->FinalizeHookManagement();
  534. pApiHook->InitializeHookManagement();
  536. m_pMetrics->RefreshMetrics();
  537. m_pSchema->RefreshMetrcis();
  538. XTPColorManager()->RefreshColors();
  540. OnSkinChanged(m_bEnabled, m_bEnabled);
  541. }
  544. void CXTPSkinManager::SetResourceFile(CXTPSkinManagerResourceFile* pResourceFile)
  545. {
  546. ASSERT(pResourceFile);
  547. if (!pResourceFile)
  548. return;
  550. SAFE_DELETE(m_pResourceFile);
  552. m_pResourceFile = pResourceFile;
  553. m_pResourceFile->m_pManager = this;
  554. }
  556. void CXTPSkinManager::FreeSkinData()
  557. {
  559. POSITION pos = m_mapClasses.GetStartPosition();
  560. CString strClassName;
  561. CXTPSkinManagerClass* pClass;
  562. while (pos != NULL)
  563. {
  564. m_mapClasses.GetNextAssoc( pos, strClassName, (void*&)pClass);
  565. delete pClass;
  566. }
  567. m_mapClasses.RemoveAll();
  569. m_pResourceFile->Close();
  570. }
  572. BOOL CXTPSkinManager::ReadSkinData(LPCTSTR strResourcePath, LPCTSTR strIniFileName)
  573. {
  574. FreeSkinData();
  576. if (!m_pResourceFile->Open(strResourcePath, strIniFileName))
  577. return FALSE;
  579. m_pSchema = m_pResourceFile->CreateSchema();
  580. if (!m_pSchema)
  581. return FALSE;
  583. if (FAILED(m_pSchema->ReadProperties(m_pResourceFile)))
  584. return FALSE;
  586. return TRUE;
  587. }
  589. CXTPSkinManager* CXTPSkinManager::s_pInstance = NULL;
  591. static class CXTPSkinManager::CDestructor
  592. {
  593. public:
  594. ~CDestructor()
  595. {
  596. if (s_pInstance != NULL)
  597. delete s_pInstance;
  598. }
  600. } __xtpSkinManagerDestructor;
  602. LRESULT CALLBACK CXTPSkinManager::CbtFilterHook(int code, WPARAM wParam, LPARAM lParam)
  603. {
  604. XTP_SKINAMANGER_THREAD_STATE* pThreadState = _xtpSkinManagerThreadState.GetData();
  606. LRESULT lResult = CallNextHookEx(pThreadState->m_hHookOldCbtFilter, code,
  607. wParam, lParam);
  609. if (code == HCBT_CREATEWND && XTPSkinManager()->m_bAutoApplyWindows)
  610. {
  611. ASSERT(lParam != NULL);
  612. LPCREATESTRUCT lpcs = ((LPCBT_CREATEWND)lParam)->lpcs;
  613. ASSERT(lpcs != NULL);
  615. ASSERT(wParam != NULL); // should be non-NULL HWND
  616. HWND hWnd = (HWND)wParam;
  618. TCHAR lpszClassName[50];
  619. GetClassName(hWnd, lpszClassName, 50);
  621. XTPSkinManager()->SetHook(hWnd, lpszClassName, lpcs, TRUE);
  622. }
  624. return lResult;
  625. }
  627. _XTP_EXT_CLASS CXTPSkinManager* AFX_CDECL XTPSkinManager()
  628. {
  629. if (CXTPSkinManager::s_pInstance == NULL)
  630. CXTPSkinManager::s_pInstance = new CXTPSkinManager();
  632. return CXTPSkinManager::s_pInstance;
  633. }
  635. void CXTPSkinManager::SetSkinManager(CXTPSkinManager* pSkinManager)
  636. {
  637. if (s_pInstance != NULL)
  638. delete s_pInstance;
  640. s_pInstance = pSkinManager;
  641. }
  645. CXTPSkinManagerClass* CXTPSkinManager::GetSkinClass(CString strClassList)
  646. {
  647. strClassList.MakeUpper();
  649. CXTPSkinManagerClass* pClass;
  651. if (m_mapClasses.Lookup(strClassList, (void *&)pClass))
  652. return pClass;
  654. int nClassCode = m_pSchema->GetClassCode(strClassList);
  655. if (nClassCode == 0)
  656. return NULL; // Not supported;
  658. pClass = new CXTPSkinManagerClass(this);
  659. pClass->m_strClass = strClassList;
  660. pClass->m_nClassCode =  nClassCode;
  662. m_mapClasses.SetAt(strClassList, pClass);
  664. return pClass;
  665. }
  667. void CXTPSkinManager::GetCurrentThemeName(CString& strThemeFileName, CString& strColorBuff)
  668. {
  669. if (m_pResourceFile)
  670. {
  671. strThemeFileName = m_pResourceFile->GetResourcePath();
  672. strColorBuff = m_pResourceFile->GetIniFileName();
  673. }
  674. }
  677. int CXTPSkinManager::GetThemeSysSize(int iSizeId)
  678. {
  679. int iVal = 0;
  680. if (!SUCCEEDED(m_pSchema->GetIntProperty(m_pSchema->GetClassCode(_T("SYSMETRICS")), 0, 0, iSizeId, iVal)))
  681. return 0;
  682. return iVal;
  683. }
  685. BOOL CXTPSkinManager::GetThemeSysBool(int iBoolId)
  686. {
  687. BOOL bVal = FALSE;
  688. if (!SUCCEEDED(m_pSchema->GetBoolProperty(m_pSchema->GetClassCode(_T("SYSMETRICS")), 0, 0, iBoolId, bVal)))
  689. return FALSE;
  691. return bVal;
  692. }
  695. COLORREF CXTPSkinManager::GetThemeSysColor(int iColorId)
  696. {
  697. return iColorId >= TMT_FIRSTCOLOR && iColorId <= TMT_LASTCOLOR ?
  698. m_pMetrics->m_clrTheme[iColorId - TMT_FIRSTCOLOR] : (COLORREF)-1;
  699. }
  701. HRESULT CXTPSkinManager::GetThemeSysFont(int iFontId, LOGFONT *plf)
  702. {
  703. HRESULT hr = m_pSchema->GetFontProperty(m_pSchema->GetClassCode(_T("SYSMETRICS")), 0, 0, iFontId, *plf);
  704. return hr;
  706. }
  708. HRESULT CXTPSkinManager::EnableThemeDialogTexture(HWND hWnd, DWORD dwFlags)
  709. {
  710. CXTPSkinObjectFrame* pObject = (CXTPSkinObjectFrame*)Lookup(hWnd);
  712. if (!pObject)
  713. return E_INVALIDARG;
  715. pObject->m_dwDialogTexture = dwFlags;
  717. return S_OK;
  718. }
  720. //////////////////////////////////////////////////////////////////////////
  722. CXTPSkinManagerClass::CXTPSkinManagerClass(CXTPSkinManager* pManager)
  723. {
  724. m_pImages = new CXTPSkinImages();
  725. m_pManager = pManager;
  727. m_mapCachedProperties.InitHashTable(199);
  728. }
  730. CXTPSkinManagerClass::~CXTPSkinManagerClass()
  731. {
  732. delete m_pImages;
  733. }
  737. BOOL CXTPSkinManagerClass::DrawThemeText(CDC* pDC, int iPartId, int iStateId, const CString& strText, DWORD dwFormat, const RECT *pRect)
  738. {
  739. pDC->SetBkMode(TRANSPARENT);
  742. CRect rcCaptionMargins = GetThemeRect(iPartId, iStateId, TMT_CAPTIONMARGINS);
  743. rcCaptionMargins.top = rcCaptionMargins.bottom = 0;
  745. CRect rc(pRect);
  746. rc.DeflateRect(rcCaptionMargins);
  748. if (GetThemeEnumValue(iPartId, iStateId, TMT_CONTENTALIGNMENT) == CA_CENTER)
  749. {
  750. dwFormat |=  DT_CENTER;
  752. }
  754. pDC->SetTextColor(GetThemeColor(iPartId, iStateId, TMT_TEXTCOLOR, pDC->GetTextColor()));
  757. if (GetThemeEnumValue(iPartId, iStateId, TMT_TEXTSHADOWTYPE) == TST_SINGLE)
  758. {
  759. CSize sz = GetThemeSize(iPartId, iStateId, TMT_TEXTSHADOWOFFSET);
  761. if (sz != CSize(0, 0))
  762. {
  764. COLORREF clrShadow = GetThemeColor(iPartId, iStateId, TMT_TEXTSHADOWCOLOR);
  765. CRect rcShadow(rc);
  766. rcShadow.OffsetRect(sz);
  768. COLORREF clr = pDC->SetTextColor(clrShadow);
  769. pDC->DrawText(strText, rcShadow, dwFormat);
  770. pDC->SetTextColor(clr);
  771. }
  772. }
  774. pDC->DrawText(strText, rc, dwFormat);
  778. return TRUE;
  779. }
  781. CXTPSkinManagerSchemaProperty* CXTPSkinManagerClass::GetProperty(XTPSkinManagerProperty propType, int iPartId, int iStateId, int iPropId)
  782. {
  783. UINT nCachedProp = iPropId + ((iPartId + (iStateId << 6 )) << 14);
  784. CXTPSkinManagerSchemaProperty* pProperty = NULL;
  786. if (m_mapCachedProperties.Lookup(nCachedProp, pProperty))
  787. return pProperty;
  789. pProperty = m_pManager->GetSchema()->GetProperty(m_nClassCode, iPartId, iStateId, iPropId);
  790. if (!pProperty)
  791. {
  792. m_mapCachedProperties.SetAt(nCachedProp, NULL);
  793. return 0;
  794. }
  796. if (pProperty->propType != propType)
  797. return 0;
  799. m_mapCachedProperties.SetAt(nCachedProp , pProperty);
  801. return pProperty;
  802. }
  804. CString CXTPSkinManagerClass::GetThemeString(int iPartId, int iStateId, int iPropId, LPCTSTR lpszDefault)
  805. {
  806. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_STRING, iPartId, iStateId, iPropId);
  808. if (!pProperty)
  809. return lpszDefault;
  811. return pProperty->lpszVal;
  812. }
  814. CRect CXTPSkinManagerClass::GetThemeRect(int iPartId, int iStateId, int iPropId, CRect rcDefault)
  815. {
  816. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_RECT, iPartId, iStateId, iPropId);
  818. if (!pProperty)
  819. return rcDefault;
  821. return pProperty->rcVal;
  822. }
  824. int CXTPSkinManagerClass::GetThemeInt(int iPartId, int iStateId, int iPropId, int nDefault)
  825. {
  826. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_INT, iPartId, iStateId, iPropId);
  828. if (!pProperty)
  829. return nDefault;
  831. return pProperty->iVal;
  832. }
  833. BOOL CXTPSkinManagerClass::GetThemeBool(int iPartId, int iStateId, int iPropId, BOOL bDefault)
  834. {
  835. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_BOOL, iPartId, iStateId, iPropId);
  837. if (!pProperty)
  838. return bDefault;
  840. return pProperty->bVal;
  841. }
  842. COLORREF CXTPSkinManagerClass::GetThemeColor(int iPartId, int iStateId, int iPropId, COLORREF clrDefault)
  843. {
  844. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_COLOR, iPartId, iStateId, iPropId);
  846. if (!pProperty)
  847. return clrDefault;
  849. COLORREF clrVal = pProperty->clrVal;
  850. m_pManager->ApplyColorFilter(clrVal);
  852. return clrVal;
  853. }
  855. int CXTPSkinManagerClass::GetThemeEnumValue(int iPartId, int iStateId, int iPropId, int nDefault)
  856. {
  857. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_ENUM, iPartId, iStateId, iPropId);
  859. if (!pProperty)
  860. return nDefault;
  862. return pProperty->iVal;
  863. }
  865. CSize CXTPSkinManagerClass::GetThemeSize(int iPartId, int iStateId, int iPropId, CSize szDefault)
  866. {
  867. CXTPSkinManagerSchemaProperty* pProperty = GetProperty(XTP_SKINPROPERTY_POSITION, iPartId, iStateId, iPropId);
  869. if (!pProperty)
  870. return szDefault;
  872. return pProperty->szVal;
  873. }
  876. BOOL CXTPSkinManagerClass::DrawThemeBackground(CDC* pDC, int iPartId, int iStateId, const RECT *pRect)
  877. {
  878. return m_pManager->GetSchema()->DrawThemeBackground(pDC, this, iPartId, iStateId, pRect);
  879. }
  881. BOOL CXTPSkinManagerClass::GetThemePartSize(int iPartId, int iStateId, RECT *pRect, THEMESIZE eSize, SIZE* pSize)
  882. {
  883. if (GetThemeEnumValue(iPartId, iStateId, TMT_BGTYPE) != BT_IMAGEFILE)
  884. return FALSE;
  886. int nImageFile = (GetThemeEnumValue(iPartId, iStateId, TMT_IMAGESELECTTYPE) != IST_NONE) &&
  887. (GetThemeEnumValue(iPartId, iStateId, TMT_GLYPHTYPE, GT_NONE) == GT_NONE) ?
  888. TMT_IMAGEFILE1: TMT_IMAGEFILE;
  890. CString strImageFile = GetThemeString(iPartId, iStateId, nImageFile);
  891. if (strImageFile.IsEmpty())
  892. {
  893. if (nImageFile != TMT_IMAGEFILE1)
  894. return FALSE;
  896. strImageFile = GetThemeString(iPartId, iStateId, TMT_IMAGEFILE);
  897. if (strImageFile.IsEmpty())
  898. return FALSE;
  900. }
  903. CXTPSkinImage* pImage = GetImages()->LoadFile(m_pManager->GetResourceFile(), strImageFile);
  904. if (!pImage)
  905. {
  906. return FALSE;
  907. }
  909. int nImageCount = GetThemeInt(iPartId, iStateId, TMT_IMAGECOUNT, 1);
  910. if (nImageCount < 1)
  911. nImageCount = 1;
  913. BOOL bHorizontalImageLayout = GetThemeEnumValue(iPartId, iStateId, TMT_IMAGELAYOUT, IL_HORIZONTAL) == IL_HORIZONTAL;
  915. CSize sz(pImage->GetWidth(), pImage->GetHeight());
  916. if (bHorizontalImageLayout) sz.cx /= nImageCount; else sz.cy /= nImageCount;
  918. if (eSize == TS_TRUE)
  919. {
  920. *pSize = sz;
  921. }
  922. if (eSize == TS_DRAW)
  923. {
  924. if (GetThemeEnumValue(iPartId, iStateId, TMT_SIZINGTYPE, ST_STRETCH) == ST_TRUESIZE)
  925. {
  926. *pSize = sz;
  927. return TRUE;
  928. }
  930. if (!pRect)
  931. {
  932. pSize->cy = 0;
  933. pSize->cx = 0;
  934. }
  935. else
  936. {
  937. pSize->cy = pRect->bottom - pRect->top;
  938. pSize->cx = pRect->right - pRect->left;
  939. }
  941. if (GetThemeBool(iPartId, iStateId, TMT_UNIFORMSIZING, FALSE))
  942. {
  943. pSize->cx = MulDiv(pSize->cy, sz.cx, sz.cy);
  944. }
  945. }
  947. return TRUE;
  948. }