Subclass.cpp
上传用户:shilei2004
上传日期:2020-07-18
资源大小:83k
文件大小:7k
源码类别:

RichEdit

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////////
  2. // PixieLib(TM) Copyright 1997-1998 Paul DiLascia
  3. // If this code works, it was written by Paul DiLascia.
  4. // If not, I don't know who wrote it.
  5. // Download by http://www.codefans.net
  6. // CSubclassWnd is a generic class for hooking another window's messages.
  7. #include "stdafx.h"
  8. #include "Subclass.h"
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  14. //////////////////
  15. // The message hook map is derived from CMapPtrToPtr, which associates
  16. // a pointer with another pointer. It maps an HWND to a CSubclassWnd, like
  17. // the way MFC's internal maps map HWND's to CWnd's. The first CSubclassWnd
  18. // attached to a window is stored in the map; all other CSubclassWnd's for that
  19. // window are then chained via CSubclassWnd::m_pNext.
  20. //
  21. class CSubclassWndMap : private CMapPtrToPtr {
  22. public:
  23. CSubclassWndMap();
  24. ~CSubclassWndMap();
  25. static CSubclassWndMap& GetHookMap();
  26. void Add(HWND hwnd, CSubclassWnd* pSubclassWnd);
  27. void Remove(CSubclassWnd* pSubclassWnd);
  28. void RemoveAll(HWND hwnd);
  29. CSubclassWnd* Lookup(HWND hwnd);
  30. };
  31. // This trick is used so the hook map isn't
  32. // instantiated until someone actually requests it.
  33. //
  34. #define theHookMap (CSubclassWndMap::GetHookMap())
  35. IMPLEMENT_DYNAMIC(CSubclassWnd, CWnd);
  36. CSubclassWnd::CSubclassWnd()
  37. {
  38. m_pNext = NULL;
  39. m_pOldWndProc = NULL;
  40. m_hWnd  = NULL;
  41. }
  42. CSubclassWnd::~CSubclassWnd()
  43. {
  44. if (m_hWnd) 
  45. HookWindow((HWND)NULL); // unhook window
  46. }
  47. //////////////////
  48. // Hook a window.
  49. // This installs a new window proc that directs messages to the CSubclassWnd.
  50. // pWnd=NULL to remove.
  51. //
  52. BOOL CSubclassWnd::HookWindow(HWND hwnd)
  53. {
  54. ASSERT_VALID(this);
  55. if (hwnd) {
  56. // Hook the window
  57. ASSERT(m_hWnd==NULL);
  58. ASSERT(::IsWindow(hwnd));
  59. theHookMap.Add(hwnd, this); // Add to map of hooks
  60. } else if (m_hWnd) {
  61. // Unhook the window
  62. theHookMap.Remove(this); // Remove from map
  63. m_pOldWndProc = NULL;
  64. }
  65. m_hWnd = hwnd;
  66. return TRUE;
  67. }
  68. //////////////////
  69. // Window proc-like virtual function which specific CSubclassWnds will
  70. // override to do stuff. Default passes the message to the next hook; 
  71. // the last hook passes the message to the original window.
  72. // You MUST call this at the end of your WindowProc if you want the real
  73. // window to get the message. This is just like CWnd::WindowProc, except that
  74. // a CSubclassWnd is not a window.
  75. //
  76. LRESULT CSubclassWnd::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
  77. {
  78. // ASSERT_VALID(this);  // removed for speed
  79. ASSERT(m_pOldWndProc);
  80. return m_pNext ? m_pNext->WindowProc(msg, wp, lp) :
  81. ::CallWindowProc(m_pOldWndProc, m_hWnd, msg, wp, lp);
  82. }
  83. //////////////////
  84. // Like calling base class WindowProc, but with no args, so individual
  85. // message handlers can do the default thing. Like CWnd::Default
  86. //
  87. LRESULT CSubclassWnd::Default()
  88. {
  89. // MFC stores current MSG in thread state
  90. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  91. // Note: must explicitly call CSubclassWnd::WindowProc to avoid infinte
  92. // recursion on virtual function
  93. return CSubclassWnd::WindowProc(curMsg.message, curMsg.wParam, curMsg.lParam);
  94. }
  95. #ifdef _DEBUG
  96. void CSubclassWnd::AssertValid() const
  97. {
  98. CObject::AssertValid();
  99. ASSERT(m_hWnd==NULL || ::IsWindow(m_hWnd));
  100. if (m_hWnd) {
  101. for (CSubclassWnd* p = theHookMap.Lookup(m_hWnd); p; p=p->m_pNext) {
  102. if (p==this)
  103. break;
  104. }
  105. ASSERT(p); // should have found it!
  106. }
  107. }
  108. void CSubclassWnd::Dump(CDumpContext& dc) const
  109. {
  110. CObject::Dump(dc);
  111. }
  112. #endif
  113. //////////////////
  114. // Subclassed window proc for message hooks. Replaces AfxWndProc (or whatever
  115. // else was there before.)
  116. //
  117. LRESULT CALLBACK
  118. HookWndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
  119. {
  120. #ifdef _USRDLL
  121. // If this is a DLL, need to set up MFC state
  122. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  123. #endif
  124. // Set up MFC message state just in case anyone wants it
  125. // This is just like AfxCallWindowProc, but we can't use that because
  126. // a CSubclassWnd is not a CWnd.
  127. //
  128. MSG& curMsg = AfxGetThreadState()->m_lastSentMsg;
  129. MSG  oldMsg = curMsg;   // save for nesting
  130. curMsg.hwnd = hwnd;
  131. curMsg.message = msg;
  132. curMsg.wParam  = wp;
  133. curMsg.lParam  = lp;
  134. // Get hook object for this window. Get from hook map
  135. CSubclassWnd* pSubclassWnd = theHookMap.Lookup(hwnd);
  136. ASSERT(pSubclassWnd);
  137. LRESULT lr;
  138. if (msg==WM_NCDESTROY) {
  139. // Window is being destroyed: unhook all hooks (for this window)
  140. // and pass msg to orginal window proc
  141. //
  142. WNDPROC wndproc = pSubclassWnd->m_pOldWndProc;
  143. theHookMap.RemoveAll(hwnd);
  144. lr = ::CallWindowProc(wndproc, hwnd, msg, wp, lp);
  145. } else {
  146. // pass to msg hook
  147. lr = pSubclassWnd->WindowProc(msg, wp, lp);
  148. }
  149. curMsg = oldMsg; // pop state
  150. return lr;
  151. }
  152. ////////////////////////////////////////////////////////////////
  153. // CSubclassWndMap implementation
  154. //
  155. CSubclassWndMap::CSubclassWndMap()
  156. {
  157. }
  158. CSubclassWndMap::~CSubclassWndMap()
  159. {
  160. // This assert bombs when posting WM_QUIT, so I've deleted it.
  161. // ASSERT(IsEmpty()); // all hooks should be removed!
  162. }
  163. //////////////////
  164. // Get the one and only global hook map
  165. // 
  166. CSubclassWndMap& CSubclassWndMap::GetHookMap()
  167. {
  168. // By creating theMap here, C++ doesn't instantiate it until/unless
  169. // it's ever used! This is a good trick to use in C++, to
  170. // instantiate/initialize a static object the first time it's used.
  171. //
  172. static CSubclassWndMap theMap;
  173. return theMap;
  174. }
  175. /////////////////
  176. // Add hook to map; i.e., associate hook with window
  177. //
  178. void CSubclassWndMap::Add(HWND hwnd, CSubclassWnd* pSubclassWnd)
  179. {
  180. ASSERT(hwnd && ::IsWindow(hwnd));
  181. // Add to front of list
  182. pSubclassWnd->m_pNext = Lookup(hwnd);
  183. SetAt(hwnd, pSubclassWnd);
  184. if (pSubclassWnd->m_pNext==NULL) {
  185. // If this is the first hook added, subclass the window
  186. pSubclassWnd->m_pOldWndProc = 
  187. (WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC, (DWORD)HookWndProc);
  188. } else {
  189. // just copy wndproc from next hook
  190. pSubclassWnd->m_pOldWndProc = pSubclassWnd->m_pNext->m_pOldWndProc;
  191. }
  192. ASSERT(pSubclassWnd->m_pOldWndProc);
  193. }
  194. //////////////////
  195. // Remove hook from map
  196. //
  197. void CSubclassWndMap::Remove(CSubclassWnd* pUnHook)
  198. {
  199. HWND hwnd = pUnHook->m_hWnd;
  200. ASSERT(hwnd && ::IsWindow(hwnd));
  201. CSubclassWnd* pHook = Lookup(hwnd);
  202. ASSERT(pHook);
  203. if (pHook==pUnHook) {
  204. // hook to remove is the one in the hash table: replace w/next
  205. if (pHook->m_pNext)
  206. SetAt(hwnd, pHook->m_pNext);
  207. else {
  208. // This is the last hook for this window: restore wnd proc
  209. RemoveKey(hwnd);
  210. SetWindowLong(hwnd, GWL_WNDPROC, (DWORD)pHook->m_pOldWndProc);
  211. }
  212. } else {
  213. // Hook to remove is in the middle: just remove from linked list
  214. while (pHook->m_pNext!=pUnHook)
  215. pHook = pHook->m_pNext;
  216. ASSERT(pHook && pHook->m_pNext==pUnHook);
  217. pHook->m_pNext = pUnHook->m_pNext;
  218. }
  219. }
  220. //////////////////
  221. // Remove all the hooks for a window
  222. //
  223. void CSubclassWndMap::RemoveAll(HWND hwnd)
  224. {
  225. CSubclassWnd* pSubclassWnd;
  226. while ((pSubclassWnd = Lookup(hwnd))!=NULL)
  227. pSubclassWnd->HookWindow((HWND)NULL); // (unhook)
  228. }
  229. /////////////////
  230. // Find first hook associate with window
  231. //
  232. CSubclassWnd* CSubclassWndMap::Lookup(HWND hwnd)
  233. {
  234. CSubclassWnd* pFound = NULL;
  235. if (!CMapPtrToPtr::Lookup(hwnd, (void*&)pFound))
  236. return NULL;
  237. ASSERT_KINDOF(CSubclassWnd, pFound);
  238. return pFound;
  239. }