24

Главные окна Delphi

Вверху во всю ширину экрана окно управления проектом и средой разработки Delphi.

При его сворачивании сворачиваются и все остальные. Слева сверху – древо объектов (Object TreeView). В нем отображается иерархия компонентов. Слева снизу - Инспектор объектов (ObjectInspector). В нём задаются свойства составляющих программу компонентов. И наконец, в центре одно поверх другого два окна Delphi, окно формы будущей программы и окно модуля. В модуле содержится программный код. Форма является визуальным прообразом будущей программы.

Свойства формы. Размеры - ширина и высота в пикселах, свойства Width и Height. Изменяем их мышкой, двигая края Формы, затем устанавливаем более точные значения в Инспекторе.

Положение на экране - свойства Top и Left. Это расстояния в пикселях от левой и верхней границы экрана соответственно. Cвойство Position, с помощью которого можно настроить автоматическое появление Формы в нужном месте. При значениях poDesktopCenter и poScreenCenter форма появится в центре рабочего стола или центре экрана.

Также возможно запрограммировать появление Формы в нормальном, минимизированном или максимизированном состоянии. За это отвечает свойство WindowState - значения wsNormal, wsMinimized и wsMaximized соответственно.

Не у всех окон в заголовке есть кнопки свернуть, развернуть, закрыть. Их наличием или отсутствием управляет свойство BorderIcons. В Инспекторе слева от него маленький плюсик, открывающий признак наличия или отсутствия нужной кнопки. True - кнопка будет, False - нет.

Можно управлять также границами Формы. Для этого служит свойство BorderStyle. При значении bsSizeable - обычная Форма, значение по умолчанию; bsNone - Форма вообще не будет иметь границ, включая строку заголовка; bsSingle - Форма не может менять размеры, но может свернуться или развернуться.

Сохранение проекта. В начале работы над новым проектом командой меню File -» Save All (или соответствующей кнопкой на главном окне) сохраним проект в специально для него созданную папку. Проект в целом сохраняется в файле с именем Project1. Форма функционирует вместе с модулем. Если модулей в проекте несколько, для каждого из них Delphi создаст отдельный файл, и предложит его сохранить под именем Unit1, Unit2 и т.д. И для файла проекта, и файлов модулей можно дать и своё, более осмысленное название.

Команда File -» Close All закрывает проект. Открыть файл модуля можно командой Open.... Если открыть модуль, мы сможем нормально работать, но кнопка запуска программы окажется неактивной. Поэтому сначала нужно открывать файл проекта. В папке с проектом содержатся несколько типов файлов:

файл проекта (.dbr) - это текстовый файл используется для хранения информации о формах и модулях. В нем содержатся операторы инициализации и запуска программы на выполнение;

файл модуля (.pas) - соответствующий файл модуль для хранения кода;

файл формы (.dfm) - это двоичный файл, который создается для хранения информации о формах;

файл опций проекта (.dof) - в нем хранится установки опций проекта;

файл конфигурации проекта (.cfg) в нем хранятся установки проекта.

файл ресурсов (.res) содержит пиктограмму и прочие ресурсы.

файл группы файлов (.bpg) для создания групп файлов.

резервные копии (~dp,~df,~pa).

Листинг программы на Delphi

Стандартный листинг:

unit Unit1;

Interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs;

type

TForm1 = class(TForm)

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

Implementation

{$R *.dfm}

end.

Рассмотим подробнее структуру листинга:

unit Unit1 - название модуля (pas-файла);

interface - начало раздела, в котором могут подключаться списки подключаемых модулей, объявление типов, констант и т.д.;

uses - список подключаемых модулей. Название модулей вносится через запятую;

type - объявление типа формы. Здесь содержатся все объекты на форме;

private - раздел объявления переменных, доступных только в текущем модуле;

public - раздел объявления общедоступных переменных;

var - раздел объявления переменных (объявленные здесь переменные будут доступны всем процедурам и функциям);

implementation - это, собственно, и есть раздел для программного кода;

{$R *.dfm} - директива для компилятора, определяющая файл ресурса.

Далее идут функции и процедуры программы. Любой листинг программы на delphi завершается оператором end.

На этом описание стандартного листинга программы на delphi окончено. Далее этот листинг надо наполнить программным кодом:

unit Unit1;

Interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Label1: TLabel;

Edit1: TEdit;

Label2: TLabel;

Edit2: TEdit;

Button1: TButton;

procedure Button1Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

Implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);

var

a,b,c:real;

begin

a:=StrToFloat(Edit1.Text);

b:=StrToFloat(Edit2.Text);

c:=a+b;

ShowMessage(FloatToStr(c));

end;

end.

В данном примере используется 5 компонентов (Label1, Edit1, Label2, Edit2, Button1). В листинге они отображены в разделе type, под объявлением типа формы.

После списка компонентов в программе идет список процедур и функций модуля, например:

procedure Имя_процедуры_1(СписокПараметров);

function Имя_функции_1(СписокПараметров) : Тип;

В нашем случае объявлена процедура Button1Click, т.е. процедура обработчика события нажатия на Button1, которая будет выполнена, если будет нажата Button1.

Дальше сравнивая данный листинг программы со стандартным, мы видим, что между директивой «{$R *.dfm}» и оператором «end.» находится сама процедура. При ее добавлении, она имела следующий вид:

procedure TForm1.Button1Click(Sender: TObject);

begin

end;

Обратите внимание, что в разделе написания кода (между директивой «{$R *.dfm}», стоящей после «implementation», и оператором «end.») содержатся сами процедуры или функции (с исполняемым кодом), а в разделе type, после объявления компонентов лишь их объявления. Причем, название и список параметров (для функции также и тип) объявленной процедуры (функции) не должны отличаться от названия и списка параметров процедуры (функции) в области написания кода, за исключением того, что в области написания кода перед именем процедуры (функции) должно стоять название класса текущей формы через точку (в данном случае - TForm1), т.е.:

В области объявления: procedure Button1Click(Sender: TObject);

В области написания кода: procedure TForm1.Button1Click(Sender: TObject);

У процедуры в области написания кода есть начало и конец, обозначающиеся соответственно «begin» и «end;», между которыми и содержится код, выполняемый процедурой.

Для объявления локальных переменных (будут доступны только в данной процедуре) необходимо между названием процедуры и ключевым словом «begin» вставить ключевое слово «var» и после слова «var» объявить переменные (задать имя и тип):

procedure TForm1.Button1Click(Sender: TObject);

var

a,b,c:real;

begin

end;

Аналогично задаются переменные для функций.

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

ShowMessage(FloatToStr(StrToFloat(Edit1.Text)+StrToFloat(Edit2.Text)));

Компоненты Delphi

Компоненты располагаются на соответствующих вкладках палитры компонентов на главном окне. Все основные компоненты Delphi находятся на первых четырёх вкладках. Их названия всплывают в виде подсказок при наведении мышки на пиктограммы. Чтобы перенести компонент на форму, нужно щёлкнуть его мышкой, и затем щёлкнуть в том месте формы, где его предполагается разместить.

Пикто-грамма	Имя	Назначение
Вкладка «Standard»
	MainMenu	Главное меню программы. Компонент способен создавать и обслуживать сложные иерархические меню.
	PopupMenu	Всплывающее меню. Обычно это меню появляется после нажатия правой кнопкой мыши.
	Label	Метка. Используется для размещения не очень длинных сообщений в виде статического текста
	Edit	Строка ввода. Предназначена для ввода пользователем текстовой информации в виде одной строки.
	Memo	Многострочный текстовый редактор. Используется для ввода и отображения многострочного текста без функций форматирования.
	Button	Командная кнопка. Используется для реализации в программе команд с помощью обработчика события onclick этого компонента.
	CheckBox	Независимый переключатель. Используется его свойство Checked (отмечено), имеющее значения true или false, меняющееся при щелчке мышью.
	RadioButton	Зависимый переключатель. Используется для выбора одного из нескольких вариантов. Для этого компонент объединяется как минимум с одним или компонентом в группу. Щелчок по компоненту приводит к его выделению и снятию выделения ранее выбранного компонента.
	ListBox	Список выбора. Содержит список предлагаемых вариантов (опций) и даёт возможность проконтролировать текущий выбор.
	ComboBox	"Выпадающий" список выбора. Представляет собой комбинацию компонентов Edit и ListBox.
	GroupBox	Контейнер группы компонентов. Используется для группировки нескольких связанных по смыслу компонентов.
	RadioGroup	Группа зависимых переключателей. Содержит специальные свойства для обслуживания нескольких связанных зависимых переключателей.
	Panel	Панель. Этот компонент, как и GroupBox, служит для объединения нескольких компонентов.
Вкладка «Additional»
	StringGrid	Таблица, содержащая строки. Компонент StringGrid предназначен в первую очередь для отображения таблиц текстовой информации.
	Bevel	Фаска. Имеет декоративное назначение.
	Splitter	Разделитель. Предоставляет пользователю возможность перемещать границы, разделяющие различные визуальные компоненты, изменяя их относительные размеры.

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

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

