extracted_text:
билет 25 тема 2
77 Характеристика интегрированной среды разработки программ Delphi.
Создание прикладных программ, или приложений, в Delphi выполняется в интегрированной среде
разработки IDE (Integrated Development Environment). IDE служит для организации взаимодействия с
программистом и включает в себя ряд окон, содержащих различные элементы управления. С
помощью средств интегрированной среды разработчик может проектировать интерфейсную часть
приложения, а также писать программный код, и связывать его с управляющими элементами. При
этом вся работа по созданию приложения, включая отладку, происходит в IDE.
Главные составные части среды программирования
Интегрированная среда программирования Delphi состоит из следующих основных частей:
1.
2.
3.
4.
5.
Главное окно
Дизайнер форм (Form Designer)
Редактор исходного текста (Editor Window)
Палитра компонентов (Component Palette)
Инспектор объектов (Object Inspector)
В главном окне отображается Главное меню, Панель инструментов и Палитра компонентов (см.
рисунок). Главное меню содержит обширный набор команд для доступа к функциям Delphi. Панель
инструментов находится под Главным меню в левой части Главного окна и содержит 15 кнопок
быстрого доступа для вызова часто используемых команд Главного меню. Палитра компонентов
находится справа от Панели инструментов и содержит множество компонентов, размещаемых в
создаваемых приложениях. Все компоненты делятся на группы, каждая из которых в Палитре
компонентов располагается на отдельной странице (Standard, Additional, Win 32 и др.).
Рисунок  Приложение Delphi.
Дизайнер форм в Delphi служит для создания визуального интерфейса программы (рис. 9). Дизайнер
Форм первоначально состоит из одного пустого окна, которое заполняется компонентами,
выбранными в Палитре компонентов.
Редактор исходного текста (Редактор кода) представляет собой текстовый редактор, с помощью
которого можно создавать и редактировать программный код (рис. 9).
Инспектор объектов состоит из двух страниц, каждую из которых можно использовать для
определения поведения данного компонента (рис. 9). Первая страница – это список свойств, вторая –
список событий. Если нужно изменить чтонибудь, связанное с определенным компонентом, то
обычно делается это в Инспекторе объектов. Страница событий связана с Редактором кода. Если
дважды щелкнуть мышкой на правую сторону какоголибо пункта, то соответствующий данному
событию код автоматически запишется в Редактор. Сам Редактор немедленно получит фокус, и
появится возможность добавить код обработчика данного события.
Организация проекта, основные файлы проекта
Проект в Delphi состоит из форм, модулей, установок параметров проекта, ресурсов и т.д. Вся эта
информация размещена в файлах: файл проекта (.dpr); файл модуля (.pas); описание формы (.dfm);
описание ресурсов (.res); параметры проекта (.dof); параметры среды (.cfg); исполняемый файл
(.exe).
Типичная головная программа приложения имеет вид:
program Project1; uses
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
Текст модуля имеет вид.
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}
{Сюда могут помещаться предложения uses, объявления типов, констант, переменных, к которым не
будет доступа из других модулей. Тут же должны быть реализации всех объявленных в разделе
interface функций и процедур, а также могут быть реализации любых дополнительных, не
объявленных ранее функций и процедур.}
end.

file_name: билет 25 тема 2.docx

title: Лекция "Характеристика интегрированной среды разработки программ Delphi."


extracted_text:
билет 25 тема 3
1. Охарактеризуйте составные элементы реляционной модели данных и формы
их представления.
Реляционная модель данных (РМД) некоторой предметной области – это набор
изменяющихся во времени отношений. Элементы РМД и формы их представления
приведены в таблице:
Элемент реляционной модели  Форма представления
Отношение
Схема отношения
Кортеж
Сущность
Атрибут
Домен
Значение атрибута
Первичный ключ
Тип данных
Таблица
Заголовок таблицы
Строка таблицы
Описание свойств объекта
Заголовок столбца таблицы
Множество допустимых значений атрибута
Значение поля в записи
Один или несколько атрибутов
Тип значений элементов таблицы.
Отношение – это двумерная таблица, содержащая некоторые данные.
Сущность– объект любой природы, данные о котором хранятся в отношении БД.
Атрибуты – свойства, которые характеризуют сущность. Атрибут имеет имя и ему
соответствует заголовок некоторого столбца таблицы. Перестановка атрибутов не
приводит к образованию нового отношения.
Домен – множество всех возможных значений определенного атрибута отношения.
Кортеж — упорядоченный набор фиксированной длины.
Первичным ключом (ключом отношения, ключевым атрибутом) называется атрибут
отношения, однозначно идентифицирующий каждый из его кортежей. Например, для
отношения СТУДЕНТ ключевым является атрибут “ФИО”.
Схема отношения (заголовок отношения) – это список имен атрибутов. Например,
СТУДЕНТ(ФИО,Группа,Дата_рожд).

file_name: билет 25 тема 3.docx

информатика

group: Дисциплины

title: Лекция "Охарактеризуйте составные элементы реляционной модели данных и формы их представления."


extracted_text:
билет 26
83 Базовые классы VCL. Характеристика. Примеры.
Все классы библиотеки визуальных компонентов (VCL) произошли от группы базовых
классов, которые лежат в основе иерархии. Самый общий предок компонентов — это класс
TObject, инкапсулирующий простейший объект. Как известно (см. гл. 1), каждый объект
наследует свойства и методы родительского класса. К объекту можно добавить новые
свойства и методы, но нельзя удалить унаследованные. Объектнаследник в свою очередь
может стать родительским для нового класса, который унаследует возможности всех своих
предков.
Поэтому иерархия базовых классов VCL продумана чрезвычайно тщательно — ведь на их
основе создано все множество компонентов. Особое место среди базовых классов, помимо
TObject, занимают TComponent (от него происходят все компоненты) и TControl (от него
происходят все элементы управления).
В этой главе рассматриваются иерархия базовых классов и их возможности.
Представленные здесь сведения помогут разобраться с основными механизмами
функционирования компонентов. Также глава послужит справочным материалом для тех,
кто создает собственные объекты и элементы управления.
Иерархия базовых классов
В основе всего многообразия классов и компонентов, используемых в Delphi, лежат всего
лишь несколько базовых классов (рис. 2.1). Благодаря механизму наследования свойств и
методов, потомки базовых классов умеют "общаться" друг с другом, работают в среде
разработки, взаимодействуя с Палитрой компонентов и Инспектором объектов,
распознаются операционной системой как элементы управления и окна.
В основе иерархии классов лежит класс TObject. Он обеспечивает выполнение важнейших
функций "жизнедеятельности" любого объекта. Благодаря ему каждый класс получает в
наследство механизмы создания экземпляра объекта и его уничтожения.
Класс Tpersistent происходит непосредственно от класса TObject. Он обеспечивает своих
потомков возможностью взаимодействовать с другими объектами.
Класс TComponent является важнейшим для всех компонентов. Непосредственно от него
можно создавать любые невизуальные компоненты. Механиз
мы, реализованные в классе TComponent, обеспечивают взаимодействие компонента со
средой разработки, главным образом с Палитрой компонентов и Инспектором объектов.
Благодаря возможностям этого класса компоненты начинают "работать" уже во время
разработки проекта.
Рис. 2.1. Иерархия базовых классов VCL
Класс TControl происходит от класса TComponent. Его основное назначение — обеспечить
функционирование визуальных компонентов.
Класс TwinControl расширяет возможности разработчиков по созданию элементов
управления. Он наследует от TControl и обеспечивает создание оконных элементов
управления. На уровне TwinControl обеспечивается взаимодействие с GUI (Graphic User
Interface — Графический Интерфейс Пользователя).
На основе класса TwinControl создан еще один дополнительный класс — TCustomControl.
Он обеспечивает создаваемые на его основе компоненты возможностями по использованию
канвы — специального объекта, предназначенного для рисования графики Ниже мы остановимся на основных свойствах и методах базовых классов, выделяя только
те, которые могут пригодиться в реальной работе. Часть из них опубликована и доступна в
Инспекторе объектов, часть может быть установлена и использована только в программном
коде.
Класс TPersistent
"Persistent" в переводе с английского означает "устойчивый", "постоянный". Что же такого
постоянного в одноименном классе? Ответ таков: виртуальный метод
procedure Assign(Source: TPersistent);
Этот важнейший метод осуществляет копирование содержимого одного объекта (source) в
другой (self, то есть в объект, вызвавший метод Assign). При этом объектполучатель
остается самим собой, чего нельзя достигнуть, используя простое присваивание
переменных объектного типа:
FirstObject := SecondObject;
Ведь в этом случае указатель на одну область адресного пространства, содержащую
экземпляр класса (объект), замещается указателем на другую область адресного
пространства, содержащую другой объект.
Метод Assign позволяет продублировать объект — присвоить одному объекту значения
всех свойств другого. При этом объекты не обязательно должны быть одного и того же
класса; более того, они не обязательно должны находиться в отношениях "родитель
потомок"! Данный метод тем и хорош, что позволяет полиморфное присвоение.
Конструкция
Clipboard.Assign( Picture );
позволяет скопировать содержимое картинки picture в папку обмена Windows (объект
clipboard). Какова здесь логика? Известно, что в папку обмена можно поместить растровую
картинку, текст, метафайл, мультимедийные данные и т. п. Метод Assign класса rciipboard
переписан таким образом, чтобы обеспечить присвоение (то есть реальное перемещение в
папку обмена) всех этих данных.
procedure TClipboard.Assign(Source: TPersistent);
begin
if Source is TPicture then
AssignPicture(TPicture(Source)) else
if Source is TGraphic then
AssignGraphic(TGraphic(Source)) else
inherited Assign(Source);
end;
Для обеспечения взаимодействия потомков класса TPersistent со средой разработки
предназначен метод
function GetNamePath: string; dynamic;
Он возвращает имя объекта для передачи его в Инспектор объектов.
Для взаимодействия с потоками при загрузке и сохранении компонентов предназначен
следующий метод:
procedure DefineProperties(Filer: TFiler);
virtual;
Класс TPersistent никогда не используется напрямую, от него порождаются потомки,
которые должны уметь передавать другим объектам значения своих свойств, но не
являться при этом компонентами.
Класс TComponent
Класс TComponent является предком всех компонентов VCL. Он используется в качестве
основы для создания невизуальных компонентов и реализует основные механизмы, которые
обеспечивают функционирование любого компонента. В нем появляются первые свойства,
которые отображаются в Инспекторе объектов. Это свойство
property Name: TComponentName; Оно содержит имя экземпляра компонента, которое используется для идентификации
компонента в приложении.
Тип TComponentName представляет собой обычную строку.

