Разработка собственных компонентов

 

Глава 19. Разработка собственных компонентов ................................................................... 431

 

 

19.1 Пакеты. ............................................................................................................................ 432

 

19.2 Подготовка к созданию компонента. ........................................................................... 438

 

19.3 Создание первого компонента. ..................................................................................... 441

 

19.4 Создание иконки компонента. ...................................................................................... 449

 

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

 

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

Зайди на сайт www.torry.net и посмотри раздел VCL. Тут целое море компонентов, написанных разными программистами одиночками и маленькими фирмами. Некоторые даже зарабатывают этим деньги (я не думаю, что большие, но всё же).

Допустим, что ты написал какой-то код, который может пригодиться тебе в дальнейшем. Можно оформить этот код в виде DLL файла, но это не всегда возможно. Вдруг твой компонент реализует часы, которые должны выводиться на главной форме, а DLL не может такого позволить.

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

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

19.1 Пакеты.

 

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

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

Давай посмотрим, как работать с пакетами. Для начала создай где-нибудь у себя на компьютере папку Components. В неё ты будешь складывать все созданные или скаченные с интернета компоненты. Внутри этой папки создай ещё одну папку Other. Компонент, который мы сейчас проинсталлируем трудно отнести к какой-нибудь категории, поэтому я его поместил в папку с таким названием.

На диске, в директории Компоненты/Handles ты найдёшь исходники компонента, который мы будем сейчас устанавливать. Скопируй найденный там файл в папку Other. Скопировать нужно файла Handles.pas – здесь находиться исходник компонента.

Теперь запусти Delphi и закрой всё, что в нём открыто (File->Close All). Чтобы установить компонент выбери из меню Component выбери пункт Install Component. Перед тобой откроется окно, как на рисунке 19.1.1. В этом окне ты можешь увидеть три строки ввода:

1. 1. Unit file name. В первой строке нужно указать имя устанавливаемого компонента. Для этого щёлкни кнопку Browse и увидишь стандартное окно открытия файла. Открой файл Handles.pas.

2. 2. Search Path – здесь находиться список путей, по которым Delphi при компиляции ищет исходники установленных компонентов. В принципе, в конец этой строки мы должны были бы добавить после точки с запятой и путь к нашему компоненту, но пока этого делать не будем.

3. 3. Package file name. Это имя пакета, в который будет помещён устанавливаемый компонент. Здесь можно выбирать в выпадающем списке любой пакет.

4. 4. Package description. Текстовое описание пакета. Здесь может быть любой текст заданный тобой.

 

Будем считать, что у тебя в системе ещё нет своих пакетов и Delphi предложил установить новый компонент в пакет по умолчанию. Мы не будем этого делать, потому что так у нас в системе будет бардак. Давай создадим новый пакет, в который будем помещать все файлы из директории Components/Other. Для этого в этом же окне выбери сверху окна закладку Into new package и нажми кнопку Browse напротив строки Package file name. В появившемся стандартном окне открытия файлов перейди в директорию Components/Other и здесь вручную введи имя пакета OtherComponents и нажми кнопку «Открыть».

Теперь нажимай кнопку ОК, чтобы закрыть окно установки компонента. Перед тобой автоматически должно появиться сообщение типа: «Package OtherComponents.bpl will be build then installed. Continue?». Смысл сообщения следующий «Пакет OtherComponents будет откомпилирован и установлен в систему. Продолжить?». Можешь нажать «Yes» и Delphi сделает всё необходимое для установки нового компонента в систему. Я нажму «No» и покажу как это делать не автоматически и что же произошло.

Для начала у нас появилось новое окно, показанное на рисунке 19.1.2. В центре окна ты можешь видеть дерево из двух веток:

Contains – здесь содержаться модули входящие в пакет. У нас пока один модуль и ты видишь только его файлы.