Основное свойство компонента - Items. Его заполнение производится с помощью Конструктора Меню, вызываемого двойным щелчком на компоненте MainMenu или нажатием кнопки с многоточием рядом со свойством Items в окне Инспектора Объектов.

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

Другой путь ввода нового раздела - использование контекстного меню, всплывающего при щелчке правой кнопкой мыши. Если вы предварительно выделите какой-то раздел меню и выберите из контекстного меню команду "Insert", то рамка нового раздела вставится перед ранее выделенным. Из контекстного меню вы можете также выполнить команду "Create Submenu", позволяющую ввести подменю в выделенный раздел.

При выборе нового раздела вы увидите в Инспекторе Объектов множество свойств данного раздела. Дело в том, что каждый раздел меню, т.е. каждый элемент свойства Items, является объектом типа TMenuItem, обладающим своими свойствами, методами, событиями.

Свойство Caption обозначает надпись раздела. Заполнение этого свойства подчиняется тем же правилам, что и заполнение аналогичного свойства в кнопках. Если вы в качестве значения Caption очередного раздела введете символ минус «-», то вместо раздела в меню появится разделитель.

Свойство Name задает имя объекта, соответствующего разделу меню. Очень полезно давать этим объектам осмысленные имена, так как иначе вы скоро запутаетесь в ничего не говорящих именах типа "N21". Куда понятнее имена типа "MFile", "MOpen", "MSave" и т.п.

Свойство Shortcut определяет клавиши быстрого доступа к разделу меню — «горячие» клавиши, с помощью которых пользователь, даже не заходя в меню, может в любой момент вызвать выполнение процедуры, связанной с данным разделом. Чтобы определить клавиши быстрого доступа, надо открыть выпадающий список свойства Shortcut в окне Инспектора Объектов и выбрать из него нужную комбинацию клавиш.

PopupMenu - контекстное меню привязано к конкретным компонентам. Оно всплывает, если во время, когда данный компонент в фокусе, пользователь щелкнет правой кнопкой мыши. Обычно в контекстное меню включают те команды главного меню, которые в первую очередь могут потребоваться при работе с данным компонентом.

Контекстному меню соответствует компонент PopupMenu. Поскольку в приложении может быть несколько контекстных меню, то и компонентов PopupMenu может быть несколько. Оконные компоненты: панели, окна редактирования, а также метки и др. имеют свойство PopupMenu, которое по умолчанию пусто, но куда можно поместить имя того компонента PopupMenu, с которым будет связан данный компонент.

Формирование контекстного всплывающего меню производится с помощью Конструктора Меню, вызываемого двойным щелчком на PopupMenu, точно так же, как это делалось для главного меню. Работа с PopupMenu почти не отличается от работы с MainMenu.

Label - используется для отображения различных надписей на форме. Отображаемые тексты определяются значением свойства Caption. Его можно устанавливать в процессе проектирования или задавать и изменять программно во время выполнения приложения. Например:

Label1.Caption := 'Новый текст';

Если требуется отобразить числовую информацию, можно воспользоваться функциями FloatToStr и IntToStr, переводящими соответственно числа с плавающей запятой и целые в строку. Для формирования текста, состоящего из нескольких фрагментов, можно использовать операцию «+», которая для строк означает их склеивание. Например, если в программе имеется целая переменная I, отображающая число сотрудников некоторой организации, то вывести в метку Label1 информацию об этом можно оператором:

Label1.Caption := 'Число сотрудников: '+IntToStr(I);

Цвет фона определяется свойством Color, а цвет надписи — подсвойством Color свойства Font.

Для Label цвет и шрифт - единственно доступные элементы оформления надписи. Размещение на форме определяется, в частности, свойствами Тор (координата верхнего края), Left (координата левого края), Height (высота), Width (ширина). Имеются также свойства, определяющие изменение размера компонента при изменении пользователем во время выполнения приложения размеров окна. Это общие свойства всех оконных компонентов: Align (выравнивание компонента по всей верхней, левой, правой, нижней частям контейнера или по всей его клиентской области), Anchors (привязка сторон компонента к сторонам контейнера), Constraints (ограничения допустимых изменений размеров). Учтите, что использование в свойстве Anchors одновременной привязки компонента к противоположным сторонам контейнера приведет к растягиванию или сжатию компонента при изменении пользователем размеров окна. Чтобы избежать этих неприятностей, надо в обработку события формы OnResize вставить операторы, перерисовывающие компоненты методом Repaint.

Размер меток Label и StaticText определяется также свойством AutoSize. Если это свойство установлено в true, то вертикальный и горизонтальный размеры компонента определяются размером надписи. Если же AutoSize равно false, то выравнивание текста внутри компонента определяется свойством Alignment, которое позволяет выравнивать текст по левому краю, правому краю или центру клиентской области метки. В панели Panel также имеется свойство AutoSize, но оно не относится к размерам надписи Caption. Однако, свойство выравнивания Alignment работает и для панели.

В Label имеется свойство Wordwrap — допустимость переноса слов длинной надписи, превышающей длину компонента, на новую строчку. Чтобы такой перенос мог осуществляться, надо установить свойство WordWrap в true, свойство AutoSize в false (чтобы размер компонента не определялся размером надписи) и сделать высоту компонента такой, чтобы в нем могло поместиться несколько строк. Если WordWrap не установлено в true при AutoSize равном false, то длинный текст, не помещающийся в рамке метки, просто обрезается.

Edit – строка ввода. В компоненте Edit вводимый и выводимый текст содержится в свойстве Text. Это свойство можно устанавливать в процессе проектирования или задавать программно. Выравнивание текста невозможно. Перенос строк тоже невозможен. Текст, не помещающийся по длине в окно, просто сдвигается и пользователь может перемещаться по нему с помощью курсора.

Строки ввода снабжены многими функциями, свойственными большинству редакторов. Например, в них предусмотрены типичные комбинации «горячих» клавиш: копирование выделенного текста в буфер обмена, вырезание выделенного текста в буфер, вставка текста из буфера в позицию курсора, отмена последней команды редактирования.

Свойство AutoSelect определяет, будет ли автоматически выделяться весь текст при передаче фокуса в окно редактирования. Его имеет смысл задавать равным true в случаях, когда при переключении в данное окно пользователь будет скорее заменять текущий текст, чем исправлять его. Имеются также свойства только времени выполнения SelLength, SelStart, SelText, определяющие соответственно длину выделенного текста, позицию перед первым символом выделенного текста и сам выделенный текст. Например, если в окне имеется текст «выделение текста» и в нем пользователь выделил слово «текста», то SelLength = 6, SelStart = 10 и SelText = 'текста'. Если выделенного текста нет, то свойство SelStart просто определяет текущее положение курсора.

Строки ввода можно использовать и просто как компоненты отображения текста. Для этого надо установить в true их свойство ReadOnly и целесообразно установить AutoSelect в false. В этом случае пользователь не сможет изменять отображаемый текст и окно редактирования становится подобным меткам. Но имеются и определенные отличия. Во-первых, окна редактирования оформлены несколько иначе. А главное — окна редактирования могут вмещать текст, превышающий их длину. В этом случае пользователь может прокручивать этот текст, перемещая курсор в окне. Такими особенностями не обладает ни одна метка.

Для вывода, ввода и редактирования чисел необходимо использовать функции взаимного преобразования строк и чисел. Для вывода это описанные при рассмотрении меток функции FloatToStr и IntToStr. При вводе это функции StrToFloat — преобразование строки в значение с плавающей запятой, и StrToInt — преобразование строки в целое значение. Если вводимый текст не соответствует числу (например, содержит недопустимые символы), то функции преобразования генерируют исключение EConvertError.

Если вы хотите, чтобы пользователь мог вводить в окно редактирования Edit только цифры и символ точки, вы можете в обработчик события OnKeyPress этого компонента вставить следующий код:

if not (Key in ['0'..'9', ',']) then Key := #0;

Свойство MaxLength определяет максимальную длину вводимого текста. Если MaxLength = 0, то длина текста не ограничена. В противном случае значение MaxLength указывает максимальное число символов, которое может ввести пользователь.

Свойство Modified, доступное только во время выполнения, показывает, проводилось ли редактирование текста в окне. Если вы хотите использовать это свойство, то в момент начала работы пользователя с текстом Modified надо установить в false. Тогда при последующем обращения к этому свойству можно по его значению (true или false) установить, было или не было произведено редактирование.

Свойство PasswordChar позволяет превращать окно редактирования в окно ввода пароля. По умолчанию значение PasswordChar равно #0 — нулевому символу. В этом случае это обычное окно редактирования. Но если в свойстве указать иной символ (например, символ звездочки «*»), то при вводе пользователем текста в окне будут появляться именно эти символы, а не те, которые вводит пользователь.

Memo - является компонентом для редактирования многострочного текста. Он так же, как и окно Edit, снабжен многими функциями, свойственными большинству редакторов. В нем предусмотрены типичные комбинации «горячих» клавиш.

В компоненте Memo формат (шрифт, его атрибуты, выравнивание) одинаков для всего текста и определяется свойством Font. Если вы сохраните в файле текст, введенный или отредактированный пользователем, то будет создан текстовый файл, содержащий только символы и не содержащий элементов форматирования. При последующем чтении этого файла в Memo формат будет определяться текущим состоянием свойства Font компонента Memo, а не тем, в каком формате ранее вводился текст.

