Vytvorenie používateľovi upravovať urýchľovačov

Tento príklad ukazuje ako na výstavbu dialógové okno, ktoré umožňuje používateľovi zmeniť akcelerátora priradená položka ponuky. Dialógovom okne pozostáva z rozbaľovacie pole obsahujúce položky menu, rozbaľovacie pole obsahujúce mená tlačidlá a začiarkavacie políčka pre výber ctrl, alt a posun kľúče. Nasledujúca ilustrácia zobrazuje dialógové okno.

Nasledujúci príklad ukazuje, ako dialógovom okne definovaná v súbore zdrojov-definícia.

EdAccelBox dialógové okno 5, 17, 193, 114 štýl DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION popis "Edit urýchľovače" začať COMBOBOX IDD_MENUITEMS, 10, 22, 52, 53, CBS_SIMPLE | CBS_SORT | WS_VSCROLL | 
                        WS_TABSTOP kontrola "Kontrola", IDD_CNTRL, "tlačidlo", BS_AUTOCHECKBOX | WS_TABSTOP, 76, 35, 40, 10 kontroly "Alt", IDD_ALT, "Tlačidlo", BS_AUTOCHECKBOX | WS_TABSTOP, 76, 48, 40 10 kontroly "Zmeny", IDD_SHIFT, "tlačidlo", 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 "zrušiť", IDCANCEL, 103, 92, 40, 14 LTEXT "zvoľte položku:", 101, 10, 12, 43, 8 LTEXT "vyberte stlačenie klávesu:", 102, 123, 12, 60, 8 koniec 
 

Panel s ponukami aplikácie obsahuje znak vedľajšej ktorého položky boli urýchľovače sú s nimi spojené.

Skrytie MENU {POPUP "amp;Znak"{MENUITEM" & Regular\tF5 ", IDM_REGULAR MENUITEM" & Bold\tCtrl + B ", IDM_BOLD MENUITEM" & Italic\tCtrl + I ", IDM_ITALIC MENUITEM" & Underline\tCtrl + U ", IDM_ULINE}
} URÝCHĽOVAČE FontAccel {VK_F5, IDM_REGULAR, VIRTKEY "B", IDM_BOLD, kontrolu, VIRTKEY "Ja", IDM_ITALIC, kontrolu, VIRTKEY "U", IDM_ULINE, kontrolu, VIRTKEY} 
 

Hodnoty ponuky položku ponuky šablóny sú konštanty definovaný v hlavičke súboru aplikácie.

# define IDM_REGULAR 1100
# define IDM_BOLD 1200
# define IDM_ITALIC 1300
# define IDM_ULINE 1400

Dialógovom okne používa zprovoznit definovanom aplikáciou domáceho kina štruktúr, obsahujú stlačenie klávesu textový reťazec a urýchľovača textový reťazec. Pri vytvorení dialógovom okne analyzuje pole a pridá každý stlačenie klávesu textový reťazec rozbaľovacie pole Vyberte stlačenie klávesu . Keď používateľ klikne na tlačidlo OK , dialógovom okne vyhľadá vybraných stlačenie klávesu textový reťazec a načíta zodpovedajúce akcelerátora textový reťazec. Dialógovom okne pripojí akcelerátora textový reťazec text položky ponuky, vybratého používateľa. Nasledujúci príklad zobrazuje pole štruktúry domáceho kina:

/ / Domáceho kina Lookup podpora # define MAXKEYS 25 typedef struct _VKEYS {char * pKeyName; 
    char * pKeyString; 
} VKEYS; 
 
VKEYS vkeys [MAXKEYS] = {"BkSp", "Späť Space", "PgUp", "Page Up", "Page Down", "Page Down", "End", "End", "Home", "Home", "Lft", "Zľava", "Up", "Up", "Rgt", "Právo", "Dn „"Dole","Ins","Vložiť"," Del","Zmazať","Mult","Násobiť","Pridať","Pridať","Sub","Odčítanie","DecPt","Desatinnú čiarku","Div","Rozdelenie","F2","F2","F3","F3","F5","F5","F6","F6","F7","F7","F8","F8","F9","F9","F11","F11","F12","F12"} 
 

Dialógovým oknom Inicializácia režimu vyplní poliach so zoznamom Vyberte položku a Vyberte stlačenie klávesu . Po používateľ vyberie položku ponuky a pridružené akcelerátora, dialógovom okne skúma ovládacie prvky v dialógovom okne získať výber používateľa, aktualizuje text položky ponuky a potom vytvorí nový urýchľovač tabuľky, ktorý obsahuje používateľský nový urýchľovač. Nasledujúci príklad zobrazuje dialógového postupu. Všimnite si, že musí inicializovať hwndMain okno postupu.

 // 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;     // address of 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 
 
    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), 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) 
                    { 
                        lstrcat(szAccelText, "Ctl+"); 
                        fAccelFlags |= FCONTROL; 
                    } 
                    hwndCtl = GetDlgItem(hwndDlg, IDD_ALT); 
                    if (SendMessage(hwndCtl, BM_GETCHECK, 0, 0) == 1) 
                    { 
                        lstrcat(szAccelText, "Alt+"); 
                        fAccelFlags |= FALT; 
                    } 
                    hwndCtl = GetDlgItem(hwndDlg, IDD_SHIFT); 
                    if (SendMessage(hwndCtl, BM_GETCHECK, 0, 0) == 1) 
                    { 
                        lstrcat(szAccelText, "Shft+"); 
                        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); 
                    SendMessage(hwndCtl, CB_GETLBTEXT, 
                        nCurSel, (LONG) (LPSTR) szKeyStroke); 
                    for (i = 0; i < MAXKEYS; i++) 
                    { 
                        if(lstrcmp(vkeys[i].pKeyString, szKeyStroke) 
                            == 0) 
                        { 
                            lstrcpy(szKeyStroke, vkeys[i].pKeyName); 
                            break; 
                        } 
                    } 
 
                    // Concatenate the keystroke text to the 
                    // "Ctl+","Alt+", or "Shft+" string. 
 
                    lstrcat(szAccelText, szKeyStroke); 
 
                    // Determine the position in the menu of the 
                    // selected menu item. Menu items in the 
                    // "Character" menu have positions 0,2,3, and 4. 
 
                    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), 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; (lpaccelNew[i].cmd == 
                                (WORD) idItem) 
                            && (i < (UINT) cAccelerators); i++) 
                    { 
                        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; 
} 
 

Index