Свойство
property Tag: Longint;
является вспомогательным и не влияет на работу компонента. Оно отдано на откуп
разработчику, который может присваивать ему значения по своему усмотрению. Например,
это свойство можно использовать для дополнительной, более удобной идентификации
компонентов. Пример его использования для определения кнопок приведен в предыдущей
главе.
Определение методаконструктора TComponent выглядит лаконично, в нем присутствует
указатель на единственный параметр AOwner:
constructor Create(AOwner: TComponent);
Смысл его таков: owner — это тот объект, который при создании вызывает конструкторы
всех объектов, владельцем которых он является, а при уничтожении — их деструкторы.
Таким образом, поместив при разработке компонент на форму, вы можете не заботиться о
его создании и уничтожении в программе. Все свойства таких компонентов и все связи
между ними запоминаются в файле формы (.dfm) и при запуске приложения создаются
вновь автоматически.
Деструктор компонента:
destructor Destroy;
уничтожает все дочерние компоненты (вызывая их деструкторы) и вычеркивает себя из
списка компонентавладельца.
Для реализации описанной иерархии компонентов в классе TComponent введен механизм
учета и управления компонентами, для которых данный компонент является владельцем.
Свойства и методы, которые отвечают за управление, приведены в табл. 2.1.
Таблица 2.1. Методы и свойства для управления списком компонентов
Свойство (метод)
Описание
property Components[Index: Integer]:
TComponent;
Содержит индексированный список указателей
всех компонентов, для которых данный компонент
является владельцем (Owner)
property ComponentCount: Integer;
Число подчиненных компонентов
property Owner: TComponent;
Указывается, какой компонент является
владельцем данного
property Component Index: Integer;
Индекс данного компонента в списке владельца
procedure InsertCompo
nent(AComponent: TComponent) ;
Вставляет компонент AComponent в список procedure R (AComponent:
TComponent);
Удаляет компонент AComponent из списка
procedure FindComponent (AName:
string): TComponent;
Осуществляет поиск компонента по имени AName
procedure DestroyComponents;
Предназначен для уничтожения всех компонентов,
подчиненных данному
Очень важное свойство
type TComponentState = set of (csLoading, csReading, csWriting, csDestroying, csDesigning,
csAncestor, csUpdating, csFixups) ;
property Component State: TComponentState;
дает представление о текущем состоянии компонента. В табл. 2.2 описаны возможные
значения свойства. Состояние может измениться в результате получения компонентом
некоторого сообщения, действий разработчика, выполнения акции и т. д. Это свойство
активно используется средой разработки.
Таблица 2.2. Возможные состояния компонента
Состояние
Описание
csLoading
Устанавливается при загрузке компонента из потока
csReading
Устанавливается при чтении значений свойств из потока
csWriting
Устанавливается при записи значений свойств в поток
csDestroying
Устанавливается при уничтожении компонента
csDesigning
Состояние разработки. Устанавливается во время работы с формой
во время разработки
csAncestor
Устанавливается при переносе компонента на форму. Для перехода в
это состояние должно быть уже установлено состояние csDesigning
csUpdating
Устанавливается при изменении значений свойств и отображения
результата на формевладельце. Для перехода в это состояние должно быть уже установлено состояние csAncestor
csFixups
Устанавливается, если компонент связан с компонентом другой
формы, которая еще не загружена в среду разработки
Для обеспечения работы механизма действий (Actions, см. гл. 12) предназначен метод
function ExecuteAction(Action: TBasicAction): Boolean; dynamic;
Он вызывается автоматически при необходимости выполнить акцию, предназначенную для
данного компонента.
На уровне класса TComponent обеспечена поддержка СОМинтерфейсов
Unknown и IDispatch (cм. гл. 26).
Посредством свойства
property ComObject: lUnknown;
вы можете обеспечить использование методов этих интерфейсов.
Таким образом, класс TComponent имеет все для использования в качестве предка для
создания собственных невизуальных компонентов.
Базовые классы элементов управления
Вслед за классом TComponent в иерархии базовых классов (см. рис. 2.1) располагается
группа из трех классов, которые обеспечивают создание различных визуальных
компонентов. Визуальные компоненты — это разнообразные стандартные для Windows и
специальные (созданные разработчиками Inprise) элементы управления.
Понятно, что визуальные компоненты должны уметь отобразить себя на экране монитора и
реагировать на целый ряд новых событий (реакция на мышь и клавиатуру). Для этого в них
встроен специальный механизм, обеспечивающий взаимодействие компонентов с
графической подсистемой ОС (GUI).
Существует несколько типов элементов управления, которые существенно отличаются по
своим возможностям и поведению. Каждому типу соответствует собственный класс
иерархии.
Класс TWinControl обеспечивает использование в Delphi оконных элементов управления.
Главное отличие оконного элемента управления от любых других — наличие дескриптора
окна hWnd. Дескриптор окна — это специальный
идентификатор, который операционная система присваивает всем объектам, которые
должны обладать свойствами окна. Если элемент управления имеет дескриптор окна, то он
должен уметь выполнять следующие операции:



получать и передавать фокус управления во время выполнения приложения;
воспринимать управляющие воздействия от мыши и клавиатуры;
уметь размещать на себе другие элементы управления.
Оконными элементами управления являются не только формы, но и практически все
стандартные элементы управления Windows: и списки, и редакторы имеют дескриптор
окна.
Оконные элементы управления имеют еще одного общего предка. Это класс
TCustomControl. Он существенно облегчает использование элементов управления, так как
позволяет управлять отрисовкой компонента путем использования специального класса
TCanvas — так называемой канвы (см. гл. 13) вместо обращения к системным функциям
GUI.
Для обеспечения создания обычных (не оконных) элементов управления непосредственно
от класса TControl порожден класс TGraphicControi. Его потомки не могут получать
фокус, но используют для визуализации канву. Класс TControl
Класс TControl является базовым для всех визуальных компонентов и инкапсулирует
основные механизмы "поведения" всех компонентов. В нем используется множество новых
свойств и методов. Недаром в Delphi 5 в Инспекторе объектов впервые появилась
категоризация методов и свойств (рис. 2.2). Большинство из них вводятся как раз в классах
TControl и TWinControl.
Рассмотрим только важнейшие свойства и методы по категориям.
Рис. 2.2. Категории свойств визуального компонента. Для представлении их в таком
виде нужно отметить флажок By Category в пункте меню Arrange всплывающего
меню Инспектора объектов
Размер и местоположение элемента управления
Для определения местоположения и размеров визуального компонента введены два
опубликованных свойства для задания координат левого верхнего угла:
property Тор: Integerproperty Left: Integer;
И два опубликованных свойства для определения размеров:
property Height: Integer;
property Width: Integer;
Значения свойств задаются в пикселах. Для определения местоположения используется
система координат рабочей области родителя данного компонента. Начало отсчета
находится в левом верхнем углу. Оси направлены вправо и вниз. Под рабочей областью
понимается та часть площади родительского окна (формы, панели), которая предназначена
для размещения дочерних элементов. Для формы верхний левый угол выражен в системе
координат экрана. Эти свойства можно использовать как на этапе разработки, так и во
время выполнения.
Подругому к этим же значениям можно обратиться через свойство
property BoundsRect: TRect;
которое определяет тот же прямоугольник (Left, Top, Left+width, тор+Height). Также
можно установить положение и размер компонента, изменяя координаты верхнего левого
угла, длины и ширины методом:
procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); virtual;
Свойство
property ClientOrigin: TPoint; содержит координаты левого верхнего угла элемента управления в системе координат
экрана. Координаты любой точки можно пересчитать в экранные при помощи метода:
function ClientToScreen(const Point: TPoint): TPoint;
и наоборот:
function ScreenToClient(const Point: TPoint): TPoint;
У большинства визуальных компонентов есть так называемая рабочая (клиентская)
область, в которой могут размещаться дочерние элементы управления и которая
отрисовывается стандартными методами. Параметры рабочей области компонента
определяются следующими свойствами:
property ClientHeight: Integer;
определяет высоту рабочей области в пикселах.
property ClientWidth: Integer;
определяет ширину рабочей области в пикселах. Комуто будет удобнее пользоваться
свойством
property ClientRect: TRect;
значение которого есть ни что иное, как (0, 0, ClientWidth, ClientHeight).
Оно доступно только для чтения.
Выравнивание и масштабирование элемента управления
Для выравнивания компонента в рабочей области его родителя применяется свойство:
property Align: TAlign;
Тип TAlign объявлен следующим образом:
type TAlign = (aINone, alTop, alBottom, alLeft, alRight, alClient);
При значении aiNone выравнивание отсутствует. При следующих четырех значениях
выравнивание осуществляется по соответствующей стороне. Значение alciient приводит к
тому, что элемент управления изменяет свои размеры до размеров рабочей области
родителя.
Выравнивание гарантирует, что при изменении размеров родителя относительная позиция
дочернего элемента не меняется. Это свойство имеет приоритет над простым изменением
положения и размеров. Если новые координаты элемента противоречат способу его
выравнивания (например, перемещение вверх при alBottom), изменения отвергаются и
элемент возвращается к первоначальным координатам. Свойство Align незаменимо при
организации панелей инструментов и строк состояния — они могут перемещаться и
видоизменяться вместе с содержащей их формой.
Для временного отключения действия свойства Align предназначены методы:
procedure DisableAlign;
procedure EnableAlign;
Эти методы управляют возможностью выравнивания потомков данного элемента, они
должны вызываться в паре. Для восстановления выравнивания элементов в соответствии с
Align есть метод:
procedure Realign;
В следующем примере использование методов DisableAlign и EnableAlign позволяет
настроить выравнивание панели по тому краю формы, на который пользователь перетащит
ее мышью:
procedure TFormI.FormCreate(Sender: TObject);
begin
Panel1.Align := alBottom;
Moving := Falser; end;
procedure TFormI.PanellMouseDown(Sender: TObject;
Button: TMouseButton;
Shift: TShiftState; X, Y: Integersbegin
if not Moving then
begin Forinl. DisableAlign;
Moving := True;
end;
end;
procedure TForml.Panel1MouseMove(Sender: TObject;Shift: TShiftState; X, Y:
Integer) ;
begin
if Moving then with Panel1 do
begin
Left := Left + X  Width div 2;
Top := Top + Y  Height div 2;
Panell.Caption := Format('%d,%d',[Left,Top]);
end;
end;
procedure TForml.PanelIMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var LastPos : TPoint; rO, rl, r2 : real;
begin
if Moving then
begin
Moving := False;
Panell.Caption := '';
LastPos := Point(Panell.Left + X, Panell.Top + Y);
if LastPos.X<=0 then LastPos.X := 1;
if LastPos.X>=ClientWidth then LastPos.X := ClientWidth1;
if LastPos.Y<=0 then LastPos.Y := 1;
if LastPos.Y>=ClientHeight then LastPos.Y := ClientHeight1;
rO := ClientWidth/ClientHeight;
rl := LastPos.X/LastPos.Y;
r2 := LastPos.X/(ClientHeight  LastPos.Y);
with Panell do if r1 < r0 then if r2 < r0
then Align := a1Left else
Align := alBottom else
then Align := alTop if r2 < r0 else Align := alRight;
Form1.EnableAlign;
end;
end;
В предыдущей версии Delphi появились два свойства, сильно облегчающие поддержание
нормальных размера и положения элемента управления при изменении разрешения экрана и
размера окна. Эти свойства — Constraints
И Anchors. Свойство property Anchors: TAnchors;
type TAnchors = set of TAnchorKind;
type TAnchorKind = (akTop, akLeft, akRight, akBottom);
обеспечивает фиксацию элемента управления по сторонам родительского элемента
управления. "Якорь" можно установить по одной, двум, трем или четырем сторонам. При
задании якоря по любой стороне расстояние между данной стороной и элементом
управления сохраняется неизменным. По умолчанию любой компонент привязан к верхней
и левой сторонам ([akLeft, akTop]), то есть не двигается при стандартном масштабировании
(за нижний правый угол окна). Комбинируя установку якорей для различных сторон,
можно добиться различных вариантов поведения компонента при изменении размеров
родителя. Если по вертикали или горизонтали якорь не установлен вообще, то при изменении
размеров владельца компонент остается на том же месте с учетом изменившегося размера.
С другой стороны, если прикрепить все четыре стороны, то получится интересный и
нужный во многих случаях эффект. Такой компонент увеличивается и уменьшается вместе
с формой; но в то же время сохраняется расстояние до всех четырех ее краев.
Но как избежать того, что в процессе масштабирования элемент управления станет
слишком большим или слишком маленьким (вплоть до полного исчезновения с экрана)?
Тут на помощь приходит свойство
property Constraints: TSizeConstraints;
Значение этого свойства — четверка чисел Minwidth, Maxwidth, MinHeight, MaxHeight.
Они могут задаваться в Инспекторе объектов или во время выполнения. Об их смысле
догадаться нетрудно — это минимальные и максимальные размеры компонента. При
масштабировании родительского окна гарантируется, что размеры компонента будут
изменяться только в этих пределах. Наконец, если нужна еще более глубокая проработка
вопросов масштабирования, можно написать свои обработчики двух событий,
предусмотренных в классе TControl:
property OnCanResize: TCanResizeEvent;
type TCanResizeEvenc = procedure(Sender: TObject;
var
NewWidth, NewHeight: Integer;
var
Resize: Boolean) of object;
property OnConstrainedResize: TConstrainedResizeEvent;
type TConstrainedResizeEvent = procedure(Sender: TObject;
var
MinWidth, MinHeight, MaxWidth, MaxHeight: Integer) of object;
Описав обработчики этих событий, вы сначала можете разрешить или запретить изменение
размеров до значений NewWidth, NewHeight (вернув значение В параметре Resize). Затем,
В Обработчике OnConstrainedResize
Вы можете задать минимальные и максимальные размеры для каждого конкретного случая
в отдельности. Наконец, когда масштабирование полностью закончено, произойдет
событие:
property OnResize: TNotifyEvent;
Свойствам Align, Constraints и Anchors не такто легко "ладить" друг с другом.
Одновременное задание их может породить конфликты. Конечно, ваша программа от
этого не завершится аварийно, но компоненты могут получить не те позиции и
размеры, которые вы ожидали.
Наконец, большинство элементов управления имеет свойство
property AutoSize: Boolean;
которое обеспечивает автоматическое изменение размеров компонента в соответствии с
размерами его содержимого (текста, изображения, списка, иерархического дерева и т. д.).
Внешний вид элемента управления
Для определения цвета рабочей области компонента используется свойство:
При нахождении указателя мыши над компонентом изображение курсора может
изменяться в соответствии со значением свойства
property Color: TColor;
property Cursor: TCursor;
С каждым элементом управления связан некий текст, который может играть роль
заголовка или редактироваться. В зависимости от роли, текст может содержаться в
свойствах caption:
property Caption: TCaption;
TCaption = string[255]; либо Text:
property Text: TCaption;
Не задумываясь о том, в каком именно свойстве содержится текст, получить доступ к нему
можно посредством методов:
function GetTextBuf(Buffer: PChar; BufSize: Integer): Integer; procedure SetTextBuf(Buffer:
PChar);
function GetTextLen: Integer;
Все три метода работают, посылая в собственную функциюобработчик сообщений объекта
(через вызов метода perform) сообщения Windows
WM_GETTEXT, WM_SETTEXT И WM_GETTEXTLENGTH.
Шрифт для текста компонента задается свойством:
property Font: TFont;
Класс TFont, задающий все характеристики шрифта, подробно рассматривается в главе 8
"Использование графики".
Элемент управления можно сделать видимым или невидимым. Для этого применяется
свойство
property Visible: Boolean;
Этих же результатов можно достичь методами show (компонент видим) и Hide (компонент
невидим).
Для каждого элемента управления можно создать собственное всплывающее (контекстное)
меню. Ссылка на соответствующий компонент трорирмепи (см. гл. 6), хранится в свойстве
property PopupMenu: TPopupMenu;
Перед тем как происходит вызов меню, инициируется событие
property OnContextPopup: TContextPopupEvent;
type TContextPopupEvent = procedure(Sender: TObject; MousePos: TPoint, var
Handled: Boolean) of object;
В его обработчике можно изменить значение параметра Handled. Если оно равно True,
вызов меню не производится.
Текущее состояние элемента управления определяется .свойством
ControlState:
type TControlState = set of (csLButtonDown, csClicked, csPalette,
csReadingState, csAlignmentNeeded, csFocusing, csCreating, csCustomPaint,
csDestroyingHandle, csDocking);
property ControlState: TControlState;
Описание возможных значений свойства представлены в табл. 2.3.
Таблица 2.3. Возможные состояния элемента управления
Состояние
Описание
CsLButtonDown
Левая кнопка мыши нажата, но еще не отпущена. Используется
для реализации события OnMouseDown
CsClicked
Левая кнопка мыши нажата, но еще не отпущена. Используется
для реализации события OnClick
csPalette
Состояние соответствует режиму изменения палитры. Это реакция на сообщение wm palettchanged
csReadingState
Осуществляется чтение значений свойств из потока (см. табл.
2.1)
csAlignmentNeeded
Осуществляется выравнивание компонента
csFocusing
Элемент управления получает фокус
csCreating
Создаются элемент управления и его дочерние элементы
csCustomPaint
Элемент управления выполняет нестандартные операции
отрисовки, заданные разработчиком
CsDestroyingHandle
Указатель на объект элемента управления уничтожается
CsDocking
Элемент управления находится в режиме переноса
В зависимости от совокупности установленных свойств, элемент управления может
соответствовать одному из возможных стилей, который задается свойством
type TControlStyle = set of (csAcceptsControis, csCaptureMouse,
csDesignInteractive, csFramed, csClickEvents, csSetCaption, csOpaque,
csDoubleClicks, csFixedWidth, csFixedHeight, csNoDesignVisible,
csReplicatable, csNoStdEvents, csDisplayDragImage, csReflector,
csActionClient, csMenuEvents) ;
property ControlStyle: TControlStyle;
Доступность элемента управления в целом определяется свойством
property Enabled: Boolean;
При значении True элемент управления полностью работоспособен. При значении False
элемент управления неактивен и отображается серым цветом.
Для получения контекста устройства hdc элемента управления используется метод
function GetDeviceContext(var WindowHandle: HWnd): HDC; virtual;
Набор свойств и методов класса TWinControl обеспечивает функционирование механизма
перетаскивания (DragandDrop) и механизма переноса (см. гл. 12). В классе TControi
впервые появляются методыобработчики событий, которые обеспечивают передачу в
элемент действия мыши, перенос и перетаскивание.
Связь с родительским элементом управления
Механизм связывания визуального компонента с родительским компонентом (владельцем)
позволяет автоматически задавать для нового элемента управления некоторые свойства,
отвечающие за его внешний вид (см. выше). В результате все дочерние элементы
управления для одного родительского (формы, панели) будут выглядеть одинаково
оформленными. Родительский компонент задается свойством
property Parent: TWinControl;
Для каждого дочернего элемента управления можно задать значения нескольких свойств:
property ParentBiDiMode: Boolean;
property ParentColor: Boolean; property ParentFont: Boolean;
property ParentShowHint: Boolean;
Каждое из них управляет одной характеристикой визуализации элемента.
Метод
function HasParent: Boolean; override;
используется для того, чтобы определить, имеется ли у компонента родитель вообще.
Класс TWinControl
Класс TWinControi обеспечивает создание и использование оконных элементов
управления. Напомним, что оконный элемент управления имеет системный дескриптор
окна (hwnd). С помощью этого дескриптора вы можете вызывать функции API Windows,
если средств VCL вам недостаточно для решения задачи. Оконными элементами являются
не только формы и диалоги, но и большинство стандартных элементов управления: окна
ввода, списки, панели и т. п.
Новые механизмы, инкапсулированные в классе, обеспечивают выполнение функций,
характерных для оконных элементов: прием и передачу фокуса, отклик на действия
мышью и ввод с клавиатуры и т. д. Рассмотрим основные свойства и методы класса.
Дескриптор окна содержится в свойстве
property Handle: HWND;
При создании оконного элемента управления вызывается метод
procedure CreateParams(var Params: TCreateParams); virtual;
который заполняет структуру TCreateParams необходимыми значениями:
type
TCreateParams = record
Caption: PChar;
Style: DWORD;
ExStyle: DWORD;
X, Y: Integer;
Width, Height: Integer;
WndParent: HWND;
Param: Pointer
WindowClass: TWndClass;
WinClassName: array[0..63] of Char;
end;
Для создания дескриптора окна для элемента управления используется метод
procedure CreateHandle; virtual;
Операционная система создает дескриптор окна только вместе с самим окном. Поэтому
метод CreateHandle только создает окно, а для присваивания свойству Handle значения
дескриптора окна вызывает метод createwnd.
Важной особенностью TWinControl является то, что он может содержать другие —
дочерние — элементы управления. Они упорядочены в виде списка. Если быть точным, то
списков на самом деле два: для неоконньгх и оконных дочерних элементов. Но "видны" они
как один объединенный:
сначала первый, потом второй.
Методы и свойства для работы с этим списком приведены в таблице 2.4:
Таблица 2.4. Методы и свойства, управляющие списком дочерних элементов
управления Свойство
Значение
property Controls[Index: Integer]:
TControl;
Содержит список дочерних элементов
property ControlCount: Integer;
Содержит число элементов в списке
function ContainsControl (Control:
TControl): Boolean;
Проверяет наличие элемента в списке
Function ControlAtPos(const Pos:
TPoint; AllowDisabled: Boolean):
TControl;
Отыскивает в списке элемент, которому принадлежит
заданная точка (в системе координат собственной
клиентской области). Флаг AllowDisabled показывает,
разрешен ли поиск среди пассивных (свойство Enabled
которых равно False) элементов
Procedure InsertControl(AControl:
TControl) ;
Вставляет элемент в конец списка
procedure RemoveControl
(AControl: TControl);
Удаляет элемент из списка
procedure Broadcast (var Message);  Рассылает всем дочерним элементам из списка
сообщение Message
Для передачи фокуса между элементами управления на одной форме часто используется
клавиша <Таb>. Порядок перемещения фокуса между элементами определяется свойством
type TTabOrder = 1..32767;
property TabOrder: TTabOrder;
В первую очередь фокус передается компоненту с минимальным значением свойства.
Далее — по возрастанию значения. При переносе компонента на форму это значение
устанавливается автоматически в соответствии с числом компонентов на форме.
Компонент можно заставить не откликаться на клавишу <ТаЬ>. Для этого свойству
property TabStop: Boolean;
необходимо присвоить значение False.
Будучи окнами Windows, компонент TWinControl и его потомки должны управлять
фокусом ввода (состоянием, когда они получают и обрабатывают входные сообщения).
Они имеют предназначенные для этого методы:
function Focused: Boolean;
показывает, имеет ли элемент в данный момент фокус ввода;
function CanFocus: Boolean; возвращает True, если оконный элемент может получить фокус ввода (для этого он и все
его родительские оконные элементы управления должны быть активными (Enabled)
видимыми);
procedure SetFocus;
virtual;
запрашивает у родительской формы получение фокуса ввода. При получении и утере
фокуса оконными компонентами происходят события:
property OnEnter: TNotifyEvent;
property OnExit: TNotifyEvent;
Все оконные элементы имеют рамку по контуру (впрочем, она может быть не видна). Ее
параметры задаются группой свойств:
85 Назначение классов TPersistent  и TComponent. Примеры.
Разработчикам компонентов вовсе не обязательно создавать свои компоненты как
непосредственные потомки класса  TОbjeсt. Библиотека VCL предоставляет широ кий
выбор  классов потомков класса TОbjeсt, и создаваемые компоненты могут быть
производными от них. Эти уже существующие  классы обеспечивают большинство
функциональных  возможностей, которые могут  понадобиться новым  компонентам. Лишь
 при  создании классов, не  являющихся компонентами, имеет  смысл  делать  их
потомками класса TОbjeсt.
Методы  Create() и Destroy() класса TОbjeсt предназначены для выделения и
освобождения памяти для экземпляра объекта. Конструктор TОbjeсt.Create() воз
вращает  указатель  на  созданный  объект.  Класс  TОbjeсt содержит  несколько  полез
ных функций, позволяющих получить информацию об объекте.
Библиотека VCL использует в основном внутренние вызовы методов класса  TОb jeсt, что
 позволяет получить необходимую информацию о типе  класса,  его  имени, базовых
классах (предках) для экземпляра любого  класса, поскольку  все они являются потомками
TОbjeсt.CОВЕТ
Используйте  метод  TObject.Free() вместо  метода  TObject.Destroy().  Метод Free
вызывает метод Destroy(), но перед этим проверяет, имеет ли указатель объ екта значение
nil, что позволяет избежать передачи исключения при попытке уничто жить
несуществующий объект.
Класс TPersistent
Класс  TPersistent происходит непосредственно от  класса  TОbjeсt. Особенно стью класса
TPersistent является то, что экземпляры происходящих от него объек тов могут читать и
записывать свои  свойства в поток.  Поскольку все компоненты яв ляются  потомками
класса  TPersistent, то  все  они  обладают этой  способностью. Класс  TPersistent
определяет не специальные свойства или  события, а только  не которые методы, полезные
как пользователям, так и разработчикам компонентов.
Методы класса TPersistent
В табл. 10.3 приведен список наиболее интересных методов, определенных в клас
се TPersistent.
Таблица 10.3. Методы класса TPersistent
Метод                                                 Назначение
Assign()           Этот   открытый  (public)   метод   позволяет  компоненту присваивать себе
данные, связанные с другим компонентом
AssignTo()         Это защищенный (protected) метод, в который производ ные   от  TPersistent
классы   должны   помещать  реали зацию  собственного метода  AssignTo(), объявленного в
VCL.  При   вызове  данного  метода   непосредственно  из класса  TPersistent передается исключение. С помощью такого  метода компонент может присвоить свои данные другому
экземпляру класса — операция, обратная выполняе мой методом Assign()
DefineProperties() Этот  защищенный метод  позволяет разработчику компо нентов
определить, каким образом компонент хранит значения дополнительных или  закрытых
свойств. Обыч но он используется для хранения в компонентах данных нестандартного
формата, например бинарных
Более  подробная информация о работе компонентов с потоками приведена в гла ве 12,
“Работа  с файлами”, предыдущего издания —  Delphi 5 Руководство разработчика,
находящегося на прилагаемом CD. А пока  достаточно знать,  что  с помощью потока
компоненты могут быть сохранены и прочитаны из файла  на диске.
Класс TComponent
Этот  класс происходит непосредственно от класса  TPersistent. Отличительны ми
 особенностями класса  TComponent являются возможность редактирования  его свойств в
окне  инспектора объектов и способность объектов данного класса  владеть другими
компонентами.
Невизуальные компоненты  также   происходят от  класса  TComponent,  наследуя
возможность  их  редактирования  в  процессе  разработки.  Компонент  TTimer —  пре
красный пример такого невизуального потомка класса TComponent. Не являясь визу
альным элементом управления, он, тем не менее,  доступен в палитре компонентов.
Класс TComponent определяет наиболее важные свойства и методы, описанные в
следующих разделах.
Свойства класса TComponent
Свойства класса TComponent и описание их назначения приведены в табл. 10.4.
Таблица 10.4. Специальные свойства класса TComponent
Свойство                                     Назначение
Owner                Указывает владельца компонента
ComponentCount         Определяет  количество  компонентов,  принадлежащих  дан
ному компоненту
ComponentIndex         Текущая позиция в списке компонентов, принадлежащих дан
ному компоненту. Первый компонент списка имеет номер 0
Components       Массив,  содержащий список  компонентов, принадлежащих данному
компоненту
ComponentState   Это  свойство содержит информацию о  текущем  состоянии компонента
типа  TComponentState. Дополнительная инфо рмация о  классе  TComponentState
содержится в интерак тивной справочной системе Delphi  и в главе 11, “Разработка
компонентов VCL”
ComponentStyle   Управляет  поведением  компонента.  Этому  свойству   могут быть
присвоены два значения — csInheritable и csCheck PropAvail. Их назначение объясняется в
интерактивной справочной системе Delphi
Name                 Содержит имя компонента
Tag              Целочисленное свойство без определенного значения. Пред назначено для
пользователей компонентов, а не их разработ чиков.  Благодаря целочисленному формату
свойство Tag может  быть использовано для хранения указателя  на структу ру данных или
экземпляр объекта
DesignInfo       Используется конструктором форм.  Значение этого  свойства изменять не
следует
Методы класса TComponent
Класс  TComponent определяет несколько методов, связанных с его  способностью владеть
другими компонентами и возможностью редактирования в конструкторе форм.
Класс  TComponent определяет конструктор компонентов Create(). Этот  конст руктор
 создает  экземпляр компонента и назначает ему владельца на основе переда ваемого  ему параметра. В отличие от конструктора TObject.Create(), конструктор класса
 TComponent.Create() является виртуальным. Потомки класса  TComponent, включающие
реализацию этого  конструктора, обязаны заявить о конструкторе Create(), используя
директиву override (переопределение). Хотя можно  использовать и другие конструкторы
для класса компонента, однако  лишь конструктор VCL TCom ponent.Create() позволяет
создать  экземпляр класса  во время  разработки или  за грузить компонент из потока во
время  выполнения программы.
Деструктор  TComponent.Destroy() уничтожает компонент  вместе  со  всеми  ре
сурсами, выделенными этим компонентом.
Метод  TComponent.Destroying() приводит сам  компонент и  принадлежащие ему
 компоненты в  состояние,  предшествующее их  уничтожению.  Метод  TCompo
nent.DestroyComponents() уничтожает все компоненты, принадлежащие данному
компоненту. Но эти методы  редко приходится использовать самостоятельно.
Метод TComponent.FindComponent() удобно использовать для получения указа теля на
компонент с известным именем. Предположим, что главная  форма имеет компонент TEdit
по имени Edit1. Тогда  для получения указателя  на экземпляр ком понента достаточно
выполнить следующий код:
EditInstance := FindComponent.(‘Edit1 );′
В этом  примере экземпляр компонента EditInstance должен  иметь  тип  TEdit. Метод
FindComponent возвратит значение nil, если  объект с указанным  именем не существует.
Метод  TComponent.GetParentComponent() позволяет найти экземпляр предка компонента.
Данный метод  возвращает значение nil в случае отсутствия такого  ком понента.
Метод  TComponent.HasParent() возвращает логическое значение, определяю щее, есть ли у
компонента родитель. Запомните, что этот метод не проверяет наличие владельца у
заданного компонента.
Метод  TComponent.InsertComponent() позволяет добавить компонент, переходя щий во
владение вызывающего компонента. Метод TComponent.RemoveComponent() удаляет  все
компоненты, принадлежащие тому компоненту, который вызвал  этот  метод. В обычных
случаях такие  методы  не используются, потому что они автоматически вызы ваются
конструктором компонента Create() и его деструктором Destroy().
Класс TControl
Класс TControl определяет свойства, методы  и события, общие  для большинства
визуальных компонентов. Например,  класс  TControl позволяет визуальным компо нентам
 отображаться на экране. Класс TControl содержит такие  позиционные свой ства,  как Top
и Left, свойства размеров Width и Height, значения которых опреде ляют  размеры элемента
по горизонтали и вертикали. Имеются и некоторые другие свойства: ClientRect, ClientWidth
и ClientHeight.
Класс  TControl содержит свойства, отвечающие за внешний вид и доступ к ком поненту:
 Visible, Enabled и Color. В свойстве Font даже можно  задать  шрифт, ис пользуемый для
текста, помещаемого в компонент TControl. Этот текст  выводится с помощью  свойств
Text и Caption.
В классе TControl впервые появляются некоторые стандартные события: события мыши —
OnClick, OnDblClick, OnMouseDown, OnMouseMove и OnMouseUp, а также  со бытия
перетаскивания с помощью мыши — OnDragOver, OnDragDrop и OnEndDrag.
Сам по себе класс TControl не очень  полезен на своем уровне  иерархии. Прямые потомки
этого класса никогда не создаются.Компонент TControl может  иметь  родительский
компонент. Он  обязательно должен  принадлежать классу TWinControl (в VCL) или
 TWidgetControl (в CLX). Родительские элементы управления должны  быть  оконными
(windowed) элементами управления. Для этого  в класс TControl введено свойство Parent.
Большинство элементов управления Delphi являются производными от прямых потомков
класса TControl: классов TWinControl и TWidgetControl.
Классы TWinControl и TWidgetControl Стандартные элементы управления происходят от класса  TWinControl (в VCL) и от класса
TWidgetControl (в CLX). Объекты пользовательского интерфейса про грамм  Windows —
это  и есть  стандартные элементы управления. Поля  редактирова ния  (edit   control),
списки   (list  box),   раскрывающиеся  списки   (list  box)  и  кнопки (button) —  вот
 примеры подобных элементов. Поскольку Delphi  сам инкапсулирует поведение
стандартных элементов управления, а не  использует для этого  функции интерфейса API
на уровне  Windows  или  Qt,  он  обладает возможностью непосредст венно  управлять
этими  элементами.
Три  основные особенности класса  TWinControl: объекты этого  класса  имеют  де
скриптор Windows,  могут получить фокус  ввода  и являться родительским элементом для
других компонентов. Элементы управления CLX не имеют  дескриптора окна; вме сто него
 используется указатель  на объект Qt,  который выполняет ту же самую роль. Свойства,
методы  и события обеспечивают обработку изменения фокуса,  событий клавиатуры,
отображение элементов и другие необходимые функции.
Обычно разработчикам приложений достаточно просто знать,  как  использовать потомки
классов  TWinControl и  TWidgetControl, а разработчикам компонентов, несомненно,
придется изучить их намного глубже.
Свойства классов TWinControl и TWidgetControl
В классах TWinControl и TWidgetControl определено несколько свойств, предна значенных
для изменения фокуса и внешнего вида элемента. Далее речь  пойдет только о классе
TWinControl, но все это будет справедливо и для класса TWidgetControl.
Свойство TWinControl.Brush используется для  отображения  элемента  управле
ния на экране. (Более подробная информация по этой теме приведена в главе 8, “GDI,
шрифты и графика”, предыдущего издания — Delphi 5 Руководство разработчика, нахо
дящегося на прилагаемом CD.)
Свойство массив   TWinControl.Controls предоставляет  доступ  к  списку   всех элементов
управления, для которых вызывающий компонент TWinControl является родительским.
Свойство  TWinControl.ControlCount содержит  количество  дочерних  элемен
тов управления.
Свойство  TWinControl.Ctl3D определяет  использование  трехмерной  стилиза
ции при отображении элемента.
Свойство TWinControl.Handle содержит дескриптор объекта Windows,  инкапсу
лированный классом  TWinControl. Именно этот  дескриптор следует использовать в
качестве параметра функций API Win32, требующих указания дескриптора окна.
Свойство TWinControl.HelpContext содержит контекстный справочный номер,
соответствующий определенному  справочному  окну  в  файле  справки. Это
 свойствоприменяется для  поддержки функций контекстно зависимой справки для
 отдельных элементов управления.
Свойство TWinControl.Showing содержит информацию о видимости элемента, а свойство
TWinControl.TabStop —  логическое значение, определяющее поведение элемента при
 использовании клавиши  . Свойство TWinControl.TabOrder по казывает, где в списке
 элементов родительского компонента, изменяющих фокус при нажатии клавиши  ,
находится указанный элемент (если он там есть).
Методы класса TWinControl
Компонент TWinControl так же предлагает несколько методов создания и позицио
нирования окна,  управления фокусом  и диспетчеризации событий. Подробное обсужде
ние  этих  методов явно  не укладывается в рамки  одной  главы,  однако  все они  исчерпы
вающе описаны в интерактивной справочной системе Delphi. Далее рассмотрим наиболее
интересные методы.
Методы  создания окна,  его восстановления и уничтожения в основном применя ются
разработчиками компонентов и рассматриваются в главе 11, “Разработка компо нентов
VCL”. Это методы  класса TWinControl библиотеки VCL — CreateParams(), CreateWnd(), CreateWindowHandle(), DestroyWnd(), DestroyWindowHandle() и RecreateWnd(), а также
 методы  класса  TWidgetControl библиотеки CLX — Cre ateWidget(), DestroyWidget(),
CreateHandle() и DestroyHandle().
К методам управления фокусом, позиционированием и выравнивания окна относятся:
CanFocus(), Focused(), AlignControls(), EnableAlign(), DisableAlign() и
ReAlign().
События класса TWinControl
Класс TWinControl предлагает новые  события для работы с клавиатурой и управле ния
фокусом. События клавиатуры — это OnKeyDown, OnKeyPress и OnKeyUp. К событи ям
управления фокусом относятся OnEnter и OnExit. Все они описаны в интерактивной
справочной системе Delphi.
Класс TGraphicControl
В отличие от класса  TWinControl, объекты класса  TGraphicControl не  имеют дескриптора
окна и поэтому  не могут получить фокус. Они  также  не могут быть роди тельскими для
других элементов управления. Класс TGraphicControl используется, когда необходимо
отобразить в форме какую то информацию, не предоставляя поль зователю доступ к этому
элементу.  Преимуществом элементов TGraphicControl яв ляется то,  что  они  не
нуждаются  в дескрипторе,  использующем системные ресурсы Windows.  К тому же
отсутствие дескриптора говорит о том,  что  элемент TGraphic Control не  участвует  в
непрерывном процессе перерисовки окон.  Таким  образом, отображение  элемента типа
 TGraphicControl происходит значительно быстрее, чем его эквивалента из класса
TWinControl.
Объект класса TGraphicControl способен реагировать на события мыши.  В дей
ствительности сообщения мыши  обрабатываются родительским компонентом класса
TGraphicControl, а затем передаются его дочерним элементам.
Класс TGraphicControl обладает способностью выводить на экран представляе
мые  им  элементы  управления, а  следовательно,  обладает свойством
 Canvas типаTCanvas. Он также содержит метод Paint(), который производные классы
элемен
тов обязаны переопределять.
Класс TCustomControl
Как можно  было  заметить, имена  некоторых классов,  производных от TWinCon trol,
начинаются с сочетания “TCustom”, например: TCustomComboBox, TCustom Control,
TCustomEdit и TCustomListBox.
Нестандартные, или  пользовательские  (custom),  элементы управления выполняют
почти такие  же функции, как и потомки класса  TWinControl, за исключением того, что
благодаря некоторым специальным визуальным особенностям и характеристикам
поведения разработчик получает заготовку, на основе которой можно  создавать свои
собственные пользовательские компоненты. Они  особенно полезны разработчикам
компонентов, которым приходится создавать собственные визуальные элементы
управления.
Другие классы
Несколько классов  не принадлежат к разряду  компонентов, но служат для про граммной
поддержки существующих  компонентов. Как правило, эти классы являются свойствами
других компонентов и происходят непосредственно от класса  TPersis tent. Некоторые из
них имеют типы TString, TCanvas и TCollection.
Классы TStrings и TStringsLists
Абстрактный класс  TStrings позволяет манипулировать списками строк, принад лежащих
 компонентам, подобно тому, как это делается с помощью элемента управления типа
 TListBox. Однако  на самом деле класс TStrings не управляет памятью для хра нения и
обработки таких  строк  (этим  занимается тот элемент управления, который яв ляется владельцем класса TStrings). Класс TStrings лишь определяет методы  и свой ства,
необходимые для доступа к строкам и их обработки, не используя ни функции API, ни
системные сообщения.
Заметьте, что TStrings — это абстрактный класс, т.е. в нем нет реализации кода, не
обходимого для работы со строками, он лишь определяет требуемые методы.  Реализа ция
же методов обработки строк относится к компетенции потомков этого класса.
Чтобы внести ясность, приведем такой  пример. Допустим, имеется несколько
компонентов  со  свойствами  типа   TStrings —   TListBox.Items,  TMemo.Lines и
TComboBox.Items. Каждое  из этих  свойств имеет  тип TStrings. Но как вызвать ме тоды
этих свойств, если они еще не воплощены в коде? Хороший вопрос. Ответ таков: хотя  все
эти  свойства определены как TStrings, переменная, к которой относится, например,
свойство TListBox.FItems, будет создана  как  экземпляр производного класса, методы
 которого и будут вызываться. Чтобы прояснить этот момент, отметим, что переменная
FItems является закрытым полем свойства Items класса TListBox:
TCustomListBox = class(TWinControl)
private
FItems: TStrings;Модуль StdCtrls.pas, являющийся частью  библиотеки VCL, определяет
класс TListBoxStrings как производный от класса TStrings. Листинг 10.1 демонстрирует его
определение.
Листинг 10.1. Объявление класса TListBoxStrings
TListBoxStrings = class(TStrings)
private
ListBox: TCustomListBox;
protected
procedure Put(Index: Integer; const S: string); override;
function Get(Index: Integer): string; override;
function GetCount: Integer; override;
function GetObject(Index: Integer): TObject; override;
procedure PutObject(Index: Integer;
AObject: TObject); override;
procedure SetUpdateState(Updating: Boolean); override;
public
function Add(const S: string): Integer; override;
procedure Clear; override;
procedure Delete(Index: Integer); override;
procedure Exchange(Index1, Index2: Integer); override;
function IndexOf(const S: string): Integer; override;
procedure Insert(Index: Integer; const S: string); override;
procedure Move(CurIndex, NewIndex: Integer); override;
end;
Затем  StdCtrls.pas определяет реализацию каждого  метода  этого  производного класса.
Когда класс TListBox создает  экземпляры для своей  переменной FItems, на самом деле
создается экземпляр его производного класса, к свойству FItems которого и происходит
обращение:
constructor TCustomListBox.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
…
// Создается экземпляр TListBoxStrings
FItems := TListBoxStrings.Create;
…
end; Следует четко  уяснить,  что класс TStrings лишь определяет свои методы, но не со держит
их  реализацию —  ее  осуществляют производные  классы.  Всем  разработчикам
компонентов полезно изучить  данную технологию. Когда возникают какие либо вопро сы
или сомнения по этому поводу, всегда можно обратиться к исходному коду библиотек
VCL или CLX, чтобы увидеть, как именно Borland реализовала такие методы.
Если речь  не идет  о разработке компонента, то при  необходимости манипулиро вания
 списком  строк  следует  воспользоваться другим  потомком класса  TStrings — вполне
самодостаточным классом  TStringList. Он обрабатывает список  строк, раз мещаемых  вне
 компонента. Его  главным   достоинством является полная совмести мость  с классом
 TStrings. Это означает, что  экземпляр класса  TStringList можноприсвоить
непосредственно  соответствующему свойству  элемента управления класса TStrings. В
следующем фрагменте кода показано, как можно  создать  экземпляр клас са TStringList:
var
MyStringList: TStringList;
begin
MyStringList := TStringList.Create;
Чтобы  добавить  строки  во  вновь  созданный  экземпляр  класса  TStringList,  по
ступите следующим образом:
MyStringList.Add(‘Red’); MyStringList.Add(‘White’); MyStringList.Add(‘Blue’);
Если   необходимо  добавить  одинаковые  строки  одновременно  в  компоненты TMemo и
TListBox, можно  воспользоваться совместимостью свойств TStrings, при надлежащих
различным компонентам, и выполнить присвоение одной строкой кода:
Memo1.Lines.Assign(MyStringList); ListBox1.Items.Assign(MyStringList);
Вместо непосредственного присвоения, подобного Memo1.Lines := MyStringList, можно
скопировать экземпляр класса TStrings с помощью метода Assign(). В табл. 10.5 приведены
наиболее часто используемые методы классов типа TStrings.
Таблица 10.5. Наиболее популярные методы класса TStrings
Метод                                                                             Описание
Add(const S: String): Integer Добавляет строку  S в список  и возвращает ее позицию в нем
AddObject(const S: string; Aobject: TObject): Integer
Добавляет строку  и объект в строку  или  в объект списка строк
AddStrings(Strings: TStrings)  Копирует  строки  из   указанного  объекта TStrings в конец
 существующего  списка строк
Assign(Source: TPersistent)    Замещает существующие  строки строками, заданными
параметром SourceМетод          Описание
Clear                             Удаляет все строки из списка
Delete(Index: Integer)            Удаляет   строку,   находящуюся  в  позиции
Index
Exchange(Index1, Index2: Integer)
IndexOf(const S: String): Integer
I nsert(Index: Integer;
const S: String)
Move(CurIndex, NewIndex: Integer)
LoadFromFile(const FileName: String)
SaveToFile(const FileName:
string)
Класс TCanvas
Меняет   местами     строки   с    позициями
Index1 и Index2
Возвращает позицию строки S в списке
Вставляет строку S в позицию Index
Перемещает строку с позицией CurIndex в позицию NewIndex Считывает текстовый файл  по имени File Name и помещает его строки в список
Сохраняет список  в текстовом файле
FileName
Свойство Canvas типа  TCanvas применяется в оконных элементах управления и
представляет собой  его поверхность, используемую  для прорисовки содержимого ок на.
 Класс   TCanvas инкапсулирует  так   называемый  контекст  устройства (device context)
окна. Этот класс содержит множество функций и объектов, необходимых для прорисовки
поверхности окна.  Более  подробная информация по данной теме  приве дена в главе 8,
“GDI, шрифты и графика”, предыдущего издания — Delphi 5 Руководство разработчика,
находящегося

file_name: билет 26.docx

description:
Стандартные элементы управления происходят от класса  TWinControl (в VCL) и от класса
TWidgetControl (в CLX). Объекты пользовательского интерфейса про грамм  Windows —
это  и есть  стандартные элементы управления. Поля  редактирова ния  (edit   control),
списки   (list  box),   раскрывающиеся  списки   (list  box)  и  кнопки (button) —  вот
 примеры подобных элементов. Поскольку Delphi  сам инкапсулирует поведение
стандартных элементов управления, а не  использует для этого  функции интерфейса API
на уровне  Windows  или  Qt,  он  обладает возможностью непосредст венно  управлять
этими  элементами.
Три  основные особенности класса  TWinControl: объекты этого  класса  имеют  де
скриптор Windows,  могут получить фокус  ввода  и являться родительским элементом для
других компонентов. Элементы управления CLX не имеют  дескриптора окна; вме сто него
 используется указатель  на объект Qt,  который выполняет ту же самую роль. Свойства,
методы  и события обеспечивают обработку изменения фокуса,  событий клавиатуры,
отображение элементов и другие необходимые функции.
Обычно разработчикам приложений достаточно просто знать,  как  использовать потомки
классов  TWinControl и  TWidgetControl, а разработчикам компонентов, несомненно,
придется изучить их намного глубже.
Свойства классов TWinControl и TWidgetControl
В классах TWinControl и TWidgetControl определено несколько свойств, предна значенных
для изменения фокуса и внешнего вида элемента. Далее речь  пойдет только о классе
TWinControl, но все это будет справедливо и для класса TWidgetControl.
Свойство TWinControl.Brush используется для  отображения  элемента  управле
ния на экране. (Более подробная информация по этой теме приведена в главе 8, “GDI,
шрифты и графика”, предыдущего издания — Delphi 5 Руководство разработчика, нахо
дящегося на прилагаемом CD.)
Свойство массив   TWinControl.Controls предоставляет  доступ  к  списку   всех элементов
управления, для которых вызывающий компонент TWinControl является родительским.
Свойство  TWinControl.ControlCount содержит  количество  дочерних  элемен
тов управления.
Свойство  TWinControl.Ctl3D определяет  использование  трехмерной  стилиза
ции при отображении элемента.
Свойство TWinControl.Handle содержит дескриптор объекта Windows,  инкапсу
лированный классом  TWinControl. Именно этот  дескриптор следует использовать в
качестве параметра функций API Win32, требующих указания дескриптора окна.
Свойство TWinControl.HelpContext содержит контекстный справочный номер,
соответствующий определенному  справочному  окну  в  файле  справки. Это
 свойствоприменяется для  поддержки функций контекстно зависимой справки для
 отдельных элементов управления.
Свойство TWinControl.Showing содержит информацию о видимости элемента, а свойство
TWinControl.TabStop —  логическое значение, определяющее поведение элемента при
 использовании клавиши  <Tab>. Свойство TWinControl.TabOrder по казывает, где в списке
 элементов родительского компонента, изменяющих фокус при нажатии клавиши  <Tab>,
находится указанный элемент (если он там есть).
Методы класса TWinControl
Компонент TWinControl так же предлагает несколько методов создания и позицио
нирования окна,  управления фокусом  и диспетчеризации событий. Подробное обсужде
ние  этих  методов явно  не укладывается в рамки  одной  главы,  однако  все они  исчерпы
вающе описаны в интерактивной справочной системе Delphi. Далее рассмотрим наиболее
интересные методы.
Методы  создания окна,  его восстановления и уничтожения в основном применя ются
разработчиками компонентов и рассматриваются в главе 11, “Разработка компо нентов
VCL”. Это методы  класса TWinControl библиотеки VCL — CreateParams(), CreateWnd(),

intro: Все классы библиотеки визуальных компонентов (VCL) произошли от группы базовых классов, которые лежат в основе иерархии. Самый общий предок компонентов — это класс TObject, инкапсулирующий простейший объект. Как известно (см. гл. 1), каждый объект наследует свойства и методы родительского класса. К объекту можно добавить новые свойства и методы, но нельзя удалить унаследованные. Объект-наследник в свою очередь может стать родительским для нового класса, который унаследует возможности всех своих предков.

title: Лекция "Базовые классы VCL. Характеристика. Примеры."


extracted_text:
билет 27 тема 2
Структура проекта в Delphi.
Проект Delphi состоит из форм, модулей, установок параметров проекта, ресурсов и т.д.
Вся эта информация размещается в файлах. Многие из этих файлов автоматически
создаются Delphi:
Файл проекта
(.dpr)
Этот текстовый файл используется для хранения информации о формах и
модулях. В ней содержатся операторы инициализации и запуска программ
на выполнение
Файл модуля
(.pas)
Каждой создаваемой вами форме соответствует текстовый файл модуля,
используемый для хранения кода. Можно создавать модули, не связанные
с формами. Многие из функций и процедур Delphi хранятся в модулях.
Файл формы
(.dfm)
Это двоичный или текстовый файл, который создается Delphi для
хранения информации о ваших формах. Каждому файлу формы
соответствует файл модуля (.pas)
В этом файле хранятся установки параметров проекта
Файл
параметров
проекта(.dfo)
Файл
ресурсов(.res)
Этот бинарный файл содержит используемую проектом пиктограмму и
прочие ресурсы
Файлы
резервных
копий (.~dp,
.~df, .~pa)
Это соответственно файлы резервных копий для файлов проекта, формы
и модуля. Если чтото безнадежно испорчено в проекте, можно
соответственно изменить расширения этих файлов и таким образом
вернуться к предыдущему не испорченному варианту
Файл
конфигурации
окон (.dsk)
Исполняемый
файл (.exe)
Объектный
файл модуля
Файл хранит конфигурацию всех окон среды разработки (раздел 2.3.9)
Это исполняемый файл вашего приложения. Он является автономным
исполняемым файлом, для которого больше ничего не требуется, если
только вы не используете библиотеки, содержащиеся в DLL, OCX и т.д., а
также если вы не используете поддержку пакетов времени выполнения
(раздел 7.6)
Это откомпилированный файл модуля (.pas), который компонуется в (.dcu)
окончательный исполняемый файл.
Главной частью приложения является файл проекта (.dpr) с которого начинается
выполнение программы и который обеспечивает инициализацию других модулей.
Проект Delphi представляет собой набор программных единиц – модулей.
Модуль – автономно компилируемая программная единица, включающая в себя различные
компоненты раздела описаний (типы, константы, переменные, процедуры и функции) и,
возможно некоторые исполняемые операторы инициирующей части.
Один из модулей – главный, содержит инструкции, с которых начинается выполнение
программы. Главный модуль приложения полностью формируется Delphi.
Помимо главного модуля каждая программа включает в себя еще как минимум один
модуль формы, который содержит описание стартовой формы приложения и
поддерживающих ее работу процедур. В Delphi каждой форме соответствует свой модуль.
Программа Delphiэто несколько связанных между собой файлов.
Главный файл проекта, изначально называется PROJECT1.DPR. Если необходимо
переименовать название проекта, нужно перезаписать этот файл, выбрав в меню File
команду Save Project As: При задании имени следует придерживаться правил задания имен
в Object Pascal. Имя не должно содержать пробелов (используйте в таком случае знак
подчеркивания), должно начинаться с буквы (цифры допустимы, но со второй позиции), не
должно содержать других символов, кроме букв и цифр. Под каким именем вы сохраняете
проект, под таким именем и будет создаваться исполняемый EXE файл, который вы всегда
сможете самостоятельно переименовать.
Модуль программы, который автоматически появляется в начале работы Unit1. Файл
называется UNIT1.PAS по умолчанию, но его можно назвать любым другим именем, вроде
MAIN.PAS. Это делается аналогично переименованию названия проекта. Необходимо
выбрать в меню File команду Save As: Сохраняется активный модуль в редакторе кода.
Файл главной формы, который по умолчанию называется UNIT1.DFM, используется для
сохранения информации о внешнем виде формы (окна разрабатываемого приложения). При
переименовании названия модуля автоматически меняет свое название. Файл
PROJECT1.RES изначально содержит иконку для проекта. Создается автоматически.
Имеет одноименное название с названием проекта. Файл PROJECT1.DSK содержит
информацию о состоянии рабочего пространства. Состояние окон во время разработки
приложения. Исполняемый EXE файл, который создается в процессе компиляции проекта.
Разумеется, если сохранить проект под другим именем, то изменят название и файлы с
расширением RES и DSK. После компиляции программы получаются файлы с
расширениями:DCU  скомпилированные модули PAS для последующей быстрой
компиляции некоторые файлы не перезаписываются
EXE  исполняемый файл
~PA, ~DP  backup файлы редактора. Автоматически создаются и содержат информацию,
перед последним сохранением. И так, любая программа всегда состоит из уже знакомого нам файла проекта(такой файл
имеет расширение .dpr) и одного или нескольких модулей(файлы с расширением .pas) Файл
проекта не предназначен для редактирования пользователем и создаётся автоматически
самой системой программирования Delphi. Для того, чтобы увидеть содержимое файла
проекта, необходимо выполнить команду Project|View Source.Содержимое файла проекта
может быть,например,следующим:
program Project1;
uses
  Forms, unit in 'Unit1.pas' {Form};
{$R *.RES}
begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.
Файл проекта(главный модуль) начинается словом program,за которым следует имя
программы,совпадающее с именем проекта. Далее за словом uses следуют имена
используемых модулей:стандартного модуля Forms и модуля формы Unit1. Похожая на
комментарий директива {$R *.RES} указывает компилятору,что нужно использовать файл
ресурсов,который содержит описание ресурсов
приложения,например,пиктограммы.Звездочка указывает,что имя файла ресурсов такое
же,как и у файла проекта,но с раширением .res. Исполняемая часть главного модуля
находится между операторными скобками begin:end.Операторы исполняемой части
обеспечивают инициализацию приложения и вывод на экран стартового окна.Помимо
главного модуля каждая программа включает как минимум один модуль формы,который
содержит описание стартовой формы приложения и поддерживающи* * *аботу процедур.В
Delphi каждой форме соответствует свой модуль.Для переключения между формой и
окном редактора кода,содержащего соответствующий модуль,следует нажать на клавишу
F12.Модулиэто программные единицы,служащие для размещения фрагментов
программ.При помощи содержащихся в них текстов программ и реализуется решаемая
пользователем задача.
Методы
Методами называются инкапсулированные в классе процедуры и функции. Например:
type
  TChildClass = classFone: Integer;
    Ftwo: string;
    Fthree: Tobject;
    function FirstFuns(x: real): real;
    procedure SecondProc;
  end
Для того чтобы обратиться к методам,как и для полей,необходимо использовать составные
имена:
var
  MyObject: TChildClass;
  y: real; begin
  MyObject.SecondProc;
  y := MyObject.FirstFunc(3.14);
end;
Методы,определенные в классе,могут быть статическими,виртуальными,динамическими
или абстрактными.Тип метода определяется механизмом перекрытия его в потомках. Для
статических методов перекрытие осуществляется компилятором. Например,пусть у нас
имеется описание родительского класса Tbase и его потомка Tdescedant, содержащих
одноименный метод
MyJoy:
type
  Tbase = class
    procedure MyJoy;
  end;
  Tdescedant = class(Tbase)
    procedure MyJoy;
  end;
var
  FirstObject: Tbase;
  SecondObject: Tdescedant;
begin
  FirstObject.MyJoy;
  SecondObject.MyJoy;
end;
В соответствии с принципом полиморфизма в операторе FirstObject.MyJoy; вызывается
метод, описанный в классе Tbase,а в операторе SecondObject.MyJoy; Вызывается
метод,описанный в классе Tdescedant.По умолчанию все методы,описанные в
классе,являются статическими.Динамические и виртуальные методы отличаются от
статических тем,что замещение родительских методов методами потомков происходит на
этапе выполнения прогрммы.Для обьявления виртуального метода в родительском классе
необходимо использовать зарезервированное слово virtual,а для обьявления динамического
методазарезервированное слово dynamic.В классепотомке в загаловке замещающего
метода должно быть указано зарезервированное слово override. Например:
type
  TBase = class
    Procedure MyJoy; virtual;
  end;
  Tdescedant = class(TBase)
    procedure MyJoy; override;
  end;
var
  FirstObject: Tbase;
  SecondObject: Tdescedant;
begin
  FirstObject.MyJoy;
  SecondObject.MyJoy;
end; Если бы мы захотели,чтобы метод MyJoy в классе Tbase был динамическим, слово virtual в
заголовке процедуры следует заменить словом dynamic.Различие между виртуальными и
динамическими методами невилико и связано с особенностями реализации их
вызовов.Можно сказать,что виртуальные методы более эффективны с точки зрения затрат
времени,а динамические методы позволяют более рационально использовать оперативную
память.Абстрактными называются виртуальный или динамические методы,которые
определены в классе,но не содержат никаких действий,никогда не вызываются и
обязательно должны быть переопределены в классахпотомках.Обьявляется абстрактный
метод при помощи зарезервированного слова abstract,расположенного после слов virtual
или dynamic,например:procedure MyMetod; virtual; abstrat; Основное предназначение
абстрактных методовбыть родоначальником иерархий конкретных методов в классах
потомках. В любом классе содержатся два специальных методаконструктор и деструктор.
Эти методы содержатся в классеродоначальнике всех остальных классовTobject
и,следовательно,наследуются потомками. Как и другие методы,они могут быть изменины в
классахпотомках,т.е.перекрыты. В классе Tobject и в большинстве его потомков
конструктор и деструктор называются Create и Destroy соответственно. Конструкторы
предназначены для создания и инициализации обьекта. Дело в том,что обьект в языке
Object Pascal является динамической структурой и переменнаяобьект содержит не сами
данныые, а ссылку на них. Конструктор распределяет обьект в динамической памяти и
присваивает полям обьекта начальные значения. При этом поля порядковых типов в
качестве начального значения получают 0, строковогопустую строку, поляуказатели
значения nil,полявариантыUnassigned. Кроме того,конструктор помещает ссылку на
созданный обьект в переменную Self,которая автоматически обьявляется в классе. Из
сказанного следует,что обращение к полям, свойствам и методам обьекта должно
осуществляться только после вызова конструктора. Деструктор освобождает динамическю
память и разрушает обьект. Для обьявления конструктора и деструктора используются
зарезервированные слова constructor и destructor соответственно. Например:
type
  Tsample = classText: string;
  constructor Create;
  destructor Destroy;
end;
Для того,чтобы создать обьект,необходимо применить методконструктор к классу
обьекта: varMyObject : TSample;
begin
  MyObject := TSample.Create;
end;
Если создается класспотомок и при его создании планируется осуществить некоторые
дополнительные действия,отсутствующие у классародителя, то в конструкторе класса
потомка следует сначала вызвать конструктор своего родителя, а уже потом осуществлять
дополнительные действия. Вызвать любой перекрытый метод родительского класса можно
при помощи зарезервированного слова inherited(унаследованный). Например, если в классе
TDescedant имеется свой собственный конструктор typeTDescedant = class(TBase)FMark :
Boolean;
constructor Create(Mark: Boolean);
end;
то его реализация могла бы быть такой: constructor TDescedant.Create(Mark:Boolean); begin
  inherited Create;
  Emark := Mark;
end;
где вызов родительского конструктора осуществляется оператором inherited Create; а
оператор Emark := Mark; Осуществляет дополнительные действия. Кроме деструктора
Destroy,в базовом классе Tobject определен метод Free, который прежде проверяет, был ли
обьект на самом деле реализован и только потом вызывает метод Destroy. Если обьект не
был создан конструктором, то обращение к деструктору,приведет к генерации
исключительной ситуации. Следовательно,для уничтожения ненужного обьекта удобнее
использовать метод Free, например: MyObject.Free; В классе могут быть определены
методы, которые могут вызываться без создания и инициализации обьекта. Эти методы
называются методами класса,и для их обьявления используется зарезервированное слово
class. Например:
type
  TChildClass = class(Tobject)
    class function ChildClassInfo: string;
  end;
  vary: string;
begin
  y := ChildClassInfo;
end;
Как правило, методы класса предназначены для справочной информации о классеимени
класса, предке класса, размере класса и т.д.
События
Событиеэто то,что происходит в процессе работы программы. В Delphi определенно
несколько десятков типовых событий. Рассмотрим,что представляют собой события с
точки зрения языка Object Pascal. Событиеэто свойство процедурного типа,и его
значением является указатель на некоторый метод. Присвоить такому свойству значение
означает указать адрес метода, который будет выполняться в момент наступления
события.Такие методы называются обработчиками событий. В качестве примера
рассмотрим,как описаны стандартные события OnDblClick (возникает при двойном щелчке
левой кнопкой мыши), OnMouseDown(возникает при нажатии кнопки мыши) и
OnMouseMove (возникает при перемещении мыши) в классе TControl:Tcontrol =
class(Tcomponent) Private FonDblClick: TnotifyEvent;FonMouseDown:TmouseEvent;
FonMouseMove:TmouseMoveEvent protected property OnDblClick: Tnotify read FonDblClick
writeFonDblClick; Property OnMouseDown: TmouseEvent read FonMouseDown writeProperty
OnMouseMove: TmouseMoveEvent read FonMouseMove writeFonMouseMove; end;
Назначение зарезервированных слов private и protected мы рассотрим позже, а пока
отметим следующее. Поля FonDblClick,FonMouseDown и FonMouseMove, используемые
при описании свойствсобытии, предназначенны для хранения указателя на метод,
являющийся обработчиком соответствующего события. Используемые при описаний полей
процедурные типы определяются следующим образом: TypeTnotifyEvent = procedure
(Sender: Tobject) of object; TmouseEvent = procedure(Sender:Tobject;Button: TmouseButton;
Shift: TshiftState; x, y: Integer) of object; TmouseMoveEvent = procedure(Sender:Tobject;
Shift: TshiftState;X, y:Integer) of object; Общим для всех процедурных типов является
параметр Sender, содержащий указатель на обьектисточник события. Параметр Button содержит информацию,какая клавиша мыши была нажата. Параметр Shift содержит код
клавиши,нажатой на клавиатуре.x и y текущие координаты мыши в пределах компонента.
Поля
Полями называются инкапсулированные в классе данные. Поля класса подобны полям
записи, но в отличие от них могут быть любого типа, в том числе классами, например: type
TchildClass = class Fone : Integer; Ftwo : String; Fthree : TObject; end; Исходя из принципа
инкапсуляции,обращение к полям должно осуществляется при помощи методов и свойств
класса. Вместе с тем, в Object Pascal допускается обращаться к полям и
непосредственно .Для того чтобы обратиться к полю, необходимо записать составные имя,
состоящее из имени класса и имени поля,разделенных точкой,например: var MyObject :
TChildClass; begin MyObject.Fone := 16; MyObject.Ftwo := 'Некоторое строковое значение';
end; Обычно имя поля такое же, как и имя соответствующего свойства, но к имени поля в
качестве первой буквы добавляют букву F.
81 Управление проектами в Delphi.
Еремин Андрей
В каком виде сохраняются созданные программы? Этот вопрос возникает у любого
начинающего программиста. Эта тема заслуживает отдельного внимания. Как известно, в
Windows любая программа представляет собой exeфайл, который является исполняемым,
т.е. может быть запущен как отдельное приложение. Понятно, что разрабатывая
программу, в итоге нужно получить именно exeфайл, чтобы его можно было запустить на
компьютере, где не установлена среда, в которой эта программа была создана. В языках
программирования для DOS, в частности Turbo Pascal, всё довольно просто  весь
программный код сохраняется в одинединственный файл, а в итоге получается exeфайл.
Довольно просто и удобно. При переходе в Windows всё становится гораздо сложнее.
Оконное приложение Windows не может быть сохранено в одном файле. Если в среде DOS
программы можно называть именно программами, то в объектноориентированном
программировании они называются проектами. Почему проектами? Всё достаточно просто
 программа представляет собой совокупность некоторого числа файлов различного типа,
определённым образом связанных между собой. Очевидно, что всю эту группу логично
назвать проектом.
В этой статье мы познакомимся с самыми основными типами файлов, которые включены в
любой проект, созданный на Delphi. На самом деле типов файлов гораздо больше, но эти
базовые.
*.dpr  файл проекта
Это главный файл всего проекта. Если этот файл отсутствует, запустить программу будет
невозможно. В файле хранятся все основные параметры приложения, а также информация
об окнах, которые в приложение включены. Файл представляет собой свободно читаемый
код. Посмотреть содержимое этого файла можно командой меню Project > View Source .
*.dfm  файл описания формы
В этом файле содержится описание всех объектов, которые расположены на форме, а
также информация обо всех их свойствах. При этом в этот файл сохраняются только те
свойства объектов, которые были принудительно изменены. Это объясняется тем, что все
свойства любого объекта имеют значения по умолчанию (т.е. заранее установленные).
Соответственно нет смысла хранить значения абсолютно всех свойств  достаточно
запомнить только те, которые имеют значение, отлиное от начального. Все остальные свойства принимают своё исходное значение и таким образом вся форма
восстанавливается.
*.pas  модуль (самостоятельный, либо модуль формы)
Именно этот файл больше всего похож на файл программ Turbo Pascal. В этом файле
находится код программы. Модули могут быть отдельными от конкретных проектов  в
этом случае их можно подключить к любому проекту и использовать. Как правило, в
отдельных модулях находятся вспомогательные функции, либо какиелибо объекты.
Помимо этого модуль есть у каждой формы. В результате *.pasфайл неразрывно связан с
файлом *.dfm, а форма соответственно описывается этими двумя файлами  один
содержит её состояние и объекты, а второй  код программы, относящийся к этой форме.
Следует отметить, что модули значительно облегчают процесс написания программы и
ориентацию в больших модулях  отдельные элементы большого модуля можно вынести в
несколько модулей и просто подключить их к проекту.
*.res  файл ресурсов
Это дополнительный файл. В нём находятся данные различных типов  это могут быть
тексты, изображения, звуки и т.д. К примеру, для проекта этот файл создаётся
автоматически и в нём сохраняется иконка (значок) приложения, а также некоторая
информация о проекте.
Вот и все основные файлы, информацию о которых обязательно нужно знать. Чтобы
перенести проект, достаточно следующих файлов: *.dpr, *.dfm и *.pas. Имея эти файлы
проект можно восстановить, а программу  запустить. Желательно также наличие *.res
файла(ов), но тем не менее это не обязательно. Если *.resфайл, сопоставленный проекту
будет отсутствовать, то при открытии проекта Delphi предупредит, что файл не найден и
спросит, что нужно сделать. Достаточно проигнорировать сообщение и файл будет создан
автоматически при следующем запуске программы.
Работа с проектом
Ну а теперь пришло время рассказать о базовых операциях с проектом, так как ранее речь
об этом не шла. Рассмотрим всё по порядку.
Создание нового проекта
Для создания "чистого листа" следует
выбрать в меню File > New >
Application . В разных версиях Delphi
содержимое подменю New может
немного отличаться, но всё основное
присутствует всегда. После этого
создаётся новый проект, такой, какой
появляется при запуске Delphi.

Открытие существующего проекта
(или файла)
Для этого существует команда File >
Open... Выбрав файл *.dpr , откроется
Меню File содержит все основные команды
управления проектом проект, а выбрав какойлибо другой
файл (например, *.pas или *.dfm )
откроется чтолибо другое (например,
отдельная форма).
Сохранение
С сохранением есть несколько
тонкостей. Исходя из того, что проект
представляет собой совокупность
нескольких файлов, можно сделать
вывод, что сохранять нужно все эти
файлы, а не какойто в отдельности.
Выбрав File > Save , Вы сохраните
только текущую форму, но не более
того, а проект останется "висеть в
воздухе". File > Save As...
стандартный пункт, который делает то
же самое, что и Save , только
Железное правило: каждый проект должен быть сохранён в отдельном каталоге!
Если в один каталог сохранить несколько проектов, то все файлы перемешаются и можно
отправлять всё в корзину. Этого нельзя делать ни в коем случае!
Запуск и остановка программы
Теперь, когда проект сохранён, программу можно и запустить и посмотреть, что же
получилось. Ещё одно правило, которое желательно соблюдать: перед запуском программы
проект нужно сохранить. Мгновенный вопрос: зачем? Конечно, делать это или нет  решать
Вам, но бывают случаи, когда программа зависает (по вине самого программиста
например), а с ней зависает и оболочка Delphi. В этом случае ничего не остаётся делать,
как "убивать" Delphi через Диспетчер задач Windows. Понятно, что изменения, которые были внесены в проект, теряются. Однако не всё так плохо. Случаи зависания Delphi IDE
достаточно редки. Как правило, если программа зависает, Delphi позволяет её просто
уничтожить из памяти и продолжить работу. Процесс сохранения проекта перед запуском
можно поручить оболочке: меню Tools > Environment Options... , вкладка Preferences , блок
Autosave options  опция Editor files.
Запомните следующие основные горячие клавиши:
Ctrl+F9  компиляция программы. Что такое компиляция? Говоря простым языком
создание выходного (exe) файла программы. Следует отметить, что имя выходного файла
совпадает с именем проекта, т.е. именем *.dprфайла и не может быть изменено. Выходной
файл создаётся в том же каталоге, где расположение *.dprфайл. Однако компиляция
просто "собирает" всю программу, но не запускает её.
F9  запуск. В отличие от компиляции, это уже полноценный запуск программы из
оболочки Delphi, однако не совсем такой, каким является запуск приложения из Windows.
Запуск происходит под отладчиком. Но об этом позже.
Ctrl+F2  остановка выполнения программы. Это именно то, о чём сказано чуть выше. Если
нужно экстренно завершить работу программы, нужно активировать какое=либо из окон
оболочки Delphi и нажать это сочетание клавиш. Программа будет остановлена и можно
будет безболезненно продолжить работу.
Все эти команды доступны и напрямую из меню: Run > Run , Project > Compile , Run >
Program Reset .
Все основные команды управления проектом вынесены также в виде кнопок на панели
инструментов:
Свойства проекта
Для проекта можно установить
множество разнообразных параметров.
Все они находятся в окне Project >
Options . В частности, на вкладке
Application можно указать заголовок
проекта, который будет отображаться
на кнопке программы на панели задач.
Совет: всегда прописывайте заголовок
своей программе, не оставляйте
стандартного " Project1 "  это резко
бросается в глаза. На этой же вкладке
можно выбрать иконку (значок) для
приложения  файл *.ico размером
32х32 пикселя. В блоке Output settings
можно указать расширение выходного
файла. Заполнять это поле не
обязательно  по умолчанию файлу

Окно свойств проекта присваивается расширение .exe .
Однако в некоторых случаях эта
настройка бывает полезной. Например,
экранные программызаставки
представляют собой те же
исполняемые exeфайлы, только имеют
расширение .scr . Неудобно каждый раз
после внесения изменений в программу,
Заключение
В этой статье рассмотрены все базовые навыки для управления проектами. Теперь можно
приступить непосредственно к изучению языка и исследованию объектов.

file_name: билет 27 тема 2.docx

title: Лекция "Структура проекта в Delphi."


extracted_text:
билет 27 тема 3
1. характеристика языков запросов БД. Примеры.
В реляционных СУБД для выполнения операций над отношениями используются две
группы языков, имеющие в качестве своей математической основы теоретические языки
запросов, предложенные Э.Коддом:
 реляционная алгебра;
 реляционное исчисление.
Эти языки представляют минимальные возможности реальных языков манипулирования
данными в соответствии с реляционной моделью и эквивалентны друг другу по своим
выразительным возможностям. Существуют не очень сложные правила преобразования
запросов между ними.
В реляционной алгебре операнды и результаты всех действий являются отношениями.
Языки исчислений, в отличие от реляционной алгебры, являются непроцедурными
(описательными, или декларативными) и позволяют выражать запросы с помощью
предиката первого порядка (высказывания в виде функции), которому должны
удовлетворять кортежи или домены отношений. Запрос к БД, выполненный с
использованием подобного языка, содержит лишь информацию о желаемом результате. Для
этих языков характерно наличие наборов правил для записи запросов. В частности, к
языкам этой группы относится SQL.
Язык SQL предназначен для выполнения:
а) операций над таблицами (создание, удаление, изменение структуры);
б) над данными таблиц (выборка, изменение, добавление и удаление)
в) некоторых сопутствующих операций (управление доступом, управление индексами,
управление транзакциями и др.).
SQL является непроцедурным языком и не содержит операторов управления, организации
подпрограмм, вводавывода и т.п. В связи с этим SQL автономно не используется, обычно
он погружен в среду встроенного языка программирования СУБД (например, FoxPro
СУБД Visual FoxPro, ObjectPAL СУБД Paradox, Visual Basic for Applications СУБД
Access).
В современных СУБД с интерактивным интерфейсом можно создавать запросы, используя
другие средства, например QBE. Однако применение SQL зачастую позволяет повысить
эффективность обработки данных в базе. Например, при подготовке запроса в среде Access
можно перейти из окна Конструктора запросов (формулировки запроса по образцу на
языке QBE) в окно с эквивалентным оператором SQL. Подготовку нового запроса путем
редактирования уже имеющегося в ряде случае проще выполнить путем изменения
оператора SQL. В различных СУБД состав операторов SQL может несколько отличаться.
Язык SQL не обладает функциями полноценного языка разработки, а ориентирован на
доступ к данным, поэтому его включают в состав средств разработки программ. В этом
случае его называют встроенным SQL. Стандарт языка SQL поддерживают современные
реализации следующих языков программирования: PL/1, Ada, С, COBOL, Fortran, MUMPS
и Pascal.
В специализированных системах разработки приложений типа клиентсервер (данную
архитектуру мы рассмотрим позже) среда программирования, кроме того, обычно
дополнена коммуникационными средствами (установление и
разъединение соединений с серверами БД, обнаружение и обработка возникающих в сети
ошибок и. т. д.), средствами разработки пользовательских интерфейсов, средствами
проектирования и отладки.
Различают два основных метода использования встроенного SQL: статический и
динамический. При статическом использовании языка (статический SQL) в тексте программы имеются
фиксированные по структуре вызовы функций языка SQL, включаемые в выполняемый
модуль в процессе компиляции. Параметры запросов (обычно представляют константные
значения, с которыми сравниваются значения полей в таблицах), являющиеся переменными
языка программирования, позволяют добиться некоторой гибкости статических запросов.
При динамическом использовании языка (динамический SQL) предполагается
динамическое построение запроса в форме текстовой строки. Данная строка используется
как параметр для функции выполнения SQLзапросов, которая выполняет синтаксический
анализ строки запроса и формирует на его основе последовательность команд БД.
Динамический метод обычно применяется в случаях, когда в приложении заранее
неизвестен вид SQLвызова.
В результате выборки данных из одной или нескольких, таблиц может быть получено
множество записей, называемое представлением. Представление по существу является
таблицей, формируемой в результате выполнения запроса, которая существует
«виртуально» только до завершения выполнения программы.
Для удобства работы с представлениями в язык SQL введено понятие курсора. Курсор
представляет собой своеобразный указатель на набор записей в представлении,
обеспечивающий в каждый момент доступ лишь к некоторой небольшой части строк
представления. С помощью операторов перемещения курсора по записям можно получить
доступ ко всем строкам таблицы

