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

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

对话框与窗口

开发平台：

Visual C++

XTPHookManager.cpp：源码内容
  1. // XTPHookManager.cpp : implementation of the CXTPHookManager class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO 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 "XTPHookManager.h"
  24. #include "XTPColorManager.h"
  25. #include "XTPDrawHelpers.h"
  27. #ifdef _DEBUG
  28. #define new DEBUG_NEW
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #endif
  33. #define FALSE_EXIT 2
  36. CXTPHookManagerHookAble::CXTPHookManagerHookAble()
  37. {
  38. m_bAutoDestroy = FALSE;
  39. }
  41. CXTPHookManagerHookAble::~CXTPHookManagerHookAble()
  42. {
  44. }
  48. class CXTPHookManager::CHookSink : public CArray<CXTPHookManagerHookAble*, CXTPHookManagerHookAble*>
  49. {
  50. friend class CXTPHookManager;
  52. public:
  53. CHookSink(HWND hWnd);
  55. ~CHookSink();
  57. public:
  58. int Find(CXTPHookManagerHookAble* pItem)
  59. {
  60. for (int i = 0; i < GetSize(); i++)
  61. {
  62. if (pItem == GetAt(i))
  63. return  i;
  64. }
  65. return -1;
  66. }
  68. void RemoveHook(CXTPHookManagerHookAble* pHook)
  69. {
  70. int nIndex = Find(pHook);
  71. if (nIndex != -1)
  72. {
  73. RemoveAt(nIndex);
  75. if (pHook->m_bAutoDestroy)
  76. delete pHook;
  78. if (GetSize() == 0)
  79. {
  80. XTPHookManager()->m_mapHooks.RemoveKey(m_hWnd);
  81. delete this;
  82. }
  83. }
  84. }
  86. public:
  87. BOOL OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult);
  89. protected:
  90. WNDPROC m_pOldWndProc;
  91. HWND m_hWnd;
  92. BOOL m_bUnicode;
  93. #ifdef _AFXDLL
  94. AFX_MODULE_STATE* m_pModuleState;
  95. #endif
  96. };
  98. #if (_MSC_VER <= 1200) && !defined(_WIN64)
  99. #define GetWindowLongPtrW GetWindowLongW
  100. #define GetWindowLongPtrA GetWindowLongA
  101. #define SetWindowLongPtrW SetWindowLongW
  102. #define SetWindowLongPtrA SetWindowLongA
  103. #endif
  105. CXTPHookManager::CHookSink::CHookSink(HWND hWnd)
  106. {
  107. #ifdef _AFXDLL
  108. m_pModuleState = 0;
  109. #endif
  110. m_bUnicode = IsWindowUnicode(hWnd);
  112. m_hWnd = hWnd;
  114. if (m_bUnicode)
  115. {
  116. m_pOldWndProc = (WNDPROC)GetWindowLongPtrW(hWnd, GWLP_WNDPROC);
  117. SetWindowLongPtrW(hWnd, GWLP_WNDPROC, (LONG_PTR)CXTPHookManager::HookWndProc);
  118. }
  119. else
  120. {
  121. m_pOldWndProc = (WNDPROC)GetWindowLongPtrA(hWnd, GWLP_WNDPROC);
  122. SetWindowLongPtrA(hWnd, GWLP_WNDPROC, (LONG_PTR)CXTPHookManager::HookWndProc);
  123. }
  124. }
  126. CXTPHookManager::CHookSink::~CHookSink()
  127. {
  128. if (m_bUnicode)
  129. SetWindowLongPtrW(m_hWnd, GWLP_WNDPROC, (LONG_PTR)m_pOldWndProc);
  130. else
  131. SetWindowLongPtrA(m_hWnd, GWLP_WNDPROC, (LONG_PTR)m_pOldWndProc);
  133. for (int i = (int)GetSize() - 1; i >= 0; i--)
  134. {
  135. CXTPHookManagerHookAble* pHookAble = GetAt(i);
  136. if (pHookAble->m_bAutoDestroy)
  137. {
  138. delete pHookAble;
  139. }
  140. }
  141. }
  143. BOOL CXTPHookManager::CHookSink::OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  144. {
  145. int nCount = (int)GetSize();
  147. for (int i = nCount - 1; i >= 0; i--)
  148. {
  149. int nResult = GetAt(i)->OnHookMessage(hWnd, nMessage, wParam, lParam, lResult);
  151. if (nResult == TRUE)
  152. return TRUE;
  153. if (nResult == FALSE_EXIT)
  154. return FALSE;
  155. }
  156. return FALSE;
  157. }
  160. CXTPHookManager::CXTPHookManager()
  161. {
  162. }
  164. CXTPHookManager* AFX_CDECL XTPHookManager()
  165. {
  166. static CXTPHookManager s_managerInstance;
  167. return &s_managerInstance;
  168. }
  170. CXTPHookManager::~CXTPHookManager()
  171. {
  172. RemoveAll();
  173. }
  176. LRESULT CXTPHookManager::Default(WPARAM wParam, LPARAM lParam)
  177. {
  178. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  180. CHookSink* pSink = Lookup(curMsg.hwnd);
  181. ASSERT(pSink);
  182. if (!pSink)
  183. return 0;
  185. WNDPROC wndProc = pSink->m_pOldWndProc;
  187. LRESULT lResult = ::CallWindowProc(wndProc, curMsg.hwnd, curMsg.message, wParam, lParam);
  189. return lResult;
  190. }
  192. LRESULT CXTPHookManager::Default()
  193. {
  194. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  195. return Default(curMsg.wParam, curMsg.lParam);;
  196. }
  198. LRESULT CALLBACK CXTPHookManager::HookWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  199. {
  200. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  201. MSG  oldMsg = curMsg;
  202. curMsg.hwnd = hWnd;
  203. curMsg.message = message;
  204. curMsg.wParam = wParam;
  205. curMsg.lParam = lParam;
  207. // Get hook object for this window. Get from hook map
  208. CHookSink* pSink = XTPHookManager()->Lookup(hWnd);
  209. ASSERT(pSink);
  210. if (!pSink)
  211. return 0;
  213. SAFE_MANAGE_STATE(pSink->m_pModuleState);
  215. LRESULT lResult = 0;
  216. WNDPROC wndProc = pSink->m_pOldWndProc;
  218. // Window is being destroyed: unhook all hooks (for this window)
  219. // and pass message to orginal window proc
  220. if (message == WM_NCDESTROY)
  221. {
  222. XTPHookManager()->RemoveAll(hWnd);
  223. }
  224. // pass to message hook
  225. else
  226. {
  227. if (pSink->OnHookMessage(hWnd, message, wParam, lParam, lResult))
  228. {
  229. curMsg = oldMsg;
  230. return lResult;
  231. }
  232. }
  233. lResult = ::CallWindowProc(wndProc, hWnd, message, wParam, lParam);
  235. curMsg = oldMsg;
  236. return lResult;
  237. }
  239. void CXTPHookManager::SetHook(HWND hWnd, CXTPHookManagerHookAble* pHook)
  240. {
  241. CHookSink* pSink = Lookup(hWnd);
  243. if (pSink)
  244. {
  245. if (pSink->Find(pHook) == -1)
  246. {
  247. pSink->Add(pHook);
  248. }
  250. }
  251. else
  252. {
  253. pSink = new CHookSink(hWnd);
  254. pSink->Add(pHook);
  256. m_mapHooks[hWnd] = pSink;
  257. }
  259. #ifdef _AFXDLL
  260. pSink->m_pModuleState = AfxGetModuleState();
  261. #endif
  264. }
  265. void CXTPHookManager::RemoveAll()
  266. {
  267. HWND hWnd;
  268. POSITION pos = m_mapHooks.GetStartPosition();
  269. CHookSink* pSink;
  271. while (pos)
  272. {
  273. m_mapHooks.GetNextAssoc(pos, hWnd, (void*&)pSink);
  274. delete pSink;
  275. }
  276. m_mapHooks.RemoveAll();
  277. }
  279. void CXTPHookManager::RemoveAll(HWND hWnd)
  280. {
  281. CHookSink* pSink = Lookup(hWnd);
  282. if (pSink)
  283. {
  284. m_mapHooks.RemoveKey(hWnd);
  285. delete pSink;
  286. }
  287. }
  289. void CXTPHookManager::RemoveAll(CXTPHookManagerHookAble* pHook)
  290. {
  291. ASSERT(pHook);
  292. HWND hWnd;
  293. CHookSink* pSink = NULL;
  295. POSITION pos = m_mapHooks.GetStartPosition();
  296. while (pos)
  297. {
  298. m_mapHooks.GetNextAssoc(pos, hWnd, (void*&)pSink);
  299. pSink->RemoveHook(pHook);
  300. }
  301. }
  303. CXTPHookManager::CHookSink* CXTPHookManager::Lookup(HWND hWnd)
  304. {
  305. CHookSink* pSink;
  307. if (m_mapHooks.Lookup(hWnd, (void*&)pSink))
  308. return pSink;
  309. return NULL;
  310. }
  312. void CXTPHookManager::RemoveHook(HWND hWnd, CXTPHookManagerHookAble* pHook)
  313. {
  314. ASSERT(hWnd);
  315. CHookSink* pSink = Lookup(hWnd);
  317. if (pSink)
  318. {
  319. pSink->RemoveHook(pHook);
  320. }
  321. }
  323. //////////////////////////////////////////////////////////////////////////
  324. // CXTPShadowManager
  326. class CXTPShadowManager::CShadowWnd : public CWnd, public CXTPHookManagerHookAble
  327. {
  328. public:
  330. //-------------------------------------------------------------------------
  331. // Summary:
  332. //     Constructs a CShadowWnd object.
  333. //-------------------------------------------------------------------------
  334. CShadowWnd(CXTPShadowManager* pShadowManager);
  335. ~CShadowWnd();
  337. public:
  338. BOOL Create(BOOL bHoriz, CRect rcWindow);
  339. void LongShadow(CShadowList* pList);
  340. BOOL ExcludeRect(CRect rcExclude);
  342. private:
  343. DECLARE_MESSAGE_MAP()
  345. afx_msg BOOL OnEraseBkgnd(CDC* pDC);
  346. afx_msg void OnPaint();
  347. afx_msg void OnSize(UINT nType, int cx, int cy);
  348. afx_msg LRESULT OnNcHitTest(CPoint point);
  350. private:
  351. virtual int OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult);
  352. UINT Factor(int& nRed, int& nGreen, int& nBlue, double dFactor);
  354. private:
  356. BOOL m_bHoriz;
  357. BOOL m_bExcluded;
  358. CWnd* m_pShadowsOwner;
  359. BOOL m_bControlPopup;
  360. CXTPShadowManager* m_pShadowsManager;
  362. friend class CXTPShadowManager;
  363. };
  366. //===========================================================================
  367. // Summary:
  368. //     Shadow list
  369. //===========================================================================
  370. class CXTPShadowManager::CShadowList : public CList<CShadowWnd*, CShadowWnd*>
  371. {
  372. public:
  374. void AddShadow(CShadowWnd* pShadow)
  375. {
  376. pShadow->LongShadow(this);
  377. AddTail(pShadow);
  378. }
  380. void RemoveShadow(CShadowWnd* pShadow)
  381. {
  382. POSITION pos = Find(pShadow);
  383. ASSERT(pos);
  384. RemoveAt(pos);
  385. }
  386. };
  388. CXTPShadowManager::CXTPShadowManager()
  389. {
  390. m_pfnUpdateLayeredWindow = NULL;
  392. HMODULE hLib = GetModuleHandle(_T("USER32"));
  393. if (hLib)
  394. {
  395. m_pfnUpdateLayeredWindow = (LPFNUPDATELAYEREDWINDOW) GetProcAddress(hLib, "UpdateLayeredWindow");
  396. }
  398. m_bAlphaShadow = IsAlphaShadow();
  399. m_nShadowOptions = 0;
  400. m_clrShadowFactor = 0;
  401. m_bUseSystemSaveBitsStyle = TRUE;
  403. m_pShadows = new CShadowList();
  404. }
  406. CXTPShadowManager::~CXTPShadowManager()
  407. {
  408. ASSERT(m_pShadows->IsEmpty());
  409. SAFE_DELETE(m_pShadows);
  410. }
  412. BOOL CXTPShadowManager::IsAlphaShadow()
  413. {
  414. #ifdef NOALPHASHADOW
  415. return FALSE;
  416. #endif
  418. if (XTPColorManager()->IsLowResolution())
  419. return FALSE;
  421. return (m_pfnUpdateLayeredWindow != NULL);
  422. }
  425. #ifndef SPI_GETDROPSHADOW
  426. #define SPI_GETDROPSHADOW     0x1024
  427. #endif
  430. void CXTPShadowManager::SetShadow(CWnd* pShadowOwner, const CRect& rcExclude)
  431. {
  432. if (!(GetShadowOptions() & xtpShadowOfficeAlpha))
  433. {
  434. if (!m_bAlphaShadow)
  435. return;
  437. BOOL bDropShadow = FALSE;
  438. SystemParametersInfo(SPI_GETDROPSHADOW, 0, &bDropShadow, 0);
  440. if (!bDropShadow)
  441. return;
  442. }
  444. CXTPWindowRect rc(pShadowOwner);
  445. CreateShadow(TRUE, rc, rcExclude, pShadowOwner, FALSE);
  446. CreateShadow(FALSE, rc, rcExclude, pShadowOwner, FALSE);
  448. HRGN hRgn = CreateRectRgn(0, 0, 0, 0);
  449. if (pShadowOwner->GetWindowRgn(hRgn) == COMPLEXREGION)
  450. {
  451. CreateShadow(2, rc, rcExclude, pShadowOwner, FALSE);
  452. }
  453. DeleteObject(hRgn);
  455. }
  457. void CXTPShadowManager::SetShadow(CRect rcWindow, CWnd* pShadowOwner)
  458. {
  459. if ((GetShadowOptions() & (xtpShadowOfficeAlpha | xtpShadowShowPopupControl)) ==
  460. (xtpShadowOfficeAlpha | xtpShadowShowPopupControl))
  461. {
  462. CreateShadow(TRUE, rcWindow, CXTPEmptyRect(), pShadowOwner, TRUE);
  463. CreateShadow(FALSE, rcWindow, CXTPEmptyRect(), pShadowOwner, TRUE);
  464. }
  465. }
  467. POSITION CXTPShadowManager::GetHeadPosition(CWnd* pShadowOwner) const
  468. {
  469. POSITION pos = m_pShadows->GetHeadPosition();
  470. while (pos)
  471. {
  472. CShadowWnd* pShadow = m_pShadows->GetAt(pos);
  473. if (pShadow->m_pShadowsOwner == pShadowOwner)
  474. return pos;
  475. m_pShadows->GetNext(pos);
  476. }
  478. return NULL;
  479. }
  481. CWnd* CXTPShadowManager::GetNext(POSITION& pos) const
  482. {
  483. CShadowWnd* pShadowResult = m_pShadows->GetNext(pos);
  485. while (pos)
  486. {
  487. CShadowWnd* pShadow = m_pShadows->GetAt(pos);
  488. if (pShadow->m_pShadowsOwner == pShadowResult->m_pShadowsOwner)
  489. break;
  490. m_pShadows->GetNext(pos);
  491. }
  493. return pShadowResult;
  494. }
  496. void CXTPShadowManager::RemoveShadow(CWnd* pShadowOwner)
  497. {
  498. POSITION pos = m_pShadows->GetHeadPosition();
  499. while (pos)
  500. {
  501. CShadowWnd* pShadow = m_pShadows->GetNext(pos);
  503. if (pShadowOwner == pShadow->m_pShadowsOwner)
  504. {
  505. XTPHookManager()->RemoveHook(pShadow->m_pShadowsOwner->GetSafeHwnd(), pShadow);
  506. DestroyShadow(pShadow);
  507. }
  508. }
  509. }
  511. void CXTPShadowManager::OffsetShadow(CWnd* pShadowOwner, CSize szOffset)
  512. {
  513. BOOL bLayoutRTL = pShadowOwner->GetExStyle() & WS_EX_LAYOUTRTL;
  515. POSITION pos = m_pShadows->GetHeadPosition();
  516. while (pos)
  517. {
  518. CShadowWnd* pShadow = m_pShadows->GetNext(pos);
  520. if (pShadowOwner == pShadow->m_pShadowsOwner && pShadow->GetSafeHwnd() && !pShadow->m_bControlPopup)
  521. {
  522. if (pShadow->m_bExcluded)
  523. {
  524. pShadow->SetWindowRgn(NULL, FALSE);
  525. pShadow->m_bExcluded = FALSE;
  526. }
  528. CXTPWindowRect rc(pShadow);
  530. if (bLayoutRTL)
  531. {
  532. if (pShadow->m_bHoriz == 1)
  533. {
  534. pShadow->SetWindowPos(0, rc.left - szOffset.cx , rc.top + szOffset.cy,
  535. rc.Width() + szOffset.cx, rc.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  536. }
  537. else if (pShadow->m_bHoriz == 2)
  538. {
  539. pShadow->SetWindowPos(0, rc.left, rc.top + szOffset.cy,
  540. rc.Width(), rc.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  541. }
  542. else
  543. {
  544. pShadow->SetWindowPos(0, rc.left, rc.top,
  545. rc.Width(), rc.Height() + szOffset.cy, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  546. }
  547. }
  548. else
  549. {
  550. if (pShadow->m_bHoriz == 1)
  551. {
  552. pShadow->SetWindowPos(0, rc.left, rc.top + szOffset.cy,
  553. rc.Width() + szOffset.cx, rc.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  554. }
  555. else if (pShadow->m_bHoriz == 2)
  556. {
  557. pShadow->SetWindowPos(0, rc.left + szOffset.cx , rc.top + szOffset.cy,
  558. rc.Width(), rc.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  559. }
  560. else
  561. {
  562. pShadow->SetWindowPos(0, rc.left + szOffset.cx, rc.top,
  563. rc.Width(), rc.Height() + szOffset.cy, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  564. }
  565. }
  566. }
  567. }
  568. }
  570. CXTPShadowManager::CShadowWnd* CXTPShadowManager::CreateShadow(BOOL bHoriz, CRect rc, CRect rcExclude, CWnd* pShadowOwner, BOOL bControlPopup)
  571. {
  572. CShadowWnd* pShadow = new CShadowWnd(this);
  574. pShadow->m_pShadowsOwner = pShadowOwner;
  575. pShadow->m_bControlPopup = bControlPopup;
  576. pShadow->Create(bHoriz, rc);
  578. m_pShadows->AddShadow(pShadow);
  580. if (m_nShadowOptions & xtpShadowShowPopupControl)
  581. {
  582. pShadow->ExcludeRect(rcExclude);
  583. }
  585. POSITION pos = m_pShadows->GetHeadPosition();
  586. while (pos)
  587. {
  588. CShadowWnd* pShadowPrev = m_pShadows->GetNext(pos);
  589. if (pShadowPrev->m_pShadowsOwner && (bHoriz != 2 || pShadowPrev->m_pShadowsOwner != pShadowOwner))
  590. {
  591. pShadow->ExcludeRect(CXTPWindowRect(pShadowPrev->m_pShadowsOwner));
  592. }
  593. }
  596. pShadow->SetWindowPos(pShadowOwner->GetExStyle() & WS_EX_TOPMOST ? &CWnd::wndTopMost : &CWnd::wndTop,
  597. 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  599. XTPHookManager()->SetHook(pShadowOwner->m_hWnd, pShadow);
  601. return pShadow;
  602. }
  605. void CXTPShadowManager::DestroyShadow(CShadowWnd* pWnd)
  606. {
  607. if (pWnd->GetSafeHwnd()) pWnd->ShowWindow(SW_HIDE);
  608. pWnd->m_pShadowsOwner = 0;
  609. m_pShadows->RemoveShadow(pWnd);
  610. pWnd->DestroyWindow();
  611. delete pWnd;
  612. }
  614. CXTPShadowManager::CShadowWnd::CShadowWnd(CXTPShadowManager* pShadowManager)
  615. {
  616. m_pShadowsOwner = 0;
  617. m_bHoriz = FALSE;
  618. m_bExcluded = FALSE;
  620. m_pShadowsManager = pShadowManager;
  621. CMDTARGET_ADDREF(m_pShadowsManager);
  622. }
  624. CXTPShadowManager::CShadowWnd::~CShadowWnd()
  625. {
  626. CMDTARGET_RELEASE(m_pShadowsManager);
  627. }
  630. int CXTPShadowManager::CShadowWnd::OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& /*lParam*/, LRESULT& /*lResult*/)
  631. {
  632. if (nMessage == WM_SHOWWINDOW && wParam == FALSE)
  633. {
  634. ShowWindow(SW_HIDE);
  635. }
  636. if (nMessage == WM_SHOWWINDOW && wParam == TRUE)
  637. {
  638. ShowWindow(SW_SHOWNA);
  639. }
  640. if (nMessage == WM_DESTROY)
  641. {
  642. XTPHookManager()->RemoveHook(hWnd, this);
  643. m_pShadowsManager->DestroyShadow(this);
  644. }
  645. return 0;
  646. }
  648. BOOL CXTPShadowManager::CShadowWnd::Create(BOOL bHoriz, CRect rcWindow)
  649. {
  650. CWnd* pSite = m_pShadowsOwner->GetParent();
  651. ASSERT(pSite);
  653. if (m_hWnd == 0)
  654. {
  655. int nFlags = WS_EX_TOOLWINDOW;
  656. if (m_pShadowsManager->m_bAlphaShadow) nFlags |= 0x80000;
  658. UINT nClassStyle = m_pShadowsManager->m_bUseSystemSaveBitsStyle ? CS_SAVEBITS | CS_OWNDC : 0;
  660. CString strClass = ::AfxRegisterWndClass(nClassStyle, AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  661. if (!CreateEx(nFlags, strClass, 0, WS_POPUP, CXTPEmptyRect(), pSite, 0))
  662. return FALSE;
  663. }
  664. SetWindowRgn(NULL, FALSE);
  666. int nWidth = m_pShadowsManager->m_bAlphaShadow ? 4 : 2;
  668. m_bHoriz = bHoriz;
  670. CRect rcShadow;
  672. if (bHoriz == 2)
  673. rcShadow.SetRect(rcWindow.right - 1, rcWindow.bottom - 1, rcWindow.right, rcWindow.bottom);
  674. else if (bHoriz == 1)
  675. rcShadow.SetRect(rcWindow.left + nWidth, rcWindow.bottom, rcWindow.right + nWidth, rcWindow.bottom + nWidth);
  676. else
  677. rcShadow.SetRect(rcWindow.right, rcWindow.top + nWidth, rcWindow.right + nWidth, rcWindow.bottom);
  679. MoveWindow(rcShadow, FALSE);
  680. return TRUE;
  681. }
  683. BEGIN_MESSAGE_MAP(CXTPShadowManager::CShadowWnd, CWnd)
  684. { WM_ERASEBKGND, 0, 0, 0, AfxSig_bD, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(CDC*) > (CXTPShadowManager::CShadowWnd::OnEraseBkgnd)) },
  685. { WM_PAINT, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > (CXTPShadowManager::CShadowWnd::OnPaint)) },
  686. { WM_SIZE, 0, 0, 0, AfxSig_vwii, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, int, int) > (CXTPShadowManager::CShadowWnd::OnSize)) },
  687. { WM_NCHITTEST, 0, 0, 0, AfxSig_wp, (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(CPoint) > (CXTPShadowManager::CShadowWnd::OnNcHitTest)) },
  688. END_MESSAGE_MAP()
  690. LRESULT CXTPShadowManager::CShadowWnd::OnNcHitTest(CPoint /*point*/)
  691. {
  692. return (LRESULT)HTTRANSPARENT;
  693. }
  695. void CXTPShadowManager::CShadowWnd::OnPaint()
  696. {
  697. CPaintDC dc(this);
  698. CXTPClientRect rcClient(this);
  700. dc.FillSolidRect(rcClient, m_pShadowsManager->m_bAlphaShadow ? 0 : GetXtremeColor(COLOR_3DSHADOW));
  701. }
  704. BOOL CXTPShadowManager::CShadowWnd::OnEraseBkgnd(CDC* /*pDC*/)
  705. {
  706. return TRUE;
  707. }
  709. BOOL CXTPShadowManager::CShadowWnd::ExcludeRect(CRect rcExclude)
  710. {
  711. CXTPWindowRect rcWindow(this);
  712. CRect rcIntersect;
  713. if (rcIntersect.IntersectRect(rcWindow, rcExclude))
  714. {
  715. CXTPClientRect rcClient(this);
  716. HRGN hrgnClip = ::CreateRectRgnIndirect(&rcClient);
  718. rcIntersect.OffsetRect(-rcWindow.TopLeft());
  719. HRGN hrgnIntersect = ::CreateRectRgnIndirect(&rcIntersect);
  720. CombineRgn(hrgnClip, hrgnClip, hrgnIntersect, RGN_DIFF);
  721. DeleteObject(hrgnIntersect);
  723. if (!SetWindowRgn(hrgnClip, FALSE))
  724. DeleteObject(hrgnClip);
  725. m_bExcluded = TRUE;
  726. }
  727. return TRUE;
  728. }
  730. void CXTPShadowManager::CShadowWnd::LongShadow(CShadowList* pList)
  731. {
  732. CXTPWindowRect rcWindow(this);
  734. POSITION pos = pList->GetHeadPosition();
  735. while (pos)
  736. {
  737. CShadowWnd* pWnd = pList->GetNext(pos);
  738. if (m_bHoriz == !pWnd->m_bHoriz)
  739. {
  740. CXTPWindowRect rc(pWnd);
  741. if (m_bHoriz == FALSE)
  742. {
  743. if (rcWindow.top == rc.bottom -1 && rcWindow.right < rc.right && rcWindow.right > rc.left)
  744. {
  745. rcWindow.top -= 2 * rc.Height();
  746. MoveWindow(rcWindow, FALSE);
  747. }
  748. }
  749. else
  750. {
  752. if (rcWindow.left == rc.right - 1 && rcWindow.top > rc.top && rcWindow.bottom < rc.bottom)
  753. {
  754. rcWindow.left -= 2 * rc.Width() + 1;
  755. MoveWindow(rcWindow, FALSE);
  756. }
  757. }
  758. }
  759. }
  760. }
  762. UINT CXTPShadowManager::CShadowWnd::Factor(int& nRed, int& nGreen, int& nBlue, double dFactor)
  763. {
  764. return (int(nRed * dFactor) << 16) + (int(nGreen * dFactor) << 8) + (int(nBlue * dFactor));
  765. }
  768. void CXTPShadowManager::CShadowWnd::OnSize(UINT nType, int cx, int cy)
  769. {
  770. CWnd::OnSize(nType, cx, cy);
  772. if (!cx || !cy || !m_pShadowsManager->m_bAlphaShadow ||
  773. !m_pShadowsManager->m_pfnUpdateLayeredWindow || !m_pShadowsOwner)
  774. return;
  776. BLENDFUNCTION bf;
  777. bf.BlendOp = AC_SRC_OVER;
  778. bf.BlendFlags = 0;
  779. bf.SourceConstantAlpha = 255;
  780. bf.AlphaFormat = 0x01;
  782. POINT pt = {0, 0};
  783. int x, y;
  784. HBITMAP hbitmap;
  785. BITMAPINFO bmi;
  787. CClientDC cDC(this);
  788. CDC dc;
  789. dc.CreateCompatibleDC(&cDC);
  792. // zero the memory for the bitmap info
  793. ZeroMemory(&bmi, sizeof(BITMAPINFO));
  795. bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  796. bmi.bmiHeader.biWidth = cx;
  797. bmi.bmiHeader.biHeight = cy;
  798. bmi.bmiHeader.biPlanes = 1;
  799. bmi.bmiHeader.biBitCount = 32;         // four 8-bit components
  800. bmi.bmiHeader.biCompression = BI_RGB;
  801. bmi.bmiHeader.biSizeImage = cx * cy * 4;
  803. UINT* pvBits = NULL;
  805. // create our DIB section and select the bitmap into the dc
  806. hbitmap = CreateDIBSection(cDC, &bmi, DIB_RGB_COLORS, (void**)&pvBits, NULL, 0x0);
  808. if (pvBits == NULL || hbitmap == NULL)
  809. return;
  811. COLORREF clrFactor = m_pShadowsManager->m_clrShadowFactor;
  814. int nRed = GetRValue(clrFactor), nGreen = GetGValue(clrFactor), nBlue = GetBValue(clrFactor);
  816. int nFactor = m_pShadowsManager->m_nShadowOptions & xtpShadowOfficeAlpha ? 1 : 2;
  818. if (m_bHoriz == 2)
  819. {
  820. pvBits[0] = (UINT) 4 * 0x0F000000 * nFactor
  821. + Factor(nRed, nGreen, nBlue, 1);
  822. }
  823. else if (m_bHoriz == 0)
  824. {
  825. ASSERT(cx == 4);
  827. for (x = 0; x < 4; x++) for (y = 0; y < 4; y++)
  828. {
  829. pvBits[3 - x + (cy - 1 - y) * cx] = (UINT) 3 * (x + 1) * (y + 1) * 0x1000000 * nFactor
  830. + Factor(nRed, nGreen, nBlue, double((x + 1) * (y + 1))/20);
  831. }
  833. for (x = 3; x >= 0; x--)
  834. {
  835. UINT nColor = 0x0F000000 * nFactor * (4 - x) + Factor(nRed, nGreen, nBlue, double(4 - x)/4);
  837. for (y = 0; y < cy - 4; y++) pvBits[x + y * cx] = nColor;
  838. }
  839. }
  840. else
  841. {
  842. ASSERT(cy == 4);
  844. for (x = 0; x < 4; x++) for (y = 0; y < 4; y++)
  845. {
  846. pvBits[x + y * cx] = (UINT) 3 * (x + 1) * (y + 1) * 0x1000000 * nFactor
  847. + Factor(nRed, nGreen, nBlue, double((x + 1) * (y + 1))/20);
  848. }
  850. for (y = 0; y < 4; y++)
  851. {
  852. UINT nColor = 0x0F000000 * nFactor * (y + 1) + Factor(nRed, nGreen, nBlue, double(y + 1)/4);
  854. for (x = 4; x < cx - 4; x++) pvBits[x + y * cx] = nColor;
  855. }
  857. for (x = 0; x < 4; x++) for (y = 0; y < 4; y++)
  858. {
  859. pvBits[cx - 1 - x + y * cx] = (UINT)3 * (x + 1) * (y + 1) * 0x1000000 * nFactor
  860. + Factor(nRed, nGreen, nBlue, double((x + 1) * (y + 1))/20);
  861. }
  862. }
  865. HBITMAP hOld = (HBITMAP)SelectObject(dc, hbitmap);
  867. SIZE sz = {cx, cy};
  869. m_pShadowsManager->m_pfnUpdateLayeredWindow((HWND)GetSafeHwnd(), (HDC)0, 0, &sz, dc.GetSafeHdc(), &pt, 0, &bf, 0x02);
  871. SelectObject(dc, hOld);
  872. DeleteObject(hbitmap);
  873. dc.DeleteDC();
  874. }