Перейти на главную   
  helloworld.ru - документация и книги по программированию  
helloworld.ru - документация и книги по программированию
    главная     хостинг     контакты
Поиск по сайту:  
Смотрите также
Языки программирования
C#
MS Visual C++
Borland C++
C++ Builder
Visual Basic
Quick Basic
Turbo Pascal
Delphi
JavaScript
Java
PHP
Perl
Assembler
AutoLisp
Fortran
Python
1C

Интернет-технологии
HTML
VRML
HTTP
CGI
FTP
Proxy
DNS
протоколы TCP/IP
Apache

Web-дизайн
HTML
Дизайн
VRML
PhotoShop
Cookie
CGI
SSI
CSS
ASP
PHP
Perl

Программирование игр
DirectDraw
DirectSound
Direct3D
OpenGL
3D-графика
Графика под DOS

Алгоритмы
Численные методы
Обработка данных

Сис. программирование
Драйверы

Базы данных
MySQL
SQL

Другое

Хостинг


Друзья
demaker.ru
Реклама

Лучший хостинг. Аренда серверов




helloworld.ru

Часть 1. Изучение ObjectWindows

                          Глава 1. Знакомство с Windows

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

             Этот процесс разбит на следующие шаги:

             - создание базового приложения;
             - вывод текста в окне;
             - изображение линий в окне;
             - добавление строки меню;
             - добавление диалогового окна;
             - изменение атрибутов пера;
             - повторное отображение графики;
             - сохранение изображения в файле;
             - печать образа;
             - добавление всплывающего окна;
             - добавление специализированных управляющих элементов;
             - создание специализированного управляющего элемента окна.

             Исходный код приложения для различных этапов вы можете найти
        на дистрибутивных  дисках.  Описываемым в руководстве шагам соот-
        ветствуют файлы STEP01.PAS,  STEP02.PAS и так далее (можно  найти
        также промежуточные программы).

                       Шаг 1: Создание базового приложения
        -----------------------------------------------------------------

             +-----------------------+
             |XStepX1:XBasicXAppXXXXX| Базовая программа
             | Step 2: Text          | Текст
             | Step 3: Lines         | Строки
             | Step 4: Menu          | Меню
             | 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 | Специализированные элементы
             +-----------------------+

             Отправным пунктом для всех программ,  которые  вы  пишете  с
        применением ObjectWindows,  является  программа STEP01A.PAS.  Эта
        программа, которая называется Steps, создает основное окно прило-
        жения.

             Все программы   ObjectWindows   должны  использовать  модуль
        OWindows, которые  содержит  стандартные  объекты,   используемые
        ObjectWindows для приложений и окон. Большинство приложений вклю-
        чают в себя также диалоговые блоки и соответствующие  управляющие
        элементы. ObjectWindows  предусматривает для них объекты в модуле
        ODialogs. Объекты,  относящиеся  к  печати,  находятся  в  модуле
        OPrinter. Программам,  применяющим наборы и потоки, необходим мо-
        дуль Objects.

             Кроме модулей ObjectWindows большинству программ  необходимы
        также модули WinTypes и WinProcs.  Эти два модуля определяют типы
        и константы (WinTypes) и процедуры и функции (WinProcs), образую-
        щие прикладной программный интерфейс Windows (API).  Приложениям,
        использующим продвинутые средства Windows  (версий  старше  3.0),
        кроме данных двух нужны также другие модули.

                   Примечание: Обзор модулей ObjectWindows вы можете най-
              ти в Главе 7 "Иерархия ObjectWindows".

                             Требования к приложению
        -----------------------------------------------------------------

             Все приложения Windows имеют основное окно, которое выводит-
        ся при запуске программы пользователем.  Пользователь выходит  из
        приложения, закрывая  основное  окно.  В приложении ObjectWindows
        основное окно представляет собой объект окна. Этот объект принад-
        лежит объекту приложения, который отвечает за создание и вывод на
        экран основного окна,  обработку сообщений Windows  и  завершение
        программы. Объект приложения действует как объектно-ориентирован-
        ная замена самого приложения.  Аналогично, чтобы сделать скрытыми
        детали программирования в Windows,  ObjectWindows предусматривает
        окно, диалоговый блок и другие объектные типы.

             Каждая программа ObjectWindows должна определять  новый  тип
        приложения, являющегося    наследником    предоставляемого   типа
        TApplication. В   программе    Steps    этот    тип    называется
        TMyApplication. Приведем основной блок программы Steps:

             var
               MyApp: TMyApplication;
             begin
               MyApp.Init('Steps');
               MyApp.Run;
               MyApp.Done;
             end.

             Init - это конструктор TMyApplication,  создающий новый объ-
        ект MyApp.  Он позволяет также задать имя приложения (поле объек-
        та) 'Steps'  и создает (и выводит) основное окно приложения.  Run
        запускает последовательность вызовов  методов,  составляющих  ход
        выполнения приложения    Windows.    Done    -   это   деструктор
        TMyApplication.

                           Определение типа приложения
        -----------------------------------------------------------------

             Ваша прикладная  программа  должна  создавать  новый  тип из
        стандартного типа ObjectWindows TApplication (или  некоторых  ти-
        пов,  производных от TApplication). Этот новый тип должен переоп-
        ределять  по  крайней   мере   один   метод   -   InitMainWindow.
        TApplication.InitMainWindow вызывается ObjectWindows автоматичес-
        ки для установки  основного  окна  программы.  Каждое  приложение
        ObjectWindows должно строить свое основное окно.

                   Примечание: Объекты  приложения подробно описываются в
              Главе 8.

             Определение TMyApplication имеет следующий вид:

             type
               TMyApplication = object(TApplication)
                  procedure InitMainWindow; virtual;
             end;

                          Инициализация основного окна
        -----------------------------------------------------------------

             InitMainWindow отвечает за построение объекта окна,  исполь-
        зуемого в качестве основного окна программы. Этот объект основно-
        го окна хранится в поле объекта  приложения  MainWindow.  Объекту
        приложения принадлежит объект основного окна,  но эти два объекта
        не являются родственными в иерархии наследования.

             precedure TMyApplication.InitMainWindow;
             begin
               MainWindow := New(PWindow, Init(nil, 'Steps'));
             end;

             Обычно метод  InitMainWindow модифицируется для создания но-
        вого типа основного окна.  Указанный метод  использует  экземпляр
        объекта TWindow - предоставляемый ObjectWindows тип окна, который
        определяет наиболее общее окно.  На шаге 2 мы заменим  его  более
        интересным оконным типом.

             Пока программа  Steps  просто  выводит на экран пустое окно,
        которое можно перемещать по экрану,  изменять его размер, миними-
        зировать, максимизировать  и  закрывать.  Приведем полный листинг
        программы Steps, которую мы получили к данному моменту:

             program Steps;

             uses OWindows;

             type
               TMyApplication = object(TApplication)
                  procedure InitMainWindow; virtual;
               end;

             procedure TMyApplication.InitMainWindow;
             begin
               MainWindows := New(PWindow, Init(nil, 'Steps'));
             end;

             var MyApp: TMyApplication;
             begin
               MyApp.Init('Steps');
               MyApp.Run;
               MyApp.Done;
             end.


                              Объект основного окна
        -----------------------------------------------------------------

             Пока программа Steps состоит из двух объектов - объекта при-
        ложения и  объекта  окна.  Объект приложения (MyApp) является эк-
        земпляром TMyApplication - типом,  производным  от  TApplication.
        Оконный  объект,  который  содержится  в  поле MainWindow объекта
        MyApp,  является экземпляром TWindow (общее окно  ObjectWindows).
        Во  всех программах,  кроме простейших,  вам нужно определить тип
        своего основного окна,  соответствующий поведению  приложения.  В
        данном разделе  мы  выведем на экран основное окно,  тип которого
        является производным от TWindow.

                   Приложения: Более подробно об основном окне  рассказы-
              вается в Главе 8 "Объекты приложения".

                             Что такое объект окна?
        -----------------------------------------------------------------

             Объект приложения инкапсулирует стандартное поведение прило-
        жения Windows,   включая   построение   основного    окна.    Тип
        TApplication обеспечивает  фундаментальное  поведение для каждого
        создаваемого вами приложения.

             Аналогично, объект окна инкапсулирует поведение, реализуемое
        приложениями ObjectWindows, включая их основные окна. Это поведе-
        ние включает в себя вывод на экран, изменение размера и закрытие;
        ответ на пользовательские события,  такие как щелчок кнопкой "мы-
        ши",  буксировку и выбор пунктов меню;  вывод управляющих элемен-
        тов, таких как блоки списка и командные кнопки. Тип TWindow и его
        предок  TWindowsObject предусматривают для данного базового пове-
        дения методы и поля.

                   Примечание: Объекты окна подробно описываются в  Главе
              10 "Объекты окна".

             Чтобы сделать ваши программы полезными  и  интересными,  вам
        нужно создать новый тип, производный от TWindow. Новый тип насле-
        дует поля и методы TWindow и добавляет часть своих.  В общем слу-
        чае объектно-ориентированный подход позволяет вам не "изобретать"
        каждый раз окно.


                                    Описатели
        -----------------------------------------------------------------

             Объект окна имеет по крайней мере три поля:  HWindow. Parent
        и ChildList.  HWindow  содержит описатель окна.  Описатель окна -
        это уникальное число,  которое связывает интерфейсный объект (та-
        кой как окно, диалоговый блок или объект управляющего элемента) с
        соответствующим элементом экрана.

                   Примечание: Подробно  об описателях окна  их использо-
              вании рассказывается в Главе 10 "Объекты окна".

             Таким образом,  HWindow содержит целое значение, идентифици-
        рующее соответствующий  элемент  экрана.  Это напоминает бирку на
        связке ключей.  Аналогично тому как вы выбираете ключ, чтобы дос-
        тать из шкафа пальто,  вы выбираете описатель для получения окна.
        В большинстве случаев вы работаете с объектами окна,  и у вас нет
        необходимости манипулировать описателем окна непосредственно,  но
        они используются при вызове функций Windows.  Например, на данном
        шаге вы вызываете функцию MessageBox.  Эта функция требует указа-
        ния параметра,  идентифицирующего порождающее окно сообщений.  Вы
        указываете основное  окно,  описатель которого записан в его поле
        HWindow:

             MessageBox(MainWindow^.HWindow, 'Хотите сохранить?',
                        'Файл не изменен', mb_YesNo or mb_IconQuestion);

                           Порождающие и дочерние окна
        -----------------------------------------------------------------

             Большинство приложений используют несколько  окон,  и, чтобы
        они взаимодействовали,  их требуется связать.  Например, когда вы
        завершаете приложение, оно должно иметь способ очистки всех окон,
        за которые отвечает.  В общем случае Windows справляется с  этим,
        связывая окна как дочернее и порождающее.  Порождающее окно отве-
        чает за свое дочернее  окно.  ObjectWindows  предусматривает  для
        каждого  объекта окна поля для отслеживания порождающего и дочер-
        них окон.

                   Примечание: Взаимодействие  этих окон подробнее описы-
              вается в Главе 9.

             Поле Parent содержит указатель на порождающий  оконный  объ-
        ект. Это не порождающее окно в смысле предка,  а скорее окно-вла-
        делец. Взаимосвязь этих окон описывается в шаге 10.

             Третье поле оконного объекта - это поле ChildList,  содержа-
        щее связанный список дочерних окон.

                            Создание нового типа окна
        -----------------------------------------------------------------

             Теперь у вас есть некоторое представление о том,  что содер-
        жит оконный объект, и вы можете создать новый оконный тип, произ-
        водный от  TWindow,  используя  его  как  основное окно программы
        Step. Сначала  измените   определения   и   задайте   новый   тип
        TStepWindow. Не  забудьте также определить новый указатель на тип
        TStepWindow - PStepWindow, который будет полезен при создании эк-
        земпляров объектов TStepWindow.

             type
               PStepWindow = ^TStepWindow;
               TStepWindow = object(TWindow)
             end;

             Затем измените TMyApplication.InitMainWindow,  чтобы создать
        в качестве основного окна вместо TWindow TStepWindow.

             procedure TMyApplication.InitMainWindow;
             begin
               Main := New(PStepWindow, Init(nil, 'Step'));
             end;

             Определение нового  типа  и  создание   его   экземпляра   в
        InitMainWindow -  это  все,  что требуется для определения нового
        типа основного окна для TMyProgram.  Объект  приложения  вызывает
        методы для создания интерфейсного элемента окна (Create) и вывода
        его на экран (Show).  Вам почти никогда не потребуется  использо-
        вать эти методы непосредственно. Обычно они вызываются при вызове
        метода MakeWindow объекта приложения.

                   Примечание: MAkeWindow поясняется в  Главе  9  "Интер-
              фейсные объекты".

             Однако TStepWindow не определяет новых видов поведения,  от-
        личных от тех,  которые наследуются от TWindow  и  TWindowObject.
        Другими словами,  программа  Step не становится более интересной.
        Такие виды поведения будут добавлены в следующем разделе.

                              Реакция на сообщения
        -----------------------------------------------------------------

             Скорейший способ  сделать оконный объект полезным - это зас-
        тавить его отвечать на  некоторые  сообщения  Windows.  Например,
        когда вы щелкаете "мышью" в основном окне программы Step, Windows
        посылает окну сообщение wm_LButtonDown,  которое  перехватывается
        ObjectWindows и посылается затем соответствующему оконному объек-
        ту.  Это указывает оконному объекту,  что пользователь щелкнул  в
        нем  кнопкой "мыши".  При этом передаются также координаты точки,
        где пользователь нажал кнопку.  (Эту информацию мы  используем  в
        шаге 2.)

                   Примечание: Сообщения   Windows  определены  в  модуле
              WinTypes.

             Аналогично, когда пользователь щелкает правой  кнопкой  "мы-
        ши", основной  оконный  объект получает сообщение wm_RButtonDown,
        переданное Windows. На следующем шаге мы узнаем, как сделать так,
        чтобы основное окно (экземпляр TStepWindow) отвечало на эти сооб-
        щения и делало что-нибудь полезное.

             Чтобы перехватывать сообщения Windows и отвечать на них, для
        каждого типа поступающего сообщения,  на которое вы хотите реаги-
        ровать, вам нужно определить метод оконного объекта. Такие методы
        называются методами реакции на сообщение.  Чтобы определить заго-
        ловок определения метода как метод реакции, нужно добавить к вир-
        туальному методу  расширение,  представляющее собой идентификатор
        сообщения, на которое нужно реагировать.  Например,  определенный
        ниже метод реагирует на все сообщения wm_LButtonDown.

             type
               TStepWindow = object(TWindow)
                  procedure WMLButtonDown(var Msg: TMessage); virtual
                     vm_First + wm_LButtonDown;
               end;

                   Примечание: Все программы и  модули,  переопределяющие
              методы ответа на сообщение, должны использовать WinTypes.

             Все сообщения в Windows, включая системные сообщения Windows
        и команды меню, представляются в виде чисел. Каждый метод реакции
        на сообщение должен иметь уникальное число, так что для сообщений
        Windows и команд,  если они имеют одинаковые  номера,  вызываются
        различные методы.

             Чтобы облегчить для вас эту задачу, ObjectWindows определяет
        для каждого вида  сообщений  константы:  wm_First  для  сообщений
        окон, cm_First  для командных сообщений и nf_First для уведомляю-
        щих сообщений. Подробнее об этих константах рассказывается в Гла-
        ве 7,  но сейчас нужно только помнить,  что когда вы пишете метод
        реакции на сообщение,  начинающееся с  wm_,  к  нему  добавляется
        wm_First.

             Msg - это запись типа TMessage, содержащая такую информацию,
        как координаты точки,  где была нажата кнопка "мыши".  Все методы
        реакции на сообщение должны воспринимать один параметр-переменную
        типа TMessage.  Аргумент Msg мы рассмотрим в программе Step позд-
        нее.

             В данный момент вы можете просто определить методы  реакции,
        которые выводят  на экран окно сообщения о нажатии кнопки "мыши".
        Позднее вы сможете добавить более полезную реакцию.  Приведем оп-
        ределение метода реакции на нажатие левой кнопки "мыши":

             procedure TStepWindow.WMLButtonDown(var Msg: TMessage);
             begin
               MessageBox(HWindow, 'Вы нажали левую кнопку мыши',
                   'Диспетчеризуемое сообщение', mb_OK);
             end;

                   Примечание: Программы, которые вызывают MessageBox или
              другие функции  API  Windows,  должны  использовать  модуль
              WinProcs.

        +-----------------------------------------------------------+-+-+
        |#=#XXXXXXXXXXXXXXXXXXXXStepsXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|^|v|
        +-----------------------------------------------------------+-+-|
        |                                                               |
        |      +----------------------------------------------+         |
        |      |@=@#########Диспетчеризуемое сообщение########|         |
        |      +----------------------------------------------|         |
        |      |                                              |         |
        |      |       Вы нажали левую кнопку мыши            |         |
        |      |                +-----------+                 |         |
        |      |                |####OK#####|                 |         |
        |      |                +-----------+                 |         |
        |      +----------------------------------------------+         |
        |                                                               |
        +---------------------------------------------------------------+

             Рис. 1.2 Программа Steps реагирует на пользовательское собы-
        тие.

                         Завершение прикладной программы
        -----------------------------------------------------------------

             Программа Steps  завершает  выполнение,  когда  пользователь
        дважды щелкает "мышью" в блоке управляющего меню основного окна -
        маленьком квадрате в левом верхнем углу. Окно и приложение немед-
        ленно закрываются.  Такое поведение годится для простых программ,
        но может вызвать затруднения в более сложных случаях.

             Перед выходом  хорошо написанное приложение всегда спрашива-
        ет, хочет ли пользователь сохранить несохраненные результаты  ра-
        боты. Такой  вид  поведения вы легко можете добавить в свою прик-
        ладную программу ObjectWindows.  Начните со Step и добавьте двой-
        ную проверку запроса пользователя на выход.

             Когда пользователь      пытается      закрыть     приложение
        ObjectWindows, Windows   посылает   основному   окну    сообщение
        wm_Close, которое вызывает метод CanClose приложения.  CanClose -
        это  булевская функция, указывающая, можно ли завершить (OK) при-
        ложение (True). По умолчанию метод CanClose наследуется из вызова
        TApplication метода CanClose основного оконного объекта.  В боль-
        шинстве случаев  решение о закрытии (OK) принимается объектом ос-
        новного окна.


                            Переопределение CanClose
        -----------------------------------------------------------------

             Тип основного  окна  TStepWindow наследует метод CanClose от
        TWindowObject, которые вызывает методы CanClose каждого из  своих
        дочерних окон  (если они имеются).  Если дочерних окон нет (как в
        данном случае),  CanClose просто возвращает значение True.  Чтобы
        модифицировать поведение приложения при закрытии, вы можете пере-
        определить метод CanClose для объектного  типа  своего  основного
        окна:

             function TStepWindow.CanClose: Boolean;
             var Reply: Integer;
             begin
                CanClose := True;
                Reply := MessageBox(HWindow, 'Хотите сохранить?',
                           'Графическое изображение изменено',
                           mb_YesNo or mb_IconQuestion);
                if Reply = id_Yes then CanClose := False;
             end;


             Теперь когда пользователи попытаются закрыть Step, они полу-
        чат окно сообщений с запросом "Хотите сохранить".  Щелчок "мышью"
        на командной кнопке Yes (Да) приводит к тому,  что CanClose возв-
        ращает значение False и предотвращает закрытие основного  окна  и
        приложения. Щелчок "мышью" на No (Нет) возвращает True,  и прило-
        жение завершает работу.  На шаге 8 это окно сообщений получит не-
        который смысл.  Модифицированная программа Steps показана на Рис.
        1.3.

        +-----------------------------------------------------------+-+-+
        |#=#XXXXXXXXXXXXXXXXXXXXStepsXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|^|v|
        +-----------------------------------------------------------+-+-|
        |                                                               |
        |                                                               |
        |      +----------------------------------------------+         |
        |      |@=@#########Изображение изменилось############|         |
        |      +----------------------------------------------|         |
        |      |  @@@                                         |         |
        |      |  @?@  Хотите сохранить?                      |         |
        |      |  @@@  +-----------+      +-----------+       |         |
        |      |       |###Yes#####|      |####No#####|       |         |
        |      |       +-----------+      +-----------+       |         |
        |      +----------------------------------------------+         |
        |                                                               |
        +---------------------------------------------------------------+

             Рис. 1.3 Программа Steps с переопределенным поведением окна.

                          Дальнейшее изменение закрытия
        -----------------------------------------------------------------

             Естественно, сообщение  о  том,  что изображение изменилось,
        полезно только в том случае, если программа действительно обнару-
        живается изменение  изображения.  Добавив в TStepWindow поле типа
        Boolean, вы можете задать флаг,  указывающий на изменение изобра-
        жения, и  выводить  окно сообщения только тогда,  когда этот флаг
        установлен.

             Нужно помнить о том,  что когда вы добавляете это поле, поле
        нужно также  инициализировать,  поэтому переопределим конструктор
        TStepWindow:

             type
               PStepWindow = ^TStepWindow;
               TStepWindow = object(TWindow)
                  HasGhanged: Boolean;
                  constructor Init(AParent: PWindowsObject: ATitle:
                                   PChar);
                   .
                   .
                   .
                end;

             constructor TStepWindow.Init(AParent: PWindowsObject:
                                   ATitle: PChar);
             begin
               inherited Init(AParent, ATitle);
               HasChanged := False;
             end;

             Далее измените метод CanClose для проверки перед выводом ок-
        на сообщения HasChanged:

             function TStepWindow.CanClose: Boolean;
             var Reply: Integer;
             begin
               CanClose := True;
               if HasChanged then
               begin
                 Reply := MessageBox(HWindow, 'Хотите сохранить?',
                                     'Изображение изменилось',
                                      mb_YesNo or mb_IconQuestion);
                 if Reply = id_Yes then CanClose := False;
               end;
             end;

             Позднее, когда   вы   фактически   изменяете    изображение,
        HasChanged нужно установить в True.  Следующий листинг показывает
        полный исходный под программы Steps на данном шаге:

             program Steps;

             uses WinTypes, WinProcs, OWindows;

             type
               TMyApplication = object(TApplication)
                  procedure InitMainWindow; virtual;
               end;

             type
               PStepWindow = ^TStepWindow;
               TStepWindow = object(TWindow)
                  Haschanged: Boolean;
                  constructio Init(AParent: PWindowsObject; ATitle:
                                    PChar);
                  function CanClose: Boolean; virtual;
                  procedure CanClose: Boolean; virtual;
                  procedure WMLButtonDown(var Msg: TMessage);
                     virtual wm_First + wm_LButtonDown;
                  procedure WMRButtonDown(var Msg: TMessage);
                     virtual sm_First +? wm_RButtonDown;
             end;

             constructor TStepWindow.Init(AParent: PWindowsObject;
                                          ATitle: PChar);
             begin
               inherited Init(AParent, ATitle);
               HasChanged := False;
             end;

             function TStepWindow.CanClose: Boolean;
             var Reply: Integer;
             begin
                if HasChanged then
                begin
                  CanClose := True;
                  Reply := MessageBox(HWindow, 'Хотите сохранить?',
                                      'Изображение изменилось',
                                       mb_YesNo or mb_IconQuestion);
                 if Reply = id_Yes then CanClose := False;
               end;
             end;

             procedure TStepWindow.WMLButtonDown(var Msg: TMessage);
             begin
               MessageBox(HWindow, 'Вы нажали левую кнопку мыши',
                   'Диспетчеризуемое сообщение', mb_OK);
             end;

             procedure TStepWindow.WMRButtonDown(var Msg: TMessage);
             begin
               MessageBox(HWindow, 'Вы нажали правую кнопку мыши',
                   'Диспетчеризуемое сообщение', mb_OK);
             end;

             procedure TMyApplication.InitMainWindow;
             begin
               MainWindows := New(PStepWindow, Init(nil, 'Steps'));
             end;

             var MyApp: TMyApplication;
             begin
               MyApp.Init('Steps');
               MyApp.Run;
               MyApp.Done;
             end.

[ Назад | Оглавление | Далее ]










helloworld.ru © 2001-2021
Все права защищены