Récupérer et traiter les touches du clavier

LES INFORMATIONS CONTENUES DANS CE DOCUMENT SONT FOURNIES SANS GARANTIE
D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. LE DESTINATAIRE ASSUME LE RISQUE
DE L'UTILISATION DU CONTENU DE CE DOCUMENT.

Cet article suppose que vous êtes familier avec le langage de
développement VISUAL BASIC (ACCESS BASIC pour les versions antérieures à
Microsoft Access 7.00 pour Windows 95), et avec la création d'application
MICROSOFT ACCESS.

Cet exemple est fourni à titre d'information pour les utilisateurs
avertis. Si vous utilisez incorrectement des fonctions API, vous risquez
de causer des erreurs au niveau de votre système d'exploitation et de
devoir redémarrer votre ordinateur. Pour plus d'informations concernant
l'utilisation des API WINDOWS avec MICROSOFT ACCESS veuillez vous référer
aux documentations du WINDOWS SDK (SOFTWARE DEVELOPMENT KIT).

Comment connaître et traiter les touches du clavier par anticipation pour
éviter un déclenchement d'action sur un contrôle de formulaire ou au
niveau du formulaire lui-même ?

Cet article technique propose plusieurs méthodes pour traiter la gestion
des touches claviers dans un formulaire ACCESS.

Méthode simple : Evénement "Sur sortie".
****************************************
Cet exemple explique comment tester si les touches clavier : Entrée,
Tabulation, Majuscule-Tabulation, Page-Suivante, Page-Précèdente ont été
pressés sur un contrôle d'un formulaire et ainsi contourner ou éviter
toute action sensé se déclencher.

AVANTAGE :
Simple à mettre en place.
INCONVENIENT :
Il sera nécessaire de créer une procédure événementielle de ce type sur
l'événement "Sur sortie" de tous les contrôles à traiter, donc autant de
fois le code à copier/coller que de contrôles à gérer.

Vous trouverez ci-dessous un exemple en Visual Basic qui annule l'action
la frappe de touches clavier.

Private Sub Adresse_KeyDown(KeyCode As Integer, Shift As Integer)
Select Case KeyCode
Case 13, 9, 33, 34
KeyCode = 0
Case Else
Debug.Print KeyCode, Shift
End Select
End Sub

Remarque :
- Pour Access 2.0, voir le fichier CONSTANT.TXT du répertoire ACCESS,
pour les constantes et valeur des touches clavier.
- Pour Access 7.0, à partir d'une fenêtre de module, choisir
l'Explorateur d'Objet à partir de la commande Affichage, dans la liste
nommée "Access - Microsoft Access for Windows 95", dans la liste
"Modules/Class" choisir Constants.


Méthode avec API .
*****************

Pour Microsoft Access 2.0
-------------------------

Cet exemple montre comment utiliser la fonction API GetKeyState() de
Windows pour détecter quelle touche ou combinaisons de touches a été
frappé au clavier pour quitter un contrôle d'un formulaire. Cette
technique permet d'éviter de quitter un contrôle de formulaire ou d'être
rediriger sur une action spécifique.

Tout en utilisant l'API et un code proche de la fonction
VerifieToucheClavier () ci-dessous, on pourrait créer une procédure
événementielle sur l'événement "Sur sortie" de tous les contrôles à
traiter.

La méthode proposée ici permet d'activer la gestion des touches clavier
en une seule fois à l'aide de trois fonctions Access Basic.

AVANTAGE :

- Permet de gérer les touches clavier au niveau du formulaire complet, au
niveau de l'application complète.
- Activer ou désactiver à tout moment la gestion des touches clavier

INCONVENIENT :
Méthode relativement complexe avec API.

1. Créer un nouveau module général.
Dans la section déclarations, entrer le code suivant :

' **** SECTION DECLARATIONS ******************************
Option Compare Database 'Utilise l'ordre de la base pour les
comparaisons de chaînes
Option Explicit

Global Const VK_CONTROL = &H11
Global Const VK_SHIFT = &H10

Global Const VK_TAB = &H9
Global Const VK_RETURN = &HD
Global Const VK_PRIOR = &H21 ' PGUP
Global Const VK_NEXT = &H22 ' PGDN

Declare Function GetKeyState% Lib "user.exe" (ByVal nKey%)

Global TestControleTouches As Integer'
********************************************************

Puis saisir les trois fonctions suivante dans un nouveau module générale
ACCESS BASIC :

Function ActiveControlTouches ()
Dim x As Integer

' Initialise à Vrai la variable Global TestControleTouches
TestControleTouches = True

' Active la fonction VerifieToucheClavier()
x = VerifieToucheClavier()

End Function

Function StopControlTouches ()

' Initialise à Vrai la variable Global TestControleTouches
' déclenche l'action de quitter-désactiver la fonction
VerifieToucheClavier
TestControleTouches = False

End Function

