Глава 3. Меню и диалоговые ресурсы
Большинство приложений Windows имеют в своих основных окнах
меню, которые предоставляют пользователю возможность выбора -
например, команды File|Save, File|Open и Help. В шаге 4 мы доба-
вим в программу Steps строку меню. Ввод пользователем данных и
выбор параметров в программах Windows часто происходит в диалого-
вых блоках. В шаге 5 в программу Steps будет добавлен диалоговый
блок.
Меню и диалоговые блоки объединены общим понятием ресурсов.
Ресурсы - это данные, хранимые в выполняемом файле, который опи-
сывает пользовательские интерфейсные элементы приложений Windows.
Ресурс не содержит фактического меню или диалогового блока. Вмес-
то этого он содержит информацию, необходимую программе для созда-
ния конкретного диалогового блока или меню.
Ресурсы для программы проще всего создавать с помощью редак-
торов ресурсов, таких как Resource Workshop (пакет разработчика
ресурсов) фирмы Borland. Подробно о создании и редактировании ре-
сурсов рассказывается в "Руководстве пользователя по пакету раз-
работчика ресурсов".
Шаг 4: Добавление строки меню
-----------------------------------------------------------------
+-----------------------+
| Step 1: Basic App |
| Step 2: Text |
| Step 3: Lines |
|XStepX4:XMenuXXXXXXXXXX|
| Step 5: About Box |
| Step 6: Pens |
| Step 7: Painting |
| Step 8: Streams |
| Step 9: Printing |
| Step 10: Palette |
| Step 11: BWCC |
| Step 12: Custom ctrls |
+-----------------------+
В оконной среде выбор пункта меню относится к той же катего-
рии, что и щелчок кнопкой "мыши". И то, и другое - это пользова-
тельские события. Ответ на выбор пункта меню аналогичен реакции
на другие пользовательские события. В данном разделе описываются
шаги, необходимые для добавления в приложение меню.
* Проектирование меню как ресурса меню.
* Определение констант меню во включаемом файле.
* Загрузка файла ресурса из программы.
* Загрузка ресурса меню в объект основного окна.
* Определение реакции на выбор в меню.
Меню прикладной программы - это не отдельный объект, а атри-
бут основного окна. Все оконные объекты имеют набор атрибутов,
записанных в поле записи Attr объекта. В поле Menu записи Attr
хранится не описатель меню, а меню. Чтобы установить атрибут ме-
ню, вы должны переопределить конструктор своего типа окна
TStepWindow.
Ресурсы меню
-----------------------------------------------------------------
Определение ресурсов меню не является частью исходного кода
программы. Вместо этого существует ресурс, содержит текст пунктов
меню и структуру элементов верхнего уровня и их подсистем. Для
проектирования меню и других ресурсов, таких как диалоговые бло-
ки, пиктограммы и битовые массивы, вы можете использовать пакет
разработчика ресурсов Resource Workshop.
Определение идентификаторов ресурса
Приложение обращается к присоединенным к нему ресурсам по
идентификатору ресурса. Этот идентификатор представляет собой це-
лое значение, например, 100, или целочисленную константу, такую
как MyMenu. Кроме того, приложение отличает один выбор меню от
другого по идентификатору, связанному с элементом меню.
Определение констант меню
Чтобы сделать программу более читаемой, замените идентифика-
торы меню константами, определяемыми во включаемом файле. При
создании своего ресурса меню с помощью Resource Workshop или ком-
пилятора ресурсов вы можете включить те же константы и использо-
вать те же идентификаторы, которые вы используете для доступа к
ресурсу к своей программе. Константы меню для программы Steps оп-
ределены в файле STEPS.INC:
const
cm_FilePrint = 105;
cm_FileSetup = 107;
cm_Pen = 200;
cm_About = 201;
cm_PalShow = 301;
cm_PalHide = 302;
Заметим, что число элементов меню в файле STEPS.INC не опре-
делено. Это связано с тем, что ObjectWindows в файле IWINDOWS.INC
определяет для вас некоторые общие команды меню, включая
cm_FileOpen, cm_FileNew, cm_FileSave и cm_FileSaveAs.
Включение файлов ресурсов
Чтобы продолжить работу с программой Steps, используйте па-
кет разработчика ресурсов или компилятор ресурсов для создания
ресурса меню и сохраните его в файле с расширением .RES -
STEPS.RES. Формат файла ресурса в исходном виде вы можете посмот-
реть в файле STEPS.RC. Вы можете также использовать файл
STEPS.RES, который можно найти на дистрибутивных дисках. Имея
файл STEPS.RES, вы можете включить его с помощью директивы компи-
лятора $R:
{$R STEPS.RES}
Директива компилятора $R в конце компиляции и компоновки ав-
томатически добавляет заданный файл ресурса к выполняемому файлу.
Ресурсы можно добавить или удалить из выполняемых файлов, а су-
ществующие ресурсы можно модифицировать.
Примечание: О модификации ресурсов, уже скомпонованных
с выполняемыми файлами, рассказывается в "Руководстве поль-
зователя по пакету разработчика ресурсов".
На Рис. 3.1 показан внешний вид этого меню (идентификатор
ресурса 100). Оно включает в себя пункты File (Файл), Options
(Параметры) и Palette (Палитра), а меню File содержит элементы
New (Новый), Open (Открытие), Save (Сохранение), Save As (Сохра-
нение под именем), Print (Печать), Printer Setup (Установка прин-
тера) и Exit (Выход). Элементы верхнего уровня, у которых есть
подэлементы, не имеют идентификаторов меню, а их вывод не вызыва-
ет никаких действий кроме вывода подэлементов.
Примечание: Не путайте идентификатор ресурса меню с
идентификаторами меню отдельных элементов (пунктов) меню.
+-----------------------------------------------------------+-+-+
|#=#XXXXXXXXXXXXXXXXXXXXStepsXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|^|v|
+-----------------------------------------------------------+-+-|
|XFileX Options Palette |
+------------------+--------------------------------------------|
|XNewXXXXXXXXXXXXXX| |
| Open. | |
| Save | |
| Save as. | |
+------------------| |
| Print. | |
| Printer Setup. | |
+------------------| |
| Exit | |
+------------------+ |
| |
| |
| |
| |
| |
+---------------------------------------------------------------+
Рис. 3.1 Программа Steps с ресурсом меню.
Загрузка ресурса меню
-----------------------------------------------------------------
Получить ресурс меню можно с помощью вызова функции Windows
LoadMenu:
LoadMenu(HInstance, MakeIntResource(100));
MakeIntResource(100) приводит число 100 к ссылочному типу
PChar, представляющему собой указатель на массив символов. Функ-
ции Windows, воспринимающие в качестве аргументов строки, требу-
ют, чтобы они имели тип PChar. Имея дело с ресурсами, Windows
ожидает, что целые числа должны быть представлены в виде PChar,
поэтому если вы хотите обратиться к ресурсу, имеющему числовой
идентификатор, нужно преобразовать его тип с помощью
MakeIntResource.
Примечание: Для использования типа PChar требуется ус-
тановка $X+ (по умолчанию).
В качестве альтернативы идентификатор меню может иметь сим-
вольный идентификатор, например, 'SAMPLE_MENU'. В этом случае
загрузить ресурс меню можно следующим образом:
LoadMenu(HInstance, 'SAMPLE_MENU');
Вот как это делает TStepWindow.Init (заметим, что первое,
что он делает - это вызов конструктора Init, наследуемого из
TWindow, для выполнения инициализации, необходимой для всех окон-
ных объектов):
constructor TStepWindow(AParent: PWindowObject;
ATitle: PChar);
begin
inherited Init(AParent, ATitle);
Attr.Menu := LoadMenu(HInstance, MakeIntResource(100));
BottomDown := False;
HasChanged := False;
end;
Теперь при выводе основного окна оно имеет рабочее меню, по-
казанное на Рис. 1.3. Однако, чтобы при выборе элементов меню вы-
полнялись какие-либо действия, вы должны перехватывать сообщения
меню и реагировать на них. Если вы не определили реакцию на ко-
манду меню, то можете выбирать элемент меню, но при этом ничего
не происходит.
Перехват сообщений меню
-----------------------------------------------------------------
Когда пользователь выбирает элемент меню, окно, к которому
присоединено меню, получает командное сообщение Windows.
ObjectWindows обрабатывает и диспетчеризует эти сообщения
wm_Command аналогично другим сообщениям, но облегчает для вас ра-
боту со специальными командами.
Одним из параметров сообщения wm_Command является сама ко-
манда (номер, соответствующий идентификатору меню выбранного эле-
мента). Вместо вызова метода WMCommand и возложения на вас реше-
ния, что делать с каждой возможной командой, ObjectWindows вызы-
вает основанные на конкретных командах методы. Чтобы обработать
эти сообщения, вы можете определить методы для объектного типа
TStepWindow, используя специальное расширение:
procedure CMFileNew(var Msg: TMessage);
virtual cm_First + cm_FileNew;
где cm_First - это константа ObjectWindows, определяющая начало
диапазона констант для команд, а cm_FileNew - это желаемая коман-
да меню. Это означает, что все элементы меню должны иметь уни-
кальные идентификаторы (если только не предполагается реагировать
на них одинаковым образом).
Примечание: О диапазонах сообщений и смещениях расска-
зывается в Главе 16.
Не путайте основанный на cm_First динамический индекс метода
с индексом, соответствующим поступающему сообщению Windows (осно-
ванному на wm_First). cm_First - это специальное смещение, ис-
пользуемое только для определения методов реакции для команд меню
и командных клавиш.
Определение методов реакции на команду
-----------------------------------------------------------------
Теперь вы можете определить все методы реакции на команды:
procedure CMFileNew(var Msg: TMessage);
virtual cm_First + cm_FileNew;
procedure CMFileOpen(var Msg: TMessage);
virtual cm_First + cm_FileOpen;
procedure CMFileSave(var Msg: TMessage);
virtual cm_First + cm_FileSave;
procedure CMFileSaveAs(var Msg: TMessage);
virtual cm_First + cm_FileSaveAs;
procedure CMFilePrint(var Msg: TMessage);
virtual cm_First + cm_FilePrint;
procedure CMFileSetup(var Msg: TMessage);
virtual cm_First + cm_FileSetup;
Определять процедуру CMExit не требуется, поскольку
TWindowsObject уже определяет завершающую программу процедуру,
которая вызывается при поступлении в основное окно сообщения
cm_Exit.
Связывание клавиш с командами
-----------------------------------------------------------------
Методы реакции на команды не связываются с конкретным эле-
ментом меню - они привязаны к конкретной команде. Объекту не важ-
но, откуда поступила команда. Он знает только, что что-то вызвало
данное командное сообщение. Таким образом, у вас есть несколько
способов генерации команды. Обычно для этого применяются опера-
тивные клавиши, называемые командными клавишами.
Командные клавиши определяются в ресурсах аналогично меню,
но они намного проще. Ресурс командной клавиши - это таблица на-
жатий клавиш и команд, которые они генерируют. О создании ресур-
сов для командных клавиш рассказывается в "Руководстве пользова-
теля по пакету разработчика ресурсов".
Каждая прикладная программа может иметь только один набор
командных клавиш. Чтобы загрузить в программу ресурс командных
клавиш, переопределите метод InitInstance:
procedure TMyApplication.InitInstance;
begin
inherited InitInstance;
HaccTable := LoadAccelerators(HInstance, 'ShortCuts');
end;
Командные клавиши 'ShortCuts' в STEPS.RES связывают знакомые
вам по IDE функциональные клавиши с аналогичными функциями прог-
раммы Steps. Например, клавиша F3 генерирует команду cm_FileOpen.
Реакция на команды меню
-----------------------------------------------------------------
Теперь для каждого выбора в меню у вас есть метод, который
будет вызываться в ответ на соответствующую команду. Выбор коман-
ды File|Print вызывает ваш метод CMFilePrint. Пока вызовем просто
окно сообщения:
procedure TStepWindow.CMFilePrint(var sg: TMessage);
begin
Message(HWindow, 'Средство не реализовано',
'Печать файла', mb_Ok);
end;
На Рис. 3.2 показана реакция программы Steps на выбор коман-
ды File|Print.
+-----------------------------------------------------------+-+-+
|#=#XXXXXXXXXXXXXXXXXXXXStepsXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|^|v|
+-----------------------------------------------------------+-+-|
| File Options Palette |
+---------------------------------------------------------------|
| |
| |
| +----------------------------------------------+ |
| |@=@##############Печать файла#################| |
| +----------------------------------------------| |
| | | |
| | Средство не реализовано | |
| | | |
| | +-----------+ | |
| | |####OK#####| | |
| | +-----------+ | |
| +----------------------------------------------+ |
| |
| |
| |
| |
+---------------------------------------------------------------+
Рис. 3.2 Программа Steps реагирует на команду File|Print.
Для CMFileOpen, CMFileSave, CMFileSaveAs и CMFileSetup напи-
шите фиктивные методы, аналогичные CMFilePrint. Позднее вы пере-
пишете данные методы для выполнения осмысленных действий.
Теперь, очистив окно, вы можете реагировать на выбор команды
меню File|New более интересным образом. Добавьте следующий метод
CMFileNew:
procedure TStepWindow.CMFileNew(var Msg: TMessage);
begin
InvalidateRect(HWindow, nil, True);
end;
InvalidateRect выполняет принудительное повторное отображе-
ние окна. Полный исходный код программы Steps для данного этапа
содержится в файле STEP04A.PAS.
Добавление диалогового блока
-----------------------------------------------------------------
Диалоговый блок аналогичен всплывающему окну, но обычно оно
сохраняется на экране в течении короткого периода и выполняет од-
ну конкретную задачу, связанную с вводом-выводом, такую как выбор
принтера или настройка страницы документа. Здесь мы добавим в
программу Steps диалоговое окно для открытия и сохранения файлов.
Файловое диалоговое окно, как одно из диалоговых окон
ObjectWindows, определено с типом TFileDialog. Файловое диалого-
вое окно полезно использовать в любой ситуации, когда вы запраши-
ваете у пользователя для сохранения и загрузки выбор файла на
диске. Например, редактор текстов может использовать диалоговое
окно для открытия и сохранения документов.
Вы будете выводить файловое диалоговое окно в ответ на выбор
пользователем команды File|Open или File|Save As. Файловое диало-
говое окно заменяет окно сообщения "Средство не реализовано". В
шаге 8 оно будет приспособлено для некоторых реальных файлов, а
также сохранения и открытия их для записи и считывания реальных
данных. Пока просто выведем диалоговые окна. Вид файлового диало-
гового окна показан на Рис. 3.3.
+-----------------------------------------------------------+-+-+
|#=#XXXXXXXXXXXXXXXXXXXXStepsXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|^|v|
+-----------------------------------------------------------+-+-|
| File Options Palette |
+---------------------------------------------------------------|
| +----------------------------------------------+ |
| |@=@##############Открытие файла###############| |
| +----------------------------------------------| |
| | +------------------+ +----------+| |
| | Имя файла: | *.pts | |####OK####|| |
| | +------------------+ +----------+| |
| | +----------+| |
| | Каталог: a:\ |##Cancel##|| |
| | +----------+| |
| | Файлы: Каталоги: | |
| | +----------------+ +-------------+-+ | |
| | | | |[-a] |^| | |
| | | | |[-b] +-| | |
| | | | |[-c] |#| | |
| | | | |[-d] |#| | |
| | | | |[-e] |#| | |
| | | | |[-f] |#| | |
| | | | |[-g] |#| | |
| | | | |[-h] +-| | |
| | | | |[-i] |v| | |
| | +----------------+ +-------------+-+ | |
| +----------------------------------------------+ |
+---------------------------------------------------------------+
Рис. 3.3 Программа Steps с диалоговым блоком File Open.
Добавление к программе Steps файлового диалогового блока
требует трех шагов:
* Добавление поля объекта, содержащего имя файла.
* Модификация конструктора объекта для инициализации файла.
* Выполнение диалогового блока.
Добавление поля объекта
-----------------------------------------------------------------
Вместо хранения всего объекта файлового диалогового окна в
виде поля его порождающего окна, вам следует построить новый объ-
ект файлового диалогового окна, когда он потребуется. Вместо дан-
ных, которые вам следует хранить вместо данных этого диалогового
окна, вы должны сохранять имя и маску файла. На практике хорошо
придерживаться следующего: вместо хранения всех объектов, которые
вам могут не потребоваться, храните просто данные, необходимые
для инициализации объектов, когда они потребуются.
Построение файлового диалогового блока требует трех парамет-
ров: порождающего окна, шаблона ресурса и имя или маску файла (в
зависимости от того, используется файловое окно для открытия или
закрытия файла). Шаблон ресурса определяет, какое из стандартных
файловых диалоговых окон вы хотите использовать. Стандартные фай-
ловые диалоговые ресурсы определяются идентификаторами ресурсов
sd_FileOpen и sd_FileSave. Параметр имени файла используется для
передачи используемой по умолчанию маски файла диалогу открытия
файла (а также для возврата выбранного имени файла) и для переда-
чи используемого по умолчанию имени для сохранения файла.
Параметр шаблона ресурса определяет, будет ли файловый диа-
логовый блок использоваться для открытия или для сохранения фай-
ла. Если диалоговый ресурс имеет блок списка файлов с идентифика-
тором управляющего элемента id_FList, диалоговый блок использует-
ся для открытия файлов; отсутствие такого блока списка указывает
на диалоговое окно для сохранения файлов.
Определение типа TStepsWindow должно теперь выглядеть следу-
ющим образом:
TStepWindow = object(TWindow)
.
.
.
FileName: array[0.fsPathName] of Char;
.
.
.
Примечание: Для работы с константой fsPathName нужно
использовать модуль WinDos.
Модификация конструктора
Для создания экземпляра объекта справочного окна вы можете
использовать конструктор Init типа TStepWindow. Теперь вам потре-
буется добавить к нему код для инициализации FileName:
StrCopy(FileName, '*.PTS');
Расширение .PTS используется для файлов, содержащих точки
вашего графического изображения.
Выполнение диалогового блока
В зависимости от переданного конструктору диалогового блока
параметра шаблона ресурса диалоговый блок может поддерживать отк-
рытие или сохранение файла. Каждый параметр, при создании диало-
гового блока, аналогичен показанному на Рис. 3.3. Между диалогами
открытия или закрытия файла имеются два различия: диалог открытия
содержит список файлов в текущем каталоге, соответствующий теку-
щей маске файла, а в диалоге сохранения в поле редактирования уп-
равляющего диалогового элемента выводится имя текущего файла, но
список файлов отсутствует.
CMFileOpen и CMFileSaveAs следует переписать следующим обра-
зом:
procedure TStepWindow.CMFileOpen(var Msg: TMessage);
begin
if Application^.ExecDialog(New(PFileDialog,
Init(@Self, PChar(sd_FileOpen), FileName))) = id_Ok
then MessageBox(HWindow, FileName, 'Открыть файл:',
mb_Ok);
end;
procedure TStepWindow.CMFileSaveAs(var Msg: TMessage);
begin
if Application^.ExecDialog(New(PFileDialog,
Init(@Self, PChar(sd_FileSave), FileName))) = id_Ok
then MessageBox(HWindow, FileName, 'Сохранить файл:',
mb_Ok);
end;
Заметим, что при выполнении файлового диалогового окна ис-
пользуется тот же метод ExecDialog, который вы вызывали для вы-
полнения диалогового окна ввода в шаге 3. С помощью метода
ExecDialog выполняются все режимные диалоговые окна в приложении.
Полный исходный код программы Steps для данного шага вы мо-
жете найти в файле STEP04B.PAS.
------------------------------------------------------------------------
Шаг 5: Добавление диалогового блока
-----------------------------------------------------------------
+-----------------------+
| Step 1: Basic App |
| Step 2: Text |
| Step 3: Lines |
| Step 4: Menu |
|XStepX5:XAboutXBoxXXXXX|
| Step 6: Pens |
| Step 7: Painting |
| Step 8: Streams |
| Step 9: Printing |
| Step 10: Palette |
| Step 11: BWCC |
| Step 12: Custom ctrls |
+-----------------------+
До сих пор в программе Steps использовались два очень прос-
тых диалоговых блока: окно сообщений (в методе CanClose) и диало-
говый блок ввода для изменения размера пера. Эти диалоговые блоки
удобно применять для простых задач, но в программах обычно требу-
ются более сложные и ориентированные на задачу взаимодействия с
пользователем. В таких случаях вы можете разработать собственные
диалоговые блоки.
Как и меню, диалоговые блоки обычно создаются из описания,
сохраненного в ресурсе. Для сложных диалоговых блоков это значи-
тельно быстрее, чем индивидуальное создание каждого элемента от-
дельного окна. Однако в отличие от меню, поскольку программы
должны взаимодействовать с диалоговыми окнами более разнообразны-
ми и сложными путями, ObjectWindows использует для представления
диалогового блока объект.
Создание диалогового блока из ресурса требует следующих ша-
гов:
* Создание ресурса диалогового блока.
* Построение объекта диалогового блока.
* Выполнение диалогового блока.
Создание ресурсов диалогового блока
-----------------------------------------------------------------
Проектировать ресурсы диалогового блока можно несколькими
способами, используя пакет разработчика ресурса Resource Workshop
или компилятор ресурсов. Диалоговый блок (блок диалога) - это
специализированное окно с рамкой, содержащее один или более уп-
равляющих элементов (командные кнопки, блоки списка и пиктограм-
мы). Ваша прикладная программа не знает о том, как выглядят уп-
равляющие элементы и как они позиционированы; она знает только о
типе управляющих элементах и их идентификаторах.
Примечание: Не забывайте, что ресурс - это просто не-
кое описание того, что будет создавать ваша программа.
Идентификаторы управляющих элементов
-----------------------------------------------------------------
Аналогично элементам в ресурсе меню, каждый управляющий эле-
мент в ресурсе диалогового блока имеет идентификатор, который
прикладная программа использует для определения того, с каким уп-
равляющим элементом нужно взаимодействовать. Для статических эле-
ментов, с которыми ваша прикладная программа не взаимодействует
(статический текст или битовые массивы) уникальные идентификаторы
не требуются, поэтому они обычно имеют идентификатор -1.
Обычно, если вашей прикладной программе требуется доступ к
конкретному управляющему элементу, вы присваиваете ему идентифи-
катор-константу, так что и ваша программа, и компилятор ресурсов
могут использовать в качестве идентификатора одно и то же сим-
вольное имя. Такие идентификаторы-константы следует определять во
включаемом файле или в модуле, содержащем только описания-конс-
танты. При создании или редактировании ваших ресурсов пакет раз-
работчика ресурсов автоматически управляет такими файлами.
Построение объекта диалогового блока
-----------------------------------------------------------------
После того как ресурс диалогового окна будет определен, ваша
программа может использовать его для создания и выполнения диало-
гового окна. Диалоговые блоки выводятся обычно как дочерние окна
основного окна приложения, но они создаются несколько по-другому,
чем обычные окна.
Конструктор объекта диалогового блока выглядит как конструк-
тор оконного объекта, воспринимающий два параметра. В обоих слу-
чаях первый параметр - это указатель на объект порождающего окна.
Второй параметр (PChar) определяет заголовок объекта окна. Однако
для объекта диалогового блока в качестве шаблона диалогового бло-
ка используется имя диалогового ресурса.
Файл ресурса для программы Steps определяет диалоговый блок
с именем 'ABOUTBOX', которое вы можете использовать в качестве
окна About box, показанного на Рис. 3.4. Построение объекта диа-
логового блока из данного ресурса выглядит следующим образом:
New(PDialog, Init(@Self, 'ABOUTBOX'));
+-------------------------------------------------+
|#=#XXXXXXXXXXXXXXXXXAbout StepsXXXXXXXXXXXXXXXXXX|
+-------------------------------------------------|
| |
| +----------------------------------------+ |
| | | |
| | @@@@ ObjectWindows tutorial program | |
| | @@@@ | |
| | Copiright (C) 1992 | |
| | Borland International Inc. | |
| | All Rights Reserved | |
| +----------------------------------------+ |
| |
| +-----------+ |
| |####OK#####| |
| +-----------+ |
+-------------------------------------------------+
Рис. 3.4 Окно About Box для программы Steps.
Выполнение диалогового блока
-----------------------------------------------------------------
Чтобы выполнить специализированный диалоговый блок, исполь-
зуйте тот же метод ExecDialog, который вы уже использовали для
других диалоговых блоков:
Application^.ExecDialog(New(PDialog,Init(@Self,'ABOUTBOX')));
Естественно, нужно определить команду для вывода диалогового
блока About box; Steps использует сообщение cm_About, генерируе-
мое выбором меню Optrions|About. Теперь такой вид реакции на ко-
манду должен быть вам достаточно знаком (см. файл STEP05.PAS):
type
TStepWindow = object(TWindow)
.
.
.
procedure CMAbout(var Msg: TMessage);
virtual cm_First + cm_About;
end;
procedure TStepWindow.CMAbout(var Msg: TMessage);
begin
Application^.ExecDialog(New(PDialog, Init(@Self,
'ABOUTBOX')));
end;
В шаге 6 мы создадим более сложное диалоговое окно с нес-
колькими управляющими элементами.
Режимные и безрежимные диалоговые блоки
-----------------------------------------------------------------
После выполнения окна с помощью ExecDialog диалоговый блок
становится режимным. Это означает, что программа работает с этим
блоком до его закрытия. Пока активно это окно, все получаемые
программой сообщения поступают в него. Такой диалоговый блок на-
зывается режимным окном приложения, поскольку оно режимное только
по отношению к выполняющему его приложению. Существуют также сис-
темные режимные диалоговые блоки, которые приостанавливают всю
работу приложения, пока блок не будет закрыт. Такие блоки и окна
используются редко, и применять их следует только в том случае,
если при работе других приложений могут возникнуть проблемы.
Иногда желательно получить диалоговый блок, сохраняющийся
при работе других частей программы. Такой диалоговый блок работа-
ет почти как обычное окно, но не является режимным, и потому но-
сит название безрежимного. О создании безрежимных диалоговых бло-
ков рассказывается в Главе 11 "Объекты диалоговых блоков".
Назад | Содержание | Вперед
🔥 VPS до 5.7 ГГц под любые задачи с AntiDDoS в 7 локациях
Виртуальные VPS серверы в РФ и ЕС
