La programmation de l'interface utilisateur

Dans la colonne de gauche, la liste des constantes permettant de spécifier le type du bouton et dans celle de droite, la liste des constantes permettant de choisir la disposition texte du bouton.

BS_PUSHBUTTON (bouton poussoir ou de commande) est le type par défaut. Le type BS_DEFPUSHBUTTON est en principe réservé au bouton par défaut (celui qui est activé lorsqu'on appuie sur ENTREE) d'une boîte de dialogue. Par défaut, ce bouton s'il est présent doit avoir l'ID IDOK. Mais on peut changer cela en envoyant à la fenêtre le message DM_SETDEFID qui permet d'utiliser une autre valeur (que l'on placera dans wParam) à la place de IDOK.

Un bouton automatique (BS_AUTOXXX) est en gros un bouton dont l'état change automatiquement chaque fois qu'on clique dessus.

Un BS_CHECKBOX et un BS_3STATE ont la même apparence (case à cocher) sauf qu'un BS_3STATE, en plus de pouvoir être coché (BST_CHECKED) ou décoché (BST_UNCHECKED), peut aussi être dans un état non assigné (BST_INDETERMINATE). Les cases à cocher sont généralement utilisées pour donner à l'utilisateur la possibilité de sélectionner une ou plusieurs options parmi un groupe d'options. À l'inverse les boutons radio sont généralement utilisés pour demander à l'utilisateur de faire un choix parmi un groupe d'options. Si cette convention est conforme à vos attentes, vous n'avez aucune raison d'utiliser les boutons de type BS_CHECKBOX, BS_3STATE ou BS_RADIOBUTTON à la place de BS_AUTOCHECKBOX, BS_AUTO3STATE ou BS_AUTORADIOBUTTON.

Pour être encore plus rationnel (et cela est même requis pour les radio buttons), il ne faut pas se contenter de placer les contrôles les uns à côté des autres à l'intérieur d'un rectangle assez net pour former un « vrai » groupe de contrôles. En plus de cela, le premier contrôle du groupe doit avoir le style WS_GROUP. Autrement dit, un contrôle possédant ce style commence un nouveau groupe. Généralement, on donne aussi le style WS_TABSTOP au premier contrôle de chaque groupe pour permettre à l'utilisateur de naviguer facilement entre les différents groupes à l'aide de la touche TAB et de passer d'un contrôle à un autre du même groupe en utilisant les touches fléchées du clavier. Du point de vue esthétique, il est coutume de placer un groupe d'options à l'intérieur d'un group box (BS_GROUPBOX), mais bien entendu, cela n'est point une règle.

Et enfin, BS_PUSHLIKE est un style qu'on peut donner aux « state-buttons » (BS_AUTOCHECKBOX, BS_AUTORADIOBUTTON, etc.) pour leur donner une apparence de push button.

CheckDlgButton :

BOOL CheckDlgButton(HWND hwndParent, int nIDButton, UINT uCheck);

Cette fonction permet de modifier l'état d'une case à cocher ou d'un bouton radio. Les valeurs utilisables sont : BST_CHECKED (coché), BST_UNCHECKED (décoché) et BST_INDETERMINATE (non assigné).

CheckRadioButton :

BOOL CheckRadioButton(HWND hwndParent, int nIDFirstButton, int nIDLastButton, int nIDCheckButton);

Permet de sélectionner (cocher) un bouton radio tout en s'assurant qu'un et seul seulement parmi un groupe ne soit sélectionné (les autres seront tous décochés).

IsDlgButtonChecked :

UINT IsDlgButtonChecked(HWND hwndParent, int nIDButton);

Cette fonction ne retourne pas une valeur booléenne (!), mais l'état du bouton (qui doit être une case à cocher ou un bouton radio) c'est-à-dire coché, décoché ou non assigné.

BM_CLICK : ce message peut être envoyé à un bouton pour simuler un clic de la part de l'utilisateur. Il ne nécessite aucun paramètre (c'est-à-dire que vous laissez tout simplement wParam et lParam à zéro).

BM_SETCHECK : modifie l'état d'une case à cocher ou d'un bouton radio. Utilise wParam comme unique paramètre, qui peut être BST_CHECKED, BST_UNCHECKED ou BST_INDETERMINATE (pour les boutons à 3 états uniquement). Macro équivalente :

