Contrôle du clavier et de la souris sous Windows

C'est la chose la plus simple. Cela se fait par un appel à la fonction GetForegroundWindow(). Cette fonction ne prend pas de paramètre et renvoie une valeur de type HWND (handle de fenêtre). Cette valeur vaut NULL en C ou nil en Pascal si la fonction a échoué. Voici un exemple d'utilisation en langage C :

#include <windows.h>
#include <stdio.h>
int main(int argc, char * argv[])
{
     HWND hFore = GetForegroundWindow();
     printf("le handle de la fenêtre au premier plan est : 0x%X",hFore);
     return 0;
}

Cela nécessite de connaître le nom de la « classe » de composant à laquelle la fenêtre appartient. Le nom de classe ou class name correspond à un identifiant qu'on associe à une fenêtre pour la distinguer d'une autre. Par exemple, WinAMP dans ses versions 1.x et 2.x avait pour nom de classe « Winamp v1.x » ; le nom de classe du lecteur Windows Media est « Media Player 2 ».

Pour récupérer le handle d'une fenêtre dont on connaît le class name, on utilise la fonction FindWindow(). Cette fonction prend deux paramètres : un pointeur vers une chaîne de caractères contenant le class name de la fenêtre recherchée (char * en C, character^ en Pascal) et un pointeur vers une chaîne de caractères contenant le titre de la fenêtre recherchée (optionnel, mettre NULL en C ou nil en Pascal). Elle renvoie une valeur de type HWND (handle de fenêtre). Cette valeur vaut NULL en C ou nil en Pascal si la fonction a échoué. Voici un exemple d'utilisation en langage C :

#include <windows.h>
#include <stdio.h>
int main(int argc, char * argv[])
{
     HWND hMediaplayer = FindWindow("Media Player 2",NULL);
     printf("le handle de la fenêtre de media player 2 est : 0x%X",hMediaplayer);
     return 0;
}

Nous allons maintenant voir quel message envoyerLes différents messages pour le clavier et la souris et comment l'envoyerComment envoyer un message.

Il existe trois messages pour répertorier les actions du clavier, trois messages pour chacun des trois boutons de la souris et un message pour la molette.

III-C-1. Le clavier▲

III-C-2. La souris ▲

L'objectif de cette partie est plus d'expliciter les paramètres qu'on va passer à la fonction PostMessage() que d'expliquer son fonctionnement. Si j'ai choisi d'utiliser PostMessage() plutôt que SendMessage(), c'est parce que j'ai considéré qu'on n'attendait pas de résultat de la part de l'application qu'on cherche à commander.

III-D-1. Le clavier▲

#include <windows.h>
 int main(int argc, char * argv[])
{
     HWND hMPlayer = FindWindow("Media Player 2",NULL);
     SetForegroundWindow(hMPlayer);
     Sleep(100);
     PostMessage(hMPlayer,WM_KEYDOWN,VK_SPACE,0);
     Sleep(5000);
     PostMessage(hMPlayer,WM_KEYUP,VK_SPACE,0);
     return 0;
}

III-D-2. La souris▲

Comme je l'ai dit dans la partie précédente, l’intérêt des événements WM_LBUTTONDOWN, WM_LBUTTONUP et WM_LBUTTONDBLCLK est minime dans notre démarche, nous n'allons donc étudier que l'utilisation du message WM_MOUSEWHEEL.

Le message WM_MOUSEWHEEL fournit quatre informations de 16 bits chacune, réparties entre les mots hauts et bas des deux arguments (32 bits chacun) de PostMessage() restants à notre disposition. Voyons quelles sont les informations à fournir.
Tout d'abord, il y a les états des touches système et des trois boutons de la souris. Ceux-ci sont représentés à l'aide de masques prédéfinis dans le SDK Microsoft par les constantes : MK_CONTROL (Contrôle), MK_SHIFT (Majuscule), MK_LBUTTON, MK_MBUTTON et MK_RBUTTON (boutons gauche, milieu et droit de la souris). Il n'y a aucune garantie que l'application cible s'en serve.