file_name: билет 27 тема 3.docx

intro:
В реляционных СУБД для выполнения операций над отношениями используются две группы языков, имеющие в качестве своей математической основы теоретические языки запросов, предложенные Э.Коддом:
- реляционная алгебра;
- реляционное исчисление.
Эти языки представляют минимальные возможности реальных языков манипулирования данными в соответствии с реляционной моделью и эквивалентны друг другу по своим выразительным возможностям. Существуют не очень сложные правила преобразования запросов между ними

title: Лекция "Характеристика языков запросов БД. Примеры."


extracted_text:
билет 28 тема 4
162 Адресация в сети
 Internet

 . Примеры.
Цифровые адреса в Интернете состоят из четырех чисел, каждое из которых не превышает двухсот
пятидесяти шести. При записи числа отделяются точками, например: 195.63.77.21. Такой способ
нумерации позволяет иметь в сети более четырех миллиардов компьютеров.
Для отдельного компьютера или локальной сети, которые впервые подключаются к сети Интернет,
специальная организация, занимающейся администрированием доменных имен, присваивает IP –
номера.
Первоначально в сети Internet применялись IP – номера, но когда количество компьютеров в сети стало
больше чем 1000, то был принят метод связи имен и IP – номеров, который называется сервер имени
домена (Domain Name Server, DNS). Сервер DNS поддерживает список имен локальных сетей и
компьютеров и соответствующих им IP – номеров.
В Интернете применяется так называемая доменная система имен. Каждый уровень в такой системе
называется доменом. Типичное имя домена состоит из нескольких частей, расположенных в
определенном порядке и разделенных точками. Домены отделяются друг от друга точками, например:
www.lessonstva.info или tva.jino.ru.
В Интернете доменная система имен использует принцип последовательных уточнений также как и в
обычных почтовых адресах  страна, город, улица и дом, в который следует доставить письмо.
Домен верхнего уровня располагается в имени правее, а домен нижнего уровня  левее. В нашем
примере домены верхнего уровня info и ru указывают на то, что речь идет о принадлежности сайта
www.lessonstva.info к тематическому домену верхнего уровня info, а сайта tva.jino.ru к российской (ru)
части Интернета. Но в России множество пользователей Интернета, и следующий уровень определяет
организацию, которой принадлежит данный адрес. В нашем случае это компания jino.
Интернетадрес этой компании  jino.ru. Все компьютеры, подключенные к Интернету в этой компании,
объединяются в группу, имеющую такой адрес. Имя отдельного компьютера или сети каждая компания
выбирает для себя самостоятельно, а затем регистрирует его в той организации Интернет, которая
обеспечивает подключение.
Это имя в пределах домена верхнего уровня должно быть уникальным. Далее следует имя хоста tva,
таким образом, полное имя домена третьего уровня: tva.jino.ru. В имени может быть любое число
доменов, но чаще всего используются имена с количеством доменов от трех до пяти
Доменная система образования адресов гарантирует, что во всем Интернете больше не найдется
другого компьютера с таким же адресом. Для доменов нижних уровней можно использовать любые
адреса, но для доменов самого верхнего уровня существует соглашение.
В системе адресов Интернета приняты домены, представленные географическими регионами. Они
имеют имя, состоящее из двух букв, например:
Украина  uaФранция  fr;Канада  са;США  us;
Россия  ru.
Существуют и домены, разделенные по тематическим признакам, например:
Учебные заведения  edu.
Правительственные учреждения  gov.
Коммерческие организации  com.
В последнее время добавлены новые зоны, например: biz, info, in, .cn и так далее
При работе в Internet используются не доменные имена, а универсальные указатели ресурсов,
называемые URL (Universal Resource Locator). URL  это адрес любого ресурса (документа, файла) в
Internet, он указывает, с помощью какого протокола следует к нему обращаться, какую программу
следует запустить на сервере и к какому конкретному файлу следует обратиться на сервере. Общий
вид URL: протокол://хосткомпьютер/имя файла (например: http://www.lessonstva.info/book.html).
Регистрация домена осуществляется в выбранной пользователем зоне ua, ru, com, net, info и так далее. В
зависимости от назначения сайта выбирается его зона регистрации. Для регистрации сайта желательно
выбрать домен второго уровня, например lessonstva.info, хотя можно работать и с доменом третьего
уровня, например tva.jino.ru.
Домен второго уровня регистрируется у регистратора – организации занимающейся
администрированием доменных имен, например http://www.imhoster.net/domain.htm. Домен третьего уровня приобретается, как правило, вместе с хостингом у хостинговой компании. Имя сайта выбирают
исходя из вида деятельности, названия компании или фамилии владельца сайта
163