void Button_SetCheck(HWND hwndCtl, int check);

BM_GETCHECK : retourne l'état d'une case à cocher ou d'un bouton radio. Ne nécessite aucun paramètre. Macro équivalente :

int Button_GetCheck(HWND hwndCtl);

BM_SETSTATE : modifie l'état d'un bouton-poussoir. Utilise wParam comme unique paramètre. Mettez TRUE pour rendre le bouton enfoncé et FALSE pour le relâcher. Macro équivalente :

UINT Button_SetState(HWND hwndCtl, int state);

BM_GETSTATE : retourne l'état d'un bouton. Attention ! Ce n'est pas « l'inverse » du message BM_SETSTATE. BM_GETSTATE peut être utilisé avec n'importe quel bouton. Il ne nécessite aucun paramètre. Et enfin, il retourne une combinaison des valeurs suivantes :

• BST_CHECKED : le bouton est coché ;
• BST_UNCHECKED : le bouton est décoché ;
• BST_INDETERMINATE : le bouton est non assigné ;
• BST_FOCUS : le bouton a le focus clavier ;
• BST_PUSHED : le bouton est maintenu enfoncé.
  
  

Ces valeurs sont toutes indépendantes donc on peut utiliser l'opérateur & pour extraire les informations utiles. Par exemple :

int state = (int)SendDlgItemMessage(hWnd, MYBUTTON, BM_GETSTATE, 0, 0);
if (state & BST_CHECKED) {
    ...
}

La Macro équivalente est :

int Button_GetState(HWND hwndCtl);

BM_SETIMAGE : associe une nouvelle image (une icône ou un bitmap) à un bouton. Le bouton doit avoir le style BS_ICON pour pouvoir afficher une icône et BS_BITMAP pour pouvoir afficher une image bitmap (sachez également que le style BS_TEXT permet à un bouton d'afficher du texte, mais ce style est appliqué par défaut). Avec les boutons « normaux », on ne peut qu'afficher soit du texte soit une image. Pour pouvoir afficher à la fois du texte et une image (et faire d'autres trucs jusqu'ici impossibles), il faudra utiliser des boutons personnalisés (Owner Draw Buttons) que nous verrons encore plus loin. Ce message requiert en paramètres le type de l'image qu'on veut associer au bouton (wParam) qui peut prendre les valeurs IMAGE_ICON ou IMAGE_BITMAP et le handle de l'image en question (lParam). En retour, on a le handle de l'ancienne image associée au bouton (ou NULL).

BM_GETIMAGE : retourne le handle de l'image associée au bouton ou NULL si aucune image ne lui a été associée. Nécessite en paramètre (wParam) le type de l'image (IMAGE_ICON ou IMAGE_BITMAP).

BN_CLICKED : envoyé lorsque le bouton a été cliqué

BN_DBLCLK : envoyé lorsque le bouton a été double-cliqué. Seuls les boutons radio et les boutons personnalisés savent envoyer automatiquement cette notification. Pour les autres types de boutons, il faut qu'ils aient le style BS_NOTIFY.

Format▲

Comportement▲

WM_COPY : copie la sélection courante vers le presse-papiers. Ne nécessite aucun paramètre.

WM_CUT : coupe la sélection courante et place le texte ainsi coupé dans le presse-papiers. Ne nécessite aucun paramètre

WM_PASTE : copie si possible le contenu du presse-papiers à partir de la position courante dans le contrôle. Ne nécessite aucun paramètre.

WM_CLEAR : efface la sélection courante. Ne nécessite aucun paramètre.

EM_CANUNDO : retourne l'état du flag « Can Undo » indiquant s'il est possible d'annuler la dernière action (TRUE) ou non (FALSE). Ce message ne nécessite aucun paramètre. Macro équivalente :

BOOL Edit_CanUndo(HWND hwndCtl);

EM_UNDO : annule, si possible, la dernière action effectuée. Ne nécessite aucun paramètre. Macro équivalente :

BOOL Edit_Undo(HWND hwndCtl);

EM_LIMITTEXT : ou EM_SETLIMITTEXT. Limite le nombre maximum de caractères que l'utilisateur peut entrer à un nombre passé en paramètre (wParam). On peut mettre 0 pour limiter ce nombre au maximum supporté par le système.

EM_GETLIMITTEXT : retourne le nombre maximum de caractères que l'utilisateur peut entrer. Ne nécessite aucun paramètre.

EM_SETPASSWORDCHAR : spécifie le caractère à utiliser pour masquer les mots de passe (par défaut : '*'). Le seul paramètre requis est le caractère de remplacement (wParam). Macro équivalente :

void Edit_SetPasswordChar(HWND hwndCtl, UINT ch);

EM_GETPASSWORDCHAR : retourne le caractère actuellement utilisé pour masquer les mots de passe. Macro équivalente :

TCHAR Edit_GetPasswordChar(HWND hwndCtl);

EM_GETLINECOUNT : retourne le nombre actuel de lignes d'un contrôle multi lignes. Ce nombre est toujours supérieur ou égal à 1, même si le contrôle est vide (auquel cas la valeur retournée est 1, comme s'il y avait une ligne). Macro équivalente :