Основное свойство компонента Memo - Lines, содержащее текст окна в виде списка строк и имеющее тип TStrings. Начальное значение текста можно установить в процессе проектирования, нажав кнопку с многоточием около свойства Lines в окне Инспектора Объектов. Перед вами откроется окно редактирования списков строк. Вы можете редактировать или вводить текст непосредственно в этом окне.

Во время выполнения приложения вы можете заносить текст в окно редактирования с помощью методов свойства Lines типа TStrings. Этот тип широко используется в свойствах многих компонентов и его описание вы можете найти в во встроенной справке Delphi. Здесь коротко укажем только на его основные свойства и методы, используемые в свойстве Lines.

Весь текст, представленный одной строкой типа String, внутри которой используются разделители типа символов возврата каретки и перевода строки, содержится в свойстве Text.

Доступ к отдельной строке текста можно получить с помощью свойства Strings[Index: Integer]. Индексы, как и везде в Delphi, начинаются с 0. Так что Memo1.Lines.Strings[0] - это текст первой строки. Учтите, что если окно редактирования изменяется в размерах при работе с приложением и свойство WordWrap = true, то индексы строк будут изменяться при переносах строк, так что в этих случаях индекс мало о чем говорит.

Свойство только для чтения Count указывает число строк в тексте.

Для очистки текста в окне надо выполнить процедуру Clear. Этот метод относится к самому компоненту, а не к его свойству Lines.

Для занесения новой строки в конец текста окна редактирования можно воспользоваться методами Add или Append свойства Lines. Для загрузки текста из файла применяется метод LoadFromFile. Сохранение текста в фале осуществляется методом SaveToFile.

Загрузка в окно Memo1 текста из файла может осуществляться командой:

Memo1.Lines.LoadFromFile ('text.txt');

Сохранение текста в файле может осуществляться командой:

Memo1.Lines.SaveToFile('text.txt');

Свойство SelStart компонента Memo указывает позицию курсора в тексте или начало выделенного пользователем текста. Свойство CaretPos указывает на запись, поле X которой содержит индекс символа в строке, перед которым расположен курсор, а поле Y - индекс строки, в которой находится курсор. Таким образом, учитывая, что индексы начинаются с 0, значения Memo1.CaretPos.Y+1 и Memо1.CaretPos.X+1 определяют соответственно номер строки и символа в ней, перед которым расположен курсор.

Button - Простейший и наиболее часто используемый компонент. Основное с точки зрения внешнего вида свойство кнопки - Caption (надпись). В надписях кнопок можно предусматривать использование клавиш ускоренного доступа, выделяя для этого один из символов надписи. Перед символом, который должен соответствовать клавише ускоренного доступа, ставится символ амперсанта «&». Этот символ не появляется в надписи, а следующий за ним символ оказывается подчеркнутым. Тогда пользователь может вместо щелчка на кнопке нажать в любой момент клавишу Alt совместно с клавишей выделенного символа.

Например, если в вашем приложении имеется кнопка выполнения какой-то операции, вы можете задать ее свойство Caption равным «&Выполнить». На кнопке эта надпись будет иметь вид «Выполнить». И если пользователь нажмет клавиши Alt-В, то это будет эквивалентно щелчку на кнопке.

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

Свойство Cancel, если его установить в true, определяет, что нажатие пользователем клавиши Esc будет эквивалентно нажатию на данную кнопку. Это свойство целесообразно задавать равным true для кнопок «Отменить» в различных диалоговых окнах, чтобы можно было выйти из диалога, нажав на эту кнопку или нажав клавишу Esc.

Свойство Default, если его установить в true, определяет, что нажатие пользователем клавиши ввода Enter будет эквивалентно нажатию на данную кнопку, даже если данная кнопка в этот момент не находится в фокусе. Правда, если в момент нажатия Enter в фокусе находится другая кнопка, то все-таки сработает именно кнопка в фокусе.

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

CheckBox - индикаторы с флажком (независимый переключатель) используются в приложениях в основном для того, чтобы пользователь мог включать и выключать какие-то опции, или для индикации состояния. При каждом щелчке пользователя на индикаторе его состояние изменяется, проходя в общем случае последовательно через три значения: выделение (появление черной галочки), промежуточное (серое окно индикатора и серая галочка) и не выделенное (пустое окно индикатора). Этим трем состояниям соответствуют три значения свойства компонента State: cbChecked, cbGrayed, cbUnchecked. Впрочем, эти три состояния допускаются только при значении другого свойства AllowGrayed равном true. Если же AllowGrayed = false (значение по умолчанию), то допускается только два состояния: выделенное и не выделенное. И State, и AllowGrayed можно устанавливать во время проектирования или программно во время выполнения.

Промежуточное состояние обычно используется, если индикатор применяется для отображения какой-то характеристики объекта. Например, если индикатор призван показать, какой регистр использовался при написании какого-то фрагмента текста, то в случае, если весь текст написан в верхнем регистре индикатор может принимать выделенное состояние, если в нижнем — не выделенное, а если использовались оба регистра — промежуточное.

Проверять состояние индикатора можно не только по значению State, но и по значению свойства Checked. Если Checked равно true, то индикатор выбран, т.е. State = cbChecked. Если Checked равно false, то State равно cbUnchecked или cbGrayed. Установка Checked в true во время проектирования или выполнения автоматически переключает State в cbChecked.

Как и в радиокнопке, в индикаторе CheckBox надпись задается свойством Caption, а ее размещение по отношению к индикатору — свойством Alignment.

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

Начнем рассмотрение радиокнопок с компонента RadioGroup - панели группы радиокнопок. Это панель, которая может содержать регулярно расположенные столбцами и строками радиокнопки. А надписи кнопок и их количество определяются свойством Items, имеющим тип TStrings. Щелкнув на кнопке с многоточием около этого свойства в окне Инспектора Объектов, вы попадете в редактор списков строк. В нем вы можете занести надписи, которые хотите видеть около кнопок, по одной в строке. Сколько строчек вы запишете — столько и будет кнопок.

Кнопки, появившиеся в панели после задания значений Items, можно разместить в несколько столбцов (не более 17), задав свойство Columns. По умолчанию Columns = 1, т.е. кнопки размещаются друг под другом.

Определить, какую из кнопок выбрал пользователь, можно по свойству ItemIndex, которое показывает индекс выбранной кнопки. Индексы, как всегда в Delphi, начинаются с 0. По умолчанию ItemIndex = -1, что означает отсутствие выбранной кнопки. Если вы хотите, чтобы в момент начала выполнения приложения какая-то из кнопок была выбрана (это практически всегда необходимо), то надо установить соответствующее значение ItemIndex во время проектирования. Если вы используете радиокнопки не для ввода, а для отображения данных, устанавливать значение ItemIndex можно программно во время выполнения приложения.

Компонент RadioGroup очень удобен, но не свободен от некоторых недостатков. Его хорошо использовать, если надписи кнопок имеют примерно одинаковую длину и если число кнопок в каждом столбце (при размещении их в нескольких столбцах) одинаково.

В подобных случаях желательно нерегулярное расположение кнопок. Такую возможность дают компоненты RadioButton, сгруппированные панелью GroupBox. Панель GroupBox выглядит на форме так же, как RadioGroup, и надпись в ее верхнем левом углу также определяется свойством Caption. Эта панель сама по себе пустая. Ее назначение — служить контейнером для других управляющих элементов, в частности, для радиокнопок RadioButton. Отдельная радиокнопка RadioButton особого смысла не имеет, хотя и может служить индикатором, включаемым и выключаемым пользователем. Но в качестве индикаторов обычно используются другие компоненты - CheckBox. А радиокнопки имеют смысл, когда они взаимодействуют друг с другом в группе. Эта группа и объединяется единым контейнером, обычно панелью GroupBox (или Panel).

Рассмотрим свойства радиокнопки RadioButton. Свойство Caption содержит надпись, появляющуюся около кнопки. Значение свойства Alignment определяет, с какой стороны от кнопки появится надпись: taLeftJustify — слева, taRightJustify — справа (это значение принято по умолчанию). Свойство Checked определяет, выбрана ли данная кнопка пользователем, или нет. Поскольку в начале выполнения приложения обычно надо, чтобы одна из кнопок группы была выбрана по умолчанию, ее свойство Checked надо установить в true в процессе проектирования. Если вы поэкспериментируете, то заметите, что и во время проектирования можно установить в true значение Checked только у одной кнопки из группы.

Радиокнопки RadioButton могут размещаться не только в панели GroupBox, но и в любой панели другого типа, а также непосредственно на форме. Группа взаимосвязанных кнопок в этих случаях определяется тем оконным компонентом, который содержит кнопки. В частности, для радиокнопок, размещенных непосредственно на форме, контейнером является сама форма. Таким образом, все кнопки, размещенных непосредственно на форме, работают как единая группа, т.е. только в одной из этих кнопок можно установить значение Checked в true.

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

