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

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

对话框与窗口

开发平台：

Visual C++

XTPSkinManagerApiHook.cpp：源码内容
  1. // XTPSkinManagerApiHook.cpp: implementation of the CXTPSkinManagerApiHook 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 <imagehlp.h>
  24. #pragma comment(lib, "imagehlp.lib")
  26. #include "Common/XTPVC80Helpers.h"
  28. #include "XTPSkinManager.h"
  29. #include "XTPSkinObjectFrame.h"
  30. #include "XTPSkinDrawTools.h"
  32. #include "XTPSkinManagerApiHook.h"
  33. #include "XTPSkinManagerModuleList.h"
  34. #include "XTPSkinManagerResource.h"
  36. #ifdef _UNICODE
  37. #define lpszSystemParametersInfo "SystemParametersInfoW"
  38. #else
  39. #define lpszSystemParametersInfo "SystemParametersInfoA"
  40. #endif
  43. int XTPCompareStringNoCase(const char* dst, const char* src)
  44. {
  45. int f, l;
  46. do
  47. {
  48. f = (unsigned char)(*(dst++));
  49. if ((f >= 'A') && (f <= 'Z'))
  50. f -= ('A' - 'a');
  52. l = (unsigned char)(*(src++));
  53. if ((l >= 'A') && (l <= 'Z'))
  54. l -= ('A' - 'a');
  55. }
  56. while ( f && (f == l) );
  58. return (f - l);
  59. }
  61. CXTPSkinManagerApiHook::CXTPSkinManagerApiHook()
  62. {
  63. m_bInitialized = FALSE;
  64. ZeroMemory(&m_arrFunctions, sizeof(m_arrFunctions));
  66. ExcludeModule(_T("SHLWAPI.DLL"), TRUE);
  67. ExcludeModule(_T("COMCTL32.DLL"), TRUE);
  68. ExcludeModule(_T("KERNEL32.DLL"), FALSE);
  69. ExcludeModule(_T("USER32.DLL"), FALSE);
  70. ExcludeModule(_T("GDI32.DLL"), FALSE);
  71. ExcludeModule(_T("WININET.DLL"), FALSE);
  73. ::InitializeCriticalSection(&m_cs);
  74. }
  76. CXTPSkinManagerApiHook::~CXTPSkinManagerApiHook()
  77. {
  78. FinalizeHookManagement();
  80. ::DeleteCriticalSection(&m_cs);
  82. }
  84. void CXTPSkinManagerApiHook::ConnectWrapper(CXTPWinThemeWrapper* pThemeWrapper)
  85. {
  86. pThemeWrapper->CreateSharedData();
  87. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperOpenThemeData, &CXTPSkinManagerApiHook::OnHookOpenThemeData);
  88. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperDrawThemeBackground, &CXTPSkinManagerApiHook::OnHookDrawThemeBackground);
  89. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperCloseThemeData, &CXTPSkinManagerApiHook::OnHookCloseThemeData);
  90. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperGetThemeColor, &CXTPSkinManagerApiHook::OnHookGetThemeColor);
  91. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperIsAppThemed, &CXTPSkinManagerApiHook::OnHookIsAppThemed);
  92. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperIsThemeActive, &CXTPSkinManagerApiHook::OnHookIsThemeActive);
  93. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperGetCurrentThemeName, &CXTPSkinManagerApiHook::OnHookGetCurrentThemeName);
  94. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperGetThemeSysBool, &CXTPSkinManagerApiHook::OnHookGetThemeSysBool);
  95. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperGetThemeSysColor, &CXTPSkinManagerApiHook::OnHookGetThemeSysColor);
  96. pThemeWrapper->SetThemeWrapperPtr(xtpWrapperGetThemePartSize, &CXTPSkinManagerApiHook::OnHookGetThemePartSize);
  98. }
  101. CXTPSkinManagerApiHook* CXTPSkinManagerApiHook::GetInstance()
  102. {
  103. static CXTPSkinManagerApiHook instance;
  104. return &instance;
  105. }
  107. void CXTPSkinManagerApiHook::ExcludeModule(LPCTSTR lpszModule, BOOL bWin9x)
  108. {
  109. EXCLUDEDMODULE em;
  110. em.bWin9x = bWin9x;
  111. em.strModule = lpszModule;
  112. em.hModule = 0;
  113. m_arrExcludedModules.Add(em);
  114. }
  116. BOOL CXTPSkinManagerApiHook::IsModuleExcluded(HMODULE hModule) const
  117. {
  118. BOOL bWin9x = XTPSkinManager()->IsWin9x();
  120. for (int i = 0; i < (int)m_arrExcludedModules.GetSize(); i++)
  121. {
  122. const EXCLUDEDMODULE& em = m_arrExcludedModules[i];
  124. if (em.bWin9x && !bWin9x)
  125. continue;
  127. if (em.hModule == hModule)
  128. return TRUE;
  130. }
  131. return FALSE;
  132. }
  135. void CXTPSkinManagerApiHook::UnhookAllFunctions()
  136. {
  137. for (int i = 0; i < XTP_SKIN_APIHOOKCOUNT; i++)
  138. {
  139. CXTPSkinManagerApiFunction* pHook = m_arrFunctions[i];
  141. if (pHook)
  142. {
  143. pHook->UnhookImport();
  144. delete pHook;
  146. m_arrFunctions[i] = NULL;
  147. }
  148. }
  150. ZeroMemory(&m_arrFunctions, sizeof(m_arrFunctions));
  152. }
  154. CXTPSkinManagerApiFunction* CXTPSkinManagerApiHook::HookImport(XTPSkinFrameworkApiFunctionIndex nIndex, LPCSTR pszCalleeModName, LPCSTR pszFuncName, PROC  pfnHook)
  155. {
  156. CXTPSkinManagerApiFunction* pResult = NULL;
  158. try
  159. {
  160. if (!GetHookedFunction(pszCalleeModName, pszFuncName))
  161. {
  162. if (XTPCompareStringNoCase(pszCalleeModName, "UXTHEME.DLL") == 0)
  163. {
  164. return AddHook(nIndex, pszCalleeModName, pszFuncName, NULL, pfnHook);
  165. }
  167. PROC pfnOrig = GetProcAddressWindows(::GetModuleHandleA(pszCalleeModName), pszFuncName);
  169. if (NULL == pfnOrig)
  170. {
  171. HMODULE hmod = ::LoadLibraryA(pszCalleeModName);
  172. if (hmod)
  173. {
  174. pfnOrig = GetProcAddressWindows(::GetModuleHandleA(pszCalleeModName), pszFuncName);
  175. }
  176. }
  178. if (pfnOrig)
  179. {
  180. pResult = AddHook(nIndex, pszCalleeModName, pszFuncName, pfnOrig,pfnHook);
  181. }
  182. }
  183. }
  184. catch(...)
  185. {
  187. }
  189. return pResult;
  190. }
  192. CXTPSkinManagerApiFunction* CXTPSkinManagerApiHook::AddHook(XTPSkinFrameworkApiFunctionIndex nIndex, LPCSTR pszCalleeModName, LPCSTR pszFuncName, PROC  pfnOrig, PROC  pfnHook)
  193. {
  194. ASSERT(!GetHookedFunction(pszCalleeModName, pszFuncName));
  195. ASSERT(!GetHookedFunction(nIndex));
  196. ASSERT(nIndex < XTP_SKIN_APIHOOKCOUNT);
  197. if (nIndex >= XTP_SKIN_APIHOOKCOUNT)
  198. return NULL;
  200. CXTPSkinManagerApiFunction* pHook = new CXTPSkinManagerApiFunction(this, pszCalleeModName, pszFuncName, pfnOrig, pfnHook);
  201. m_arrFunctions[nIndex] = pHook;
  202. pHook->HookImport();
  204. return pHook;
  205. }
  207. FARPROC WINAPI CXTPSkinManagerApiHook::GetProcAddressWindows(HMODULE hModule, LPCSTR pszProcName)
  208. {
  209. typedef FARPROC (WINAPI* LPFNGETPROCADDRESS)(HMODULE hModule, LPCSTR pszProcName);
  211. PROC pfnOrig = GetOriginalProc(xtpSkinApiGetProcAddress);
  213. if (pfnOrig)
  214. return ((LPFNGETPROCADDRESS)pfnOrig)(hModule, pszProcName);
  216. return ::GetProcAddress(hModule, pszProcName);
  217. }
  219. LRESULT WINAPI CXTPSkinManagerApiHook::CallWindowProcOrig(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  220. {
  221. typedef LRESULT (WINAPI* LPFNCALLWINDOWPROC)(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  223. #ifdef _UNICODE
  224. PROC pfnOrig = GetOriginalProc(xtpSkinApiCallWindowProcW);
  225. #else
  226. PROC pfnOrig = GetOriginalProc(xtpSkinApiCallWindowProcA);
  227. #endif
  229. if (pfnOrig)
  230. return ((LPFNCALLWINDOWPROC)pfnOrig)(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  232. return ::CallWindowProc(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  233. }
  235. CXTPSkinManagerApiFunction* CXTPSkinManagerApiHook::GetHookedFunction(XTPSkinFrameworkApiFunctionIndex nIndex)
  236. {
  237. ASSERT(nIndex < XTP_SKIN_APIHOOKCOUNT);
  238. if (nIndex < 0 || nIndex >= XTP_SKIN_APIHOOKCOUNT)
  239. return NULL;
  241. return m_arrFunctions[nIndex];
  242. }
  244. PROC AFX_CDECL CXTPSkinManagerApiHook::GetOriginalProc(XTPSkinFrameworkApiFunctionIndex nIndex)
  245. {
  246. CXTPSkinManagerApiFunction* pFunction = GetInstance()->GetHookedFunction(nIndex);
  247. if (!pFunction)
  248. return NULL;
  250. return pFunction->m_pfnOrig;
  251. }
  254. CXTPSkinManagerApiFunction* CXTPSkinManagerApiHook::GetHookedFunction(LPCSTR pszCalleeModName, LPCSTR pszFuncName)
  255. {
  256. for (int i = 0; i < XTP_SKIN_APIHOOKCOUNT; i++)
  257. {
  258. CXTPSkinManagerApiFunction* pHook = m_arrFunctions[i];
  260. if (!pHook)
  261. {
  262. continue;
  263. }
  265. if (XTPCompareStringNoCase(pHook->m_szCalleeModName, pszCalleeModName) == 0 &&
  266. XTPCompareStringNoCase(pHook->m_szFuncName, pszFuncName) == 0)
  267. {
  268. return pHook;
  269. }
  270. }
  272. return NULL;
  273. }
  275. //
  276. // The PUSH opcode on x86 platforms
  277. //
  278. const BYTE cPushOpCode = 0x68;
  280. PVOID CXTPSkinManagerApiFunction::sm_pvMaxAppAddr = NULL;
  281. PVOID CXTPSkinManagerApiFunction::sm_pfnAfxWndProc = NULL;
  283. //////////////////////////////////////////////////////////////////////////
  284. // CXTPSkinManagerApiFunction
  286. CXTPSkinManagerApiFunction::CXTPSkinManagerApiFunction( CXTPSkinManagerApiHook* pApiHook,
  287. LPCSTR pszCalleeModName, LPCSTR pszFuncName, PROC pfnOrig, PROC pfnHook)
  288. :
  289. m_pApiHook(pApiHook),
  290. m_bHooked(FALSE),
  291. m_pfnOrig(pfnOrig),
  292. m_pfnHook(pfnHook)
  293. {
  294. #if (_MSC_VER > 1310) // VS2005
  295. strcpy_s(m_szCalleeModName, 20, pszCalleeModName);
  296. strcpy_s(m_szFuncName, 30, pszFuncName);
  297. #else
  298. strcpy(m_szCalleeModName, pszCalleeModName);
  299. strcpy(m_szFuncName, pszFuncName);
  300. #endif
  302. if (sm_pfnAfxWndProc == NULL)
  303. {
  304. sm_pfnAfxWndProc = (FARPROC)AfxGetAfxWndProc();
  306. }
  308. if (sm_pvMaxAppAddr == NULL)
  309. {
  310. //
  311. // Functions with address above lpMaximumApplicationAddress require
  312. // special processing (Windows 9x only)
  313. //
  314. SYSTEM_INFO si;
  315. GetSystemInfo(&si);
  316. sm_pvMaxAppAddr = si.lpMaximumApplicationAddress;
  317. }
  319. if (m_pfnOrig > sm_pvMaxAppAddr)
  320. {
  321. //
  322. // The address is in a shared DLL; the address needs fixing up
  323. //
  324. PBYTE pb = (PBYTE) m_pfnOrig;
  325. if (pb[0] == cPushOpCode)
  326. {
  327. //
  328. // Skip over the PUSH op code and grab the real address
  329. //
  330. PVOID pv = * (PVOID*) &pb[1];
  331. m_pfnOrig = (PROC) pv;
  332. }
  333. }
  335. }
  338. CXTPSkinManagerApiFunction::~CXTPSkinManagerApiFunction()
  339. {
  340. UnhookImport();
  341. }
  343. BOOL CXTPSkinManagerApiFunction::HookImport()
  344. {
  345. return m_bHooked = ReplaceInAllModules(m_szCalleeModName, m_pfnOrig, m_pfnHook);
  346. }
  348. BOOL CXTPSkinManagerApiFunction::UnhookImport()
  349. {
  350. if (m_bHooked)
  351. {
  352. ReplaceInAllModules(m_szCalleeModName, m_pfnHook, m_pfnOrig);
  353. m_bHooked = FALSE;
  354. }
  355. return !m_bHooked;
  356. }
  358. BOOL CXTPSkinManagerApiFunction::ReplaceInAllModules(LPCSTR pszCalleeModName,
  359. PROC pfnCurrent, PROC pfnNew)
  360. {
  361. BOOL bResult = FALSE;
  363. if ((NULL != pfnCurrent) && (NULL != pfnNew))
  364. {
  365. HINSTANCE hInstance = AfxGetInstanceHandle();
  367. CXTPSkinManagerModuleList moduleList(::GetCurrentProcessId());
  369. HMODULE hModule = moduleList.GetFirstModule();
  371. while (hModule)
  372. {
  373. #ifdef _DEBUG
  374. TCHAR fn[MAX_PATH];
  375. GetModuleFileName(hModule, fn, MAX_PATH);
  376. #endif
  377. if ((hModule != hInstance) && !m_pApiHook->IsModuleExcluded(hModule))
  378. {
  379. if (ReplaceInOneModule(pszCalleeModName, pfnCurrent, pfnNew, hModule))
  380. {
  381. bResult = TRUE;
  382. }
  383. }
  385. hModule = moduleList.GetNextModule();
  386. }
  389. if (ReplaceInOneModule(pszCalleeModName, pfnCurrent, pfnNew, hInstance))
  390. {
  391. bResult = TRUE;
  392. }
  393. }
  394. return bResult;
  395. }
  397. BOOL CXTPSkinManagerApiFunction::ReplaceInOneModule(LPCSTR pszCalleeModName, PROC pfnCurrent, PROC pfnNew, HMODULE hmodCaller)
  398. {
  399. if (pfnCurrent == NULL || pfnNew == NULL)
  400. return FALSE;
  402. CXTPLockGuard lock(m_pApiHook->m_cs);
  404. try
  405. {
  406. ULONG ulSize;
  407. // Get the address of the module's import section
  408. PIMAGE_IMPORT_DESCRIPTOR pImportDesc =
  409. (PIMAGE_IMPORT_DESCRIPTOR)ImageDirectoryEntryToData(
  410. hmodCaller,
  411. TRUE,
  412. IMAGE_DIRECTORY_ENTRY_IMPORT,
  413. &ulSize
  414. );
  415. // Does this module has import section ?
  416. if (pImportDesc == NULL)
  417. return FALSE;
  419. while (pImportDesc != NULL)
  420. {
  422. // Loop through all descriptors and
  423. // find the import descriptor containing references to callee's functions
  424. while (pImportDesc->Name)
  425. {
  426. LPCSTR lpszName = ((LPCSTR)((PBYTE) hmodCaller + pImportDesc->Name));
  427. if (XTPCompareStringNoCase(lpszName, pszCalleeModName) == 0)
  428. break;   // Found
  429. pImportDesc++;
  430. } // while
  431. // Does this module import any functions from this callee ?
  432. if (pImportDesc->Name == 0)
  433. return FALSE;
  435. PIMAGE_THUNK_DATA pThunk =
  436. (PIMAGE_THUNK_DATA)( (PBYTE) hmodCaller + (UINT_PTR)pImportDesc->FirstThunk );
  438. while (pThunk->u1.Function)
  439. {
  440. PROC* ppfn = (PROC*) &pThunk->u1.Function;
  442. BOOL bFound = (*ppfn == pfnCurrent);
  444. if (!bFound && (*ppfn > sm_pvMaxAppAddr))
  445. {
  446. PBYTE pbInFunc = (PBYTE) *ppfn;
  447. // Is this a wrapper (debug thunk) represented by PUSH instruction?
  448. if (pbInFunc[0] == cPushOpCode)
  449. {
  450. ppfn = (PROC*) &pbInFunc[1];
  451. bFound = (*ppfn == pfnCurrent);
  452. }
  453. }
  456. if (bFound)
  457. {
  458. MEMORY_BASIC_INFORMATION mbi;
  459. ::VirtualQuery(ppfn, &mbi, sizeof(MEMORY_BASIC_INFORMATION));
  460. // In order to provide writable access to this part of the
  461. // memory we need to change the memory protection
  462. if (!::VirtualProtect(mbi.BaseAddress, mbi.RegionSize,
  463. PAGE_READWRITE, &mbi.Protect))
  464. {
  465. return FALSE;
  466. }
  468. // Hook the function.
  469. *ppfn = *pfnNew;
  471. // Restore the protection back
  472. DWORD dwOldProtect;
  473. ::VirtualProtect(mbi.BaseAddress, mbi.RegionSize,
  474. mbi.Protect, &dwOldProtect);
  476. return TRUE;
  477. }
  478. pThunk++;
  479. }
  480. pImportDesc++;
  482. }
  483. }
  484. catch(...)
  485. {
  486. // do nothing
  487. }
  489. return FALSE;
  490. }
  492. void CXTPSkinManagerApiHook::InitializeHookManagement()
  493. {
  494. if (m_bInitialized)
  495. return;
  497. for (int i = 0; i < (int)m_arrExcludedModules.GetSize(); i++)
  498. {
  499. m_arrExcludedModules[i].hModule = GetModuleHandle(m_arrExcludedModules[i].strModule);
  500. }
  503. #define ADDHOOK(Dll, ProcName) 
  504. HookImport(xtpSkinApi##ProcName, Dll, #ProcName, (PROC)&CXTPSkinManagerApiHook::OnHook##ProcName)
  506. ADDHOOK("KERNEL32.DLL", LoadLibraryA);
  507. ADDHOOK("KERNEL32.DLL", LoadLibraryW);
  508. ADDHOOK("KERNEL32.DLL", LoadLibraryExA);
  509. ADDHOOK("KERNEL32.DLL", LoadLibraryExW);
  510. ADDHOOK("KERNEL32.DLL", GetProcAddress);
  511. ADDHOOK("KERNEL32.DLL", GetModuleHandleA);
  512. ADDHOOK("KERNEL32.DLL", CreateThread);
  514. ADDHOOK("USER32.DLL", RegisterClassA);
  515. ADDHOOK("USER32.DLL", RegisterClassW);
  517. if (XTPSkinManager()->GetApplyOptions() & xtpSkinApplyColors)
  518. {
  519. ADDHOOK("USER32.DLL", GetSysColor);
  520. ADDHOOK("USER32.DLL", GetSysColorBrush);
  521. ADDHOOK("USER32.DLL", DrawEdge);
  522. ADDHOOK("USER32.DLL", FillRect);
  523. ADDHOOK("GDI32.DLL", DeleteObject);
  525. ADDHOOK("UXTHEME.DLL", OpenThemeData);
  526. ADDHOOK("UXTHEME.DLL", DrawThemeBackground);
  527. ADDHOOK("UXTHEME.DLL", CloseThemeData);
  528. ADDHOOK("UXTHEME.DLL", GetThemeColor);
  529. ADDHOOK("UXTHEME.DLL", IsAppThemed);
  530. ADDHOOK("UXTHEME.DLL", IsThemeActive);
  531. ADDHOOK("UXTHEME.DLL", GetCurrentThemeName);
  532. ADDHOOK("UXTHEME.DLL", GetThemeSysBool);
  533. ADDHOOK("UXTHEME.DLL", GetThemeSysColor);
  534. ADDHOOK("UXTHEME.DLL", GetThemePartSize);
  536. ADDHOOK("USER32.DLL", DrawFrameControl);
  537. }
  540. if (XTPSkinManager()->GetApplyOptions() & xtpSkinApplyFrame)
  541. {
  542. ADDHOOK("USER32.DLL", SetScrollInfo);
  543. ADDHOOK("USER32.DLL", SetScrollPos);
  544. ADDHOOK("USER32.DLL", GetScrollInfo);
  545. ADDHOOK("USER32.DLL", EnableScrollBar);
  546. }
  548. if (XTPSkinManager()->GetApplyOptions() & xtpSkinApplyMetrics)
  549. {
  550. HookImport(xtpSkinApiSystemParametersInfo, "USER32.DLL", lpszSystemParametersInfo, (PROC)&CXTPSkinManagerApiHook::OnHookSystemParametersInfo);
  551. ADDHOOK("USER32.DLL", AdjustWindowRectEx);
  552. }
  554. ADDHOOK("USER32.DLL", DefWindowProcA);
  555. ADDHOOK("USER32.DLL", DefWindowProcW);
  556. ADDHOOK("USER32.DLL", DefFrameProcA);
  557. ADDHOOK("USER32.DLL", DefFrameProcW);
  558. ADDHOOK("USER32.DLL", DefDlgProcA);
  559. ADDHOOK("USER32.DLL", DefDlgProcW);
  560. ADDHOOK("USER32.DLL", DefMDIChildProcA);
  561. ADDHOOK("USER32.DLL", DefMDIChildProcW);
  563. ADDHOOK("USER32.DLL", CallWindowProcA);
  564. ADDHOOK("USER32.DLL", CallWindowProcW);
  566. m_bInitialized = TRUE;
  567. }
  569. void CXTPSkinManagerApiHook::FinalizeHookManagement()
  570. {
  571. if (!m_bInitialized)
  572. return;
  574. UnhookAllFunctions();
  576. m_bInitialized = FALSE;
  577. }
  579. DWORD WINAPI CXTPSkinManagerApiHook::OnHookGetSysColor(int nIndex)
  580. {
  581. typedef int(WINAPI* LPFNGETSYSCOLOR)(int);
  583. CXTPSkinManagerMetrics* pMetrics = XTPSkinManager()->GetMetrics();
  585. if (XTPSkinManager()->IsEnabled() && nIndex < XTP_SKINMETRICS_COLORTABLESIZE && pMetrics->m_clrTheme[nIndex] != -1)
  586. return pMetrics->m_clrTheme[nIndex];
  588. PROC pfnOrig = GetOriginalProc(xtpSkinApiGetSysColor);
  590. DWORD nResult = pfnOrig ? ((LPFNGETSYSCOLOR)pfnOrig)(nIndex) : GetSysColor(nIndex);
  592. return nResult;
  594. }
  596. BOOL WINAPI CXTPSkinManagerApiHook::OnHookDeleteObject(HGDIOBJ hObject)
  597. {
  598. typedef BOOL (WINAPI* LPFNDELETEOBJECT)(HGDIOBJ);
  600. CXTPSkinManagerMetrics* pMetrics = XTPSkinManager()->GetMetrics();
  601. if (pMetrics->IsMetricObject(hObject))
  602. return FALSE;
  604. PROC pfnOrig = GetOriginalProc(xtpSkinApiDeleteObject);
  606. return pfnOrig ? ((LPFNDELETEOBJECT)pfnOrig)(hObject) : DeleteObject(hObject);
  607. }
  609. HBRUSH WINAPI CXTPSkinManagerApiHook::OnHookGetSysColorBrush(  int nIndex)
  610. {
  611. typedef HBRUSH (WINAPI* LPFNGETSYSCOLORBRUSH)(int);
  613. CXTPSkinManagerMetrics* pMetrics = XTPSkinManager()->GetMetrics();
  615. if (XTPSkinManager()->IsEnabled() && nIndex > 0 && nIndex < XTP_SKINMETRICS_COLORTABLESIZE && pMetrics->m_brTheme[nIndex])
  616. {
  617. return pMetrics->m_brTheme[nIndex];
  618. }
  620. PROC pfnOrig = GetOriginalProc(xtpSkinApiGetSysColorBrush);
  622. HBRUSH nResult = pfnOrig ? ((LPFNGETSYSCOLORBRUSH)pfnOrig)(nIndex) : GetSysColorBrush(nIndex);
  624. return nResult;
  626. }
  628. int WINAPI CXTPSkinManagerApiHook::OnHookSetScrollPos( HWND hwnd,  int nBar,   int nPos,  BOOL redraw)
  629. {
  631. typedef int(WINAPI* LPFNSETSCROLLPOS)(  HWND hWnd,  int nBar,  int nPos,  BOOL bRedraw);
  633. PROC pfnOrig = GetOriginalProc(xtpSkinApiSetScrollPos);
  634. if (!pfnOrig)
  635. return SetScrollPos(hwnd, nBar, nPos, redraw);
  637. CXTPSkinObjectFrame* pFrame = (CXTPSkinObjectFrame*)XTPSkinManager()->Lookup(hwnd);
  639. if (!pFrame)
  640. return pfnOrig ? ((LPFNSETSCROLLPOS)pfnOrig)(hwnd, nBar, nPos, redraw) : 0;
  642. int nResult = pfnOrig ? ((LPFNSETSCROLLPOS)pfnOrig)(hwnd, nBar, nPos, FALSE) : 0;
  644. if (redraw)
  645. {
  646. if (nBar == SB_CTL) InvalidateRect(hwnd, NULL, FALSE);
  647. else pFrame->RedrawScrollBar(nBar);
  648. }
  651. return nResult;
  653. }
  656. int WINAPI CXTPSkinManagerApiHook::OnHookSetScrollInfo( HWND hwnd,  int nBar,  LPCSCROLLINFO lpsi,  BOOL redraw)
  657. {
  658. typedef int(WINAPI* LPFNSETSCROLLINFO)(HWND hwnd, int fnBar, LPCSCROLLINFO lpsi, BOOL fRedraw);
  660. PROC pfnOrig = GetOriginalProc(xtpSkinApiSetScrollInfo);
  661. if (!pfnOrig)
  662. return SetScrollInfo(hwnd, nBar, lpsi, redraw);
  664. CXTPSkinObjectFrame* pFrame = (CXTPSkinObjectFrame*)XTPSkinManager()->Lookup(hwnd);
  666. if (!pFrame || (nBar == SB_CTL) || !redraw)
  667. return ((LPFNSETSCROLLINFO)pfnOrig)(hwnd, nBar, lpsi, redraw);
  669. int nResult = ((LPFNSETSCROLLINFO)pfnOrig)(hwnd, nBar, lpsi, FALSE);
  670. pFrame->RedrawScrollBar(nBar);
  672. return nResult;
  673. }
  675. BOOL WINAPI CXTPSkinManagerApiHook::OnHookEnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows)
  676. {
  677. typedef int(WINAPI* LPFNENABLESCROLLBAR)(HWND hWnd, UINT wSBflags, UINT wArrows);
  679. PROC pfnOrig = GetOriginalProc(xtpSkinApiEnableScrollBar);
  680. if (!pfnOrig)
  681. return EnableScrollBar(hWnd, wSBflags, wArrows);
  683. CXTPSkinObjectFrame* pFrame = (CXTPSkinObjectFrame*)XTPSkinManager()->Lookup(hWnd);
  685. if (!pFrame)
  686. return pfnOrig ? ((LPFNENABLESCROLLBAR)pfnOrig)(hWnd, wSBflags, wArrows) : 0;
  688. int nResult = pfnOrig ? ((LPFNENABLESCROLLBAR)pfnOrig)(hWnd, wSBflags, wArrows) : 0;
  690. if (wSBflags == SB_BOTH || wSBflags == SB_HORZ)
  691. pFrame->RedrawScrollBar(SB_HORZ);
  693. if (wSBflags == SB_BOTH || wSBflags == SB_VERT)
  694. pFrame->RedrawScrollBar(SB_VERT);
  697. return nResult;
  698. }
  700. BOOL WINAPI CXTPSkinManagerApiHook::OnHookGetScrollInfo(HWND hWnd, int nBar, LPSCROLLINFO lpsi)
  701. {
  703. typedef BOOL(WINAPI* LPFNGETSCROLLINFO)(HWND hwnd, int nBar, LPCSCROLLINFO lpsi);
  705. PROC pfnOrig = GetOriginalProc(xtpSkinApiGetScrollInfo);
  706. if (!pfnOrig)
  707. return GetScrollInfo(hWnd, nBar, lpsi);
  709. BOOL nResult = pfnOrig ? ((LPFNGETSCROLLINFO)pfnOrig)(hWnd, nBar, lpsi) : FALSE;
  711. if (lpsi && (lpsi->fMask & SIF_TRACKPOS))
  712. {
  713. CXTPSkinObject* pSink = XTPSkinManager()->Lookup(hWnd);
  715. if (pSink)
  716. {
  717. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = ((CXTPSkinObjectFrame*)pSink)->GetScrollBarTrackInfo();
  719. if (pSBTrack && (pSBTrack->nBar == nBar))
  720. {
  721. // posNew is in the context of psbiSB's window and bar code
  722. lpsi->nTrackPos = pSBTrack->posNew;
  723. }
  724. }
  726. }
  728. return nResult;
  729. }
  731. BOOL CXTPSkinManagerApiHook::IsSystemWindowModule(WNDPROC lpWndProc)
  732. {
  733. if ((HIWORD((ULONG)(ULONG_PTR)lpWndProc)) == 0xFFFF)
  734. return TRUE;
  736. static XTP_MODULEINFO miUser32 = {(LPVOID)-1, 0, 0, 0};
  738. if (miUser32.lpBaseOfDll == (LPVOID)-1)
  739. {
  740. HMODULE hUser32 = GetModuleHandle(_T("USER32.DLL"));
  741. miUser32.hModule = hUser32;
  742. if (hUser32)
  743. {
  744. CXTPSkinManagerModuleList moduleList(::GetCurrentProcessId());
  745. moduleList.GetModuleInformation(hUser32, &miUser32);
  746. }
  747. }
  749. if ((LPBYTE)lpWndProc > (LPBYTE)miUser32.lpBaseOfDll
  750. && (LPBYTE)lpWndProc < (LPBYTE)miUser32.lpBaseOfDll + miUser32.SizeOfImage)
  751. return TRUE;
  753. static XTP_MODULEINFO miComCtrl32  = {(LPVOID)-1, 0, (LPVOID)-1, 0};
  755. HMODULE hComCtl32 = GetModuleHandle(_T("COMCTL32.DLL"));
  757. if (hComCtl32 && (miComCtrl32.lpBaseOfDll == (LPVOID)-1 || miComCtrl32.hModule != hComCtl32 ))
  758. {
  759. miComCtrl32.hModule = hComCtl32;
  760. CXTPSkinManagerModuleList moduleList(::GetCurrentProcessId());
  761. moduleList.GetModuleInformation(hComCtl32, &miComCtrl32);
  762. }
  764. if ((LPBYTE)lpWndProc > (LPBYTE)miComCtrl32.lpBaseOfDll
  765. && (LPBYTE)lpWndProc < (LPBYTE)miComCtrl32.lpBaseOfDll + miComCtrl32.SizeOfImage)
  766. return TRUE;
  768. if (XTPSystemVersion()->IsWinXPOrGreater())
  769. {
  770. static XTP_MODULEINFO miNtDll = {(LPVOID)-1, 0, 0, 0};
  772. if (miNtDll.lpBaseOfDll == (LPVOID)-1)
  773. {
  774. HMODULE hNtDLL = GetModuleHandle(_T("NTDLL.DLL"));
  775. miNtDll.hModule = hNtDLL;
  776. if (hNtDLL)
  777. {
  778. CXTPSkinManagerModuleList moduleList(::GetCurrentProcessId());
  779. moduleList.GetModuleInformation(hNtDLL, &miNtDll);
  780. }
  781. }
  783. if ((LPBYTE)lpWndProc > (LPBYTE)miNtDll.lpBaseOfDll
  784. && (LPBYTE)lpWndProc < (LPBYTE)miNtDll.lpBaseOfDll + miNtDll.SizeOfImage)
  785. return TRUE;
  786. }
  788. return FALSE;
  789. }
  791. BOOL CXTPSkinManagerApiHook::CallHookDefWindowProc(HWND hWnd, PROC pfnOrig, XTPSkinDefaultProc defProc, LPVOID lpPrev, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  792. {
  793. CXTPSkinManager* pSkinManager = XTPSkinManager();
  794. if (!pSkinManager->IsEnabled())
  795. return FALSE;
  797. CXTPSkinObject* pSkinObject = pSkinManager->Lookup(hWnd);
  799. if (!pSkinObject || pSkinObject->m_bCustomDraw)
  800. return FALSE;
  802. if (nMessage == pSkinObject->GetHeadMessage())
  803. return FALSE;
  805. if (nMessage == WM_NCDESTROY && pSkinObject->m_bWindowsForms)
  806. {
  807. pSkinObject->GetSkinManager()->Remove(hWnd, TRUE);
  808. return FALSE;
  809. }
  811. if (defProc == xtpSkinDefaultCallWindowProc && pSkinObject->IsDefWindowProcAvail(nMessage))
  812. {
  813. WNDPROC lpWndProc = (WNDPROC)lpPrev;
  815. if (IsSystemWindowModule(lpWndProc))
  816. {
  817. lpWndProc = 0;
  818. }
  820. if (lpWndProc != 0 && (!pSkinManager->IsWin9x() ||
  821. ((DWORD_PTR)lpWndProc < (DWORD_PTR)0x70000000)))
  822. {
  823. return FALSE;
  824. }
  825. }
  827. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  828. MSG  oldMsg = curMsg;
  829. curMsg.hwnd = hWnd;
  830. curMsg.message = nMessage;
  831. curMsg.wParam  = wParam;
  832. curMsg.lParam  = lParam;
  834. pSkinObject->OnBeginHook(nMessage, defProc, pfnOrig, lpPrev);
  836. BOOL bResult = pSkinObject->OnHookDefWindowProc(nMessage, wParam ,lParam, lResult);
  838. pSkinObject->OnEndHook();
  840. curMsg = oldMsg;
  842. if (bResult)
  843. return TRUE;
  845. return FALSE;
  846. }
  848. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookCallWindowProcW(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  849. {
  850. PROC pfnOrig = GetOriginalProc(xtpSkinApiCallWindowProcW);
  851. if (!pfnOrig)
  852. return CallWindowProcW(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  854. LRESULT lResult = 0;
  855. if (lpPrevWndFunc && GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultCallWindowProc, lpPrevWndFunc, Msg, wParam ,lParam, lResult))
  856. {
  857. return lResult;
  858. }
  860. typedef LRESULT (WINAPI* LPFNCALLWINDOWPROC)(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  861. LRESULT bResult = ((LPFNCALLWINDOWPROC)pfnOrig)(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  863. return bResult;
  864. }
  866. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookCallWindowProcA(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  867. {
  868. PROC pfnOrig = GetOriginalProc(xtpSkinApiCallWindowProcA);
  869. if (!pfnOrig)
  870. return CallWindowProcA(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  872. LRESULT lResult = 0;
  873. if (lpPrevWndFunc && GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultCallWindowProc, lpPrevWndFunc, Msg, wParam ,lParam, lResult))
  874. {
  875. return lResult;
  876. }
  878. typedef LRESULT (WINAPI* LPFNCALLWINDOWPROC)(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  879. LRESULT bResult = ((LPFNCALLWINDOWPROC)pfnOrig)(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  881. return bResult;
  882. }
  884. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefWindowProcA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  885. {
  886. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefWindowProcA);
  887. if (!pfnOrig)
  888. return DefWindowProcA(hWnd, Msg, wParam, lParam);
  890. LRESULT lResult = 0;
  891. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefWindowProc, NULL, Msg, wParam ,lParam, lResult))
  892. {
  893. return lResult;
  894. }
  896. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  897. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, Msg, wParam, lParam);
  898. }
  900. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefWindowProcW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  901. {
  902. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefWindowProcW);
  903. if (!pfnOrig)
  904. return DefWindowProcW(hWnd, Msg, wParam, lParam);
  906. LRESULT lResult = 0;
  907. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefWindowProc, NULL, Msg, wParam ,lParam, lResult))
  908. {
  909. return lResult;
  910. }
  912. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  913. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, Msg, wParam, lParam);
  914. }
  916. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefFrameProcA(HWND hWnd, HWND hWndMDIClient, UINT Msg, WPARAM wParam, LPARAM lParam)
  917. {
  918. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefFrameProcA);
  919. if (!pfnOrig)
  920. return DefFrameProcA(hWnd, hWndMDIClient, Msg, wParam, lParam);
  922. LRESULT lResult = 0;
  923. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefFrameProc, (LPVOID)hWndMDIClient, Msg, wParam ,lParam, lResult))
  924. {
  925. return lResult;
  926. }
  928. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, HWND hWndMDIClient, UINT Msg, WPARAM wParam, LPARAM lParam);
  929. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, hWndMDIClient, Msg, wParam, lParam);
  930. }
  932. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefFrameProcW(HWND hWnd, HWND hWndMDIClient, UINT Msg, WPARAM wParam, LPARAM lParam)
  933. {
  934. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefFrameProcW);
  935. if (!pfnOrig)
  936. return DefFrameProcW(hWnd, hWndMDIClient, Msg, wParam, lParam);
  938. LRESULT lResult = 0;
  939. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefFrameProc, (LPVOID)hWndMDIClient, Msg, wParam ,lParam, lResult))
  940. {
  941. return lResult;
  942. }
  944. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, HWND hWndMDIClient, UINT Msg, WPARAM wParam, LPARAM lParam);
  945. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, hWndMDIClient, Msg, wParam, lParam);
  946. }
  948. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefDlgProcA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  949. {
  950. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefDlgProcA);
  951. if (!pfnOrig)
  952. return DefDlgProcA(hWnd, Msg, wParam, lParam);
  954. LRESULT lResult = 0;
  955. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefDlgProc, NULL, Msg, wParam ,lParam, lResult))
  956. {
  957. return lResult;
  958. }
  960. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  961. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, Msg, wParam, lParam);
  962. }
  964. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefDlgProcW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  965. {
  966. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefDlgProcW);
  967. if (!pfnOrig)
  968. return DefDlgProcW(hWnd, Msg, wParam, lParam);
  970. LRESULT lResult = 0;
  971. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefDlgProc, NULL, Msg, wParam ,lParam, lResult))
  972. {
  973. return lResult;
  974. }
  976. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  977. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, Msg, wParam, lParam);
  978. }
  980. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefMDIChildProcA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  981. {
  982. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefMDIChildProcA);
  983. if (!pfnOrig)
  984. return DefMDIChildProcA(hWnd, Msg, wParam, lParam);
  986. LRESULT lResult = 0;
  987. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefMDIChildProc, NULL, Msg, wParam ,lParam, lResult))
  988. {
  989. return lResult;
  990. }
  992. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  993. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, Msg, wParam, lParam);
  994. }
  996. LRESULT WINAPI CXTPSkinManagerApiHook::OnHookDefMDIChildProcW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  997. {
  998. PROC pfnOrig = GetOriginalProc(xtpSkinApiDefMDIChildProcW);
  999. if (!pfnOrig)
  1000. return DefMDIChildProcW(hWnd, Msg, wParam, lParam);
  1002. LRESULT lResult = 0;
  1003. if (GetInstance()->CallHookDefWindowProc(hWnd, pfnOrig, xtpSkinDefaultDefMDIChildProc, NULL, Msg, wParam ,lParam, lResult))
  1004. {
  1005. return lResult;
  1006. }
  1008. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  1009. return ((LPFNDEFWINDOWPROC)pfnOrig)(hWnd, Msg, wParam, lParam);
  1010. }
  1016. struct XTP_SKINFRAMEWORK_THREADPROCPARAMETER
  1017. {
  1018. LPTHREAD_START_ROUTINE lpStartAddress;
  1019. LPVOID lpParameter;
  1020. };
  1022. DWORD WINAPI CXTPSkinManagerApiHook::ThreadProcHook(LPVOID lpThreadData)
  1023. {
  1025. XTP_SKINFRAMEWORK_THREADPROCPARAMETER* parameter = (XTP_SKINFRAMEWORK_THREADPROCPARAMETER*)lpThreadData;
  1026. LPTHREAD_START_ROUTINE lpStartAddress = parameter->lpStartAddress;
  1027. LPVOID lpParam = parameter->lpParameter;
  1028. delete lpThreadData;
  1030. XTPSkinManager()->EnableCurrentThread();
  1032. return (lpStartAddress)(lpParam);
  1033. }
  1035. HANDLE STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookCreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
  1036. UINT_PTR dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter,
  1037. DWORD dwCreationFlags, LPDWORD lpThreadId)
  1038. {
  1039. typedef HANDLE (WINAPI* LPFNCREATETHREAD)(LPSECURITY_ATTRIBUTES lpThreadAttributes,
  1040. UINT_PTR dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter,
  1041. DWORD dwCreationFlags, LPDWORD lpThreadId);
  1043. PROC pfnOrig = GetOriginalProc(xtpSkinApiCreateThread);
  1044. if (!pfnOrig)
  1045. return CreateThread(lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId);
  1047. if (XTPSkinManager()->IsEnabled() && XTPSkinManager()->GetAutoApplyNewThreads())
  1048. {
  1050. XTP_SKINFRAMEWORK_THREADPROCPARAMETER* pParam = new XTP_SKINFRAMEWORK_THREADPROCPARAMETER;
  1051. pParam->lpParameter = lpParameter;
  1052. pParam->lpStartAddress = lpStartAddress;
  1054. return ((LPFNCREATETHREAD)pfnOrig)(lpThreadAttributes,
  1055. dwStackSize, ThreadProcHook, pParam,
  1056. dwCreationFlags, lpThreadId);
  1057. }
  1059. return ((LPFNCREATETHREAD)pfnOrig)(lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId);
  1060. }
  1063. ATOM WINAPI CXTPSkinManagerApiHook::OnHookRegisterClassA ( const WNDCLASSA *lpWndClass)
  1064. {
  1065. typedef ATOM(WINAPI* LPFNREGISTERCLASSA)(const WNDCLASSA* lpWndClass);
  1067. PROC pfnOrig = GetOriginalProc(xtpSkinApiRegisterClassA);
  1068. if (!pfnOrig)
  1069. return RegisterClassA(lpWndClass);
  1071. CXTPSkinManagerApiFunction* pDefWindowFunction = NULL;
  1072. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefWindowProcA)
  1073. {
  1074. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefWindowProcA);
  1075. }
  1076. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefFrameProcA)
  1077. {
  1078. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefFrameProcA);
  1079. }
  1080. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefMDIChildProcA)
  1081. {
  1082. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefMDIChildProcA);
  1083. }
  1084. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefDlgProcA)
  1085. {
  1086. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefDlgProcA);
  1087. }
  1089. if (pDefWindowFunction)
  1090. {
  1091. WNDCLASSA wc;
  1092. wc = *lpWndClass;
  1093. wc.lpfnWndProc = (WNDPROC)pDefWindowFunction->m_pfnOrig;
  1095. return ((LPFNREGISTERCLASSA)pfnOrig)(&wc);
  1096. }
  1098. return ((LPFNREGISTERCLASSA)pfnOrig)(lpWndClass);
  1099. }
  1101. ATOM WINAPI CXTPSkinManagerApiHook::OnHookRegisterClassW ( const WNDCLASSW *lpWndClass)
  1102. {
  1103. typedef ATOM(WINAPI* LPFNREGISTERCLASSW)(const WNDCLASSW* lpWndClass);
  1105. PROC pfnOrig = GetOriginalProc(xtpSkinApiRegisterClassW);
  1106. if (!pfnOrig)
  1107. return RegisterClassW(lpWndClass);
  1109. CXTPSkinManagerApiFunction* pDefWindowFunction = NULL;
  1110. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefWindowProcW)
  1111. {
  1112. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefWindowProcW);
  1113. }
  1114. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefFrameProcW)
  1115. {
  1116. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefFrameProcW);
  1117. }
  1118. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefMDIChildProcW)
  1119. {
  1120. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefMDIChildProcW);
  1121. }
  1122. if (lpWndClass && lpWndClass->lpfnWndProc == (WNDPROC)&CXTPSkinManagerApiHook::OnHookDefDlgProcW)
  1123. {
  1124. pDefWindowFunction = GetInstance()->GetHookedFunction(xtpSkinApiDefDlgProcW);
  1125. }
  1127. if (pDefWindowFunction)
  1128. {
  1129. WNDCLASSW wc;
  1130. wc = *lpWndClass;
  1131. wc.lpfnWndProc = (WNDPROC)pDefWindowFunction->m_pfnOrig;
  1133. return ((LPFNREGISTERCLASSW)pfnOrig)(&wc);
  1134. }
  1136. return ((LPFNREGISTERCLASSW)pfnOrig)(lpWndClass);
  1138. }
  1140. BOOL WINAPI CXTPSkinManagerApiHook::OnHookSystemParametersInfo (UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
  1141. {
  1142. typedef BOOL(WINAPI* LPFNSYSTEMPARAMETERSINFO )(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni);
  1144. PROC pfnOrig = GetOriginalProc(xtpSkinApiSystemParametersInfo);
  1145. if (!pfnOrig)
  1146. return SystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
  1149. BOOL bResult = ((LPFNSYSTEMPARAMETERSINFO)pfnOrig)(uiAction, uiParam, pvParam, fWinIni);
  1151. if (uiAction == SPI_GETICONTITLELOGFONT && uiParam == sizeof(LOGFONT))
  1152. {
  1153. LOGFONT* pLogFont = (LOGFONT*)pvParam;
  1155. CXTPSkinManagerSchema* pSchema = XTPSkinManager()->GetSchema();
  1156. UINT nSysMetrics = pSchema->GetClassCode(_T("SYSMETRICS"));
  1158. pSchema->GetFontProperty(nSysMetrics, 0, 0, TMT_ICONTITLEFONT, *pLogFont);
  1159. }
  1161. if (uiAction == SPI_GETNONCLIENTMETRICS && uiParam == sizeof(NONCLIENTMETRICS))
  1162. {
  1163. NONCLIENTMETRICS* pncm = (NONCLIENTMETRICS*)pvParam;
  1165. CXTPSkinManagerSchema* pSchema = XTPSkinManager()->GetSchema();
  1166. UINT nSysMetrics = pSchema->GetClassCode(_T("SYSMETRICS"));
  1168. pSchema->GetFontProperty(nSysMetrics, 0, 0, TMT_MENUFONT, pncm->lfMenuFont);
  1169. pSchema->GetFontProperty(nSysMetrics, 0, 0, TMT_STATUSFONT, pncm->lfStatusFont);
  1170. pSchema->GetFontProperty(nSysMetrics, 0, 0, TMT_CAPTIONFONT, pncm->lfCaptionFont);
  1172. }
  1174. return bResult;
  1175. }
  1177. BOOL WINAPI CXTPSkinManagerApiHook::OnHookAdjustWindowRectEx(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle)
  1178. {
  1179. typedef BOOL (WINAPI* LPFNADJUSTWINDOWRECTEX)(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle);
  1181. PROC pfnOrig = GetOriginalProc(xtpSkinApiAdjustWindowRectEx);
  1182. if (!pfnOrig)
  1183. return AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle);
  1185. CXTPSkinManager* pSkinManager = XTPSkinManager();
  1187. if (lpRect && !bMenu && (pSkinManager->GetApplyOptions() & xtpSkinApplyMetrics) && (dwStyle & WS_THICKFRAME)
  1188. && !(((dwStyle & (WS_CAPTION | WS_MAXIMIZE)) == (WS_CAPTION | WS_MAXIMIZE) && ((dwStyle & WS_CHILD) == 0))))
  1189. {
  1190. CRect rcBorders = pSkinManager->GetSchema()->CalcFrameBorders(dwStyle, dwExStyle);
  1191. lpRect->top -= rcBorders.top;
  1192. lpRect->left -= rcBorders.left;
  1193. lpRect->right += rcBorders.right;
  1194. lpRect->bottom += rcBorders.bottom;
  1196. return TRUE;
  1197. }
  1199. BOOL bResult =((LPFNADJUSTWINDOWRECTEX)pfnOrig)(lpRect, dwStyle, bMenu, dwExStyle);
  1201. if (bResult && ((dwStyle & WS_CAPTION) == WS_CAPTION) &&
  1202. lpRect && (pSkinManager->GetApplyOptions() & xtpSkinApplyMetrics))
  1203. {
  1204. BOOL bSmallCaption = dwExStyle & WS_EX_TOOLWINDOW;
  1205. CXTPSkinManagerMetrics* pMetrics = pSkinManager->GetMetrics();
  1206. int cyCaption = bSmallCaption ? pMetrics->m_cySmallCaption : pMetrics->m_cyCaption;
  1207. int cyOsCaption = bSmallCaption ? pMetrics->m_cyOsSmallCaption : pMetrics->m_cyOsCaption;
  1208. lpRect->top -= cyCaption - cyOsCaption;
  1209. }
  1211. return bResult;
  1212. }
  1214. int WINAPI CXTPSkinManagerApiHook::OnHookFillRect(HDC hDC, CONST RECT *lprc, HBRUSH hbr)
  1215. {
  1216. typedef int (WINAPI* LPFNFILLRECT)(HDC hDC, CONST RECT *lprc, HBRUSH hbr);
  1218. PROC pfnOrig = GetOriginalProc(xtpSkinApiFillRect);
  1219. if (!pfnOrig)
  1220. return ::FillRect(hDC, lprc, hbr);
  1222. if ((DWORD_PTR)hbr > 0 && (DWORD_PTR)hbr < XTP_SKINMETRICS_COLORTABLESIZE)
  1223. {
  1224. hbr = XTPSkinManager()->GetMetrics()->m_brTheme[(DWORD_PTR)hbr - 1];
  1225. }
  1227. if (pfnOrig)
  1228. {
  1229. return ((LPFNFILLRECT)pfnOrig)(hDC, lprc, hbr);
  1230. }
  1232. return 0;
  1233. }
  1235. BOOL WINAPI CXTPSkinManagerApiHook::OnHookDrawEdge(HDC hdc, LPRECT lprc, UINT edge, UINT flags)
  1236. {
  1237. PROC pfnOrig = GetOriginalProc(xtpSkinApiDrawEdge);
  1238. if (!pfnOrig)
  1239. return DrawEdge(hdc, lprc, edge, flags);
  1241. return XTRSkinFrameworkDrawEdge(hdc, lprc, edge, flags);
  1242. }
  1244. BOOL WINAPI CXTPSkinManagerApiHook::OnHookDrawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT uState)
  1245. {
  1246. typedef BOOL (WINAPI* LPFNDRAWFRAMECONTROL)(HDC, LPRECT, UINT, UINT);
  1248. PROC pfnOrig = GetOriginalProc(xtpSkinApiDrawFrameControl);
  1249. if (!pfnOrig)
  1250. return DrawFrameControl(hdc, lprc, uType, uState);
  1252. if (XTRSkinFrameworkDrawFrameControl(hdc, lprc, uType, uState))
  1253. return TRUE;
  1255. return ((LPFNDRAWFRAMECONTROL)pfnOrig)(hdc, lprc, uType, uState);
  1256. }
  1259. void CXTPSkinManagerApiHook::HackModuleOnLoad(HMODULE hmod, DWORD dwFlags)
  1260. {
  1261. for (int i = 0; i < (int)m_arrExcludedModules.GetSize(); i++)
  1262. {
  1263. EXCLUDEDMODULE& em = m_arrExcludedModules[i];
  1264. if (em.hModule == NULL) em.hModule = GetModuleHandle(em.strModule);
  1265. }
  1267. if (IsModuleExcluded(hmod))
  1268. return;
  1270. if ((hmod != NULL) && ((dwFlags & LOAD_LIBRARY_AS_DATAFILE) == 0))
  1271. {
  1272. for (int i = 0; i < XTP_SKIN_APIHOOKCOUNT; i++)
  1273. {
  1274. CXTPSkinManagerApiFunction* pHook = m_arrFunctions[i];
  1276. if (pHook)
  1277. {
  1278. if (pHook->ReplaceInOneModule(pHook->m_szCalleeModName, pHook->m_pfnOrig, pHook->m_pfnHook, hmod))
  1279. {
  1280. pHook->m_bHooked = TRUE;
  1281. }
  1282. }
  1283. }
  1284. }
  1285. }
  1287. HMODULE WINAPI CXTPSkinManagerApiHook::OnHookLoadLibraryA(LPCSTR pszModuleName)
  1288. {
  1289. typedef HMODULE (WINAPI* LPFNLOADLIBRARYA)(LPCSTR pszModuleName);
  1291. PROC pfnOrig = GetOriginalProc(xtpSkinApiLoadLibraryA);
  1292. if (!pfnOrig)
  1293. return ::LoadLibraryA(pszModuleName);
  1295. HMODULE hmod = ((LPFNLOADLIBRARYA)pfnOrig)(pszModuleName);
  1297. GetInstance()->HackModuleOnLoad(hmod, 0);
  1299. return hmod;
  1300. }
  1302. HMODULE WINAPI CXTPSkinManagerApiHook::OnHookLoadLibraryW(PCWSTR pszModuleName)
  1303. {
  1304. typedef HMODULE (WINAPI* LPFNLOADLIBRARYW)(PCWSTR pszModuleName);
  1306. PROC pfnOrig = GetOriginalProc(xtpSkinApiLoadLibraryW);
  1307. if (!pfnOrig)
  1308. return ::LoadLibraryW(pszModuleName);
  1310. HMODULE hmod = ((LPFNLOADLIBRARYW)pfnOrig)(pszModuleName);
  1312. GetInstance()->HackModuleOnLoad(hmod, 0);
  1314. return hmod;
  1315. }
  1317. HMODULE WINAPI CXTPSkinManagerApiHook::OnHookLoadLibraryExA(LPCSTR  pszModuleName, HANDLE hFile, DWORD dwFlags)
  1318. {
  1319. typedef HMODULE (WINAPI* LPFNLOADLIBRARYEXA)(LPCSTR pszModuleName, HANDLE hFile, DWORD dwFlags);
  1321. PROC pfnOrig = GetOriginalProc(xtpSkinApiLoadLibraryExA);
  1322. if (!pfnOrig)
  1323. return ::LoadLibraryExA(pszModuleName, hFile, dwFlags);
  1325. HMODULE hmod = ((LPFNLOADLIBRARYEXA)pfnOrig)(pszModuleName, hFile, dwFlags);
  1328. GetInstance()->HackModuleOnLoad(hmod, 0);
  1330. return hmod;
  1331. }
  1333. HMODULE WINAPI CXTPSkinManagerApiHook::OnHookLoadLibraryExW(PCWSTR pszModuleName, HANDLE hFile, DWORD dwFlags)
  1334. {
  1335. typedef HMODULE (WINAPI* LPFNLOADLIBRARYEXW)(PCWSTR pszModuleName, HANDLE hFile, DWORD dwFlags);
  1337. PROC pfnOrig = GetOriginalProc(xtpSkinApiLoadLibraryExW);
  1338. if (!pfnOrig)
  1339. return ::LoadLibraryExW(pszModuleName, hFile, dwFlags);
  1341. HMODULE hmod = ((LPFNLOADLIBRARYEXW)pfnOrig)(pszModuleName, hFile, dwFlags);
  1343. GetInstance()->HackModuleOnLoad(hmod, dwFlags);
  1345. return hmod;
  1346. }
  1348. HMODULE WINAPI CXTPSkinManagerApiHook::OnHookGetModuleHandleA(LPCSTR lpModuleName)
  1349. {
  1350. if (lpModuleName && XTPCompareStringNoCase(lpModuleName, "UxTheme.dll") == 0)
  1351. if (XTPSkinManager()->GetApplyOptions() & xtpSkinApplyColors)
  1352. return XTP_UXTHEME_HANDLE;
  1354. typedef HMODULE (WINAPI* LPFNGETMODULEHANDLEA)(LPCSTR lpModuleName);
  1356. PROC pfnOrig = GetOriginalProc(xtpSkinApiGetModuleHandleA);
  1358. if (pfnOrig)
  1359. return ((LPFNGETMODULEHANDLEA)pfnOrig)(lpModuleName);
  1361. return ::GetModuleHandleA(lpModuleName);
  1362. }
  1364. FARPROC WINAPI CXTPSkinManagerApiHook::OnHookGetProcAddress(HMODULE hmod, PCSTR pszProcName)
  1365. {
  1366. if ((DWORD_PTR)pszProcName < 0xFFFF)
  1367. return GetProcAddressWindows(hmod, pszProcName);
  1369. CXTPSkinManagerApiFunction* pFuncHook = NULL;
  1370. if (hmod == XTP_UXTHEME_HANDLE)
  1371. {
  1372. pFuncHook = GetInstance()->GetHookedFunction("UXTHEME.DLL", pszProcName);
  1373. }
  1374. else
  1375. {
  1376. char szFullFileName[MAX_PATH];
  1377. ::GetModuleFileNameA(hmod, szFullFileName, MAX_PATH);
  1378. // We must extract only the name and the extension
  1380. char* szFileName = strrchr(szFullFileName, '\');
  1381. if (szFileName == NULL)
  1382. szFileName = szFullFileName;
  1383. else
  1384. szFileName = szFileName + 1;
  1386. if (XTPCompareStringNoCase(szFileName, "UxTheme.dll") == 0)
  1387. return GetProcAddressWindows(hmod, pszProcName);
  1389. pFuncHook = GetInstance()->GetHookedFunction(szFileName, pszProcName);
  1390. }
  1393. if (pFuncHook)
  1394. return pFuncHook->m_pfnHook;
  1396. return GetProcAddressWindows(hmod, pszProcName);
  1397. }
  1401. HTHEME STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookOpenThemeData(HWND /*hWnd*/, LPCWSTR pszClassList)
  1402. {
  1403. CXTPSkinManager* pManager = XTPSkinManager();
  1405. if (!pManager->IsEnabled())
  1406. return 0;
  1408. CXTPSkinManagerClass* pClass = pManager->GetSkinClass(CString(pszClassList));
  1409. return (HTHEME)pClass;
  1410. }
  1412. HRESULT STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookDrawThemeBackground(HTHEME hTheme, HDC hDC, int iPartId, int iStateId, const RECT* pRect, const RECT* pClipRect)
  1413. {
  1414. if (!hTheme)
  1415. return E_FAIL;
  1417. CXTPSkinManagerClass* pClass = XTPSkinManager()->FromHandle(hTheme);
  1418. if (!pClass)
  1419. return E_FAIL;
  1421. HRGN hrgnClip = 0;
  1423. if (pClipRect && pRect && !EqualRect(pClipRect, pRect))
  1424. {
  1425. hrgnClip = CreateRectRgn(0, 0, 0, 0);
  1426. if (hrgnClip != NULL)
  1427. {
  1428. if (GetClipRgn(hDC, hrgnClip) != 1)
  1429. {
  1430. DeleteObject(hrgnClip);
  1431. hrgnClip = (HRGN)-1;
  1432. }
  1433. ::IntersectClipRect(hDC, pClipRect->left, pClipRect->top, pClipRect->right, pClipRect->bottom);
  1434. }
  1435. }
  1438. HRESULT hResult = S_OK;
  1439. if (!pClass->DrawThemeBackground(CDC::FromHandle(hDC), iPartId, iStateId, pRect))
  1440. hResult = E_FAIL;
  1442. if (hrgnClip != NULL)
  1443. {
  1444. if (hrgnClip == (HRGN)-1)
  1445. {
  1446. ExtSelectClipRgn(hDC, NULL, RGN_COPY);
  1447. }
  1448. else
  1449. {
  1450. ExtSelectClipRgn(hDC, hrgnClip, RGN_COPY);
  1451. DeleteObject(hrgnClip);
  1452. }
  1453. }
  1456. return hResult;
  1457. }
  1460. HRESULT STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookCloseThemeData(HTHEME)
  1461. {
  1462. return S_OK;
  1463. }
  1465. HRESULT STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookGetThemeColor(HTHEME hTheme, int iPartId, int iStateId, int iPropID, COLORREF *pColor)
  1466. {
  1467. if (!hTheme)
  1468. return E_FAIL;
  1470. CXTPSkinManagerClass* pClass = XTPSkinManager()->FromHandle(hTheme);
  1471. if (!pClass)
  1472. return E_FAIL;
  1474. COLORREF clr = pClass->GetThemeColor(iPartId, iStateId, iPropID);
  1476. if (clr == COLORREF_NULL)
  1477. return E_FAIL;
  1479. *pColor = clr;
  1480. return S_OK;
  1481. }
  1483. BOOL STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookIsThemeActive()
  1484. {
  1485. return TRUE;
  1486. }
  1488. BOOL STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookIsAppThemed()
  1489. {
  1490. return TRUE;
  1491. }
  1493. HRESULT STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookGetThemePartSize(HTHEME hTheme, HDC, int iPartId, int iStateId, RECT *pRect, THEMESIZE eSize, SIZE* pSize)
  1494. {
  1495. if (!hTheme)
  1496. return E_FAIL;
  1498. CXTPSkinManagerClass* pClass = XTPSkinManager()->FromHandle(hTheme);
  1499. if (!pClass)
  1500. return E_FAIL;
  1502. if (!pClass->GetThemePartSize(iPartId, iStateId, pRect, eSize, pSize))
  1503. return E_FAIL;
  1505. return S_OK;
  1506. }
  1509. BOOL STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookGetThemeSysBool(HTHEME /*hTheme*/, int iBoolId)
  1510. {
  1511. return XTPSkinManager()->GetThemeSysBool(iBoolId);
  1512. }
  1514. COLORREF STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookGetThemeSysColor(HTHEME /*hTheme*/, int iColorId)
  1515. {
  1516. return XTPSkinManager()->GetThemeSysColor(iColorId);
  1517. }
  1520. HRESULT STDAPICALLTYPE CXTPSkinManagerApiHook::OnHookGetCurrentThemeName(LPWSTR pszThemeFileName, int dwMaxNameChars, LPWSTR pszColorBuff, int cchMaxColorChars, LPWSTR /*pszSizeBuff*/, int /*cchMaxSizeChars*/)
  1521. {
  1522. CXTPSkinManager* pManager = XTPSkinManager();
  1524. if (!pManager->GetResourceFile())
  1525. return E_FAIL;
  1527. if (pszThemeFileName)
  1528. {
  1529. CString strThemeFileName = pManager->GetResourceFile()->GetResourcePath();
  1530. int nLength = strThemeFileName.GetLength();
  1532. if (nLength < dwMaxNameChars)
  1533. {
  1534. MBSTOWCS_S(pszThemeFileName, strThemeFileName, nLength + 1);
  1535. }
  1536. }
  1538. if (pszColorBuff)
  1539. {
  1540. CString strColorBuff = pManager->GetResourceFile()->GetIniFileName();
  1541. strColorBuff.MakeUpper();
  1543. if (strColorBuff.Find(_T("METALLIC")) > 0) strColorBuff = _T("metallic");
  1544. if (strColorBuff.Find(_T("BLUE"))  > 0) strColorBuff = _T("normalcolor");
  1545. if (strColorBuff.Find(_T("HOMESTEAD"))  > 0) strColorBuff = _T("homestead");
  1548. int nLength = strColorBuff.GetLength();
  1550. if (nLength < cchMaxColorChars)
  1551. {
  1552. MBSTOWCS_S(pszColorBuff, strColorBuff, nLength + 1);
  1553. }
  1555. }
  1556. return S_OK;
  1557. }