int Edit_GetLineCount(HWND hwndCtl);

EM_LINELENGTH : retourne la longueur c'est-à-dire le nombre de caractères d'une ligne. Ce message ne nécessite qu'un seul paramètre (wParam) à savoir de numéro de la ligne que l'on veut interroger. Le numéro de la première ligne est 0. Macro équivalente :

int Edit_LineLength(HWND hwndCtl, int line);

EM_GETLINE : copie le contenu d'une ligne dans un buffer. Il faut placer le numéro de la ligne à copier dans le paramètre wParam et l'adresse du buffer destiné à recevoir les caractères copiés dans lParam. Il faut également placer la taille du buffer dans le premier mot (WORD) de ce buffer. Le caractère de fin de chaîne n'est pas ajouté. En retour, on a le nombre de caractères copiés.

En général, on envoie donc dans un premier temps le message EM_LINELENGTH avant d'envoyer le message EM_GETLINE, comme montré dans l'extrait de code suivant :

size_t len = (size_t)SendMessage(hEdit, EM_LINELENGTH, (WPARAM)iLine, 0);

TCHAR * lpBuffer = malloc( max(len + 1, sizeof(WORD)) * sizeof(TCHAR) );

if (lpBuffer != NULL)
{
    memcpy(lpBuffer, &len, sizeof(WORD));
    SendMessage(hEdit, EM_GETLINE, (WPARAM)iLine, (LPARAM)lpBuffer);
    lpBuffer[len] = '\0';
    
    MessageBox(hWnd, lpBuffer, "", MB_OK);
    
    free(lpBuffer);
}

La Macro équivalente est :

int Edit_GetLine(HWND hwndCtl, int line, LPTSTR lpBuffer, WORD wBufLength);

Bien entendu on peut toujours utiliser GetWindowText pour récupérer tout le texte d'un contrôle Edit comme avec n'importe quelle fenêtre. GetWindowTextLength permet de connaître le nombre de caractères constituant le texte d'une fenêtre.

Mais il y a tout de même un problème. En fait, GetWindowText n'est pas trop recommandé pour récupérer le contenu d'un contrôle multi lignes puisque cette opération peut consommer beaucoup de mémoire. Pour avoir accès à tout le contenu, il vaut mieux accéder directement à la mémoire utilisée par le contrôle lui-même. C'est là qu'entre en jeu le message EM_GETHANDLE.

