HOWTO: Hook Into a Window's Messages Using AddressOf

• Microsoft Visual Basic Enterprise Edition for Windows, version 5.0

SUMMARY

Hooking into a Window (sometimes called sub-classing) is a technique that enables interception of the messages that are being sent to that Window. Microsoft Visual Basic version 5.0 allows sub-classing through the use of the AddressOf operator.

NOTE: This article's purpose is to demonstrate a hooked message stream. It is beyond the scope of this article to describe any particular application of this technique.

WARNING: ANY USE BY YOU OF THE SAMPLE CODE PROVIDED IN THIS ARTICLE IS AT YOUR OWN RISK. Microsoft provides this sample code "as is" without warranty of any kind, either express or implied, including but not limited to the implied warranties of merchantability and/or fitness for a particular purpose.

WARNING: Failure to unhook a window before its imminent destruction will result in application errors, Invalid Page Faults, and data loss. This is due the fact that the new WindowProc function being pointed to no longer exists, but the window has not been notified of the change. Always unhook the sub-classed window upon unloading the sub-classed form or exiting the application. This is especially important while debugging an application that uses this technique within the Microsoft Visual Basic 5.0 Development Environment. Pressing the End button or selecting End from the Run menu without unhooking will cause an Invalid Page Fault and close Microsoft Visual Basic.

MORE INFORMATION

Microsoft Windows controls applications by sending messages to the windows that are created by each application. These messages alert the targeted window when it's time to redraw, when a mouse button is pressed, and all of the other information a window needs to know in order to act appropriately.

Thus, a minimal Windows application consists of a function for which these messages are processed (called WindowProc). This function is registered into the system when the window is created so the system knows where to send messages.

The following application consists of a simple form with two command buttons. The code is designed to intercept Windows messages being sent to the form and to print the values of those messages in the Immediate window.

1. In a new "Standard EXE" project, add Form1, two Command Buttons, and Module1.BAS. The first part of the code consists of declarations for the API functions, constant values, and variables:

         Declare Function CallWindowProc Lib "user32" Alias _
         "CallWindowProcA" (ByVal lpPrevWndFunc As Long, _
         ByVal hwnd As Long, ByVal Msg As Long, _
         ByVal wParam As Long, ByVal lParam As Long) As Long
   

         Declare Function SetWindowLong Lib "user32" Alias _
         "SetWindowLongA" (ByVal hwnd As Long, _
         ByVal nIndex As Long, ByVal dwNewLong As Long) As Long
   

         Public Const GWL_WNDPROC = -4
         Global lpPrevWndProc As Long
         Global gHW As Long
   

2. Add the following procedures to MODULE1.BAS:

         Public Sub Hook()
             lpPrevWndProc = SetWindowLong(gHW, GWL_WNDPROC, _
             AddressOf WindowProc)
         End Sub
   
         Public Sub Unhook()
             Dim temp As Long
             temp = SetWindowLong(gHW, GWL_WNDPROC,lpPrevWndProc)
         End Sub
   
      These two procedures enable the code to hook into the stream of
      messages.
   
      In the first procedure, "Hook," you make use of the SetWindowLong
      function. The SetWindowLong function changes an attribute of a specified
      window. It takes the following parameters:
   
      hwnd:      The handle of the Window you are going to change.
      nIndex:    The action you are going to do to the window.
      dwNewLong: The new value you change to.
   
      In this example, you use the Form's hwnd property as the targeted window
      to change. You then use the GWL_WNDPROC constant to tell the
      SetWindowLong function that you want to change the address of the target
      window's WindowProc function. Finally you set dwNewLong to the address
      of a new WindowProc function (see next step). Notice that you store the
      previous WindowProc address in the lpPrevWndProc variable.
   
      The second procedure, "UnHook," simply reverses what you have done and
      puts the address of the original window procedure back.
   
   

3. Add the following function to MODULE1.BAS:

         Function WindowProc(ByVal hw As Long, ByVal uMsg As _
         Long, ByVal wParam As Long, ByVal lParam As Long) As Long
             Debug.Print "Message: "; hw, uMsg, wParam, lParam
             WindowProc = CallWindowProc(lpPrevWndProc, hw, _
             uMsg, wParam, lParam)
         End Function
   
      Here is the function that you are routing the window messages to when
      you "Hook" the form's WindowProc function. Note that you make use of the
      CallWindowProc function; using the lpPrevWndProc variable to send any
      unprocessed messages to the original handler. Hence, you are allowing a
      chain of window procedures to process all messages.
   
   

4. Finally, the code for the form sets the initial hWnd value, and the code for the buttons simply calls the two subroutines:

         Private Sub Form_Load()
             gHW = Me.hwnd
         End Sub
   
         Private Sub Command1_Click()
             Hook
         End Sub
   
         Private Sub Command2_Click()
             Unhook
         End Sub
   
   

5. Before running this sample, save your project.

REFERENCES

Microsoft Windows 32 SDK Win32 Programmer Reference

   CallWindowProc
   SetWindowLong

Keywords          : vb5all kbcode kbusage kbhowto
Version           : 5.0
Platform          : WINDOWS
Issue type        : kbhowto