Ensuite, il y a la valeur de la rotation de la molette. Une valeur positive représente une rotation vers le haut (vers le fil de la souris) et une valeur négative représente une rotation vers le bas (vers l'utilisateur). La rotation équivalant à un « cran » de la molette est définie par la constante WHEEL_DELTA (120). Il est possible d'utiliser des valeurs plus précises, mais toutes les applications n'en tiennent pas compte.

Finalement, il y a la positon verticale et horizontale du curseur au moment de l'événement. Là encore, il n'y a aucune garantie que l'application cible s'en serve.

Voyons maintenant comment construire les arguments de PostMessage() à partir de ces informations. La position du curseur doit être placée dans le second paramètre et les autres informations dans le premier. L'exemple ci-dessous montre comment le faire en C :

 

Sélectionnez

int iPosX,iPosY;
int iMasqueTouches;
int iDeplMolette;
DWORD dwWParam,dwLParam;
HWND hWindow;
// initialisation des variables avec les valeurs souhaitées
dwLParam = iPosY << 16 | iPosX; // on effectue un décalage de 16 bits vers la gauche
dwWParam = iDeplMolette << 16 | iMasqueTouches;
PostMessage(hWindow,WM_MOUSEWHEEL, dwWParam, dwLParam);

Une autre solution peut consister à utiliser une structure :

 

Sélectionnez

struct _dword {
     short w1;
     short w2;
} dwWParam, dwLParam;
int iPosX,iPosY;
int iMasqueTouches;
int iDeplMolette;
HWND hWindow;
// initialisation des variables avec les valeurs souhaitées
dwLParam.w1 = iPosY;
dwLParam.w2 = iPosX;
dwWParam.w1 = iDeplMolette;
dwWParam.w2 = iMasqueTouches;
PostMessage(hWindow,WM_MOUSEWHEEL, (DWORD)(dwWParam), (DWORD)(dwLParam));

Voilà, nous avons maintenant tous les éléments dont nous avions besoin pour simuler des actions simples à l'attention d'une application déterminée. Cependant, cela n'est pas suffisant, car on ne peut toujours pas faire de simulation globale ni déplacer la souris : il n'est donc pas possible d'interfacer un périphérique multimédia tel qu'un joystick avec la souris et le clavier. C'est pourquoi nous allons voir dans une deuxième partie comment simuler le clavier et la souris à un niveau beaucoup plus proche de la machine.

Dans cette partie, nous allons voir comment faire croire au système qu'une touche est pressée ou non. Si je parle ici de système et non pas d'application, c'est parce que la fonction que nous allons utiliser n'a pas conscience d'une telle chose. Pour elle, il n'y a qu'un seul logiciel en cours : Windows ; et elle se contente de lui indiquer les modifications d'état du clavier. Il faudra donc prendre en compte lors des futurs développements qu'il n'est pas possible de dire « je veux simuler telle action pour telle fenêtre ».

Pour comprendre le fonctionnement du principe que nous allons voir, il faut considérer que le programme qu'on est en train de réaliser est en réalité le pilote d'un périphérique réel et agir en tant que tel. Les pilotes de périphérique des claviers utilisent la fonction keybd_event() pour indiquer au système l'état des différentes touches. Comme son nom l'indique, cette fonction ne signalera au système que les changements d'état des touches. Il n'y aura donc pas à intercepter les significations d'état que pourraient être amenés à faire d'autres pilotes de périphériques si le système avait voulu qu'on l'informe toutes les n millisecondes de l'état de chacune des touches. Voyons maintenant quels sont les paramètres que la fonction keybd_event() attend.

La fonction keybd() prend quatre paramètres : le code touche virtuel (ENTRÉE, A, F1…), le code matériel de la touche (touche n° 1, n° 2…), un masque indiquant si la touche est une touche étendue et si la touche est relâchée et finalement un double mot contenant des informations supplémentaires. Les codes de touches virtuels ont été présentés dans la partie précédenteLe clavier :. Les codes matériels de touche ne sont pas utiles pour nous, car ils correspondent à une étape antérieure des pilotes de périphérique ; nous le laisserons donc à 0. Le masque est composé à partir de KEYEVENTF_EXTENDEDKEY qui indique que la touche est soit AltGr soit Ctrl droite, et KEYEVENTF_KEYUP qui indique que la touche est relâchée. Finalement le dernier paramètre est une donnée complémentaire qui ne nous sert à rien non plus, on le laissera donc à 0. Voici un exemple dans lequel on considère que par exemple le lecteur Windows Media est en train de lire une vidéo. Notre programme exemple va simuler la pression de Alt + Entrée pour faire passer le lecteur en mode plein écran.

#include <windows.h>
int main(int argc, char *argv[])
{
    SetForegroundWindow(FindWindow("Media Player 2",NULL));
    Sleep(100);
    keybd_event(VK_LMENU,0,0,0);
    keybd_event(VK_RETURN,0,0,0);
    keybd_event(VK_RETURN,0,KEYEVENTF_KEYUP,0);
    keybd_event(VK_LMENU,0,KEYEVENTF_KEYUP,0);
    return 0;
}

De la même façon que précédemment, nous allons faire croire au système qu'il y a eu un clic ou un mouvement de souris. Contrairement au cas du clavier, nous allons avoir besoin de plusieurs fonctions. Nous allons donc partager cette partie en deux thèmes : le déplacement du curseur d'une part et les clics et autres tours de molettes d'autre part.

IV-B-1. Déplacer le curseur▲

#include <windows.h>
int main(int argc, char *argv[])
{
     POINT pt;
     BOOL bContinue = TRUE;
     const SHORT Mask = 32768;
     while (bContinue)
     {
          if (GetKeyState(VK_ESCAPE) & Mask)
               bContinue = FALSE;
          GetCursorPos(&pt);
          if (GetKeyState(VK_UP) & Mask)
               pt.y -= 1;
          if (GetKeyState(VK_DOWN) & Mask)
               pt.y += 1;
          if (GetKeyState(VK_LEFT) & Mask)
               pt.x -= 1;
          if (GetKeyState(VK_RIGHT) & Mask)
               pt.x += 1;
          SetCursorPos(pt.x,pt.y);
          Sleep(10);
     }
     return 0;
}

IV-B-2. Simuler les clics et la mollette▲

#include <windows.h>
int main(int argc, char *argv[])
{
     POINT pt;
     BOOL bContinue = TRUE;
     SHORT Mask = 32768;
     DWORD dwEventFlags;
     DWORD dwData;

     while (bContinue)
     {
          dwData = 0;
          dwEventFlags = MOUSEEVENTF_ABSOLUTE;
          if (GetKeyState(VK_ESCAPE) & Mask)
               bContinue = FALSE;
          GetCursorPos(&pt);
          if (GetKeyState(VK_NUMPAD1) & Mask)
          {
               if (!(GetKeyState(VK_LBUTTON) & Mask))
                   dwEventFlags |= MOUSEEVENTF_LEFTDOWN;
          }
          else if (GetKeyState(VK_LBUTTON) & Mask)
               // Ce test est nécessaire pour s'assurer qu'on n'envoie pas plus
               // de relevés de touche que d'abaissements
               dwEventFlags |= MOUSEEVENTF_LEFTUP;
          if (GetKeyState(VK_NUMPAD2) & Mask)
          {
               if (!(GetKeyState(VK_MBUTTON) & Mask))
                   dwEventFlags |= MOUSEEVENTF_MIDDLEDOWN;
          }
          else if (GetKeyState(VK_MBUTTON) & Mask)
               dwEventFlags |= MOUSEEVENTF_MIDDLEUP;
          if (GetKeyState(VK_NUMPAD3) & Mask)
          {
               if (!(GetKeyState(VK_RBUTTON) & Mask))
                   dwEventFlags |= MOUSEEVENTF_RIGHTDOWN;
          }
          else if GetKeyState(VK_R3BUTTON) & Mask)
               dwEventFlags |= MOUSEEVENTF_RIGHTUP;
          if (GetKeyState(VK_SUBTRACT) & Mask)
          {
               dwEventFlags |= MOUSEEVENTF_WHEEL;
               dwData += WHEEL_DELTA;
          }
          else if (GetKeyState(VK_ADD) & Mask)
          {
               dwEventFlags |= MOUSEEVENTF_WHEEL;
               dwData -= WHEEL_DELTA;
          }
          if (GetKeyState(VK_UP) & Mask)
               pt.y -= 1;
          if (GetKeyState(VK_DOWN) & Mask)
               pt.y += 1;
          if (GetKeyState(VK_LEFT) & Mask)
               pt.x -= 1;
          if (GetKeyState(VK_RIGHT) & Mask)
               pt.x += 1;
          SetCursorPos(pt.x,pt.y);
          mouse_event(dwEventFlags,pt.x,pt.y,dwData,0);
          Sleep(10);
     }
     return 0;
}