EM_GETHANDLE : retourne le handle de la mémoire utilisée par un contrôle multi lignes (en effet son utilisation avec les contrôles à une seule ligne présente peu d'intérêt). Ce handle, passé à LocalLock, permet d'obtenir ensuite un pointeur vers cette mémoire, qui est un tableau de caractères (ANSI ou UNICODE selon le jeu de caractères que vous utilisez) terminé par zéro. Le programme peut lire le contenu de cette mémoire, mais ne peut pas la modifier. Pour déverrouiller le contrôle, on appellera la fonction LocalUnlock. Par exemple :

HLOCAL hMemory = (HLOCAL)SendMessage(hEdit, EM_GETHANDLE, 0, 0);

TCHAR * pMemory = LocalLock(hMemory);

MessageBox(hWnd, pMemory, "", MB_OK);

LocalUnlock(hMemory);

La Macro équivalente est :

HLOCAL Edit_GetHandle(HWND hwndCtl);

EM_GETSEL : permet de récupérer le début et la fin de la sélection courante. Nécessite en paramètres les adresses respectives de la variable destinée à recevoir l'indice du début de la sélection (wParam) et de celle destinée à recevoir l'indice de la fin de sélection (lParam). La fin de la sélection n'est pas le dernier caractère sélectionné, mais le caractère suivant.

EM_SETSEL : modifie la sélection courante. Ce message nécessite en paramètres les indices respectifs du début (wParam) et de la fin (lParam) de la nouvelle sélection. Utilisez respectivement 0 et -1 pour tout sélectionner.

EM_REPLACESEL : remplace le texte de la sélection courante par un autre (lParam). Il faut également spécifier (wParam) si l'action peut être annulée (TRUE) ou non (FALSE).

EM_GETMODIFY : retourne l'état du flag « Modified » indiquant si le contenu a été modifié depuis la dernière fois qu'on l'a marqué comme sain et sauf. TRUE indique que le contenu a été modifié. Macro équivalente :

BOOL Edit_GetModify(HWND hwndCtl);

EM_SETMODIFY : permet de modifier l'état du flag « Modified » du contrôle. Mettre FALSE (wParam) pour indiquer que le contenu est sain et sauf. Macro équivalente :

void Edit_SetModify(HWND hwndCtl, UINT fModified);

EN_UPDATE : envoyé chaque fois que l'utilisateur modifie le contenu du contrôle. Cette notification est envoyée avant que la modification ne prenne effet.

EN_CHANGE : envoyé chaque fois que l'utilisateur modifie le contenu du contrôle. Cette notification est envoyée après que la modification ait pris effet.

EN_MAXTEXT : envoyé lorsque l'utilisateur a tenté d'entrer plus de texte que le contrôle ne peut supporter.

EN_SETFOCUS : envoyé lorsque le contrôle reçoit le focus du clavier.

EN_KILLFOCUS : envoyé lorsque le contrôle vient de perdre le focus du clavier.

LBS_DISABLENOSCROLL : spécifie que la barre de défilement du contrôle doit toujours être visible. Par défaut, cette barre n'apparaît que lorsque le contrôle contient trop d'éléments pour être tous affichés en même temps.

LBS_EXTENDEDSEL : spécifie que l'utilisateur peut sélectionner plusieurs éléments en même temps à l'aide de la souris et les touches SHIFT ou CTRL ou à l'aide d'une combinaison spéciale de touches.

LBS_MULTIPLESEL : spécifie que l'utilisateur peut sélectionner plusieurs éléments en même temps en cliquant successivement sur les éléments à sélectionner. La sélection / désélection d'un élément se fait à l'aide d'un simple clic.

LBS_NOSEL : spécifie que les éléments de la liste peuvent être uniquement visualisés et non sélectionnés.

LBS_SORT : spécifie que les éléments de la liste doivent être triés alphabétiquement.

LBS_NOTIFY : autorise le contrôle à envoyer des notifications (LBN_CLICKED, LBN_DBLCLK, etc.).

LBS_STANDARD : zone de liste standard (inclut les styles les plus courants, à savoir WS_BORDER, LBS_SORT et LBS_NOTIFY).

LB_ADDSTRING : ajoute une chaîne (lParam) à la fin de la liste. Macro équivalente :

int ListBox_AddString(HWND hwndCtl, LPCTSTR lpszString);

LB_INSERTSTRING : insère une chaîne (lParam) à la position numéro n (wParam) sachant que l'indice du premier élément est 0. Si wParam = -1, la chaîne sera ajoutée à la fin. Macro équivalente :

int ListBox_InsertString(HWND hwndCtl, int index, LPCTSTR lpszString);

LB_DELETESTRING : supprime une chaîne de la liste. Le seul paramètre requis est l'indice de la chaîne à supprimer (wParam). Macro équivalente :

int ListBox_AddString(HWND hwndCtl, int index);

LB_GETCOUNT : retourne le nombre d'éléments dans la liste. Macro équivalente :

int ListBox_GetCount(HWND hwndCtl);

LB_GETTEXTLEN : retourne la longueur (strlen) du texte de l'élément spécifié (wParam). Macro équivalente :

int ListBox_GetTextLen(hwndCtl, int index);

LB_GETTEXT : copie le texte de l'élément spécifié (wParam) pour le placer dans un buffer (lParam). Ce buffer doit être suffisamment grand pour contenir le texte copié ainsi que le caractère de fin de chaîne (qui est automatiquement ajouté). Macro équivalente :

int ListBox_GetTextLen(hwndCtl, int index, LPTSTR lpszBuffer);

LB_FINDSTRING : recherche une chaîne (lParam) à partir de la position spécifiée (wParam), plus précisément à partir de la position suivante. Donc pour chercher depuis le début de la liste (position 0), il faut passer -1 en paramètre. En fait, LB_FINDSTRING cherche une chaîne contenant le préfixe placé dans lParam et non la chaîne exacte. Pour chercher la chaîne exacte, il faut utiliser LB_FINDSTRINGEXACT à la place de LB_FINDSTRING. Dans tous les cas, la recherche ne tient pas compte de la casse et la valeur retournée est l'indice du premier élément trouvé ou LB_ERR si aucun élément n'a été trouvé. Macro équivalente :

int ListBox_FindString(HWND hwndCtl, int indexStart, LPCTSTR lpszString);

LB_SETITEMDATA : associe une valeur (lParam) à un élément de la liste (wParam). Macro équivalente :

int ListBox_SetItemData(HWND hwndCtl, int index, LPARAM data);

LB_GETITEMDATA : retourne la valeur associée à un élément de la liste (wParam). Macro équivalente :

LRESULT ListBox_SetItemData(HWND hwndCtl, int index);

LB_GETSEL : retourne l'état d'un élément de la liste (wParam). Une valeur positive indique que l'élément est sélectionné et 0 indique qu'il est désélectionné. LB_ERR est retourné en cas d'erreur. Macro équivalente :

int ListBox_GetSel(HWND hwndCtl, int index);

LB_SETSEL : modifie l'état (wParam) d'un élément de la liste (lParam). Utilisez TRUE pour sélectionner l'élément et FALSE pour le désélectionner. Si lParam = -1, la modification sera appliquée à tous les éléments de la liste. Macro équivalente :

int ListBox_GetSel(HWND hwndCtl, BOOL fSelect, int index);

LB_GETCURSEL : dans un contrôle à sélection simple, retourne l'indice de la sélection courante ou LB_ERR si aucun élément n'est sélectionné. Macro équivalente :

int ListBox_GetCurSel(HWND hwndCtl);

LB_SETCURSEL : sélectionne un élément (wParam). Macro équivalente :

int ListBox_GetCurSel(HWND hwndCtl, int index);

LB_GETSELCOUNT : dans un contrôle à sélection multiple, retourne le nombre d'éléments sélectionnés, 0 si aucun élément n'est sélectionné. Macro équivalente :

int ListBox_GetSelCount(HWND hwndCtl);

LB_GETSELITEMS : permet de récupérer dans un tableau (lParam) d'entiers les indices des éléments sélectionnés. On devra également placer dans wParam le nombre maximum d'éléments que peut accepter le tableau. Macro équivalente :

int ListBox_GetSelItems(HWND hwndCtl, int cItems, int * lpItems)

LB_RESETCONTENT : réinitialise la liste (supprime tous les éléments). Macro équivalente :

BOOL ListBox_ResetContent(HWND hwndCtl);

La technique la plus puissante pour obtenir des contrôles très personnalisés c'est évidemment de les dessiner soi-même. Fondamentalement, cela se fait tout simplement en traitant le message WM_PAINT à l'intérieur de la procédure de fenêtre du contrôle. On peut spécifier une nouvelle procédure de fenêtre pour n'importe quelle fenêtre déjà créée en modifiant l'adresse indiquée dans sa « variable interne » GWL_WNDPROC à l'aide de la fonction SetWindowLong. En fait, SetWindowLong est une fonction obsolète, car elle ne peut être utilisée que sur les plateformes 32 bits. Pour avoir du code compatible avec tous les processeurs (32 ou 64 bits), il faudra utiliser SetWindowLongPtr (et GWLP_WNDPROC).

En pratique, on n'aura pas qu'à traiter le message WM_PAINT pour dessiner le contrôle cela demande généralement trop de détails à prendre en charge. De plus, un contrôle doit généralement changer d'aspect en fonction de son état. Par exemple, pour un bouton, les états possibles sont normal, survolé par la souris, enfoncé, etc. Or les paramètres qui accompagnent le message WM_PAINT ne permettent pas de connaître dans quel état est actuellement le contrôle. C'est pourquoi, lorsqu'on veut dessiner soi-même ses contrôles, il est généralement préférable d'utiliser les « owner-draw controls ».

Chaque fois qu'un owner-draw control doit être dessiné ou redessiné, Windows envoie à sa fenêtre parent le message WM_DRAWITEM. Si le message provient d'un contrôle, alors le paramètre wParam contient l'ID de ce contrôle sinon zéro. lParam quant à lui contient toujours l'adresse d'une structure de type DRAWITEMSTRUCT contenant les informations nécessaires permettant d'effectuer un traitement convenable.

typedef struct tagDRAWITEMSTRUCT {
    UINT CtlType;
    UINT CtlID;
    UINT itemID;
    UINT itemAction;
    UINT itemState;
    HWND hwndItem;
    HDC hDC;
    RECT rcItem;
    ULONG_PTR itemData;
} DRAWITEMSTRUCT;

La description complète de cette structure peut être évidemment trouvée dans l'aide de MSDN (elle n'est d'ailleurs pas compliquée), mais ce qu'il faut au moins retenir ce sont les champs CtlID (ID du contrôle), hDC (handle du DC à utiliser pour dessiner le contrôle) et rcItem (le rectangle qui décrit le contour du contrôle). Le champ itemState a également son importance, car il spécifie l'état actuel du contrôle. Sa valeur peut être une ou une combinaison de constantes (indépendantes) définies dans winuser.h parmi lesquels ODS_SELECTED (l'élément est sélectionné c'est-à-dire maintenu enfoncé), ODS_DISABLED (l'élément a été désactivé) et ODS_FOCUS (l'élément a le focus clavier).

Un owner-draw button (bouton personnalisé) est un bouton possédant le style BS_OWNERDRAW. Ce style ne peut être mélangé avec les autres styles de boutons (BS_XXX). Pour dessiner le bouton, il n'est généralement pas nécessaire de traiter le message WM_PAINT. Par contre, il est nécessaire d'ajouter un traitement sur réception des messages WM_MOUSEMOVE et WM_MOUSELEAVE pour le faire changer d'aspect respectivement quand la souris vient le survoler et quand la souris le quitte. Le dessin ne se fera cependant que dans le traitement du message WM_DRAWITEM, c'est-à-dire dans la procédure de fenêtre de la fenêtre parent.

À noter que WM_MOUSELEAVE n'est pas envoyé automatiquement. Pour recevoir ce message, il faut avoir préalablement appelé la fonction TrackMouseEvent qui n'existe que depuis Windows 2000.

Voici un exemple de création et d'utilisation d'un owner-draw button.

#define _WIN32_WINNT 0x0500 /* TrackMouseEvent n'existe que depuis Windows 2000 (Windows NT 5.0). */

#include <windows.h>

/* La structure MYAPP regroupe les variables globales utilisées par notre application. */

typedef struct _MYAPP {
    HWND hCtl; /* Handle du contrôle actuellement survolé par la souris. */
} MYAPP;

MYAPP MyApp;
WNDPROC DefButtonProc; /* "Pointeur" vers l'ancienne procédure de fenêtre de notre bouton. */

#define BUTTON_WIDTH 100
#define BUTTON_HEIGHT 24
#define BUTTON_TEXT "QUIT"

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
void OnCreate(HWND hwnd);
LRESULT CALLBACK ButtonProc(HWND hButton, UINT message, WPARAM wParam, LPARAM lParam);
void OnDrawItem(HWND hwnd, LPDRAWITEMSTRUCT lpdis);
void OnCommand(HWND hwnd, int CtrlID, int Event);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASS wc;
    HWND hWnd;
    MSG msg;
    
    wc.cbClsExtra     = 0;
    wc.cbWndExtra     = 0;
    wc.hbrBackground  = CreateSolidBrush(RGB(0x99, 0xCC, 0xFF));
    wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
    wc.hInstance      = hInstance;
    wc.lpfnWndProc    = WndProc;
    wc.lpszClassName  = "Classe 1";
    wc.lpszMenuName   = NULL;
    wc.style          = CS_HREDRAW | CS_VREDRAW;

    RegisterClass(&wc);

    hWnd = CreateWindow( "Classe 1", "Owner-Draw Button",
        WS_POPUP |WS_BORDER | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        100, 100, 200, 100, NULL, NULL, hInstance, NULL
    );

    ShowWindow(hWnd, nCmdShow);

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
    case WM_CREATE:
        OnCreate(hwnd);
        break;

    case WM_DRAWITEM:
        OnDrawItem(hwnd, (LPDRAWITEMSTRUCT)lParam);
        break;

    case WM_COMMAND:
        OnCommand(hwnd, LOWORD(wParam), HIWORD(wParam));
        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    default:
        return DefWindowProc(hwnd, message, wParam, lParam);
    }

    return 0L;
}