Requires – здесь находиться список имён пакетов необходимых для компиляции данного пакета. В принципе, эти имена ты можешь удалить (иногда они не нужны), но если при компиляции хотя бы один из этих пакетов понадобиться, то появиться сообщение о необходимости подключения данных пакетов и Delphi снова их вернёт автоматически.

Сверху окна ты можешь видеть панели со следующими кнопками:

Compile – компилировать пакет.

Add – добавить новый модуль в этот пакет.

Remove – удалить модуль.

Install – установить пакет в систему. При нажатии этой кнопки, пакет при необходимости будет перекомпилирован.

Options – настройки пакета.

Прежде чем компилировать наш пакет, давай посмотрим его настройки. Нажми кнопку Options и ты увидишь окно, как на рисунке 19.1.3.

В принципе, большинство настроек схоже с настройками запускных файлов, но я не это хотел тебе показать. Обрати внимание на раздел Usage options, где ты указываешь, для чего будет использоваться пакет. Тебе доступны тут три варианта

1. 1. Designtime only – компоненты пакета могут использоваться только во время проектирования формы в оболочке Delphi.

2. 2. Runtime only – компоненты нельзя использовать во время проектирования, а можно только создавать во время выполнения программы. Для этого, на машине запускающей программу, обязательно должен присутствовать откомпилированный файл проекта (файл с тем же именем и расширением bpl).

 

3. Designtime and Runtime – компоненты пакета можно использовать в обоих случаях.

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

Но это всё лирическое отступление, чтобы показать тебе возможности пакетов. Чуть позже я покажу тебе, чем отличаются Designtime и Runtime пакеты на практике, а пока закрывай окно свойств пакета и возвращайся в окно пакета.

Нажми кнопку Install чтобы установить пакет в систему. Если кнопка Install недоступна, то сначала откомпилируй проект, а потом установи. Delphi откомпилирует пакет и выведет сообщение об удачной установке. Закрой окно пакета. При закрытии Delphi спросит о необходимости сохранить его, ответь «Да», чтобы все изменения сохранились.

Теперь на палитре компонентов у тебя должна появиться новая закладка с именем «CyD», где ты сможешь найти новый компонент. Некоторые компоненты попадают на закладку Symples, а для некоторых создаются новые закладки.

Теперь снова закрой всё (File->Close All) и создай новый проект приложения. Сейчас я покажу тебе, как используются Designtime и Runtime пакеты. Выбери пункт меню Options из меню Project. Перед тобой откроется окно свойств проекта, как на рисунке

19.1.4. В этом окне перейди на закладку Packages

Здесь, внизу окна ты можешь видеть CheckBox с текстом: «Build with runtime packages». Если здесь поставить галочку, то твои программы резко уменьшаются в размере, потому что в них будет храниться только код программы. Все компоненты, которые установлены на форме не попадут в запускной файл.

Когда программа будет запускаться, она будет подгружать эти компоненты из файлов пакетов перечисленных в строке чуть ниже CheckBox. Получается, что пакеты bpl могут работать как самые настоящие динамические библиотеки. Так ты можешь сильно экономить размер программ, но при переносе программы на другой компьютер, ты должен заботиться о том, чтобы и необходимые bpl файлы тоже попали на тот компьютер. Их достаточно скопировать в папку System (System32 для Windows NT/2000/XP) директории Windows.

Если убрать этот флажок, то программа становиться полноценной и не нуждается в дополнительных bpl файлах. Исключения составляют только случаи, когда ты использовал Runtime пакет, который не может компилироваться в программу и обязательно должен использоваться только на этапе работы программы. Но такие пакеты редкость и я не советую тебе их использовать. Работай с теми компонентами, которые можно установить на форму во время проектировки приложения.

Теперь проверим путь к нашему компоненту. Выбирай из меню Tools пункт Environment Options. Перед тобой откроется окно настроек Delphi. В этом окне нужно перейти на закладку Library (рисунок 19.1.5).

В этом окне ты можешь увидеть следующие строки ввода:

Library Path – здесь перечислены пути, где Delphi должен искать исходники компонентов.

