On-line справка по Win32 API

БЕСПЛАТНАЯ ежедневная online лотерея! Выигрывай каждый день БЕСПЛАТНО!

A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z | Скачать

Creating User-Editable Accelerators

This example shows how to construct a dialog box that allows the user to change the accelerator associated with a menu item. The dialog box consists of a combo box containing menu items, a combo box containing the names of keys, and check boxes for selecting the CTRL, ALT, and SHIFT keys. The following illustration shows the dialog box.

The following example shows how the dialog box is defined in the resource-definition file.

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

The dialog box uses an array of application-defined VKEY structures, each containing a keystroke-text string and an accelerator-text string. When the dialog box is created, it parses the array and adds each keystroke-text string to the Select Keystroke combo box. When the user clicks the Ok button, the dialog box looks up the selected keystroke-text string and retrieves the corresponding accelerator-text string. The dialog box appends the accelerator-text string to the text of the menu item that the user selected. The following example shows the array of VKEY structures:

/* VKey Lookup Support */

#define MAXKEYS 26

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"
};

The dialog box's initialization procedure fills the Select Item and Select Keystroke combo boxes. After the user selects a menu item and associated accelerator, the dialog box examines the controls in the dialog box to get the user's selection, updates the text of the menu item, and then creates a new accelerator table that contains the user-defined new accelerator. The following example shows the dialog-box procedure.

/* Global variables */

HWND hwndMain; /* handle of main window */
HANDLE hinstAcc; /* handle of application instance */
HACCEL haccel; /* handle of accelerator table */

.
.
.

/* Dialog-box procedure */

LRESULT CALLBACK EdAccelProc(hwndDlg, uMsg, wParam, lParam)
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 of control window */

static HMENU hmenu; /* handle of "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 accel. table */
HACCEL haccelOld; /* handle of old accel. 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 of the menu-item combo box. */

hwndCtl = GetDlgItem(hwndDlg, IDD_MENUITEMS);

/*
* The application's menu bar contains a "Character"
* submenu whose items have accelerators associated
* with them. Get the handle of the "Character"
* submenu (its position within the main menu is 2),

* and count the number of items it has.
*/

hmenu = GetSubMenu(GetMenu(hwndMain), 2);
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 menu-
* item 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 menu-
* item 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;
}

Пригласи друзей и счет твоего мобильника всегда будет положительным!

Пригласи друзей и счет твоего мобильника всегда будет положительным!

Создание Акселераторов User-Editable

Этот пример показывает как, чтобы создавать диалогового блока, который позволяет пользователя, чтобы изменять акселератор связанный пунктом меню. Диалоговый блок состоит из блока combo, содержащего пункты меню, блок combo, содержащие имена клавиш, и контрольные блоков для выбора CTRL, ALT, и клавиш СДВИГА. Следующая иллюстрация показывает диалогового блока.

Следующий пример показывает как диалоговый блок определен в ресурсе-определении файла.

ДИАЛОГ EdAccelBox 5, 17, 193, 114 STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | ЗАГОЛОВОК WS_CAPTION "Акселераторы Редактирования" НАЧИНАЕТСЯ
COMBOBOX IDD_MENUITEMS, 10, 22, 52, 53, CBS_SIMPLE | CBS_SORT | WS_VSCROLL | УПРАВЛЕНИЕ WS_TABSTOP "Управление", IDD_CNTRL, "Кнопка", BS_AUTOCHECKBOX | WS_TABSTOP,
76, 35, 40, 10
УПРАВЛЕНИЕ "Alt", IDD_ALT, "Кнопка",

BS_AUTOCHECKBOX | WS_TABSTOP,
76, 48, 40, 10
УПРАВЛЕНИЕ "Сдвига", IDD_SHIFT, "Кнопка", BS_AUTOCHECKBOX | WS_TABSTOP,
76, 61, 40, 10
COMBOBOX IDD_KEYSTROKES, 124, 22, 58, 58, CBS_SIMPLE | CBS_SORT | WS_VSCROLL | КНОПКА WS_TABSTOP "Ok", IDOK, 43, 92, 40, 14 КНОПОК "Отмены", IDCANCEL, 103, 92, 40, 14

