使用鍵盤快捷鍵
本節涵蓋與鍵盤快捷鍵相關聯的工作。
使用加速鍵表資源
將加速器支援新增至應用程式最常見的方法是將快速鍵數據表資源與應用程式的可執行檔包含在一起，然後在運行時間載入資源。
本節涵蓋下列主題。
建立加速鍵表資源
您可以在應用程式的資源定義檔案中使用 ACCELERATORS 語句來建立加速器表格資源。 您必須將名稱或資源標識碼指派給加速器表，最好不同於任何其他資源。 系統會使用此標識碼在運行時間載入資源。
您定義的每個加速器都需要加速器表中的個別條目。 在每個條目中，您會定義用以產生快捷鍵的擊鍵（即 ASCII 字元碼或虛擬按鍵碼）以及快捷鍵的識別碼。 您也必須指定按鍵是否必須與 ALT、SHIFT 或 CTRL 鍵組合使用。 如需虛擬金鑰的詳細資訊，請參閱 鍵盤輸入。
以雙引弧括住 ASCII 字元，或使用字元的整數值搭配 ASCII 旗標來指定 ASCII 按鍵。 下列範例示範如何定義 ASCII 加速器。
"A", ID_ACCEL1 ; SHIFT+A
65, ID_ACCEL2, ASCII ; SHIFT+A
根據按鍵是英數鍵或非英數鍵，虛擬鍵碼的定義方式有所不同。 對於字母數字鍵，鍵的字母或數字用雙引號括起來，會與 VIRTKEY 旗標結合。 對於非字母數字鍵，特定鍵的虛擬鍵碼會與 VIRTKEY 旗標結合。 下列範例示範如何定義虛擬密鑰程式代碼加速器。
"a", ID_ACCEL3, VIRTKEY ; A (caps-lock on) or a
VK_INSERT, ID_ACCEL4, VIRTKEY ; INSERT key
下列範例顯示定義檔案作業加速器的快速鍵數據表資源。 資源的名稱 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
如果您希望使用者以某種組合按下 ALT、SHIFT 或 CTRL 鍵與快捷鍵按鍵，請在快速鍵的定義中指定 ALT、SHIFT 和 CONTROL 旗標。 以下是一些範例。
"B", ID_ACCEL5, ALT ; ALT_SHIFT+B
"I", ID_ACCEL6, CONTROL, VIRTKEY ; CTRL+I
VK_F5, ID_ACCEL7, CONTROL, ALT, VIRTKEY ; CTRL+ALT+F5
根據預設，當快捷鍵對應至功能表項時，系統會醒目提示功能表項。 您可以使用 NOINVERT 標誌來防止單個加速鍵被凸顯。 下列範例示範如何使用 NOINVERT 旗標：
VK_DELETE, ID_ACCEL8, VIRTKEY, SHIFT, NOINVERT ; SHIFT+DELETE
若要定義對應至應用程式中功能表項的加速鍵，請在功能表項的文字中包含加速鍵。 在資源定義檔案中，下列範例示範如何在功能表項文字中包含加速鍵。
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
載入快速鍵數據表資源
應用程式會藉由呼叫 LoadAccelerators 函式，並指定可執行檔包含資源和資源名稱或標識符之應用程式的實例句柄，以載入快速鍵數據表資源。 LoadAccelerators 將指定的快速鍵數據表載入記憶體中，並將句柄傳回至快捷鍵數據表。
應用程式可以隨時載入快速鍵數據表資源。 通常，單個線程應用程式會在進入主要訊息迴圈之前載入其加速器數據表。 使用多個執行緒的應用程式通常會在進入執行緒的消息循環之前，載入執行緒的加速器表格資源。 應用程式或執行緒也可能使用多個加速鍵表，每個加速鍵表都與應用程式中的特定視窗相關聯。 這類應用程式會在使用者每次啟用視窗時載入視窗的快捷鍵表。 如需線程的詳細資訊，請參閱 進程和線程。
呼叫翻譯加速器函式
若要處理加速器，應用程式的 （或線程） 訊息循環必須包含對 translateAccelerator函式的呼叫。 TranslateAccelerator 比較按鍵與加速鍵表，如果找到相符項目，則會將按鍵轉譯成 WM_COMMAND（或 WM_SYSCOMMAND）訊息。 函式接著會將訊息傳送至視窗程式。 TranslateAccelerator 函式的參數包括接收 WM_COMMAND 訊息的視窗句柄、用來轉譯加速鍵的加速鍵表句柄，以及包含佇列中訊息的 MSG 結構指標。 下列範例示範如何在訊息迴圈內呼叫 TranslateAccelerator。
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);
}
}
}
處理WM_COMMAND訊息
使用快捷鍵時，TranslateAccelerator 函式中指定的視窗會收到 WM_COMMAND 或 WM_SYSCOMMAND 訊息。 wParam 參數的低序字組包含加速鍵的標識碼。 視窗程式會檢查標識碼，以判斷 WM_COMMAND 訊息的來源，並據以處理訊息。
一般而言，如果快捷鍵對應至應用程式中的功能表項，則快捷鍵和功能表項會指派相同的標識碼。 如果您需要知道 WM_COMMAND 訊息是由快速鍵或功能表項所產生，您可以檢查 wParam 參數的高位字。 如果加速器產生訊息，則高序字為 1，如果功能表項產生訊息，則高序字為 0。
刪除加速鍵表資源
系統會自動銷毀 LoadAccelerators 函式所載入的加速器表資源，並在應用程式關閉之後從記憶體中移除該資源。
建立字型屬性的加速器
本節中的範例示範如何執行下列工作：
- 建立加速器表資源。
- 在運行時間載入快速鍵數據表。
- 在訊息循環中轉譯加速器。
- 處理加速器所產生的訊息 WM_COMMAND。
這些工作會在應用程式的內容中示範，其中包含 字元 功能表，以及可讓用戶選取目前字型屬性的對應快速鍵。
資源定義檔的下列部分定義了 字元 功能表和相關聯的加速器表。 請注意，功能表項會顯示快速鍵擊鍵，而且每個快捷鍵都有與其相關聯功能表項相同的標識碼。
#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
}
下列來自應用程式來源檔案的各節會示範如何實作加速器。
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;
}
使用在執行時期建立的加速器資料表
本主題討論如何使用在運行時間建立的加速器數據表。
建立 Run-Time 加速器參數表
在執行時建立加速器表的第一個步驟是填入 ACCEL 結構的陣列。 在數組中的每個結構都會定義表格中的加速器。 加速器的定義包括其旗標、索引鍵和標識碼。 ACCEL 結構的格式如下。
typedef struct tagACCEL { // accl
BYTE fVirt;
WORD key;
WORD cmd;
} ACCEL;
您可以在 ACCEL 結構中的 鍵 成員中指定 ASCII 字元碼或虛擬鍵代碼，以定義加速鍵的擊鍵。 如果您指定虛擬金鑰程式代碼，您必須先在 fVirt 成員中包含 FVIRTKEY 旗標;否則，系統會將程式代碼解譯為 ASCII 字元碼。 您可以包含 FCONTROL、FALT或 FSHIFT 旗標或全部三個旗標，以結合 CTRL、ALT 或 SHIFT 鍵與擊鍵。
若要創建加速器表，請將 ACCEL 結構的陣列指標傳遞至 CreateAcceleratorTable 函式。 CreateAcceleratorTable 會建立快捷鍵數據表，並將句柄傳回數據表。
處理加速器
載入和呼叫在運行時間建立的加速器表所提供的加速器，與處理加速器表資源所提供的加速器相同。 如需詳細資訊，請參閱 載入加速器數據表資源 到 處理 WM_COMMAND 訊息。
刪除 Run-Time 加速器表格
系統會自動刪除在程式執行期間建立的加速表格，並在應用程式關閉後，從記憶體移除相關資源。 您可以將加速器表的句柄傳遞至 DestroyAcceleratorTable 函式，以銷毀加速器表，並將它從記憶體中移除。
建立用戶可編輯加速器
此範例示範如何建構一個對話框，使用戶能夠變更與選單項目相關聯的快鍵鍵。 對話框包含包含功能表項的下拉式方塊、包含索引鍵名稱的下拉式方塊，以及選取 CTRL、ALT 和 SHIFT 鍵的複選框。 下圖顯示對話框。
具有下拉式方塊和複選框的 [![] 對話框](images/useredit.gif)
下列範例示範如何在資源定義檔案中定義對話框。
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
應用程式的功能表列包含 字元 子功能表，其項目具有與之相關的快捷鍵。
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
}
功能表範本的功能表項值是應用程式頭檔中所定義的常數，如下所示。
#define IDM_REGULAR 1100
#define IDM_BOLD 1200
#define IDM_ITALIC 1300
#define IDM_ULINE 1400
對話框使用應用程式自定義的 VKEY 結構陣列，每個結構包含一個按鍵文本字串和一個加速鍵文本字串。 建立對話框時，它會剖析陣列，並將每個按鍵文字串新增至 選取按鍵 組合框。 當使用者按兩下 [確定] 按鈕時，對話框會查閱選取的擊鍵文字字串，並擷取對應的快捷鍵文字字串。 對話框會將快速鍵文字字串添加到使用者所選功能表項的文字。 下列範例顯示 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"
};
對話框的初始化程式會填入 選取專案 和 選取按鍵 下拉式方塊。 當使用者選取功能表項和相關聯的快速鍵之後，對話框會檢查對話框中的控件，以取得使用者的選取範圍、更新功能表項的文字，然後建立包含使用者定義新快捷鍵的新快速鍵數據表。 下列範例顯示對話框程序。 請注意，您必須在視窗程式中初始化。
// 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;
}