BPL output directory – здесь указывается директория, куда будут сохраняться откомпилированные пакеты. По умолчанию здесь указано $(DELPHI)ProjectsBpl. Конструкция $(DELPHI) указывает на директорию, куда установлен Delphi. Получается, что bpl файлы будут сохраняться в директорию, где установлен Delphi, поддиректорию ProjectsBpl.

DCP output directory – директория, в которую будут помещаться DCP файлы. Это скомпилированные файлы пакета, которые хранят все информацию о всех компонентах скомпилированных в пакет.

Browsing Path – пути для просмотра.

Нас сейчас интересует только первая строка, остальные вообще можно оставлять по умолчанию. Нажми на кнопку с тремя точками справа от строки Library Path. Перед тобой откроется окно редактора путей, как на рисунке 19.1.6.

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

Проверь список на наличие пути к директории, где у нас находиться исходник файла Handles.pas. Если такого пути нет, то щёлкни по кнопке с тремя точками справа от строки ввода и ты увидишь окно выбора директории. Найди нужную директорию и нажми ОК. Теперь выбранный путь находиться в строке ввода. Чтобы его добавить в список, нужно нажать кнопку “Add”. Сделай это и можешь закрывать окно редактора путей нажатием кнопки «ОК». После этого закрой и окно настроек Delphi.

Если ты не добавишь путь к исходникам в настройки Delphi, то компилятор не найдёт исходный код и при компиляции выдаст ошибку.

Когда ты устанавливаешь Runtime пакет, то тебе необходимо найти файл с расширением bpl в директории $(DELPHI)ProjectsBpl и скопировать его в системную папку Windows.

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

Рисунок 19.1.7. Окно установки пакетов.

Для установки уже скомпилированного пакета выбери из меню Component пункт Install Packages. Перед тобой откроется окно (рисунок 19.1.7), которое похоже на закладку Packages окна свойств проекта, которое ты мог видеть на рисунке 19.1.4.

Для установки нового пакета нужно нажать кнопку Add. Перед тобой откроется стандартное окно открытия файлов. Найди нужный bpl файл и открой его. Delphi автоматически установит все компоненты из пакета в палитру компонентов.

 

19.2 Подготовка к созданию компонента.

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

объекты в Delphi происходят от объекта TObject. А все компоненты имеют среди родственников объект TComponent. На рисунке 19.2.1 показана иерархия предков компонента TButton.

В самом верху иерархии находиться объект TObject. Как я уже говорил, абсолютно все объекты происходят именно от него. В TObject находятся базовые свойства и методы, которые необходимы любому другому объекту. Именно поэтому, чтобы во всех объектах не прописывать одни и те же свойства и методы, всё уже реализовано в TObject. Остальные просто наследуют эти возможности.

Далее по иерархии идёт объект TPersistent, который является предком для всех объектов, которые должны уметь назначаться другим объектам. Например, если наш объект должен уметь выполнять метод Assign (назначить), то этот объект должен иметь в предках объект TPersistent.

Следующим в иерархии идёт объект TComponent. Этот объект должен быть предком для любых компонентов Delphi, которые должны уметь ставиться на форму в режиме проектирования. Этот объект наследует все свойства и методы своих предков (Tpersistent и TObject) и добавляет новые возможности по работе с объектом, как с полноценным компонентом на форме.

Если компонент должен быть видимым во время выполнения программы, то он обязательно должен происходить от компонента TControl (следующий в иерархии для кнопки). Для невидимых компонентов (например компоненты с закладки Dialogs, которые не видны во время выполнения), этот объект среди предков не нужен.

Следующий в иерархии идёт TWinControl. Этот объект добавляет функции получения фокуса ввода, работы с текстовым буфером, возможность содержания дочерних компонентов. Если твой компонент будет иметь среди предков TWinControl, то поверх этого компонента можно будет ставить ещё компоненты (не обязательно, но возможно) в режиме дизайна формы. TWinControl – имеет дескриптор (Handle) окна и может получать фокус. Вспомни пример с потоками, где мы использовали для вывода текста из потока компонент TLabel. Когда мы решили подкорректировать поток и добавить возможность посылать сообщения SendMessage, то нам пришлось заменить TLabel на TEdit, потому что у первого не было дескриптора окна и мы не могли ему отсылать сообщения Windows.