Comme vous avez pu le remarquer, on aurait bien souvent besoin d'une fonction hybride entre PostMessage() et keybd_event(). En effet, il n'est pas possible de simuler le raccourci clavier ALT + ENTRÉE avec la fonction PostMessage() et l'utilisation de keybd_event() ne permet pas de limiter l'événement à une application cible. Par ailleurs, une combinaison de ces deux fonctions ne résout pas le problème à coup sûr. Le problème vient du fait que la fonction PostMessage() n'attend pas que le message ait été traité par l'application cible avant de rendre la main à notre programme de contrôle. Pour parer à ce problème, on est obligé d'utiliser la fonction SendMessage() qui a le même prototype que PostMessage(), mais qui attend que le message ait été traité pour rendre la main. Cependant, si l'application cible ne rend pas la main très rapidement il y a de grandes chances pour que l'utilisateur appuie sur une touche du clavier pendant ce laps de temps et on ne peut pas mesurer les conséquences de cette interférence. La seule solution qui nous reste est donc d'espérer que l'utilisateur sera loin de son clavier au moment où on effectuera la simulation.

Voyons un bref exemple de simulation pseudociblée d'un raccourci clavier. Nous allons faire passer l'affichage de la vidéo du lecteur Windows Media en plein écran (ou inverse)