Основное свойство обоих компонентов, содержащее список строк, - Items, имеющее рассмотренный ранее тип TStrings. Заполнить его во время проектирования можно, нажав кнопку с многоточием около этого свойства в окне Инспектора Объектов. Во время выполнения работать с этим свойством можно, пользуясь свойствами и методами класса TStrings - Clear, Add и другими.

В компоненте ListBox имеется свойство MultiSelect, разрешающее пользователю множественный выбор в списке. Если MultiSelect = false (значение по умолчанию), то пользователь может выбрать только один элемент списка. В этом случае можно узнать индекс выбранной строки из свойства ItemIndex, доступного только во время выполнения. Если ни одна строка не выбрана, то ItemIndex = -1. Начальное значение ItemIndex невозможно задать во время проектирования. По умолчанию ItemIndex = -1. Это означает, что ни один элемент списка не выбран. Если вы хотите задать этому свойству какое-то другое значение, т.е. установить выбор по умолчанию, который будет показан в момент начала работы приложения, то сделать это можно, например, в обработчике события OnCreate формы, введя в него оператор вида

ListBox1.ItemIndex:=0;

Если допускается множественный выбор (MultiSelect = true), то значение ItemIndex соответствует тому элементу списка, который находится в фокусе. При множественном выборе проверить, выбран ли данный элемент, можно проверив свойство Selected[Index: Integer] типа Boolean.

На способ множественного выбора при MultiSelect = true влияет еще свойство ExtendedSelect. Если ExtendedSelect = true, то пользователь может выделить интервал элементов, выделив один из них, затем нажав клавишу Shift и переведя курсор к другому элементу. Выделить не прилегающие друг к другу элементы пользователь может, если будет удерживать во время выбора нажатой клавишу Ctrl. Если же ExtendedSelect = false, то клавиши Shift и Ctrl при выборе не работают.

Свойство Columns определяет число столбцов, в которых будет отображаться список, если он не помещается целиком в окне компонента ListBox.

Свойство Sorted позволяет упорядочить список по алфавиту. При Sorted = true новые строки в список добавляются не в конец, а по алфавиту.

Свойство Style, установленное в lbStandard (значение по умолчанию) соответствует списку строк. Другие значения Style позволяют отображать в списке не только текст, но и изображения.

ComboBox – «выпадающий» список выбора. Стиль изображения этого компонента определяется свойством Style, которое может принимать следующие основные значения: csDropDown - выпадающий список со строками одинаковой высоты и с окном редактирования, позволяющим пользователю вводить или редактировать текст; csSimple - развернутый список со строками одинаковой высоты и с окном редактирования, позволяющим пользователю вводить или редактировать текст; csDropDownList - выпадающий список со строками одинаковой высоты, не содержащий окна редактирования.

Выбор пользователя или введенный им текст можно определить по значению свойства Text. Если же надо определить индекс выбранного пользователем элемента списка, то можно воспользоваться обсуждавшимся в компоненте ListBox свойством ItemIndex. Все сказанное выше об ItemIndex и о задании его значения по умолчанию справедливо и для компонента ComboBox. Причем для ComboBox задание начального значения ItemIndex еще актуальнее, чем для ListBox. Если начальное значение не задано, то в момент запуска приложения пользователь не увидит в окне компонента одно из возможных значений списка и, вероятнее всего, не очень поймет, что с этим окном надо делать.

Если в окне проводилось редактирование данных, то ItemIndex = -1. По этому признаку можно определить, что редактирование проводилось.

Свойство MaxLength определяет максимальное число символов, которые пользователь может ввести в окно редактирования. Если MaxLength = 0, то число вводимых символов не ограничено.

Как и в компоненте ListBox, свойство Sorted позволяет упорядочить список по алфавиту. При Sorted = true новые строки в список добавляются не в конец, а по алфавиту.

Panel, Splitter, GroupBox, Bevel

Panel – панели, используются наиболее широко. С их помощью компонуются различные элементы интерфейса (кнопки, окна редактирования, списки), функционально связанные друг с другом. Такая функциональная связь должна поддерживаться и зрительной связью — объединением соответствующих элементов в рамках одной панели. Панели Panel могут также использоваться для организации инструментальных панелей, полос состояния и т.п., хотя для этих целей имеются и специализированные компоненты.

Внешний вид панели Panel определяется совокупностью параметров BevelInner - стиль внутренней части панели, BevelOuter - стиль внешней части панели, BevelWidth - ширина внешней части панели, BorderStyle - стиль бордюра, BorderWidth - ширина бордюра. Результат сочетания некоторых значений этих параметров показан на рис. 7.1. Верхняя панель соответствует значениям параметров по умолчанию. Нижняя панель соответствует случаю, когда не определен стиль ни одной из областей панели. В этом случае сама панель никак не выделяется на форме. Видна только надпись на ней (свойство Caption), если надпись задана, и, конечно, видны те компоненты, которые размещаются на панели.

Если вы строите приложение, в котором разрешаете пользователю изменять размер окна, надо позаботиться о том, чтобы синхронно с этим изменялись и размеры панелей. (Align, Anchors и Constraints). Но в ряде приложений этого мало. В зависимости от ситуации какие-то панели в приложении могут оказаться временно перегруженными отображаемыми данными, а другие в значительной степени пустыми. В этих случаях полезно предоставить пользователю возможность перемещать границы, разделяющие различные панели, изменяя их относительные размеры.

В библиотеке Delphi имеется специальный компонент — Splitter, который позволяет легко осуществить это. Рассмотрим это на примере. Пусть вы хотите иметь в приложении форму, содержащую 2 панели. Для этого вам необходимо разместить на форме Panel, выставить ей свойство Align в значение alTop, далее поместить на форму Splitter и также установить Align в значение alTop и, наконец, поместить на форму еще одну Panel, но ей уже задать Align – alClient. При изменении размеров такого окна будет меняться размер нижней панели, а расстояние между панелями можно менять перетаскиванием Splitter-a.

Свойство ResizeStyle компонента Splitter определяет поведение разделителя при перемещении его пользователем. По умолчанию это свойство равно rsPattern. Это означает, что пока пользователь тянет курсором мыши границу, сам разделитель не перемещается и панели тоже остаются прежних размеров. Перемещается только шаблон линии, указывая место намечаемого перемещения границы. Лишь после того, как пользователь отпустит кнопку мыши, разделитель переместится и панели изменят свои размеры. Практически такая же картина наблюдается, если установить ResizeStyle = rsLine. При ResizeStyle = rsUpdate в процессе перетаскивания границы пользователем разделитель тоже перемещается и размеры панелей все время меняются. Это, может быть, удобно, если пользователь хочет установить размер панели таким, чтобы на ней была видна какая-то конкретная область. Но так как процесс перетаскивания в этом случае сопровождается постоянной перерисовкой панелей, наблюдается неприятное мерцание изображения. Так что этот режим можно рекомендовать только в очень редких случаях. Если установить ResizeStyle = rsNone, то в процессе перетаскивания границы не перемещается ни сама граница, ни изображающая ее линия.

Свойство MinSize компонента Splitter устанавливает минимальный размер в пикселях обеих панелей, между которыми зажат разделитель. Задание такого минимального размера необходимо, чтобы при перемещениях границы панель не сжалась бы до нулевого размера или до такой величины, при которой на ней исчезли бы какие-то необходимые для работы элементы управления. К сожалению, свойство MinSize не всегда срабатывает верно. К тому же это свойство относится к обеим панелям, граница между которыми перемещается, а в ряде случаев желательно раздельно установить различные минимальные размеры одной и другой панели. Это проще (и надежнее) сделать, задав в панелях соответствующие значения свойства Constraints.

Компонент Splitter имеет событие OnMoved, которое наступает после конца перемещения границы. В обработчике этого события можно предусмотреть, если необходимо, упорядочение размещения компонентов на панелях, размеры которых изменились: переместить какие-то метки, изменить размеры компонентов и т.д.

GroupBox – контейнер группы компонентов, не имеет таких широких возможностей задания различных стилей оформления, как Panel. Но имеет встроенную рамку с надписью, которая обычно используется для выделения на форме группы функционально объединенных компонентов. Никаких особых свойств, отличных от уже рассмотренных, панель GroupBox не имеет.

Bevel формально не является панелью, он не может служить контейнером для компонентов. Однако зрительно компонент Bevel может использоваться как подобие панели.

Стиль отображения Bevel определяется свойством Style, которое может принимать значения bsLowered — утопленный, и bsRaised — приподнятый. А контур компонента определяется свойством Shape, которое может принимать значения: bsBox — прямоугольник, bsFrame — рамка, bsSpacer — пунктирная рамка, bsTopLine, bsBottomLine, bsLeftLine, bsRightLine — соответственной верхняя, нижняя, левая и правая линии. В зависимости от значения Style линии могут быть утопленными или выступающими.

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

Основные свойства компонента, определяющие отображаемый текст:

StringGrid.Cells[ACol, ARow: Integer]: string - строка, содержащаяся в ячейке с индексами столбца и строки ACol и ARow.