LTEXT "ПУНКТ Выбора:", 101, 10, 12, 43, 8 LTEXT "Нажатие клавиши Выбора:", 102, 123, 12, 60, 8 КОНЦОВ

Диалоговый блок использует массив определенных прикладных структур VKEY, каждого содержания нажатия клавиши-текстовая строка и акселератор-текстовая строка. Когда диалоговый блок создан, он выполняет грамматический разбор массив и добавляет каждое нажатие клавиши-текстовая строка к Нажатию клавиши Выбора combo блок. Когда пользователь щелкает кнопку Ok, диалоговый блок ищет выбранное нажатие клавиши-текстовая строка и извлекает соответствующую акселератор-текстовую строку. Диалоговый блок добавляет акселератор-текстовую строку в текст пункта меню, что пользователь выбирался. Следующий пример показывает массив структур VKEY:

/* ПОДДЕРЖКА Поиска VKey */

#define MAXKEYS 26

typedef struct _VKEYS { символ *pKeyName;
символ *pKeyString;
} VKEYS;

VKEYS vkeys[MAXKEYS] = { "BkSp", "ПРОСТРАНСТВО", "PgUp", "Страница По", "PgDn", "Страница Вниз", "Конец", "Конец", "Дом", "Дом", "Lft", "Оставленное", "По", "По", "Rgt", "Право", "Dn", "Вниз", "Ins", "Включать", "Дель", "Удалять", "Mult", "Умножать",

"Добавлять", "Добавлять", "Под", "Вычитать", "DecPt", "Знак Десятичной дроби", "Деление", "Делить", "F2", "F2", "F3", "F3", "F5", "F5", "F6", "F6", "F7", "F7", "F8", "F8", "F9", "F9", "F11", "F11", "F12", "F12"
};

Процедура инициализации диалогового блока заполняет Пункт Выбора и Нажатия клавиши Выбора combo блоки. После того, как пользователь выберется пункт меню и связавший акселератор, диалоговые проверки блока элементы управления в диалоговом блоке, чтобы получать выбор пользователя, корректировать текст пункта меню, затем создает новую таблицу акселератора, которая содержит новый акселератор определенного пользователя. Следующий пример показывает процедуру диалогового блока.

/* Глобальные переменные */

HWND hwndMain; /* ручка основного окна */ РУЧКА hinstAcc; /* ручка прикладного примера */ HACCEL haccel; /* ручка таблицы акселератора */

.
.
.

/* Процедура Диалогового блока */