Function VerifieToucheClavier ()
Dim sControl As String
Dim sShift As String

Do
DoEvents
sControl = ""
sShift = ""

' Teste la frappe de la touche clavier Contrôle CTRL or Majuscule SHIFT
If GetKeyState(VK_CONTROL) < 0 Then sControl = "Ctrl+"
If GetKeyState(VK_SHIFT) < 0 Then sShift = "Shift+"

' Teste la frappe de la touche clavier TABulation
If GetKeyState(VK_TAB) < 0 Then
MsgBox "Vous venez d'appuyer sur les touches " & sControl & sShift &
"TABULATION!"
End If

' Teste la frappe de la touche clavier ENTREE
If GetKeyState(VK_RETURN) < 0 Then
MsgBox "Vous venez d'appuyer sur les touches " & sControl & sShift &
"ENTREE !"
End If

' Teste la frappe de la touche clavier PAGE SUIVANTE
If GetKeyState(VK_NEXT) < 0 Then
MsgBox "Vous venez d'appuyer sur les touches " & sControl & sShift &
"PAGE SUIVANTE !"
End If

' Teste la frappe de la touche clavier PAGE PRECEDENTE
If GetKeyState(VK_PRIOR) < 0 Then
MsgBox "Vous venez d'appuyer sur les touches " & sControl & sShift &
"PAGE PRECEDENTE !"
End If
DoEvents
Loop While TestControleTouches = True

End Function

2. Pour tester cette nouvelle fonctionnalité, créez une nouvelle macro
avec les actions suivantes :

OuvrirFormulaire: "Nom du Formulaire"
ExecuterCode: =ActiveControlTouches()

Vous pouvez également en mode modification du formulaire créer deux
controles de types bouton de commande avec les caractéristiques
suivantes:

Bouton1 :
---------
Légende : Stoppe la gestion des Touches Clavier.
Evénement Sur Clic : = StopControlTouches ()

Bouton2:
--------
Légende : Active la gestion des Touches Clavier.
Evénement Sur Clic : = =ActiveControlTouches ()

EXPLICATION :

L'exemple est conçu de telle sorte qu'après le chargement du formulaire
la gestion des touches est activée pour l'ensemble de l'application, d'où
la possibilité de gérer cette gestion par ces deux boutons de commande.

3. Pour tester, charger le formulaire, et essayer de quitter-sortir du
contrôle que vous avez modifié à l'étape 2.


AUTRE EXEMPLE : Désactiver les touches PAGE PRECEDENTE et PAGE SUIVANTE
*************************************************************************
*

Désactiver les touches du clavier PAGE PRECEDENTE et PAGE SUIVANTE AVEC
l'API GetKeyState() Windows sur un formulaire

1. Créer dans un nouveau module général le code suivant :

Option Explicit
Global Const VK_PRIOR = &H21 ' PGUP
Global Const VK_NEXT = &H22 ' PGDN
Declare Function GetKeyState% Lib "user.exe" (ByVal nKey%)

Function DésactivePGUP_PGDN()
If GetKeyState(VK_PRIOR) < 0 Or GetKeyState(VK_NEXT) < 0 Then
DoCmd CancelEvent
End If
End Function

2. Sur la propriété SUR SORTIE de tous les contrôles d'un formulaire dont
vous souhaitez désactiver les touches du clavier PAGE PRECEDENTE et PAGE
SUIVANTE, taper :
=DésactivePGUP_PGDN()


Méthode Access 7.0 : propriété Aperçu des touches (KeyPreview)
***************************************************************
La propriété Aperçu des touches (KeyPreview) vous permet de spécifier si
les événements de clavier du formulaire sont appelés avant les évènements
de clavier des contrôles.

Vous pouvez utiliser la propriété Aperçu des touches (KeyPreview) pour
créer une procédure de gestion du clavier pour un formulaire. Par
exemple, lorsqu'une application utilise des touches de fonction,
l'attribution de la valeur OUI à la propriété Aperçu des touches
(KeyPreview) vous permet de traiter les frappes de touches au niveau du
formulaire plutôt que de devoir écrire du code pour chacun des contrôles
qui pourrait recevoir des événements de frappe de touches.

Cet exemple explique comment tester si les touches clavier : Entrée,
Tabulation, Majuscule-Tabulation, Page-Suivante, Page-Précèdente ont été
pressés dans un formulaire et ainsi par anticipation contourner ou éviter
toute action sensée se déclencher.

Solution :
1. Afficher les propriétés du formulaire, et affecter la valeur Oui à la
propriété Aperçu des touches.

2. Sur l'événement Sur Touche Appuyée créer le code en Visual Basic qui
annule l'action la frappe de touches clavier avant celle des contrôles.

Private Sub Adresse_KeyDown(KeyCode As Integer, Shift As Integer)
Select Case KeyCode
Case 13, 9, 33, 34
KeyCode = 0
Case Else
Debug.Print KeyCode, Shift
End Select
End Sub