void OnCreate(HWND hwnd)
{
    RECT r;
    int x, y;
    HWND hButton;

    /* Centrer le bouton. */
    
    GetClientRect(hwnd, &r);
    x = (r.right - BUTTON_WIDTH) / 2;
    y = (r.bottom - BUTTON_HEIGHT) / 2;

    hButton = CreateWindow( "BUTTON", "", WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        x, y, BUTTON_WIDTH, BUTTON_HEIGHT, hwnd, (HMENU)1, NULL, NULL
    );

    /* On modifie la procédure de fenêtre du bouton. */

    DefButtonProc = (WNDPROC)SetWindowLongPtr(hButton, GWLP_WNDPROC, (LONG_PTR)ButtonProc);
}

LRESULT CALLBACK ButtonProc(HWND hButton, UINT message, WPARAM wParam, LPARAM lParam)
{
    LRESULT ret = 0L;

    /* A la fin du traitement d'un message, il reste parfois nécessaire d'appeler l'ancienne  */
    /* procédure de fenêtre. Il n'est cependant pas garanti que DefButtonProc soit réellement */
    /* un pointeur de fonction. Il faut appeler CallWindowProc pour utiliser DefButtonProc.   */

    switch(message)
    {
    case WM_MOUSEMOVE: /* Quand la souris survole le bouton ... */

        if (MyApp.hCtl != hButton)
        {
            TRACKMOUSEEVENT tme;

            MyApp.hCtl = hButton; /* Le contrôle actuellement survolé par la souris est hButton. */

            /* Générer WM_MOUSELEAVE quand la souris quitte le bouton. */

            tme.cbSize = sizeof(tme);
            tme.dwFlags = TME_LEAVE;
            tme.hwndTrack = hButton;
            TrackMouseEvent(&tme);

            InvalidateRect(hButton, NULL, TRUE); /* Redessiner le bouton. */
        }

        ret = CallWindowProc(DefButtonProc, hButton, message, wParam, lParam);

        break;

    case WM_MOUSELEAVE: /* Quand la souris quitte le bouton ... */

        MyApp.hCtl = NULL; /* Aucun contrôle n’est actuellement survolé par la souris. */

        InvalidateRect(hButton, NULL, TRUE); /* Redessiner le bouton. */

        ret = CallWindowProc(DefButtonProc, hButton, message, wParam, lParam);

        break;

    default:

        ret = CallWindowProc(DefButtonProc, hButton, message, wParam, lParam);
    }

    return ret;
}

