Using Mouse Input

This section covers tasks associated with mouse input.

Tracking the Mouse Cursor

Applications often perform tasks that involve tracking the position of the mouse cursor. Most drawing applications, for example, track the position of the mouse cursor during drawing operations, allowing the user to draw in a window's client area by dragging the mouse. Word-processing applications also track the cursor, enabling the user to select a word or block of text by clicking and dragging the mouse.

Tracking the cursor typically involves processing the WM_LBUTTONDOWN, WM_MOUSEMOVE, and WM_LBUTTONUP messages. A window determines when to begin tracking the cursor by checking the cursor position provided in the lParam parameter of the WM_LBUTTONDOWN message. For example, a word-processing application would begin tracking the cursor only if the WM_LBUTTONDOWN message occurred while the cursor was on a line of text, but not if it was past the end of the document.

A window tracks the position of the cursor by processing the stream of WM_MOUSEMOVE messages posted to the window as the mouse moves. Processing the WM_MOUSEMOVE message typically involves a repetitive painting or drawing operation in the client area. For example, a drawing application might redraw a line repeatedly as the mouse moves. A window uses the WM_LBUTTONUP message as a signal to stop tracking the cursor.

In addition, an application can call the TrackMouseEvent function to have the system send other messages that are useful for tracking the cursor. The system posts the WM_MOUSEHOVER message when the cursor hovers over the client area for a certain time period. It posts the WM_MOUSELEAVE message when the cursor leaves the client area. The WM_NCMOUSEHOVER and WM_NCMOUSELEAVE messages are the corresponding messages for the nonclient areas.

Drawing Lines with the Mouse

The example in this section demonstrates how to track the mouse cursor. It contains portions of a window procedure that enables the user to draw lines in a window's client area by dragging the mouse.

When the window procedure receives a WM_LBUTTONDOWN message, it captures the mouse and saves the coordinates of the cursor, using the coordinates as the starting point of the line. It also uses the ClipCursor function to confine the cursor to the client area during the line drawing operation.

During the first WM_MOUSEMOVE message, the window procedure draws a line from the starting point to the current position of the cursor. During subsequent WM_MOUSEMOVE messages, the window procedure erases the previous line by drawing over it with an inverted pen color. Then it draws a new line from the starting point to the new position of the cursor.

The WM_LBUTTONUP message signals the end of the drawing operation. The window procedure releases the mouse capture and frees the mouse from the client area.

LRESULT APIENTRY MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam) 
    HDC hdc;                       // handle to device context 
    RECT rcClient;                 // client area rectangle 
    POINT ptClientUL;              // client upper left corner 
    POINT ptClientLR;              // client lower right corner 
    static POINTS ptsBegin;        // beginning point 
    static POINTS ptsEnd;          // new endpoint 
    static POINTS ptsPrevEnd;      // previous endpoint 
    static BOOL fPrevLine = FALSE; // previous line flag 
    switch (uMsg) 
       case WM_LBUTTONDOWN: 
            // Capture mouse input. 
            // Retrieve the screen coordinates of the client area, 
            // and convert them into client coordinates. 
            GetClientRect(hwndMain, &rcClient); 
            ptClientUL.x = rcClient.left; 
            ptClientUL.y =; 
            // Add one to the right and bottom sides, because the 
            // coordinates retrieved by GetClientRect do not 
            // include the far left and lowermost pixels. 
            ptClientLR.x = rcClient.right + 1; 
            ptClientLR.y = rcClient.bottom + 1; 
            ClientToScreen(hwndMain, &ptClientUL); 
            ClientToScreen(hwndMain, &ptClientLR); 
            // Copy the client coordinates of the client area 
            // to the rcClient structure. Confine the mouse cursor 
            // to the client area by passing the rcClient structure 
            // to the ClipCursor function. 
            SetRect(&rcClient, ptClientUL.x, ptClientUL.y, 
                ptClientLR.x, ptClientLR.y); 
            // Convert the cursor coordinates into a POINTS 
            // structure, which defines the beginning point of the 
            // line drawn during a WM_MOUSEMOVE message. 
            ptsBegin = MAKEPOINTS(lParam); 
            return 0; 
        case WM_MOUSEMOVE: 
            // When moving the mouse, the user must hold down 
            // the left mouse button to draw lines. 
            if (wParam & MK_LBUTTON) 
                // Retrieve a device context (DC) for the client area. 
                hdc = GetDC(hwndMain); 
                // The following function ensures that pixels of 
                // the previously drawn line are set to white and 
                // those of the new line are set to black. 
                SetROP2(hdc, R2_NOTXORPEN); 
                // If a line was drawn during an earlier WM_MOUSEMOVE 
                // message, draw over it. This erases the line by 
                // setting the color of its pixels to white. 
                if (fPrevLine) 
                    MoveToEx(hdc, ptsBegin.x, ptsBegin.y, 
                        (LPPOINT) NULL); 
                    LineTo(hdc, ptsPrevEnd.x, ptsPrevEnd.y); 
                // Convert the current cursor coordinates to a 
                // POINTS structure, and then draw a new line. 
                ptsEnd = MAKEPOINTS(lParam); 
                MoveToEx(hdc, ptsBegin.x, ptsBegin.y, (LPPOINT) NULL); 
                LineTo(hdc, ptsEnd.x, ptsEnd.y); 
                // Set the previous line flag, save the ending 
                // point of the new line, and then release the DC. 
                fPrevLine = TRUE; 
                ptsPrevEnd = ptsEnd; 
                ReleaseDC(hwndMain, hdc); 
        case WM_LBUTTONUP: 
            // The user has finished drawing the line. Reset the 
            // previous line flag, release the mouse cursor, and 
            // release the mouse capture. 
            fPrevLine = FALSE; 
            return 0; 
        case WM_DESTROY: 
        // Process other messages. 