#include <windows.h>
#include <stdio.h>
int main(int argc, char * argv[])
{
     HWND hMediaplayer = FindWindow("Media Player 2",NULL);
     if (hMediaplayer)
     {
          keybd_event(VK_LMENU,0,0,0);
          SendMessage(hMediaPlayer,WM_CHAR,VK_RETURN,0);
          keybd_event(VK_LMENU,0,KEYEVENTF_KEYUP,0);
     }
     return 0;
}

Voici un exemple de programme permettant de retrouver le class name d'une fenêtre quelconque. Celui-ci est facilement adaptable à une interface graphique pour que n'importe quel utilisateur puisse fournir le class name au programme qui en a besoin.

#include <windows.h>
#include <stdio.h>
#include <conio.h>
int main(int argc, char * argv[])
{
     HWND hFore;
     char szBuffer[128];
     int iNbChar;

     printf("Vous avez 5 secondes pour activer la fenêtre dont vous voulez connaître le class name\r\n");
     printf("Appuyez sur une touche pour déclencher le compteur ...");
     getch();
     Sleep(5000);

     hFore = GetForegroundWindow();
     iNbChar = GetClassName(hFore,szBuffer,128);
     if (iNbChar && (iNbChar < 128))
     {
          printf("\r\nLe class name de cette fenêtre est :\r\n|%s|",szBuffer);
          printf("\r\nLes barres verticales (|) de gauche et droite n'en font pas partie\r\n");
     }
     else
     {
          printf("Impossible de récupérer le class name ou celui-ci est trop long\r\n");
     }
     return 0;
}

Un hook est un moyen de contrôler ce qui transite par le système de gestion de messages de Windows : c'est comme si on dénudait un fil électrique et qu'on y branchait un appareil de mesure pour voir ce qui s'y passe. La mise en place d'un hook va permettre de demander au système d'exploitation de faire un appel à une fonction de notre cru à chaque fois qu'il rencontrera un certain type de message et avant de le transmettre à l'application cible.

L'API Win32 propose actuellement 11 types de hooks dont deux sont spécialisés en deux sous-types chacun soit un total de 13 hooks possibles. Chaque type de hook permet à une application de surveiller différents aspects du mécanisme de gestion des messages de Windows.

Voici un bref descriptif de chacun d'entre eux :

Ce tutoriel étant destiné à la gestion du clavier et de la souris, nous ne verrons que les hooks WH_MOUSE et WH_KEYBOARD, mais les autres hooks s'utilisent exactement de la même façon.

