Partager via

Tables accélérateurs

  • Article

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

  • Nécessite moins de codage.
  • Regroupe 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 d’accélérateurs, nous avons 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 à l’application, telles que les menus, les curseurs, les icônes, les images, les chaînes de texte ou 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 microsoft Windows Resource Compiler (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, ainsi que le Kit de développement logiciel (SDK) Windows.
  3. Liez le fichier de ressources compilé au fichier binaire.

Ces étapes sont à peu près équivalentes au processus de compilation/liaison pour les fichiers de code. Visual Studio fournit un ensemble d’éditeurs de ressources qui facilitent la création et la modification de 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 de 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 d’application. Créons une table d’accélérateur 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 Commande
Ctrl+M Basculer entre les modes.
F1 Passez en 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. 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érateur, et les trois constantes suivantes définissent les commandes d’application. Par convention, un fichier d’en-tête qui définit des 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 d’accélérateur 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 des constantes symboliques sont utilisées dans l’exemple. Le fichier de définition de ressource inclut resource.h, où ces constantes sont définies.
  • La 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 sera 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 perturber les utilisateurs, il est donc généralement préférable d’utiliser des codes de clé virtuelle, plutôt que des caractères ASCII, pour les raccourcis.

Chargement de la table Accelerator

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

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

Appelez cette fonction avant d’entrer dans la boucle de message. Le premier paramètre est le handle du module. (Ce paramètre est passé à votre fonction WinMain . Pour plus d’informations, consultez WinMain : le point d’entrée de l’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érateur en appelant DestroyAcceleratorTable. Toutefois, le système libère automatiquement la table à la fin du programme. 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 par l’utilisateur.

Traduction de traits clés en commandes

Une table d’accélérateurs fonctionne en traduisant les traits clés 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 présenté précédemment, le trait de touche CTRL+M est traduit en message WM_COMMAND avec la valeur ID_TOGGLE_MODE. Pour ce faire, remplacez votre boucle de message par ce qui 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 les messages de touche vers le bas. Si l’utilisateur appuie sur l’une des combinaisons de touches répertoriées dans le tableau 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 différente de zéro, 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 d’habitude.

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.

Suivant

Définition de l’image du curseur