LRESULT CALLBACK EdAccelProc(hwndDlg, uMsg, wParam, lParam) HWND hwndDlg;
UINT uMsg;
WPARAM wParam;
LPARAM lParam;
{
int nCurSel; /* индекс пункта блока списка */ UINT idItem; /* меню-пункт идентификатора */

UINT uItemPos; /* меню-пункт позиции */ UINT я, j = 0; /* счетчики цикла */ статический UINT cItems; /* счет пунктов в меню */ символ szTemp[32]; /* временный буфер */ символ szAccelText[32]; /* буфер для текста акселератора */ символ szKeyStroke[16]; /* буфер для нажатия клавиши текста */ статический символ szItem[32]; /* буфер для меню-пункта текста */ HWND hwndCtl; /* ручка управляющего окна */

статический HMENU hmenu; /* ручка меню "Символа" */ PCHAR pch, pch2; /* указатели для копирования строки */ WORD wVKCode; /* акселератор виртуальный-ключевой код */ BYTE fAccelFlags; /* fVirt Сигнализирует для структуры ACCEL */ LPACCEL lpaccelNew; /* адрес новой accel. таблицы */ HACCEL haccelOld; /* ручка старой accel. таблицы */ int cAccelerators; /* количество акселераторов в таблице */ статический BOOL fItemSelected = ЛОЖЬ; /* флаг выбора пункта */

статический BOOL fKeySelected = ЛОЖЬ; /* ключевой флаг выбора */

ключ (uMsg) { случай WM_INITDIALOG:

/* Получите ручку меню-пункта combo box. */

hwndCtl = GetDlgItem(hwndDlg, IDD_MENUITEMS);

/*
* Прикладная зона меню содержит "Символ"
* субменю, чьи пункты связали акселераторы
* с ими. Получите ручку "Символа"
* субменю ( позиция в пределах основного меню - 2),

* и счет количество пунктов это имеет.
*/

hmenu = GetSubMenu(GetMenu(hwndMain), 2);
cItems = GetMenuItemCount(hmenu);

/*
* Получите текст каждого пункта, удаляйте '&' и
* текст акселератора и добавляет текст к the
* меню-пункт combo блок.
*/

для (i = 0; я < cItems; я++) { если (!(GetMenuString(hmenu, Я, szTemp,

sizeof(szTemp), MF_BYPOSITION))), оставаться;
для (pch = szTemp, pch2 = szItem;
*pch != '\0; ) {

если (*pch != '&') { если (*pch == '\t') { *pch = '\0;
*pch2 = '\0;
}
еще *pch2++ = *pch++;
}

еще pch++;
}
SendMessage(hwndCtl, CB_ADDSTRING, 0, (ДОЛГО (ДЛИНОЙ)) (LPSTR) szItem);
}

/*
* Теперь заполните нажатие клавиши combo блок списком
* нажатия клавиши, которые будут учтены акселераторы.
* Список нажатий клавиши - в определенном приложении
* структура была названа "vkeys".
*/

hwndCtl = GetDlgItem(hwndDlg, IDD_KEYSTROKES);
для (i = 0; я < MAXKEYS; я++) SendMessage(hwndCtl, CB_ADDSTRING, 0, (ДОЛГО (ДЛИНОЙ)) (LPSTR) vkeys[i].pKeyString);

возвращайтесь ВЕРНО;

случай WM_COMMAND: ключ (LOWORD(wParam)) { случай IDD_MENUITEMS:

/*
* Пользователь должен выбраться пункт из меню-
* пункт combo блок. Этот флаг проверен в течение

* IDOK, ОБРАБАТЫВАЮЩИЙ, чтобы быть уверенно выбор был сделан.
*/

fItemSelected = ИСТИНА;
возврат 0;

случай IDD_KEYSTROKES:

/*
* Пользователь должен выбраться пункт из меню-
* пункт combo блок. Этот флаг проверен в течение
* IDOK, ОБРАБАТЫВАЮЩИЙ, чтобы быть уверенно выбор был сделан.
*/

fKeySelected = ИСТИНА;

возврат 0;

случай IDOK:

/*
* Если пользователь не выбрался бы пункт меню
* и нажатие клавиши, отображает напоминание в a
* блок сообщения.
*/

если (!fItemSelected || !fKeySelected) { MessageBox(hwndDlg, "Пункт или клавиша не выбиралась.", НЕДЕЙСТВИТЕЛЬНЫЙ,

MB_OK);
возврат 0;
}

/*
* Определите независимо CTRL, ALT, и СДВИГ
* клавиши выбраны. Конкатенируйте the
* присвойте строки на акселератор-
* текстовый буфер и устанавливает подходящий
* флаги акселератора.
*/

szAccelText[0] = '\0;

hwndCtl = GetDlgItem(hwndDlg, IDD_CNTRL);
если (SendMessage(hwndCtl, BM_GETCHECK, 0, 0)
== 1) {
lstrcat(szAccelText, "Ctl+");
fAccelFlags |= FCONTROL;
}
hwndCtl = GetDlgItem(hwndDlg, IDD_ALT);
если (SendMessage(hwndCtl, BM_GETCHECK, 0, 0)
== 1) {
lstrcat(szAccelText, "Alt+");

fAccelFlags |= FALT;
}
hwndCtl = GetDlgItem(hwndDlg, IDD_SHIFT);
если (SendMessage(hwndCtl, BM_GETCHECK, 0, 0)
== 1) {
lstrcat(szAccelText, "Shft+");
fAccelFlags |= FSHIFT;
}

/*
* Получите выбранное нажатие клавиши и ищите the
* текст акселератора и виртуальная-клавиша кодируются

* для нажатия клавиши в vkeys структуре.
*/

hwndCtl = GetDlgItem(hwndDlg, IDD_KEYSTROKES);
nCurSel = (int) SendMessage(hwndCtl, CB_GETCURSEL, 0, 0);
SendMessage(hwndCtl, CB_GETLBTEXT, nCurSel, (ДОЛГО (ДЛИНОЙ)) (LPSTR) szKeyStroke);
для (i = 0; я < MAXKEYS; я++) { если(lstrcmp(vkeys[i].pKeyString,

szKeyStroke) == 0) { lstrcpy(szKeyStroke, vkeys[i].pKeyName);
прерывание;
}
}

/*
* Конкатенируйте нажатие клавиши текста в the
* строка "Ctl+","Alt+", или "Shft+".
*/

lstrcat(szAccelText, szKeyStroke);

/*
* Определите позицию в меню the
* выбранный пункт меню. Пункты Меню в the
* Меню "Символа" имеет позиции 0,2,3, и 4.
*/

если (lstrcmp(szItem, "Регулярный") == 0) uItemPos = 0;
еще если (lstrcmp(szItem, "Жирный шрифт") == 0) uItemPos = 2;
еще если (lstrcmp(szItem, "Курсив") == 0)

uItemPos = 3;
еще если (lstrcmp(szItem, "Подчеркивание") == 0) uItemPos = 4;

/*
* Получите строку, которая переписывается в the
* выбранный пункт.
*/

GetMenuString(hmenu, uItemPos, szItem, sizeof(szItem), MF_BYPOSITION);

/*
* Добавьте новый текст акселератора в the

* меню-пункт текста.
*/

для (pch = szItem; *pch != '\t; pch++);
++pch;

для (pch2 = szAccelText; *pch2 != '\0;
pch2++) *pch++ = *pch2;
*pch = '\0;

/*
* Модифицируйте пункт меню, чтобы отражать новый
* текст акселератора.

*/

idItem = GetMenuItemID(hmenu, uItemPos);
ModifyMenu(hmenu, idItem, MF_BYCOMMAND | MF_STRING, idItem, szItem);

/* Восстановите выбор flags. */

fItemSelected = ЛОЖЬ;
fKeySelected = ЛОЖЬ;

/* Сохраните текущий акселератор table. */

haccelOld = haccel;

/*

* Посчитайте номером данных в течение
* таблица, распределяет буфер для таблицы, и
* затем скопируйте таблицу в буфер.
*/

cAccelerators = CopyAcceleratorTable( haccelOld, НЕДЕЙСТВИТЕЛЬНЫЙ, 0);
lpaccelNew = (LPACCEL) LocalAlloc(LPTR, cAccelerators * sizeof(ACCEL));

если (lpaccelNew != НЕДЕЙСТВИТЕЛЬНЫЙ)

CopyAcceleratorTable(haccel, lpaccelNew, cAccelerators);

/*
* Найдите акселератор, что пользователь модифицировал
* и изменение флаги и виртуальный-ключевой код
* как подходящий.
*/

для (i = 0; (lpaccelNew[i].cmd == (СЛОВО) idItem) && (я < (UINT) cAccelerators); я++) {

lpaccelNew[i].fVirt = fAccelFlags;
lpaccelNew[i].key = wVKCode;
}

/*
* Создайте новую таблицу акселератора, и
* уничтожьте старый.
*/

DestroyAcceleratorTable(haccelOld);
haccel = CreateAcceleratorTable(lpaccelNew, cAccelerators);

/* Уничтожьте диалог box. */

EndDialog(hwndDlg, ИСТИНА);
возврат 0;

случай IDCANCEL: EndDialog(hwndDlg, ИСТИНА);
возвращайтесь ВЕРНО;

умолчание: прерывание;
}
умолчание: прерывание;
}
обратная ЛОЖЬ;
}

Используются технологии uCoz