Uso degli acceleratori di tastiera
Questa sezione illustra le attività associate agli acceleratori di tastiera.
- Uso di una risorsa tabella acceleratore
- Uso di una tabella acceleratore creata in fase di esecuzione
Uso di una risorsa tabella acceleratore
Il modo più comune per aggiungere il supporto dell'acceleratore a un'applicazione consiste nell'includere una risorsa di tabella acceleratore con il file eseguibile dell'applicazione e quindi caricare la risorsa in fase di esecuzione.
Questa sezione illustra gli argomenti seguenti.
- Creazione della risorsa tabella acceleratore
- Caricamento della risorsa tabella acceleratore
- Chiamata alla funzione di acceleratore di traduzione
- Elaborazione di messaggi di WM_COMMAND
- Eliminazione della risorsa tabella acceleratore
- Creazione di acceleratori per attributi del tipo di carattere
Creazione della risorsa tabella acceleratore
Creare una risorsa di tabella acceleratore usando l'istruzione ACCELERATORS nel file di definizione delle risorse dell'applicazione. È necessario assegnare un nome o un identificatore di risorsa alla tabella acceleratore, preferibilmente a differenza di quello di qualsiasi altra risorsa. Il sistema usa questo identificatore per caricare la risorsa in fase di esecuzione.
Ogni acceleratore definito richiede una voce separata nella tabella acceleratore. In ogni voce viene definita la sequenza di tasti (codice carattere ASCII o codice chiave virtuale) che genera l'acceleratore e l'identificatore dell'acceleratore. È anche necessario specificare se la sequenza di tasti deve essere usata in una combinazione con i tasti ALT, MAIUSC o CTRL. Per altre informazioni sulle chiavi virtuali, vedere Input da tastiera.
Una sequenza di tasti ASCII viene specificata racchiudendo il carattere ASCII tra virgolette doppie o usando il valore intero del carattere in combinazione con il flag ASCII. Negli esempi seguenti viene illustrato come definire acceleratori ASCII.
"A", ID_ACCEL1 ; SHIFT+A
65, ID_ACCEL2, ASCII ; SHIFT+A
Una sequenza di tasti chiave virtuale viene specificata in modo diverso a seconda che la sequenza di tasti sia una chiave alfanumerica o una chiave non alfanumerica. Per una chiave alfanumerica, la lettera o il numero della chiave, racchiusa tra virgolette doppie, viene combinata con il flag VIRTKEY . Per una chiave non alfanumerica, il codice della chiave virtuale per la chiave specifica viene combinato con il flag VIRTKEY . Negli esempi seguenti viene illustrato come definire acceleratori di codice chiave virtuale.
"a", ID_ACCEL3, VIRTKEY ; A (caps-lock on) or a
VK_INSERT, ID_ACCEL4, VIRTKEY ; INSERT key
Nell'esempio seguente viene illustrata una risorsa di tabella acceleratore che definisce gli acceleratori per le operazioni di file. Il nome della risorsa è FileAccel.
FileAccel ACCELERATORS
BEGIN
VK_F12, IDM_OPEN, CONTROL, VIRTKEY ; CTRL+F12
VK_F4, IDM_CLOSE, ALT, VIRTKEY ; ALT+F4
VK_F12, IDM_SAVE, SHIFT, VIRTKEY ; SHIFT+F12
VK_F12, IDM_SAVEAS, VIRTKEY ; F12
END
Se si desidera che l'utente preme ALT, MAIUSC o CTRL in una combinazione con la sequenza di tasti di scelta rapida, specificare i flag ALT, MAIUSC e CONTROL nella definizione dell'acceleratore. Di seguito sono riportati alcuni esempi.
"B", ID_ACCEL5, ALT ; ALT_SHIFT+B
"I", ID_ACCEL6, CONTROL, VIRTKEY ; CTRL+I
VK_F5, ID_ACCEL7, CONTROL, ALT, VIRTKEY ; CTRL+ALT+F5
Per impostazione predefinita, quando un tasto di scelta rapida corrisponde a una voce di menu, il sistema evidenzia la voce di menu. È possibile usare il flag NOINVERT per impedire l'evidenziazione per un singolo acceleratore. Nell'esempio seguente viene illustrato come usare il flag NOINVERT :
VK_DELETE, ID_ACCEL8, VIRTKEY, SHIFT, NOINVERT ; SHIFT+DELETE
Per definire acceleratori corrispondenti alle voci di menu dell'applicazione, includere gli acceleratori nel testo delle voci di menu. Nell'esempio seguente viene illustrato come includere acceleratori nel testo della voce di menu in un file di definizione delle risorse.
FilePopup MENU
BEGIN
POPUP "&File"
BEGIN
MENUITEM "&New..", IDM_NEW
MENUITEM "&Open\tCtrl+F12", IDM_OPEN
MENUITEM "&Close\tAlt+F4" IDM_CLOSE
MENUITEM "&Save\tShift+F12", IDM_SAVE
MENUITEM "Save &As...\tF12", IDM_SAVEAS
END
END
Caricamento della risorsa tabella acceleratore
Un'applicazione carica una risorsa di tabella acceleratore chiamando la funzione LoadAccelerators e specificando l'handle dell'istanza all'applicazione il cui file eseguibile contiene la risorsa e il nome o l'identificatore della risorsa. LoadAccelerators carica la tabella di acceleratore specificata in memoria e restituisce l'handle alla tabella acceleratore.
Un'applicazione può caricare una risorsa di tabella acceleratore in qualsiasi momento. In genere, un'applicazione a thread singolo carica la tabella acceleratore prima di immettere il ciclo di messaggi principale. Un'applicazione che usa più thread in genere carica la risorsa della tabella acceleratore per un thread prima di immettere il ciclo di messaggi per il thread. Un'applicazione o un thread possono anche usare più tabelle di acceleratore, ognuna associata a una determinata finestra nell'applicazione. Tale applicazione carica la tabella acceleratore per la finestra ogni volta che l'utente ha attivato la finestra. Per altre informazioni sui thread, vedere Processi e thread.
Chiamata alla funzione di acceleratore di traduzione
Per elaborare gli acceleratori, il ciclo di messaggi dell'applicazione (o del thread) deve contenere una chiamata alla funzione TranslateAccelerator . TranslateAccelerator confronta le sequenze di tasti in una tabella di acceleratore e, se trova una corrispondenza, converte le sequenze di tasti in un messaggio WM_COMMAND (o WM_SYSCOMMAND). La funzione invia quindi il messaggio a una routine di finestra. I parametri della funzione TranslateAccelerator includono l'handle alla finestra che consiste nel ricevere i messaggi di WM_COMMAND , l'handle alla tabella di acceleratore usato per convertire gli acceleratori e un puntatore a una struttura MSG contenente un messaggio dalla coda. Nell'esempio seguente viene illustrato come chiamare TranslateAccelerator dall'interno di un ciclo di messaggi.
MSG msg;
BOOL bRet;
while ( (bRet = GetMessage(&msg, (HWND) NULL, 0, 0)) != 0)
{
if (bRet == -1)
{
// handle the error and possibly exit
}
else
{
// Check for accelerator keystrokes.
if (!TranslateAccelerator(
hwndMain, // handle to receiving window
haccel, // handle to active accelerator table
&msg)) // message data
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
Elaborazione di messaggi di WM_COMMAND
Quando viene usato un acceleratore, la finestra specificata nella funzione TranslateAccelerator riceve un messaggio di WM_COMMAND o WM_SYSCOMMAND . La parola a basso ordine del parametro wParam contiene l'identificatore dell'acceleratore. La procedura della finestra esamina l'identificatore per determinare l'origine del messaggio di WM_COMMAND e elaborare di conseguenza il messaggio.
In genere, se un acceleratore corrisponde a una voce di menu nell'applicazione, l'acceleratore e la voce di menu vengono assegnati allo stesso identificatore. Se è necessario sapere se un messaggio di WM_COMMAND è stato generato da un acceleratore o da una voce di menu, è possibile esaminare la parola ad ordine elevato del parametro wParam . Se un acceleratore ha generato il messaggio, la parola di ordine elevato è 1; se una voce di menu ha generato il messaggio, la parola dell'ordine elevato è 0.
Eliminazione della risorsa tabella acceleratore
Il sistema elimina automaticamente le risorse della tabella acceleratore caricate dalla funzione LoadAccelerators , rimuovendo la risorsa dalla memoria dopo la chiusura dell'applicazione.
Creazione di acceleratori per attributi del tipo di carattere
L'esempio in questa sezione illustra come eseguire le attività seguenti:
- Creare una risorsa di tabella acceleratore.
- Caricare la tabella acceleratore in fase di esecuzione.
- Tradurre gli acceleratori in un ciclo di messaggi.
- Elaborare WM_COMMAND messaggi generati dagli acceleratori.
Queste attività vengono illustrate nel contesto di un'applicazione che include un menu Carattere e gli acceleratori corrispondenti che consentono all'utente di selezionare gli attributi del tipo di carattere corrente.
La parte seguente di un file di definizione delle risorse definisce il menu Carattere e la tabella di acceleratore associata. Si noti che le voci di menu mostrano le sequenze di tasti di scelta rapida e che ogni acceleratore ha lo stesso identificatore della voce di menu associata.
#include <windows.h>
#include "acc.h"
MainMenu MENU
{
POPUP "&Character"
{
MENUITEM "&Regular\tF5", IDM_REGULAR
MENUITEM "&Bold\tCtrl+B", IDM_BOLD
MENUITEM "&Italic\tCtrl+I", IDM_ITALIC
MENUITEM "&Underline\tCtrl+U", IDM_ULINE
}
}
FontAccel ACCELERATORS
{
VK_F5, IDM_REGULAR, VIRTKEY
"B", IDM_BOLD, CONTROL, VIRTKEY
"I", IDM_ITALIC, CONTROL, VIRTKEY
"U", IDM_ULINE, CONTROL, VIRTKEY
}
Le sezioni seguenti del file di origine dell'applicazione mostrano come implementare gli acceleratori.
HWND hwndMain; // handle to main window
HANDLE hinstAcc; // handle to application instance
int WINAPI WinMain(HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR lpCmdLine, int nCmdShow)
{
MSG msg; // application messages
BOOL bRet; // for return value of GetMessage
HACCEL haccel; // handle to accelerator table
// Perform the initialization procedure.
// Create a main window for this application instance.
hwndMain = CreateWindowEx(0L, "MainWindowClass",
"Sample Application", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL,
hinst, NULL );
// If a window cannot be created, return "failure."
if (!hwndMain)
return FALSE;
// Make the window visible and update its client area.
ShowWindow(hwndMain, nCmdShow);
UpdateWindow(hwndMain);
// Load the accelerator table.
haccel = LoadAccelerators(hinstAcc, "FontAccel");
if (haccel == NULL)
HandleAccelErr(ERR_LOADING); // application defined
// Get and dispatch messages until a WM_QUIT message is
// received.
while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0)
{
if (bRet == -1)
{
// handle the error and possibly exit
}
else
{
// Check for accelerator keystrokes.
if (!TranslateAccelerator(
hwndMain, // handle to receiving window
haccel, // handle to active accelerator table
&msg)) // message data
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
return msg.wParam;
}
LRESULT APIENTRY MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
BYTE fbFontAttrib; // array of font-attribute flags
static HMENU hmenu; // handle to main menu
switch (uMsg)
{
case WM_CREATE:
// Add a check mark to the Regular menu item to
// indicate that it is the default.
hmenu = GetMenu(hwndMain);
CheckMenuItem(hmenu, IDM_REGULAR, MF_BYCOMMAND |
MF_CHECKED);
return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
// Process the accelerator and menu commands.
case IDM_REGULAR:
case IDM_BOLD:
case IDM_ITALIC:
case IDM_ULINE:
// GetFontAttributes is an application-defined
// function that sets the menu-item check marks
// and returns the user-selected font attributes.
fbFontAttrib = GetFontAttributes(
(BYTE) LOWORD(wParam), hmenu);
// SetFontAttributes is an application-defined
// function that creates a font with the
// user-specified attributes the font with
// the main window's device context.
SetFontAttributes(fbFontAttrib);
break;
default:
break;
}
break;
// Process other messages.
default:
return DefWindowProc(hwndMain, uMsg, wParam, lParam);
}
return NULL;
}
Uso di una tabella acceleratore creata in fase di esecuzione
Questo argomento illustra come usare tabelle di acceleratore create in fase di esecuzione.
- Creazione di una tabella acceleratore di Run-Time
- Acceleratori di elaborazione
- Eliminazione di una tabella acceleratore di Run-Time
- Creazione di acceleratori modificabili utente
Creazione di una tabella acceleratore di Run-Time
Il primo passaggio nella creazione di una tabella di acceleratore in fase di esecuzione sta riempiendo una matrice di strutture ACCEL . Ogni struttura nella matrice definisce un acceleratore nella tabella. La definizione di un acceleratore include i flag, la relativa chiave e il relativo identificatore. La struttura ACCEL ha il formato seguente.
typedef struct tagACCEL { // accl
BYTE fVirt;
WORD key;
WORD cmd;
} ACCEL;
È possibile definire la sequenza di tasti di un acceleratore specificando un codice carattere ASCII o un codice chiave virtuale nel membro chiave della struttura ACCEL . Se si specifica un codice di chiave virtuale, è prima necessario includere il flag FVIRTKEY nel membro fVirt ; in caso contrario, il sistema interpreta il codice come codice carattere ASCII. È possibile includere il flag FCONTROL, FALT o FSHIFT o tutti e tre, per combinare il tasto CTRL, ALT o MAIUSC con la sequenza di tasti.
Per creare la tabella acceleratore, passare un puntatore alla matrice di strutture ACCEL alla funzione CreateAcceleratorTable . CreateAcceleratorTable crea la tabella acceleratore e restituisce l'handle alla tabella.
Acceleratori di elaborazione
Il processo di caricamento e chiamata degli acceleratori forniti da una tabella di acceleratore creata in fase di esecuzione è uguale all'elaborazione di quelle fornite da una risorsa di tabella acceleratore. Per altre informazioni, vedere Caricamento della risorsa tabella acceleratore tramite l'elaborazione di messaggi WM_COMMAND.
Eliminazione di una tabella acceleratore di Run-Time
Il sistema elimina automaticamente le tabelle dell'acceleratore create in fase di esecuzione, rimuovendo le risorse dalla memoria dopo la chiusura dell'applicazione. È possibile eliminare una tabella acceleratore e rimuoverla dalla memoria precedente passando l'handle della tabella alla funzione DestroyAcceleratorTable .
Creazione di acceleratori modificabili utente
In questo esempio viene illustrato come costruire una finestra di dialogo che consente all'utente di modificare l'acceleratore associato a una voce di menu. La finestra di dialogo è costituita da una casella combinata contenente voci di menu, una casella combinata contenente i nomi delle chiavi e le caselle di controllo per selezionare i tasti CTRL, ALT e MAIUSC. La figura seguente mostra la finestra di dialogo.
Nell'esempio seguente viene illustrato come viene definita la finestra di dialogo nel file di definizione della risorsa.
EdAccelBox DIALOG 5, 17, 193, 114
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION
CAPTION "Edit Accelerators"
BEGIN
COMBOBOX IDD_MENUITEMS, 10, 22, 52, 53,
CBS_SIMPLE | CBS_SORT | WS_VSCROLL |
WS_TABSTOP
CONTROL "Control", IDD_CNTRL, "Button",
BS_AUTOCHECKBOX | WS_TABSTOP,
76, 35, 40, 10
CONTROL "Alt", IDD_ALT, "Button",
BS_AUTOCHECKBOX | WS_TABSTOP,
76, 48, 40, 10
CONTROL "Shift", IDD_SHIFT, "Button",
BS_AUTOCHECKBOX | WS_TABSTOP,
76, 61, 40, 10
COMBOBOX IDD_KEYSTROKES, 124, 22, 58, 58,
CBS_SIMPLE | CBS_SORT | WS_VSCROLL |
WS_TABSTOP
PUSHBUTTON "Ok", IDOK, 43, 92, 40, 14
PUSHBUTTON "Cancel", IDCANCEL, 103, 92, 40, 14
LTEXT "Select Item:", 101, 10, 12, 43, 8
LTEXT "Select Keystroke:", 102, 123, 12, 60, 8
END
La barra dei menu dell'applicazione contiene un sottomenu Carattere i cui elementi hanno acceleratori associati.
MainMenu MENU
{
POPUP "&Character"
{
MENUITEM "&Regular\tF5", IDM_REGULAR
MENUITEM "&Bold\tCtrl+B", IDM_BOLD
MENUITEM "&Italic\tCtrl+I", IDM_ITALIC
MENUITEM "&Underline\tCtrl+U", IDM_ULINE
}
}
FontAccel ACCELERATORS
{
VK_F5, IDM_REGULAR, VIRTKEY
"B", IDM_BOLD, CONTROL, VIRTKEY
"I", IDM_ITALIC, CONTROL, VIRTKEY
"U", IDM_ULINE, CONTROL, VIRTKEY
}
I valori della voce di menu per il modello di menu sono costanti definite come segue nel file di intestazione dell'applicazione.
#define IDM_REGULAR 1100
#define IDM_BOLD 1200
#define IDM_ITALIC 1300
#define IDM_ULINE 1400
Nella finestra di dialogo viene usata una matrice di strutture VKEY definite dall'applicazione, ognuna contenente una stringa keystroke-text e una stringa di testo acceleratore. Quando viene creata la finestra di dialogo, analizza la matrice e aggiunge ogni stringa di testo chiave alla casella combinata Select Keystroke . Quando l'utente fa clic sul pulsante OK , la finestra di dialogo cerca la stringa di tasti selezionata e recupera la stringa di testo dell'acceleratore corrispondente. La finestra di dialogo aggiunge la stringa di testo dell'acceleratore al testo della voce di menu selezionata dall'utente. Nell'esempio seguente viene illustrata la matrice di strutture VKEY:
// VKey Lookup Support
#define MAXKEYS 25
typedef struct _VKEYS {
char *pKeyName;
char *pKeyString;
} VKEYS;
VKEYS vkeys[MAXKEYS] = {
"BkSp", "Back Space",
"PgUp", "Page Up",
"PgDn", "Page Down",
"End", "End",
"Home", "Home",
"Lft", "Left",
"Up", "Up",
"Rgt", "Right",
"Dn", "Down",
"Ins", "Insert",
"Del", "Delete",
"Mult", "Multiply",
"Add", "Add",
"Sub", "Subtract",
"DecPt", "Decimal Point",
"Div", "Divide",
"F2", "F2",
"F3", "F3",
"F5", "F5",
"F6", "F6",
"F7", "F7",
"F8", "F8",
"F9", "F9",
"F11", "F11",
"F12", "F12"
};
La procedura di inizializzazione della finestra di dialogo riempie le caselle combinate Seleziona elemento e Seleziona tasto . Dopo aver selezionato una voce di menu e un acceleratore associato, la finestra di dialogo esamina i controlli nella finestra di dialogo per ottenere la selezione dell'utente, aggiorna il testo della voce di menu e quindi crea una nuova tabella di acceleratore contenente il nuovo acceleratore definito dall'utente. Nell'esempio seguente viene illustrata la procedura della finestra di dialogo. Si noti che è necessario inizializzare nella procedura della finestra.
// Global variables
HWND hwndMain; // handle to main window
HACCEL haccel; // handle to accelerator table
// Dialog-box procedure
BOOL CALLBACK EdAccelProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
int nCurSel; // index of list box item
UINT idItem; // menu-item identifier
UINT uItemPos; // menu-item position
UINT i, j = 0; // loop counters
static UINT cItems; // count of items in menu
char szTemp[32]; // temporary buffer
char szAccelText[32]; // buffer for accelerator text
char szKeyStroke[16]; // buffer for keystroke text
static char szItem[32]; // buffer for menu-item text
HWND hwndCtl; // handle to control window
static HMENU hmenu; // handle to "Character" menu
PCHAR pch, pch2; // pointers for string copying
WORD wVKCode; // accelerator virtual-key code
BYTE fAccelFlags; // fVirt flags for ACCEL structure
LPACCEL lpaccelNew; // pointer to new accelerator table
HACCEL haccelOld; // handle to old accelerator table
int cAccelerators; // number of accelerators in table
static BOOL fItemSelected = FALSE; // item selection flag
static BOOL fKeySelected = FALSE; // key selection flag
HRESULT hr;
INT numTCHAR; // TCHARs in listbox text
switch (uMsg)
{
case WM_INITDIALOG:
// Get the handle to the menu-item combo box.
hwndCtl = GetDlgItem(hwndDlg, IDD_MENUITEMS);
// Get the handle to the Character submenu and
// count the number of items it has. In this example,
// the menu has position 0. You must alter this value
// if you add additional menus.
hmenu = GetSubMenu(GetMenu(hwndMain), 0);
cItems = GetMenuItemCount(hmenu);
// Get the text of each item, strip out the '&' and
// the accelerator text, and add the text to the
// menu-item combo box.
for (i = 0; i < cItems; i++)
{
if (!(GetMenuString(hmenu, i, szTemp,
sizeof(szTemp)/sizeof(TCHAR), MF_BYPOSITION)))
continue;
for (pch = szTemp, pch2 = szItem; *pch != '\0'; )
{
if (*pch != '&')
{
if (*pch == '\t')
{
*pch = '\0';
*pch2 = '\0';
}
else *pch2++ = *pch++;
}
else pch++;
}
SendMessage(hwndCtl, CB_ADDSTRING, 0,
(LONG) (LPSTR) szItem);
}
// Now fill the keystroke combo box with the list of
// keystrokes that will be allowed for accelerators.
// The list of keystrokes is in the application-defined
// structure called "vkeys".
hwndCtl = GetDlgItem(hwndDlg, IDD_KEYSTROKES);
for (i = 0; i < MAXKEYS; i++)
{
SendMessage(hwndCtl, CB_ADDSTRING, 0,
(LONG) (LPSTR) vkeys[i].pKeyString);
}
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDD_MENUITEMS:
// The user must select an item from the combo
// box. This flag is checked during IDOK
// processing to be sure a selection was made.
fItemSelected = TRUE;
return 0;
case IDD_KEYSTROKES:
// The user must select an item from the combo
// box. This flag is checked during IDOK
// processing to be sure a selection was made.
fKeySelected = TRUE;
return 0;
case IDOK:
// If the user has not selected a menu item
// and a keystroke, display a reminder in a
// message box.
if (!fItemSelected || !fKeySelected)
{
MessageBox(hwndDlg,
"Item or key not selected.", NULL,
MB_OK);
return 0;
}
// Determine whether the CTRL, ALT, and SHIFT
// keys are selected. Concatenate the
// appropriate strings to the accelerator-
// text buffer, and set the appropriate
// accelerator flags.
szAccelText[0] = '\0';
hwndCtl = GetDlgItem(hwndDlg, IDD_CNTRL);
if (SendMessage(hwndCtl, BM_GETCHECK, 0, 0) == 1)
{
hr = StringCchCat(szAccelText, 32, "Ctl+");
if (FAILED(hr))
{
// TODO: write error handler
}
fAccelFlags |= FCONTROL;
}
hwndCtl = GetDlgItem(hwndDlg, IDD_ALT);
if (SendMessage(hwndCtl, BM_GETCHECK, 0, 0) == 1)
{
hr = StringCchCat(szAccelText, 32, "Alt+");
if (FAILED(hr))
{
// TODO: write error handler
}
fAccelFlags |= FALT;
}
hwndCtl = GetDlgItem(hwndDlg, IDD_SHIFT);
if (SendMessage(hwndCtl, BM_GETCHECK, 0, 0) == 1)
{
hr = StringCchCat(szAccelText, 32, "Shft+");
if (FAILED(hr))
{
// TODO: write error handler
}
fAccelFlags |= FSHIFT;
}
// Get the selected keystroke, and look up the
// accelerator text and the virtual-key code
// for the keystroke in the vkeys structure.
hwndCtl = GetDlgItem(hwndDlg, IDD_KEYSTROKES);
nCurSel = (int) SendMessage(hwndCtl,
CB_GETCURSEL, 0, 0);
numTCHAR = SendMessage(hwndCtl, CB_GETLBTEXTLEN,
nCursel, 0);
if (numTCHAR <= 15)
{
SendMessage(hwndCtl, CB_GETLBTEXT,
nCurSel, (LONG) (LPSTR) szKeyStroke);
}
else
{
// TODO: writer error handler
}
for (i = 0; i < MAXKEYS; i++)
{
//
// lstrcmp requires that both parameters are
// null-terminated.
//
if(lstrcmp(vkeys[i].pKeyString, szKeyStroke)
== 0)
{
hr = StringCchCopy(szKeyStroke, 16, vkeys[i].pKeyName);
if (FAILED(hr))
{
// TODO: write error handler
}
break;
}
}
// Concatenate the keystroke text to the
// "Ctl+","Alt+", or "Shft+" string.
hr = StringCchCat(szAccelText, 32, szKeyStroke);
if (FAILED(hr))
{
// TODO: write error handler
}
// Determine the position in the menu of the
// selected menu item. Menu items in the
// "Character" menu have positions 0,2,3, and 4.
// Note: the lstrcmp parameters must be
// null-terminated.
if (lstrcmp(szItem, "Regular") == 0)
uItemPos = 0;
else if (lstrcmp(szItem, "Bold") == 0)
uItemPos = 2;
else if (lstrcmp(szItem, "Italic") == 0)
uItemPos = 3;
else if (lstrcmp(szItem, "Underline") == 0)
uItemPos = 4;
// Get the string that corresponds to the
// selected item.
GetMenuString(hmenu, uItemPos, szItem,
sizeof(szItem)/sizeof(TCHAR), MF_BYPOSITION);
// Append the new accelerator text to the
// menu-item text.
for (pch = szItem; *pch != '\t'; pch++);
++pch;
for (pch2 = szAccelText; *pch2 != '\0'; pch2++)
*pch++ = *pch2;
*pch = '\0';
// Modify the menu item to reflect the new
// accelerator text.
idItem = GetMenuItemID(hmenu, uItemPos);
ModifyMenu(hmenu, idItem, MF_BYCOMMAND |
MF_STRING, idItem, szItem);
// Reset the selection flags.
fItemSelected = FALSE;
fKeySelected = FALSE;
// Save the current accelerator table.
haccelOld = haccel;
// Count the number of entries in the current
// table, allocate a buffer for the table, and
// then copy the table into the buffer.
cAccelerators = CopyAcceleratorTable(
haccelOld, NULL, 0);
lpaccelNew = (LPACCEL) LocalAlloc(LPTR,
cAccelerators * sizeof(ACCEL));
if (lpaccelNew != NULL)
{
CopyAcceleratorTable(haccel, lpaccelNew,
cAccelerators);
}
// Find the accelerator that the user modified
// and change its flags and virtual-key code
// as appropriate.
for (i = 0; i < (UINT) cAccelerators; i++)
{
if (lpaccelNew[i].cmd == (WORD) idItem)
{
lpaccelNew[i].fVirt = fAccelFlags;
lpaccelNew[i].key = wVKCode;
}
}
// Create the new accelerator table, and
// destroy the old one.
DestroyAcceleratorTable(haccelOld);
haccel = CreateAcceleratorTable(lpaccelNew,
cAccelerators);
// Destroy the dialog box.
EndDialog(hwndDlg, TRUE);
return 0;
case IDCANCEL:
EndDialog(hwndDlg, TRUE);
return TRUE;
default:
break;
}
default:
break;
}
return FALSE;
}
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per