Свойства ColCount и RowCount определяют соответственно число столбцов и строк, свойства FixedCols и FixedRows - число фиксированных, не прокручиваемых столбцов и строк. Цвет фона фиксированных ячеек определяется свойством FixedColor. Свойства LeftCol и TopRow определяют соответственно индексы первого видимого на экране в данный момент прокручиваемого столбца и первой видимой прокручиваемой строки.

Свойство ScrollBars определяет наличие в таблице полос прокрутки. Причем полосы прокрутки появляются и исчезают автоматически в зависимости от того, помещается таблица в соответствующий размер, или нет.

Свойство Options является множеством, определяющим многие свойства таблицы: наличие разделительных вертикальных и горизонтальных линий в фиксированных (goFixedVertLine и goFixedHorzLine) и не фиксированных (goVertLine и goHorzLine) ячейках, возможность для пользователя изменять с помощью мыши размеры столбцов и строк (goColSizing и goRowSizing), перемещать столбцы и строки (goColMoving и goRowMoving) и многое другое. Важным элементом в свойстве Options является goEditing — возможность редактировать содержимое таблицы.

В основном компонент StringGrid используется для выбора пользователем каких-то значений, отображенных в ячейках. Свойства Col и Row показывают индексы столбца и колонки выделенной ячейки. Возможно также выделение пользователем множества ячеек, строк и столбцов.

Среди множества событий компонента StringGrid следует отметить событие OnSelectСell, возникающее в момент выбора пользователем ячейки. В обработчик этого события передаются целые параметры ACol и ARow - столбец и строка выделенной ячейки, и булев параметр CanSelect - допустимость выбора. Параметр CanSelect можно использовать для запрета выделения ячейки, задав его значение false. А параметры ACol и ARow могут использоваться для какой-то реакции программы на выделение пользователя. Например, оператор

Label1.Caption:='Выбрана ячейка '+IntToStr(ARow)+':'+IntToStr(ACol);

выдаст в метку Label1 номер выбранной ячейки. А оператор

Label1.Caption :=StringGrid1.Cells [ACol, ARow];

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

Свойства (Properties) и События (Events)

Операционная система Windows - многозадачная, т.е. несколько программ в ней могут функционировать одновременно. Когда, например, мы щёлкаем по кнопке в окне нашей программы, система Windows определяет, что произошло событие именно в нашей программе, и посылает ей сообщение об этом. Наша программа должна соответствующим образом отреагировать на него. Для этого мы, как программисты, должны написать код-обработчик этого события. Таким образом, структура программы для Windows представляет собой набор подпрограмм, каждая из которых ответственна за обработку конкретного события и вызывается только при его возникновении. Удобство Delphi состоит в том, что мы избавлены от необходимости получать сообщения от Windows сами, Delphi это делает за нас. Каждый компонент имеет впечатляющий набор событий, на которые он может реагировать. Программист сам определяет, какие события в программе требуется обрабатывать.

В инспекторе объектов две вкладки: Properties (свойства) и Events (события). Выбирая нужный компонент, в Инспекторе Объектов мы можем получить доступ к его свойствам (Properties). Прежде всего, у визуальных компонентов есть такие свойства, как: ширина компонента (Width), высота компонента (Height), расстояние до левого края формы (Left), расстояние до верхнего края формы (Top). За визуальное представление отвечают для компонентов: Label и Button - свойство Caption, Edit - свойство Text, Memo - свойство Lines.

Рассмотрим вкладку Events. Чтобы создать обработчик нужного события, нужно дважды кликнуть по нему мышкой (в правой (белой части) – не по названию события). А если раскрыть выпадающий список, в нём будут находиться уже готовые обработчики, которые могут подходить для этого компонента. Таким образом, один обработчик может вызываться для обработки событий нескольких компонентов.

Например, для того, чтобы текст в Label1 менялся прямо в момент его ввода необходимо проделать следующее: В момент ввода у Edit1 меняется свойство Text - в нём появляется новая буква. Значит, воспользуемся событием onchange (change - изменение (англ.)), которое и происходит в этот момент. Итак: Кликаем дважды по onchange, и оказываемся внутри только что созданного обработчика (процедуры в Unit-е). Присваиваем свойству Caption компонента Label1 значение свойства Text компонента Edit1: Label1.Caption := Edit1.Text.

Теперь рассмотрим событие onclick. Это событие возникает при щелчке мышкой на компоненте. Воспользуемся им, чтобы очищать строку ввода от уже введённых символов. В обработчике нужно присвоить свойству Text значение пустой строки. Строка в Delphi образуется заключением текста в одинарные кавычки: 'Так в Delphi образуется строка'. Значит, пустая строка - это кавычки без текста: ''. Не должно быть даже пробела, иначе он окажется в строке ввода: Edit1.Text:=''. Есть другой способ, воспользоваться специально предназначенным для этого методом компонента Edit, который так и называется Clear (очистка англ.): Edit1.Clear;

Но если при вводе текста пользователь захочет что-то исправить, и щёлкнет мышкой по компоненте, то всё стирается. Поэтому лучше использовать событие onEnter, которое происходит, когда вы "входите" в него и компонент получает фокус ввода.

У каждого компонента свой набор событий. Три из них были рассмотрены выше: onchange, onclick, onEnter.

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

onExit - возникает, когда компонент теряет фокус ввода;

ondblclick - возникает при двойном щелчке мышкой по компоненту;

onkeydown - когда при нажатии на кнопку на клавиатуре она оказалась в нижнем положении;

onkeyup - когда при отпускании клавиатурной кнопки она оказалась в верхнем положении;

onkeypress - возникает при нажатии на клавиатурную кнопку. От событий onkeydown и onkeyup оно отличается типом используемого параметра Key, в котором содержится код нажатой клавиши;

onmousedown - когда при нажатии кнопки мышки она оказалась в нижнем положении;

onmouseup - когда при отпускании кнопки мышки она оказалась в верхнем положении;

onMouseMove - возникает при перемещении указателя мышки над компонентом.

В начале работы любой программы происходит очень важное событие основного компонента - Формы (onCreate). Оно происходит перед появлением Формы на экране. Это событие используется для задания свойств элементов программы. Запуск программы осуществляется с помощью клавиши «F9».

Если в результате ошибки программа зависает необходимо нажать OK в окне предупреждения об ошибке и выполнить команду меню главного окна Delphi Run -» Program Reset или нажать Ctrl+F2, находясь в окне модуля!

Переменные, константы

Данные в компьютере можно рассматривать как ячейки памяти, имеющие свои имена (идентификаторы). Все данные в программе на языке Delphi должны быть описаны до их первого использования. Любая величина в Delphi может быть постоянной или переменной. Её имя (идентификатор) может состоять из комбинации латинских букв, цифр и знака подчёркивания, и начинаться не с цифры. При этом регистр символов значения не имеет.

В модуле перед ключевым словом implementation есть блок описания:

var

Form1: TForm1;

Именно здесь, удобно объявлять глобальные переменные и константы.

Команда объявления переменных в языке Delphi: имя_переменной : тип_переменной;

Слово var - ключевое. Именем может быть любой идентификатор, если он не был описан ранее и не является одним из ключевых или зарезервированных слов языка Delphi. Если нужно описать несколько переменных одного типа, то их перечисляют, отделяя запятой: var A, B, C : Integer;

Если несколько описаний следуют друг за другом, то ключевое слово var повторно не указывается:

var A, B : Integer; C, D : String;

Постоянную величину иначе называют константой. Описание констант аналогично описанию переменных, но используется ключевое слово const, за именем идентификатора следует тип, затем знак равенства и его значение. Причём тип константы допускается не указывать:

const pi=3.1415;

Типы данных

Целочисленные типы

Тип	Диапазон
Integer	-2147483648 .. +2147483647
Cardinal	0 .. 4294967295
Shortint	-128 .. +127
Smallint	-32768 .. +32767
Longint	-2147483648 .. +2147483647
Int64	-263 .. +263-1
Byte	0 .. +255
Word	0 .. +65535
Longword	0..4294967295

Как следует из названия, целочисленные типы позволяют хранить целые числа. Среди них есть типы, которые хранят числа со знаком, а есть и такие, которые хранят только положительные. Чем большее количество значений может содержать тип, тем больше памяти он занимает. Существуют 2 общих типа (Integer и Cardinal). Рекомендуется использовать именно эти типы, т.к. компилятор "заточен" под них и создаёт более быстрый и эффективный код.

Логические типы

Существуют следующие логические типы: Boolean, ByteBool, WordBool и LongBool. Однако последние три введены лишь для обеспечения совместимости с другими языками программирования. Использовать рекомендуется тип Boolean. Тип Boolean принимает значения True и False.

Символьные типы

Символьные типы обеспечивают хранение отдельных символов. Основной тип данных - Char, который содержит символы с кодами 0..255. Существуют ещё типы AnsiChar и WideChar. Тип AnsiChar эквивалентен типу Char. Занимает в памяти 1 байт. Для кодирования символов используется код ANSI (American National Standards Institute). Тип WideChar кодируется международным кодом Unicode и занимает в памяти 2 байта. Таблица Unicode включает символы практически всех языков мира.

Вещественные (действительные) типы