file_name: билет 28 тема 4.docx

title: Лекция "Адресация в сети Internet. Примеры."


extracted_text:
билет 29 тема 2
92 Стандартные визуальные компоненты в Delphi
ВИзуальный интерфейс в Delphi создается с помощью визуальных компонентов. Основные
из них находятся на вкладках Standard, Additional и Win32. Это стандартные компоненты,
которые входят в минимальный установочный пакет Delphi 7. Сейчас рассмотрим их
подробнее.
Компоненты Standard
Frames (фреймы);
MainMenu (главное меню);
PopupMenu (всплывающее меню);
Label (надпись);
Edit (однострочный редактор);
Memo (многострочный редактор);
Button (стандартная кнопка);
CheckBox (независимый переключатель, флажок); RadioButton (зависимый переключатель, переключатель);
ListBox (список);
ComboBox (поле со списком);
ScrollBar (полоса прокрутки);
GroupBox (группа);
RadioGroup (группа зависимых переключателей);
Panel (панель);
ActionList (список действий).
Компоненты Additional
BitBtn (кнопка с рисунком);
SpeedButton (кнопка быстрого доступа); MaskEdit (однострочный редактор с вводом по шаблону);
StringGrid (таблица строк);
DrawGrid (таблица);
Image (графическое изображение);
Shape (геометрическая фигура);
Bevel (фаска);
ScrollBox (область прокрутки);
CheckListBox (список флажков);
Splitter (разделитель);
StaticText (статический текст);
ControlBar (контейнер для панели инструментов); ApplicationEvents (события приложения);
ValueListEditor (редактор списка значений);
LabeledEdit (однострочный редактор с надписью);
ColorBox (комбинированный список выбора цвета);
Chart (диаграмма);
ActionManager (менеджер действий);
ActionMainMenuBar (главное меню действий);
ActionToolBar (панель действий);
XpColorMap (цветовая карта ХР для меню и панелей инструментов);
StandardColorMap (стандартная цветовая карта для меню и панелей инструментов);
TwilightColorMap (цветовая карта Twilight для меню и панелей инструментов); CustomizeDig (диалог настройки).
Компоненты Win32
TabControl (вкладка);
PageControl (блркнот);
ImageList (список графических изображений);
RichEdit (полнофункциональный тестовый редактор);
TrackBar (ползунок);
ProgressBar (индикатор выполнения);
UpDown (счетчик);
HotKey (редактор комбинаций «горячих» клавиш);
Animate (просмотр видеоклипов); DateTimePicker (строка ввода даты);
MonthCalendar (календарь);
TreeView (дерево объектов);
ListView (список);
HeaderControl (разделитель);
StatusBar (строка состояния);
ToolBar (панель инструментов);
CoolBar («крутая» панель инструментов);
PageScroller (прокрутка изображений);
ComboBoxEx (расширенный комбинированный список);
XpManifest (декларация ХР).

file_name: билет 29 тема 2.docx

title: Лекция "Стандартные визуальные компоненты в Delphi"