Windows Dev Intro - Subclassing Controls

https://msdn.microsoft.com/en-us/library/windows/desktop/bb773183(v=vs.85).aspx

Subclassing Controls

If a control does almost everything you want, but you need a few more features, you can change or add features to the original control by subclassing it. A subclass can have all the features of an existing class as well as any additional features you want to give it.

This document discusses how subclasses are created and includes the following topics.

• Subclassing Controls Prior to ComCtl32.dll version 6
  • Storing User Data
  • Disadvantages of the Old Subclassing Approach
• Subclassing Controls Using ComCtl32.dll version 6
  • SetWindowSubclass
  • GetWindowSubclass
  • RemoveWindowSubclass
  • DefSubclassProc

Subclassing Controls Prior to ComCtl32.dll version 6

You can put a control in a subclass and store user data within a control. You do this when you use versions of ComCtl32.dll prior to version 6. There are some disadvantages in creating subclasses with earlier versions of ComCtl32.dll.

To make a new control, it is best to start with one of the Windows common controls and extend it to fit a particular need. To extend a control, create a control and replace its existing window procedure with a new one. The new procedure intercepts the control's messages and either acts on them or passes them to the original procedure for default processing. Use the SetWindowLong or SetWindowLongPtr function to replace the WNDPROC of the control. The following code sample shows how to replace a WNDPROC.

OldWndProc = (WNDPROC)SetWindowLongPtr (hButton,
GWLP_WNDPROC, (LONG_PTR)NewWndProc);

Storing User Data

You might want to store user data with an individual window. This data can be used by the new window procedure to determine how to draw the control or where to send certain messages. For example, you might use data to store a C++ class pointer to the class that represents the control. The following code sample shows how to use SetProp to store data with a window.

SetProp (hwnd, TEXT("MyData"), (HANDLE)pMyData);

Disadvantages of the Old Subclassing Approach

The following list points out some of the disadvantages of using the previously described approach to subclassing a control.

• The window procedure can only be replaced once.
• It is difficult to remove a subclass after it is created.
• Associating private data with a window is inefficient.
• To call the next procedure in a subclass chain, you cannot cast the old window procedure and call it, you must call it by using the CallWindowProc function.

Subclassing Controls Using ComCtl32.dll version 6

Note  ComCtl32.dll version 6 is Unicode only. The common controls supported by ComCtl32.dll version 6 should not be subclassed (or superclassed) with ANSI window procedures.

 

ComCtl32.dll version 6 contains four functions that make creating subclasses easier and eliminate the disadvantages previously discussed. The new functions encapsulate the management involved with multiple sets of reference data, therefore the developer can focus on programming features and not on managing subclasses. The subclassing functions are:

• SetWindowSubclass
• GetWindowSubclass
• RemoveWindowSubclass
• DefSubclassProc

SetWindowSubclass

This function is used to initially subclass a window. Each subclass is uniquely identified by the address of the pfnSubclass and its uIdSubclass. Both of these are parameters of the SetWindowSubclass function. Several subclasses can share the same subclass procedure and the ID can identify each call. To change reference data you can make subsequent calls to SetWindowSubclass. The important advantage is that each subclass instance has its own reference data.

The declaration of a subclass procedure is slightly different from a regular window procedure because it has two additional pieces of data: the subclass ID and the reference data. The last two parameters of the following function declaration show this.

LRESULT CALLBACK MyWndProc (HWND hWnd, UINT msg,
WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass,
DWORD_PTR dwRefData);

Every time a message is received by the new window procedure, a subclass ID and reference data are included.

Note  All strings passed to the procedure are Unicode strings even if Unicode is not specified as a preprocessor definition.

 

The following example shows a skeleton implementation of a window procedure for a subclassed control.

LRESULT CALLBACK OwnerDrawButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam,
                               LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
    switch (uMsg)
    {
    case WM_PAINT:
        .
        .
        .
        return TRUE;
    // Other cases...
    } 
    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

The window procedure can be attached to the control in the WM_INITDIALOG handler of the dialog procedure, as shown in the following example.

case WM_INITDIALOG:
{
    HWND button = GetDlgItem(hDlg, IDC_OWNERDRAWBUTTON);
    SetWindowSubclass(button, OwnerDrawButtonProc, 0, 0);
    return TRUE;
}

GetWindowSubclass

This function retrieves information about a subclass. For example, you can use GetWindowSubclass to access the reference data.

RemoveWindowSubclass

This function removes subclasses. RemoveWindowSubclass in combination with SetWindowSubclass allows you to dynamically add and remove subclasses.

DefSubclassProc

The DefSubclassProc function calls the next handler in the subclass chain. The function also retrieves the proper ID and reference data and passes the information to the next window procedure.

#include <windows.h>
#include <cstdio>

#include <commctrl.h> //for subclassing
// linked libcomctl32.a in the project options

using namespace std;

// for subclass 
DWORD dwRefData;
UINT uIdSubclass;
UINT uMsg;
LRESULT CALLBACK EditControlProc (HWND, UINT, WPARAM, LPARAM, UINT, DWORD);
LRESULT WINAPI DefSubclassProc(HWND,UINT,WPARAM,LPARAM);
typedef LRESULT (CALLBACK *SUBCLASSPROC)( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);
BOOL SetWindowSubclass( HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass, DWORD_PTR dwRefData );


/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);
    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Subclass Example",       /* Title Text */
           WS_OVERLAPPEDWINDOW,
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           319,                 /* The programs width */
           120,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        
        HDC      hdc;
        
    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */

        case WM_COMMAND:

            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
            
        case WM_CREATE:

    SetWindowSubclass(hwnd,EditControlProc,uIdSubclass,dwRefData);

    CreateWindow ( TEXT("edit"), NULL,
             WS_CHILD | WS_VISIBLE |
             ES_AUTOHSCROLL | ES_AUTOVSCROLL,
             5,5,300,18, hwnd, (HMENU) 0,
             ((LPCREATESTRUCT) lParam)->hInstance, //instance handle
             NULL) ;


             return 0 ;

    }
        
        
//----------------------BEGIN Subclass to capture tabs and enter for setfocus---------------------
EditControlProc ( hwnd, uMsg, wParam, lParam, uIdSubclass, dwRefData);
{
    switch (uMsg)
    {
    case WM_CHAR:
         switch (wParam){
                    case 0x09:
                         MessageBox(hwnd,"That was the tab key!", "tab key", MB_OK );
                         //process the tab key
                         break;
        return TRUE;
    } 
    return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
//----------------------END Subclass to capture tabs and enter for setfocus---------------------


                       

    return 0;
}
} // I have to add an extra } to make this compile