Эти типы используются для хранения вещественных, т.е. действительных чисел. Отличаются они границами допустимых значений и точностью, т.е. числом цифр после запятой. Ниже приведены стандартные типы дробных чисел и соответствующие им диапазоны допустимых значений.

Тип	Диапазон	Количество значащих цифр
Real	2.9·10-39 .. 1.7·1038	11-12
Single	1.5·10-45 .. 3.4·1038	7-8
Double	5.0·10-324 .. 1.7·10308	15-16
Extended	3.6·10-4951 .. 1.1·104932	19-20
Comp	-263+1 .. 263-1	19-20
Currency	-922337203685477.5808 .. 922337203685477.5807	19-20

Строковые типы

В выражениях Delphi поддерживает три физических строковых формата: короткий (ShortString), длинный (LongString) и широкий (WideString). Их можно комбинировать в операторах присваивания и выражениях (все необходимые преобразования Delphi выполняет автоматически).

Переменные типов AnsiString и WideString - это динамически распределяемые массивы символов, максимальная длина которых ограничивается только наличием памяти. Разница между ними состоит в том, что в AnsiString знаки записываются в формате char, а в WideString- в формате WideChar. Обычно вполне достаточно одного типа AnsiString, однако при работе с международными наборами символов, такими как UNICODE, удобнее использовать WideString.

Тип ShortString-это, по существу, массив Array [0..255] of char. Символы, составляющие строку, занимают места от 1 до 255. Тип ShortString предназначен, в основном, для обеспечения совместимости с ранними версиями Delphi. Логический строковый тип именуется просто String.

Структурные типы данных

Обойтись только простыми - линейными типами в большой программе довольно сложно. Желательно, чтобы структура данных прикладной программы отвечала структуре данных решаемой задачи. Для этого в Delphi есть набор структурных типов данных.

Массив — это структура данных, доступ к элементам которой осуществляется по номеру (или индексу). Все элементы в массиве имеют одинаковый тип. Индекс элемента массива может быть вычисляемым, что позволяет организовывать компактную и эффективную обработку больших наборов данных. Описание массива имеет вид: имя-массива : array[диапазон] of тип-элемента;

Слова array (массив) и of - ключевые. Диапазон определяет нижнюю и верхнюю границы массива и, соответственно, число элементов в нем. При обращении к массиву индекс должен лежать в этом диапазоне. Тип элемента определяет тип каждого элемента массива. Массив А, состоящий из 5 столбцов и 10 строк целого типа описывается в программе так: А : array [1..5,1..10] of integer;

Множество - это группа элементов, объединённая под одним именем, и с которой можно сравнивать другие величины, чтобы определить, принадлежат ли они этому множеству. Количество элементов в одном множестве не может превышать 256. Множество описывается так:

type имя_множества = set of диапазон_значений_множества;

В качестве диапазона может указываться любой тип, количество элементов в котором не больше 256. Конкретные значения множества задаются в программе с помощью перечисления элементов, заключённых в квадратные скобки. Допускается использовать и диапазоны: MySet:=[1, 3 .. 7, 9];

Основные арифметические операции

Оператор	Операция	Типы операндов	Тип результата	Пример
+	сложение	integer, real	integer, real	2 + 1 = 3
-	разность	integer, real	integer, real	7 – 1 = 6
*	умножение	integer, real	integer, real	2 * 4 = 8
/	деление	integer, real	real	10 / 2 = 5
div	целая часть результата деления	integer	integer	10 div 3 = 3
mod	остаток от деления	integer	integer	10 mod 3 = 1

Операции сравнения

Оператор	Значение
=	Равно
<>	Не равно
>	Больше
<	Меньше
>=	Больше или равно
<=	Меньше или равно

Логические операции

Оператор	Значение	Результат
not	НЕ	отрицание
and	И	равен true, если оба операнда равны true
or	ИЛИ	равен true, если хотя бы один из операндов равен true
xor	исключающее ИЛИ	равен true, если операнды не равны друг другу

Для некоторых типов данных есть дополнительные операции. Например, для множеств - оператор in проверяет, входит ли некоторое значение в множество. Например: X := [2, 4, 8, 10]; Выражение 2 in X истинно (имеет значение true); Выражение 6 in X ложно (имеет значение false).

Процедуры и функции

Часто некоторая последовательность инструкций встречается в разных частях программы несколько раз. Можно избежать дублирования кода в программе. Для этого надо оформить инструкции, которые встречаются в программе несколько раз, как подпрограмму, и заменить инструкции, оформленные в виде подпрограммы (процедуры или функции), инструкцией вызова подпрограммы. Примером может служить обработка вводимых в Edit символов. Можно создать одну процедуру обработчика события onKeyPress и выбрать ее в соответствующем событии каждого компонента Edit.

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

Подпрограмма — это небольшая программа, которая решает часть общей задачи. В языке Delphi есть два вида подпрограмм — процедура и функция.

У каждой подпрограммы есть имя, которое используется в программе для вызова подпрограммы. Отличие функции от процедуры состоит в том, что с именем функции связано значение, поэтому функцию можно использовать в качестве операнда выражения, например, инструкции присваивания. Как правило, подпрограмма имеет параметры. Различают формальные и фактические параметры.

Параметры, которые указываются в объявлении функции, называются формальными. Параметры, которые указываются в инструкции вызова процедуры, называются фактическими. Параметры используются: для передачи данных в подпрограмму; для получения из результата подпрограммы.

Функция

Функция - это подпрограмма, т. е. последовательность инструкций, имеющая имя.

Процесс перехода к инструкциям функции называется вызовом функции или обращением к функции. Процесс перехода от инструкций функции к инструкциям программы, вызвавшей функцию, называется возвратом из функции. В общем виде инструкция обращения к функции выглядит так:

Переменная := Функция (Параметры);

где:

переменная — имя переменной, которой надо присвоить значение, вычисляемое функцией;

Функция — имя функции, значение которой надо присвоить переменной;

Параметры — список формальных параметров, которые применяются для вычисления значения функции. В качестве параметров обычно используют переменные или константы.

Следует обратить внимание на то, что:

каждая функция возвращает значение определенного типа, поэтому тип переменной, которой присваивается значение функции, должен соответствовать типу функции;

тип и количество параметров для каждой конкретной функции строго определены.

Объявление функции

Объявление функции в общем виде выглядит так:

function Имя(параметр1 : тип1, ..., параметрК : типК) : Тип;

var

// здесь объявления локальных переменных

begin

// здесь инструкции функции

Имя := Выражение;

end;

где:

function — зарезервированное слово языка Delphi, обозначающее, что далее следуют инструкции, реализующие функцию программиста;

имя — имя функции. Используется для перехода из программы к инструкциям функции;

параметр — это переменная, значение которой используется для вычисления значения функции. Отличие параметра от обычной переменной состоит в том, что он объявляется не в разделе объявления переменных, который начинается словом var, а в заголовке функции. Конкретное значение параметр получает во время работы программы в результате вызова функции из основной программы;

тип — тип значения, которое функция возвращает в вызвавшую ее программу.

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

Пример функции:

// проверяет, является ли символ допустимым во время ввода целого числа

function Islnt(ch : char) : Boolean;

begin

if (ch >= '0') and (ch <= '9') // цифры

