Dela via

Acceleratortabeller

Program definierar ofta kortkommandon, till exempel CTRL+O för kommandot Öppna fil. Du kan implementera kortkommandon genom att hantera enskilda WM_KEYDOWN meddelanden, men acceleratortabeller ger en bättre lösning som:

  • Kräver mindre kodning.
  • Konsoliderar alla dina genvägar till en datafil.
  • Stöder lokalisering till andra språk.
  • Gör att genvägar och menykommandon kan använda samma programlogik.

En acceleratortabell är en dataresurs som mappar tangentbordskombinationer, till exempel CTRL+O, till programkommandon. Innan vi ser hur du använder en acceleratortabell behöver vi en snabb introduktion till resurser. En resurs är en datablob som är inbyggd i ett binärt program (EXE eller DLL). Resurser lagrar data som behövs av programmet, till exempel menyer, markörer, ikoner, bilder, textsträngar eller anpassade programdata. Programmet läser in resursdata från binärfilen vid körning. Gör följande för att inkludera resurser i en binär fil:

  1. Skapa en resursdefinitionsfil (.rc). Den här filen definierar typerna av resurser och deras identifierare. Resursdefinitionsfilen kan innehålla referenser till andra filer. Till exempel deklareras en ikonresurs i .rc-filen, men ikonbilden lagras i en separat fil.
  2. Använd Microsoft Windows Resource Compiler (RC) för att kompilera resursdefinitionsfilen till en kompilerad resursfil (.res). RC-kompilatorn tillhandahålls med Visual Studio och även Windows SDK.
  3. Länka den kompilerade resursfilen till den binära filen.

De här stegen motsvarar ungefär kompilerings-/länkprocessen för kodfiler. Visual Studio innehåller en uppsättning resursredigerare som gör det enkelt att skapa och ändra resurser. (Dessa verktyg är inte tillgängliga i Express-utgåvorna av Visual Studio.) Men en .rc-fil är helt enkelt en textfil och syntaxen dokumenteras på MSDN, så det går att skapa en .rc-fil med valfri textredigerare. Mer information finns i Om resursfiler.

Definiera en acceleratortabell

En acceleratortabell är en tabell med kortkommandon. Varje genväg definieras av:

  • En numerisk identifierare. Det här numret identifierar programkommandot som ska anropas av genvägen.
  • ASCII-tecknet eller den virtuella nyckelkoden för genvägen.
  • Valfria modifierarnycklar: ALT, SKIFT eller CTRL.

Själva acceleratortabellen har en numerisk identifierare som identifierar tabellen i listan över programresurser. Nu ska vi skapa en acceleratortabell för ett enkelt ritningsprogram. Det här programmet kommer att ha två lägen, dragningsläge och markeringsläge. I dragningsläge kan användaren rita former. I markeringsläge kan användaren välja former. För det här programmet vill vi definiera följande kortkommandon.

Genväg Befallning
CTRL+M Växla mellan lägen.
F1 Växla till dragningsläge.
F2 Växla till markeringsläge.

 

Definiera först numeriska identifierare för tabellen och för programkommandona. Dessa värden är godtyckliga. Du kan tilldela symboliska konstanter för identifierarna genom att definiera dem i en rubrikfil. Till exempel:

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

I det här exemplet identifierar värdet IDR_ACCEL1 acceleratortabellen och de följande tre konstanterna definierar programkommandona. Enligt konventionen heter en huvudfil som definierar resurskonstanter ofta resource.h. Nästa lista visar resursdefinitionsfilen.

#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
}

Kortkommandona för acceleratorn definieras inom klammerparenteserna. Varje genväg innehåller följande poster.

  • Den virtuella nyckelkoden eller ASCII-tecknet som anropar genvägen.
  • Programkommandot. Observera att symboliska konstanter används i exemplet. Resursdefinitionsfilen innehåller resource.h, där dessa konstanter definieras.
  • Nyckelordet VIRTKEY innebär att den första posten är en virtuell nyckelkod. Det andra alternativet är att använda ASCII-tecken.
  • Valfria modifierare: ALT, CONTROL eller SKIFT.

Om du använder ASCII-tecken för genvägar är ett gemener ett annat genväg än ett versalt tecken. (Om du till exempel skriver "a" kan du anropa ett annat kommando än att skriva "A".) Det kan förvirra användare, så det är vanligtvis bättre att använda koder för virtuella nycklar i stället för ASCII-tecken för genvägar.

Läser in acceleratortabellen

Resursen för acceleratortabellen måste läsas in innan programmet kan använda den. Om du vill läsa in en acceleratortabell anropar du funktionen LoadAccelerators.

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

Anropa den här funktionen innan du anger meddelandeloopen. Den första parametern är referensen till modulen. (Den här parametern skickas till funktionen WinMain. Mer information finns i WinMain: Startpunkten för programmet.) Den andra parametern är resursidentifieraren. Funktionen returnerar ett handtag till resursen. Kom ihåg att ett handtag är en ogenomskinlig typ som refererar till ett objekt som hanteras av systemet. Om funktionen misslyckas returneras NULL-.

Du kan släppa en acceleratortabell genom att anropa DestroyAcceleratorTable. Systemet släpper dock tabellen automatiskt när programmet avslutas, så du behöver bara anropa den här funktionen om du ersätter en tabell med en annan. Det finns ett intressant exempel på detta i avsnittet Skapa användarredigerbara acceleratorer.

Översätta nyckeldrag till kommandon

En acceleratortabell fungerar genom att översätta tangentstreck till WM_COMMAND meddelanden. Parametern wParam för WM_COMMAND innehåller kommandots numeriska identifierare. Om du till exempel använder tabellen som visades tidigare översätts tangentstrecket CTRL+M till ett WM_COMMAND meddelande med värdet ID_TOGGLE_MODE. Gör så här genom att ändra meddelandeloopen till följande:

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

Den här koden lägger till ett anrop till funktionen TranslateAccelerator i meddelandeloopen. Funktionen TranslateAccelerator undersöker varje fönstermeddelande och letar efter nedtangentade meddelanden. Om användaren trycker på någon av de tangentkombinationer som anges i acceleratortabellen skickar TranslateAccelerator ett WM_COMMAND meddelande till fönstret. Funktionen skickar WM_COMMAND genom att direkt anropa fönsterproceduren. När TranslateAccelerator översätter ett nyckeldrag returnerar funktionen ett värde som inte är noll, vilket innebär att du bör hoppa över den normala bearbetningen för meddelandet. Annars returnerar TranslateAccelerator noll. I så fall skickar du fönstermeddelandet till TranslateMessage och DispatchMessage, som vanligt.

Så här hanterar ritningsprogrammet WM_COMMAND meddelande:

    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;

Den här koden förutsätter att SetMode är en funktion som definieras av programmet för att växla mellan de två lägena. Informationen om hur du hanterar varje kommando beror uppenbarligen på ditt program.

Nästa

Ange

 

 

  • Last updated on