Deux problèmes se posent lorsqu'on veut créer un hook. Premièrement, si celui-ci est destiné à observer les événements du système complet, on ne peut pas implémenter la fonction associée à ce crochet dans un programme séparé, mais on est obligé de le faire dans une DLL séparée. Exactement comme un programme normal qui ne peut se servir d'une fonction développée par un tiers que si elle se trouve dans une DLL (et autres ActiveX…) et non dans un programme normal. Deuxièmement, la fonction qui gère le hook doit transmettre le message qu'elle a reçu dans la chaîne et pour cela elle a besoin du handle du hook ; hors, si on pourrait être tenté de stocker cette information de manière globale, cela ne résout en rien le problème, car il existe en réalité une instance de la DLL par processus recevant des messages ce qui implique que le handle ne serait connu que du processus appelant et que cela provoquerait des erreurs dans les autres applications. On va donc devoir créer une zone de mémoire nommée afin que toutes les instances de la DLL puissent accéder à ce handle de hook.

Dans l'exemple exposé dans la partie suivante, on considérera qu'on évolue sous Borland C++ Builder et qu'on a utilisé l'expert DLL. Pour des informations complémentaires concernant la création de DLL dans BC++ Builder, voyez ce tutoriel de LFE.

Pour mettre en place un hook, il suffit d'un appel à la fonction SetWindowsHookEx() et pour l'arrêter nous ferons appel à UnhookWindowsHookEx(). SetWindowsHookEx() prend quatre arguments : le type de hook à mettre en place, le pointeur sur la fonction à utiliser pour le hook, l'instance de la DLL contenant la fonction de hook et finalement l'identifiant du thread à hooker. Elle renvoie le handle du hook créé qui a pour la valeur NULL en cas d'échec. UnhookWindowsHookEx() prend comme seul paramètre le handle du hook à défaire et renvoie la constante FALSE si elle échoue.

Voyons le prototype de la fonction de hook :

LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam);