or (ch = #13) // клавиша <Enter>

or (ch = #8) // клавиша <Backspace>

then Islnt := True // символ допустим

else Islnt := False; // недопустимый символ

end;

Данную функцию можно использовать (вызвать) при фильтрации вводимого текста в любое текстовое поле, например, Edit1:

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

begin

if Islnt(Key) = False then key:=#0;

end;

Из примера видно, что функция вызывается и ей передается параметр Key, который обрабатывается в самой функции, после чего возвращается результат (в данном случае – False). При возвращенном значении False переменной key присваивается #0,что предотвратит ввод какого-либо символа в поле ввода, иначе символ вводится в поле ввода.

Процедура

Процедура — это разновидность подпрограммы. Обычно подпрограмма реализуется как процедура в двух случаях: когда подпрограмма не возвращает в основную программу никаких данных. Например, вычерчивает график в диалоговом окне; когда подпрограмма возвращает в вызвавшую ее программу больше чем одно значение. Например, подпрограмма, которая решает квадратное уравнение, должна вернуть в вызвавшую ее программу два дробных числа — корни уравнения.

В общем виде объявление процедуры выглядит так:

procedure Имя (var параметр1: тип1; ... var параметрК: типК);

var

// здесь объявление локальных переменных

begin

// здесь инструкции процедуры

end;

где:

procedure — зарезервированное слово языка Delphi, обозначающее, что далее следуют инструкции, реализующие процедуру программиста;

имя — имя процедуры, которое используется для вызова процедуры;

параметр K — формальный параметр, переменная, которая используется в инструкциях процедуры. Слово var перед именем параметра не является обязательным. Однако если оно стоит, то это означает, что в инструкции вызова процедуры фактическим параметром обязательно должна быть переменная. Параметры процедуры используются для передачи данных в процедуру, а также для возврата данных из процедуры в вызвавшую ее программу.

В качестве примера приведена процедура решения квадратного уравнения. У процедуры шесть параметров: первые три предназначены для передачи в процедуру исходных данных — коэффициентов уравнения; параметры x1 и х2 используются для возврата результата — корней уравнения; параметр ok служит для возврата информации о том, что решение существует.

// решает квадратное уравнение

procedure TForm1.SqRoot(a,b,c : real; var x1,x2 : real; var ok : boolean);

var

d : real; // дискриминант

begin

d:= Sqr(b) - 4*a*c;

if d < 0 then ok := False // уравнение не имеет решения

else

begin

ok := True;

x1 := (-b + Sqrt(d)) / (2*a) ; x2 := (-b - Sqrt(d)) / (2*a);

end;

end;

//обрабатывает событие нажатие на Button1, где вызывает процедуру SqRoot

procedure TForm1.Button1Click(Sender: TObject);

var

k1,k2: real; // корни уравнения

rez: boolean; // True —решение есть, False — решения нет

mes:string; // сообщение

begin

SqRoot(StrToFloat(Edit1.Text), StrToFloat(Edit2.Text),

StrToFloat(Edit3.Text),k1,k2,rez);

if rez then mes := 'Корни:'+#13+'x1='+FloatToStr(k1)+#13+'x2='+ FloatToStr(k2)+#13 else mes := 'Уравнение не имеет решения'; label_result.Caption := mes;

end;

Инструкция вызова процедуры в общем виде выглядит так:

Имя(СписокПараметров);

где:

Имя — имя вызываемой процедуры;

СписокПараметров — разделенные запятыми фактические параметры.

Фактическим параметром, в зависимости от описания формального параметра в объявлении процедуры, может быть переменная, выражение или константа соответствующего типа.

Основные функции и процедуры

Функции и процедуры для порядковых типов данных

Существует несколько полезных функций и процедур, без использования которых, порой, сложно оперировать порядковыми типами данных:

Pred() - функция возвращает предыдущее значение для выражения, указанного в качестве единственного аргумента.

Примеры: Pred(5) = 4, Pred('E') = 'D', Pred(True) = False.

Succ() - функция, обратная для Pred() - возвращает следующее значение.

Примеры: Succ(5) = 6, Succ('E') = 'F', Succ(False) = True.

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

Примеры: Ord('A') = 65, Ord(True) = 1.

Low() - возвращает минимальное значение указанного типа данных.

Примеры: Low(Byte) = 0, Low(Boolean) = False, Low(Char) = #0 (символ с кодом 0).

High() - возвращает максимальное значение указанного типа данных.

Примеры: High(Byte) = 255, High(Boolean) = True, High(Char) = #255 (в русской локали это символ "я").

Dec() - уменьшает значение на единицу.

Inc() - увеличивает значение на единицу.

SizeOf() - Размер элемента данных указанного типа в байтах. Пример:значение SizeOf(Byte) равно 1, значение SizeOf (Integer) равно 4.

Стандартные функции преобразования типов

Round(X: Extended) - Округление дробного числа до ближайшего целого. Пример: значение Round (3.74) равно 4

RoundTo(X: Extended) - Округление дробного числа. . Пример: значение RoundTo(1.234, -2) равно 1.23

Trunc(X: Extended) - Отбрасывание дробной части числа. Пример: значение Trunc(3.74) равно 3

IntToStr(N: Integer): String - Преобразование целого числа в строку. Пример: значение IntToStr(12987) равно '12987'

FloatToStr(X: Extended): String- Преобразование дробного числа в строку. Пример: значение FloatToStr(3.74) равно '3.74'

StrToInt(S: String): Integer - Преобразование строки в целое число. Пример: значение StrToInt( '12985') равно 12985

StrToFloat(S: String): Extended - Преобразование строки в дробное число. Пример: значение StrToFloatf ('3.14') равно 3.14

Chr() - Символ, преобразованный из числового аргумента. Пример: значение Chr(78) равно 'N'

Функции IntToStr(), FloatToStr(), StrToInt(), StrToFloat() требуют подключения Юнита Sysutils, а функция RoundTo() подключения Юнита Math.

Функции работы со строками

Pos(Substr: String; Str: String): Integer - возвращает позицию (индекс) первого вхождения Substr в строке Str. Если Substr нет в Str, возвращает 0. Например позиция запятой в строке может быть найдена так N:=Pos(DecimalSeparator, S);

Insert(Source: String; var S: String; Index: Integer): Integer - вставляет строку Source в строку S, начиная с номера символа, равного Index

Delete(var S: String; Index: Integer, Count: Integer) - удаляет из строки S подстроку, начинающуюся с номера символа, равного Index, и содержащую до Count символов.

Copy(S: String; Index: Integer, Count: Integer): String - Возвращает подстроку строки S, начиная с номера символа, равного Index и содержащую до Count символов.

Length(S: String) - Длина строки или число элементов в массиве. Пример: значение length('abc') равно 3

AnsiLoverCase(const S: String): String - Возвращает строку S, преобразованную к нижнему регистру.

AnsiUpperCase(const S: String): String - Возвращает строку S, преобразованную к верхнему регистру.

Trim(const S: String): String - Удаляет из строки S начальные и завершающие пробелы и управляющие символы.

TrimLeft(const S: String): String - Удаляет из строки S начальные пробелы и управляющие символы.

TrimRight(const S: String): String - Удаляет из строки S завершающие пробелы и управляющие символы.

Процедуры и функции преобразования дат и времени

Функции, предоставляющие информацию о текущих дате и времени:

Now: TDateTime - возвращает текущую дату и время. Пример TekDataVr:=Now;

Date: TDateTime - dозвращает текущую дату. Пример TekData:=Date;

Time: TDateTime - dозвращает текущее время. Пример TekVr:=Time;

Функции и процедуры работающие с составляющими даты и времени (год, месяц, число, день недели, часы, минуты, секунды и даже миллисекунды):

DayOfWeek(Date: TDateTime): Integer - возвращает текущий номер дня недели: 1 - воскресенье, 7 - суббота.

DecodeDate(Date: TDateTime; var Year, Month, Day: Word) - разбивает дату Date на год - Year, месяц - Month и день - Day.

DecodeTime(Time: TDateTime; var Hour, Min, Sec, MSec: Word) - разбивает время Time на час - Hour, минуты - Min, секунды - Sec и миллисекунды - MSec.

EncodeDate(Year, Month, Day: Word): TDateTime - объединяет год - Year, месяц - Month и день - Day в значение типа TDateTime.

EncodeTime(Hour, Min, Sec, MSec: Word): TDateTime - объединяет час - Hour, минуты - Min, секунды - Sec и миллисекунды - MSec в значение типа TDateTime.

Функции, переводящие дату и время из формата TDateTime в строчный формат:

DateTimeToStr(DateTime: TDateTime): String - Преобразует дату и время DateTime в строку.

DateToStr(Date: TDateTime): String - Преобразует дату Date в строку.

TimeToStr(Time: TDateTime): String - Преобразует время Time в строку.

Основные инструкции Delphi

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

Формат инструкции присваивания имеет следующий вид:

<Имя переменной> := <Выражение>;

Вместо имени переменной можно указывать элемент массива или поле записи. Отметим, что знак присваивания := отличается от знака равенства = и имеет другой смысл. Знак присваивания означает, что значение выражения сначала вычисляется, а потом присваивается указанной переменной.

Примеры инструкций присваивания для переменных со следующими описаниями:

var

х, у: real;

n: integer;

stroka: string;

...

n := 17 * n + 1;

stroka := 'Дата ' + DateToStr(Date);

x := 12.3 * sin(pi/4) ;

у := 23.789E+3;

Составная инструкция представляет собой группу из произвольного числа любых инструкций, отделенных друг от друга точкой с запятой, и ограниченную операторными скобками begin и end.

Формат составной инструкции имеет следующий вид:

begin

<Оператор_1>;

...;

<Оператор_n>;

end;

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

Пример составной инструкции:

begin

Веер;

Edit1.Text := 'Строка';

Exit;

end;

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

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

Условная инструкция обеспечивает выполнение или невыполнение некоторых инструкций в зависимости от соблюдения определенных условий. Условная инструкция предназначена для организации ветвления программы на два направления. Условная инструкция имеет формат:

if <Условие> then <Инструкция1> else <Инструкция2>;

Условие представляет собой выражение логического типа. Инструкция работает следующим образом: если Условие истинно (имеет значение True), то выполняется Инструкция 1, в противном случае — Инструкция 2. Обе инструкции могут быть составными.

Допускается запись условной инструкции в сокращенной форме, когда слова else и Инструкция2 отсутствуют. В этом случае при невыполнении условия управление сразу передается инструкции, следующей за условной.

Для организации ветвления на три и более направлений можно использовать несколько условных инструкций, вложенных друг в друга. При этом каждое слово else соответствует тому then, которое непосредственно ему предшествует. Из-за возможной путаницы следует избегать большой глубины вложенности условных инструкций. Примеры условных инструкций:

if х > 0 then х := х + 1 else х := 0;

if q = 0 then а := 1;

Инструкция цикла с параметром имеет два возможных формата:

for <Параметр> := <Выражение1> to <Выражение2> do <Инструкция>;

for <Параметр> := <Выражение1> downto <Выражение2> do <Инструкция>;

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

Инструкция цикла (инструкция) обеспечивает выполнение тела цикла, которым является инструкция после слова do, до полного перебора с соответствующим шагом всех значений параметра цикла от начального до конечного. Шаг параметра всегда равен 1 для первого формата цикла и −1 - для второго, т. е. значение параметра последовательно увеличивается (for...to) или уменьшается (for...downto) на единицу при каждом повторении цикла.

Цикл может не выполниться ни разу, если для цикла for...to значение начального выражения больше конечного, а для цикла for...downto, наоборот, значение начального выражения меньше конечного. Примеры циклов с параметром:

var

n, k: integer;

...

s := 0;

for n := 1 to 10 do s := s + m[n] ;

for к := 0 to 2 do

for n := 5 to 10 do

begin

arr1[k, n] := 0;

arr2[k, n] := 1;

end;

В первом цикле выполняется расчет суммы десяти значений массива m. Во втором случае два цикла вложены один в другой, и в них пересчитываются значения элементов двумерных массивов arr1 и аrr2.

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

Инструкция цикла с постусловием имеет следующий формат:

repeat

<Инструкция1>;

<ИнструкцияN>;

until <Условие>;

Условие представляет собой выражение логического типа. Инструкции, заключенные между словами repeat и until, составляют тело цикла и выполняются до тех пор, пока логическое выражение Условие не примет значение True, т. е. тело цикла повторяется при значении Условия, равном False. Так как Условие проверяется только в конце цикла, инструкции тела цикла выполняются минимум один раз.

В теле цикла может находиться произвольное число инструкций без операторных скобок begin и end. По крайней мере одна из инструкций тела цикла должна влиять на значение Условие, в противном случае произойдет зацикливание.

Приведем для иллюстрации цикла с постусловием расчет суммы десяти значений массива m:

var

х: integer;

sum: real;

m: array[1..10] of real;

begin

x := 1;

sum := 0;

repeat

sum := sum + m[x];

x := x + 1;

until(x < 10);

end;

Инструкцию цикла с предусловием целесообразно использовать в случаях, когда число повторений тела цикла заранее неизвестно и тело цикла может ни разу не выполняться. Эта инструкция аналогична инструкции repeat... .until с той лишь разницей, что условие проверяется в начале оператора.

Формат инструкции цикла с предусловием:Инструкция цикла с предусловием

while <Условие> do <Инструкция>;

Инструкция тела цикла выполняется до тех пор, пока логическое выражение Условие не примет значение False, т. е. в отличие от цикла с постусловием, данный цикл выполняется при значении логического выражения True.

Снова в качестве примера рассмотрим расчет суммы десяти значений массива m:

var

х: integer;

sum: real;

m: array[1..10] of real;

begin

x: = 1;

sum: = 0 ;

while x <= 10 do

begin

sum := sum + m[x];

x : + x + 1;

end;

end;

Если перед первым выполнением цикла условие не удовлетворяется (значение логического выражения Условие равно False), то тело цикла не выполнится ни разу, и происходит переход на инструкцию, следующую за инструкцией цикла.

Инструкция выбора является обобщением условной инструкции и позволяет сделать выбор из произвольного числа имеющихся вариантов, т. е. организовать ветвление на произвольное число направлений. Эта инструкция состоит из выражения, называемого селектором, списка вариантов и необязательной ветви else, имеющей тот же смысл, что и в условной инструкции.

Формат оператора выбора имеет следующий вид:

case <Выражение-селектор> of

<Список1> : <Инструкция1>;

...

<СписокN> : <ИнструкцияN>

else <Инструкция>;

end;

Выражение-селектор должно быть порядкового типа. Каждый из вариантов выбора (от список1 до списокN) представляет собой список констант, отделенных двоеточием от относящейся к данному варианту инструкции (инструкция может быть составной). Список констант выбора состоит из произвольного количества уникальных значений и диапазонов, отделенных друг от друга запятыми. Границы диапазона записываются двумя константами через разделитель «...». Тип констант должен совпадать с типом выражения-селектора.

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

Пример инструкции выбора:

case DayNumber of

2 ... 6 : strDay:='Рабочий день';

7 : strDay: = 'Короткий день'

else strDay:='Выходной день';

end;

Процедуры и функции, реализующие диалоговые окна

Процедура ShowMessage, функции MessageDlg, MessageDlgPos и MessageBox отображают окно вывода сообщений, а функции InputBox и InputQuery — окно для ввода информации.

Процедура ShowMessage (const Msg: String) отображает окно сообщения с кнопкой ОК. Заголовок содержит название исполняемого файла приложения, а строка Msg выводится как текст сообщения.

procedure TForm1.Button1Click(Sender: TObject);

begin

ShowMessage('Сообщение');

end;

Функция MessageDlg(const Msg: String; AType: TMsgDlgType; AButtons: TMsgDlgButtons; Helpctx: Longint) : word отображает окно сообщения в центре экрана и позволяет получить ответ пользователя. Параметр Msg содержит отображаемое сообщение.

Окно сообщения может относиться к различным типам и наряду с сообщением содержать картинки. Тип окна сообщения определяется параметром АТуре, который может принимать следующие значения:

mtWarning (окно содержит черный восклицательный знак в желтом треугольнике и заголовок Warning);

mtError (окно содержит белый косой крест в красном круге и заголовок Error);

mtInformation (окно содержит синюю букву «i» в белом круге и заголовок Information);

mtConfirmation (окно содержит синий знак «?» в белом круге и заголовок Confirmation);

mtCustom (окно не содержит картинки, в заголовке выводится название исполняемого файла приложения).

Параметр AButtons задает набор кнопок окна и может принимать любые комбинации следующих значений:

mbYes (кнопка Yes);

mbAbort (кнопка Abort);

mbNo (кнопка No);

mbRetry (кнопка Retry);

mbOk (кнопка OK);

mbIgnore (кнопка Ignore);

mbCancel (кнопка Cancel);

mbAll (кнопка All);

mbHelp (кнопка Help);

Для значения параметра AButtons имеются две константы — mbYesNoCancel и mbOKCancel, задающие предопределенные наборы кнопок:

mbYesNoCancel = [mbYes, mbNo, mbCancel];

mbOKCancel = [mbOK, mbCancel]

При нажатии любой из указанных кнопок (кроме кнопки Help) диалоговое окно закрывается, а результат (свойство ModalResult) возвращается функцией MessageDlg.

Функция MessageDlgPos(const Msg: String; AType: TMsgDlgType; AButtons: TMsgDlgButtons; HelpCtx: Longint; X, Y: Integer) : Word отличается от функции MessageDlg наличием параметров Х и Y, управляющих положением окна на экране.

Функция InputBox(const ACaption, APrompt, ADefault: String): String отображает диалоговое окно для ввода строки текста. Окно выводится в центре экрана и содержит поле ввода с надписью, а также кнопки ОК и Cancel.

Параметр ACaption задает заголовок окна, а параметр APrompt содержит поясняющий текст к полю ввода. Параметр ADefault определяет строку, возвращаемую функцией при отказе пользователя от ввода информации (нажатие кнопки Cancel или клавиши <Esc>).

Пример использования функции InputBox:

rezult := InputBox('Город', 'Введите название города’, 'Владикавказ');

Приведенная процедура отображает окно запроса на ввод названия города. По умолчанию предлагается Владикавказ.

Функция InputQuery (const ACaption, APrompt: String; var Value: String): Boolean отличается от функции InputBox тем, что вместо третьего параметра - строки по умолчанию - используется параметр Value, который в случае подтверждения ввода содержит введенную пользователем строку.

В качестве результата функция возвращает логическое значение, позволяющее определить, каким образом завершен диалог. Если нажата кнопка ОК, то функция возвращает значение True, если нажата кнопка Cancel или клавиша <Esc> — значение False. C помощью функции InputQuery выводится окно запроса

var

NewString:string;

begin

NewString := 'Владикавказ';

if InputQuery('Город', 'Введите название города', NewString) = true

then ShowMessage('Вы нажали кнопку Ok')

else ShowMessage('Вы нажали кнопку Cancel');

end;

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

Функция MessageBox(Parent: HWnd; Txt, Caption: PChar; TextType: Word): Integer создает и отображает блок диалога, содеpежащий указанное сообщение и заголовок, а также предопределенные пиктограммы и текстовые кнопки, в соответствии с параметром TexType.

Параметры:

Parent - окно, владеющее блоком сообщений.

Txt - отобpажаемое сообщение.

Caption - заголовок блока диалога.

TextType: одна или комбинация констант mb_.

Возвращаемое значение:

В случае успешного завеpшения одна из следующих констант: id_Abort, id_Cancel, id_Ignore, id_No, id_OK, id_Retry или id_Yes.

Пример использования функции MessageBox:

case MessageBox(Application.handle, 'Сохранить изменения', 'Предупреждение', MB_ICONQUESTION + MB_YESNOCANCEL + MB_DEFBUTTON3)

of

mrYes: begin

AssignFile (F,'Save.dat');

Rewrite(F);

WriteLn(F,X);

CloseFile(F);

end;

mrNo: Close;

mrCancel: exit;

end;