Следующий – TButtonControl. Это уже компонент кнопки, в котором реализуется множество необходимых кнопке свойств и методов.

Нужно ещё сказать об одном базовом для некоторых компонентов – TGraphicControl. Если твой компонент должен будет иметь метод Paint, т.е. уметь рисовать на поверхности графику, то он должен иметь среди предков этот объект.

И последний базовый объект – TCustomControl – это сочетание двух объектов – TGraphicControl и TWinControl, т.е. компонент имеющий дескриптор окна и умеющий метод Paint.

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

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

Открой файл помощи в Delphi (меню Help->Delphi help). В появившемся окне найди объект TButton (рисунок 19.2.2). Для этого введи в строку ввода сверху имя TButton.

Рисунок 19.2.2. Поиск компонента TButton в файле помощи.

Теперь в большом списке выдели строку TButton и нажми кнопку «Показать». Перед тобой откроется окно с найденными разделами (рисунок 19.2.3). В данном случае список будет состоять из двух строк:

1. 1. TButton

2. 2. TButton (VCL Reference)

 

Первая строка явно относиться к объекту TButton из библиотеки CLX (если ничего не указано, то это скорей всего библиотека CLX). Вторая строка – это объект в библиотеке VCL. Оба варианта компонента схожи и имеют очень много одинаковых свойств и методов, но могут быть и отличия в VCL версии специфичные для платформы Windows. Мы в книге рассматриваем платформу Windows, поэтому выбирай VCL вариант и нажимай кнопку «Показать».

Перед тобой откроется окно помощи по выбранному объекту и оно должно выглядеть, как на рисунке 19.2.4.

Сверху окна ты можешь видеть следующие ссылки:

1. Hierarchy – если щёлкнуть по этой ссылке, то перед тобой откроется окно, как на рисунке 19.2.1 с иерархией компонента.

1. 2. Properties – здесь тебе покажут все свойства компонента.

2. 3. Methods – это метода компонента.

3. 4. Events – события, которые может генерировать компонент.

 

Попробуй посмотреть свойства. Щёлкни по ссылке Properties и перед тобой откроется окно, как на рисунке 19.2.5. В этом окне ты можешь увидеть все свойства разбитые по разделам. Большим жирным шрифтом написаны имена разделов, а после этого идут ссылки на свойства. Щёлкая по любой ссылке, можно получить её описание.

Обрати внимание на имена разделов. Например Derived from TWinControl. Судя по названию, в этом разделе будут перечислены все свойства, которые компонент получил от объекта TWinControl. Оно так и есть. Выбирая любой компонент ты можешь увидеть его и унаследованные от предков свойства. То же самое и с методами.

 

19.3 Создание первого компонента.

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

потренироваться и в программировании.

В качестве примера я выбрал достаточно простой, но сложный математики пример -часы. Наши часы смогут работать как аналоговые и числовые. Так что по этим часам будет Москва сверятся.

Для создания нового компонента выбери из меню Component пункт New Component. Перед тобой откроется окно, как на рис 19.3.1, где ты должен будешь заполнить основные параметры будущего компонента.

Давай рассмотрим каждое окошечко в отдельности:

Ancestor type -тип предка. Это имя объекта, от которого мы породим наш объект. Это даст нашему объекту все возможности его предка, плюс мы добавим свои. Для часиков нам понадобится TGraphicControl, потому что наш компонент должен будет иметь метод Paint, т.к. часы будут графическими.

Class Name -имя нашего будущего компонента. Я его назвал TGraphicClock.