void OnDrawItem(HWND hwnd, LPDRAWITEMSTRUCT lpdis)
{
    if (lpdis->CtlID == 1) /* 1 est l'ID de notre bouton. */
    {
        HDC hDC = lpdis->hDC;
        LPRECT lprcItem = &lpdis->rcItem;
        COLORREF Color;
        HBRUSH hBrush;

        if (lpdis->itemState & ODS_SELECTED) /* Le bouton est pressé. */
            Color = RGB(0x33, 0x33, 0xCC);
        else if (MyApp.hCtl == lpdis->hwndItem) /* Le bouton est survolé par la souris. */
            Color = RGB(0x66, 0x99, 0xFF);
        else /* Le bouton est dans son état normal. */
            Color = RGB(0x66, 0xCC, 0xFF);

        hBrush = CreateSolidBrush(Color);
    
        SelectObject(hDC, hBrush);
        SetBkMode(hDC, TRANSPARENT);
        Rectangle(hDC, lprcItem->left, lprcItem->top, lprcItem->right, lprcItem->bottom);
        DrawText(hDC, BUTTON_TEXT, (int)strlen(BUTTON_TEXT), lprcItem, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        
        DeleteObject(hBrush);
    }
}

void OnCommand(HWND hwnd, int CtrlID, int Event)
{
    if (CtrlID == 1 && Event == BN_CLICKED)
        SendMessage(hwnd, WM_CLOSE, 0, 0);
}