Processing a Double Click Message

To receive double-click messages, a window must belong to a window class that has the CS_DBLCLKS class style. You set this style when registering the window class, as shown in the following example.

BOOL InitApplication(HINSTANCE hInstance) 
    wc.lpfnWndProc = (WNDPROC) MainWndProc; 
    wc.cbClsExtra = 0; 
    wc.cbWndExtra = 0; 
    wc.hInstance = hInstance; 
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); 
    wc.hCursor = LoadCursor(NULL, IDC_IBEAM); 
    wc.hbrBackground = GetStockObject(WHITE_BRUSH); 
    wc.lpszMenuName = "MainMenu"; 
    wc.lpszClassName = "MainWClass"; 
    return RegisterClass(&wc); 

A double-click message is always preceded by a button-down message. For this reason, applications typically use a double-click message to extend a task that it began during a button-down message.

Selecting a Line of Text

The example in this section is taken from a simple word-processing application. It includes code that enables the user to set the position of the caret by clicking anywhere on a line of text, and to select (highlight) a line of text by double-clicking anywhere on the line.

LRESULT APIENTRY MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam) 
    HDC hdc;                     // handle to device context 
    TEXTMETRIC tm;               // font size data 
    int i, j;                    // loop counters 
    int cCR = 0;                 // count of carriage returns 
    char ch;                     // character from input buffer 
    static int nBegLine;         // beginning of selected line 
    static int nCurrentLine = 0; // currently selected line 
    static int nLastLine = 0;    // last text line 
    static int nCaretPosX = 0;   // x-coordinate of caret 
    static int cch = 0;          // number of characters entered 
    static int nCharWidth = 0;   // exact width of a character 
    static char szHilite[128];   // text string to highlight 
    static DWORD dwCharX;        // average width of characters 
    static DWORD dwLineHeight;   // line height 
    static POINTS ptsCursor;     // coordinates of mouse cursor 
    static COLORREF crPrevText;  // previous text color 
    static COLORREF crPrevBk;    // previous background color 
    static PTCHAR pchInputBuf;   // pointer to input buffer 
    static BOOL fTextSelected = FALSE; // text-selection flag 
	size_t * pcch;
	HRESULT hResult;
    switch (uMsg) 
        case WM_CREATE: 
            // Get the metrics of the current font. 
            hdc = GetDC(hwndMain); 
            GetTextMetrics(hdc, &tm); 
            ReleaseDC(hwndMain, hdc); 
            // Save the average character width and height. 
            dwCharX = tm.tmAveCharWidth; 
            dwLineHeight = tm.tmHeight; 
            // Allocate a buffer to store keyboard input. 
            pchInputBuf = (LPSTR) GlobalAlloc(GPTR, 
                BUFSIZE * sizeof(TCHAR)); 
            return 0; 
        case WM_CHAR: 
            switch (wParam) 
                case 0x08:  // backspace 
                case 0x0A:  // linefeed 
                case 0x1B:  // escape 
                    MessageBeep( (UINT) -1); 
                    return 0; 
                case 0x09:  // tab 
                    // Convert tabs to four consecutive spaces. 
                    for (i = 0; i < 4; i++) 
                        SendMessage(hwndMain, WM_CHAR, 0x20, 0); 
                    return 0; 
                case 0x0D:  // carriage return 
                    // Record the carriage return, and position the 
                    // caret at the beginning of the new line. 
                    pchInputBuf[cch++] = 0x0D; 
                    nCaretPosX = 0; 
                    nCurrentLine += 1; 
                default:    / displayable character 
                    ch = (char) wParam; 
                    // Retrieve the character's width, and display the 
                    // character. 
                    hdc = GetDC(hwndMain); 
                    GetCharWidth32(hdc, (UINT) wParam, (UINT) wParam, 
                    TextOut(hdc, nCaretPosX, 
                        nCurrentLine * dwLineHeight, &ch, 1); 
                    ReleaseDC(hwndMain, hdc); 
                    // Store the character in the buffer. 
                    pchInputBuf[cch++] = ch; 
                    // Calculate the new horizontal position of the 
                    // caret. If the new position exceeds the maximum, 
                    // insert a carriage return and reposition the 
                    // caret at the beginning of the next line. 
                    nCaretPosX += nCharWidth; 
                    if ((DWORD) nCaretPosX > dwMaxCharX) 
                        nCaretPosX = 0; 
                        pchInputBuf[cch++] = 0x0D; 
            SetCaretPos(nCaretPosX, nCurrentLine * dwLineHeight); 
            nLastLine = max(nLastLine, nCurrentLine); 
        // Process other messages. 
        case WM_LBUTTONDOWN: 
            // If a line of text is currently highlighted, redraw 
            // the text to remove the highlighting. 
            if (fTextSelected) 
                hdc = GetDC(hwndMain); 
                SetTextColor(hdc, crPrevText); 
                SetBkColor(hdc, crPrevBk);
				hResult = StringCchLength(szHilite, 128/sizeof(TCHAR), pcch);
				if (FAILED(hResult))
				// TODO: write error handler
                TextOut(hdc, 0, nCurrentLine * dwLineHeight, 
                    szHilite, *pcch); 
                ReleaseDC(hwndMain, hdc); 
                fTextSelected = FALSE; 
            // Save the current mouse-cursor coordinates. 
            ptsCursor = MAKEPOINTS(lParam); 
            // Determine which line the cursor is on, and save 
            // the line number. Do not allow line numbers greater 
            // than the number of the last line of text. The 
            // line number is later multiplied by the average height 
            // of the current font. The result is used to set the 
            // y-coordinate of the caret. 
            nCurrentLine = min((int)(ptsCursor.y / dwLineHeight), 
            // Parse the text input buffer to find the first 
            // character in the selected line of text. Each 
            // line ends with a carriage return, so it is possible 
            // to count the carriage returns to find the selected 
            // line. 
            cCR = 0; 
            nBegLine = 0; 
            if (nCurrentLine != 0) 
                for (i = 0; (i < cch) && 
                        (cCR < nCurrentLine); i++) 
                    if (pchInputBuf[i] == 0x0D) 
                nBegLine = i; 
            // Starting at the beginning of the selected line, 
            // measure  the width of each character, summing the 
            // width with each character measured. Stop when the 
            // sum is greater than the x-coordinate of the cursor. 
            // The sum is used to set the x-coordinate of the caret. 
            hdc = GetDC(hwndMain); 
            nCaretPosX = 0; 
            for (i = nBegLine; 
                (pchInputBuf[i] != 0x0D) && (i < cch); i++) 
                ch = pchInputBuf[i]; 
                GetCharWidth32(hdc, (int) ch, (int) ch, &nCharWidth); 
                if ((nCaretPosX + nCharWidth) > ptsCursor.x) break; 
                else nCaretPosX += nCharWidth; 
            ReleaseDC(hwndMain, hdc); 
            // Set the caret to the user-selected position. 
            SetCaretPos(nCaretPosX, nCurrentLine * dwLineHeight); 
        case WM_LBUTTONDBLCLK: 
            // Copy the selected line of text to a buffer. 
            for (i = nBegLine, j = 0; (pchInputBuf[i] != 0x0D) && 
                    (i < cch); i++) 
                szHilite[j++] = pchInputBuf[i]; 
            szHilite[j] = '\0'; 
            // Hide the caret, invert the background and foreground 
            // colors, and then redraw the selected line. 
            hdc = GetDC(hwndMain); 
            crPrevText = SetTextColor(hdc, RGB(255, 255, 255)); 
            crPrevBk = SetBkColor(hdc, RGB(0, 0, 0));
			hResult = StringCchLength(szHilite, 128/sizeof(TCHAR), pcch);
			if (FAILED(hResult))
			// TODO: write error handler
            TextOut(hdc, 0, nCurrentLine * dwLineHeight, szHilite, *pcch); 
            SetTextColor(hdc, crPrevText); 
            SetBkColor(hdc, crPrevBk); 
            ReleaseDC(hwndMain, hdc); 
            fTextSelected = TRUE; 

            // Process other messages. 

            return DefWindowProc(hwndMain, uMsg, wParam, lParam); 
    return NULL; 

Using a Mouse Wheel in a Document with Embedded Objects

This example assumes a Microsoft Word document with various embedded objects:

  • A Microsoft Excel spreadsheet
  • An embedded list box control that scrolls in response to the wheel
  • An embedded text box control that does not respond to the wheel

The MSH_MOUSEWHEEL message is always sent to the main window in Microsoft Word. This is true even if the embedded spreadsheet is active. The following table explains how the MSH_MOUSEWHEEL message is handled according to the focus.

Focus is onHandling is as follows
Word document Word scrolls the document window.
Embedded Excel spreadsheet Word posts the message to Excel. You must decide if the embedded application should respond to the message or not.
Embedded control It is up to the application to send the message to an embedded control that has the focus and check the return code to see if the control handled it. If the control did not handle it, then the application should scroll the document window. For example, if the user clicked a list box and then rolled the wheel, that control would scroll in response to a wheel rotation. If the user clicked a text box and then rotated the wheel, the whole document would scroll.


This following example shows how an application might handle the two wheel messages.

* this code deals with MSH_MOUSEWHEEL
#include "zmouse.h"

// Mouse Wheel rotation stuff, only define if we are
// on a version of the OS that does not support
// WM_MOUSEWHEEL messages.
    // Message ID for IntelliMouse wheel

UINT uMSH_MOUSEWHEEL = 0;   // Value returned from
                            // RegisterWindowMessage()


         HINSTANCE hInst, 
         HINSTANCE hPrevInst, 
         LPSTR lpCmdLine, 
         INT nCmdShow)
    MSG msg;
    BOOL bRet;

    if (!InitInstance(hInst, nCmdShow))
        return FALSE;

    // The new IntelliMouse uses a Registered message to transmit
    // wheel rotation info. So register for it!
    if ( !uMSH_MOUSEWHEEL )
                   RegisterWindowMessag Failed!",
        return msg.wParam;
    while (( bRet = GetMessage(&msg, NULL, 0, 0)) != 0)
        if (bRet == -1)
            // handle the error and possibly exit
            if (!TranslateAccelerator(ghwndApp,

    return msg.wParam;

* this code deals with WM_MOUSEWHEEL
    HWND hwnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam)
    static int nZoom = 0;

    switch (msg)
        // Handle Mouse Wheel messages generated
        // by the operating systems that have built-in
        // support for the WM_MOUSEWHEEL message.

        case WM_MOUSEWHEEL:
            ((short) HIWORD(wParam)< 0) ? nZoom-- : nZoom++;

            // Do other wheel stuff...


            // uMSH_MOUSEWHEEL is a message registered by
            // the mswheel dll on versions of Windows that
            // do not support the new message in the OS.

            if( msg == uMSH_MOUSEWHEEL )
               ((int)wParam < 0) ? nZoom-- : nZoom++;

                // Do other wheel stuff...

            return DefWindowProc(hwnd,

    return 0L;

Retrieving the Number of Mouse Wheel Scroll Lines

The following code allows an application to retrieve the number of scroll lines using the SystemParametersInfo function.


#include "zmouse.h"

* FUNCTION: GetNumScrollLines
* Purpose : An OS independent method to retrieve the 
*           number of wheel scroll lines
* Params  : none
* Returns : UINT:  Number of scroll lines where WHEEL_PAGESCROLL 
*           indicates to scroll a page at a time.
UINT GetNumScrollLines(void)
   HWND hdlMsWheel;
   UINT ucNumLines=3;  // 3 is the default
   OSVERSIONINFO osversion;
   UINT uiMsh_MsgScrollLines;

   memset(&osversion, 0, sizeof(osversion));
   osversion.dwOSVersionInfoSize =sizeof(osversion);

   if ((osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ||
       ( (osversion.dwPlatformId == VER_PLATFORM_WIN32_NT) && 
         (osversion.dwMajorVersion < 4) )   )
        hdlMsWheel = FindWindow(MSH_WHEELMODULE_CLASS, 
        if (hdlMsWheel)
           uiMsh_MsgScrollLines = RegisterWindowMessage
           if (uiMsh_MsgScrollLines)
                ucNumLines = (int)SendMessage(hdlMsWheel,
   else if ( (osversion.dwPlatformId ==
                         VER_PLATFORM_WIN32_NT) &&
             (osversion.dwMajorVersion >= 4) )
                                    &ucNumLines, 0);