Порядковые типы
Из простых типов данных порядковые — самые простые. В этих типах информация представляется в виде отдельных элементов. Связь между отдельными элементами и их представлением в памяти определяет естественные отношения порядка между этими элементами. Отсюда и название порядковые.
В Object Pascal определены три группы порядковых типов и два типа, определяемых пользователем. Группы — это целые, символьные и булевы типы. Порядковые типы, задаваемые пользователем, — это перечисления и поддиапазоны.
Все значения любого порядкового типа образуют упорядоченную последовательность, и значение переменной порядкового типа определяется его местом в этой последовательности. За исключением переменных целых типов, значения которых могут быть как положительными, так и отрицательными, первый элемент любого порядкового типа имеет номер 0, второй элемент — номер 1 и т.д. Порядковый номер целого значения равен самому значению. Отношение порядка определяет общие для данных всех порядковых типов операции. Некоторые стандартные функции такого вида встроены в Object Pascal. Они представлены в табл. 1.1.
Для всех порядковых типов в Object Pascal существует операция задания типа для преобразования целых значений в значения соответствующих порядковых типов. Если Т — имя порядкового типа, а Х — целое выражение, то Т (X) воз-вращает значение Т с порядковым номером X.
Совет: Программисты, работающие на С и C++, для приращения или уменьшения значений переменных привыкли заметку использовать операторы "++" и "--", возвращающие следующее и предыдущее значения. Программисты Delphi всегда разбивают эти операции на более простые составляющие с помощью функций Pred, Succ. Dec и Inc.
Пошаговая отладка
Одна из самых распространенных задач отладки — выполнение программы шаг за шагом, по одной строке за раз для проверки правильности выполнения. При пошаговом прохождении кода отладчик выводит окно редактирования с выполняемой программой. Точка выполнения, показывающая следующую выполняемую строку программы, представляется в виде зеленой стрелки, расположенной слева от области исходного текста в окне редактирования.
После успешной компиляции модуля на полосе отладочной информации каждая строка кода, внесшая свой вклад в модуль, будет отмечена маленьким, синим кружком. Если же строка не помечена, значит, здесь поработал оптимизатор. Поскольку для таких строк выполняемый код не сгенерирован эти строки не будут помечены точкой выполнения.
Интегрированная среда Delphi предоставляет пользователю несколько команд пошаговой отладки доступных в меню Run (рис 2.10)
Рис 2.10 Используйте меню Run для выполнения команд отладки
Ниже перечислены команды отладки. Run. Выбор этой команды запускает приложение на выполнение в обычном режиме. Вы можете использовать ее как для запуска приложения, так и для продолжения его работы после какого-либо прерывания выполнения (например, по точке останова). Если включена опция Break on Exception, используйте команду для продолжения работы после получения сообщения об исключительной ситуации Step Over. Когда точка выполнения находится на строке содержащей вызов процедуры или функции, используйте эту команду для выполнения строки, включая вызовы в один шаг, без прохождения отдельных строк вызываемых функций. Точка выполнения перемещается при выполнении на следующую строку Trace Into. В отличие от предыдущей команды, эта опция отработает пошаговую отладку вызываемых процедур и функций. Другими словами, если, например, в строке вызывается некая процедура, то при выполнении этой команды точка выполнения перейдет на первую строку процедуры. Однако если в строке нет таких вызовов, значит, последние две команды идентичны. Будьте осторожны при пошаговой трассировке обработчика события OnPaint. Поскольку при пошаговой отладке окно редактора размещается поверх других окон, требуется перерисовка окна приложения, для чего вызывается обработчик события OnPaint... Вы попадаете в замкнутый круг, точнее— в бесконечный цикл вызовов одного и того же обработчика. Тем не менее, стоит лишь проследить, чтобы окна приложения и редактора не перекрывались, и проблема разрешится сама собой. Trace to Next Source Line. Иногда ваш код вызывает другой код косвенно, например, при вызове функции, которая запускает обработчик события, или при вызове функции Windows API, которая, в свою очередь, запускает функцию косвенного вызова. Поскольку такие вызовы косвенные, отладчик не видит вызова и не отслеживает пошагового выполнения таких вызовов. Однако использование описываемой команды приводит к отслеживанию таких вызовов и останову отладчика на первой строке вызываемой таким образом функции или процедуры. I Run to Cursor. Зачастую вам вовсе не хочется в поисках ошибки, местоположение которой с какой-то точностью вам известно, пошагово добираться до нужного места через сотни, а то и тысячи строк кода. В таком случае просто поместите курсор на нужную вам строку программы в окне редактирования и используйте команду Run to Cursor. Эти действия эквивалентны временному помещению точки останова в необходимую вам строку программы, и после выполнения предшествующего строке кода работа программы приостанавливается. Если вы пытаетесь выполнить программу до позиции курсора, который находится в строке, не содержащей отладочной информации, вы получите сообщение об ошибке, показанное на Рисунок 2.11.
Рисунок 2.11. Это сообщение о том, что вы пытаетесь остановить выполнение программа на строке, не содержащей отладочной информации. Show Execution Point. Эта команда заставляет среду разработки открыть окно редактора и показать выполняемую в настоящее время строку программы. Она полезна в случаях, когда вы, например, закрыли или свернули окно редактора во время отладки (обычно при нормальном состоянии окна отладчик делает это автоматически). Program Pause. Выбор этой команды немедленно останавливает выполнение программы. Она особенно полезна при зацикливании программы. Program Reset. Если вы достаточно "наотлаживались" и хотите завершить работу своей программы или запустить ее заново, используйте эту команду. Она немедленно прекратит выполнение программы и вернет вас в среду разработчика. Многие команды имеют связанные с ними комбинации клавиш, например <F9 для Run. Однако назначения клавиш могут быть изменены во вкладке Editor диалогового окна Options. Например, команде Step Over назначена клавиша <F8, но при выборе назначений клавиш в стиле редактора BRIEF назначенной комбинацией клавиш становится <Ctrl+Fl1. Вы можете увидеть назначенные клавиши непосредственно в меню Run, как показано на Рисунок 2.10. Помимо этого, на панели инструментов есть кнопки, вызывающие некоторые из этих команд (вы имеете возможность также удалить некоторые из них или добавить новые).Повторное использование форм
Шаблоны форм Использование шаблонов форм Добавление собственного шаблона Разделяемое хранилище Управление хранилищем объектов
Повторное использование форм
К этому моменту вы уже должны быть хорошо знакомы с объектно-ориентированной природой Delphi. Поскольку TForm представляет собой класс, он может повторно использоваться, расширяться и изменяться. Повторное применение форм поддерживается через шаблоны форм и наследование. Оба эти метода используют Object Repository
Шаблоны форм
Шаблоны форм (Form Templates) предоставляют основу для новой формы. По одной заготовке можно создать несколько форм. В Delphi есть хранилище объектов (Object Repository), в котором содержится множество различных шаблонов форм, диалогов и проектов.
Использование шаблонов форм
Приведенные ниже опции позволяют использовать шаблоны форм. Copy. Эта опция добавляет копию шаблона формы в ваш проект. Изменения объекта в проекте не влияют на другие объекты. Use. Эта опция связывает шаблон непосредственно с вашим проектом. Изменения в проекте воздействуют на объект, находящийся в хранилище, и наоборот. Для иллюстрации сказанного добавим в проект новую форму, основанную на шаблоне About box, следующим образом. Выберите команду File/New Application. Появится пустое приложение. Выберите команду File/New. Появится диалоговое окно New Items. Щелкните на вкладке Forms вверху диалогового окна. Delphi выведет доступные шаблоны форм, как показано на Рисунок 1.6. Убедитесь, что выбран метод Copy или Use. Щелкните на кнопке ОК. Новая форма About box будет добавлена в ваш проект. Если вы выбрали опцию Copy, новая форма будет дубликатом шаблона и дальнейшая работа с ней не отразится на шаблоне-оригинале. При использовании Use все изменения в одном проекте через хранилище форм будут переданы во все проекты, применяющие эту форму с опцией Use.
Добавление собственного шаблона
Хотя имеющиеся шаблоны весьма полезны и хорошо сделаны, для продолжительной профессиональной работы их будет недостаточно. Наверняка нужно будет что-либо доработать или создать новую форму, которую можно было бы использовать в других приложениях. Чтобы не делать одну и ту же работу дважды (трижды, восемьюжды...), создайте шаблон формы и поместите его в хранилище объектов. Создайте форму, добавьте в нее компоненты и приправьте все это кодом по вашему вкусу. Конечно, вы вполне можете использовать в качестве заготовки имеющийся шаблон. Сохраните форму в папке OBJREPOS Delphi. Совет: Object Repository не хранит копий всех шаблонов, а устанавливает связи с их DFM- и PAS-файлами. Если вы удалите такой файл, шаблон станет недееспособным.
Щелкните правой кнопкой мыши на форме и затем выберите команду Add to Repository. При этом Delphi выведет диалоговое окно Add To Repository, показанное на Рисунок 1.7.
Совет: Delphi автоматически включает вновь созданные формы в текущий проект. Они связаны с проектом, как
будто вы воспользовались опцией Use.
Разделяемое хранилище
Вам может не понравиться то, что ваши шаблоны содержатся в хранилище Delphi. Предположим, что вы де инсталлируете Delphi (при этом, чтобы сохранить свои шаблоны, вы будете вынуждены вручную сохранять их в другом месте, а потом вновь добавлять их в очередное хранилище). Или, например, вы работаете в сетевом окружении и хотите поделиться своими формами с другими программистами. Обе эти проблемы позволяет решить концепция разделяемого хранилища.
Разделяемое хранилище (shared repository) представляет собой папку с двумя файлами, используемыми для хранения информации о расположении шаблонов. Вы можете определить расположение разделяемого хранилища, выполнив следующие действия.
Выберите команду Tools/Options, и на экран будет выведено диалоговое окно Environment Options, показанное на Рисунок 1.8. Щелкните на вкладке Preferences вверху диалогового окна. В поле ввода Directory введите путь к папке, которую вы хотите использовать в качестве разделяемого хранилища. Щелкните на ОК. Теперь при выводе диалогового окна New Items Delphi будет просматривать эту папку в поисках шаблонов.
После того как разделяемое хранилище определено, вы вольны в выборе места хранения своих шаблонов.
Управление хранилищем объектов
После добавления шаблона в хранилище вы вдруг обнаруживаете, что совсем забыли внести в него последние исправления. Вы можете сделать это, используя диалоговое окно Object Repository, показанное на Рисунок 1.9. Для его вызова воспользуйтесь командой Tools/Repository.
В списке Pages, расположенном слева в диалоговом окне, перечислены страницы, выводимые в диалоговом окне New Items. Управлять этим набором можно с помощью кнопок Add Page, Delete Page и Rename Page.
Выбор страницы из списка приводит к заполнению списка Objects объектами, содержащимися на этой странице. Если вы выберете элемент [Object Repository], будут показаны все объекты в хранилище. Вы можете перемещать объекты путем их перетаскивания из списка Objects на нужную страницу в списке Pages.
Кнопка Edit Object позволяет вывести диалоговое окно Edit Object Info, показанное на Рисунок 1.10. С его помощью можно редактировать свойства объекта в любой момент.
Кнопка Delete Object удаляет объект из хранилища, но не удаляет его файлы с диска.
Переключатели, расположенные внизу диалогового окна, выполняют две задачи. Первый переключатель. New Form, позволяет определить шаблон, используемый при создании новой формы. Второй, Main Form, определяет шаблон, используемый для построения главной формы при создании нового приложения. Для назначения соответствующих шаблонов просто выберите объект из списка Objects и отметьте нужную опцию.
Если вы выбираете проект, а не форму, диалоговое окно заменит переключатели новыми переключателями New Project. Он позволяет определить шаблон проекта, используемый при создании нового приложения.
Наследование форм
Наследование форм воплощает лучшие возможности повторного использования форм Use и Copy. При копировании вы создаете дубликат формы и добавляете в него необходимые компоненты и код. Неудобство этого метода состоит в том, что изменения не вносятся в шаблон. При использовании Use изменения вносятся не только в шаблон, но и во все объекты в других проектах.
Наследование позволяет создать множество экземпляров шаблона, которые могут отличаться один от другого, как при использовании Copy. Оно так же автоматически вносит изменения в объект хранилища, как и при использовании Use.
Использование наследования форм
В хранилище объектов содержится несколько примеров наследования форм. Для того чтобы наследовать одну форму из другой, выполните следующие действия.
Выберите команду File/New Application. При этом появится пустое приложение. Выберите команду File/New, и будет выведено диалоговое окно New Items. Щелкните на вкладке Dialogs, и будет выведена страница диалогов. Выберите диалог с пиктограммой Help, кнопки которого выровнены вертикально по правой стороне формы. Выберите опцию Inherit. Щелкните на кнопке ОК, и Delphi выведет новую диалоговую форму.
Заголовок нового диалогового окна— OKHelpRightDlg2. Почему Delphi создает это диалоговое окно как OKHelpRightDIg? Ответ заключается в наследовании форм. В списке форм вашего проекта содержится четыре объекта— Form1, OKHelpRightDIg, OKHelpRightDlg2 и OKRightDlg. Поскольку вы наследуете новую форму из OKHelpRightDIg, Delphi включает его в ваш проект для компиляции вашей программы. Это и приводит к наименованию новой формы как OKHelpRightDlg2. К тому же это позволяет избежать конфликта имен. В свою очередь, OKHelpRightDIg — наследник OKRightDlg, а потому последний также включен в проект.
ПРЕДОСТЕРЕЖЕНИЕ: Две родительские формы, OKHelpRightDIg и OKRightDlg, связываются с проектом так же, как и опция Use, поэтому, решив их изменить, вы измените объекты, хранящиеся в Object Repository.
Цепочка наследования отражена в автоматически генерируемом коде. Описание класса OKHelpRightDlg2 выглядит так.
TOKHelpRightDlg2 = class (TOKHelpRightDIg) private
{Закрытые объявления.}
public
{Открытые объявления.}
end;
Совет: Описание класса или типа начинается с буквы Т.
Это объявление не назовешь чересчур информативным. Поскольку вы не добавляли ни новых компонентов, ни кода, OKHelpRightDlg2 не определяет ни новых свойств, ни методов или событий. Определение класса TOKHelpRightDIg несколько интереснее.
TOKHelpRightDIg = class (TOKRightDIg)
HelpBtn: TButton;
procedure HelpBtnClick(Sender: TObject);
private
{Закрытые объявления.}
public
{Открытые объявления.}
end;
Как вы можете видеть, OKHelpRightDIg получает компоненты и код от OKRightDIg и добавляет объект HelpBtn типа TButton, а также обработчик события HelpBtnClick.
Преимущества наследования форм
Как уже упоминалось ранее, преимущества наследования форм заключаются в возможности добавления новых компонентов и кода в объект и наличии связи с оригиналом шаблона в хранилище. Если вы изменяете шаблон, наследуемый объект будет автоматически обновлен. Выполните следующие действия.
Выберите команду File/New Application, и появится пустое приложение. Закройте главную форму, окно которой озаглавлено Forml. Выберите команду File/New, и будет выведено диалоговое окно New Items. Щелкните на вкладке Dialogs, и будет выведена страница диалогов. Выберите стандартный (Standard) диалог с кнопками, выровненными вертикально по правой стороне. Выберите опцию Inherit. Щелкните на кнопке ОК, и Delphi выведет новую диалоговую форму OKRightDlg2. Выберите из меню View/Forms, и будет выведено диалоговое окно View Form. Выберите шаблонную форму OKRightDIg, щелкните на кнопке ОК, и Delphi выведет новую шаблонную форму, озаглавленную Dialog и расположенную точно поверх новой формы.
Теперь приступим к демонстрации. Переместите шаблонную форму в нижнюю часть главного окна Delphi. Вы обратили внимание, что новая форма OKRightDlg2 не открылась? Это связано с тем, что Delphi обновляет свойства Left и Тор одновременно с изменением соответствующих родительских свойств.
Однако в обратном направлении изменения не передаются. Чтобы убедиться в этом, выполните следующие действия. Выберите команду View/Forms, и появится диалоговое окно View Form. Выберите OKRightDlg2 и щелкните на ОК. Переместите OKRightDlg2 в нижнюю часть экрана. Ваш экран должен выглядеть примерно так, как на Рисунок 1.11.
При перемещении диалога-наследника на экране диалогородитель будет оставаться на месте, что иллюстрирует передачу свойств только в одном направлении.
Пример консольного приложения
Лучший способ изучить консольные приложения— создать пресловутое "Hello, world!". Для создания его вручную сделайте следующее.
1. Выберите команду File/New Application.
2. Выберите команду File/Remove From Project, и появится диалоговое окно, Remove From Project, показанное на Рисунок 1.15.
3. В проекте содержится один модуль формы. Выберете его и щелкните на кнопке ОК. Появится диалоговое окно Save changes to Unit1.pas?
4. Щелкните на кнопке No, и форма будет удалена из проекта.
Сохраните проект как EgConsoleHello.
Хотя мы создаем "бесформенное" приложение, оно все еще не является консольным и использует GUI, а значит, сравнимо по размеру с бронтозавром. Выберите команду View/Project Source, и в редакторе появится следующий текст.
program EgConsoleHello;
uses
Forms;
{$R *.RES}
begin
Application.Initialize;
Application.Run;
end;
Этого слишком много, чтобы быть достаточным. Вы видите, что подключен модуль Forms, однако он не используется, поэтому данную строку можно удалить. Строки с Application используются для инициализации OLE-сервера и вывода главной формы. Поскольку мы не используем ни того, ни другого, удалите и эти строки. Последнее действие — объяснить компилятору, что мы хотим создать обычное, простое, незамысловатое консольное приложение. Этого можно достичь с помощью команды $APPTYPE. Код в результате будет выглядеть так.
program EgConsoleHello;
{$APPTYPE CONSOLE}
{$R *.RES}
begin
end;
Ax да! Мы же собирались вывести свое приветствие! Для этого добавьте между begin и end строку
WriteLn ('Hello, world!');
Сохраните, скомпилируйте и запустите проект из командной строки. Надеюсь, вам понравилось? И еще одно замечание — консольные приложения используют стандартные потоки ввода-вывода, а значит, вы можете использовать функции Read, ReadLn, Write и WriteLn.
Multiple Document Interface) дословно означает
Создание интерфейса Написание кода Термин MDI ( Multiple Document Interface) дословно означает многодокументный интерфейс и описывает приложения, способные загрузить и использовать одновременно несколько документов или объектов. Примером такого приложения может служить диспетчер файлов (File Manager).
Обычно MDI-приложения состоят минимум из двух форм — родительской и дочерней. Свойство родительской формы FormStyle установлено равным fsMDIForm. Для дочерней формы установите стиль fsMDIChild.
Родительская форма служит контейнером, содержащим дочерние формы, которые заключены в клиентскую область и могут перемещаться, изменять размеры, минимизироваться или максимизироваться. В вашем приложении могут быть дочерние формы разных типов, например одна — для обработки изображений, а другая — для работы с текстом.
Пример MDIприложения
В этом разделе мы расширим возможности созданной ранее программы просмотра изображений.
Создание интерфейса
Интерфейс MDI-приложения очень похож на интерфейс разработанного ранее SDI-приложения, но каждое изображение выводится в отдельной, а не в главной форме. Выполните следующие действия для создания родительской формы.
1. Выберите команду File/New Application, и появится пустое приложение.
2. Установите следующие свойства.
Свойство Значение
Caption Image Viewer
FormStyle fsMDIForm
Name frmMDIParent ShowHint True
3. Поместите компонент TPanel в форму. Установите следующие его свойства.
Свойство Значение
Align alTop
Caption -
4. Поместите три компонента TSpeedButton в TPanel и назовите их spbtnLoad, spbtnStretch и spbtnCenter. Установите следующие их свойства.
Свойство Значение
spbtnLoad.Hint Load
spbtnLoad.Left 8
spbtnLoad.Top 8
spbtnStretch.AllowAlIUp True
spbtnStretch.Grouplndex 1
spbtnStretch.Hint Stretch
spbtnStretch.Left 48
spbtnStretch.Top 8
spbtnCenter.AllowAlIUp True
spbtnCenter.Grouplndex 2
spbtnCenter.Hint Center
spbtnCenter.Left 80
spbtnCenter.Top 8
Свойства Glyph установите те же, что и для SDI-приложения.
5. Добавьте в форму компонент TOpenDialog и установите следующие его свойства.
Свойство Значение
Filter Bitmaps (*.bmp)]*.bmp
Name opndlgLoad
Options [ofPathMustExist,ofFileMustExist]
Теперь создадим дочернюю форму.
1. Выберите из меню File/New Form, и появится пустая форма.
2. Установите следующие ее свойства.
Свойство Значение
FormStyle fsMDIChild
Name frmMDIChild
Position poDefaultPosOnly
3. Поместите компонент TImage во вновь созданную форму и установите его следующие свойства.
Свойство Значение
Align alClient
Name imgMain
Удалите дочернюю форму из списка автоматически создаваемых форм следующим образом.
1. Выберите команду Project/ Options, и появится диалоговое окно Project Options, показанное на Рисунок 1.14.
2. Выберите frmMDIChild в списке Auto-create forms.
3. Щелкните на кнопке. Форма frmMDIChild при этом будет перенесена в список Available forms.
4. Щелкните на кнопке ОК.
Теперь самое время сохранить проект, выбрав команду File/Save Project As. Сохраните Unit1 как MDIParent, а проект — как EgMDIApp.
Написание кода
Создав интерфейс, перейдем к написанию исходного текста приложения, который будет очень похож на код для SDI-приложения.
Сначала загрузим изображение. Введите следующий код в обработчик события OnClick компонента spbtnLoad.
procedure TfrmMDIParent.spbtnLoadClick(Sender: TObject);
begin
if opndlgLoad.Execute then
with TfrmMDIChild.Create(Application) do
begin
Caption:= opndlgLoad.FileName;
imgMain.Picture.LoadFromFile(opndlgLoad.FileName);
ClientWidth:= imgMain.Picture.Width;
ClientHeight:= imgMain.Picture.Height;
end;
end;
После запуска диалогового окна создается новый экземпляр дочерней формы и загружается файл изображения. После загрузки размеры дочерней формы изменяются так, чтобы можно было видеть все изображение.
Еще пара штрихов— и приложение заработает, как и предусматривалось. Поскольку модуль ссылается на тип TfrmMDIChild, находящийся в модуле MDIChild, после строки implementation следует добавить еще одну строку:
uses MDIChild;
Теперь можно приступить к компиляции и запуску приложения. Однако заметьте, что, когда вы щелкаете на кнопке Close, дочерняя форма не закрывается, а сворачивается в пиктограмму. Чтобы заставить ее закрыться, следует добавить в код обработчика OnClose класса TfrmMDIChild маленькую деталь— изменить свойство Action:
Action:= caFree;
Компоненты TSpeedButton Stretch и Center выполняют те же функции, что и в SDI-приложении, однако их обработчики события OnClick следует изменить следующим образом
if not (ActiveMDIChild = Nil) then
if ActiveMDIChild 15 TfrmMDIChild then
TfrmMDIChild(ActiveMDIChild).imgMain.Stretch:= spbthStretch.Down;
и
if not (ActiveMDIChild = Nil) then
if ActiveMDIChild is TfrmMDIChild then
TfrmMDIChild(ActiveMDIChild).imgMain.Center:= spbthCenter.Down;
Остается последняя проблема — состояния кнопок Stretch и Center одинаковы для всех дочерних форм Для решения этой задачи добавьте в обработчик события OnActivate класса TfrmMDIChild строки.
frmMDIParent.spbtnStretch.Down:= imgMain.Stretch;
frmMDIParent.spbtnCenter.Down:= imgMain.Center;
И, наконец, самый последний из последних штрихов— в модуле MDIChild добавьте после строки implementation строку.
uses MDIParent;
Компилируйте, запускайте и смотрите. MDI-приложение создано!
ПРЕДОСТЕРЕЖЕНИЕ: В этом примере присвоение нового значения свойству Down класса TSpeedButton вызывало событие Оn-click. Будьте осторожны при написании кода обработчика события, который генерирует новое событие путем присвоения значения свойству, ведь при этом можно создать бесконечную рекурсию.
Single Document Interface) дословно означает
Построение интерфейса Написание кода Термин SDI ( Single Document Interface) дословно означает одно-документный интерфейс и описывает приложения, способные загрузить и использовать одновременно только один документ. Программа Notepad, приведенная на Рисунок 1.12, является ярким представителем такого класса программ.
Следует сказать несколько слов о термине документ. Приложения становятся все более объекто-центричными, т.е. они работают с неким центральным объектом, в который могут быть внедрены внешние объекты. В общем случае эти внешние объекты обрабатываются другим специализированным приложением. Примером может служить Wordpad (см. Рисунок 1.5), позволяющий внедрять любые OLE-объекты в свои файлы. Но он остается при этом SDI-приложением, так как может работать только с одним объектом (или документом в широком смысле этого слова) Wordpad. Рисунок 1.12. Программа Notepad как пример SDI-приложения
Способность одновременно работать только с одним объектом не мешает приложению использовать дополнительные формы, например диалоговые окна, панели инструментов и прочее (на Рисунок 1.13 показаны панели инструментов в окне Wordpad). Для реализации этих возможностей в Delphi просто добавьте форму в ваше приложение и установите ее свойство FormStyle равным fsSizeToolWin или fsToolWindow.
Еще одним примером может служить сама Delphi — огромное количество панелей инструментов, меню, разнообразных библиотек компонентов, взаимодействующих между собой форм... Но в целом она остается SDI-приложением, так как может загрузить и использовать одновременно только один объект.
Рисунок 1.13. Программа Wordpad — SDI-приложение со многими формами
Пример SDIприложения
Для демонстрации SDI создадим простую программу просмотра изображения.
.
Построение интерфейса
Обычно первым шагом построения программы является создание интерфейса. Не будем отступать от традиций, и выполним следующие действия.
1. Выберите команду File/New Application, и появится пустое приложение.
Совет: Delphi по умолчанию создает именно SDI-приложение. Однако хранилище объектов предоставляет возможность назначить новый шаблон проекта по умолчанию.
2. Установите следующие свойства форм.
Свойство Значение
Caption Image Viewer
Name frmMain
ShowHint True
3. Поместите компонент TPanel в форму. Установите следующие его свойства.
Свойство Значение
Align alTop
Caption -
4. Поместите три компонента TSpeedButton в TPanel и назовите их spbtnLoad, spbtnStretch и spbtnCenter. Установите следующие их свойства.
Свойство Значение
spbtnLoad.Hint Load
spbtnLoad.Left 8
spbtnLoad.Top 8
spbtnStretch.AllowAlIUp True
spbtnStretch.Grouplndex 1
spbtnStretch.Hint Stretch
spbtnStretch.Left 48
spbtnStretch.Top 8
spbtnCenter.AllowAlIUp True
spbtnCenter.Grouplndex 2
spbtnCenter.Hint Center
spbtnCenter.Left 80
spbtnCenter.Top 8
5. Поместите еще одну TPanel в форму и установите следующие ее свойства.
Свойство Значение
Align alClient
Caption -
6. Поместите компонент ТImage во вновь созданную ТPanel и установите следующие его свойства.
Свойство Значение
Align alClient
Name imgMain
7. Добавьте в форму TOpenDialog со следующими свойствами.
Свойство Значение
Filter Bitmaps (*.bmp)|*.bmp
Name opndlgLoad
Options [ofPathMustExist,ofFileMustExist]
Delphi предоставляет вам множество значков для компонента TSpeedButton; они находятся в каталоге IMAGES\BUTTONS. Для нас вполне подойдут следующие установки свойств Glyph.
Свойство Значение
spbtnLoad.Glyph FLDROPEN.BMP
spbtnStretch.Glyph FONTSIZE.BMP
spbtnCenter.Glyph PICTURE.BMP
Теперь самое время сохранить проект, выбрав в меню команду File/Save Project As. Сохраните Unit1 как Main, а проект — как EgSDIApp.
Написание кода
Теперь, после создания интерфейса, перейдем к написанию исходного текста вашего приложения. Сначала загрузите изображение следующим образом.
1. Дважды щелкните на компоненте spbtnLoad, и Delphi выведет окно редактора и автоматически создаст обработчик события OnClick.
2. Введите код.
if opndlgLoad.Execute then
imgMain.Picture.LoadFromFile(opndlgLoad.FileName);
Метод opndlgLoad.Execute вызывает стандартное диалоговое окно открытия файла. Если вы выбрали файл и щелкнули на ОК, метод возвращает True и загружает в свойство FileName полный путь к имени файла. При щелчке на Cancel или нажатии клавиши <Esc> метод вернет False.
Компонент TImage предоставляет свойство Picture, которое является экземпляром класса TPicture. Этот класс обеспечивает работу с растровыми изображениями, пиктограммами и метафайлами. Один из его методов, LoadFromFile, служит для загрузки изображения по имени файла.
Выберите команду Run/Run для компиляции и запуска приложения и попытайтесь открыть картинку.
Теперь добавьте возможность растягивания изображения.
1. Дважды щелкните на компоненте spbtnStretch, и Delphi выведет окно редактора и автоматически создаст обработчик события OnClick.
2. Введите код.
imgMain.Stretch:= spbtnStretch.Down;
Компонент TSpeedButton имеет свойство Down, которое равно True при нажатой кнопке. Свойство Stretch класса TImage позволяет растянуть картинку.
Для выравнивания картинки по центру воспользуйтесь приведенной выше инструкцией (только используйте компонент spbtnCenter) и введите следующий код:
imgMain.Center:= spbtnCenter.Down;
Процедуры обработки вариантных массивов
В табл. 1.9 перечислены стандартные процедуры и функции обработки вариантных массивов, определенные в модуле System.
Просмотр значений переменных
При пошаговом прохождении программы в отладчике вы, несомненно, захотите узнать, что содержится в различных переменных. Для этого можете использовать окно просмотра переменных Watch List, которое предоставляет возможность пассивно просматривать содержимое одной или нескольких переменных, или диалоговое окно Evaluate/Modify, позволяющее работать только с одной переменной (в нем можно не только просмотреть, но и изменить ее содержимое).
Для просмотра значения переменной используйте команду Run/AddWatch или установите указатель мыши на переменную в окне редактирования, щелкните правой кнопкой мыши и выберите из контекстного меню команду Add Watch at Cursor. После этого появится диалоговое окно Watch Properties, показанное на Рисунок 2.12. Введите имя переменной в поле Expression (если оно не появилось там автоматически). Обратите внимание на то, что вы можете просматривать значения не только переменных, но и выражений типа х*(y+z). Единственное ограничение— выражение не может содержать вызовов функций, поскольку это может вызвать побочный эффект, связанный с незапланированным вызовом функции, описанный выше, в подразделе ''Использование директивы Assert". Допускается также просмотр значений записей, массивов и других структурированных элементов.
Поле Repeat Count используется в том случае, если у вас есть большой массив, и вы хотите просмотреть его часть. Предположим, что вам надо знать значения элементов 826-833 следующего массива
var
BigArray: array[1..1000] of Integer;
Вы не можете просмотреть массив BigArray, так как 1 000 элементов просто не поместятся в окне (да и пролистать ненужные вам 825 элементов — работенка немалая!) Вместо этого вы просите показать вам значение BigArray [826] и устанавливаете параметр Repeat Count равным 8. При этом вам будут показаны значения восьми элементов массива— от 826 по 833.
Использование поля Digits позволяет определить количество значащих цифр при выводе числа с плавающей точкой.
Отключенная опция Enabled предотвращает вывод значения переменной, однако, среда будет хранить все параметры, заданные для ее просмотра. Так, вы можете временно убрать с экрана информацию о переменной, которая в настоящий момент вам не нужна, и быстро восстановить ее на экране при необходимости без повторного ввода характеристик просмотра.
В диалоговом окне имеется также набор переключателей для выбора способа представления переменной. Значение Default позволяет среде разобраться с типом переменной самостоятельно. Как правило, такое решение оптимально, однако в любой момент вы можете представить переменную как переменную того типа, который вас интересует. Опция Memory dump представляет информацию как набор байтов, что бывает полезно, когда необходимо увидеть внутреннее представление информации в переменной.
На рис 2.13 отображены значения нескольких переменных в окне Watch List. Кроме того, в некоторых случаях отладчик выводит информацию о причинах, по которым содержимое переменной недоступно.
Смысл приведенных сообщений поясняется ниже Variable 'X' inaccessible here due to optimization(Переменная 'X' недоступна из-за оптимизации). В этой точке значение переменной просмотреть невозможно (иногда это можно сделать в другом месте программы), так как для нее не выделена память из-за оптимизации программы компилятором. Symbol was eliminated by linker (Переменная удалена компоновщиком). Переменная удалена из кода программы компоновщиком, так как на нее нет ни одной ссылки в тексте программы. Отладчик также выводит сообщение об ошибке, если имя переменной написано неправильно, например вы запросили значение Foo [5], в то время как переменная Foo массивом не является.
Совет: Когда вы пытаетесь просмотреть свойства объекта, выводимые значения могут оказаться бессмысленными. Многие свойства объектов, выглядящие как переменные, на самом деле являются вызовами функций. Отладчик не вызывает функции для определения значений, а потому корректные значения при таком просмотре вы получить не можете. Выход — в объявлении новых переменных, присвоении им значений свойств и просмотре не свойств, а новых переменных. Неприятности могут начаться из-за слишком умного оптимизатора, который сообразит, что, раз в программе значение переменной больше не используется, ее можно выбросить без ущерба для программы (увы, но не для отладки программы!) Если это происходит, используйте глобальные переменные, т.е. переменные, объявленные вне функции или процедуры. Отладчик всегда корректно отобразит значения глобальных переменных.
Разделяемые обработчики событий
Как вы уже знаете, каждый класс способен генерировать свои собственные события. Каждое из них имеет определенный тип, как, например, TNotifyEvent у OnClick и TCloseEvent у OnClose. Delphi позволяет написать один обработчик события и назначить его нескольким событиям одновременно.
Представьте себе объект TEdit, генерирующий события OnKeyDown и OnKeyUp. Поскольку оба события — одного типа, можете написать одну процедуру и назначить ее обоим событиям. Процедура будет вызываться дважды при каждом нажатии клавиши (при нажатии и отпускании). Или, например, вы можете создать один обработчик для событий OnCreate и OnClick.
Еще одно общее назначение разделяемых обработчиков — обработка событий от двух различных управляющих элементов, которые могут и не быть экземплярами одного класса.
Вот как создать разделяемый между классами TButton и TEdit обработчик OnClick. Выберите из меню File/New Application для создания приложения. Поместите TButton в форму и введите в обработчик OnClick следующий код. procedure TFormI.ButtonlClick (Sender: TObject);
begin
Editl.SetFocus;
Editl.SelectAll;
end; Поместите TEdit в форму. В Object Inspector выберите в списке для события OnClick обработчик ButtonClick. Теперь после щелчка на кнопке и на объекте TEdit будут выполняться одни и те же действия, фокус ввода будет передаваться управляющему элементу TEdit, и весь текст в нем будет выделяться.
Параметр Sender
Поскольку множество объектов может разделять один обработчик событий, необходимо уметь выяснять, какой именно обработчик его сгенерировал. Для этого предназначен параметр Sender, передаваемый в каждый обработчик, который указывает на объект, сгенерировавший событие. Часто этот параметр используется для различных действий обработчика в зависимости от того, кто именно породил событие.
Создание одноэкземплярного приложения
Если в Windows несколько раз щелкнуть на пиктограмме приложения, по умолчанию запустится сразу несколько его копий. Чтобы избежать этого, т.е. не дать запуститься второй копии приложения, необходимо выполнить поиск по заголовкам окон.
Поиск по заголовкам окон
При создании экземпляра окна Windows требует зарегистрировать имя класса окна (window class name). Delphi использует класс формы в качестве имени класса окна, например, когда Delphi создает экземпляр Form1 класса TForm1, TForm1 используется в качестве имени для регистрации окна Form1. Каждая форма имеет свойство Caption, известное как заголовок окна (window title). Эти два параметра позволяют искать окно с помощью функции Windows API FindWindow, возвращающей дескриптор найденного окна.
Эту функцию нельзя вызывать из класса TForm1, так как к тому времени окно уже будет создано, и вы окажетесь в глупом положении, найдя сами себя. Вот код, который должен находиться в файле проекта.
begin
Application.Initialize;
if FindWindow('TFormi','Formi') о 0 then Application.Terminate;
Application.Create Form(TForm1,Form1);
Application.Run;
end.
Поскольку вы используете функцию Windows API, проследите, чтобы был подключен модуль Windows.
Если вы запускаете это приложение из Delphi, учтите, что Form Designer уже создал такое окно, и вы всегда сможете его найти. Это приложение следует запускать отдельно, закрыв Delphi.
Изменив свойство Caption или Name, вы рискуете не найти своего окна и придется повозиться с кодом программы, чтобы отследить эти изменения. Может возникнуть ситуация, когда простое совпадение приведет к тому, что окно будет найдено в совсем другом приложении, которое будет опознано как свое.
Активизирование существующей копии
Все-таки, сказать пользователю "Ты уже запустил одну копию, теперь иди и ищи ее!"— как-то негуманно... Более профессиональным решением будет активизировать существующую копию с помощью другой функции Windows API — SetForegroundWindow. Измените проект следующим образом.
var
hwndPrev: HWND;
begin
Application.Initialize;
hwndPrev:= FindWindow('TFormi','Formi');
if hwndPrev < 0 then
begin
SetForegroundWindow(hwndPrev);
Application.Terminate;
end;
Application.CreateForm(TFormi,Formi);
Application.Run;
end.
Размещение компонентов
Размещать компоненты на форме очень просто. Требуется только щелкнуть на нужной вкладке палитры компонентов, затем на кнопке с пиктограммой соответствующего компонента и после этого щелкнуть в окне формы. Все! Или, если вам так больше нравится, можно щелкнуть на компоненте, а затем нарисовать прямоугольник с помощью мыши на форме — компонент появится внутри этого прямоугольника. Если размеры компонента поддаются изменению, при появлении на форме он заполнит собой прямоугольник.
Если вы забыли, на какой странице расположен конкретный компонент, выберите пункт Component List (Компоненты) из меню View (Вид), и на экране появится список компонентов в алфавитном порядке.
Если щелкнуть на компоненте в палитре компонентов, его кнопка окажется нажатой. Если щелкнуть на другом компоненте, первая кнопка вернется в исходное состояние — только один компонент может быть выбран в один момент времени. Для того чтобы все кнопки оказались в исходном состоянии и было восстановлено нормальное использование мыши, следует щелкнуть на кнопке со стрелкой выбора, которая появляется с левой стороны каждой страницы палитры (Рисунок 4.1). Рисунок 4.1. Для того чтобы после добавления компонентов восстановить нормальное функционирование мыши, следует щелкнуть на кнопке со стрелкой выбора Выберите страницу Standard палитры компонентов. Поместите указатель мыши на компонент с изображением кнопки ОК. После того как мышь побудет в недвижимом состоянии секунду или две, появится поле помощи, идентифицирующее этот компонент как Button (см. Рисунок 4.1). Щелкните на кнопке, затем щелкните на вашей форме. Появится кнопка среднего размера, озаглавленная Button 1. Щелкните на компоненте Button опять, но на этот раз, удерживая ле-вую кнопку мыши, нарисуйте прямоугольник большого размера прямо на форме. Текст Button2 заполнит прямоугольник. Обратите внимание, что кнопка имеет небольшие квадратные маркеры (угловые и боковые), позволяющие изменять размер. Используйте их, чтобы с помощью мыши изменить размер кнопки. Теперь щелкните на кнопке Button 1 и перетащите ее в новое место.
Вы заметите, что при перемещении и изменении размера компоненты выравниваются по точкам координатной сетки формы. Как правило, это хорошо — такая возможность помогает поддерживать порядок в формах. Если вы захотите отменить эту возможность или изменить плотность точек координатной сетки, выберите пункт Options из меню Tools. Первая страница параметров предназначена для настройки пользователем параметров среды. На этой странице имеется группа Form designer (Конструктор форм), флажки опций Display grid (Отображение сетки) и Snap to grid (Привязка к сетке) которой определяют, видна ли координатная сетка и активна ли она. Можно также изменить значения параметров Grid Size X (Шаг по оси X) и Grid Size Y (Шаг по оси Y), что приведет к изменению шага координатной сетки по горизонтали и вертикали, соответственно.
Совет: Для лучшего управления размещением и размерами своих компонентов попробуйте следующее. Установите значение шага координатной сетки равным 4 вместо 8, отключите изображение координатной сетки, но оставьте включенным параметр Snap To grid.
Редактор библиотек типов
Редактор библиотек типов Delphi используется для просмотра и редактирования библиотек типов. Основой интерфейса редактора является панель Object List (Рисунок 3.1), с помощью которой пользователь может изменять, добавлять и удалять элементы библиотеки типов. Элементами библиотек типов являются составные классы, свойства и методы интерфейсов и перечисления. Панель Object List представляет элементы в виде дерева объектов. В зависимости от типа элемента, выбранного в панели Object List, в правой части редактора библиотек типов появляются различные вкладки. Возможно, это будут вкладки Attributes, Members и Uses.
Для редактирования библиотеки типов текущего проекта выполните команду View/Type Library. Чтобы просмотреть библиотеку типов, не являющуюся частью проекта, выберите пункт меню File/Open. После этого в списка File of type выберите строку Type Library (*.tlb;*.dll;*.ocx;*.exe;*.olb), чтобы вывести все файлы, которые могут содержать информацию о типах.
Теперь более детально рассмотрим каждый элемент библиотеки типов. Начнем с информации о библиотеке.
Regestry_ActiveX
Регистрация и установка элемента управления ActiveX
Для регистрации элемента управления ActiveX нужно просто воспользоваться какой-либо утилитой или приложением, которое вызывает экспортируемую элементом ActiveX функцию DllRegiaterServer. Эта функция знает, как внести в реестр Windows записи об элементах ActiveX, данные о фабриках объектов которых зарегистрированы в глобальном объекте сервера СОМ среды программирования Delphi. Нами рассмотрена только одна фабрика объектов (TActiveXControlFactory), но для каждой страницы свойств существует своя фабрика объектов.
Чтобы зарегистрировать элемент управления ActiveX, воспользуйтесь командой Run/Register ActiveX Server.
Чтобы проверить созданный элемент ActiveX в действии, установите его в среде Delphi. Для этого выберите команду Component/lnstall ActiveX control, и на экране появится диалоговое окно Import ActiveX (Рисунок 3.10).
Если в списке зарегистрированных элементов управления нет библиотеки PieXControlLib, то следует щелкнуть на кнопке New и добавить в список файл PieXControl.dll. После щелчка на кнопке OK Delphi автоматически вызовет функцию DllRegisterServer, и элемент управления появится в списке зарегистрированных элементов управления. Выберите созданный элемент в списке и щелкните на кнопке Add to package. Здесь есть две возможности: создать новый модуль-оболочку для элемента ActiveX и вставить созданный элемент в уже существующий модуль. Я бы посоветовал вставить созданный элемент в модуль PieLib. dpk, после чего нужно только перекомпилировать модуль, так как он уже установлен.
Рисунок 3.10. Диалоговое окно Import ActiveX
После выполнения описанных выше действии на вкладке ActiveX в палитре компонентов Delphi появится элемент управления PieX. Вот и все о создании, регистрации и установке элементов управления ActiveX в среде программирования Delphi 4. В других средах программирования регистрация и установка элементов ActiveX реализованы иначе, поэтому обратитесь к руководству по продукту для получения подробных инструкции.
ShowMessage
Кроме вывода информации в форму, можно воспользоваться модальным диалоговым окном. Принципиальное отличие этого метода, в первую очередь, состоит в том, что модальное диалоговое окно останавливает выполнение программы, пока вы его не закроете. Таким образом, у вас имеется достаточно времени, чтобы прочесть и осмыслить полученную информацию.
Процедура ShowMessage (из модуля Dialogs) идеально подходит для этой цели Она позволяет вывести строку любой длины в простом модальном диалоговом окне. Вам только следует создать строку для вывода и передать ее процедуре (можно также использовать MessageDIg, но в нем слишком много шашечек и бантиков, которые требуют немалых усилий для достижения того же эффекта).
ShowMessage получает в качестве параметра одну строку, для создания которой я предпочитаю использовать функцию Format, она идеально подходит для этого, будучи одновременно простым и мощным инструментом в умелых руках.
Рассмотрим простой пример. Используем этот метод для вывода информации, получаемой от уже использовавшейся функции GlobalMemoryStatus.
Создадим новое приложение и поместим TButton в основную форму. Обработчик события OnClick будет выглядеть следующим образом.
procedure TFormI.ButtonlClick(Sender: TObject);
var MemStat: TMemoryStatus;
begin
MemStat.dwLength:= SizeOf(TMemoryStatus);
GlobalMemoryStatus(MemStat);
with MemStat do ShowMessage(Format('Memory load: %d%%'#13 +
'Total physical: %d'#13+'Available physical: %d'#13 +
'Total page file: %d'#13 + 'Available page file: %d'ftl3 +
'Total virtual: %d'#13 + 'Available virtual: %d',
[dwMemoryLoad, dwTotalPhys, dwAvailPhys, dwTotalPageFile,
dwAvailPageFile, dwTotalVirtual, dwAvailVirtual]));
end;
Заметьте, что я внес в строку несколько символов #13 (ASCII-символ возврата каретки). Это позволяет разбить строку при выводе на несколько строк, что существенно облегчает чтение информации. На рис 2.23 показано, что получится после запуска программы и щелчка на кнопке.
Судя по результатам Memory load и Available physical, представленным на рисунке, мне стоит всерьез подумать о наращивании памяти своего компьютера.
Рис 2.23 Использование функции ShowMessage для вывода отладочной информации.
Символьные типы
Смысл символьных данных очевиден, когда они выводятся на экран или принтер. Тем не менее, определение символьного типа может зависеть от того, что подразумевать под словом символ. Обычно символьные типы данных задают схему взаимодействия между участками памяти разного объема и некоторым стандартным методом кодирования/декодирования для обмена символьной информацией. В классическом языке Pascal не задано никакой схемы, и в конкретных реализациях применялось то, что на том же компьютере мог использовать каждый.
В реализациях языка Pascal для первых микропроцессоров была применена 7-битовая схема, названная ASCII (American Standard Code for Information Interchange — Американский стандартный код для обмена информацией). Эта схема и поныне широко распространена, но информация хранится, как правило, в 8-битовых участках памяти. Дополнительный бит удваивает число возможных представлений символов, но реализации расширенного набора символов ASCII часто бывают далеки от стандарта. В данной версии Delphi определен набор 8-битовых символов, известный как расширенный (extended) ANSI (American National Standards Institute — Американский национальный институт стандартов). Как бы то ни было, символьную схему приходится воспринимать так, как ее воспринимает операционная система. Для оконных операционных систем фирмы Microsoft это схема ANSI, включающая ограниченное число предназначенных для вывода международных знаков. В стремлении же применить более обширный набор международных знаков весь компьютерный мир переходит к 16-битовой схеме, именуемой UNICODE, в которой первые 256 знаков совпадают с символами, определенными в схеме ANSI.
Для совместимости со всеми этими представлениями в Object Pascal определены два физических символьных типа и один логический.
Физические типы перечислены ниже.
AnsiChar | Однобайтовые символы, упорядоченные в соответствии с расширенным набором символов ANSI |
WideChar | Символы объемом в слово, упорядоченные в соответствии с международным набором символов UNICODE. Первые 256 символов совпадают с символами ANSI |
Логический символьный тип именуется char. В классическом языке Pascal char— единственный символьный тип. В Delphi char всегда соответствует физическому типу данных AnsiChar. У американских программистов ассоциация символа с однобайтовой ячейкой памяти укоренилась за долгие годы настолько, что им зачастую просто не приходит в голову, что можно использовать другие схемы кодирования. Однако дискуссии по интернационализации программ в Internet и World Wide Web могут существенно изменить их отношение к проблеме объема символьных данных. Применяя логический тип char, следует делать реализации для других микропроцессоров и операционных систем, в которых char может определяться как WideChar. При написании программ, которые могут обрабатывать строки любого размера, для указания этого размера рекомендуется применять функцию SizeOf, не задавая ее жестко постоянной. Функция Ord (С), где С — любая переменная символьного типа, возвращает целое значение, которым символ С представлен в памяти.
Chr (X) | Преобразует целую переменную в переменную типа char с тем же порядковым номером. В Delphi это эквивалентно заданию типа Char (X) |
UpCase | Преобразует строчную букву в прописную |
Совет: Процессор не различает типы char, определенные в C/C++ и Delphi. Однако функционально каждый из этих языков трактует данный тип совершенно по-разному. В C/C++ это целый тип, переменной которого можно присваивать целые значения. Переменной int можно присвоить символьное значение, а переменной char — целое. В Delphi символьные типы жестко отделены от численных. Для присвоения численному значению символьного здесь необходимо воспользоваться функцией Ord. В языке Basic один символ представляется так же, как и строка символов. Функция Chr из Delphi эквивалентна функции CHR$ из Basic. Функция Ord из Delphi, возвращающая код ANSI символьной переменной, подобна функции A3 С из Basic, аргумент которой представляет односимвольную строку.
События TApplication
Обработка событий TApplication OnActivate и OnDeactivate OnException OnHint OnIdle
Поскольку при создании TApplication недоступен,
Обработка событий TApplication
Поскольку при создании TApplication недоступен, установка его обработчика события затруднена из-за невозможности использования инспектора объектов (Object Inspector).
Сначала опишем обработчик события. Поскольку событие распознается и запускается объектом, обработчик должен быть методом объекта. Он также должен соответствовать соглашению о вызовах события, которое обычно описано в системе справки. Например, из файлов справки можно узнать, что событие OnActivate типа TNotifyEvent является наиболее общим типом. Его описание его выглядит так:
TNotifyEvent = procedure (Sender: TObject) of Object;
Это описание говорит о том, что ваш обработчик должен получать параметр TObject, который позволяет определить, какой именно объект распознал и отослал событие.
Создадим новое приложение и модифицируем описание TForm1.
type
TForm1 = class(TForm)
private
{Закрытые объявления.}
procedure OnActivateHandler(Sender: TObject);
public
{Открытые объявления.}
end;
Описание обработчика как protected не несет особой нагрузки и принято по умолчанию. Важно лишь, чтобы он был методом класса.
Теперь, когда мы описали обработчик, определим его. Добавьте следующий код в раздел implementation вашего модуля.
procedure TFormI.OnActivateHandler(Sender: TObject);
begin
{Код вашего обработчика.}
end;
Совет: Определение процедуры или функции не требует перечисления списка параметров, так как он был дан при описании. Вы можете его повторить для повышения удобочитаемости и ясности программы.
Наконец, назначим обработчик событию. Обычно это выполняется в событии OnCreate главной формы. Измените обработчик события OnCreate класса Tform1 следующим образом.
procedure TFormI.FormCreate(Sender: TObject);
begin
Application.OnActivate:= OnActivateHandler;
end;
OnActivate и OnDeactivate
Эти события оповещают программу об изменении свойства Active.
OnException
Событие вызывается при необработанной исключительной ситуации.
OnHint
Событие генерируется при перемещении указателя мыши над объектом— потомком TControl, если его свойство Hint равно значению, которое отличается от пустой строки.
Onldle
Событие генерируется, когда приложение ожидает ввода и не занято обработкой события. Обычно оно используется для выполнения фоновых задач наподобие загрузки базы данных или обработки изображения.
Обработчик получает логический параметр Done, по умолчанию равный True. Если вы оставляете его равным True, обработчик не запустится до тех пор, пока не будет получено и обработано очередное сообщение. Если вы установили Done равным False, обработчик будет запускаться во время ожидания сообщения.
Поскольку во время работы обработчика приложение не отрабатывает сообщения, делайте его более коротким либо не забывайте запускать из него процедуру ProcessMessages.
Ниже приведен код использования обработчика для вывода текущего времени в объекте TPanel.
procedure TFormI.OnIdleHandler(Sender: TObject; var Done: Boolean);
begin
pnlTime.Caption:= TimeToStr(Now);
end;
События TForm
Класс ТForm добавляет несколько событий к родительскому классу TWinControl. Эти события позволяют изменять поведение формы путем выполнения загрузки и сохранения информации о состоянии формы или распределения и освобождения дополнительных ресурсов.
Когда форма создается и отображается, происходит пять следующих событий.
1. OnCreate запускается при создании формы и позволяет распределять ресурсы и инициализировать форму.
2. OnShow происходит непосредственно перед выводом формы на экран. К этому времени все элементы управления и компоненты созданы и инициализированы.
Совет: Хотя к тому моменту, когда происходит событие OnShow, форма еще не видна, свойство Visible установлено равным True.
3. OnResize генерируется при изменении размера формы во время выполнения приложения. Обычно здесь помещается код для изменения размера и положения на экране элементов управления, не поддерживающих свойство Align. Событие OnResize также однократно генерируется при создании формы, когда Delphi устанавливает начальные размеры формы.
Совет: OnResize вызывается неоднократно в процессе изменения размеров формы.
4. OnActivate происходит при получении формой фокуса ввода. OnActivate вызывается только при переходе фокуса ввода от одной формы к другой в пределах одного приложения. При переключении между приложениями Delphi генерирует событие OnActivate глобального объекта Application.
5. OnPaint запускается, когда необходимо перерисовать форму. Это может происходить, когда форма только что стала видимой, при частичном удалении перекрывающих ее элементов или увеличении размеров. Событие полезно, если вы перерисовываете какую-то часть формы самостоятельно.
Совет: Событие OnCreate происходит один раз за все время существования формы, прочие же события могут вызываться неоднократно.
При закрытии и уничтожении формы также генерируется пять следующих событии.
1. OnCloseQuery генерируется в ответ на действия, закрывающие форму. Обработчик получает логическую переменную CanClose, определяющую, может ли форма быть закрыта. По умолчанию она имеет значение True, но если вы в обработчике установите False, форма останется открытой. Обычно это используется для сохранения не сохраненных файлов или для подтверждения закрытия формы. Вот пример такого кода.
procedure TFormI.FormCloseQuery(Sender: TObject;
var CanClose: Boolean);
begin
CanClose:= MessageDIg('Close form?', mtConfirmation,
[mbYes,mbNo], 0) = mrYes;
end;
2. OnClose генерируется непосредственно перед закрытием формы. Обычно оно используется для изменения стандартного поведения формы при закрытии. Для этого Delphi передает в обработчик события переменную Action, которая может принимать одно из четырех значений: caHide, caMinimize, caNone или caFree. По умолчанию для не MDI-форм используется caHide, скрывающее форму. Для дочерних MDI-форм значение по умолчанию, сворачивающее форму, равно caMinimize. Если Action установлено равным caNone, закрытия не происходит. caFree заставляет Delphi закрыть форму и освободить всю связанную с ней память. Если после этого сослаться на объект формы, произойдет исключительная ситуация.
Совет: OnClose вызывается только при закрытии формы с помощью щелчка на кнопке закрытия или вызова функции Close. Если вы закрываете главную форму приложения, все другие открытые формы закрываются без вызова события OnClose. Событие OnCloseQuery вызывается всегда, независимо от способа закрытия формы.
3. OnDeActivate происходит при потере формой фокуса ввода. Запуск происходит по тем же правилам, что и запуск события OnActivate.
4. OnHide запускается непосредственно перед тем, как форма станет невидимой.
Совет: Хотя при вызове OnHide форма еще видна, ее свойство Visible установлено равным False.
5. OnDestroy генерируется непосредственно перед уничтожением формы. Обычно оно используется для освобождения ресурсов, выделенных в OnCreate.
Совет: Событие OnDestroy вызывается только один раз за все время существования формы, прочие события могут вызываться неоднократно.
События TScreen
OnActiveControlChange OnActiveFormChange
Составные классы (CoClass) в библиотеках типов
Вкладка Attributes в описании классов составных объектов
Вкладка Members в описании составного класса
Библиотеки типов — это составные документы OLE, в которых содержится информация об объектах СОМ, элементах управления ActiveX и объектах автоматизации. Информация о типах включает перечисления, свойства и методы интерфейсов.
Библиотека типов предназначена для предоставления другим приложениям и средам программирования информации о составных объектах, которые в ней содержатся. В процессе разработки элементов управления ActiveX и объектов автоматизации Delphi сохраняет информацию о типах в файле с расширением TLB, который в качестве ресурса компонуется в модуль DLL или ЕХЕ.
В следующих разделах будут коротко описаны возможности редактора библиотек типов Delphi и типы, которые создаются для элементов управления ActiveX, форм ActiveForm, объектов автоматизации и т.п.
Составные классы (CoClass) в библиотеках типов
Составной класс в библиотеке типов (CoClass) представляет весь элемент управления ActiveX, объект автоматизации или специальный объект СОМ. Составной класс включает интерфейсы и диспинтерфейсы, которые предоставляются клиентскому приложению. В следующих двух разделах рассматривается назначение вкладок Attributes и Members редактора библиотек типов в описаниях классов составных объектов.
Вкладка Attributes в описании классов составных объектов
В табл. 3.8 перечислены все атрибуты, а в табл. 3.9 — флаги, которые используются в описаниях составных классов.
Создание форм
Автоматическое создание форм Динамическое создание форм
Создание форм
В MDI-приложении, как правило, требуется выводить несколько экземпляров классов формы. Поскольку каждая форма представляет собой объект, она должна быть создана перед использованием и освобождена, когда в ней больше не нуждаются. Delphi может делать это автоматически, а может предоставить эту работу вам
.
Автоматическое создание форм
По умолчанию при запуске приложения Delphi автоматически создает по одному экземпляру каждого класса форм в проекте и освобождает их при завершении программы. Автоматическое создание обрабатывается генерируемым Delphi кодом в трех местах.
Первое — раздел интерфейса в файле модуля формы.
type
TForm1 = class (TForm)
private
{Закрытые объявления.}
public
{Открытые объявления.}
end;
В данном фрагменте кода объявляется класс TForm1.
Вторым является место, в котором описывается переменная класса.
var Form1: TForm1;
Здесь описана переменная Form1, указывающая на экземпляр класса TForm1 и доступная из любого модуля. Обычно она используется во время работы программы для управления формой.
Третье место находится в исходном тексте проекта, доступ к которому можно получить с помощью меню View/ Project Source. Этот код выглядит как:
Application.CreateForm(TForm1, Form1);
Процесс удаления форм обрабатывается с помощью концепции владельцев объектов: когда объект уничтожается, автоматически уничтожаются все объекты, которыми он владеет. Созданная описанным образом форма принадлежит объекту Application и уничтожается при закрытии приложения.
Динамическое создание форм
Хотя автоматическое создание форм полезно при разработке SDI-приложений, при создании MDI-приложении оно, как правило, неприемлемо.
Для создания нового экземпляра формы используйте конструктор Create класса формы. Приведенный ниже код создает новый экземпляр TForm1 во время работы программы и устанавливает его свойство Caption равным 'New Form'.
Form1:= TForm1.Create(Application);
Form1.Caption:= 'New Form';
Конструктор Create получает от вас в качестве параметра потомка TComponent, который и будет владельцем вашей формы. Обычно в качестве владельца выступает Application, чтобы все формы были автоматически закрыты по окончании работы приложения. Вы можете также передать параметр Nil, создав форму без владельца (или владеющую собой — как вам больше нравится), но тогда закрывать и уничтожать ее придется вам. В случае возникновения необрабатываемой ошибки такая форма останется в памяти, что не говорит о высоком профессионализме программиста...
В приведенном ниже коде Form1 указывает только на последнюю созданную форму. Если вам это не нравится, воспользуйтесь приведенным ниже кодом — возможно, он более точно отвечает вашим запросам:
with TFormI.Create(Application) do
Caption:= 'New Form';
Совет: При разработке MDI-приложения метод Show не нужен, так как Delphi автоматически показывает все вновь созданные дочерние MDI-формы. В случае SDI-приложения вы обязаны использовать метод Show.
Даже при динамическом создании форм Delphi попытается навязать вам свои услуги по созданию экземпляра каждой формы. Чтобы отказаться от них, воспользуйтесь диалоговым окном Project Options, изображенным на Рисунок 1.14, и удалите классы форм из списка Auto-create forms.
Если вы захотите получить доступ к отдельному дочернему экземпляру класса, используйте свойство MDIChildren, описываемое в следующем разделе.
Создание надежного приложения
Лучший путь исключить ошибки в программе — защититься от них еще при написании кода. Надежное приложение — приложение, создаваемое с возможностью легко и просто отлаживать его. Вот основные советы, которые помогут вам уменьшить количество ошибок при разработке программ. Ваше приложение должно быть хорошо организовано. Разделите программу на модули, каждый из которых выполняет определенные задачи. Например, если код, создающий отчет, разнесен по десяти модулям, время отладки такого кода увеличится даже более чем в десять раз (хотя бы за счет поиска нужной строки в десяти модулях). Конечно же, вы можете вызывать подпрограммы из других модулей, но они должны быть созданы для выполнения четко поставленной задачи. Глупо размещать одну половину выполняемой операции в процедуре в одном модуле, а вторую половину— в другой процедуре (тем более— в другом модуле). Пусть это примитивный совет, но он является одним из самых действенных! Порядок — прежде всего! Порядок в мыслях и в программе! Защититесь от дурака. Если ваша процедура не может переварить некорректные данные и вызвать тем самым крах всей системы, проверьте целостность входных данных, прежде чем работать с ними. Однако помните: если системой сможет воспользоваться любой дурак, значит, только дурак и будет ею пользоваться. Не увлекайтесь чрезмерной защитой, которая неумолимо будет отбирать время и ресурсы, необходимые для выполнения более важных задач. Используйте отладочный вариант вашей программы. В отладочной версии программы содержится дополнительный код, цель которого — отследить выполнение программы, убедиться в корректности ее работы и упростить отладку вашего приложения. Именно об этом и рассказывается в следующем подразделе.
Stack Overflow
Переполнение стека (stack overflow) — ошибка, появляющаяся в 32-битовом приложении гораздо реже, чем в 16 битовом, так как размер стека в этом случае существенно больше. Практически есть только один путь получить эту ошибку в Delphi 4 — попасть в бесконечную рекурсию. Например, приведенная ниже функция неминуемо должна вызвать переполнение стека.
function BlowTheStack(I: Integer); Integer;
var J: Integer;
begin
J:= 2;
Result:= BlowTheStack(I*J);
end;
Каждый раз при рекурсивном вызове в стеке резервируется место для локальной переменной J и адреса возврата. Поскольку условия возврата из рекурсии нет, переполнение стека неминуемо.
Конечно же, бесконечная рекурсия — не единственная причина возникновения ошибки такого рода, но это первое, что стоит отследить при переполнении стека.
Страницы свойств в среде DAX
Другой частью среды DAX являются страницы свойств, которые используются в различных средах программирования для изменения значений свойств элементов управления на этапе разработки. Страницы свойств часто оказываются устаревшими, так как среды программирования обладают различными реализациями инспекторов свойств объектов, которые позволяют оперировать свойствами объектов во время разработки приложения. Но несмотря на это в создаваемые элементы управления ActiveX нужно всегда включать страницы свойств. Даже если эти страницы не будут использоваться ни для чего больше, то они хотя бы предоставят разработчику способ построения специальных окон редактирования более сложных свойств элемента управления. Как будет показано ниже, в Delphi можно довольно просто создавать страницы свойств. Ниже показана иерархия классов, которая поддерживает создание страниц свойств в Delphi.
TCustomForm
TPropertyPage
TActiveXProperty Page
[TMyPropertyPage]
При создании новая страница свойств будет наследована от класса TPropertyPage.
String_type_of_data
Строковые типы
В выражениях Delphi поддерживает три физических строковых формата: короткий (ShortString), длинный (LongString) и широкий (WideString). Их можно комбинировать в операторах присваивания и выражениях (все необходимые преобразования Delphi выполняет автоматически).
Переменные типов AnsiString и WideString — это динамически распределяемые массивы символов, максимальная длина которых ограничивается только наличием памяти. Разница между ними состоит в том, что в AnsiString знаки записываются в формате char, а в WideString— в формате WideChar. Обычно вполне достаточно одного типа AnsiString, однако при работе с международными наборами символов, такими как UNICODE, удобнее использовать WideString.
Тип ShortString—это, по существу, массив Array [0..255] of char. Первый его элемент задает динамическую длину строки, которая может принимать значения от 0 до 255 символов. Символы, составляющие строку, занимают места от 1 до 255. Тип ShortString предназначен, в основном, для обеспечения совместимости с ранними версиями Delphi и Borland Pascal.
Логический строковый тип именуется просто String. Отнесение его к типу AnsiString или ShortString задается командой $Н. По умолчанию задается { $Н+}, и String совпадает с AnsiString. Если задать команду {$Н- }, то String будет совпадать с ShortString и иметь максимальную длину, равную 255 символам.
Для совместимости с другими языками программирования в Delphi поддерживается класс строк с конечным нулем. Зарезервированных слов или идентификаторов для этого класса не существует.
Строки с конечным нулем состоят из ненулевых символов и оканчиваются символом с порядковым номером 0 (#0). В отличие от типов AnsiString, ShortString и WideString, строки с нулевым окончанием не имеют указателя длины. Конец в этих стооках обозначается нулем.
Физически строки с нуль-окончанием подобны массивам символов с нумерацией элементов от нуля, наподобие array [ 0 . . X] of char, где Х — некоторое положительное целое, большее нуля, хотя никаких объявлении подобного рода не происходит. Вместо этого определяется переменная-указатель PChar и распределяется необходимый объем памяти. При необходимости строке AnsiString можно присвоить тип PChar.
В табл. 1.7 перечислены некоторые процедуры и функции обработки данных строковых типов.
Совет: Программисты, работающие на С, привыкли записывать все строки в массивы с нуль-окончанием. Фактически они применяют в выражениях не строковые переменные, а указатели на них. Программисты, работающие на Basic, привыкли использовать строку как одно целое. Для типа AnsiString из Delphi годятся оба подхода.
Таблица 1.7. Строковые функции
Функция | Описание |
Concat(sl, s2, s3) | Возвращает последовательное соединение строк. Эквивалентна оператору sl+s2+s3 |
Copy(s, pos, len) | Возвращает подстроку длиной максимум len символов, начинающуюся в позиции pos строки s |
Delete(s, pos, len) | Удаляет максимум len символов из строки s, начиная с позиции pos |
Insert(sourse, tar-get, pos) | Вставляет строку source в строковую переменную target, начиная с позиции pos |
Length (s) | Возвращает динамическую длину строки. Подобна функциям LEN в Basic и strlen — в C/C++ |
Pos(substring, s) | Возвращает место первого вхождения подстроки substring в строку s. Подобна функциям SUBSTR в Basic и strstr () — в C/C++ |
SetLength(s, newlen) | Задает новую динамическую длину newlen строковой переменной s |
SetString | Задает содержимое и длину строки |
Str(x, s) | Преобразует численное значение х в строковую переменную s |
StringOfChars | Возвращает строку с конкретным числом символов |
UniqueString | Делает данную строку уникальной со счетом обращений 1 |
Val (s, v, code) | Преобразует строку s в соответствующее численное представление v |
Свойства TApplication
Active EXEName Hint и ShowHint HintColor, HintPause, HintHidePause и HintShortPause Icon Title
с помощью которых можно отслеживать
TApplication предоставляет несколько свойств, с помощью которых можно отслеживать состояние приложения и контролировать некоторые аспекты его поведения. Active
Это свойство возвращает значение True, если в приложении в текущий момент содержится фокус ввода. Если Active приложения имеет значение True, то и свойство Active для одной из форм также равно True. Обычно оно используется для определения, имеет ли приложение фокус ввода, перед выводом строки состояния или прорисовкой объекта TCanvas. Совет: Даже будучи неактивным, приложение продолжает получать сообщения о перемещении мыши.
EXEName
Это свойство представляет собой строку, содержащую полный путь выполняемого файла (аналог в С— argv[0]). Чаще всего оно используется для определения рабочего каталога приложения, в котором могут находиться файлы данных или инициализации программы.
Совет: Для получения из EXEName рабочего каталога используйте функцию ExtractFilePath или Extract-FileDir из модуля SysUtils.
Hint и ShowHint
В свойстве Hint содержится текст, который будет выведен после запуска события OnHint.
Свойство ShowHint используется для определения, выводится ли подсказка "на лету". Установка свойства равным False отключает систему подсказок для всех элементов в приложении независимо от их индивидуальных установок. Обычно оно используется совместно с пунктом меню, включающим или отключающим подсказки. Вот примерный код.
procedure TFormI.mnuToggleHintsClick(Sender: TObject);
begin
{Переключение текущего состояния.}
mnuToggleHints.Checked:= not mnuToggleHintsChecked;
{Обновление свойства ShowHint.} Application.ShowHint:= mnuToggleHints.Checked;
end;
HintColor, HintPause, HintHidePause и HintShortPause
HintColor определяет цвет окна всплывающей подсказки, например
Application.HintColor:= cILime;
HintPause и HintHidePause определяют временные задержки при показе подсказок следующим образом. Указатель мыши помещается над потомком TControl. Событие OnHint вызывается сразу же после установки указателя мыши на TControl. Delphi ожидает HintPause миллисекунд перед выводом окна подсказки. Указатель остается над TControl. Delphi ожидает HintHidePause миллисекунд перед закрытием окна подсказки. Свойство HintShowPause определяет задержку перед отображением подсказки, если активна подсказка другого элемента.
Icon
Свойство Icon позволяет изменить пиктограмму, представляющую приложение в панели задач во время работы. Это полезно, если необходимо отмечать, таким образом, изменение состояния приложения. Следующий код назначает пиктограмму из файла INACTIVE.ICO:
Application.Icon.LoadFromFile('INACTIVE.ICO');
Title
Определяет заголовок приложения в панели задач.
Свойства TForm
Active ActiveControl AutoScroll, HorzScrollBar, VertScrollBar BorderIcons BorderStyle Height и Width ClientHeight и ClientWidth FormStyle Icon KeyPreview Menu Position WindowState
Класс TForm предоставляет возможность изменять
Класс TForm предоставляет возможность изменять его поведение и внешний вид формы с помощью ряда свойств. Active
Свойство Active определяет, имеет ли форма фокус ввода. Если имеет, оно возвращает True, если нет False. Windows выводит заголовок активной формы цветом, отличающимся от цвета неактивных. Совет: Неактивные окна продолжают получать сообщения о перемещении и выборе мыши. Независимо от типа приложения в один момент времени может быть активной только одна форма. Вы можете обратить внимание на то, что заголовок родительской формы в MDI-приложении изображен "активным" цветом. Не попадитесь на эту удочку — свойство Active родительского MDI-окна, никогда не бывает равным True.
Совет: Свойство ActiveForm класса TScreen, возвращает форму, которая в данный момент имеет фокус ввода.
ActiveControl
Свойство ActiveControl указывает на потомка TWinControl, имеющего в настоящий момент фокус ввода. Вы можете установить значение во время создания программы, определив, какой элемент будет иметь фокус ввода при инициализации формы. Назначение ActiveControl во время работы программы— установка фокуса ввода в поле с некорректно введенными данными. Приведенный ниже фрагмент кода позволяет проверить текст, введенный в элемент editCustName, перед закрытием формы.
procedure TDataEntryForm.FormCloseQuery(Sender: Tobject;
var CanClose: Boolean);
begin
{Проверяем, введен ли текст в элемент.}
if edtCustName.Text = ' ' then
begin
{Запрещаем закрытие.}
CanClose:= False;
(Устанавливаем фокус в поле с некорректными данными.)
ActiveControl:= editCustName;
end;
end;
Совет: Метод SetFocus потомков TWinControl устанавливает фокус ввода и обновляет свойство ActiveControl. Большинство событий передает параметр Sender своему обработчику. Sender определяет, какой элемент обнаружил событие и запустил обработчика.
AutoScroll, HorzScrollBar и VertScrollBar
Свойство AutoScroll управляет появлением полос прокрутки в форме, размеры которой не позволяют вывести все ее элементы одновременно. Если свойство равно True, и вы изменили размеры так, что не все элементы формы видны, в форме автоматически появляются полосы прокрутки. Если же значение свойства— False, вы теряете доступ к элементам формы, не поместившимся на экране.
Совет: Компонент TScrollBar, позволяет прокручивать форму независимо от свойства AutoScroll.
Вы можете управлять полосами прокрутки с помощью свойств HorzScrollBar и VertScrollBar. Это весьма полезно в программах, реализующих свойство распахивания окна. Поскольку размеры выводимой диаграммы могут быть больше размеров формы, а выводите вы ее самостоятельно, AutoScroll не активизируется, и вам следует обеспечить прокрутку и рисование, самому. Вот пример такого кода, обеспечивающего прокрутку в двойном размере формы.
{Устанавливаем диапазон вертикальной прокрутки.}
VetrScrollBar.Range:= Height * 2;
{Показываем вертикальную полосу прокрутки.}
VertScrollBar.Visible:= True;
{Устанавливаем диапазон горизонтальной прокрутки.}
HorzScrollBar.Range:= Width * 2;
{Показываем горизонтальную полосу прокрутки.}
HorzScrollBar.Visible:= True;
BorderIcons
Свойство Borderlcons представляет собой набор логических значений, использующийся для определения набора пиктограмм в заголовке формы.
Значения biMinimize и biMaximize создают пиктограммы, которые позволяют свернуть и развернуть форму с помощью мыши.
Совет: Для того чтобы значения biMinimize и biMaximize работали, необходимо установить свойство BorderStyle равным bsSizeable или bsSizeToolWin.
Значение biHelp выводит кнопку с вопросительным знаком. Щелчок на ней вызывает контекстно-зависимую справку, которая выводится, как текст подсказки Hint, т.е. без вызова Windows Help. На Рисунок 1.1 представлена такая кнопка. Рисунок 1.1. Доступ к контекстно-зависимой справке можно получить с помощью щелчка на кнопке с вопросительным знаком в заголовке формы.
Значение biSystemMenu создает слева от заголовка пиктограмму, позволяющую вызывать системное меню, как показано на Рисунок 1.2.
Рисунок 1.2. Системное меню позволяет перемещать и закрывать форму, а также изменять ее размеры.
Совет: Для того чтобы значения biMinimize, biMaximize и biHelp работали, необходимо присвоить свойству заметку BorderIcons значение biSystemMenu.
BorderStyle
Свойство BorderStyle перечислимого типа позволяет определить: вид заголовка формы доступные кнопки в заголовке формы отображение строки меню поведение границ формы На Рисунок 1.3 показана форма для шести значений BorderStyle. Каждая форма создавалась как форма размером 200х200 пикселей.
По умолчанию свойство BorderStyle имеет значение bsSizeable, создающее обычное окно с изменяемыми размерами. Такое окно имеет стандартную строку заголовка и не имеет ограничений на расположение в ней кнопок. Примеры таких окон — программы Explorer и Notepad.
Значение bsDialog создает диалоговое окно, которое используется, когда программа требует от вас ответа для продолжения выполнения программы или для вывода информации, 16-разрядные версии Windows выводили такое окно как окно с широкой границей того же цвета, что и заголовок. Сейчас, если вы будете следовать новому трехмерному интерфейсу, границы окна будут выглядеть так же, как границы обычного окна! Видимое различие между стандартными и диалоговыми окнами в связи с тем, что последнее не может изменять размеры, состоит лишь в том, что указатель мыши не изменяется при пересечении рамки окна.
Совет: Значения biMinimize и biMaximize свойства Borderlcons не будут работать, если свойство BorderStyle установлено равным bsDialog.
Третий по популярности стиль окон — bsSingle, создающий форму, которая не может изменять размеры во время работы. В отличие от bsDialog, bsSingle не запрещает установку любых пиктограмм. Единственное ограничение состоит в том, что кнопка сворачивания окна, будучи выведенной, является недоступной (блокированной). Пример такой программы — Calculator. На Рисунок 1.4 вы видите другой пример окна bsSingle. Рисунок 1.4. Стиль bsSingle полезен, когда пользователю не надо изменять размер окна.
Панель инструментов (Toolbar) позволяет быстро получить доступ к сгруппированным функциям. В Delphi можно сконструировать панель инструментов, поместив группу компонентов TSpeedButton в форму, имеющую стиль bsSizeToolWin или bsToolWindow. Окно в стиле bsSizeToolWin может изменять размеры и не имеет кнопок biMinimize, biMaximize HbiHelp. Окно в стиле bsToolWindow действует так же, но не позволяет изменять размеры.
Стиль bsNone создает окно без рамки и заголовка. Такое окно не рекомендуется использовать в качестве стандартного или диалогового, однако оно может быть полезным в программах сохранения экрана или заставках.
Совет: Если вы выбрали для свойства BorderStyle значение, создающее окно с разрешенным изменением размеров, Delphi автоматически установит значение AutoScroll равным True. Формы со стилями bsDialog и bsNone не могут иметь строки меню.
Height и Width
Эти свойства определяют высоту и ширину формы в пикселях и обычно используются для изменения размеров формы во время работы на дисплеях разной разрешающей способности. Вот пример увеличения размеров формы до размеров всего экрана.
{Перемещаем форму в верхний левый угол экрана.}
Left:= 0;
Тор:= 0;
(Изменяем размеры формы.)
Width:= Screen.Width;
Height:= Screen.Height;
(Класс TScreen, о котором будет сказано ниже, и его экземпляр Screen предоставляют доступ к информации о размерах всего экрана.)
Приведенный код, конечно, работает, но плохо, так как требуется четыре обновления формы. На самом деле лучше использовать метод SetBounds, определенный у потомков TWinControl:
SetBounds(0, 0, Screen.Width, Screen.Height);
ClientHeight и ClientWidth
Окно состоит из двух частей — клиентской и не клиентской. Обычно приложение выводит изображения только в клиентской области, размер которой возвращается через свойства ClientHeight и ClientWidth. Обычно эти свойства используются для того, чтобы убедиться, что в форме может выводиться весь объект определенного размера. Показанный ниже текст приводит размер клиентской области формы в соответствие размерам изображения, содержащегося в компоненте TImage, ImgPicture.
with imgPicture.Picture do
begin
(Изменение размера.)
ClientWidth:= Width;
ClientHeight:= Height;
end;
Не клиентская область обычно прорисовывается Windows и включает строку заголовка, меню и рамку окна. Вы можете рисовать в этой части окна, перехватив сообщение WM_NCPAINT.
FormStyle
Свойство FormStyle перечислимого типа определяет, как форма взаимодействует с вашим приложением и Windows.
Существует два основных стиля форм — MDI (Multiple Document Interface — многодокументный интерфейс) и не MDI. Имеется два MDI-стиля (fsMDIForm и fsMDIChild), которые рассматриваются ниже. Не MDI формы существуют также в двух вариантах— fsNormal и fsStayOnTop. Наиболее популярен стиль fsNormal, который создает стандартный стиль, используемый для диалогов, панелей инструментов и SDI-приложений.
Стиль fsStayOnTop применяется реже и создает форму, всегда остающуюся поверх других форм и приложений, что может быть полезно при выводе системной информации и использовании ресурсов. Примером такого окна является окно программа Chat, используемой при работе в сети.
Вот как можно реализовать, подобно программе Chat, установку вывода поверх других окон путем выбора пункта меню.
procedure TFormI.mnuAlwaysOnTopClick(Sender: TObject);
begin
with mnuAlwaysOnTop do
begin
{Переключаем отметку выбора пункта меню.}
Checked:= not Checked;
{Проверка установок меню.}
if Checked then
(Устанавливаем стиль fsStayOnTop.)
FormStyle:= fsStayOnTop
else
{Возвращаем нормальный стиль.}
FormStyle:= fsNormal;
end;
end;
Совет: Изменение свойства FormStyle вызывает событие OnShow.
Icon
Свойство Icon определяет пиктограмму, выводимую Windows при сворачивании вашей формы. В интерфейсе Windows 95 эта пиктограмма также выводится в левом верхнем углу формы на кнопке системного меню. Если вы не определите значения для этого свойства, будет использоваться свойство Icon глобального объекта Application.
KeyPreview
Объект TForm наследует от класса TWinControl обработку событий OnKeyDown, OnKeyUp и OnKeyPress, и свойство KeyPreview определяет ситуации, в которых эти сообщения запускаются. Если значение KeyPreview равно False, события клавиатуры пересылаются только тому управляющему элементу, который имеет фокус ввода. В неординарном случае, когда в форме нет управляющих элементов, событие передается форме. Если же значение свойства установлено равным True, событие сначала пересылается форме, а затем — управляющему элементу, имеющему фокус ввода.
Совет: Поскольку клавиша <Tab> используется для передачи фокуса другому управляющему элементу, она не вызывает генерации события.
Обычно свойство используется KeyPreview для обработки функциональных клавиш, которые должны быть переданы форме независимо от текущего активного элемента.
Без этого свойства обработка функциональных клавиш сводится к написанию для каждого элемента дополнительного обработчика, который должен отслеживать нажатие функциональных клавиш. Более элегантным является использование разделяемого обработчика событий, так что лучше всего применять свойство KeyPressed.
При этом все нажатия клавиш отсылаются обработчикам событий OnKeyDown, OnKeyUp и OnKeyPress автоматически и для "отлова" функциональной клавиши надо написать только один обработчик события OnKeyDown формы. Вот пример закрытия формы при нажатии клавиши <F2.
procedure TFormI.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState):
begin
{Проверить, нажата ли клавиша <F2.}
if Key = VK_F2 then
{Закрыть форму.}
Close;
end;
Рассматривая принцип работы этого кода, имейте в виду, что события OnKeyDown и OnKeyUp используют виртуальные коды (все они перечислены в файле WINDOWS.PAS).
Menu
Это свойство определяет компонент TMainMenu, который предоставляет главное меню формы. Свойство Menu позволяет сделать меню контекстно-зависимым и часто используется в OLE-приложениях при замене вашего исходного меню на меню приложения-сервера. На Рисунок 1.5 показан документ Wordpad с внедренным объектом MediaClip. Обратите внимание, что меню и панель инструментов при этом те же, что и у Media Player. Рисунок 1.5. Вы можете создать контекстно-зависимое меню с помощью свойства Menu
Для изменения свойства Menu просто присвойте ему новое значение (TMainMenu или его потомок):
Menu:= mnuMainMenu;
Position
Position — это свойство перечислимого типа, определяющее размещение формы при запуске приложения.
Значение по умолчанию (poDesigned) заставляет форму выводиться в месте, определенном при разработке приложения. Положение и размер формы при этом берутся из свойств Left, Top, Height и Width. Поскольку вы не можете знать заранее, в какой системе будет запущено ваше приложение, может оказаться, что на мониторе с низким разрешением при использовании этого значения свойства будет видна только часть формы.
Более полезно значение poScreenCenter, использующее заданные вами при создании приложения значения Width и Height, но оно так изменяет Left и Тор, что форма выводится в центре экрана.
Если вы установите Position равным poDefault, Windows автоматически установит размеры и положение формы, но вы при этом лишитесь возможности контролировать ее размеры. Можете создать форму размером 200х200, которая будет выведена как 640х480. Из-за этого, в частности, не допускается применение данного значения для MDI-форм.
Значение poDefaultPosOnly более полезно, так как оно автоматически определяет расположение формы, но не ее размеры (а потому рекомендуется для MDI-форм, в которых требуются определенные размеры дочерних форм).
Последнее значение свойства (poDefaultSizeOnly) автоматически определяет размер, но не расположение формы. Это значение может использоваться там, где важно положение формы на экране, а не ее размер.
Хотя свойство Position позволяет определить, каким образом будет выводиться форма, профессионально сделанные приложения сами запоминают свое расположение на экране и при следующем запуске выводятся в той же позиции и с тем же размером. Это осуществимо, например, благодаря записи положения окна в Registry или в INI-файле, в том же каталоге, где находится приложение. Обычно сохранение позиции и размеров экрана выполняется в самый последний момент — при уничтожении формы.
procedure TForml.FormDestroy(Sender: TObject);
var
sAppPath: String;
iniSettings: TINIFile;
begin
{Получить путь к ЕХЕ-файлу приложения.}
sAppPath:= ExtractFilePath(Application.EXEName);
{Создаем объект TINIFile.}
iniSettings:= TINIFile.Create(sAppPath + 'SETTINGS.INI');
try
{Записываем свойства в INI-файл.}
iniSettings.Writelnteger(Name,'Left',Left);
iniSettings.Writelnteger(Name,'Top',Top);
iniSettings.Writelnteger(Name,'Width',Width);
iniSettings.Writelnteger(Name,'Height',Height);
finally
iniSettings.Free;
end;
end;
Совет: Для компиляции примера не забудьте включить в раздел uses модуль INIFiles.
После выполнения кода ваш INI-файл будет содержать нечто вроде
[Form1]
Left=108
Тор=174
Width=540
Height=165
Заметьте, что для строки раздела используется свойство Name вашей формы.
Восстановить положение формы на экране немного сложнее (главным образом из-за того, что следует отработать ситуацию, когда INI-файла нет).
procedure TFormI.Create(Sender: TObject);
const
CNOTFOUND = -1;
var
sAppPath: String;
iniSettings: TINIFile;
liValue: Longint;
begin
{Получаем путь к ЕХЕ-файлу приложения.}
sAppPath:= ExtractFilePath(Application.ExeName);
{Создаем объект TINIFile.}
iniSettings:= TINIFile.Create(sAppPath + 'SETTINGS.INI');
try
{Пытаемся считать значение Left.}
liValue:= iniSettings.Readlnteger(Name,'Left',cNOTFOUND);
{Проверяем, считано ли значение.}
if liValue = cNOTFOUND then
begin
{Свойства в INI-файле не найдены — центруем форму.}
Left:= (Screen.Width - Width) div 2;
Top:= (Screen.Height - Height) div 2;
end
else
begin
{Считываем значения из INI-файла.}
Left:= iniSettings.Readlnteger(Name,'Left',Left);
Top:= iniSettings.Readlnteger(Name,'Top',Top);
Height:= iniSettings.Readlnteger(Name,'Height',Height);
Width:= iniSettings.Readlnteger(Name,'Width'.Width);
end;
finally
iniSettings.Free;
end:
end;
WindowState
Свойство перечислимого типа WindowState определяет состояние окна— свернутое, развернутое или нормальное. По умолчанию оно имеет значение wsNormal (при этом окно выводится в состоянии, определяемом свойствами Position, Left, Top, Height и Width). Чтобы свернуть или развернуть форму, используются значения wsMinimize и wsMaximize.
Свойства TScreen
ActiveControl ActiveForm Cursor Form и FormCount Height и Width
Это свойство возвращает объект TWinControl,
ActiveControl
Это свойство возвращает объект TWinControl, имеющий фокус ввода. Обычно оно используется для реализации команд Copy, Cut и Paste для текстовых управляющих элементов. Следующий код, помещенный в обработчик TMenuItem, выполняет функцию Copy.
procedure TFormI.mnuEditCopyClick(Sender: TObject);
begin
Screen.ActiveControl.Perform(WM_COPY,0,0);
end;
Все, что происходит в мире Windows, базируется на сообщениях. Для выполнения какой-либо функции управляющие элементы часто отсылают сообщения самим себе. Так и в этом примере управление происходит путем передачи сообщения WM_COPY.
ActiveForm
Это свойство возвращает объект TForm, имеющий фокус ввода. Если приложение неактивно, свойство указывает, какая именно форма будет иметь фокус ввода при активизации приложения. В качестве примера используем свойство для создания мигающего заголовка формы, чтобы привлечь внимание пользователя. Функция Windows API, предназначенная для этой цели, должна получить дескриптор окна:
FlashWindow(Screen.Active Form.Handle,False);
Cursor
Это свойство определяет форму указателя мыши для всего приложения. Обычно оно используется для отображения песочных часов, чтобы в то время, пока пользователь думает о сложной работе, выполняемой приложением, немного передохнуть.
{Придать курсору форму песочных часов.}
Screen.Cursor:= crHourglass;
try
{Попытаемся ничего не делать какое-то время.}
for iCount:=1 to 1000000000 do;
finally
{Восстановим форму указателя.}
Screen.Cursor:= crDefault;
end;
Форму указателя можно изменить для каждого потомка TControl (включая ТForm) отдельно.
Forms и FormCount
Эти свойства возвращают список форм и их количество. Работа с ними ничем не отличается от работы со списком дочерних окон, описанных в разделе "MDIChildren и MDIChildCount".
Height и Width
Это наиболее полезные свойства, возвращающие высоту и ширину экрана в пикселях. Они могут применяться во многих ситуациях, например при определении местоположения формы. Вот как поместить форму в центре экрана.
Left:= (Screen.Width - Width) div 2;
Top:= (Screen.Height - Height) div 2;
События TScreen
TScreen предоставляет два основных события, извещающие программу об изменении фокуса ввода. Подобно возможностям класса TApplication, возможности класса TScreen доступны лишь при выполнении.
OnActiveControlChange
Это событие возникает при передаче фокуса ввода от одного управляющего элемента к другому. Свойство
ActiveControl обновляется непосредственно перед вызовом события. Вы можете использовать событие, например, для вывода текста подсказки в строке состояния.
procedure TFormI.ActiveControlChangeHandler(Sender: TObject);
begin
if (not Application.Terminated) then
pnlStatus.Caption:= ActiveControl.Hint;
end;
Проверка связана с тем, что событие генерируется и при закрытии приложения, а при этом обращение к уже уничтоженному объекту вызовет исключительную ситуацию.
OnActiveFormChange
Событие генерируется при создании новой формы или передаче фокуса ввода от одной формы к другой. Обычно это событие используется в MDI-приложениях для обновления доступных функций меню и кнопок-ускорителей. Ниже приведен пример из шаблона MDI-приложения.
procedure TMainForm.UpdateMenuItems(Sender: TObject);
begin
FileCloseItem.Enabled:= MDIChildCount 0;
FileSaveItem.Enabled:= MDIChildCount 0;
FileSaveAsItem.Enabled:= MDIChildCount 0;
end;
Процедура UpdateMenuItems назначена в качестве обработчика событию OnActiveFormChange в обработчике
OnCreate.
procedure TMainForm.FormCreate(Sender: TObject);
begin
Application.OnHint:= ShowHint;
Screen.OnActiveFormChange:= UpdateMenuItems;
end;
Операции над порядковыми типами
Операция | Описание |
Low (T) | Минимальное значение порядкового типа Т |
High(T) | Максимальное значение порядкового типа Т |
Ord(X) | Порядковый номер значения выражения порядкового типа. Для целого выражения — просто его значение. Для остальных порядковых типов Ord возвращает физическое представление результата выражения, трактуемое как целое число. Возвращаемое значение всегда принадлежит одному из целых типов |
Pred(X) | Предыдущее по порядку значение. Для целых выражений эквивалентно Х-1 |
Succ(X) | Следующее по порядку значение. Для целых выражений эквивалентно Х+1 |
Dec(V) | Уменьшает значение переменной на 1. Эквивалентно V := Pred(V) |
Inc(V) | Увеличивает значение переменной на 1. Эквивалентно V := Succ(V) |
Физические целые типы
Тип | Диапазон значении | Физический формат |
Shortint | -128-127 | 8 бит, со знаком |
Smallint | -32 768-32 767 | 16 бит, со знаком |
Longint | -2 147 483 648-2 147 483 647 | 32 бит, со знаком |
Byte | 0-255 | 8 бит, без знака |
Word | 0-65 535 | 16 бит, без знака |
Диапазоны значений логических целых типов (Integer и Cardinal) определяются совершенно иным образом. Как видно из табл. 1.3, они никак не связаны с диапазонами соответствующих физических типов. Обратите внимание, что в Delphi по умолчанию задано 32-разрядное представление.
Логические целые типы
Тип | Диапазон значений | Физический формат |
Integer | -32 768-32 767 | 16 бит, со знаком (SmalIInt) |
Integer | -2 147 483 648-2 147 483 647 | 32 бит, со знаком (Longint) |
Cardinal | 0-65 535 | 16 бит, без знака (Word) |
Cardinal | 0-2 147483647 | 32 бит, без знака (Longint) |
Совет: В С и C++ для целых значений определены типы int, short int (или просто short) и long int (или просто long). Тип int из C/C++ соответствует типу Integer из Delphi, a long из C/C++ — Longint из Delphi. Однако Shortint из C/C++ соответствует в Delphi не Shortint, a Smalltlnt. Эквивалент Shortint из Delphi в C/C++— это signed char. Тип unsigned char в C/C++ соответствует типу Byte из Delphi. В C/C++ существует еще тип unsigned long, аналога которому в Delphi нет.
Над целыми данными выполняются все операции, определенные для порядковых типов, но с ними все же удобнее работать как с числами, а не с "нечисленными порядковыми типами". Как и "живые" числа, данные целых типов можно складывать (+), вычитать (-) и умножать (*). Однако некоторые операции и функции, применяемые к данным целых типов, имеют несколько иной смысл.
Операция | Результат |
Abs (X) | Возвращает абсолютное целое значение Х |
Х Div Y | Возвращает целую часть частного деления Х на Y |
Х Mod Y | Возвращает остаток частного деления Х на Y |
Odd (X) | Возвращает булево True (истина), если Х — нечетное целое, и False (ложь) — в противном случае |
Sqr (X) | Возвращает целый квадрат Х (т.е. Х*Х) |
Совет: Будьте внимательны при перенесении численных выражений из одного языка в другой. В Basic, например,vфункция SQR вычисляет квадратный корень. В C/C++ целое деление обозначается косой чертой (/). В Delphi косая между двумя целыми даст действительный результат с плавающей запятой.
Размеры переменных булевых типов
Тип | Размер |
Boolean | 1 байт |
ByteBool | 1 байт |
WordBool | 2 байт (объем Word) |
LongBool | 4 байт (объем Longint) |
Переменным типа Boolean можно присваивать только значения True (истина) и False (ложь). Переменные ByteBool, WordBool и LongBool могут принимать и другие порядковые значения, интерпретируемые обычно как False в случае нуля и True — при любом ненулевом значении.
Совет: Булевы типы в Delphi можно сравнить с типом LOGICAL языка FORTRAN. В Basic, С и C++ булевы типы как таковые отсутствуют. Булевы выражения в этих языках применяются точно так же, как во всех остальных, однако результаты этих выражений интерпретируются не как значения отдельного типа, а как целые числа. Как в Basic, так и в C/C++ булевы выражения дают численные результаты, интерпретируемые как False в случае 0 и True — в случае любого ненулевого значения. Это совместимо с порядковыми значениями булевых выражений в Delphi. В C/C++ простые сравнения дают результат 1 (True) или 0 (False). Это эквивалентно булевым значениям Delphi. Только результат сравнения в Delphi выводится как булевый, а не целый. В большинстве случаев типу Boolean из Delphi соответствует тип char в C/C++. В Basic зарезервированы слова TRUE (эквивалентно константе -1) и FALSE (эквивалентно константе 0). В Basic TRUE меньше FALSE, в Delphi, наоборот, False меньше True.
Действительные типы
Тип | Порог | Максимальное значение | Количество значащих цифр | Объем (байт) |
Real | 2.9E-39 | 1.7Е38 | 11-12 | 6 |
Single | 1.5E-45 | 3.4Е38 | 7-8 | 4 |
Double | 5.0E-324 | 1.7Е308 | 15-16 | 8 |
Extended | 3.4E-4932 | 1.IE4932 | 19-20 | 10 |
Comp | 1.0 | 9.2Е18 | 19-20 | 8 |
Currency | 0.0001 | 9.2Е14 | 19-20 | 8 |
Совет: Тип Real предназначен для совместимости с ранними версиями Delphi и Borland Pascal. Формат этого типа неудобен для семейства процессоров Intel, поэтому операции с типом Real выполняются несколько медленнее операций над остальными действительными типами.
Целые типы представляют целые числа, т.е. числа, дробная часть которых равна нулю. Разница между двумя неодинаковыми целыми числами не может быть меньше единицы. Именно благодаря этому целые числа применяются для обозначения дискретных величин, независимо от того, имеют ли реальные объекты какое-либо отношение к числам. Действительные типы предназначены для представления чисел, которые могут иметь дробную часть, поэтому они полезны для представления величин, которые могут быть довольно близкими, почти непрерывными.
Заметьте, именно почти. Несмотря на название действительные, переменные этих типов отличаются от математических действительных чисел. В Object Pascal действительный тип — это подмножество математических действительных чисел, которые можно представить в формате с плавающей запятой и фиксированным числом цифр. Для невнимательных программистов ситуация усугубляется тем, что в стандартных форматах IEEE (Institute of Electrical and Electronic Engi-neers — Институт инженеров- электриков и электронщиков), применяемых в программах Delphi и вообще в большинстве программ для Windows, возможно точное представление только чисел с фиксированным числом бит в дробной части. Удивительно, но такое простое число, как 0,1, записывается в расширенном формате IEEE с некоторой погрешностью, пусть очень небольшой. Из-за этого представление с плавающей запятой оказывается несколько неудобным для программ, в которых сохраняется и выводится фиксированное число десятичных разрядов численных значений. Это относится и к программам, работающим с ''живыми" деньгами.
Для частичного решения этой проблемы в Object Pascal определены два формата с фиксированной запятой. Тип Comp (computational — вычислительный) содержит только целые числа в диапазоне от -263+1 до 263-1, что примерно соответствует диапазону от —9,2х1018 до 9,2х1018. При программировании операций с американской валютой разработчикам обычно приходится искать естественный способ записи денежных сумм, в котором целая часть числа определяет количество долларов, дробная — центов. Если такие значения записывать в переменные типа Comp, придется представлять их в виде целого числа центов. В этом случае следует умножать значение на 100 для обращения центов в доллары, а затем делить на 100, чтобы снова получить центы.
Этих забот можно избежать, если воспользоваться типом Currency. В этом случае задачу выбора масштаба возьмет на себя компилятор. Физически значения Currency записываются в память того же объема, что и Comp, как целые числа, однако компилятор не забывает вовремя разделить значение на 10 000 (не на 100!) для его приведения в соответствие с денежным знаком и умножить на 10 000 перед записью в память. Это обеспечивает абсолютную точность в четыре десятичных знака после запятой.
В Delphi есть модуль System, содержащий ряд процедур обработки данных действительных типов. Наиболее распространенные из них перечислены в табл. 1.6. Много полезных процедур содержится также в модулях SysUtils и Math.
Функции действительных типов
Функция | Возвращаемое значение |
Abs (x) | Абсолютная величина х |
АгсТаn(х) | Арктангенс х |
Cos (х) | Косинус х (х выражается в радианах, а не в градусах) |
Ехр (х) | Экспоненциальная функция от х |
Frac(x) | Дробная часть х |
Int (х) | Целая часть х. Несмотря на название, возвращает действительное значение (с плавающей запятой), т.е. просто устанавливает нуль в дробной части |
Ln (х) | Натуральный логарифм от х |
Pi | Число Пи (3.1416...) |
Round (х) | Ближайшее к х целое значение. Возвращает значение целого типа. Условие "ближайшее к х" не работает, если верхнее и нижнее значения оказываются равноудаленными (например, ес-ли дробная часть точно равна 0,5). В этих случаях Delphi перекладывает решение на опера-ционную систему. Обычно процессоры Intel решают эту задачу в соответствии с рекоменда-цией IEEE округлять в сторону ближайшего четного целого числа. Иногда такой подход на-зывают "банкирским округлением" |
Sin(x) | Синус х |
Sqr(x) | Квадрат х, т.е. X*X |
Sqrt (х) | Квадратный корень от х |
Тrunc (х) | Целая часть х. В отличие от Int, возвращающей действительное значение, Trunc возвращает целое |
Совет: Будьте внимательны при переносе численных выражений из одного языка в другой. В Basic функция SQR вычисляет квадратный корень, а функция Sqr из Delphi — квадрат числа. Для вычисления квадратного корня в Delphi применяется функция Sqrt.
Средства работы с указателями
Средство | Описание |
New | Распределяет новый участок динамической памяти и записывает его адрес в переменную указательного типа |
Оператор @ | Направляет переменную-указатель на область памяти, содержащую любую существующую переменную, процедуру или функцию, включая переменные, имеющие идентификаторы |
GetMem | Создает новую динамическую переменную заданного объема и записывает ее адрес в переменную указательного типа |
Процедуры и функции
Вариантные переменные удобно применять для изменения свойств объектов OLE Automation и вызова методов этого объекта. Чтобы инициировать эту возможность, необходимо подключить модуль OleAuto.
Синтаксис вызова метода или обращения к свойству объекта OLE Automation такой же, как вызова из созданного класса. Есть, однако, несколько важных отличии. Во-первых, вызов метода объекта OLE Automation происходит по схеме позднего связывания, т.е. компилятор не проверяет, существует ли данный метод и правильно ли определены типы параметров. Для компилятора приемлемы любой идентификатор метода и любое число параметров разных типов. А это означает, что при выполнении вызванного таким образом метода может произойти ошибка.
Что же касается идентификаторов методов объекта OLE Automation, то они могут содержать любые алфавитные символы из международного набора, в том числе а, ь и ш.
Атрибуты библиотеки типов
Атрибут | Описание |
Name | Имя библиотеки типов |
GUID | Глобально уникальный 128-разрядный идентификатор библиотеки типов |
Version | Версия библиотеки типов, записанная в формате п.т, где п — старший и т — младший номера версии. В качестве номера версии может использоваться и единичное целое число. В качестве старшего и младшего номеров версий можно использовать числа от 0 до 65 535 |
LCID | Идентификатор места действия (locale), описывающий один национальный язык, который используется для всех текстовых строк в библиотеке типов и ее элементах |
Help String | Краткое описание библиотеки. Настоятельно рекомендуется указывать эту строку во всех созда-ваемых библиотеках |
Help File | Имя файла справки, связанной с библиотекой типов |
Help Context | Идентификатор контекста справки библиотеки типов |
Флаги библиотеки типов
Флаг | Описание |
None | Флаги не установлены |
Restricted | Запрещает использовать библиотеку типов в средах программирования макросов, таких как Visual Basic |
Control | Указывает, что библиотека содержит элемент управления, который будет использован на стороне сервера для порождения новых библиотек типов и классов составных объектов (CoClass) |
Hidden | Указывает, что библиотека существует, но не должна быть показана в пользовательских броузерах |
Во вкладке Uses показаны все библиотеки, на которые ссылается просматриваемая библиотека. С помощью ссылок на другие библиотеки типов можно заимствовать определение элементов, таких как пересечение или интерфейсы. Это поможет разработчику определить собственные интерфейсы в собственной библиотеке типов. Например, основной интерфейс сервера автоматизации порожден от интерфейса IDispatch, но вам не придется изобретать колесо, так как Delphi автоматически создает ссылку на библиотеку типов STDOLE32. TLB, в которой определен интерфейс IDispatch. Библиотека STDOLE32.TLB является основной библиотекой типов Windows.
С каждой записью вкладки Uses связано две части информации. Первая часть — имя библиотеки, на которую создается ссылка, вторая — идентификатор GUID, который идентифицирует библиотеку типов в реестре Windows.
Атрибуты перечисления в библиотеке типов
Атрибут | Описание |
Name | Имя перечисления |
GUID | 128-разрядный идентификатор GUID-перечисления |
Help String | Краткое описание перечисления. Настоятельно рекомендуется указывать эту строку во всех создаваемых библиотеках |
Help Context | Идентификатор контекста справки по перечислению |
Version | Версия библиотеки типов, записанная в формате п.т, где n — старший и m — младший номера версии. В качестве номера версии может использоваться и единичное целое число. В качестве старшего и младшего номеров версий можно использовать числа от 0 до 65 535 |
Во вкладке Members определяются сами константы, составляющие перечисление. Формат определения константы показан ниже.
<Имя константы> = <Значение константы>;
helpstring = 'Строка описания';
Настоятельно рекомендуется указывать строку описания для членов перечисления, так как приложения, использующие ваш объект СОМ, могут зависеть от строк описания. На Рисунок 3.3 показана вкладка Members описания перечисления.
Атрибуты интерфейсов в библиотеках типов
Атрибут | Описание |
Name | Имя перечисления |
GUID | 128-разрядный идентификатор GUID-перечисления |
Help | String Краткое описание перечисления. Настоятельно рекомендуется указывать эту строку во всех создаваемых библиотеках |
Help Context | Идентификатор контекста справки по перечислению |
Version | Версия библиотеки типов, записанная в формате п.т, где п — старший и т — младший номера версии. В качестве номера версии может использоваться и единичное целое число. В качестве старшего и младшего номеров версий можно использовать числа от 0 до 65 535 |
Parent Interface | Имя интерфейса, являющегося базовым классом для выбранного интерфейса. Этот атрибут не применяется для интерфейсов Displnterface |
Флаги интерфейсов
Атрибут | Описание |
Declaration | Объявление свойства или метода |
ID | Значение идентификатора DispID |
Help String | Краткое описание свойства или метода |
Help Context | Идентификатор контекста справки по свойству или методу |
Флаги членов интерфейса в библиотеках типов
Флаг | Описание |
Restricted | Запрещает использовать библиотеку типов в средах программирования макросов, таких как Visual Basic |
Source | Указывает, что член возвращает объект или значение типа VARIANT, являющееся источником событии |
Bindable | Указывает, что свойство поддерживает связывание (binding) данных |
Request Edit | Указывает, что свойство поддерживает сообщение OnRequestEdit |
Display Bindable | Указывает, что свойство должно быть показано пользователю как поддерживающее связывание данных (bindable) |
Default Bindable | Указывает на одно поддерживающее связывание данных свойство, которое наилучшим образом представляет объект |
Hidden | Указывает, что интерфейс существует, но не должен быть показан в пользовательских броузерах |
Атрибуты составных классов в библиотеках типов
Атрибут | Описание |
Name | Имя составного класса (CoClass) |
GUID | Уникальный 128-разрядный идентификатор GUID составного класса (CoClass) |
Help String | Краткое описание составного класса. Настоятельно рекомендуется указывать эту строку во всех создаваемых библиотеках |
Help Context | Идентификатор контекста справки по составному классу |
Version | Версия библиотеки типов, записанная в формате п. т, где n — старший и m — младший номера версии. В качестве номера версии может использоваться и единичное целое число. В качестве старшего и младшего номеров версий можно использовать числа от 0 до 65 535. |
Флаги составных классов в библиотеках типов
Флаг | Описание |
Licensed | Указывает, что во время разработки и выполнения требуется лицензия. Обычно используется вместе с элементами управления ActiveX |
Control | Указывает, что составной класс является элементом управления |
Application Object | Указывает, что составной класс помещен во внешний (out-of-process) сервер (ЕХЕ). Используется исключительно с серверами автоматизации |
Вкладка Members в описании составного класса
Во вкладке Members в описании составного класса можно добавлять и удалять интерфейсы и перечисления, которьк составляют класс СОМ. В рассматриваемой вкладке содержится следующая информация. Имена интерфейсов и диспинтерфейсов, которые реализованы в классе СОМ. Идентификаторы GUID интерфейсов и диспинтерфейсов, реализованных в классе СОМ. Указания, является ли интерфейс или диспинтерфейс источником сообщений. Указания, является ли интерфейс или диспинтерфейс программируемым интерфейсом, используемым в языке программирования макросов, таких как Word Basic, Visual Basic, Delphi, Object PAL и Excel Basic. Указания, запрещено ли использование интерфейса или диспинтерфейса в языках программирования макросов таких как Word Basic, Visual Basic, Delphi, Object PAL и Excel Basic. Чтобы добавить интерфейсы в составной класс или удалить их, нужно щелкнуть правой кнопкой мыши в облает вкладки Members. На экране появится контекстное меню, в котором нужно выбрать команду Insert Interface или Remove Interface. С помощью контекстного меню можно также установить флаги Source, Default и Restricted. Новые интерфейсы можно выбирать из текущей библиотеки или из библиотек, на которые ссылается текущая библиотека типов.
Тип Variant
Тип Variant предназначен для представления значений, которые могут динамически изменять свой тип. Если любой другой тип переменной зафиксирован, то в переменные типа Variant можно вносить переменные разных типов. Шире всего тип Variant применяется в случаях, когда фактический тип данных изменяется или неизвестен в момент компиляции.
Трассировка исходного кода VCL
Если вы используете соответствующую версию поставки Delphi 4, значит, в нее входят исходные тексты VCL (Visi Component Library). В поставку VCL входят скомпилированными без отладочной информации, что означает, что при отладке вы не сможете пройти код пошагово. Нет особой необходимости трассировать код VCL, но если вы хотите убедиться, что ошибка не в VCL, или посмотреть, как работает функция, придется перекомпилировать модули, которые нужно трассировать, с отладочной информацией.
Совет: Некоторые стандартные модули VCL требуют компиляции с отключенной опцией Overflow Checking для корректной работы. Поэтому при перекомпиляции убедитесь, что эта опция компилятора отключена.
Трассировка исходного текста кода VCL
Давным-давно, когда компьютеры были большими, а именно — лет двадцать назад, отладка заключалась в копании в огромных кипах бумаги с исходными текстами и распечатках результатов работы и потреблении невероятного количества кофеина, а зачастую и анальгина... Современный программист, особенно если он программирует на Delphi, больше не чернорабочий от программирования с крепкими от переворачивания центнеров бумаги мускулами, а "белый воротничок", окруженный разнообразными ''электронными мухобойками", предоставляемыми Delphi.
Интегрированный отладчик Delphi переполнен полезными, не очень полезными и совсем бесполезными возможностями, и кажется, что изучить их просто невозможно. Однако использование отладчика Delphi просто, как апельсин: ведь когда вы компилируете свою программу и запускаете ее из среды Delphi, вы уже пользуетесь встроенным отладчиком, хотя, вероятно, и не подозреваете об этом. Как всегда, 90% проблем решается 10% возможностей программного обеспечения, а потому все разнообразие работы с отладчиком вы можете изучить позднее, при решении оставшихся 10% ваших проблем.
Указатели и адресные функции
Информация, содержащаяся в переменной указательного типа, — это адрес некоторого участка в машинной памяти. Эти значения задаются во время работы программы и могут меняться от одного запуска к другому. Следующие функции обеспечивают доступ к адресной информации в программе и тестирование переменных-указателей.
Функция | Описание |
Addr | Возвращает адрес указанного объекта |
Assigned | Проверяет, равно ли значение процедурной функции Nil |
Ptr | Преобразует адрес в указатель |
Зарезервированное слово Nil указывает значение указателя, который ни на что не указывает. Такие указатели называют неопределенными. В Object Pascal только при определении указателей можно нарушать правило, по которому все указываемые идентификаторы, в том числе идентификаторы типов, должны быть объявлены выше. Здесь можно указать идентификатор еще необъявленного типа, как в следующем примере:
type
PointerType = ^NotYetDefinedType;
Однако необъявленный тип необходимо объявить ниже в том же блоке объявления типов.
Определенный в Object Pascal тип Pointer— это указатель без типа. Обратиться к переменной через такой указатель невозможно (к переменной типа Pointer нельзя дописывать символ "^"). Однако можно задать ей другой указательный тип.
По значениям переменных тип Pointer совместим с остальными указательными типами.
Совет: Во многих языках указательные типы как таковые отсутствуют. Однако в С и C++ они есть и определяются звездочкой перед типом объявляемой переменной. Указатели в C/C++ трактуются наподобие целых переменных. программисты Delphi избегают подобного манипулирования указателями.
Установка точек останова
Точка останова (breakpoint) — своеобразный знак STOP для отладчика (на полосе слева в окне редактора она и выглядит как маленький красный значок). Когда ваше приложение запущено под отладчиком и доходит до строки, в которой находится точка останова, оно прекращает работу и ждет ваших дальнейших распоряжений. Такие точки могут быть условными и безусловными. Отладчик всегда останавливается на точке безусловного останова и может останавливаться в точке условного останова, когда выполнено условие. Интегрированный отладчик Delphi поддерживает два типа условий — логическое и по количеству проходов. Ниже рассмотрены оба типа.
Установить точки останова можно следующими способами: Поместите курсор редактирования на выбранную строку программы и нажмите клавишу команды Toggle Breakpoint (по умолчанию это клавиша <F5>) для установки или удаления точки останова в этой строке. То же самое можно выполнить и с помощью контекстного меню. Выберите команду Run/Add Breakpoint, и откроется диалоговое окно Edit breakpoint (рис 2.15). Для установки простейшей точки останова просто щелкните на кнопке New. Вы также можете использовать поля Filename и Line Number для установки точек останова в другом файле или строке за пределами текущей позиции курсора. Поля Condition и Pass count используются для установки точки условного останова. После установки одной или нескольких точек останова можете использовать окно Breakpoint List для управления ими. Для вызова окна Breakpoint List выберите команду View/Breakpoints (Рисунок 2.16). В этом окне можете щелкнуть на строке конкретной точки правой кнопкой мыши и в контекстном меню отключить точку останова с помощью команды Disable (вновь включить точку останова можно с помощью команды Enable) или удалить ее с помощью команды Delete. Команды View Source и Edit Source активизируют окно с текущим файлом исходного текста, при этом команда Edit Source устанавливает курсор в строку с точкой останова. Команда Properties выводит диалоговое окно Edit breakpoint, показанное на Рисунок 2.15, позволяя тем самым изменять параметры точки останова. Рисунок 2.15. Использование диалогового окна Edit breakpoint для установки новой точки останова. Рисунок 2.16. Использование окна Breakpoint list для управления точками останова.
После щелчка правой кнопкой мыши в окне при невыбранной точке останова выводится контекстное меню, в котором команда Add служит для добавления новой точки, Delete All удаляет все точки останова, а команды Disable All и Enable All отключают или включают все точки останова в списке.
Для превращения безусловной точки останова в условную, необходимо вызвать диалоговое окно Edit breakpoint (см. Рисунок 2.15) и ввести условное выражение или количество проходов в соответствующие поля.
Условное выражение, введенное в поле Condition, может быть любым логическим выражением. По достижении точки останова отладчик вычисляет значение выражения и, если результат ложен, продолжает выполнение программы. Если выражение истинно, выполнение программы приостанавливается. Как обычно, выражение не должно использовать вызов функции. Такие точки останова полезны, если вы можете попасть в интересующий вас фрагмент кода различными путями, но вы хотите остановить выполнение программы только при достижении каких-либо конкретных условий.
Ненулевое значение, введенное в поле Pass count, дает отладчику задание продолжать выполнение программы при прохождении через точку останова, пока через нее не будет выполнено соответствующее количество проходов. При каждом проходе через точку останова отладчик уменьшает значение счетчика на единицу и по достижении нулевого значения программа приостанавливается. Такой метод полезен при работе с циклами, особенно если вы знаете, что ошибка происходит после определенного количества циклов.
Сейчас, когда вы изучили основы технологии отладки, вероятно, у вас возникло желание поставить точку останова у себя в голове и поработать с точками останова в программах. Кстати, один из отличных методов понять, как работает та или иная программа, — проследить за ее пошаговым выполнением, а поскольку ни установка точек останова, ни просмотр или изменение переменных не изменяют текста программы, вы можете работать смело, не опасаясь каким-либо образом "поломать" используемое в учебных целях приложение.
Вариантные записи
Вариантная часть типа record дает возможность по-разному трактовать область памяти, совместно занимаемую вариантами поля:
record
case optional tagfield: required ordinal type of
1: variantnamel: varianttype3;
2, 3: variantname2: varianttype4;
end;
Совет: Термин вариантный в отношении записей не имеет ничего общего с типом Variant, который мы рассмотрим в следующем разделе данной главы. Вариантные поля, несмотря на свое название, никогда не имеют тип Variant. Объявление этого типа в любом месте вариантной части записи запрещено.
Все варианты занимают в памяти одно место. Каждый вариант обозначается некоторой постоянной. При желании можно получать доступ ко всем полям всех вариантов одновременно, однако это может иметь смысл только в наиболее простых случаях, когда точно известно, как именно информация каждого варианта записывается в память.
Каждый вариант обозначается минимум одной константой. Все константы должны быть порядковыми и совместимыми по типу с меткой поля.
Необязательное поле — это идентификатор дополнительного поля в фиксированной части записи, общий для всех вариантов. Обычно с его помощью определяют, когда к какому варианту обращаться.
Необязательное поле можно не указывать, однако порядковый тип необходим. При отсутствии необязательного поля программе придется выбирать подходящий вариант каким-то иным образом.
Данные некоторых типов бессмысленно интерпретировать различным образом, и в Object Pascal на некоторые критические типы наложено соответствующее ограничение. Как следствие, в вариантную часть записи нельзя включать длинные строки и переменные типа Variant, а также структурные переменные, содержащие эти типы.
Совет: В С и C++ эквивалентом вариантному типу записи из Delphi является тип union.
Вариантные значения
При рассмотрении типа Record мы ознакомились с вариантной частью записи, где в одном фрагменте памяти можно хранить информацию нескольких типов. Такой метод недостаточно нагляден. Много ли пользы от того, чтобы найти в памяти действительное значение с фиксированной запятой и интерпретировать его, как целое! Тип Variant (не имеющий ничего общего с вариантной частью записи) более "проворен" и полезен в управлении данными разных типов. Переменным типа Variant можно присваивать любые значения любых целых, действительных, строковых и булевых типов. Для совместимости с другими языками программирования предусмотрена также возможность присвоения этим переменным значений даты/времени и объектов OLE Automation. Кроме того, вариантные переменные могут содержать массивы переменной длины и размерности с элементами указанных типов.
Все целые, действительные, строковые, символьные и булевы типы совместимы с типом Variant в отношении операции присваивания. Вариантные переменные можно сочетать в выражениях с целыми, действительными, строковыми, символьными и булевыми; при этом все необходимые преобразования Delphi выполняет автоматически. Можно произвольно задавать для выражении тип Variant в форме Variant (X).
В Object Pascal определены два особых значения Variant. Значение Unassigned применяется для указания, что вариантной переменной пока не присвоено значение какого бы то ни было типа. Значение Null указывает на наличие в переменной данных неизвестного типа или потерю данных. Разницу между этими двумя значениями трудно уловить. Значение Unassigned присваивается вариантным переменным автоматически при их создании, независимо от того, локальная это переменная или глобальная, и является ли она частью другой, структурной, переменной, такой как запись или массив. Unassigned означает, что к данной вариантной переменной еще не обращались. Null же означает, что к вариантной переменной обращались, но не ввели в нее никакой информации. Таким образом, Null указывает, что значение вариантной переменной недействительно или отсутствует.
Вариантные переменные предоставляют широкие возможности формирования выражений с переменными разных типов. Однако за это приходится платить большим, по сравнению с жестко задаваемыми типами, расходом памяти. К тому же на выполнение операций с вариантными переменными требуется больше времени.
Интересна проблема использования вариантной переменной как массива. Элементы этого массива должны быть одного типа. На первый взгляд, это вполне естественное условие. Однако элементам массива можно присвоить и тип Variant! Тогда каждый элемент сможет содержать информацию разных типов, в том числе массив Variant. Как правило, вариантные массивы создаются с помощью процедуры VarArrayCreate.
Для передачи двоичной информации между контроллерами автоматизации OLE и серверами обычно применяются вариантные массивы с элементами varByte. Вариантные массивы типа varByte не могут подвергаться никаким преобразованиям. Нельзя также переформатировать содержащуюся в них двоичную информацию. Эффективный доступ к ним осуществляется с помощью процедур VarArrayLock и VarArrayUnlock.
Элементы вариантного массива не могут иметь тип varString. Для создания вариантных массивов со строковыми элементами следует выбрать тип varOleStr.
VersionInfo
Вкладка Versionlnfo дает возможность добавить к выполняемому модулю или DLL информацию о версии— Major Version, Minor Version и File Description.
Действительно полезную возможность предоставляет Auto-increment build number, заставляя Delphi всякий раз увеличивать номер выпуска при компиляции программы.
Раздел Module Attributes позволяет включать флаги, такие как Debug Build, в приложение. Выбор опций не влияет на процесс компиляции — они используются только в информативных целях.
Включение в код отладочной информации
Перед началом отладки следует убедиться, что в приложение включена отладочная информация Delphi.
Для компиляции проекта с отладочной информацией следует выполнить команду Project/Options и в диалоговом окне Project Options выбрать вкладку Compiler (Рисунок 2.9).
Рисунок 2.8. Окно редактора с отладочными значками Рисунок 2.9 Вкладка Compiler диалогового окна Project Options
Включение отладочной информации регулируется следующими установками Debug Information. Опция контролирует включение отладочной информации. При отключении этой опции вы не сможете трассировать код или ставить точки прерывания в любом модуле. Опция эквивалентна директивам компилятора $D и $DEBUGINFO Local Symbols. Опция контролирует включение информации о локальных переменных, декларированных, например, внутри функций, процедур и раздела implementation. Вряд ли у вас возникнет необходимость в отключении этой опции, тем более что она игнорируется при выключенной предыдущей опции. Эквивалентные директивы компилятора— $L и $LOCALSYMBOLS. Symbol Info. Эту опцию нельзя целиком отнести к разряду отладочных, так как ее действие направлено на броузер объектов, а не на встроенный отладчик. Если опция включена, броузер объектов сможет выводить информацию для объектов, определенных в модулях Опция игнорируется при выключенных предыдущих двух опциях Эквивалентные директивы компилятора — $Y и $REFERENCEINFO Обычно вы будете включать опции Debug Information и Local Symbols для пошаговой трассировки приложения. Однако, как упоминалось ранее, вы можете отключить отладочную информацию для некоторых модулей (просто используйте соответствующую директиву в начале модуля).
unit MyUnit;
{$D-}
interface
...
Использование директивы $D- автоматически отключает опции Local Symbols и Symbol Info, так что вам не надо отключать их отдельно.
Совет: Если вы распространяете модули Delphi в виде DCU-файлов (например, VCL) и не распространяете их исходных текстов позаботьтесь о том, чтобы в скомпилированных модулях не содержалась отладочная информация
Вывод на консоль
Еще один способ вывода отладочной информации— вывод на консоль с использованием процедур Write и WriteLn. Вы можете конвертировать проект в консольное приложение, например, выбрав соответствующую опцию (команду Project/Options, вкладку Linker и опцию Generate Console Application) или поместив директиву $APPTYPE CONSOLE в главный DPR-файл. Учитывая, что ваше приложение— не консольное, воспользуйтесь возможностями условной компиляции и используйте директиву $APPTYPE как показано ниже:
{$ifdef Debug}
{$APPTYPE CONSOLE}
{$endif}
Теперь вывод на консоль будет осуществляться только в отладочной версии вашего приложения.
Если вы попытались использовать функцию Write или WriteLn и получили сообщение об ошибке I/O Еггог, значит, вы забыли сделать проект консольным приложением.
Обратите внимание, что здесь применяется тот же код, что и раньше, но теперь мы используем вывод на консоль вместо ShowMessage. Убедитесь, что вы создаете консольное приложение, и измените обработчик так, как показано ниже.
procedure TFormI.ButtonlClick(Sender: T0bject);
var MemStat: TMemoryStatus;
begin
MemStat.dwLength:= SizeOf(TMemoryStatus);
GlobalMemoryStatus(MemStat);
with MemStat do
begin
WriteLn(Format('Memory load: %d%%',[dwMemoryLoad]));
WriteLn(Format('Total physical: %d',[dwTotalPhys]));
WriteLn(Format('Available physical: %d',[dwAvailPhys]));
WriteLn(Format('Total page file: %d',[dwTotalPageFile]));
WriteLn(Format('Available page file: %d',[dwAvailPageFile]));
WriteLn(Format('Total virtual: %d',[dwTotalVirtual]));
WriteLn(Format('Available virtual: %d',[dwAvailVirtual]));
end;
end;
Результат показан на Рисунок 2.24.
Рисунок 2.24. Использование консоли для вывода отладочной информации.Опытные пользователи Pascal заметят, что функция Format использовалась там, где это не было необходимо (WriteLn имеет свои возможности форматирования). Однако я везде использую Format как мощный инструмент; кроме того, используя везде одну лишь функцию Format, я избавляюсь от необходимости помнить два набора правил форматирования.
Вывод отладочной информации в форме
Один из способов вывода такой информации — ее вывод непосредственно в форме. Обычно проще всего создать компонент TLabel или подобный ему для непосредственного вывода информации. В таком случае выведенная информация не потеряется даже при перерисовке формы.
Посмотрите на описания функций ExtractFileDir и ExtractFilePath в справочной системе Delphi 4. Я не берусь точно судить по документации о различии между этими функциями, но я знаю, что мне делать. Я создаю новое приложение (выбрав пункт меню File/New Application) и помещаю в главную форму элемент TButton и два элемента TLabel (форма будет выглядеть так, как на Рисунок 2.20).
Дважды щелкните на кнопке TButton и добавьте код к обработчику события OnClick.
procedure TFormI.ButtonlClick(Sender: TObject);
begin
Labell.Caption:= ExtractFileDir(Application.ExeName);
Label2.Caption:= ExtractFilePath(Application.ExeName);
end;
(Application. ExeName возвращает полное имя файла приложения). Нажмите клавишу <F9> для компиляции и запуска приложения и щелкните на кнопке. Теперь вам должно быть ясно, чем различаются эти две функции.
Недавно у меня возникла проблема с чужой DLL, исходного кода которой я, естественно, не имел. Странным было то, что эта DLL выцелела при загрузке и не освобождала большой фрагмент виртуальной памяти. Я создал маленькое приложение, в котором после каждого щелчка на кнопке сообщалось, сколько виртуальной памяти свободно. Мне хотелось сохранять предыдущие результаты, а потому, я использовал элемент управления TMemo и добавлял в него новые строки с результатами.
Чтобы посмотреть, как это делается, создадим новое приложение и разместим в форме элементы управления TMemo и TButton (и не забудем установить значение свойства TMemo.ScrollBars равным ssVertical). Ваша форма будет выглядеть так, как на Рисунок 2.21.
В обработчик события OnClick добавьте следующий код.
procedure TFormI.ButtonlClick(Sender: TObject);
var
MemStat: TMemoryStatus;
begin
VirtualAlloc(nil, 1000000, MEM_RESERVE, PAGE_READWRITE);// 1
MemStat.dwLength:= SizeOf(TMemoryStatus); // 2
GlobalMemoryStatus(MemStat); // 3
Memol.Lines.Add(IntToStr(MemStat.dwAvailVirtual)); // 4
end;
Не беспокойтесь о деталях вызова API-функции VirtualAlloc в строке 1. Здесь ее вызов требует от операционной системы зарезервировать миллион байтов памяти для дальнейшего использования. API-функция GlobalMemoryStatus возвращает информацию об использовании памяти приложением и системой в целом. Информация возвращается в переменной MemStat, представляющей собой запись типа TMemoryStatus. Перед вызовом GlobalMemoryStatus вы передаете системе информацию о размере структуры, как в строке 2, а затем вызываете функцию (строка 3) и выводите информацию в TMemo в строке 4.
Скомпилируйте и запустите программу, щелкните несколько раз на кнопке - и увидите, что виртуальная память уменьшается примерно на один мегабайт при каждом щелчке, как и ожидалось. На Рисунок 2.23 показана форма после нескольких щелчков на кнопке.
Используя этот метод (без вызова VirtualAlloc), я выяснил, что на самом деле DLL затребовала около 60 Мбайт (!) виртуальной памяти при загрузке и не освободила ее. Даже притом, что Windows 95 предоставляет каждому приложению двухгигабайтовое адресное пространство, потерю 60 Мбайт сложно проигнорировать...
What_new
Что нового в Delphi 5
В Delphi 5 появились следующие новые возможности и улучшения (не все они доступны в различных версиях рограммы):
ADO Dataset (Enterprise и дополнения к Professional версии)
Технология ADO предоставляет альтернативу Borland Database Engine (BDE) и предоставляет доступ к базам данных написанных при помощи Microsoft's Active Data Objects (ADO) технологии.
Data Module Designer (во всех версиях)
Data Module Designer это новый визуальный инструмент разработки, который облегчает создание и использование модулей данных.
InterBase Express (Professional и Enterprise версии)
InterBase Express (IBX) компоненты лучше всего интегрируют InterBase с Delphi и не требуют наличия Borland Database Engine (BDE).
Улучшения в MIDAS (версия Enterprise)
Технология поддержки multi-tier database (MIDAS) приложений теперь включает в себя неопределенные удаленные модули данных и новый InternetExpress компоненты для создания web приложений, в которых броузеры взаимодействуют с данными поступающими из MIDAS application server.
Изменения в CORBA (версия Enterprise)
CORBA была улучшена для работы с VisiBroker для C++ ORB version 3.32. В дополнении, был сокращен трафик посланий, потому что клиент CORBA теперь не простукивает сервер для поддержания связи. Связь теперь обрывается автоматически если клиент слишком долго не пользовался ею.
Новые возможности отладчика (Во всех версиях)
Встроенный отладчик теперь имеет новые возможности, в том числе возможность устанавливать несколько опций для каждого процесса отладки, новые позиции в меню RUN и дополнительные опции отладки.
Улучшения в VCL (Все версии)
VCL получила множество новых объектов, свойств и событий объединяя таким образом новые технологии и пожелания пользователей.
Кадры (Все версии)
Кадры это специальный вариант Формы, которые могут быть установлены на Форму или другие Кадры. Их можно создать путем выбора в меню File|New Frame или File|New, а затем двойное нажатие на Frame.
Изменяемые показатели рабочей среды (Все версии)
Теперь вы сможете менять различные стили рабочей среды, называть их и записывать.
Списки "Что сделать" (Professional и Enterprise версии)
Списки "Что сделать" являются списком заданий которые должны быть выполнены для данного проекта. Вы можете добавлять задания в исходный код или непосредственно в список.
Категории своств в Object Inspector (Все версии)
Теперь Object Inspector позволяет показывать и фильтровать свойства и события по категориям.
Изображения в всплывающих списках в Object Inspector (Все версии)
Поддержка изображений была добавлена в Object Inspector, и теперь вы можете видеть изображения, такие как курсоры, списки картинок и цвета во всплывающих списках.
Новые возможности Project Manager (Все версии)
Project Manager упрощает работу с проектами, позволяя вам переносить файлы из папок Windows или одни проекты в другие. Так же можно копировать части проектов из одного в другой и добавлять файлы любого типа. Файлы ресурсов которые вы добавляете к вашим проектам компилируются в RES файлы и связываются с проектом автоматически.
TeamSource (Версия Enterprise)
TeamSource это новый рабочий инструмент. Для дополнительной информации смотрите TeamSrc.hlp в каталоге HELP. TeamSource это отдельный продукт и требует отдельной инсталляции.
Улучшения в ActiveX (Professional и Enterprise версии)
Импортированные COM сервера могут быть примененны как компоненты для визуальной разработки. И еще другие возможности были добавлены для упророщения разработки ActiveX.
Новые помощьники (Professional и Enterprise версии)
Два новых помощьника для создания control panel applets и консольных приложений.
Улучшения Редактора (Все версии)
Изменение настроек Редактора теперь находится как отдельная комманда (Tools|Editor Options).
Новый броузер проектов (Все версии)
Новый броузер проектов может показывать символы в ваших проектах (project-wide) или показывать все сиволы (VCL-wide).
Формы могут быть сохранены как текст (Все версии)
Файлы Форм (DFM) теперь по умолчанию могут быть записаны как тестовые файлы, а не двоичные. Нажмите правой кнопкой на форме и уберите выделение с Text DFM чтобы сохранять файлы в двоичном коде.
Возможность автоматического создания форм (Все версии)
Возможность на странице Tools|Environment Options Preferences позволит вам выбрать хотите вы или нет чтобы формы создавались автоматически. Если возможность не выбрана, то формы добавленные к проекту складываются в список Доступных Форм, а не в список Авто-Создаваемых Форм.
IDE коммандная строка (Все версии)
Вы можете забускать IDE из коммандной строки и использовать несколько новых возможностей.
Интернациональные инструменты (Версия Enterprise)
Теперь есть новый набор инструментов названный Integrated Translation Environment (ITE) (Интегрированная среда перевода), который облегчает локализацию программ и одновременную разработку нескольких локальных версий.
Компоненты NetMasters (Professional и Enterprise версии)
Компоненты NetMasters теперь стали отдельной страницей (названы FastNet) в палитре компонентов.
Кроме того изменения в Help menu (Все версии)
Запись в Logфайл
Под силовой отладкой (brute-force debugging), отладкой "в лоб", понимаются методы отладки, основанные не на возможностях отладчиков, а на трюках, родословная которых, пожалуй, восходит к временам Атанасова и Лебедева, создававших первые ЭВМ по обе стороны океана.
При разработке программ часто нет необходимости в полной отладке, просто хочется убедиться в том, что какая-либо функция работает так, а не иначе (я весьма часто попадаю в подобные ситуации, когда использую малознакомые функции API или плохо или вовсе недокументированные методы объектов, и мне надо провести эксперимент, чтобы выяснить, так ли я представляю работу функции).
В этих случаях проще забыть об отладчике и просто добавить пару строк кода для вывода информации. Для этого есть много путей, и о некоторых из них будет рассказано ниже.
ПРЕДОСТЕРЕЖЕНИЕ: Большинство таких методов — из серии "быстро и грязно", и я бы не рекомендовал заменять ими описанные ранее методы тестирования и отладки.
Запись в Logфайл
Запись отладочной информации в файл протокола (Log-файл) существенно отличается от предыдущих приемов записи, так как это уже нельзя назвать "быстро и грязно". Это отличная технология, которую можно использовать в любом приложении.
Запись в файл протокола выполняется так же, как и вывод на консоль, но вместо WriteLn (. . . ) используется WriteLn (LogFile, . . . ), где LogFile — имя файловой переменной типа TextFile. Надо также не забывать открывать этот файл в начале работы приложения и закрывать — в конце. Проще всего этого добиться, поместив соответствующий код в свой модуль, который благодаря возможности условной компиляции подключается только в отладочной версии вашей программы.
Записи
С помощью зарезервированного слова record (запись) в одном типе можно объединять данные разных типов. Общий синтаксис объявления этого типа выглядит следующим образом:
record
fieldnamel: fieldtypel;
fieldname2, fieldname3: fieldtype2;
case optional tagfield: required ordinal type of
1: variantnamel: varianttype3;
2, 3: variantname2: varianttype4;
end;
Данное объявление состоит из фиксированной и вариантной частей. Однако вовсе не обязательно вставлять в одно объявление записи обе эти части. Обычно удобнее работать с каждой из этих частей отдельно.