Palette Page -имя палитры компонентов, куда будет помещён наш компонент после инсталляции. Я оставил значение по умолчанию "Samples". Но ты можешь поместить его даже на закладку "Standard".

Unit file name -имя и путь к модулю, где будет располагаться исходный код компонента. Это поле заполняется автоматически, но ты его можешь изменить. Если не хочешь менять, то хотя бы посмотри под каким именем сохранят твой компонент и где.

Search path – здесь перечислены пути, где Delphi ищет исходные коды. Если ты располагаешь компонент в новой директории, о которой Delphi ещё не знает, то обязательно нужно добавить её сюда.

Введи данные о будущем компоненте и нажимай "ОК" (именно "ОК", а не Install). После этого, Delphi создаст новый модуль с шаблоном для будущего компонента:

unit GraphicClock;

Interface

uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

Type

TGraphicClock = class(TGraphicControl)

Private

{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
published
{ Published declarations }
end;

Procedure Register; implementation

procedure Register; begin RegisterComponents('Samples', [TGraphicClock]); end;

End.

В шаблоне реализована только одна процедура – Register. В этой процедуре происходит вызов RegisterComponents с двумя параметрами:

1. Имя закладки, на которую нужно будет поместить этот компонент.

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

В принципе простейший компонент готов и его можно установить в Delphi. Но этот компонент ничего не умеет и он пока является полным аналогом своего предка TGraphicControl. Чтобы он стал отличатся, сейчас мы добавим ему разные свойства.

Начнём написание нашего компонента с конструктора и деструктора. Конструктор -это метод объекта, который автоматически вызывается при создании компонента. Деструктор -тоже метод, только она автоматически вызывается при уничтожении компонента. Вызывать эти метода напрямую нельзя, а если и можно, то не желательно.

В конструкторе мы проинициализируем все наши переменные, которые понадобятся при его работе, а в деструкторе уничтожим. Итак, напиши в разделе public:

constructor Create(AOwner: TComponent); override;

Как видишь, объявление метода похоже на объявление любой другой процедуры или функции, только вместо ключевого слова procedureстоит слово constructor. Ключевое слово override; после имени этих процедур говорит о том, что мы хотим переписать уже существующую у предка функцию с таким именем. У большинства компонентов есть конструктор и когда мы создаём конструктор у потомка, то у нас получается два метода с одним именем (у предка и у нашего объекта).

Теперь нажми сочетание клавиш CTRL+SHIFT+C и Delphi сам создаст заготовку для конструктора:

constructor TGraphicClock.Create(AOwner: TComponent); begin inherited; end;

Поправим её до вот такого вида:

 

constructor TGraphicClock.Create(AOwner: TComponent);
begin
//Вызываем конструктор предка

inherited Create(AOwner);

Устанавливаем значения ширины и высоты по умолчанию

Width := 50; Height := 50;

 

//Устанавливаем переменную ShowSecondArrow в true. //Она будет у нас отвечать за показ секундной стрелки ShowSecondArrow := true;

//Инициализируем остальные переменные PrevTime := 0; CHourDiff := 0; CMinDiff := 0;

 

Инициализируем растры TBitmap, в которых будут хранится

FBitmap:= TBitmap.Create; FBitmap.Width := Width; FBitmap.Height := Height;   //Выставляем формат времени DateFormat:='tt';

Private

Для часов обязательно понадобится таймер

//Картинки часов и фона FBitmap, FBGBitmap: TBitmap; /События FOnSecond, FOnMinute, FOnHour: TNotifyEvent;

Protected

{ Protected declarations }

procedure TickerCall(Sender: TObject);

Жмём CTRL+SHIFT+C и модифицируем созданную функцию:

 

procedure TGraphicClock.TickerCall(Sender: TObject); var H,M,S,Hp,Mp,Sp: word;

begin //Если компонент создан в дизайнере, то выход if csDesigning in ComponentState then exit;

 

Иначе это уже запущеная программа

//Сгенерировать событие OnSecond if Assigned( FOnSecond) then FOnSecond(Self);…