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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtHook.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：41k
源码类别：

界面编程

开发平台：

Visual C++

ExtHook.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "StdAfx.h"
  24. #if (!defined __EXT_HOOK_H)
  25. #include "ExtHook.h"
  26. #endif
  28. #if (!defined __EXT_PAINT_MANAGER_H)
  29. #include <ExtPaintManager.h>
  30. #endif
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. typedef
  39. CMap < HWND, HWND,
  40. CExtHookSink::HookChains_t *, CExtHookSink::HookChains_t * >
  41. HookChainsMap_t;
  43. static HookChainsMap_t g_HookChainsMap;
  45. struct __PROF_UIS_API CExtHookSink::HookSinkArray_t :
  46. public CArray< CExtHookSink *, CExtHookSink * >
  47. {
  48. INT Find( const CExtHookSink * pHookSink ) const
  49. {
  50. ASSERT( pHookSink != NULL );
  51. for( INT nSinkIdx = 0; nSinkIdx < GetSize(); nSinkIdx++ )
  52. {
  53. const CExtHookSink * pHookSinkExamine =
  54. GetAt( nSinkIdx );
  55. ASSERT( pHookSink != NULL );
  56. if( pHookSinkExamine == pHookSink )
  57. return nSinkIdx;
  58. }
  59. return -1;
  60. }
  61. void AddHead( CExtHookSink * pHookSink )
  62. {
  63. ASSERT( pHookSink != NULL );
  64. InsertAt( 0, pHookSink );
  65. }
  66. void AddTail( CExtHookSink * pHookSink )
  67. {
  68. ASSERT( pHookSink != NULL );
  69. InsertAt( GetSize(), pHookSink );
  70. }
  71. }; // struct HookSinkArray_t
  73. struct __PROF_UIS_API CExtHookSink::HookChains_t
  74. {
  75. bool m_bEatNcDestroy:1;
  76. HookSinkArray_t m_HookSinkArray;
  77. HWND m_hWndHooked;
  78. WNDPROC m_pWNDPROC;
  80. static LRESULT CALLBACK g_HookWndProc(
  81. HWND hWnd,
  82. UINT nMessage,
  83. WPARAM wParam,
  84. LPARAM lParam
  85. );
  87. HookChains_t(
  88. HWND hWndHooked
  89. )
  90. : m_hWndHooked( hWndHooked )
  91. , m_bEatNcDestroy( false )
  92. {
  93. ASSERT( m_hWndHooked != NULL );
  94. ASSERT( ::IsWindow(m_hWndHooked) );
  95. m_pWNDPROC = (WNDPROC)(__EXT_MFC_LONG_PTR)
  96. ::__EXT_MFC_SetWindowLong(
  97. m_hWndHooked,
  98. __EXT_MFC_GWL_WNDPROC,
  99. #if defined(_WIN64)
  100. (__EXT_MFC_LONG_PTR)
  101. #else
  102. (LONG)(__EXT_MFC_LONG_PTR)
  103. #endif
  104. g_HookWndProc
  105. );
  106. // ASSERT( m_pWNDPROC != NULL );
  107. };
  109. ~HookChains_t()
  110. {
  111. DestroyChains( false );
  112. };
  114. void DestroyChains( bool bDelete )
  115. {
  116. for( int nSinkIdx=0; nSinkIdx < m_HookSinkArray.GetSize(); nSinkIdx++ )
  117. {
  118. CExtHookSink * pHookSink =
  119. m_HookSinkArray[ nSinkIdx ];
  120. ASSERT( pHookSink != NULL );
  121. if( pHookSink->IsAutoDeleteHookWndSink() )
  122. delete pHookSink;
  123. } // for( int nSinkIdx=0; nSinkIdx < m_HookSinkArray.GetSize(); nSinkIdx++ )
  124. m_HookSinkArray.RemoveAll();
  126. ASSERT( m_hWndHooked != NULL );
  127. ASSERT( ::IsWindow(m_hWndHooked) );
  128. ASSERT( m_pWNDPROC != NULL );
  129. ::__EXT_MFC_SetWindowLong(
  130. m_hWndHooked,
  131. __EXT_MFC_GWL_WNDPROC,
  132. #if defined(_WIN64)
  133. (__EXT_MFC_LONG_PTR)
  134. #else
  135. (LONG)(__EXT_MFC_LONG_PTR)
  136. #endif
  137. m_pWNDPROC
  138. );
  140. POSITION posChains = g_HookChainsMap.GetStartPosition();
  141. for( ; posChains != NULL; )
  142. {
  143. CExtHookSink::HookChains_t * pHookChains = NULL;
  144. HWND hWndHooked = NULL;
  145. g_HookChainsMap.GetNextAssoc(
  146. posChains, hWndHooked, pHookChains );
  147. ASSERT( hWndHooked != NULL );
  148. ASSERT( pHookChains != NULL );
  149. if( pHookChains == this )
  150. {
  151. g_HookChainsMap.RemoveKey( hWndHooked );
  152. break;
  153. }
  154. }
  156. if( bDelete )
  157. delete this;
  158. };
  160. LRESULT HookChainsWindowProc(
  161. UINT nMessage,
  162. WPARAM & wParam,
  163. LPARAM & lParam
  164. )
  165. {
  166. __PROF_UIS_MANAGE_STATE;
  167. ASSERT( m_hWndHooked != NULL );
  168. ASSERT( ::IsWindow(m_hWndHooked) );
  169. ASSERT( m_pWNDPROC != NULL );
  170. // CWnd * pWndPermanent = NULL;
  171. // { // BLOCK: state managing
  172. // __PROF_UIS_MANAGE_STATE;
  173. // pWndPermanent = 
  174. // CWnd::FromHandlePermanent( m_hWndHooked );
  175. // } // BLOCK: state managing
  176. bool bEatNcDestroy = m_bEatNcDestroy;
  177. int nSinkIdx, nSinkCount = (int)m_HookSinkArray.GetSize();
  178. for( nSinkIdx = 0; nSinkIdx < nSinkCount; nSinkIdx++ )
  179. {
  180. CExtHookSink * pHookSink =
  181. m_HookSinkArray[ nSinkIdx ];
  182. ASSERT( pHookSink != NULL );
  183. if( nMessage == WM_NCDESTROY ) 
  184. {
  185. if( (! bEatNcDestroy )
  186. && pHookSink->m_bEatNcDestroy
  187. )
  188. bEatNcDestroy = true;
  189. if(! bEatNcDestroy )
  190. pHookSink->OnHookWndNcDestroy();
  191. continue;
  192. } // if( nMessage == WM_NCDESTROY ) 
  193. LRESULT lResult = 0;
  194. if( pHookSink->OnHookWndMsg(
  195. lResult,
  196. m_hWndHooked,
  197. nMessage,
  198. wParam,
  199. lParam
  200. )
  201. )
  202. return lResult;
  203. } // for( nSinkIdx = 0; nSinkIdx < nSinkCount; nSinkIdx++ )
  204. WNDPROC pWNDPROC = m_pWNDPROC;
  205. HWND hWndHooked = m_hWndHooked;
  206. if( nMessage == WM_NCDESTROY ) 
  207. {
  208. DestroyChains( true );
  209. // if( pWndPermanent != NULL )
  210. // {
  211. // __PROF_UIS_MANAGE_STATE;
  212. // CWnd * pWndExamine =
  213. // CWnd::FromHandlePermanent( hWndHooked );
  214. // if( pWndExamine != pWndPermanent )
  215. // return 0L;
  216. // } // if( pWndPermanent != NULL )
  217. if( bEatNcDestroy )
  218. return 0L;
  219. } // if( nMessage == WM_NCDESTROY ) 
  220. LRESULT lResult =
  221. ::CallWindowProc(
  222. pWNDPROC,
  223. hWndHooked,
  224. nMessage,
  225. wParam,
  226. lParam
  227. );
  228. if( ::IsWindow( hWndHooked ) )
  229. {
  230. CExtHookSink::HookChains_t * pHC = NULL;
  231. if( g_HookChainsMap.Lookup( hWndHooked, pHC )
  232. && pHC == this
  233. )
  234. {
  235. nSinkCount = (int)m_HookSinkArray.GetSize();
  236. for( nSinkIdx = 0; nSinkIdx < nSinkCount; nSinkIdx++ )
  237. {
  238. CExtHookSink * pHookSink =
  239. m_HookSinkArray[ nSinkIdx ];
  240. if( pHookSink == NULL )
  241. continue;
  242. pHookSink->OnPostHookWndMsg(
  243. lResult,
  244. m_hWndHooked,
  245. nMessage,
  246. wParam,
  247. lParam
  248. );
  249. if( ! ::IsWindow( hWndHooked ) )
  250. break;
  251. pHC = NULL;
  252. if( ! g_HookChainsMap.Lookup( hWndHooked, pHC ) )
  253. break;
  254. if( pHC != this )
  255. break;
  256. } // for( nSinkIdx = 0; nSinkIdx < nSinkCount; nSinkIdx++ )
  257. }
  258. } // if( ::IsWindow( hWndHooked ) )
  259. return lResult;
  260. };
  262. }; // struct CExtHookSink::HookChains_t
  264. LRESULT CALLBACK CExtHookSink::HookChains_t::g_HookWndProc(
  265. HWND hWnd,
  266. UINT nMessage,
  267. WPARAM wParam,
  268. LPARAM lParam
  269. )
  270. {
  272. LRESULT lResult = 0;
  274. MSG & refMsgMfcCurr = AfxGetThreadState()->m_lastSentMsg;
  275. MSG msgMfcSaved( refMsgMfcCurr );
  276. refMsgMfcCurr.hwnd    = hWnd;
  277. refMsgMfcCurr.message = nMessage;
  278. refMsgMfcCurr.wParam  = wParam;
  279. refMsgMfcCurr.lParam  = lParam;
  281. CExtHookSink::HookChains_t * pHookChains = NULL;
  282. if( g_HookChainsMap.Lookup( hWnd, pHookChains ) )
  283. {
  284. ASSERT( pHookChains != NULL );
  285. ASSERT( pHookChains->m_hWndHooked == hWnd );
  286. lResult =
  287. pHookChains->HookChainsWindowProc(
  288. nMessage,
  289. wParam,
  290. lParam
  291. );  
  292. if( nMessage == WM_NCDESTROY || ( ! ::IsWindow( hWnd ) ) ) 
  293. g_HookChainsMap.RemoveKey( hWnd );
  294. } // if( g_HookChainsMap.Lookup( hWnd, pHookChains ) )
  296. refMsgMfcCurr = msgMfcSaved;
  298. return lResult;
  299. }
  301. CExtHookSink::CExtHookSink(
  302. bool bEnableDetailedWndHooks // = true
  303. )
  304. : m_bEnableDetailedWndHooks( bEnableDetailedWndHooks )
  305. , m_bEatNcDestroy( false )
  306. {
  307. }
  309. CExtHookSink::~CExtHookSink()
  310. {
  311. POSITION posChains = g_HookChainsMap.GetStartPosition();
  312. for( ; posChains != NULL; )
  313. {
  314. CExtHookSink::HookChains_t * pHookChains = NULL;
  315. HWND hWndHooked = NULL;
  316. g_HookChainsMap.GetNextAssoc(
  317. posChains, hWndHooked, pHookChains );
  318. ASSERT( hWndHooked != NULL );
  319. ASSERT( pHookChains != NULL );
  320. // __try
  321. // {
  322. INT nOwnIdx = pHookChains->m_HookSinkArray.Find( this );
  323. if( nOwnIdx < 0 )
  324. continue;
  325. pHookChains->m_HookSinkArray.RemoveAt( nOwnIdx );
  326. // }
  327. // __except( EXCEPTION_EXECUTE_HANDLER )
  328. // {
  329. // }
  330. } // for( ; pos != NULL; )
  331. }
  333. LRESULT CExtHookSink::OnHookWndMsgNextProcInvoke(
  334. UINT nMessage,
  335. WPARAM wParam,
  336. LPARAM lParam
  337. )
  338. {
  339. MSG & msgCurrMfc = AfxGetThreadState()->m_lastSentMsg;
  340. ASSERT( msgCurrMfc.hwnd != NULL );
  341. ASSERT( ::IsWindow( msgCurrMfc.hwnd ) );
  343. CExtHookSink::HookChains_t * pHookChains = NULL;
  344. VERIFY(
  345. g_HookChainsMap.Lookup(
  346. msgCurrMfc.hwnd,
  347. pHookChains
  348. )
  349. );
  350. ASSERT( pHookChains != NULL );
  351. ASSERT( pHookChains->m_hWndHooked == msgCurrMfc.hwnd );
  352. ASSERT( pHookChains->m_pWNDPROC != NULL );
  354. return
  355. ::CallWindowProc(
  356. pHookChains->m_pWNDPROC,
  357. msgCurrMfc.hwnd,
  358. nMessage,
  359. wParam,
  360. lParam
  361. );
  362. }
  364. LRESULT CExtHookSink::OnHookWndMsgNextProcCurrent(
  365. WPARAM wParam,
  366. LPARAM lParam
  367. )
  368. {
  369. MSG & msgCurrMfc = AfxGetThreadState()->m_lastSentMsg;
  370. ASSERT( msgCurrMfc.hwnd != NULL );
  371. ASSERT( ::IsWindow( msgCurrMfc.hwnd ) );
  373. CExtHookSink::HookChains_t * pHookChains = NULL;
  374. VERIFY(
  375. g_HookChainsMap.Lookup(
  376. msgCurrMfc.hwnd,
  377. pHookChains
  378. )
  379. );
  380. ASSERT( pHookChains != NULL );
  381. ASSERT( pHookChains->m_hWndHooked == msgCurrMfc.hwnd );
  382. ASSERT( pHookChains->m_pWNDPROC != NULL );
  384. return
  385. ::CallWindowProc(
  386. pHookChains->m_pWNDPROC,
  387. msgCurrMfc.hwnd,
  388. msgCurrMfc.message,
  389. wParam,
  390. lParam
  391. );
  392. }
  394. LRESULT CExtHookSink::OnHookWndMsgDefault()
  395. {
  396. MSG & msgCurrMfc = AfxGetThreadState()->m_lastSentMsg;
  397. ASSERT( msgCurrMfc.hwnd != NULL );
  398. ASSERT( ::IsWindow( msgCurrMfc.hwnd ) );
  400. CExtHookSink::HookChains_t * pHookChains = NULL;
  401. VERIFY(
  402. g_HookChainsMap.Lookup(
  403. msgCurrMfc.hwnd,
  404. pHookChains
  405. )
  406. );
  407. ASSERT( pHookChains != NULL );
  408. ASSERT( pHookChains->m_hWndHooked == msgCurrMfc.hwnd );
  409. ASSERT( pHookChains->m_pWNDPROC != NULL );
  411. return
  412. ::CallWindowProc(
  413. pHookChains->m_pWNDPROC,
  414. msgCurrMfc.hwnd,
  415. msgCurrMfc.message,
  416. msgCurrMfc.wParam,
  417. msgCurrMfc.lParam
  418. );
  419. }
  421. bool CExtHookSink::OnHookWndMsg(
  422. LRESULT & lResult,
  423. HWND hWndHooked,
  424. UINT nMessage,
  425. WPARAM & wParam,
  426. LPARAM & lParam
  427. )
  428. {
  429. lResult;
  430. hWndHooked;
  431. nMessage;
  432. wParam;
  433. lParam;
  435. if( ! m_bEnableDetailedWndHooks )
  436. return false;
  438. switch( nMessage )
  439. {
  440. case WM_COMMAND:
  441. return
  442. OnHookCmdMsg(
  443. lResult,
  444. hWndHooked,
  445. HIWORD(wParam),
  446. LOWORD(wParam),
  447. (HWND)lParam
  448. );
  449. case WM_NOTIFY:
  450. return
  451. OnHookNotifyMsg(
  452. lResult,
  453. hWndHooked,
  454. (INT)wParam,
  455. (LPNMHDR)lParam
  456. );
  457. case WM_PAINT:
  458. return
  459. OnHookPaintMsg(
  460. lResult,
  461. hWndHooked,
  462. (HDC)wParam
  463. );
  464. case WM_ERASEBKGND:
  465. return
  466. OnHookEraseBackgroundMsg(
  467. lResult,
  468. hWndHooked,
  469. (HDC)wParam
  470. );
  471. case WM_PRINT:
  472. case WM_PRINTCLIENT:
  473. return
  474. OnHookPrintMsg(
  475. lResult,
  476. hWndHooked,
  477. (HDC)wParam
  478. );
  479. case WM_NCPAINT:
  480. return
  481. OnHookNcPaintMsg(
  482. lResult,
  483. hWndHooked,
  484. (HRGN)wParam
  485. );
  486. } // switch( nMessage )
  488. return false;
  489. }
  491. void CExtHookSink::OnPostHookWndMsg(
  492. LRESULT lResult,
  493. HWND hWndHooked,
  494. UINT nMessage,
  495. WPARAM wParam,
  496. LPARAM lParam
  497. )
  498. {
  499. lResult;
  500. hWndHooked;
  501. nMessage;
  502. wParam;
  503. lParam;
  504. }
  506. bool CExtHookSink::OnHookCmdMsg(
  507. LRESULT & lResult,
  508. HWND hWndHooked,
  509. WORD wNotifyCode,
  510. WORD wID,
  511. HWND hWndCtrl
  512. )
  513. {
  514. lResult;
  515. hWndHooked;
  516. wNotifyCode;
  517. wID;
  518. hWndCtrl;
  520. return false;
  521. }
  523. bool CExtHookSink::OnHookNotifyMsg(
  524. LRESULT & lResult,
  525. HWND hWndHooked,
  526. INT nIdCtrl,
  527. LPNMHDR lpnmhdr
  528. )
  529. {
  530. lResult;
  531. hWndHooked;
  532. nIdCtrl;
  533. lpnmhdr;
  535. return false;
  536. }
  538. bool CExtHookSink::OnHookPaintMsg(
  539. LRESULT & lResult,
  540. HWND hWndHooked,
  541. HDC hDC
  542. )
  543. {
  544. lResult;
  545. hWndHooked;
  546. hDC;
  548. return false;
  549. }
  551. bool CExtHookSink::OnHookEraseBackgroundMsg(
  552. LRESULT & lResult,
  553. HWND hWndHooked,
  554. HDC hDC
  555. )
  556. {
  557. lResult;
  558. hWndHooked;
  559. hDC;
  561. return false;
  562. }
  564. bool CExtHookSink::OnHookPrintMsg(
  565. LRESULT & lResult,
  566. HWND hWndHooked,
  567. HDC hDC
  568. )
  569. {
  570. lResult;
  571. hWndHooked;
  572. hDC;
  574. return false;
  575. }
  577. bool CExtHookSink::OnHookNcPaintMsg(
  578. LRESULT & lResult,
  579. HWND hWndHooked,
  580. HRGN hRgnUpdate
  581. )
  582. {
  583. lResult;
  584. hWndHooked;
  585. hRgnUpdate;
  587. return false;
  588. }
  590. void CExtHookSink::OnHookWndNcDestroy()
  591. {
  592. }
  594. void CExtHookSink::OnHookWndAttach( HWND hWnd )
  595. {
  596. ASSERT( hWnd != NULL );
  597. hWnd;
  598. }
  600. void CExtHookSink::OnHookWndDetach( HWND hWnd )
  601. {
  602. ASSERT( hWnd != NULL );
  603. hWnd;
  604. }
  606. bool CExtHookSink::IsAutoDeleteHookWndSink()
  607. {
  608. return false;
  609. }
  611. bool CExtHookSink::SetupHookWndSink(
  612. HWND hWnd,
  613. bool bRemove, // = false
  614. bool bAddToHead // = false
  615. )
  616. {
  617. ASSERT( hWnd != NULL );
  618. if( hWnd == NULL )
  619. return false;
  621. ASSERT( bRemove || (!bRemove && ::IsWindow(hWnd)) );
  622. if( (!bRemove) && (!::IsWindow(hWnd) ) )
  623. return false;
  625. CExtHookSink::HookChains_t * pHookChains = NULL;
  626. if( !g_HookChainsMap.Lookup( hWnd, pHookChains ) )
  627. {
  628. ASSERT( pHookChains == NULL );
  629. }
  630. else
  631. {
  632. ASSERT( pHookChains != NULL );
  633. }
  635. if( bRemove )
  636. {
  637. if( pHookChains == NULL )
  638. return true;
  639. INT pos =
  640. pHookChains->m_HookSinkArray.Find( this );
  641. if( pos < 0 )
  642. return true;
  644. OnHookWndDetach( hWnd );
  646. pHookChains->m_HookSinkArray.RemoveAt( pos );
  647. if( IsAutoDeleteHookWndSink() )
  648. delete this;
  650. if( pHookChains->m_HookSinkArray.GetSize() == 0 )
  651. pHookChains->DestroyChains( true );
  653. return true;
  654. } // if( bRemove )
  656. if( pHookChains == NULL )
  657. {
  658. pHookChains =
  659. new CExtHookSink::HookChains_t( hWnd );
  660. g_HookChainsMap.SetAt( hWnd, pHookChains );
  661. } // if( pHookChains == NULL )
  662. else
  663. {
  664. INT pos =
  665. pHookChains->m_HookSinkArray.Find( this );
  666. if( pos >= 0 )
  667. return true;
  668. } // else from if( pHookChains == NULL )
  670. if( bAddToHead )
  671. pHookChains->m_HookSinkArray.AddHead( this );
  672. else
  673. pHookChains->m_HookSinkArray.AddTail( this );
  675. OnHookWndAttach( hWnd );
  677. return true;
  678. }
  680. ULONG CExtHookSink::SetupHookWndSinkToChilds(
  681. HWND hWnd,
  682. UINT * pDlgCtrlIDs, // = NULL
  683. ULONG nCountOfDlgCtrlIDs, // = 0
  684. bool bDeep // = false
  685. )
  686. {
  687. ASSERT( hWnd != NULL );
  688. if( hWnd == NULL )
  689. return 0;
  691. ASSERT( ::IsWindow(hWnd) );
  692. if( !::IsWindow(hWnd) )
  693. return 0;
  694. ULONG nCountOfHooks = 0;
  695. hWnd = ::GetWindow( hWnd, GW_CHILD );
  696. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  697. {
  698. ASSERT(
  699. (nCountOfDlgCtrlIDs == 0 && pDlgCtrlIDs == NULL)
  700. || (nCountOfDlgCtrlIDs > 0 && pDlgCtrlIDs != NULL)
  701. );
  702. bool bSetupHook = true;
  703. if( nCountOfDlgCtrlIDs > 0 && pDlgCtrlIDs != NULL )
  704. {
  705. bSetupHook = false;
  706. UINT nDlgCtrlID = ::GetDlgCtrlID( hWnd );
  707. for( ULONG i=0; i<nCountOfDlgCtrlIDs; i++ )
  708. {
  709. if( pDlgCtrlIDs[i] == nDlgCtrlID )
  710. {
  711. bSetupHook = true;
  712. break;
  713. }
  714. } // for( ULONG i=0; i<nCountOfDlgCtrlIDs; i++ )
  715. } // if( nCountOfDlgCtrlIDs > 0 && pDlgCtrlIDs != NULL )
  716. if( bSetupHook )
  717. {
  718. if( SetupHookWndSink( hWnd ) )
  719. nCountOfHooks++;
  720. else
  721. {
  722. ASSERT( FALSE );
  723. }
  724. } // if( bSetupHook )
  725. if( bDeep )
  726. nCountOfHooks +=
  727. SetupHookWndSinkToChilds(
  728. hWnd,
  729. pDlgCtrlIDs,
  730. nCountOfDlgCtrlIDs,
  731. bDeep
  732. );
  733. } // for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  734. return nCountOfHooks;
  735. }
  737. void CExtHookSink::RemoveAllWndHooks()
  738. {
  739. HookedWndList_t _list;
  740. GetHookedWindows( _list );
  741. POSITION pos = _list.GetHeadPosition();
  742. for( int nHwndIdx = 0; nHwndIdx < _list.GetCount(); nHwndIdx++ )
  743. {
  744. HWND hWndHooked = _list.GetNext( pos );
  745. VERIFY( SetupHookWndSink( hWndHooked, true ) );
  746. } // for( int nHwndIdx = 0; nHwndIdx < _list.GetCount(); nHwndIdx++ )
  747. }
  749. void CExtHookSink::GetHookedWindows( HookedWndList_t & _list )
  750. {
  751. _list.RemoveAll();
  752. POSITION posChains = g_HookChainsMap.GetStartPosition();
  753. for( ; posChains != NULL; )
  754. {
  755. CExtHookSink::HookChains_t * pHookChains = NULL;
  756. HWND hWndHooked = NULL;
  757. g_HookChainsMap.GetNextAssoc(
  758. posChains, hWndHooked, pHookChains );
  759. ASSERT( hWndHooked != NULL );
  760. ASSERT( pHookChains != NULL );
  761. ASSERT( pHookChains->m_hWndHooked == hWndHooked );
  762. if( pHookChains->m_HookSinkArray.Find(this) < 0 )
  763. continue;
  764. ASSERT( _list.Find(pHookChains->m_hWndHooked) == NULL );
  765. _list.AddTail( pHookChains->m_hWndHooked );
  766. } // for( ; pos != NULL; )
  767. }
  769. bool CExtHookSink::IsHookedWindow( HWND hWnd )
  770. {
  771. CExtHookSink::HookChains_t * pHookChains = NULL;
  772. if( !g_HookChainsMap.Lookup( hWnd, pHookChains ) )
  773. return false;
  774. ASSERT( pHookChains != NULL );
  775. ASSERT( pHookChains->m_hWndHooked == hWnd );
  776. if( pHookChains->m_HookSinkArray.Find(this) >= 0 )
  777. return true;
  778. return false;
  779. }
  781. CExtHookSpy::HookSpyItem_t CExtHookSpy::g_arr[ __EHS_IDX_COUNT ] =
  782. {
  783. __EHSEF_MOUSE_ALL,
  784. __EHSEF_KEYBOARD,
  785. __EHSEF_GET_MSG,
  786. __EHSEF_SYS_MSG,
  787. __EHSEF_WND_PROC_IN,
  788. __EHSEF_WND_PROC_OUT,
  789. };
  791. CExtHookSpy::HookSpyItem_t::HookSpyItem_t( DWORD dwEHSEF )
  792. : m_hHook( NULL )
  793. , m_bListChanged( false )
  794. , m_dwEHSEF( dwEHSEF )
  795. {
  796. }
  798. bool CExtHookSpy::HookSpyItem_t::IsRegistered( CExtHookSpy * pHS, DWORD dwEHSEF )
  799. {
  800. dwEHSEF;
  801. bool bVal = false;
  802. bool bRetVal = m_map.Lookup( pHS, bVal ) ? true : false;
  804. /*
  805. #if (defined _DEBUG)
  806. DWORD dwEffectiveEHSEF = dwEHSEF & m_dwEHSEF;
  807. DWORD dwCurrentEHSEF = pHS->HookSpyGetEHSEF();
  808. DWORD dwCheckEHSEF = dwCurrentEHSEF & __EHSEF_BASIC_HOOK_FILTERING;
  809. if( bRetVal )
  810. {
  811. ASSERT( ( dwCheckEHSEF & dwEffectiveEHSEF ) != 0 );
  812. ASSERT( m_list.Find( pHS ) != NULL );
  813. }
  814. else
  815. {
  816. ASSERT( ( dwCheckEHSEF & dwEffectiveEHSEF ) == 0 );
  817. ASSERT( m_list.Find( pHS ) == NULL );
  818. }
  819. #endif // (defined _DEBUG)
  820. */
  822. return bRetVal;
  823. }
  825. void CExtHookSpy::HookSpyItem_t::Register( CExtHookSpy * pHS, DWORD dwEHSEF, bool bAddToHead )
  826. {
  827. if( pHS == NULL )
  828. return;
  829. DWORD dwEffectiveEHSEF = dwEHSEF & m_dwEHSEF;
  830. if( dwEffectiveEHSEF == 0 )
  831. return;
  832. bool bRegistered = IsRegistered( pHS, m_dwEHSEF );
  833. pHS->HookSpyModifyEHSEF( 0, dwEffectiveEHSEF );
  834. if( bRegistered )
  835. return;
  836. INT nPrevRegisteredCount = INT( m_list.GetCount() );
  837. ASSERT( nPrevRegisteredCount >= 0 );
  838. if( bAddToHead )
  839. m_list.AddHead( pHS );
  840. else
  841. m_list.AddTail( pHS );
  842. m_map.SetAt( pHS, false );
  843. m_bListChanged = true;
  844. ASSERT( (nPrevRegisteredCount+1) == INT( m_list.GetCount() ) );
  845. ASSERT( (nPrevRegisteredCount+1) == INT( m_map.GetCount() ) );
  846. if( nPrevRegisteredCount == 0 )
  847. Hook( true );
  848. }
  850. void CExtHookSpy::HookSpyItem_t::Unregister( CExtHookSpy * pHS, DWORD dwEHSEF )
  851. {
  852. if( pHS == NULL || ( m_dwEHSEF & dwEHSEF ) == 0 )
  853. return;
  854. #if (defined _DEBUG)
  855. bool bRegistered = IsRegistered( pHS, m_dwEHSEF );
  856. #endif // (defined _DEBUG)
  857. if( ( pHS->HookSpyGetEHSEF() & m_dwEHSEF ) == 0 )
  858. {
  859. ASSERT( ! bRegistered );
  860. return;
  861. }
  862. ASSERT( bRegistered );
  863. DWORD dwEffectiveEHSEF = dwEHSEF & m_dwEHSEF;
  864. pHS->HookSpyModifyEHSEF( dwEffectiveEHSEF, 0 );
  865. if( ( pHS->HookSpyGetEHSEF() & m_dwEHSEF ) != 0 )
  866. return;
  867. POSITION pos = m_list.Find( pHS );
  868. ASSERT( pos != NULL );
  869. m_list.RemoveAt( pos );
  870. m_map.RemoveKey( pHS );
  871. m_bListChanged = true;
  872. INT nRegisteredCount = INT( m_list.GetCount() );
  873. ASSERT( nRegisteredCount >= 0 );
  874. ASSERT( nRegisteredCount == INT( m_map.GetCount() ) );
  875. if( nRegisteredCount == 0 )
  876. Hook( false );
  877. }
  879. void CExtHookSpy::HookSpyItem_t::Hook( bool bHook )
  880. {
  881. if( bHook )
  882. {
  883. if( m_hHook != NULL )
  884. return;
  885. if( ( m_dwEHSEF & __EHSEF_MOUSE_ALL ) != 0 )
  886. {
  887. m_hHook =
  888. ::SetWindowsHookEx(
  889. WH_MOUSE,
  890. SHS_HookMouseProc, 
  891. 0,
  892. ::GetCurrentThreadId()
  893. );
  894. // ASSERT( m_hHook != NULL );
  895. }
  896. else
  897. if( ( m_dwEHSEF & __EHSEF_KEYBOARD ) != 0 )
  898. {
  899. m_hHook =
  900. ::SetWindowsHookEx(
  901. WH_KEYBOARD,
  902. SHS_HookKeyboardProc, 
  903. 0,
  904. ::GetCurrentThreadId()
  905. );
  906. // ASSERT( m_hHook != NULL );
  907. }
  908. else
  909. if( ( m_dwEHSEF & __EHSEF_GET_MSG ) != 0 )
  910. {
  911. m_hHook =
  912. ::SetWindowsHookEx(
  913. WH_GETMESSAGE,
  914. SHS_HookGetMsgProc, 
  915. 0,
  916. ::GetCurrentThreadId()
  917. );
  918. // ASSERT( m_hHook != NULL );
  919. }
  920. else
  921. if( ( m_dwEHSEF & __EHSEF_SYS_MSG ) != 0 )
  922. {
  923. m_hHook =
  924. ::SetWindowsHookEx(
  925. WH_SYSMSGFILTER,
  926. SHS_HookSysMsgProc, 
  927. 0,
  928. ::GetCurrentThreadId()
  929. );
  930. // ASSERT( m_hHook != NULL );
  931. }
  932. else
  933. if( ( m_dwEHSEF & __EHSEF_WND_PROC_IN ) != 0 )
  934. {
  935. m_hHook =
  936. ::SetWindowsHookEx(
  937. WH_CALLWNDPROC,
  938. SHS_HookCallWindowProcIn, 
  939. 0,
  940. ::GetCurrentThreadId()
  941. );
  942. // ASSERT( m_hHook != NULL );
  943. }
  944. else
  945. if( ( m_dwEHSEF & __EHSEF_WND_PROC_OUT ) != 0 )
  946. {
  947. m_hHook =
  948. ::SetWindowsHookEx(
  949. WH_CALLWNDPROCRET,
  950. SHS_HookCallWindowProcOut, 
  951. 0,
  952. ::GetCurrentThreadId()
  953. );
  954. // ASSERT( m_hHook != NULL );
  955. }
  956. #if (defined _DEBUG)
  957. else
  958. {
  959. ASSERT( FALSE );
  960. }
  961. #endif // (defined _DEBUG)
  962. } // if( bHook )
  963. else
  964. {
  965. if( m_hHook == NULL )
  966. return;
  967. ::UnhookWindowsHookEx( m_hHook );
  968. m_hHook = NULL;
  969. } // else from if( bHook )
  970. }
  972. CExtHookSpy::CExtHookSpy(
  973. DWORD dwEHSEF // = 0 // auto-register flags, zero - unregister
  974. )
  975. : m_bHookConvertLocationsToClient( false )
  976. , m_dwEHSEF( 0 )
  977. {
  978. if( dwEHSEF != 0 )
  979. HookSpyRegister( dwEHSEF );
  980. }
  982. CExtHookSpy::~CExtHookSpy()
  983. {
  984. HookSpyUnregister();
  985. }
  987. LRESULT CALLBACK CExtHookSpy::HookSpyItem_t::SHS_HookMouseProc(
  988. int nCode,      // hook code
  989. WPARAM wParam,  // message identifier
  990. LPARAM lParam   // mouse coordinates
  991. )
  992. {
  993. __PROF_UIS_MANAGE_STATE;
  994. MOUSEHOOKSTRUCT * lpMS = (MOUSEHOOKSTRUCT*)lParam;
  995. ASSERT( lpMS != NULL );
  996. if( nCode == HC_ACTION )
  997. {
  998. POSITION pos = g_arr[__EHS_IDX_MOUSE].m_list.GetHeadPosition();
  999. for( g_arr[__EHS_IDX_MOUSE].m_bListChanged = false; pos != NULL; )
  1000. {
  1001. CExtHookSpy * pHS = g_arr[__EHS_IDX_MOUSE].m_list.GetNext( pos );
  1002. ASSERT( pHS != NULL );
  1003. DWORD dwEHSEF = pHS->HookSpyGetEHSEF();
  1004. if( (  dwEHSEF & __EHSEF_MOUSE_ALL ) == 0 )
  1005. continue;
  1006. bool bNC = false;
  1007. switch( wParam )
  1008. {
  1009. case WM_NCMOUSEMOVE:
  1010. bNC = true;
  1011. case WM_MOUSEMOVE:
  1012. if( (  dwEHSEF & ( bNC ? __EHSEF_MOUSE_MOVE_NC : __EHSEF_MOUSE_MOVE ) ) == 0 )
  1013. continue;
  1014. else
  1015. {
  1016. CPoint point = lpMS->pt; // screen coordinates
  1017. if( pHS->m_bHookConvertLocationsToClient && (! bNC ) )
  1018. ::ScreenToClient( lpMS->hwnd, &point );
  1019. if( pHS->
  1020. HSLL_OnMouseMove(
  1021. lpMS->hwnd,
  1022. 0, // wParam,
  1023. point
  1024. )
  1025. )
  1026. return 1; // eat!
  1027. }
  1028. break;
  1030. case WM_MOUSEWHEEL:
  1031. if( (  dwEHSEF & __EHSEF_MOUSE_WHEEL ) == 0 )
  1032. continue;
  1033. else
  1034. if( pHS->
  1035. HSLL_OnMouseWheel(
  1036. wParam,
  1037. lParam
  1038. )
  1039. )
  1040. return 1; // eat!
  1041. break;
  1043. case WM_NCLBUTTONDBLCLK:
  1044. case WM_NCRBUTTONDBLCLK:
  1045. case WM_NCMBUTTONDBLCLK:
  1047. case WM_NCLBUTTONDOWN:
  1048. case WM_NCRBUTTONDOWN:
  1049. case WM_NCMBUTTONDOWN:
  1051. case WM_NCLBUTTONUP:
  1052. case WM_NCRBUTTONUP:
  1053. case WM_NCMBUTTONUP:
  1054. bNC = true;
  1056. case WM_LBUTTONDBLCLK:
  1057. case WM_RBUTTONDBLCLK:
  1058. case WM_MBUTTONDBLCLK:
  1060. case WM_LBUTTONDOWN:
  1061. case WM_RBUTTONDOWN:
  1062. case WM_MBUTTONDOWN:
  1064. case WM_LBUTTONUP:
  1065. case WM_RBUTTONUP:
  1066. case WM_MBUTTONUP:
  1067. if( (  dwEHSEF & ( bNC ? __EHSEF_MOUSE_CLICK_NC : __EHSEF_MOUSE_CLICK ) ) == 0 )
  1068. continue;
  1069. else
  1070. {
  1071. CPoint point = lpMS->pt; // screen coordinates
  1072. if( pHS->m_bHookConvertLocationsToClient && (! bNC ) )
  1073. ::ScreenToClient( lpMS->hwnd, &point );
  1074. if( pHS->
  1075. HSLL_OnMouseClick(
  1076. lpMS->hwnd,
  1077. UINT(wParam),
  1078. 0,
  1079. point
  1080. )
  1081. )
  1082. return 1; // eat!
  1083. }
  1084. break;
  1085. } // switch( wParam )
  1086. if( g_arr[__EHS_IDX_MOUSE].m_bListChanged )
  1087. {
  1088. g_arr[__EHS_IDX_MOUSE].m_bListChanged = false;
  1089. pos = g_arr[__EHS_IDX_MOUSE].m_list.GetHeadPosition();
  1090. } // if( g_arr[__EHS_IDX_MOUSE].m_bListChanged )
  1091. } // for( g_arr[__EHS_IDX_MOUSE].m_bListChanged = false; pos != NULL; )
  1092. g_arr[__EHS_IDX_MOUSE].m_bListChanged = false;
  1093. } // if( nCode == HC_ACTION )
  1094. return ::CallNextHookEx( g_arr[__EHS_IDX_MOUSE].m_hHook, nCode, wParam, lParam );
  1095. }
  1097. LRESULT CALLBACK CExtHookSpy::HookSpyItem_t::SHS_HookKeyboardProc(
  1098. int nCode,      // hook code
  1099. WPARAM wParam,  // virtual-key code
  1100. LPARAM lParam   // keystroke-message information
  1101. )
  1102. {
  1103. __PROF_UIS_MANAGE_STATE;
  1104. if( nCode == HC_ACTION )
  1105. {
  1106. POSITION pos = g_arr[__EHS_IDX_KEYBOARD].m_list.GetHeadPosition();
  1107. for( g_arr[__EHS_IDX_KEYBOARD].m_bListChanged = false; pos != NULL; )
  1108. {
  1109. CExtHookSpy * pHS = g_arr[__EHS_IDX_KEYBOARD].m_list.GetNext( pos );
  1110. ASSERT( pHS != NULL );
  1111. DWORD dwEHSEF = pHS->HookSpyGetEHSEF();
  1112. if( (  dwEHSEF & __EHSEF_KEYBOARD ) == 0 )
  1113. continue;
  1114. if( pHS->
  1115. HSLL_OnKey(
  1116. UINT(wParam),
  1117. LOWORD(lParam),
  1118. HIWORD(lParam)
  1119. )
  1120. )
  1121. return 1; // eat!
  1122. if( g_arr[__EHS_IDX_KEYBOARD].m_bListChanged )
  1123. {
  1124. g_arr[__EHS_IDX_KEYBOARD].m_bListChanged = false;
  1125. pos = g_arr[__EHS_IDX_KEYBOARD].m_list.GetHeadPosition();
  1126. } // if( g_arr[__EHS_IDX_KEYBOARD].m_bListChanged )
  1127. } // for( g_arr[__EHS_IDX_KEYBOARD].m_bListChanged = false; pos != NULL; )
  1128. g_arr[__EHS_IDX_KEYBOARD].m_bListChanged = false;
  1129. } // if( nCode == HC_ACTION )
  1130. return ::CallNextHookEx( g_arr[__EHS_IDX_KEYBOARD].m_hHook, nCode, wParam, lParam );
  1131. }
  1133. LRESULT CALLBACK CExtHookSpy::HookSpyItem_t::SHS_HookGetMsgProc(
  1134. int nCode,
  1135. WPARAM wParam,
  1136. LPARAM lParam
  1137. )
  1138. {
  1139. __PROF_UIS_MANAGE_STATE;
  1140. POSITION pos = g_arr[__EHS_IDX_GET_MSG].m_list.GetHeadPosition();
  1141. for( g_arr[__EHS_IDX_GET_MSG].m_bListChanged = false; pos != NULL; )
  1142. {
  1143. CExtHookSpy * pHS = g_arr[__EHS_IDX_GET_MSG].m_list.GetNext( pos );
  1144. ASSERT( pHS != NULL );
  1145. DWORD dwEHSEF = pHS->HookSpyGetEHSEF();
  1146. if( (  dwEHSEF & __EHSEF_GET_MSG ) == 0 )
  1147. continue;
  1148. LRESULT lResult = 0;
  1149. bool bCallNextHook = true;
  1150. if( pHS->
  1151. HSLL_OnGetMsgProc(
  1152. bCallNextHook,
  1153. lResult,
  1154. nCode,
  1155. wParam,
  1156. (MSG*)lParam
  1157. )
  1158. )
  1159. {
  1160. if( bCallNextHook )
  1161. return ::CallNextHookEx( g_arr[__EHS_IDX_GET_MSG].m_hHook, nCode, wParam, lParam );
  1162. else
  1163. return lResult; // eat!
  1164. }
  1165. if( g_arr[__EHS_IDX_GET_MSG].m_bListChanged )
  1166. {
  1167. g_arr[__EHS_IDX_GET_MSG].m_bListChanged = false;
  1168. pos = g_arr[__EHS_IDX_GET_MSG].m_list.GetHeadPosition();
  1169. } // if( g_arr[__EHS_IDX_GET_MSG].m_bListChanged )
  1170. } // for( g_arr[__EHS_IDX_GET_MSG].m_bListChanged = false; pos != NULL; )
  1171. g_arr[__EHS_IDX_GET_MSG].m_bListChanged = false;
  1172. return ::CallNextHookEx( g_arr[__EHS_IDX_GET_MSG].m_hHook, nCode, wParam, lParam );
  1173. }
  1175. LRESULT CALLBACK CExtHookSpy::HookSpyItem_t::SHS_HookSysMsgProc(
  1176. int nCode,
  1177. WPARAM wParam,
  1178. LPARAM lParam
  1179. )
  1180. {
  1181. __PROF_UIS_MANAGE_STATE;
  1182. POSITION pos = g_arr[__EHS_IDX_SYS_MSG].m_list.GetHeadPosition();
  1183. for( g_arr[__EHS_IDX_SYS_MSG].m_bListChanged = false; pos != NULL; )
  1184. {
  1185. CExtHookSpy * pHS = g_arr[__EHS_IDX_SYS_MSG].m_list.GetNext( pos );
  1186. ASSERT( pHS != NULL );
  1187. DWORD dwEHSEF = pHS->HookSpyGetEHSEF();
  1188. if( (  dwEHSEF & __EHSEF_SYS_MSG ) == 0 )
  1189. continue;
  1190. LRESULT lResult = 0;
  1191. bool bCallNextHook = true;
  1192. if( pHS->
  1193. HSLL_OnSysMsgProc(
  1194. bCallNextHook,
  1195. lResult,
  1196. nCode,
  1197. wParam,
  1198. lParam
  1199. )
  1200. )
  1201. {
  1202. if( bCallNextHook )
  1203. return ::CallNextHookEx( g_arr[__EHS_IDX_SYS_MSG].m_hHook, nCode, wParam, lParam );
  1204. else
  1205. return lResult; // eat!
  1206. }
  1207. if( g_arr[__EHS_IDX_SYS_MSG].m_bListChanged )
  1208. {
  1209. g_arr[__EHS_IDX_SYS_MSG].m_bListChanged = false;
  1210. pos = g_arr[__EHS_IDX_SYS_MSG].m_list.GetHeadPosition();
  1211. } // if( g_arr[__EHS_IDX_SYS_MSG].m_bListChanged )
  1212. } // for( g_arr[__EHS_IDX_SYS_MSG].m_bListChanged = false; pos != NULL; )
  1213. g_arr[__EHS_IDX_SYS_MSG].m_bListChanged = false;
  1214. return ::CallNextHookEx( g_arr[__EHS_IDX_SYS_MSG].m_hHook, nCode, wParam, lParam );
  1215. }
  1217. LRESULT CALLBACK CExtHookSpy::HookSpyItem_t::SHS_HookCallWindowProcIn(
  1218. int nCode,
  1219. WPARAM wParam,
  1220. LPARAM lParam
  1221. )
  1222. {
  1223. __PROF_UIS_MANAGE_STATE;
  1224. POSITION pos = g_arr[__EHS_IDX_WND_PROC_IN].m_list.GetHeadPosition();
  1225. for( g_arr[__EHS_IDX_WND_PROC_IN].m_bListChanged = false; pos != NULL; )
  1226. {
  1227. CExtHookSpy * pHS = g_arr[__EHS_IDX_WND_PROC_IN].m_list.GetNext( pos );
  1228. ASSERT( pHS != NULL );
  1229. DWORD dwEHSEF = pHS->HookSpyGetEHSEF();
  1230. if( (  dwEHSEF & __EHSEF_WND_PROC_IN ) == 0 )
  1231. continue;
  1232. LRESULT lResult = 0;
  1233. bool bCallNextHook = true;
  1234. if( pHS->
  1235. HSLL_OnCallWindowProcIn(
  1236. bCallNextHook,
  1237. lResult,
  1238. nCode,
  1239. ( wParam != 0 ) ? true : false,
  1240. (PCWPSTRUCT)lParam
  1241. )
  1242. )
  1243. {
  1244. if( bCallNextHook )
  1245. return ::CallNextHookEx( g_arr[__EHS_IDX_WND_PROC_IN].m_hHook, nCode, wParam, lParam );
  1246. else
  1247. return lResult; // eat!
  1248. }
  1249. if( g_arr[__EHS_IDX_WND_PROC_IN].m_bListChanged )
  1250. {
  1251. g_arr[__EHS_IDX_WND_PROC_IN].m_bListChanged = false;
  1252. pos = g_arr[__EHS_IDX_WND_PROC_IN].m_list.GetHeadPosition();
  1253. } // if( g_arr[__EHS_IDX_WND_PROC_IN].m_bListChanged )
  1254. } // for( g_arr[__EHS_IDX_WND_PROC_IN].m_bListChanged = false; pos != NULL; )
  1255. g_arr[__EHS_IDX_WND_PROC_IN].m_bListChanged = false;
  1256. return ::CallNextHookEx( g_arr[__EHS_IDX_WND_PROC_IN].m_hHook, nCode, wParam, lParam );
  1257. }
  1259. LRESULT CALLBACK CExtHookSpy::HookSpyItem_t::SHS_HookCallWindowProcOut(
  1260. int nCode,
  1261. WPARAM wParam,
  1262. LPARAM lParam
  1263. )
  1264. {
  1265. __PROF_UIS_MANAGE_STATE;
  1266. POSITION pos = g_arr[__EHS_IDX_WND_PROC_OUT].m_list.GetHeadPosition();
  1267. for( g_arr[__EHS_IDX_WND_PROC_OUT].m_bListChanged = false; pos != NULL; )
  1268. {
  1269. CExtHookSpy * pHS = g_arr[__EHS_IDX_WND_PROC_OUT].m_list.GetNext( pos );
  1270. ASSERT( pHS != NULL );
  1271. DWORD dwEHSEF = pHS->HookSpyGetEHSEF();
  1272. if( (  dwEHSEF & __EHSEF_WND_PROC_OUT ) == 0 )
  1273. continue;
  1274. LRESULT lResult = 0;
  1275. bool bCallNextHook = true;
  1276. if( pHS->
  1277. HSLL_OnCallWindowProcOut(
  1278. bCallNextHook,
  1279. lResult,
  1280. nCode,
  1281. ( wParam != 0 ) ? true : false,
  1282. (PCWPRETSTRUCT)lParam
  1283. )
  1284. )
  1285. {
  1286. if( bCallNextHook )
  1287. return ::CallNextHookEx( g_arr[__EHS_IDX_WND_PROC_OUT].m_hHook, nCode, wParam, lParam );
  1288. else
  1289. return lResult; // eat!
  1290. }
  1291. if( g_arr[__EHS_IDX_WND_PROC_OUT].m_bListChanged )
  1292. {
  1293. g_arr[__EHS_IDX_WND_PROC_OUT].m_bListChanged = false;
  1294. pos = g_arr[__EHS_IDX_WND_PROC_OUT].m_list.GetHeadPosition();
  1295. } // if( g_arr[__EHS_IDX_WND_PROC_OUT].m_bListChanged )
  1296. } // for( g_arr[__EHS_IDX_WND_PROC_OUT].m_bListChanged = false; pos != NULL; )
  1297. g_arr[__EHS_IDX_WND_PROC_OUT].m_bListChanged = false;
  1298. return ::CallNextHookEx( g_arr[__EHS_IDX_WND_PROC_OUT].m_hHook, nCode, wParam, lParam );
  1299. }
  1301. bool CExtHookSpy::HSLL_OnMouseWheel(
  1302. WPARAM wParam,
  1303. LPARAM lParam
  1304. )
  1305. {
  1306. wParam;
  1307. if( ! g_PaintManager.m_bIsWin2000orLater )
  1308. return false;
  1309. struct __SAME_AS_MOUSEHOOKSTRUCTEX
  1310. {
  1311. MOUSEHOOKSTRUCT mhs;
  1312. DWORD mouseData;
  1313. };
  1314. __SAME_AS_MOUSEHOOKSTRUCTEX * pMHEX =
  1315. reinterpret_cast
  1316. < __SAME_AS_MOUSEHOOKSTRUCTEX * >
  1317. ( lParam );
  1318. ASSERT( pMHEX != NULL );
  1319. DWORD dwWheelDeltaAndZeroFlags =
  1320. DWORD( pMHEX->mouseData ) & 0xFFFF0000;
  1321. MSG _msg;
  1322. ::memset( &_msg, 0, sizeof(MSG) );
  1323. _msg.hwnd = pMHEX->mhs.hwnd;
  1324. _msg.wParam = WPARAM(dwWheelDeltaAndZeroFlags);
  1325. _msg.lParam = MAKELPARAM(pMHEX->mhs.pt.x,pMHEX->mhs.pt.y);
  1326. _msg.message = WM_MOUSEWHEEL;
  1327. // TRACE1( "wheel_msg = %xn", _msg.message );
  1328. DWORD dwEHSEF = HookSpyGetEHSEF();
  1329. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1330. {
  1331. if( HSLL_PreTranslateMessage( &_msg ) )
  1332. return true;
  1333. if( ! HookSpyIsRegistered() )
  1334. return false;
  1335. }
  1336. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1337. {
  1338. if( OnHookSpyPreTranslateMessage( &_msg ) )
  1339. return true;
  1340. if( ! HookSpyIsRegistered() )
  1341. return false;
  1342. }
  1343. if( OnHookSpyMouseWheelMsg( &_msg ) )
  1344. return true;
  1345. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1346. {
  1347. if( OnHookSpyPostProcessMessage( &_msg ) )
  1348. return true;
  1349. }
  1350. return false;
  1351. }
  1353. bool CExtHookSpy::HSLL_OnMouseMove(
  1354. HWND hWnd,
  1355. UINT nFlags,
  1356. CPoint point
  1357. )
  1358. {
  1359. if( hWnd == NULL
  1360. || (! ::IsWindow(hWnd) )
  1361. || (! ::GetCursorPos(&point) ) 
  1362. )
  1363. return false;
  1364. ::ScreenToClient( hWnd, &point );
  1365. MSG _msg;
  1366. ::memset( &_msg, 0, sizeof(MSG) );
  1367. _msg.hwnd = hWnd;
  1368. _msg.wParam = WPARAM(nFlags);
  1369. _msg.lParam = MAKELPARAM( point.x, point.y );
  1370. _msg.message = WM_MOUSEMOVE;
  1371. _msg.pt = point;
  1372. DWORD dwEHSEF = HookSpyGetEHSEF();
  1373. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1374. {
  1375. if( HSLL_PreTranslateMessage( &_msg ) )
  1376. return true;
  1377. if( ! HookSpyIsRegistered() )
  1378. return false;
  1379. }
  1380. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1381. {
  1382. if( OnHookSpyPreTranslateMessage( &_msg ) )
  1383. return true;
  1384. if( ! HookSpyIsRegistered() )
  1385. return false;
  1386. }
  1387. if( OnHookSpyMouseMoveMsg( &_msg ) )
  1388. return true;
  1389. if( ! HookSpyIsRegistered() )
  1390. return false;
  1391. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1392. {
  1393. if( OnHookSpyPostProcessMessage( &_msg ) )
  1394. return true;
  1395. }
  1396. return false;
  1397. }
  1399. bool CExtHookSpy::HSLL_OnMouseClick(
  1400. HWND hWnd,
  1401. UINT nMessage,
  1402. UINT nFlags,
  1403. CPoint point
  1404. )
  1405. {
  1406. MSG _msg;
  1407. ::memset( &_msg, 0, sizeof(MSG) );
  1408. _msg.hwnd = hWnd;
  1409. _msg.wParam = WPARAM(nFlags);
  1410. _msg.lParam = MAKELPARAM(point.x,point.y);
  1411. _msg.message = nMessage;
  1412. ::ScreenToClient( hWnd, &point );
  1413. _msg.pt = point;
  1414. DWORD dwEHSEF = HookSpyGetEHSEF();
  1415. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1416. {
  1417. if( HSLL_PreTranslateMessage( &_msg ) )
  1418. return true;
  1419. if( ! HookSpyIsRegistered() )
  1420. return false;
  1421. }
  1422. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1423. {
  1424. if( OnHookSpyPreTranslateMessage( &_msg ) )
  1425. return true;
  1426. if( ! HookSpyIsRegistered() )
  1427. return false;
  1428. }
  1429. if( OnHookSpyMouseClickMsg( &_msg ) )
  1430. return true;
  1431. if( ! HookSpyIsRegistered() )
  1432. return false;
  1433. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1434. {
  1435. if( OnHookSpyPostProcessMessage( &_msg ) )
  1436. return true;
  1437. }
  1438. return false;
  1439. }
  1441. bool CExtHookSpy::HSLL_OnKey(
  1442. UINT nChar,
  1443. UINT nRepCnt,
  1444. UINT nFlags
  1445. )
  1446. {
  1447. MSG _msg;
  1448. ::memset( &_msg, 0, sizeof(MSG) );
  1449. _msg.hwnd = ::GetFocus();
  1450. _msg.wParam = WPARAM(nChar);
  1451. _msg.lParam = MAKELPARAM(nRepCnt,nFlags);
  1452. _msg.message =
  1453. ( ( nFlags & (KF_UP) ) != 0 )
  1454. ? WM_KEYUP
  1455. : WM_KEYDOWN
  1456. ;
  1457. // TRACE3(
  1458. // "key_msg = %x (%s), flags = 0x%04Xn",
  1459. // _msg.message,
  1460. // (_msg.message == WM_KEYUP) ? "WM_KEYUP" : "WM_KEYDOWN",
  1461. // nFlags
  1462. // );
  1463. DWORD dwEHSEF = HookSpyGetEHSEF();
  1464. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1465. {
  1466. if( HSLL_PreTranslateMessage( &_msg ) )
  1467. return true;
  1468. if( ! HookSpyIsRegistered() )
  1469. return false;
  1470. }
  1471. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1472. {
  1473. if( OnHookSpyPreTranslateMessage( &_msg ) )
  1474. return true;
  1475. if( ! HookSpyIsRegistered() )
  1476. return false;
  1477. }
  1478. if( OnHookSpyKeyMsg( &_msg ) )
  1479. return true;
  1480. if( ! HookSpyIsRegistered() )
  1481. return false;
  1482. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1483. {
  1484. if( OnHookSpyPostProcessMessage( &_msg ) )
  1485. return true;
  1486. }
  1487. return false;
  1488. }
  1490. bool CExtHookSpy::HSLL_OnGetMsgProc(
  1491. bool & bCallNextHook,
  1492. LRESULT & lResult,
  1493. int nCode,
  1494. WPARAM wParam,
  1495. MSG * pMSG
  1496. )
  1497. {
  1498. lResult;
  1499. if( nCode != HC_ACTION )
  1500. return false;
  1501. if( wParam != PM_REMOVE )
  1502. return false;
  1503. DWORD dwEHSEF = HookSpyGetEHSEF();
  1504. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1505. {
  1506. if( HSLL_PreTranslateMessage( pMSG ) )
  1507. {
  1508. bCallNextHook = false;
  1509. return true;
  1510. }
  1511. if( ! HookSpyIsRegistered() )
  1512. return false;
  1513. }
  1514. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1515. {
  1516. if( OnHookSpyPreTranslateMessage( pMSG ) )
  1517. {
  1518. bCallNextHook = false;
  1519. return true;
  1520. }
  1521. if( ! HookSpyIsRegistered() )
  1522. return false;
  1523. }
  1524. if( OnHookSpyGetMsgProc( pMSG ) )
  1525. {
  1526. bCallNextHook = false;
  1527. return true;
  1528. }
  1529. if( ! HookSpyIsRegistered() )
  1530. return false;
  1531. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1532. {
  1533. if( OnHookSpyPostProcessMessage( pMSG ) )
  1534. {
  1535. bCallNextHook = false;
  1536. return true;
  1537. }
  1538. }
  1539. return false;
  1540. }
  1542. bool CExtHookSpy::HSLL_OnSysMsgProc(
  1543. bool & bCallNextHook,
  1544. LRESULT & lResult,
  1545. int nCode,
  1546. WPARAM wParam,
  1547. LPARAM lParam
  1548. )
  1549. {
  1550. // lResult;
  1551. // if( nCode != HC_ACTION )
  1552. // return false;
  1553. bCallNextHook;
  1554. lResult;
  1555. nCode;
  1556. wParam;
  1557. lParam;
  1558. return false;
  1559. }
  1561. bool CExtHookSpy::HSLL_OnCallWindowProcIn(
  1562. bool & bCallNextHook,
  1563. LRESULT & lResult,
  1564. int nCode,
  1565. bool bMessageSentByCurrentThread,
  1566. PCWPSTRUCT pMessageData
  1567. )
  1568. {
  1569. bCallNextHook;
  1570. lResult;
  1571. bMessageSentByCurrentThread;
  1572. if( nCode != HC_ACTION )
  1573. return false;
  1574. MSG _msg;
  1575. ::memset( &_msg, 0, sizeof(MSG) );
  1576. _msg.hwnd = pMessageData->hwnd;
  1577. _msg.wParam = pMessageData->wParam;
  1578. _msg.lParam = pMessageData->lParam;
  1579. _msg.message = pMessageData->message;
  1580. DWORD dwEHSEF = HookSpyGetEHSEF();
  1581. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1582. {
  1583. if( HSLL_PreTranslateMessage( &_msg ) )
  1584. return true;
  1585. if( ! HookSpyIsRegistered() )
  1586. return false;
  1587. }
  1588. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1589. {
  1590. if( OnHookSpyPreTranslateMessage( &_msg ) )
  1591. return true;
  1592. if( ! HookSpyIsRegistered() )
  1593. return false;
  1594. }
  1595. if( OnHookSpyCallWindowProcIn( &_msg ) )
  1596. return true;
  1597. if( ! HookSpyIsRegistered() )
  1598. return false;
  1599. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1600. {
  1601. if( OnHookSpyPostProcessMessage( &_msg ) )
  1602. return true;
  1603. }
  1604. return false;
  1605. }
  1607. bool CExtHookSpy::HSLL_OnCallWindowProcOut(
  1608. bool & bCallNextHook,
  1609. LRESULT & lResult,
  1610. int nCode,
  1611. bool bMessageSentByCurrentThread,
  1612. PCWPRETSTRUCT pMessageData
  1613. )
  1614. {
  1615. bCallNextHook;
  1616. lResult;
  1617. bMessageSentByCurrentThread;
  1618. if( nCode != HC_ACTION )
  1619. return false;
  1620. MSG _msg;
  1621. ::memset( &_msg, 0, sizeof(MSG) );
  1622. _msg.hwnd = pMessageData->hwnd;
  1623. _msg.wParam = pMessageData->wParam;
  1624. _msg.lParam = pMessageData->lParam;
  1625. _msg.message = pMessageData->message;
  1626. DWORD dwEHSEF = HookSpyGetEHSEF();
  1627. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION_LL ) != 0 )
  1628. {
  1629. if( HSLL_PreTranslateMessage( &_msg ) )
  1630. return true;
  1631. if( ! HookSpyIsRegistered() )
  1632. return false;
  1633. }
  1634. if( ( dwEHSEF & __EHSEF_PRE_TRANSLATION ) != 0 )
  1635. {
  1636. if( OnHookSpyPreTranslateMessage( &_msg ) )
  1637. return true;
  1638. if( ! HookSpyIsRegistered() )
  1639. return false;
  1640. }
  1641. if( OnHookSpyCallWindowProcOut( &_msg ) )
  1642. return true;
  1643. if( ! HookSpyIsRegistered() )
  1644. return false;
  1645. if( ( dwEHSEF & __EHSEF_POST_PROCESSING ) != 0 )
  1646. {
  1647. if( OnHookSpyPostProcessMessage( &_msg ) )
  1648. return true;
  1649. }
  1650. return false;
  1651. }
  1653. bool CExtHookSpy::HSLL_PreTranslateMessage(
  1654. MSG * pMSG
  1655. )
  1656. {
  1657. ASSERT( pMSG != NULL );
  1658. pMSG;
  1659. return false;
  1660. }
  1662. bool CExtHookSpy::OnHookSpyPreTranslateMessage(
  1663. MSG * pMSG
  1664. )
  1665. {
  1666. ASSERT( pMSG != NULL );
  1667. pMSG;
  1668. return false;
  1669. }
  1671. bool CExtHookSpy::OnHookSpyPostProcessMessage(
  1672. MSG * pMSG
  1673. )
  1674. {
  1675. ASSERT( pMSG != NULL );
  1676. pMSG;
  1677. return false;
  1678. }
  1680. bool CExtHookSpy::OnHookSpyMouseWheelMsg(
  1681. MSG * pMSG
  1682. )
  1683. {
  1684. ASSERT( pMSG != NULL );
  1685. pMSG;
  1686. return false;
  1687. }
  1689. bool CExtHookSpy::OnHookSpyMouseMoveMsg(
  1690. MSG * pMSG
  1691. )
  1692. {
  1693. ASSERT( pMSG != NULL );
  1694. pMSG;
  1695. return false;
  1696. }
  1698. bool CExtHookSpy::OnHookSpyMouseClickMsg(
  1699. MSG * pMSG
  1700. )
  1701. {
  1702. ASSERT( pMSG != NULL );
  1703. pMSG;
  1704. return false;
  1705. }
  1707. bool CExtHookSpy::OnHookSpyKeyMsg(
  1708. MSG * pMSG
  1709. )
  1710. {
  1711. ASSERT( pMSG != NULL );
  1712. pMSG;
  1713. return false;
  1714. }
  1716. bool CExtHookSpy::OnHookSpyGetMsgProc(
  1717. MSG * pMSG
  1718. )
  1719. {
  1720. ASSERT( pMSG != NULL );
  1721. pMSG;
  1722. return false;
  1723. }
  1725. //bool CExtHookSpy::OnHookSpySysMsgProc(
  1726. // MSG * pMSG
  1727. // )
  1728. //{
  1729. // ASSERT( pMSG != NULL );
  1730. // pMSG;
  1731. // return false;
  1732. //}
  1734. bool CExtHookSpy::OnHookSpyCallWindowProcIn(
  1735. MSG * pMSG
  1736. )
  1737. {
  1738. ASSERT( pMSG != NULL );
  1739. pMSG;
  1740. return false;
  1741. }
  1743. bool CExtHookSpy::OnHookSpyCallWindowProcOut(
  1744. MSG * pMSG
  1745. )
  1746. {
  1747. ASSERT( pMSG != NULL );
  1748. pMSG;
  1749. return false;
  1750. }
  1752. void CExtHookSpy::HookSpyRegister(
  1753. DWORD dwEHSEF, // = __EHSEF_ALL
  1754. bool bAddToHead // = true
  1755. )
  1756. {
  1757. HookSpyRegister( this, dwEHSEF, bAddToHead );
  1758. }
  1760. void CExtHookSpy::HookSpyRegister(
  1761. CExtHookSpy * pHS,
  1762. DWORD dwEHSEF, // = __EHSEF_ALL
  1763. bool bAddToHead // = true
  1764. )
  1765. {
  1766. __PROF_UIS_MANAGE_STATE;
  1767. if( pHS == NULL )
  1768. return;
  1769. if( dwEHSEF == 0 )
  1770. {
  1771. HookSpyUnregister( pHS );
  1772. return;
  1773. }
  1774. INT nIndex, nCount = __EHS_IDX_COUNT;
  1775. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  1776. g_arr[ nIndex ].Register( pHS, dwEHSEF, bAddToHead );
  1777. if( ( pHS->HookSpyGetEHSEF() & __EHSEF_BASIC_HOOK_FILTERING ) != 0 )
  1778. pHS->HookSpyModifyEHSEF( 0, dwEHSEF&__EHSEF_ADDITIONAL_PROCESSING );
  1779. }
  1781. void CExtHookSpy::HookSpyUnregister(
  1782. DWORD dwEHSEF // = __EHSEF_ALL
  1783. )
  1784. {
  1785. HookSpyUnregister( this, dwEHSEF );
  1786. }
  1788. void CExtHookSpy::HookSpyUnregister(
  1789. CExtHookSpy * pHS,
  1790. DWORD dwEHSEF // = __EHSEF_ALL
  1791. )
  1792. {
  1793. __PROF_UIS_MANAGE_STATE;
  1794. if( pHS == NULL || dwEHSEF == 0 )
  1795. return;
  1796. INT nIndex, nCount = __EHS_IDX_COUNT;
  1797. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  1798. g_arr[ nIndex ].Unregister( pHS, dwEHSEF );
  1799. if( ( pHS->HookSpyGetEHSEF() & __EHSEF_BASIC_HOOK_FILTERING ) == 0 )
  1800. pHS->HookSpyModifyEHSEF( dwEHSEF&__EHSEF_ADDITIONAL_PROCESSING, 0 );
  1801. }
  1803. bool CExtHookSpy::HookSpyIsRegistered(
  1804. const CExtHookSpy * pHS,
  1805. DWORD dwEHSEF // = __EHSEF_ALL
  1806. )
  1807. {
  1808. __PROF_UIS_MANAGE_STATE;
  1809. if( pHS == NULL || dwEHSEF == 0 )
  1810. return false;
  1811. INT nIndex, nCount = __EHS_IDX_COUNT;
  1812. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  1813. {
  1814. if( g_arr[ nIndex ].IsRegistered( ((CExtHookSpy*)pHS), dwEHSEF ) )
  1815. return true;
  1816. }
  1817. return false;
  1818. }