Pour chaque type de hook, ces trois paramètres ont une signification particulière : nCode est un indicateur pour l'action à effectuer et wParam et lParam contiennent les informations du message qui a été envoyé. La valeur renvoyée par cette fonction doit être celle renvoyée par la fonction de propagation du message, CallNextHookEx(). Cette fonction prend en paramètres le handle du hook qu'on vient de gérer, suivi des arguments reçus par HookProc(), éventuellement modifiés. Si le message est intercepté par le hook (pas d'appel à CallNextHookEx()), la valeur renvoyée par HookProc() devrait être nulle (0L en C).

Détaillons maintenant le contenu des paramètres pour les fonctions associées à WH_KEYBOARD et à WH_MOUSE.

- WH_KEYBOARD
Le paramètre nCode prend sa valeur parmi HC_ACTION et HC_NOREMOVE. Dans le cas (rare) de la seconde valeur, cela veut dire qu'une application a lu le message sans le retirer de la file par un appel à PeekMessage() spécifiant le drapeau PM_NOREMOVE. Dans tous les cas, wParam et lParam contiennent les informations à propos de l'événement clavier. Il peut arriver que ce paramètre ait une valeur négative, la fonction doit alors immédiatement se terminer dans un appel à CallNextHookEx().
Les paramètres wParam et lParam contiennent les mêmes informations que dans le cas de WM_KEYDOWN ou WM_KEYUP : le code virtuel de la touche actionnée et les informations de répétition, d'état…

- WH_MOUSE
Le paramètre nCode prend sa valeur parmi HC_ACTION et HC_NOREMOVE. Dans le cas (rare) de la seconde valeur, cela veut dire qu'une application a lu le message sans le retirer de la file par un appel à PeekMessage() spécifiant le drapeau PM_NOREMOVE. Dans tous les cas, wParam et lParam contiennent les informations à propos de l'événement souris. Il peut arriver que ce paramètre ait une valeur négative, la fonction doit alors immédiatement se terminer dans un appel à CallNextHookEx().
Le paramètre wParam contient le type du message (WM_LBUTTONDOWN à WM_MOUSEWHEEL)
Le paramètre lParam contient un pointeur sur une structure MOUSEHOOKSTRUCT qui, elle, contient une structure POINT indiquant la position de la souris ; le handle de la fenêtre qui va recevoir le message ; le type de cible qui se trouve sous la souris et finalement des informations complémentaires pour le message. Voici un tableau exhaustif des types de cibles.

Voyons maintenant un exemple de DLL permettant le hook du clavier et de la souris. Celle-ci sera composée de cinq fonctions : la fonction d'initialisation (fermeture) de la DLL qui attachera (détachera) la zone de mémoire partagée, la fonction d'initialisation des hooks, la fonction de destruction des hooks et les deux fonctions de crochetage (clavier et souris).

Voici le code de la DLL. Le fichier compilé sera nommé « hooksClSo.dll ».

#include <windows.h>
// Définition de la structure de la zone mémoire partagée

typedef struct _TDonnees
{
     HHOOK MouseHookHandle; // Handle du hook de la souris 
     HHOOK KeybdHookHandle; // Handle du hook du clavier
     HWND hDestWindow; // Handle de la fenêtre à laquelle le hook du clavier doit les données
     // Mettez ici toutes les données que vous voulez partager
} TDonnees;

// Déclaration des variables globales de la DLL
HANDLE MemPartagee; // Handle de la zone de mémoire partagée
TDonnees * VueDonnees; // Pointeur vers la zone de mémoire
HINSTANCE HInst; // Handle d'instance de la DLL

// Déclaration des fonctions de la DLL
void _export InitHook(HWND hDest);
void _export EndHook();
LRESULT CALLBACK MouseProc(int nCode,WPARAM wParam,LPARAM lParam);
LRESULT CALLBACK KeybdProc(int nCode,WPARAM wParam,LPARAM lParam);

// fonction d'initialisation de la DLL
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
     HInst = hinst;
     switch (reason)
     {
          case DLL_PROCESS_ATTACH : // à la création de l'instance de la DLL
               // Attachement d'une zone de mémoire partagée (notez le cast)
               MemPartagee = CreateFileMapping((HANDLE)0xFFFFFFFF, // On map un espace mémoire
                                        NULL, // Pas d'informations de sécurité
                                        PAGE_READWRITE, // Partage en lecture/écriture
                                        0, // Taille de la zone réservée sur 64 bits (32 bits de poids fort)
                                        sizeof(TDonnees), // 32 bits de poids faible
                                        "Tutoriel Hooks par gRRosminet"); // Nom de la zone réservée

               // Création d'une vue pour pouvoir accéder à la zone de mémoire partagée (notez le cast)
               VueDonnees = (TDonnees *)(MapViewOfFile((HANDLE)MemPartagee, // Zone sur laquelle créer la vue
                                        FILE_MAP_WRITE, // Mode d'accès en lecture/écriture
                                        0, 0, // Offset de début de la vue sur 64 bits
                                        0)); // Taille de la vue (0 = tout)
                                        break;

          case DLL_PROCESS_DETACH : // au détachement de la DLL
               // Destruction de la vue sur la zone de mémoire partagée
               UnmapViewOfFile((LPVOID)VueDonnees);
               // Détachement de la zone de mémoire partagée
               CloseHandle(MemPartagee);
               break;

          default :
               // DLL_THREAD_ATTACH, DLL_THREAD_DETACH
               break;
     }
     return 1;
}

void _export InitHook(HWND hDest) // _export est spécifique à BCB 
{
     // Installation du hook sur la souris
     VueDonnees->MouseHookHandle = SetWindowsHookEx(WH_MOUSE, // Créer un hook sur la souris
                                             (HOOKPROC)MouseProc, // Utiliser la fonction MouseProc
                                             HInst, // Dans la DLL d'instance HInst
                                             0); // Pour tous les threads

     // Installation du hook pour le clavier
     VueDonnees->KeybdHookHandle = SetWindowsHookEx(WH_KEYBOARD, // Créer un hook sur le clavier
                                             (HOOKPROC)KeybdProc, // Utiliser la fonction KeybdProc
                                             HInst, // Dans la DLL d'instance HInst
                                             0); // Pour tous les threads


     // Partage de la fenêtre destinatrice des données du clavier
     VueDonnees->hDestWindow = hDest;
}

void _export EndHook()
{
     // Supression des hooks
     UnhookWindowsHookEx(VueDonnees->MouseHookHandle);
     UnhookWindowsHookEx(VueDonnees->KeybdHookHandle);
}

