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

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

对话框与窗口

开发平台：

Visual C++

XTPSkinObject.cpp：源码内容
  1. // XTPSkinObject.cpp: implementation of the CXTPSkinObject 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/XTPVc50Helpers.h"
  24. #include "XTPSkinManager.h"
  25. #include "XTPSkinManagerApiHook.h"
  26. #include "XTPSkinObject.h"
  28. #include "XTPSkinObjectFrame.h"
  29. #include "XTPSkinObjectButton.h"
  30. #include "XTPSkinObjectEdit.h"
  31. #include "XTPSkinObjectComboBox.h"
  32. #include "XTPSkinObjectListView.h"
  33. #include "XTPSkinObjectListBox.h"
  34. #include "XTPSkinObjectTreeView.h"
  35. #include "XTPSkinObjectScrollBar.h"
  36. #include "XTPSkinObjectTab.h"
  37. #include "XTPSkinObjectToolBar.h"
  38. #include "XTPSkinObjectProgress.h"
  39. #include "XTPSkinObjectSpin.h"
  40. #include "XTPSkinObjectHeader.h"
  41. #include "XTPSkinObjectTrackBar.h"
  42. #include "XTPSkinObjectStatusBar.h"
  43. #include "XTPSkinObjectMDI.h"
  44. #include "XTPSkinObjectMenu.h"
  46. #ifdef _DEBUG
  47. #undef THIS_FILE
  48. static char THIS_FILE[]=__FILE__;
  49. #define new DEBUG_NEW
  50. #endif
  53. CXTPSkinObjectPaintDC::CXTPSkinObjectPaintDC(CWnd* pWnd)
  54. {
  55. ASSERT_VALID(pWnd);
  56. ASSERT(::IsWindow(pWnd->m_hWnd));
  58. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  60. m_ps.hdc = 0;
  61. m_hWnd = pWnd->m_hWnd;
  63. if (curMsg.wParam)
  64. {
  65. Attach((HDC)curMsg.wParam);
  66. }
  67. else
  68. {
  69. if (!Attach(::BeginPaint(m_hWnd, &m_ps)))
  70. AfxThrowResourceException();
  72. ASSERT(m_ps.hdc != NULL);
  73. }
  74. }
  76. CXTPSkinObjectPaintDC::~CXTPSkinObjectPaintDC()
  77. {
  78. ASSERT(m_hDC != NULL);
  79. ASSERT(::IsWindow(m_hWnd));
  81. if (m_ps.hdc != NULL)
  82. {
  83. ::EndPaint(m_hWnd, &m_ps);
  84. }
  85. Detach();
  86. }
  87. //////////////////////////////////////////////////////////////////////////
  88. //
  90. UINT CXTPSkinObject::m_nMsgUpdateSkinState = RegisterWindowMessage(_T("WM_SKINFRAMEWORK_UPDATESTATE"));
  91. UINT CXTPSkinObject::m_nMsgQuerySkinState = RegisterWindowMessage(_T("WM_SKINFRAMEWORK_QUERYSTATE"));
  94. CXTPSkinObject::CXTPSkinObject()
  95. {
  96. m_hWnd = 0;
  97. m_pManager = NULL;
  98. m_pOldWndProc = NULL;
  100. m_wndDefProcAddr = (WNDPROC)(DWORD_PTR)0x70000000;
  101. m_bActiveX = FALSE;
  102. m_bWindowsForms = FALSE;
  104. m_bCustomDraw = FALSE;
  105. m_bUnicode = FALSE;
  106. }
  108. CXTPSkinObject::~CXTPSkinObject()
  109. {
  110. m_hWnd = 0;
  111. }
  113. #if (_MSC_VER <= 1200) && !defined(_WIN64)
  114. #define GetWindowLongPtrW GetWindowLongW
  115. #define GetWindowLongPtrA GetWindowLongA
  116. #define SetWindowLongPtrW SetWindowLongW
  117. #define SetWindowLongPtrA SetWindowLongA
  118. #endif
  120. void CXTPSkinObject::UnattachHook(BOOL bAuto)
  121. {
  122. BOOL bWindowsForms = m_bWindowsForms;
  124. if (!bWindowsForms)
  125. {
  126. if (m_bUnicode)
  127. SetWindowLongPtrW(m_hWnd, GWLP_WNDPROC, (DWORD_PTR)m_pOldWndProc);
  128. else
  129. SetWindowLongPtrA(m_hWnd, GWLP_WNDPROC, (DWORD_PTR)m_pOldWndProc);
  130. }
  132. OnHookDetached(bAuto);
  133. }
  136. void CXTPSkinObject::OnFinalRelease()
  137. {
  138. delete this;
  139. }
  141. WNDPROC* CXTPSkinObject::GetSuperWndProcAddr()
  142. {
  143. return &m_pOldWndProc;
  144. }
  146. LRESULT CXTPSkinObject::DoDefWindowProc (UINT nMsg, WPARAM wParam, LPARAM lParam)
  147. {
  148. OnBeginHook(nMsg, xtpSkinDefaultHookMessage, 0, 0);
  149. LRESULT lResult = DefWindowProc(nMsg, wParam, lParam);
  150. OnEndHook();
  152. return lResult;
  153. }
  155. LRESULT CXTPSkinObject::DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  156. {
  157. if (m_arrDescriptors.IsEmpty())
  158. return ::CallWindowProc(m_pOldWndProc, m_hWnd, nMsg, wParam, lParam);
  160. DEFWINDOW_DESCRIPTIOR& des = m_arrDescriptors.GetHead();
  162. if (des.defProc == xtpSkinDefaultHookMessage)
  163. return ::CallWindowProc(m_pOldWndProc, m_hWnd, nMsg, wParam, lParam);
  165. if (des.defProc == xtpSkinDefaultCallWindowProc)
  166. {
  167. ASSERT(des.lpPrev);
  168. ASSERT(des.defProcAddr);
  170. typedef LRESULT (WINAPI* LPFNCALLWINDOWPROC)(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  171. return ((LPFNCALLWINDOWPROC)des.defProcAddr)((WNDPROC)des.lpPrev, m_hWnd, nMsg, wParam, lParam);
  172. }
  174. if (des.defProc == xtpSkinDefaultDefWindowProc || des.defProc == xtpSkinDefaultDefMDIChildProc || des.defProc == xtpSkinDefaultDefDlgProc)
  175. {
  176. ASSERT(des.defProcAddr);
  178. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  179. return ((LPFNDEFWINDOWPROC)des.defProcAddr)(m_hWnd, nMsg, wParam, lParam);
  180. }
  182. if (des.defProc == xtpSkinDefaultDefFrameProc)
  183. {
  184. ASSERT(des.defProcAddr);
  186. typedef LRESULT (WINAPI* LPFNDEFWINDOWPROC)(HWND hWnd, HWND hWndMDIClient, UINT Msg, WPARAM wParam, LPARAM lParam);
  187. return ((LPFNDEFWINDOWPROC)des.defProcAddr)(m_hWnd, (HWND)des.lpPrev, nMsg, wParam, lParam);
  188. }
  190. return 0;
  191. }
  193. void CXTPSkinObject::AttachHook(HWND hWnd, LPCREATESTRUCT lpcs, BOOL bAuto)
  194. {
  195. m_hWnd = hWnd;
  196. m_bUnicode = IsWindowUnicode(hWnd);
  198. BOOL bWindowsForms = m_bWindowsForms;
  200. if (m_bUnicode)
  201. {
  202. m_pOldWndProc = (WNDPROC)GetWindowLongPtrW(hWnd, GWLP_WNDPROC);
  203. if (!bWindowsForms) SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (DWORD_PTR)CXTPSkinManager::HookWndProc);
  204. }
  205. else
  206. {
  207. m_pOldWndProc = (WNDPROC)GetWindowLongPtrA(hWnd, GWLP_WNDPROC);
  208. if (!bWindowsForms) SetWindowLongPtrA(hWnd, GWLP_WNDPROC, (DWORD_PTR)CXTPSkinManager::HookWndProc);
  209. }
  212. if (CXTPSkinManagerApiHook::IsSystemWindowModule(m_pOldWndProc))
  213. {
  214. m_wndDefProcAddr = 0;
  215. }
  217. OnHookAttached(lpcs, bAuto);
  218. }
  220. CXTPSkinManagerClass* CXTPSkinObject::GetSkinClass() const
  221. {
  222. return GetSkinManager()->GetSkinClass(m_strClassName);
  223. }
  225. CXTPSkinManagerMetrics* CXTPSkinObject::GetMetrics() const
  226. {
  227. return GetSkinManager()->GetMetrics();
  228. }
  230. COLORREF CXTPSkinObject::GetColor(int nIndex) const
  231. {
  232. return GetMetrics()->GetColor(nIndex);
  233. }
  236. void CXTPSkinObject::OnSkinChanged(BOOL /*bPrevState*/, BOOL /*bNewState*/)
  237. {
  238. RefreshMetrics();
  239. }
  241. void CXTPSkinObject::OnHookAttached(LPCREATESTRUCT /*lpcs*/, BOOL /*bAuto*/)
  242. {
  243. m_bCustomDraw = CWnd::FromHandlePermanent(m_hWnd) ? SendMessage(m_nMsgQuerySkinState) != 0 : FALSE;
  245. RefreshMetrics();
  246. }
  248. void CXTPSkinObject::OnHookDetached(BOOL /*bAuto*/)
  249. {
  251. }
  253. void CXTPSkinObject::RefreshMetrics()
  254. {
  256. }
  258. BOOL CXTPSkinObject::IsDefWindowProcAvail(int nMessage) const
  259. {
  260. if (nMessage == WM_TIMER)
  261. return FALSE;
  264. if (m_wndDefProcAddr == 0)
  265. return FALSE;
  267. if (!m_pManager->IsWin9x())
  268. return TRUE;
  270. return ((DWORD_PTR)m_pOldWndProc < (DWORD_PTR)m_wndDefProcAddr) || (m_pOldWndProc == CXTPSkinManagerApiFunction::sm_pfnAfxWndProc);
  271. }
  273. BOOL CXTPSkinObject::PreHookMessage(UINT nMessage)
  274. {
  275. if (nMessage == WM_SETCURSOR || nMessage == WM_NOTIFY|| nMessage == WM_COMMAND || nMessage == WM_ACTIVATE)
  276. return TRUE;
  278. if (nMessage == m_nMsgUpdateSkinState)
  279. {
  280. m_bCustomDraw = SendMessage(m_nMsgQuerySkinState) != 0;
  281. }
  283. return FALSE;
  284. }
  286. BOOL CXTPSkinObject::OnHookDefWindowProc(UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  287. {
  288. if (PreHookMessage(nMessage))
  289. return FALSE;
  291. if (nMessage == m_nMsgQuerySkinState)
  292. {
  293. lResult = 0;
  294. return TRUE;
  295. }
  297. if (OnWndMsg(nMessage, wParam, lParam, &lResult))
  298. {
  299. return TRUE;
  300. }
  302. return FALSE;
  303. }
  305. BOOL CXTPSkinObject::OnHookMessage(UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  306. {
  307. if (PreHookMessage(nMessage))
  308. return FALSE;
  310. if (IsDefWindowProcAvail(nMessage))
  311. return FALSE;
  313. if (OnWndMsg(nMessage, wParam, lParam, &lResult))
  314. {
  315. return TRUE;
  316. }
  318. return FALSE;
  319. }
  321. //////////////////////////////////////////////////////////////////////
  322. // CXTPSkinManager
  324. void CXTPSkinManager::ApplyWindow(HWND hWnd)
  325. {
  326. if (Lookup(hWnd))
  327. return;
  329. TCHAR lpszClassName[50];
  330. GetClassName(hWnd, lpszClassName, 50);
  332. CREATESTRUCT cs;
  333. ZeroMemory(&cs, sizeof(cs));
  335. cs.dwExStyle = (DWORD)GetWindowLongPtr(hWnd, GWL_EXSTYLE);
  336. cs.style = (LONG)GetWindowLongPtr(hWnd, GWL_STYLE);
  337. cs.hwndParent = ::GetParent(hWnd);
  338. cs.lpszClass = lpszClassName;
  340. CXTPSkinObject* pSkinObject = SetHook(hWnd, lpszClassName, &cs, FALSE);
  342. if (pSkinObject)
  343. {
  344. pSkinObject->OnSkinChanged(FALSE, m_bEnabled);
  345. }
  347. hWnd = ::GetWindow(hWnd, GW_CHILD);
  348. while (hWnd)
  349. {
  350. ApplyWindow(hWnd);
  352. hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  353. }
  354. }
  357. BOOL CALLBACK CXTPSkinManager::EnumWindowsProcNetBroadcast(HWND hWnd, LPARAM /*lParam*/)
  358. {
  359. DWORD dwProcessId = 0;
  360. if (GetWindowThreadProcessId(hWnd, &dwProcessId) && dwProcessId == GetCurrentProcessId())
  361. {
  362. ::PostMessage(hWnd, WM_SYSCOLORCHANGE, 0, 0);
  363. }
  365. return TRUE;
  366. }
  368. void CXTPSkinManager::OnSkinChanged(BOOL bPrevState, BOOL bNewState)
  369. {
  370. HWND hWnd;
  371. POSITION pos = m_mapObjects.GetStartPosition();
  372. CXTPSkinObject* pSink;
  374. EnumWindows(EnumWindowsProcNetBroadcast, 0);
  376. while (pos)
  377. {
  378. m_mapObjects.GetNextAssoc(pos, hWnd, pSink);
  380. if (::IsWindow(hWnd))
  381. {
  382. pSink->OnSkinChanged(bPrevState, bNewState);
  383. }
  384. else
  385. {
  386. Remove(hWnd);
  387. }
  388. }
  389. }
  391. CXTPSkinObject* CXTPSkinManager::Lookup(HWND hWnd)
  392. {
  393. CXTPLockGuard lock(m_csObjects);
  395. CXTPSkinObject* pSink;
  397. if (m_mapObjects.Lookup(hWnd, pSink))
  398. return pSink;
  400. return NULL;
  401. }
  403. #ifndef OBJID_WINDOW
  404. #define OBJID_WINDOW 0x00000000
  405. #endif
  407. #ifndef EVENT_OBJECT_REORDER
  408. #define EVENT_OBJECT_REORDER 0x8004
  409. #endif
  411. void CALLBACK CXTPSkinManager::WinEventProc(HWINEVENTHOOK /*hWinEventHook*/,
  412. DWORD event, HWND hWnd, LONG idObject, LONG /*idChild*/, DWORD /*dwEventThread*/, DWORD /*dwmsEventTime*/)
  413. {
  414. if (event == EVENT_OBJECT_REORDER && idObject == OBJID_WINDOW && (XTPSkinManager()->GetApplyOptions() & xtpSkinApplyFrame)
  415. && XTPSkinManager()->IsEnabled())
  416. {
  417. CXTPSkinObjectFrame* pFrame = (CXTPSkinObjectFrame*)XTPSkinManager()->Lookup(hWnd);
  419. if (pFrame)
  420. {
  421. DWORD dwStyle = pFrame->GetStyle();
  422. DWORD dwStyleRemove = (WS_CAPTION | WS_VSCROLL | WS_HSCROLL);
  424. if (dwStyle & dwStyleRemove)
  425. {
  426. pFrame->SetTimer(XTP_TID_REFRESHFRAME, 1000, NULL);
  427. }
  428. }
  429. }
  431. return;
  432. }
  434. BOOL CXTPSkinObject::IsSkinEnabled() const
  435. {
  436. return !m_bCustomDraw && m_hWnd && m_pManager->IsEnabled();
  437. }
  439. #define PSH_WIZARD97IE4            0x00002000
  440. #define PSH_WIZARD97IE5            0x01000000
  442. #ifndef DWLP_USER
  443. #define DWLP_USER 8
  444. #endif
  446. AFX_INLINE BOOL IsTabPage(LPCREATESTRUCT lpcs)
  447. {
  448. if (!lpcs || !lpcs->hwndParent)
  449. return FALSE;
  451. if (!((lpcs->style & DS_CONTROL) && (lpcs->style & WS_CHILD)))
  452. return FALSE;
  454. CXTPSkinObjectFrame* pParent = (CXTPSkinObjectFrame*)XTPSkinManager()->Lookup(lpcs->hwndParent);
  455. if (pParent && pParent->m_dwDialogTexture == ETDT_ENABLETAB)
  456. return TRUE;
  458. HWND hwndTabControl = (HWND)::SendMessage(lpcs->hwndParent, PSM_GETTABCONTROL, 0, 0);
  459. if (!hwndTabControl || !::IsWindow(hwndTabControl))
  460. return FALSE;
  462. HWND* ppd = (HWND*)GetWindowLongPtr(lpcs->hwndParent, DWLP_USER);
  463. if (!ppd || *ppd != lpcs->hwndParent)
  464. return FALSE;
  466. PROPSHEETHEADER* psh = (PROPSHEETHEADER*)(ppd + 1);
  467. if (!psh)
  468. return FALSE;
  470. if ((psh->dwFlags & (PSH_WIZARD | PSH_WIZARD97IE4 | PSH_WIZARD97IE5)) != 0)
  471. return FALSE;
  473. return TRUE;
  474. }
  476. CXTPSkinObject* CXTPSkinManager::SetHook(HWND hWnd, LPCTSTR lpszClassName, LPCREATESTRUCT lpcs, BOOL bAuto)
  477. {
  478. if (_tcscmp(lpszClassName, _T("tooltips_class32")) == 0)
  479. return NULL;
  481. if (_tcsicmp(lpszClassName, _T("IME")) == 0)
  482. return NULL;
  484. CXTPSkinObject* pSink = NULL;
  486. if (pSink == NULL && _tcsstr(lpszClassName, _T("WindowsForms")) != NULL)
  487. {
  489. CString strClass(lpszClassName);
  490. int nClassNameStart = strClass.Find(_T('.'));
  491. int nClassNameEnd = FIND_S(strClass, _T('.'), nClassNameStart + 1);
  493. if (nClassNameStart != -1 && nClassNameEnd != -1 && nClassNameEnd != nClassNameStart)
  494. {
  495. strClass = strClass.Mid(nClassNameStart + 1, nClassNameEnd - nClassNameStart - 1);
  497. CXTPSkinObjectClassInfo* pInfo = m_pClassMap->Lookup(strClass);
  499. if (pInfo)
  500. {
  501. pSink = pInfo->CreateObject(lpszClassName, lpcs);
  502. }
  503. }
  505. if (pSink == NULL)
  506. {
  507. pSink = new CXTPSkinObjectFrame();
  508. }
  510. pSink->m_bWindowsForms = TRUE;
  511. }
  513. if (pSink == NULL)
  514. {
  515. CXTPSkinObjectClassInfo* pInfo = m_pClassMap->Lookup(lpszClassName);
  517. if (pInfo)
  518. {
  519. pSink = pInfo->CreateObject(lpszClassName, lpcs);
  520. }
  521. else
  522. {
  523. if (_tcsstr(lpszClassName, _T("Internet Explorer")) != NULL)
  524. return NULL;
  526. if (_tcsstr(lpszClassName, _T("OleMainThread")) != NULL)
  527. return NULL;
  529. pSink = new CXTPSkinObjectFrame();
  530. }
  531. }
  533. if (pSink && _tcscmp(lpszClassName, _T("#32770")) == 0)
  534. {
  535. ((CXTPSkinObjectFrame*)pSink)->m_dwDialogTexture = IsTabPage(lpcs) ? ETDT_ENABLETAB : ETDT_ENABLE;
  536. }
  538. if (pSink)
  539. {
  541. pSink->m_pManager = this;
  542. {
  543. CXTPLockGuard lock(m_csObjects);
  544. m_mapObjects[hWnd] = pSink;
  545. }
  547. pSink->AttachHook(hWnd, lpcs, bAuto);
  548. }
  550. return pSink;
  551. }
  553. void CXTPSkinManager::Remove(HWND hWnd)
  554. {
  555. Remove(hWnd, FALSE);
  556. }
  558. void CXTPSkinManager::Remove(HWND hWnd, BOOL bAuto)
  559. {
  560. CXTPSkinObject* pSink = Lookup(hWnd);
  561. if (pSink)
  562. {
  563. {
  564. CXTPLockGuard lock(m_csObjects);
  565. m_mapObjects.RemoveKey(hWnd);
  566. }
  567. pSink->UnattachHook(bAuto);
  569. #ifdef _AFXDLL
  570. pSink->m_pModuleState = AfxGetModuleState();
  571. #endif
  572. pSink->InternalRelease();
  573. }
  574. }
  576. void CXTPSkinManager::RemoveAll(BOOL bUnattach)
  577. {
  578. CXTPLockGuard lock(m_csObjects);
  581. HWND hWnd;
  582. POSITION pos = m_mapObjects.GetStartPosition();
  583. CXTPSkinObject* pSink;
  585. while (pos)
  586. {
  587. m_mapObjects.GetNextAssoc(pos, hWnd, pSink);
  588. if (bUnattach) pSink->UnattachHook(FALSE);
  590. #ifdef _AFXDLL
  591. pSink->m_pModuleState = AfxGetModuleState();
  592. #endif
  593. pSink->InternalRelease();
  594. }
  595. m_mapObjects.RemoveAll();
  596. }
  598. void CXTPSkinObject::OnBeginHook(UINT nMessage, XTPSkinDefaultProc defProc, PROC defProcAddr, LPVOID defProcPrevWndFunc)
  599. {
  600. InternalAddRef();
  601. CXTPLockGuard lock(m_csDescriptors);
  603. DEFWINDOW_DESCRIPTIOR des;
  605. des.defProc = defProc;
  606. des.nMessage = nMessage;
  607. des.defProcAddr = defProcAddr;
  608. des.lpPrev = defProcPrevWndFunc;
  610. m_arrDescriptors.AddHead(des);
  611. }
  613. void CXTPSkinObject::OnEndHook()
  614. {
  615. {
  616. CXTPLockGuard lock(m_csDescriptors);
  617. m_arrDescriptors.RemoveHead();
  618. }
  619. InternalRelease();
  620. }
  622. UINT CXTPSkinObject::GetHeadMessage()
  623. {
  624. CXTPLockGuard lock(m_csDescriptors);
  626. if (!m_arrDescriptors.IsEmpty())
  627. {
  628. return m_arrDescriptors.GetHead().nMessage;
  629. }
  630. return WM_NULL;
  631. }
  633. LRESULT CALLBACK CXTPSkinManager::DoCallWindowProc(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  634. {
  635. return CXTPSkinManagerApiHook::CallWindowProcOrig(lpPrevWndFunc, hWnd, Msg, wParam, lParam);
  636. }
  638. LRESULT CALLBACK CXTPSkinManager::HookWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  639. {
  640. // Get hook object for this window. Get from hook map
  641. CXTPSkinObject* pSink = XTPSkinManager()->Lookup(hWnd);
  642. if (!pSink)
  643. return 0;
  645. LRESULT lResult = 0;
  646. WNDPROC wndProc = pSink->m_pOldWndProc;
  648. if (!pSink->GetSkinManager()->m_bEnabled)
  649. {
  650. if (message == WM_NCDESTROY)
  651. {
  652. pSink->GetSkinManager()->Remove(hWnd, TRUE);
  653. }
  655. return ::CallWindowProc(wndProc, hWnd, message, wParam, lParam);
  656. }
  659. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  660. MSG  oldMsg = curMsg;
  661. curMsg.hwnd = hWnd;
  662. curMsg.message = message;
  663. curMsg.wParam  = wParam;
  664. curMsg.lParam  = lParam;
  666. BOOL bCallWindowProc = TRUE;
  668. // Window is being destroyed: unhook all hooks (for this window)
  669. // and pass message to orginal window proc
  670. if (message == WM_NCDESTROY)
  671. {
  672. pSink->GetSkinManager()->Remove(hWnd, TRUE);
  673. }
  674. // pass to message hook
  675. else if (!pSink->m_bCustomDraw || message == CXTPSkinObject::m_nMsgUpdateSkinState)
  676. {
  677. pSink->OnBeginHook(message, xtpSkinDefaultHookMessage, 0, 0);
  679. if (pSink->OnHookMessage(message, wParam, lParam, lResult))
  680. {
  681. bCallWindowProc = FALSE;
  682. }
  684. pSink->OnEndHook();
  685. }
  687. if (bCallWindowProc)
  688. {
  689. lResult = DoCallWindowProc(wndProc, hWnd, message, wParam, lParam);
  690. }
  692. curMsg = oldMsg;
  693. return lResult;
  694. }
  696. //////////////////////////////////////////////////////////////////////////
  697. // CXTPSkinObjectClassInfo
  699. CXTPSkinObjectClassInfo::CXTPSkinObjectClassInfo(CRuntimeClass* pClass)
  700. {
  701. m_pMap = NULL;
  702. m_pClass = pClass;
  703. }
  705. CXTPSkinObject* CXTPSkinObjectClassInfo::CreateObject(LPCTSTR /*lpszClassName*/, LPCREATESTRUCT /*lpcs*/)
  706. {
  707. if (!m_pClass)
  708. return NULL;
  710. return (CXTPSkinObject*)m_pClass->CreateObject();
  711. }
  713. void CXTPSkinObjectClassInfo::AddClass(LPCTSTR lpszClassName)
  714. {
  715. m_pMap->AddClass(lpszClassName, this);
  716. }
  718. void CXTPSkinObjectClassInfo::Remove()
  719. {
  720. m_pMap->RemoveClass(this);
  721. }
  723. //////////////////////////////////////////////////////////////////////////
  724. // CXTPSkinObjectClassMap
  726. CXTPSkinObjectClassMap::CXTPSkinObjectClassMap()
  727. {
  729. }
  731. CXTPSkinObjectClassMap::~CXTPSkinObjectClassMap()
  732. {
  733. RemoveAll();
  734. }
  736. #define RUNTIME_CLASS_INFO(x) new CXTPSkinObjectClassInfo(RUNTIME_CLASS(x))
  737. #define RUNTIME_CLASS_INFOACTIVEX(x) new CXTPSkinObjectClassInfoActiveX(RUNTIME_CLASS(x), TRUE)
  738. #define RUNTIME_CLASS_INFOACTIVEX_DEF(x) new CXTPSkinObjectClassInfoActiveX(RUNTIME_CLASS(x), FALSE)
  740. void CXTPSkinObjectClassMap::AddStandardClasses()
  741. {
  742. AddClass(_T("ComboBox"), RUNTIME_CLASS_INFO(CXTPSkinObjectComboBox));
  744. AddClass(_T("Edit"), RUNTIME_CLASS_INFO(CXTPSkinObjectEdit));
  745. AddClass(_T("SysDateTimePick32"), RUNTIME_CLASS_INFO(CXTPSkinObjectDateTime));
  746. AddClass(_T("SysMonthCal32"), RUNTIME_CLASS_INFO(CXTPSkinObjectMonthCal));
  748. AddClass(_T("ListBox"), RUNTIME_CLASS_INFO(CXTPSkinObjectListBox));
  749. AddSynonymClass(_T("ComboLBox"), _T("ListBox"));
  751. AddClass(_T("ScrollBar"), RUNTIME_CLASS_INFO(CXTPSkinObjectScrollBar));
  752. AddSynonymClass(_T("ATL:ScrollBar"), _T("ScrollBar"));
  754. AddClass(_T("SysListView32"), RUNTIME_CLASS_INFO(CXTPSkinObjectListView));
  755. AddClass(_T("SysHeader32"), RUNTIME_CLASS_INFO(CXTPSkinObjectHeader));
  756. AddClass(_T("msctls_statusbar32"), RUNTIME_CLASS_INFO(CXTPSkinObjectStatusBar));
  757. AddClass(_T("SysTreeView32"), RUNTIME_CLASS_INFO(CXTPSkinObjectTreeView));
  758. AddClass(_T("msctls_progress32"), RUNTIME_CLASS_INFO(CXTPSkinObjectProgress));
  759. AddClass(_T("msctls_trackbar32"), RUNTIME_CLASS_INFO(CXTPSkinObjectTrackBar));
  760. AddClass(_T("SysTabControl32"), RUNTIME_CLASS_INFO(CXTPSkinObjectTab));
  761. AddClass(_T("MDIClient"), RUNTIME_CLASS_INFO(CXTPSkinObjectMDIClient));
  762. AddClass(_T("msctls_updown32"), RUNTIME_CLASS_INFO(CXTPSkinObjectSpin));
  763. AddClass(_T("ToolbarWindow32"), RUNTIME_CLASS_INFO(CXTPSkinObjectToolBar));
  764. AddClass(_T("Button"), RUNTIME_CLASS_INFO(CXTPSkinObjectButton));
  766. AddSynonymClass(_T("TButton"), _T("Button"));
  767. AddSynonymClass(_T("TEdit"), _T("Edit"));
  768. AddSynonymClass(_T("TMemo"), _T("Edit"));
  769. AddSynonymClass(_T("TNewProgressBar"), _T("msctls_progress32"));
  770. AddSynonymClass(_T("TRichEditViewer"), _T("Edit"));
  771. AddSynonymClass(_T("TRadioButton"), _T("Button"));
  772. AddSynonymClass(_T("TCheckBox"), _T("Button"));
  773. AddSynonymClass(_T("TComboBox"), _T("ComboBox"));
  774. AddSynonymClass(_T("TGroupBox"), _T("Button"));
  775. AddSynonymClass(_T("TScrollBar"), _T("ScrollBar"));
  776. AddSynonymClass(_T("TProgressBar"), _T("msctls_progress32"));
  777. AddSynonymClass(_T("TTrackBar"), _T("msctls_trackbar32"));
  778. AddSynonymClass(_T("TTabControl"), _T("SysTabControl32"));
  779. AddSynonymClass(_T("TTreeView"), _T("SysTreeView32"));
  780. AddSynonymClass(_T("TListView"), _T("SysListView32"));
  781. AddSynonymClass(_T("TListBox"), _T("ListBox"));
  783. if (XTPSystemVersion()->IsWin95() || XTPSystemVersion()->IsWinNT4())
  784. AddClass(_T("#32768"), new CXTPSkinObjectClassInfo(NULL));
  785. else
  786. AddClass(_T("#32768"), RUNTIME_CLASS_INFO(CXTPSkinObjectMenu));
  789. AddClass(_T("SysPager"), new CXTPSkinObjectClassInfo(NULL));
  790. }
  792. void CXTPSkinObjectClassMap::AddSynonymClass(LPCTSTR lpszClassNameSynonym, LPCTSTR lpszClassName)
  793. {
  794. if (Lookup(lpszClassNameSynonym))
  795. return;
  797. if (lpszClassName == NULL || *lpszClassName == 0)
  798. {
  799. AddClass(lpszClassNameSynonym, new CXTPSkinObjectClassInfo(NULL));
  800. return;
  801. }
  803. CXTPSkinObjectClassInfo* pInfo = Lookup(lpszClassName);
  805. ASSERT(pInfo);
  806. if (!pInfo)
  807. return;
  809. AddClass(lpszClassNameSynonym, pInfo);
  810. }
  812. CXTPSkinObjectClassInfo* CXTPSkinObjectClassMap::AddClass(LPCTSTR lpszClassName, CXTPSkinObjectClassInfo* pInfo)
  813. {
  814. CString strClassName(lpszClassName);
  815. strClassName.MakeUpper();
  817. ASSERT(Lookup(strClassName) == NULL);
  819. m_mapInfo.SetAt(strClassName, pInfo);
  821. if (pInfo->m_pMap == 0)
  822. {
  823. pInfo->m_pMap = this;
  824. }
  825. else
  826. {
  827. ASSERT(pInfo->m_pMap == this);
  828. pInfo->InternalAddRef();
  829. }
  831. return pInfo;
  832. }
  834. void CXTPSkinObjectClassMap::RemoveClass(LPCTSTR lpszClassName)
  835. {
  836. CString strClassName(lpszClassName);
  837. strClassName.MakeUpper();
  839. CXTPSkinObjectClassInfo* pInfo = Lookup(strClassName);
  840. if (!pInfo)
  841. return;
  843. m_mapInfo.RemoveKey(strClassName);
  844. pInfo->InternalRelease();
  845. }
  847. void CXTPSkinObjectClassMap::RemoveClass(CXTPSkinObjectClassInfo* pInfo)
  848. {
  849. POSITION pos = m_mapInfo.GetStartPosition();
  850. CString strClassName;
  851. void* p;
  853. while (pos)
  854. {
  855. m_mapInfo.GetNextAssoc(pos, strClassName, p);
  857. if (p == pInfo)
  858. {
  859. m_mapInfo.RemoveKey(strClassName);
  860. pInfo->InternalRelease();
  861. }
  862. }
  863. }
  865. void CXTPSkinObjectClassMap::RemoveAll()
  866. {
  867. POSITION pos = m_mapInfo.GetStartPosition();
  868. CString strClassName;
  869. CXTPSkinObjectClassInfo* pInfo;
  871. while (pos)
  872. {
  873. m_mapInfo.GetNextAssoc(pos, strClassName, (void*&)pInfo);
  874. pInfo->InternalRelease();
  875. }
  877. m_mapInfo.RemoveAll();
  878. }
  880. CXTPSkinObjectClassInfo* CXTPSkinObjectClassMap::Lookup(LPCTSTR lpszClassName)
  881. {
  882. CString strClassName(lpszClassName);
  883. strClassName.MakeUpper();
  885. void* pInfo;
  887. if (!m_mapInfo.Lookup(strClassName, pInfo))
  888. return NULL;
  890. return (CXTPSkinObjectClassInfo*)pInfo;
  891. }