Все классы библиотеки визуальных компонентов (VCL) произошли от группы базовых классов, которые лежат в основе иерархии. Самый общий предок компонентов — это класс TObject, инкапсулирующий простейший объект. Как известно (см. гл. 1), каждый объект наследует свойства и методы родительского класса. К объекту можно добавить новые свойства и методы, но нельзя удалить унаследованные. Объект-наследник в свою очередь может стать родительским для нового класса, который унаследует возможности всех своих предков.
билет 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
beginForinl. 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 Руководство разработчика,
находящегося
билет 26.docx