LRESULT CALLBACK _export MouseProc(int nCode,WPARAM wParam,LPARAM lParam)
{
     // On joue un son à chaque fois que l'utilisateur enfonce le bouton gauche
     if (wParam == WM_LBUTTONDOWN)
              MessageBeep(MB_OK);
         return CallNextHookEx(VueDonnees->MouseHookHandle,nCode,wParam,lParam);
}

#define WMAP_KEYBDHOOKMSG WM_APP + 1

LRESULT CALLBACK _export KeybdProc(int nCode,WPARAM wParam,LPARAM lParam)
{
     // On envoie un message WMAP_KEYBDHOOKMSG à chaque fois que
         // l'utilisateur presse la touche ENTRÉE
     if (wParam == VK_RETURN)

          PostMessage(VueDonnees->hDestWindow, WMAP_KEYBDHOOKMSG, 0, 0);

     return CallNextHookEx(VueDonnees->KeybdHookHandle,nCode,wParam,lParam);
}

#ifndef appliH
#define appliH

#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>

typedef void (*TInitFunc)(HWND);
typedef void (*TEndFunc)();
         
#define WMAP_KEYBDHOOKMSG WM_APP + 1
         
class TForm1 : public TForm
{
     __published: // Composants gérés par l'EDI
          TCheckBox *CheckBox1;
          TLabel *Label1;
          void          __fastcall CheckBox1Click(TObject *Sender);
          void          __fastcall FormClose(TObject *Sender, TCloseAction &Action);
     private: // Déclarations utilisateur
          TInitFunc InitHooks; // fonction d'initialisation des hooks
          TEndFunc EndHooks; // fonction de suppression des hooks
          HINSTANCE hinstDLL; // instance de la DLL
          bool bHook; // Les hooks ont-ils été initialisés ?
          int nbEntree; // compteur de pressions pour le gestionnaire de messages
     public: // Déclarations utilisateur
          void __fastcall PressionEntree(TWMNoParams &p);
          __fastcall TForm1(TComponent* Owner);
     protected: // déclaration du gestionnaire de messages
          BEGIN_MESSAGE_MAP
               VCL_MESSAGE_HANDLER(WMAP_KEYBDHOOKMSG, TWMNoParams, PressionEntree)
          END_MESSAGE_MAP(TForm)
};

extern PACKAGE TForm1 *Form1;

#endif

Voyons maintenant du côté du source :

#include <vcl.h>
#include "appli.h"

#pragma package(smart_init)
#pragma resource "*.dfm"
         
TForm1 *Form1;
         
__fastcall TForm1::TForm1(TComponent* Owner)
          : TForm(Owner)
{
     bHook = false; // Les hooks ne sont pas initialisés
     hinstDLL = LoadLibrary("hooksClSo.dll"); // Chargement de la librairie
     if (!hinstDLL) // Erreur lors du chargement de la librairie ?
          Application->MessageBox("Impossible de charger la librairie.","gloups",MB_OK);
     else
         {
          // On récupère les adresses des fonctions
          InitHooks = (TInitFunc)GetProcAddress(hinstDLL, "_InitHook");
          EndHooks = (TEndFunc)GetProcAddress(hinstDLL, "_EndHook");
     }
}
         
void __fastcall TForm1::CheckBox1Click(TObject *Sender)
{
     if (!hinstDLL) // La librairie n'est pas chargée, inutile de continuer
          Close();
     else if (CheckBox1->Checked) // Activer les hooks
     {
          nbEntree = 0; // On réinitialise le compteur
          InitHooks(Form1->Handle); // On initialise les hooks
     }
     else // Désactiver les hooks
          EndHooks(); // On supprime les hooks
     }

 void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
     if (bHook) // Si les hooks sont actifs, on les supprime avant de quitter
          EndHooks();
         
     Action = caFree;
}
                 
void __fastcall TForm1::PressionEntree(TWMNoParams &p)
{
     nbEntree++; // On a reçu un message du hook : on incrémente et on affiche le compteur
     Label1->Caption = AnsiString("Pressions de ENTREE : ") + nbEntree;
}

Une fois compilé, cet exemple permettra de compter les pressions et relâchements de la touche ENTREE, et jouera le son « par défaut » de Windows à chaque clic de souris.