Partager via

Tables accélérateurs

  • Article

Les applications définissent souvent des raccourcis clavier, tels que Ctrl+O pour la commande Ouvrir de fichier. Vous pouvez implémenter des raccourcis clavier en gérant des messages WM_KEYDOWN individuels, mais les tables accélérateurs offrent une meilleure solution :

  • Nécessite moins de codage.
  • Consolide tous vos raccourcis dans un seul fichier de données.
  • Prend en charge la localisation dans d’autres langues.
  • Permet aux raccourcis et aux commandes de menu d’utiliser la même logique d’application.

Une table d’accélérateur est une ressource de données qui mappe des combinaisons de clavier, telles que Ctrl+O, aux commandes d’application. Avant de voir comment utiliser une table accélérateur, nous aurons besoin d’une présentation rapide des ressources. Une ressource est un objet blob de données intégré à un fichier binaire d’application (EXE ou DLL). Les ressources stockent les données nécessaires par l’application, telles que les menus, les curseurs, les icônes, les images, les chaînes de texte ou toutes les données d’application personnalisées. L’application charge les données de ressource à partir du fichier binaire au moment de l’exécution. Pour inclure des ressources dans un fichier binaire, procédez comme suit :

  1. Créez un fichier de définition de ressource (.rc). Ce fichier définit les types de ressources et leurs identificateurs. Le fichier de définition de ressource peut inclure des références à d’autres fichiers. Par exemple, une ressource d’icône est déclarée dans le fichier .rc, mais l’image d’icône est stockée dans un fichier distinct.
  2. Utilisez le compilateur de ressources Microsoft Windows (RC) pour compiler le fichier de définition de ressource dans un fichier de ressource compilé (.res). Le compilateur RC est fourni avec Visual Studio et le Kit de développement logiciel (SDK) Windows.
  3. Liez le fichier de ressources compilé au fichier binaire.

Ces étapes sont approximativement équivalentes au processus de compilation/lien pour les fichiers de code. Visual Studio fournit un ensemble d’éditeurs de ressources qui facilitent la création et la modification des ressources. (Ces outils ne sont pas disponibles dans les éditions Express de Visual Studio.) Toutefois, un fichier .rc est simplement un fichier texte et la syntaxe est documentée sur MSDN. Il est donc possible de créer un fichier .rc à l’aide de n’importe quel éditeur de texte. Pour plus d’informations, consultez À propos des fichiers de ressources.

Définition d’une table accélérateur

Une table d’accélérateurs est une table de raccourcis clavier. Chaque raccourci est défini par :

  • Identificateur numérique. Ce numéro identifie la commande d’application qui sera appelée par le raccourci.
  • Caractère ASCII ou code clé virtuelle du raccourci.
  • Touches de modification facultatives : Alt, Maj ou Ctrl.

La table accélérateur elle-même a un identificateur numérique, qui identifie la table dans la liste des ressources de l’application. Créons une table d’accélérateurs pour un programme de dessin simple. Ce programme aura deux modes, le mode dessin et le mode de sélection. En mode dessin, l’utilisateur peut dessiner des formes. En mode sélection, l’utilisateur peut sélectionner des formes. Pour ce programme, nous aimerions définir les raccourcis clavier suivants.

Raccourci Commander
Ctrl+M Basculez entre les modes.
F1 Basculez vers le mode dessin.
F2 Basculez vers le mode de sélection.

 

Tout d’abord, définissez des identificateurs numériques pour la table et pour les commandes d’application. Ces valeurs sont arbitraires. Vous pouvez affecter des constantes symboliques pour les identificateurs en les définissant dans un fichier d’en-tête. Par exemple:

#define IDR_ACCEL1                      101
#define ID_TOGGLE_MODE                40002
#define ID_DRAW_MODE                  40003
#define ID_SELECT_MODE                40004

Dans cet exemple, la valeur IDR_ACCEL1 identifie la table d’accélérateurs et les trois constantes suivantes définissent les commandes d’application. Par convention, un fichier d’en-tête qui définit les constantes de ressource est souvent nommé resource.h. La liste suivante montre le fichier de définition de ressource.

#include "resource.h"

