Nota
O acesso a esta página requer autorização. Podes tentar iniciar sessão ou mudar de diretório.
O acesso a esta página requer autorização. Podes tentar mudar de diretório.
Esta seção aborda tarefas associadas a aceleradores de teclado.
Usando um recurso de tabela aceleradora
A maneira mais comum de adicionar suporte a acelerador a um aplicativo é incluir um recurso de tabela aceleradora com o arquivo executável do aplicativo e, em seguida, carregar o recurso em tempo de execução.
Esta seção abrange os seguintes tópicos.
- Criando o de recursos da tabela do acelerador
- Carregando o recurso da tabela do acelerador
- Invocando a função "Translate Accelerator"
- Processamento de "WM_COMMAND" Mensagens
- Destruição do recurso da tabela do acelerador
- Criando aceleradores para atributos de fonte
Criando o recurso de tabela do acelerador
Você cria um recurso de tabela aceleradora usando a instrução ACCELERATORS no arquivo de definição de recursos do seu aplicativo. Você deve atribuir um nome ou identificador de recurso à tabela aceleradora, de preferência diferente de qualquer outro recurso. O sistema usa esse identificador para carregar o recurso em tempo de execução.
Cada acelerador definido requer uma entrada separada na tabela do acelerador. Em cada entrada, você define o pressionamento de tecla (um código de caractere ASCII ou um código de chave virtual) que gera o acelerador e o identificador do acelerador. Você também deve especificar se o pressionamento de tecla deve ser usado em alguma combinação com as teclas ALT, SHIFT ou CTRL. Para obter mais informações sobre teclas virtuais, consulte Keyboard Input.
Um pressionamento de tecla ASCII é especificado colocando o caractere ASCII entre aspas duplas ou usando o valor inteiro do caractere em combinação com o sinalizador ASCII. Os exemplos a seguir mostram como definir aceleradores ASCII.
"A", ID_ACCEL1 ; SHIFT+A
65, ID_ACCEL2, ASCII ; SHIFT+A
Um pressionamento de tecla do código de tecla virtual é especificado de forma diferente, dependendo se a tecla pressionada é alfanumérica ou não alfanumérica. Para uma chave alfanumérica, a letra ou o número da chave, entre aspas duplas, é combinado com a bandeira VIRTKEY. Para uma tecla não alfanumérica, o código de tecla virtual para a tecla específica é combinado com o sinalizador VIRTKEY. Os exemplos a seguir mostram como definir aceleradores de código de chave virtual.
"a", ID_ACCEL3, VIRTKEY ; A (caps-lock on) or a
VK_INSERT, ID_ACCEL4, VIRTKEY ; INSERT key
O exemplo a seguir mostra um recurso de tabela aceleradora que define aceleradores para operações de arquivo. O nome do recurso é 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 desejar que o usuário pressione as teclas ALT, SHIFT ou CTRL em alguma combinação com o pressionamento de tecla do acelerador, especifique os sinalizadores ALT, SHIFT e CONTROL na definição do acelerador. Seguem-se alguns exemplos.
"B", ID_ACCEL5, ALT ; ALT_SHIFT+B
"I", ID_ACCEL6, CONTROL, VIRTKEY ; CTRL+I
VK_F5, ID_ACCEL7, CONTROL, ALT, VIRTKEY ; CTRL+ALT+F5
Por padrão, quando uma tecla aceleradora corresponde a um item de menu, o sistema destaca o item de menu. Você pode usar o flag NOINVERT para evitar o destaque de um acelerador individual. O exemplo a seguir mostra como usar a flag NOINVERT:
VK_DELETE, ID_ACCEL8, VIRTKEY, SHIFT, NOINVERT ; SHIFT+DELETE
Para definir aceleradores que correspondem a itens de menu em seu aplicativo, inclua os aceleradores no texto dos itens de menu. O exemplo a seguir mostra como incluir aceleradores no texto do item de menu em um arquivo de definição de recurso.
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
Carregando o recurso de tabela do acelerador
Uma aplicação carrega um recurso de tabela de aceleradores chamando a função LoadAccelerators e especificando o manipulador de instância para a aplicação cujo ficheiro executável contém o recurso e o nome ou identificador do recurso. LoadAccelerators carrega a tabela aceleradora especificada na memória e retorna o identificador para a tabela aceleradora.
Uma aplicação pode carregar um recurso de tabela de aceleradores a qualquer momento. Normalmente, uma aplicação de thread única carrega a sua tabela de aceleradores antes de entrar no seu loop de mensagem principal. Um aplicativo que usa vários threads normalmente carrega o recurso da tabela aceleradora para um thread antes de inserir o loop de mensagem para o thread. Um aplicativo ou thread também pode usar várias tabelas de aceleração, cada uma associada a uma janela específica no aplicativo. Tal aplicativo carregaria a tabela aceleradora para a janela cada vez que o usuário ativasse a janela. Para obter mais informações sobre threads, consulte Processos e Threads.
Chamando a função Translate Accelerator
Para processar aceleradores, o loop de mensagem de um aplicativo (ou thread) deve conter uma chamada para a função TranslateAccelerator. TranslateAccelerator compara pressionamentos de teclas a uma tabela de aceleração e, se encontrar uma correspondência, traduz as teclas pressionadas em uma mensagem WM_COMMAND (ou WM_SYSCOMMAND). Em seguida, a função envia a mensagem para um procedimento de janela. Os parâmetros da função TranslateAccelerator incluem o identificador para a janela que deve receber as mensagens WM_COMMAND, o identificador para a tabela aceleradora usada para traduzir aceleradores e um ponteiro para uma estrutura deMSGcontendo uma mensagem da fila. O exemplo a seguir mostra como chamar TranslateAccelerator a partir de um loop de mensagens.
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);
}
}
}
Processamento de mensagens WM_COMMAND
Quando um acelerador é usado, a janela especificada na funçãoTranslateAccelerator recebe uma mensagem WM_COMMAND ou WM_SYSCOMMAND. A palavra de ordem baixa do parâmetro wParam contém o identificador do acelerador. O procedimento de janela examina o identificador para determinar a origem da mensagem WM_COMMAND e processar a mensagem em conformidade.
Normalmente, se um acelerador corresponde a um item de menu no aplicativo, o acelerador e o item de menu recebem o mesmo identificador. Se você precisar saber se uma mensagem de WM_COMMAND foi gerada por um acelerador ou por um item de menu, você pode examinar a palavra de alta ordem do parâmetro wParam. Se um acelerador gerou a mensagem, a palavra de ordem alta é 1; Se um item de menu gerou a mensagem, a palavra de ordem alta é 0.
Destruindo o recurso da tabela de aceleradores
O sistema destrói automaticamente os recursos da tabela de aceleradores carregados pela função LoadAccelerators, removendo o recurso da memória após o fechamento do aplicativo.
Criando aceleradores para atributos de fonte
O exemplo nesta seção mostra como executar as seguintes tarefas:
- Crie um recurso de tabela de aceleradores.
- Carregue a tabela do acelerador em tempo de execução.
- Traduza aceleradores em um loop de mensagens.
- Processar WM_COMMAND mensagens geradas pelos aceleradores.
Essas tarefas são demonstradas no contexto de um aplicativo que inclui um menu de caracteres e aceleradores correspondentes que permitem ao usuário selecionar atributos da fonte atual.
A parte a seguir de um ficheiro de definição de recurso define o menu de caracteres e a tabela de atalhos associada. Observe que os itens de menu mostram as teclas do acelerador e que cada acelerador tem o mesmo identificador que seu item de menu associado.
#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
}
As seções a seguir do arquivo de origem do aplicativo mostram como implementar os aceleradores.
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;
}
Usando uma tabela de aceleração criada durante a execução
Este tópico discute como usar tabelas de aceleração criadas em tempo de execução.
- Criando uma tabela do Run-Time Accelerator
- Aceleradores de processamento
- Destruindo uma tabela de aceleração Run-Time
- Criando aceleradores editáveis pelo usuário
Criando uma tabela do Run-Time Accelerator
A primeira etapa na criação de uma tabela de aceleração em tempo de execução é preencher um array de estruturas ACCEL. Cada estrutura na matriz define um acelerador na tabela. A definição de um acelerador inclui seus sinalizadores, sua chave e seu identificador. A estrutura ACCEL tem a seguinte forma.
typedef struct tagACCEL { // accl
BYTE fVirt;
WORD key;
WORD cmd;
} ACCEL;
Você define o pressionamento de tecla de um acelerador especificando um código de caractere ASCII ou um código de chave virtual na tecla membro da estruturaACCEL. Se especificares um código de chave virtual, deves incluir primeiro a flag FVIRTKEY no membro fVirt; caso contrário, o sistema interpreta o código como um código de caractere ASCII. Você pode incluir o indicador FCONTROL, FALT, ou FSHIFT, ou todos os três, para combinar a tecla CTRL, ALT ou SHIFT com a tecla pressionada.
Para criar a tabela de aceleradores, passe um ponteiro para a matriz de estruturas ACCEL para a função CreateAcceleratorTable. CreateAcceleratorTable cria a tabela aceleradora e retorna o identificador para a tabela.
Aceleradores de processamento
O processo de carregar e chamar aceleradores fornecidos por uma tabela de aceleradores criada em tempo de execução é o mesmo que processar aqueles fornecidos por um recurso de tabela de aceleradores. Para obter mais informações, consulte Carregando o de recursos da tabela do acelerador por meio processamento WM_COMMAND mensagens.
Destruição de uma Tabela de Acelerador Run-Time
O sistema destrói automaticamente as tabelas de aceleração criadas em tempo de execução, removendo os recursos da memória após o fechamento do aplicativo. Você pode destruir uma tabela aceleradora e removê-la da memória mais cedo passando o identificador da tabela para a funçãoDestroyAcceleratorTable.
Criando aceleradores editáveis pelo usuário
Este exemplo mostra como construir uma caixa de diálogo que permite ao usuário alterar o acelerador associado a um item de menu. A caixa de diálogo consiste em uma caixa de combinação contendo itens de menu, uma caixa de combinação contendo os nomes das teclas e caixas de seleção para selecionar as teclas CTRL, ALT e SHIFT. A ilustração a seguir mostra a caixa de diálogo.
O exemplo a seguir mostra como a caixa de diálogo é definida no arquivo de definição de recurso.
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
A barra de menus da aplicação contém um submenu Caráter cujos itens têm aceleradores associados a eles.
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
}
Os valores de item de menu para o modelo de menu são constantes definidas da seguinte forma no arquivo de cabeçalho do aplicativo.
#define IDM_REGULAR 1100
#define IDM_BOLD 1200
#define IDM_ITALIC 1300
#define IDM_ULINE 1400
A caixa de diálogo usa uma matriz de estruturas VKEY definidas pelo aplicativo, cada uma contendo uma cadeia de caracteres de texto de pressionamento de tecla e uma cadeia de caracteres de texto acelerador. Quando a caixa de diálogo é criada, ela analisa a matriz e adiciona cada sequência de texto de pressionamento de tecla à caixa de combinação Selecionar Pressionamento de Tecla. Quando o usuário clica no botão OK, a caixa de diálogo procura a cadeia de caracteres de texto-pressionamento de tecla selecionada e recupera a cadeia de texto acelerador correspondente. A caixa de diálogo acrescenta a cadeia de caracteres de texto acelerador ao texto do item de menu selecionado pelo usuário. O exemplo a seguir mostra a matriz de estruturas 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"
};
O procedimento de inicialização da caixa de diálogo preenche as caixas de combinação Selecionar Item e Selecionar Pressionamento de Tecla. Depois que o usuário seleciona um item de menu e um acelerador associado, a caixa de diálogo examina os controles na caixa de diálogo para obter a seleção do usuário, atualiza o texto do item de menu e cria uma nova tabela de aceleração que contém o novo acelerador definido pelo usuário. O exemplo a seguir mostra o procedimento da caixa de diálogo. Observe que você deve inicializar no procedimento da janela.
// 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;
}