IDR_ACCEL1 ACCELERATORS
{
    0x4D,   ID_TOGGLE_MODE, VIRTKEY, CONTROL    // ctrl-M
    0x70,   ID_DRAW_MODE, VIRTKEY               // F1
    0x71,   ID_SELECT_MODE, VIRTKEY             // F2
}

Les raccourcis accélérateurs sont définis dans les accolades. Chaque raccourci contient les entrées suivantes.

  • Code de clé virtuelle ou caractère ASCII qui appelle le raccourci.
  • Commande d’application. Notez que les constantes symboliques sont utilisées dans l’exemple. Le fichier de définition de ressource inclut resource.h, où ces constantes sont définies.
  • Le mot clé VIRTKEY signifie que la première entrée est un code de clé virtuelle. L’autre option consiste à utiliser des caractères ASCII.
  • Modificateurs facultatifs : ALT, CONTROL ou Maj.

Si vous utilisez des caractères ASCII pour les raccourcis, un caractère minuscule est un raccourci différent d’un caractère majuscule. (Par exemple, la saisie de « a » peut appeler une commande différente de la saisie de « A ». Cela peut confondre les utilisateurs. Il est donc généralement préférable d’utiliser des codes de touche virtuelle, plutôt que des caractères ASCII, pour les raccourcis.

Chargement de la table accélérateur

La ressource de la table accélérateur doit être chargée avant que le programme puisse l’utiliser. Pour charger une table d’accélérateurs, appelez la fonction LoadAccelerators.

    HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCEL1));

Appelez cette fonction avant d’entrer la boucle de message. Le premier paramètre est le handle du module. (Ce paramètre est transmis à votre fonction WinMain. Pour plus d’informations, consultez WinMain : le point d’entrée d’application.) Le deuxième paramètre est l’identificateur de ressource. La fonction retourne un handle à la ressource. Rappelez-vous qu’un handle est un type opaque qui fait référence à un objet géré par le système. Si la fonction échoue, elle retourne NULL .

Vous pouvez libérer une table d’accélérateurs en appelant DestroyAcceleratorTable. Toutefois, le système libère automatiquement la table lorsque le programme se ferme. Vous n’avez donc besoin d’appeler cette fonction que si vous remplacez une table par une autre. Il existe un exemple intéressant de ceci dans la rubrique Création d’accélérateurs modifiables utilisateur.

Traduction de traits de clé en commandes

Une table d’accélérateurs fonctionne en convertissant les traits de clé en messages WM_COMMAND. Le paramètre wParam de WM_COMMAND contient l’identificateur numérique de la commande. Par exemple, à l’aide du tableau indiqué précédemment, le trait de touche Ctrl+M est traduit en message WM_COMMAND avec la valeur ID_TOGGLE_MODE. Pour ce faire, modifiez votre boucle de message en procédant comme suit :

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(win.Window(), hAccel, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

Ce code ajoute un appel à la fonction TranslateAccelerator à l’intérieur de la boucle de message. La fonction TranslateAccelerator examine chaque message de fenêtre, en recherchant des messages de clé vers le bas. Si l’utilisateur appuie sur l’une des combinaisons de touches répertoriées dans la table de l’accélérateur, TranslateAccelerator envoie un message WM_COMMAND à la fenêtre. La fonction envoie WM_COMMAND en appelant directement la procédure de fenêtre. Lorsque TranslateAccelerator traduit correctement un trait de clé, la fonction retourne une valeur non nulle, ce qui signifie que vous devez ignorer le traitement normal du message. Sinon, TranslateAccelerator retourne zéro. Dans ce cas, transmettez le message de fenêtre à TranslateMessage et dispatchMessage, comme normale.

Voici comment le programme de dessin peut gérer le message WM_COMMAND :

    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case ID_DRAW_MODE:
            SetMode(DrawMode);
            break;

        case ID_SELECT_MODE:
            SetMode(SelectMode);
            break;

        case ID_TOGGLE_MODE:
            if (mode == DrawMode)
            {
                SetMode(SelectMode);
            }
            else
            {
                SetMode(DrawMode);
            }
            break;
        }
        return 0;

Ce code suppose que SetMode est une fonction définie par l’application pour basculer entre les deux modes. Les détails de la façon dont vous gérez chaque commande dépendent évidemment de votre programme.

Prochain

définition de l’image de curseur