Руководство по созданию своих компонентов на delphi

Для чего нужны компоненты

  Дельфи имеет
открытую архитектуру — это значит, что
каждый программист волен
усовершенствовать эту среду
разработки, как он захочет. К
стандартным наборам компонентов,
которые поставляются вместе с Дельфи
можно создать еще массу своих
интересных компонентов, которые
заметно упростят вам жизнь (это я вам
гарантирую). А еще можно зайти на какой-нибудь
крутой сайт о Дельфи и там скачать кучу
крутых компонентов, и на их основе
сделать какую-нибудь крутую прогу. Так
же компоненты освобождают вас от
написания «тысячи тонн словесной
руды». Пример: вы создали компонент —
кнопку, при щелчке на которую данные из
Memo сохранятся во временный файл. Теперь
как только вам понадобится эта функция
вы просто ставите этот компонент на
форму и наслаждаетесь результатом. И не
надо будет каждый раз прописывать это,
для ваших новых программ — просто
воспользуйтесь компонентом.

Шаг 1. Придумывание идеи

  Первым шагом нужно ответить себе на вопрос: «Для
чего мне этот компонент и что он будет
делать?». Затем необходимо в общих
чертах продумать его свойства, события,
на которые он будет реагировать и те
функции и процедуры, которыми
компонент должен обладать. Затем очень
важно выбрать «предка» компонента, то
есть наследником какого класса он
будет являться. Тут есть два пути. Либо в
качестве наследника взять уже готовый
компонент (то есть модифицировать уже
существующий класс), либо  создать
новый класс. 

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

1. Создание Windows-элемента управления (TWinControl)
2. Создание
   графического элемента управления (TGraphicControl)
3. Создание
   нового класса или элемента управления (TCustomControl)
4. Создание
   невизуального компонента (не видимого) (TComponent)

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

  Невизуальные
компоненты видны только во время
разработки приложения (Design-Time), а во
время работы приложения (Run-Time) их не
видно, но они могут выполнять какую-нибудь
работу. Наиболее часто используемый
невизуальный компонент — это Timer.

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

Шаг 2. Создание пустого модуля компонента

  Рассматривать этот шаг я буду исходя из устройства
Дельфи 3, в других версиях этот процесс
не сильно отличается. Давайте
попробуем создать кнопку, у которой
будет доступна информация о количестве
кликов по ней.

  Чтобы
приступить к непосредственному
написанию компонента, вам необходимо
сделать следующее:

• Закройте
  проекты, которые вы разрабатывали (формы
  и модули)
• В основном
  меню выберите Component -> New Component…
• Перед вами
  откроется диалоговое окно с
  названием «New Component»
•  В поле
  Ancestor Type (тип предка) выберите класс
  компонента, который вы хотите
  модифицировать. В нашем случае вам
  надо выбрать класс TButton
• В поле Class Name
  введите имя класса, который вы хотите
  получить. Имя обязательно должно
  начинаться с буквы «T». Мы
  напишем туда, например, TCountBtn
• В поле Palette
  Page укажите имя закладки на которой
  этот компонент появиться после
  установки. Введем туда MyComponents (теперь
  у вас в Делфьи будет своя закладка с
  компонентами!).
• Поле Unit File Name
  заполняется автоматически, в
  зависимости от выбранного имени
  компонента. Это путь куда будет
  сохранен ваш модуль.
• В поле Search Path
  ничего изменять не нужно.
• Теперь
  нажмите на кнопку Create Unit и получите
  следующее:

unit CountBtn;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls;

type
 TCountBtn = class(TButton)

  private
   { Private declarations }

  protected
   { Protected declarations }

  public
   { Public declarations }

  published
   { Published declarations }
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('MyComponents', [TCountBtn]);
end;

end.

Шаг 3. Начинаем разбираться во всех директивах

Что же здесь написано? да собственно пока ничего
интересного. Здесь объявлен новый
класс TCountBtn и процедура регистрации
вашего компонента в палитре
компонентов.

Директива Private.
Здесь вы будете писать все скрытые поля
которые вам понадобятся для создания
компонента. Так же в этой директиве
описываются процедуры и функции,
необходимые для работы своего
компонента, эти процедуры и функции
пользователю не доступны. Для нашего
компонент мы напишем туда следующее (запись
должна состоять из буквы «F» имени
поля: тип этого поля):

FCount:integer;

Буква «F»
должна присутсвовать обязательно.
Здесь мы создали скрытое поле Count, в
котором и будет храниться число кликов
по кнопке.

Директива Protected. Обычно я здесь пишу различные
обработчики событий мыши и клавиатуры.
Мы напишем здесь следующую строку:

procedure Click; override;

Это указывает на то, что мы
будем обрабатывать щелчок мыши по
компоненту. Слово «override» указывает
на то, что мы перекроем стандартное
событие OnClick для компонента предка.

В директиве Public описываются те процедуры и функции
компонента, которые будут доступны
пользователю. (Например, в процессе
написания кода вы пишите имя
компонента, ставите точку и перед вами
список доступных функций, объявленных
в диретиве Public). Для нашего компонента,
чтобы показать принцип использования
этой директивы создадим функцию — ShowCount,
которая покажет сообщение, уведомляя
пользователя сколько раз он уже нажал
на кнопку. Для этого в директиве Public
напишем такой код:

procedure ShowCount;

Осталась последняя директива Published. В ней также
используется объявления доступных
пользователю, свойств и методов
компонента. Для того, чтобы наш
компонент появился на форме необходимо
описать метод создания компонента (конструктор),
можно прописать и деструктор, но это не
обязательно. Следует обратить внимание
на то, что если вы хотите, чтобы какие-то
свойства вашего компонента появились в
Инспекторе Объектов (Object Inspector) вам
необходимо описать эти свойства в
директиве Published. Это делается так: property
Имя_свойства (но помните здесь букву
«F» уже не нужно писать), затем
ставиться двоеточие «:» тип
свойства, read процедура для чтения
значения, write функция для записи
значения;. Но похоже это все сильно
запутано. Посмотрите, что нужно
написать для нашего компонента и все
поймете:

constructor Create(aowner:Tcomponent);override; //Конструктор
property Count:integer read FCount write FCount; //СвойствоCount

Итак все объявления сделаны и мы можем
приступить к написанию непосредственно
всех объявленных процедур.

Шаг 4. Пишем процедуры и функции.

Начнем с написания конструктора. Это делается примерно так:

constructor TCountBtn.Create(aowner:Tcomponent);
begin
 inherited create(Aowner);
end;

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

Теперь мы напишем процедуру обработки щелчка
мышкой по кнопке:

procedure Tcountbtn.Click;
begin
  inherited click;
  FCount:=FCount+1;
end;

«Inherited click»
означает, что мы повторяем стандартные
методы обработки щелчка мышью (зачем
напрягаться и делать лишнюю работу:)).

У нас осталась
последняя процедура ShowCount. Она может
выглядеть примерно так:

procedure TCountBtn.ShowCount;
begin
  Showmessage('По кнопке '+ caption+' вы сделали: '+inttostr(FCount)+' клик(а/ов)');
end;

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

И если вы все поняли и сделали правильно,
то у вас должно получится следующее:

unit CountBtn;
 
interface
 
uses
 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
 StdCtrls, ExtCtrls;
 
type
 TCountBtn = class(TButton)
  private
   { Private declarations }
  FCount: integer;
  protected
   { Protected declarations }
  procedure Click;override;
  public
   { Public declarations }
  procedure ShowCount;
  published
   { Published declarations }
  property Count:integer read FCount write FCount;
  constructor Create(aowner:Tcomponent); override;
 end;
 
procedure Register;
 
implementation
 
procedure Register;
begin
 RegisterComponents('Mihan Components', [TCountBtn]);
end;
 
constructor TCountBtn.Create(aowner:Tcomponent);
begin
 inherited create(Aowner);
end;
 
procedure Tcountbtn.Click;
begin
 inherited click;
 FCount:=FCount+1;
end;
 
procedure TCountBtn.ShowCount;
begin
 Showmessage('По кнопке '+ caption+' вы сделали: '+inttostr(FCount)+' клик(а/ов)');
end;

end.

Скорее сохраняйтесь, дабы не потерять случайным образом байты набранного кода:)).

Шаг 5. Устанавливаем компонент

Если вы сумели
написать и понять, все то что здесь
предложено, то установка компонента не
должна вызвать у вас никаких проблем.
Все здесь делается очень просто. В
главном меню выберите пункт Component ->
Install Component. перед вами открылось
диалоговое окно Install Component. В нем вы
увидите две закладки: Into exsisting Package и Into
new Package. Вам предоставляется выбор
установить ваш компонент в уже
существующий пакет или в новый пакет соответственно.
Мы выберем в уже существующий пакет.

В поле Unit File Name
напишите имя вашего сохранненого
модуля (естественно необходимо еще и
указать путь к нему), а лучше
воспользуйтесь кнопкой Browse и выберите
ваш файл в открывшемся окне.

В Search Path ничего
изменять не нужно, Делфьи сама за вас
все туда добавит.

В поле Package File
Name выберите имя пакета, в который будет
установлен ваш компонент. Мы
согласимся с предложенным по умолчанию
пакетом.

Теперь
нажимаем кнопочку Ok. И тут появиться
предупреждение Package dclusr30.dpk will be rebuilt.
Continue? Дельфи спрашивает: «Пакет такой-то
будет изменен. Продолжить?». Конечно
же надо ответить «Да». И если вы все
сделали правильно, то появиться
сообщение, что ваш компонент
установлен. Что ж можно кричать Ура! Это
ваш первый компонент.

Создание свойств своего типа

Теперь мы
попробуем создать свойство
нестандартного типа. Рассмотрим это на
примере метки — TLabel. У этого компонента
есть такое свойство: Alignment. Оно может
принимать следующие значения: taLeftJustify,
taCenter, taRightJustify. Приступаем к созданию
свойства. Ничего интересного мне
придумать не удалось, но тем не менее я
вам покажу это на примере того свойства,
которое я придумал. Оно очень простое и
поможет вам разобраться. Свойство
будет называться ShowType (тип TShowTp), в нашем
компоненте оно будет отвечать за
отображение свойства Count. Если
пользователь установит свойство ShowType в
Normal, то кнопка будет работать, как и
работала. А если пользователь присвоит
этому свойтсву значение CountToCaption, то
количество кликов, будет отображаться
на самой кнопке.

Для
начале нам необходимо объявить новый
тип. Описание типа нужно добавить после
слова Type. Вот так это выглядело вначале:

type
TCountBtn = class(TButton)

Вот так это должно выглядеть:

type
 TShowTp = (Normal, CountToCaption);
 TCountBtn = class(TButton)

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

Теперь
нам понадобиться создать поле этого
типа. Это мы уже умеем и делать и
поэтому не должно вызвать никаких
сложностей. В директиву Private напишите:

FShowType:TShowTp;

Мы
создали поле ShowType, типа TShowTp.

Конечно
же необходимо добавить это свойство в
инспектор объектов:

property ShowType: TshowTp read FshowType write FShowType;

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

procedure Tcountbtn.Click;
begin
 inherited click;
 FCount:=Fcount+1;
 if ShowType = Normal then
   Caption:=Caption;
 if ShowType = CountToCaption then
   Caption:='Count= '+inttostr(count);
end;

Объясню
что произошло. Вначале мы увеличиваем
счетчик на единицу. Затем проверяем
какое значение имеет свойство ShowType.
Если Normal, то ничего не делаем, а если
CountToCaption, то в надпись на кнопке выводим
количество кликов. Не так уж и сложно
как это могло показаться с первого раза.

Имплантируем таймер в компонент

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

После раздела uses,
где описаны добавленные в программу
модули, объявите переменную типа TTimer.
Назовем ее Timer. Приведу небольшой
участок кода:

unit CountBtn;

interface
        
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls;
        
var Timer: TTimer;
type

Дальше в директиву Protected необходимо добавить обработчик события OnTimer для нашего таймера. Это делается так:

		
procedure OnTimer(Sender: TObject);

Поскольку наш таймер это не переменная, а компонент, его тоже надо создать, для этого в конструктор нашей кнопки напишем:

		
constructor TCountBtn.Create(aowner:Tcomponent);
begin
 inherited create(Aowner);
 Timer:=TTimer.Create(self);
 Timer.Enabled:=true;
 Timer.OnTimer:=OnTimer;
 Timer.Interval:=10000;
end;

Здесь создается экземпляр нашего таймера и
его свойству Iterval (измеряется в
миллисекундах) присваивается
значение 10000 (то есть 10 секунд если по простому).
Собственно осталось написать саму процедуру OnTimer.
Я сделал это так:

		
procedure TCountBtn.OnTimer(Sender: TObject);
begin
 FCount:=FCount*2;
end;

Вот примерно то, что у вас должно получиться в конце:

unit CountBtn;
  
interface
  
uses
 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
 StdCtrls, ExtCtrls;
  
var Timer: TTimer;
type
 TShowTp = (Normal, CountToCaption);
 TCountBtn = class(TButton)
  
 private
  { Private declarations }
  
 FCount:integer;
 FShowType:TShowTp;

 protected
  { Protected declarations }
 procedure OnTimer(Sender: TObject);
 procedure Click;override;

 public
  { Public declarations }
 procedure ShowCount;

 published
  { Published declarations }
 property Count:integer read FCount write FCount;
 constructor Create(aowner:Tcomponent);override;
 property ShowType: TshowTp read FshowType write FShowType;
end;
  
procedure Register;
  
implementation
  
procedure Register;
begin
 RegisterComponents('Mihan Components', [TCountBtn]);
end;
  
constructor TCountBtn.Create(aowner:Tcomponent);
begin
  inherited create(Aowner);
  Timer:=TTimer.Create(self);
  Timer.Enabled:=false;
  Timer.OnTimer:=OnTimer;
  Timer.Interval:=1000;
end;
  
procedure Tcountbtn.Click;
begin
  inherited click;
  FCount:=Fcount+1;
  Timer.Enabled:=true;
  if ShowType = Normal then
  Caption:=Caption;
  if ShowType = CountToCaption then
    Caption:='Count= '+inttostr(count);
end;
  
procedure TCountBtn.ShowCount;
begin
  Showmessage('По кнопке '+ caption+' вы сделали: '+inttostr(FCount)+' клик(а/ов)');
end;
  
procedure TCountBtn.OnTimer(Sender: TObject);
begin
  FCount:=FCount*2;
end;
  
end.

Если у вас что-то не сработало, то в начале проверьте все ли
у вас написано правильно. Затем
проверьте может у вас не хватает какого-нибудь
модуля в разделе Uses.

Переустановка компонента

public
{Public declarations}
constructor CreateShow(AOwner: TComponent; Msg, Cpt: String; Flags: Integer = 0;
Show: Boolean = false);

published
  property Buttons: TMBBtns read GetButtons write
SetButtons default btnOK;
  property Icon: TMBIcon read GetIcon write
SetIcon default icoError;
  property DefaultButton: Integer read GetDefButton
write SetDefButton default 1;
  property Modality: TMBModality read GetModality write
SetModality default modApplModal;
  property Help: Boolean read GetHelp write
SetHelp default false;
  property WinStyle: TMBWinStyle read GetWinStyle write
SetWinStyle default [];
  property TextAttr: TMBTextAttr read GetTextAttr write
SetTextAttr default [];

type
  TMBBtns = (btnOK, btnOKCancel, btnAbortRetryIgnore, btnYesNo,
btnYesNoCancel, btnRetryCancel);
  TMBTextAttr = set of (taRight, taRTLReading);
  TMBModality = (modApplModal, modSystemModal, modTaskModal);
  TMBWinStyles = (modSetForeground, modDefaultDesktopOnly, modTopMost);
  TMBWinStyle = set of TMBWinStyles;
  TMBIcon = (icoNone, icoError, icoQuestion, icoWarning, icoInfo);

private
{ Private declarations }
  function GetButtons: TMBBtns;
  procedure SetButtons(Value: TMBBtns);
  function GetIcon: TMBIcon;
  procedure SetIcon(Value: TMBIcon);
  function GetDefButton: Integer;
  procedure SetDefButton(Value: Integer);
  function GetModality: TMBModality;
  procedure SetModality(Value: TMBModality);
  function GetHelp: Boolean;
  procedure SetHelp(Value: Boolean);
  function GetWinStyle: TMBWinStyle;
  procedure SetWinStyle(Value: TMBWinStyle);
  function GetTextAttr: TMBTextAttr;
  procedure SetTextAttr(Value: TMBTextAttr);
{…}
implementation
{…}
function TMsgBox.GetButtons: TMBBtns;
begin
{…Код, возврщаем значение} 
end;

TMsgBox.SetButtons(Value: TMBBtns);
begin
{…Код, записываем значение в поле} 

end;

{etc…}

TMsgBoxEditor = class(TComponentEditor)
  function GetVerbCount: Integer; override;
  function GetVerb(Index: Integer): String; override;
  procedure ExecuteVerb(Index: Integer); override;
  procedure Edit; override;
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  RegisterComponentEditor(TMsgBox, TMsgBoxEditor);
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  RegisterComponentEditor(TMsgBox, TMsgBoxEditor);
  RegisterPropertyInCategory(TCopyrightCategory, TMsgBox, ‘About’);
  RegisterPropertiesInCategory(TVisualCategory, TMsgBox, [‘Buttons’, ‘DefaultButton’,
‘WinStyle’]);
  RegisterPropertiesInCategory(TLocalizableCategory, TMsgBox, [‘TextAttr’,
‘Modality’, ‘Flags’]);
end;

TCopyrightCategory = class(TPropertyCategory)
  class function Name: String; override;
end;
{…}
implementation
{…}
class function TCopyrightCategory.Name: String;
begin
  Result:= ‘Copyright, etc’;
end;

private
  {…}
  fAbout: String;
{…}
published
  {…}
  property About: String read fAbout write SetAbout;
{…}
implementation
{…}
constructor TMsgBox.Create(AOwner: TComponent);
begin
  {…}
  fAbout:= ‘TMsgBox by Andrew Breslav, 2000’;
end;
{…}
procedure TMsgBox.SetAbout(Value: String);
begin end;

private
  {…}
  fOnSuccess: TNotifyEvent;
  fBExecute: TNotifyEvent;
  fAExecute: TNotifyEvent;
{…}
published
  {…}
  property OnSuccess: TNotifyEvent read fOnSuccess write
fOnSuccess;
  property BeforeExecute: TNotifyEvent read fBExecute
write fBExecute;
  property AfterExecute: TNotifyEvent read fAExecute
write fAExecute;
{…}
implementation
{…}
function TMsgBox.Execute: Boolean;
begin
  if Assigned(fBExecute) then fBExecute(Self);
  fDResult:= MessageBox(fhWnd, PChar(fText), PChar(fCaption), fFlags);
  Result:= fDResult in fTrueResults;
  if (Result) and (Assigned(fOnSuccess)) then
fOnSuccess(Self);
  if Assigned(fAExecute) then fAExecute(Self);
end;

private
  {…}
  fDialog: Boolean;
{…}
published
  {…}
  property Dialog: Boolean read fDialog write
fDialog default true;
{…}
implementation
{…}
function TMsgBox.Execute: Boolean;
var
  Wnd: THandle;
  i: Integer;
begin
  if Assigned(fBExecute) then fBExecute(Self);
  if not fDialog then
    begin
      if GetIcon = icoNone then i:=
MB_OK
      else i:= 16*GetNumBit(fFlags, 2);
      MessageBeep(i);
    end
  else begin
            Wnd:= fhWnd;
            if fhWnd
<= 32 then
             
case fhWnd of
               
1: Wnd:= Application.Handle;
               
2: Wnd:= GetDesktopWindow;
              
end;
            fDResult:=
MessageBox(Wnd, PChar(fText), PChar(fCaption), fFlags);
          end;
  Result:= fDResult in fTrueResults;
  if (Result) and (Assigned(fOnSuccess)) then
fOnSuccess(Self);
  if Assigned(fAExecute) then fAExecute(Self);
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  {…}
  RegisterPropertyEditor(TypeInfo(DWord), TMsgBox, ‘Flags’, TROIntProperty);
end;

TMBIconProperty = class(TEnumProperty)
  function GetAttributes: TPropertyAttributes; override;
  procedure ListDrawValue(const Value: string;
ACanvas: TCanvas;
                                           
const ARect: TRect; ASelected: Boolean); override;
  procedure ListMeasureWidth(const Value: string;
ACanvas: TCanvas;
                                                
var AWidth: Integer); override;
  procedure ListMeasureHeight(const Value: string;
ACanvas: TCanvas;
                                                
var AHeight: Integer); override;
  procedure PropDrawValue(ACanvas: TCanvas; const ARect:
TRect;
                                             
ASelected: Boolean); override;
end;

function TMBIconProperty.GetAttributes: TPropertyAttributes;
begin
  Result:= [paValueList, paMultiSelect, paRevertable];
end;

procedure TMBIconProperty.ListDrawValue(const Value:
string; ACanvas: TCanvas; const ARect: TRect; ASelected:
Boolean);
var
  IDI: PChar;
begin
  IDI:= nil;
  if Value = ‘icoError’ then
    IDI:= IDI_ERROR
  else if Value = ‘icoQuestion’ then
            IDI:= IDI_QUESTION
  else if Value = ‘icoWarning’ then
            IDI:= IDI_WARNING
  else if Value = ‘icoInformation’ then
            IDI:= IDI_INFORMATION;
  with ACanvas do
    try
      if ASelected then Brush.Color:=
clHighlight;
      FillRect(ARect);
      DrawIconEx(ACanvas.Handle, ARect.Left, Arect.Top,
LoadIcon(0, IDI), GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0,
                            
0, DI_NORMAL or DI_DEFAULTSIZE);
    finally
      inherited ListDrawValue(Value, ACanvas,
Rect(ARect.Left+GetSystemMetrics(SM_CXSMICON), Arect.Top, ARect.Right, ARect.Bottom),
ASelected);
    end;
end;

procedure TMBIconProperty.PropDrawValue(ACanvas: TCanvas; const
ARect: TRect;
ASelected: Boolean);
begin
  if GetVisualValue <> » then
    ListDrawValue(GetVisualValue, ACanvas, ARect, false)
  else
    inherited PropDrawValue(ACanvas, ARect, ASelected);
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  {…}
  RegisterPropertyEditor(TypeInfo(TMBIcon), TMsgBox, ‘Icon’,
TMBIconProperty);
end;

procedure TMBModalProperty.ListDrawValue(const Value:
string; ACanvas: TCanvas; const ARect: TRect; ASelected:
Boolean);
var
  IDI: PChar;
  Inst: THandle;
begin
  IDI:= IDI_APPLICATION;
  Inst:= 0;
  if Value = ‘modTaskModal’ then
    begin
      IDI:= ‘icoTaskModal’;
      Inst:= hInstance;
    end
  else if Value = ‘modSystemModal’ then
            IDI:= IDI_WINLOGO;
  with ACanvas do
    try
      if ASelected then Brush.Color:=
clHighlight;
      FillRect(ARect);
      DrawIconEx(ACanvas.Handle, ARect.Left, Arect.Top,
LoadIcon(Inst, IDI), GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
                             0,0,
DI_NORMAL or DI_DEFAULTSIZE);
    finally
      inherited ListDrawValue(Value, ACanvas,
Rect(ARect.Left+GetSystemMetrics(SM_CXSMICON), Arect.Top, ARect.Right, ARect.Bottom),
ASelected);
    end;
end;

TAboutProperty = class(TPropertyEditor)
  function GetAttributes: TPropertyAttributes; override;
  function GetName: String; override;
  procedure PropDrawName(ACanvas: TCanvas; const ARect:
TRect;
                                             ASelected:
Boolean); override;
  procedure Edit; override;
  procedure ListDrawValue(const Value: string;
ACanvas: TCanvas;
                                           const
ARect: TRect; ASelected: Boolean); override;
  procedure ListMeasureWidth(const Value: string;
ACanvas: TCanvas;
                                                var
AWidth: Integer); override;
  procedure ListMeasureHeight(const Value: string;
ACanvas: TCanvas;
                                                var
AHeight: Integer); override;
  function GetValue: string; override;
  procedure GetValues(Proc: TGetStrProc); override;
end;

function TAboutProperty.GetAttributes:
TPropertyAttributes;
begin
  Result:= [paValueList, paReadOnly, paMultiSelect];
end;

function TAboutProperty.GetName: String;

begin
  Result:= ‘About this component…’;
end;

procedure TAboutProperty.PropDrawName(ACanvas: TCanvas; const
ARect: TRect; ASelected: Boolean);
begin
  DrawIconEx(ACanvas.Handle, 0, ARect.Top, LoadIcon(hInstance, ‘logo’),
GetSysTemMetrics(SM_CXSMICON), GetSysTemMetrics(SM_CXSMICON),
                         0,0,DI_NORMAL
or DI_DEFAULTSIZE);
  ACanvas.Font.Color:= clRed;
  inherited PropDrawName(ACanvas,
Rect(GetSystemMetrics(SM_CXSMICON), ARect.Top, ARect.Right, ARect.Bottom), ASelected);
end;

procedure TAboutProperty.Edit;
begin
  ShowMessage(‘TMsgBox — Delphi VCL component’#13#10 +

                          ‘Created
and used as an exaple’#13#10 +

                          ‘in
the Tutorial of designing components’#13#10 +

                          ‘©
Andrew Breslav, St.Petersburg, Russia, y. 2000’);
end;

procedure TAboutProperty.ListDrawValue(const Value:
string; ACanvas: TCanvas;
                                                                    const
ARect: TRect; ASelected: Boolean);
var
  Bmp: TBitMap;
begin
  ACanvas.Brush.Color:= $0033FFFF;
  ACanvas.FillRect(ARect);
  Bmp:= TBitmap.Create;
  Bmp.LoadFromResourceName(hInstance, ‘About’);
  ACanvas.Draw((ARect.Right — 110) div 2,0,Bmp);
  Bmp.Free;
end;

function TAboutProperty.GetValue: string;

begin
  Result:= TMsgBox(GetComponent(0)).About;
end;

procedure TAboutProperty.GetValues(Proc: TGetStrProc);
begin
  Proc(‘‘);
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  {…}
  RegisterPropertyEditor(TypeInfo(String), TMsgBox, ‘About’,
TAboutProperty);
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  {…} 
  RegisterPropertyInCategory(TCopyrightCategory, TMsgBox, ‘About this
component…’);
  {…}
  RegisterPropertyEditor(TypeInfo(String), TMsgBox, ‘About’,
TAboutProperty);
end;

TMBHWndProperty = class(TIntegerProperty)
  function GetAttributes: TPropertyAttributes; override;
  procedure ListDrawValue(const Value: string;
ACanvas: TCanvas;
                                            const
ARect: TRect; ASelected: Boolean); override;
  procedure ListMeasureWidth(const Value: string;
ACanvas: TCanvas;

                                                 var
AWidth: Integer); override;
  procedure ListMeasureHeight(const Value: string;
ACanvas: TCanvas;

                                                  var
AHeight: Integer); override;
  procedure PropDrawValue(ACanvas: TCanvas; const ARect:
TRect;
                                              ASelected:
Boolean); override;
  function GetValue: String; override;
  procedure SetValue(const Value: String);
override;
  procedure GetValues(Proc: TGetStrProc); override;
end;

function TMBHWndProperty.GetAttributes:
TPropertyAttributes;
begin
  Result:= [paValueList, paReadOnly, paMultiSelect, paRevertable];
end;

procedure TMBHWndProperty.GetValues(Proc: TGetStrProc);
begin
  Proc(‘Application’);
  Proc(‘Desktop’);
  Proc(‘NULL’);
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  {…}
  RegisterPropertyEditor(TypeInfo(HWND), TMsgBox, ‘hWnd’, TMBHWndProperty);
end;

type
  TRT = (idOK, idCancel, idAbort, idRetry, idIgnore, idYes, idNo, idClose, idHelp);

TMBTRProperty = class(TSetProperty)
  function GetValue: String; override;
  procedure GetProperties(Proc: TGetPropEditProc); override;
end;

function TMBTRProperty.GetValue: String;

var
  S: TIntegerSet;
  TpInfo: PTypeInfo;
  I: Integer;
begin
  Integer(S):= GetOrdValue;
  TpInfo:= TypeInfo(TRT);
  Result := ‘[‘;
  for I := 0 to SizeOf(Integer) * 8 — 1 do
    if I in S then
      begin
        if Length(Result) <> 1 then
Result := Result + ‘,’;
        Result := Result + GetEnumName(TpInfo, I — 1);
      end;
  Result := Result + ‘]’;
end;

procedure TMBTRProperty.GetProperties(Proc:
TGetPropEditProc);
var
  I: Integer;
begin
  with GetTypeData(GetTypeData(GetPropType)^.CompType^)^ do
    for I := MinValue to MaxValue do
      Proc(TMBTResProperty.Create(Self, I));
end;

procedure Register;
begin
  RegisterComponents(‘Custom’, [TMsgBox]);
  {…}
  RegisterPropertyEditor(TypeInfo(TMBTRes), TMsgBox, ‘TrueResults’,
TMBTRProperty);
end;

Поле Ancestor type должно содержать базовый тип для создаваемого компонента. Базовый тип компонента можно задать непосредственным вводом имени типа или выбором из раскрывающегося списка. Для разрабатываемого компонента базовым компонентом является стандартный компонент Edit (поле ввода-редактирования). Поэтому базовым типом для типа разрабатываемого компонента является тип TEdit.

В поле Class Name необходимо ввести имя класса разрабатываемого компонента, например THkedit. Вспомните, что в Delphiимена типов должны начинаться буквой т. В поле Palette Page нужно ввести имя вкладки палитры компонентов, на которую после создания компонента будет добавлен его значок. Название вкладки палитры компонентов можно выбрать из раскрывающегося списка.

Если в поле Palette Page ввести имя еще не существующей вкладки палитры компонентов, то непосредственно перед добавлением компонента вкладка с указанным именем будет создана.

В поле Unit file name находится автоматически сформированное имя файла модуля создаваемого компонента. Delphiприсваивает модулю компонента имя, которое совпадает с именем типа компонента, но без буквы т. Щелкнув на кнопке с тремя точками, можно выбрать каталог, в котором должен быть сохранен модуль компонента.

После нажатия кнопки ОК к текущему проекту добавляется сформированный Delphi-модуль, представляющий собой заготовку (шаблон) модуля компонента. Текст этого модуля приведен в листинге 16.1.

Листинг 16.1. Шаблон модуля компонента

В объявлении нового класса указан только тип родительского класса. В раздел реализации помещена процедура Register, которая используется во время установки созданного программистом компонента на указанную вкладку палитры компонентовDelphi для регистрации нового класса.

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

В листинге 16.2 приведен текст модуля компонента NkEdit после внесения всех необходимых изменений.

Листинг 16.2. Модуль компонента NkEdit

В описание класса TNkEdit добавлено объявление свойства Numb, которое представляет собой число, находящееся в поле редактирования. Для хранения значения свойства Numb используется поле FNumb. Функция GetNumb необходима для доступа к полю FNumb, а процедура setNumb — для установки значения свойства.

Конструктор класса TNkEdit сначала вызывает конструктор родительского класса (TEdit), присваивает значение свойству Text, затем устанавливает значение свойства Numb.

Реакция компонента NkEdit на нажатие клавиши клавиатуры определяется процедурой обработки события TNkEdit.KeyPress, которая замещает соответствующую процедуру базового класса. В качестве параметра процедура THkEdit-Keypress получает код нажатой клавиши. Перед вызовом процедуры обработки события onkeypress родительского класса код нажатой клавиши проверяется на допустимость. Если нажата недопустимая для компонента NkEdit клавиша, то код символа заменяется на ноль. Допустимыми для компонента Nkedit являются цифровые клавиши, разделитель целой и дробной частей числа (в зависимости от настройки Windows: точка или запятая), «минус», (позволяет удалить ошибочно введенный символ) и .

Здесь следует вспомнить, что в тексте программы дробная часть числовой константы отделяется от целой части точкой. Во время работы программы при вводе исходных данных пользователь должен использовать тот символ, который задан в настройке Windows. В качестве разделителя обычно применяют запятую (это для России стандартная настройка) или точку. Приведенная процедура обработки события onkeypress учитывает, что настройка Windows может меняться, и поэтому введенный пользователем символ сравнивается не с константой, а со значением глобальной переменной Decimaiseparator, которая содержит с и мв о л-разделитель, используемый в Windows в данный момент.

После ввода текста модуля компонента модуль нужно откомпилировать и сохранить.

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

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

Создается тестовое приложение обычным образом: сначала создается форма приложения, а затем — модуль приложения.

Вид формы приложения тестирования компонента NkEdit приведен на рис. 16.2.

Рис. 16.2. Форма приложения Тест компонента NkEdit

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

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

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

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

3. Для формы приложения создать процедуру обработки события OnCreate, которая вызовом конструктора тестируемогокомпонента создаст компонент и установит значения его свойств.

В листинге 16.3 приведен модуль приложения тестирования компонента NkEdit.

Листинг 16.3. Тест компонента NkEdit

Тестируемый компонент создается процедурой обработки события FormCreate (Создание формы) посредством вызова конструктора компонента, которому в качестве параметра передается значение self, показывающее, что владельцемкомпонента является форма приложения.

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

На рис. 16.3 приведено окно программы Тест компонента NkEdit во время ее работы, после ввода числа в поле редактирования и щелчка на кнопке Тест.

Рис. 16.3. Тестирование компонента. Поле ввода— компонент NkEdit

Для того чтобы значок компонента появился в палитре компонентов, компонент должен быть добавлен в один из пакетов (Packages) компонентов Delphi. Пакет компонентов — это файл с расширением dpk (Delphi Package File). Например, компоненты, созданные программистом, находятся в пакете DclusrVO.dpk.

Во время добавления компонента в пакет Delphi использует модуль компонента и файл ресурсов компонента, в котором должен находиться битовый образ значка компонента. Имя файла ресурсов компонента должно обязательно совпадать с именем файла модуля компонента. Файл ресурсов имеет расширение dcr (Dynamic Component Resource). Битовый образ, находящийся внутри файла ресурсов, должен иметь имя, совпадающее с именем класса компонента.

Файл ресурсов компонента можно создать при помощи утилиты Image Editor, которая запускается выбором из меню Tools команды Image Editor. Для того чтобы создать новый файл ресурса компонента, нужно из меню File выбрать команду New и из появившегося списка выбрать тип создаваемого файла — Component Resource File (рис. 16.4).

Рис. 16.4. Выбор типа создаваемого файла

В результате открывается окно файла ресурсов Unfitted I.dcr, а в меню диалогового окна Image Editor появляется новый пункт — Resource. Теперь нужно из меню Resource выбрать команду New/Bitmap и в открывшемся окне Bitmap Properties (рис. 16.5) установить характеристики битового образа значка компонента: Size — 24×24 пиксела, Colors — 16.

Рис. 16.5. Диалоговое окно Bitmap Properties

В результате этих действий в создаваемый файл ресурсов компонента будет добавлен новый ресурс -— битовый образ с именем Bitmap 1. Двойной щелчок на имени ресурса (Bitmap 1) раскрывает окно редактора битового образа, в котором можно нарисовать нужную картинку.

Изображение в окне графического редактора можно увеличить. Для этого необходимо выбрать команду Zoom In меню View. Следует обратить внимание, что нвет правой нижней точки рисунка определяет «прозрачный» цвет. Элементы значкакомпонента, закрашенные этим цветом, на палитре компонентов Delphi не видны.

Перед тем, как сохранить файл ресурсов компонента, битовому образу надо присвоить имя. Имя должно совпадать с именем класса компонента. Чтобы задать имя битового образа, необходимо щелкнуть правой кнопкой мыши на имени битового образа (Bitmapl), выбрать в появившемся контекстном меню команду Rename и ввести новое имя.

Созданный файл ресурсов компонента нужно сохранить в том каталоге, в котором находится файл модуля компонента. Для этого надо из меню File выбрать команду Save.

На рис. 16.6 приведен вид окна Image Editor, в левой части которого содержится файл ресурсов компонента TNkEdit (nkedit.dcr), а в правой части окно редактора битового образа, в котором находится изображение значка для создаваемого компонента.

Внимание!: Имя файла ресурсов компонента (NkEdit.dcr) должно совпадать с именем модуля компонента (NkEdit. pas), а имя битового образа (TNkEdit) — с именем класса компонента (TkNEdit).

Рис. 16.6. Значок компонента NkEdit

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

Рис. 16.7. Диалоговое окно Install Component

В поле Unit file name нужно ввести имя файла модуля. Для этого удобно воспользоваться кнопкой Browse. Поле Search path (Путь поиска) должно содержать разделенные точкой с запятой имена каталогов, в которых Delphi во время установкикомпонента будет искать необходимые файлы, в частности файл ресурсов компонента. Если имя файла модуля было введено в поле Unit file name выбором файла из списка, полученного при помощи кнопки Browse, то Delphi автоматически добавляет в поле Search path имена необходимых каталогов.

Примечание: Файл ресурса компонента должен находиться в одном из каталогов, перечисленных в поле Search path. Если его там нет, то компоненту будет назначен значок его родительского класса.

Поле Package file name должно содержать имя пакета, в который будет установлен компонент. По умолчанию компоненты, создаваемые программистом, добавляются в пакет Dclu.sr70.dpk.

Поле Package description содержит название пакета. Для пакета DclusrTO.dpk ЭТО Текст: Borland User’s Components. 

После заполнения перечисленных полей и нажатия кнопки ОК начинается процесс установки. Сначала на экране появляется окно Confirm (рис. 16.8), в котором Delphi просит подтвердить обновление пакета.

 Рис. 16.8. Запрос подтверждений обновления пакета в процессе установки компонента

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

Рис. 16.9. Сообщение об успешной установке компонента 

После установки компонента в пакет открывается диалоговое окно Package (Редактор пакета компонентов) (рис. 16.10), в котором перечислены компоненты, находящиеся в пакете.

Рис. 16.10. Окно редактора пакета компонентов 

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

Это не очередная копия той самой статьи (сколько ей уже лет?), которая была написана еще под Borland Delphi. Ниже поэтапно описан опыт разработки своего компонента на реальном примере с более глубоким пояснением параметров компонента для Design Time. Возможно, у кого-то есть решения и получше, однако, это мой первый компонент и я очень рад, что разобрался.

Этап 1. Постановка задачи

Так как я часто использую различный диалоговые окна в своих программах, то первым же своим компонентом я решил сделать панельку с кнопками «Ок» и «Отмена«. Соответственно, мне понадобиться создавать новый компонент на основе класса TPanel и внутри него создать две кнопки (класса TButton).

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

Итак, параметры для TPanel:

Этап 2. Создание компонента

Далее — придерживаемся какое-то время той самой инструкции.

Этап 3. Добавление кнопок в конструктор

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

В разделе public запишем такой код:

constructor Create(AOwner: TComponent); override;

С его помощью мы перезапишем уже существующий метод из «предка».

Также, подготовим класс к созданию кнопок, добавив в uses модуль Vcl.StdCtrls, а в класс в раздел protected две переменных:

Теперь описываем работу конструктора:

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

Если скомпилировать, а затем установить наш пакет (Package) уже сейчас, то мы можем увидеть именно то, что было показано на картинке выше. Однако, работа только началась, я ведь хотел сделать еще и включение и выключение видимости каждой кнопки.

Этап 4. Переменные для переключения видимости

Так я начинал делать, стараясь понять, как делать правильно.

В раздел private добавим две переменные:

В них будет хранится информация о том, видима ли там или иная кнопка или нет. Так как эти переменные запривачены, то объявим свойства, которые будут с ними работать. А еще лучше — если работать свойства будут с функциями и процедурами, а не напрямую с переменными. Напишем так:

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

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

Как известно, чтобы добавить эти свойства, достаточно лишь записать их в раздел published.

Например, добавим такое:

property ButtonOkIsVisible:boolean read getOk write setOk default True;

Тогда они будут отображены таким образом:

Но так может сделать кто угодно и мне это кажется не очень красивым решением. Хотя, оно довольно наглядно и вы можете сразу проверить работу метода setOk, поменяв значение свойства ButtonOkIsVisible и проверив значение Visible у кнопки «Ok».

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

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

А чтобы это реализовать, мне пришлось внимательно читать исходники уже имеющихся компонентов, для примера взяв уже существующую группу Anchors. Как оказалось, эта группа записана во все компоненты как обычное свойство (смотрите сами в Vcl.StdCtrls), а корни идут гораздо глубже, аж в System.UITypes!

Что представляют из себя элементы группы Anchors? Всего лишь четыре константы в Vcl.Controls:

которые занесены в список (в модуле System.UITypes), а оттуда — в множество:

Именно последнее мы и видим в качестве группы свойств в панели Object Inspector.

Этап 6. Создание группы свойств

Пособиепонаписаниюсвоихкомпонентовна Delphi дляначинающих

Почемуяселписатьэтопособие

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

Все мои готовые компоненты можно найти на сайте https://delphid.dax 

Длячегонужныкомпоненты

Дельфи имеет открытую архитектуру — это значит, что каждый программист волен усовершенствовать эту среду разработки, как он захочет. К стандартным наборам компонентов, которые поставляются вместе с Дельфи можно создать еще массу своих интересных компонентов, которые заметно упростят вам жизнь (это я вам гарантирую). А еще можно зайти на какой-нибудь крутой сайт о Дельфи и там скачать кучу крутых компонентов, и на их основе сделать какую-нибудь крутую прогу. Так же компоненты освобождают вас от написания «тысячи тонн словесной руды». Пример: вы создали компонент — кнопку, при щелчке на которую данные из Memo сохранятся во временный файл. Теперь как только вам понадобится эта функция вы просто ставите этот компонент на форму и наслаждаетесь результатом. И не надо будет каждый раз прописывать это, для ваших новых программ — просто воспользуйтесь компонентом.

Шаг 1. Придумываниеидеи

Первым шагом нужно ответить себе на вопрос: «Для чего мне этот компонент и что он будет делать?». Затем необходимо в общих чертах продумать его свойства, события, на которые он будет реагировать и те функции и процедуры, которыми компонент должен обладать. Затем очень важно выбрать «предка» компонента, то есть наследником какого класса он будет являться. Тут есть два пути. Либо в качестве наследника взять уже готовый компонент (то есть модифицировать уже существующий класс), либо создать новый класс.

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

1. Создание Windows-элемента управления (TWinControl)

2. Создание графического элемента управления (TGraphicControl)

3. Создание нового класса или элемента управления (TCustomControl)

4. Создание невизуального компонента (не видимого) (TComponent)

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

Невизуальные компоненты видны только во время разработки приложения (Design-Time), а во время работы приложения (Run-Time) их не видно, но они могут выполнять какую-нибудь работу. Наиболее часто используемый невизуальный компонент — это Timer.

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

Шаг 2. Созданиепустогомодулякомпонента

Рассматривать этот шаг я буду исходя из устройства Дельфи 3, в других версиях этот процесс не сильно отличается. Давайте попробуем создать кнопку, у которой будет доступна информация о количестве кликов по ней.

Чтобы приступить к непосредственному написанию компонента, вам необходимо сделать следующее:

Шаг 3. Начинаемразбиратьсявовсехдирективах

Что же здесь написано? да собственно пока ничего интересного. Здесь объявлен новый класс TCountBtn и процедура регистрации вашего компонента в палитре компонентов.

Директива Private Здесь вы будете писать все скрытые поля которые вам понадобятся для создания компонента. Так же в этой директиве описываются процедуры и функции, необходимые для работы своего компонента, эти процедуры и функции пользователю не доступны. Для нашего компонент мы напишем туда следующее (запись должна состоять из буквы «F» имени поля: тип этого поля):

Буква «F» должна присутсвовать обязательно. Здесь мы создали скрытое поле Count, в котором и будет храниться число кликов по кнопке.

Директива Protected. Обычно я здесь пишу различные обработчики событий мыши и клавиатуры. Мы напишем здесь следующую строку:

Это указывает на то, что мы будем обрабатывать щелчок мыши по компоненту. Слово «override» указывает на то, что мы перекроем стандартное событие OnClick для компонента предка.

В директиве Public описываются те процедуры и функции компонента, которые будут доступны пользователю. (Например, в процессе написания кода вы пишите имя компонента, ставите точку и перед вами список доступных функций, объявленных в диретиве Public). Для нашего компонента, чтобы показать принцип использования этой директивы создадим функцию — ShowCount, которая покажет сообщение, уведомляя пользователя сколько раз он уже нажал на кнопку. Для этого в директиве Public напишем такой код:

Осталась последняя директива Published. В ней также используется объявления доступных пользователю, свойств и методов компонента. Для того, чтобы наш компонент появился на форме необходимо описать метод создания компонента (конструктор), можно прописать и деструктор, но это не обязательно. Следует обратить внимание на то, что если вы хотите, чтобы какие-то свойства вашего компонента появились в Инспекторе Объектов (Object Inspector) вам необходимо описать эти свойства в директиве Published. Это делается так: property Имя_свойства (но помните здесь букву «F» уже не нужно писать), затем ставиться двоеточие «:» тип свойства, read процедура для чтения значения, write функция для записи значения;. Но похоже это все сильно запутано. Посмотрите, что нужно написать для нашего компонента и все поймете:

Итак все объявления сделаны и мы можем приступить к написанию непосредственно всех объявленных процедур.

Шаг 4. Пишемпроцедурыифункции.

Начнем с написания конструктора. Это делается примерно так:

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

Теперь мы напишем процедуру обработки щелчка мышкой по кнопке:

«Inherited click» означает, что мы повторяем стандартные методы обработки щелчка мышью (зачем напрягаться и делать лишнюю работу:)).

У нас осталась последняя процедура ShowCount. Она может выглядеть примерно так:

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

И если вы все поняли и сделали правильно, то у вас должно получится следующее:

Скорее сохраняйтесь, дабы не потерять случайным образом байты набранного кода:)).

Шаг 5. Устанавливаемкомпонент

Если вы сумели написать и понять, все то что здесь предложено, то установка компонента не должна вызвать у вас никаких проблем. Все здесь делается очень просто. В главном меню выберите пункт Component -> Install Component. перед вами открылось диалоговое окно Install Component. В нем вы увидите две закладки: Into exsisting Package и Into new Package. Вам предоставляется выбор установить ваш компонент в уже существующий пакет или в новый пакет соответственно. Мы выберем в уже существующий пакет.

В поле Unit File Name напишите имя вашего сохранненого модуля (естественно необходимо еще и указать путь к нему), а лучше воспользуйтесь кнопкой Browse и выберите ваш файл в открывшемся окне.

В Search Path ничего изменять не нужно, Делфьи сама за вас все туда добавит.

В поле Package File Name выберите имя пакета, в который будет установлен ваш компонент. Мы согласимся с предложенным по умолчанию пакетом.

Теперь нажимаем кнопочку Ok. И тут появиться предупреждение Package dclusr30.dpk will be rebuilt. Continue? Дельфи спрашивает: «Пакет такой-то будет изменен. Продолжить?». Конечно же надо ответить «Да». И если вы все сделали правильно, то появиться сообщение, что ваш компонент установлен. Что ж можно кричать Ура! Это ваш первый компонент.

Созданиесвойствсвоеготипа

Теперь мы попробуем создать свойство нестандартного типа. Рассмотрим это на примере метки — TLabel. У этого компонента есть такое свойство: Alignment. Оно может принимать следующие значения: taLeftJustify, taCenter, taRightJustify. Приступаем к созданию свойства. Ничего интересного мне придумать не удалось, но тем не менее я вам покажу это на примере того свойства, которое я придумал. Оно очень простое и поможет вам разобраться. Свойство будет называться ShowType (тип TShowTp), в нашем компоненте оно будет отвечать за отображение свойства Count. Если пользователь установит свойство ShowType в Normal, то кнопка будет работать, как и работала. А если пользователь присвоит этому свойтсву значение CountToCaption, то количество кликов, будет отображаться на самой кнопке.

Для начале нам необходимо объявить новый тип. Описание типа нужно добавить после слова Type. Вот так это выглядело вначале:

Воттакэтодолжновыглядеть:

Здесь мы объявили новый тип TShowTp, который может принимать только два значения. Все значения, которые вы хотите добавить перечисляются через запятую. Теперь нам понадобиться создать поле этого типа. Это мы уже умеем и делать и поэтому не должно вызвать никаких сложностей. В директиву Private напишите:

Мы создали поле ShowType, типа TShowTp.

Конечно же необходимо добавить это свойство в инспектор объектов:

property ShowType: TshowTp read FshowType write FShowType;

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

Объясню что произошло. Вначале мы увеличиваем счетчик на единицу. Затем проверяем какое значение имеет свойство ShowType. Если Normal, то ничего не делаем, а если CountToCaption, то в надпись на кнопке выводим количество кликов. Не так уж и сложно как это могло показаться с первого раза.

Имплантируемтаймервкомпонент

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

После раздела uses, где описаны добавленные в программу модули, объявите переменную типа TTimer. Назовем ее Timer. Приведу небольшой участок кода:

Дальше в директиву Protected необходимо добавить обработчик события OnTimer для нашего таймера. Это делается так:

procedure OnTimer(Sender: TObject);

Поскольку наш таймер это не переменная, а компонент, его тоже надо создать, для этого в конструктор нашей кнопки напишем:

Здесь создается экземпляр нашего таймера и его свойству Iterval (измеряется в миллисекундах) присваивается значение 10000 (то есть 10 секунд если по простому).

Собственно осталось написать саму процедуру OnTimer. Я сделал это так:

Если у вас что-то не сработало, то в начале проверьте все ли у вас написано правильно. Затем проверьте может у вас не хватает какого-нибудь модуля в разделе Uses.

Переустановкакомпонента

Очень часто бывает необходимо переустановить ваш компонент. Если вы попробуете сделать это путем выбора Component->Install Component, то Дельфи вас честно предупредит о том, что пакет уже содержит модуль с таким именем. Перед вами открывается окно с содержимым пакета. В нем вы должны найти имя вашего компонента и удалить его (либо нажать кнопочку Remove). Теперь в пакете уже нет вашего компонента. Затем проделайте стандартную процедуру по установке компонента.

Редактированиезначения, котороеввелпользователь, изменяякакое—нибудьсвойство.

Простой пример. Допустим у нас есть компонент (основанный на Tedit), у него есть два свойства: FirstNumber и SecondNumber. И у него есть процедура Division, в которой первое число делится на второе и результат присаивается свойству текст нашего компонента. Вот код этого компонента:

Хочется обратить ваше внимание на то, что в компонентах нельзя использовать переменные и поля типа Real, вместо него нужно брать переменные типов Single, Double, Extended.

Здесь все просто. Но вот если пользователю вздумается поделить на ноль (ну вдруг он математики не знает), то компонент выдаст ошибку DivisionByZero, а кому они нужны. Обойти эту проблему можно так: в код компонента добавить процедуру, которая проанализирует данные введенные пользователь и если все будет в порядке, то она присвоит значения соответствующим свойтсвам. В директиве Private объявите такую процедуру:

Обычно такие процедуры начинаются с приставки Set, затем идет имя свойства, и в конце тип переменной. Теперь в директиве Published надо сделать небольшие изменения:

А теперь напишем саму процедуру:

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

Использованиедругогокомпонентаввашем

Попробуем создать такой компонент. Это будет обычная метка (Label), у которой будет две процедуры: ChangeBackColor и ChangeFontColor, которые соответственно будут менять цвет фона метки и цвет текста. Для этого нам понадобиться ColorDialog, который будет создаваться вместе с компонентом, а потом с помощью процедур он будет активироваться. Назовем компонент ColorLabel. Вначале добавим в uses два модуля: Dialogs, StdCtrls (в них находятся описания классаов диалога и метки). Теперь нам надо объявить переменную типа TColorDialog. Объявление идет сразу после секции Uses.

Примерно это выглядит так:

Теперь в конструкторе (Create), нам надо создать этот компонент:

Теперь надо объявить процедуры ChangeBackColor, ChangeFontColor. Чтобы они были доступны пользователю их надо поместить в директиву Public:

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

Доступксвойствамдругогокомпонента

Сейчас нам предстоит более сложная задача. Мы будем создавать компонент, вместе с которым будет создаваться какой-нибудь визуальный компонент. Например создадим кнопку, которая будет сопровождаться поясняющей надписью сверху. За основу возмем тип TButton. Нам надо будет создать еще и Label. Здесь существует одна проблемка: при перемещении компонента по форме, метка должна двигаться вместе с кнопкой, поэтому нам придется обрабатывать сообщение WmMove. Итак, объявляем переменную Label (в данном примере она объявлена в директиве Private, что тоже допустимо):

Теперь я приведу весь код этого компонента и походу буду вставлять необходимые пояснения:

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

Использованиевкачествепредкакласс TWinControl

Предыдущий пример был очень сложным, к тому же пришлось обрабатывать системные сообщения. Есть другое решение этой проблемы, более простое для понимания и для реализации: использовать в качестве контейнера класс TWinControl и в этот контейнер помещать другие компоненты. Теперь попробуем совместить Edit и Label. Давайте вместе создадим такой компонент. В качестве предка нужно выбрать класс TWinControl, а в качестве типа вашего компонента выберите TlabelEdit. Будем разбирать код по кусочкам.

Попробуйте установить этот компонент. Когда вы будете размещать его на форме, то будет виден «контейнер», на котором располагаются Edit и Label. Использование в качестве предка компонента класса TWinControl, очень удобно если вы хотите объединить несколько визуальных компонентов.

Обработкасобытий OnMouseDown, OnMouseMove и OnMouseUp

Часто возникает необходимость обработки событий нажатия и отпускания кнопки в вашем компоненте. Сейчас мы это и рассмотрим. Только ради примера сделаем компонент, который будет считать количество нажатий и отпусканий кнопки в его области, допустим это будет панель (Tpanel). Для этого в директиве Private надо объявить следующие процедуры и поля:

А в директиве Published надо написать:

Ну и теперь осталось описать нужные процедуры:

Таким образом весь код компонента был таким:

Созданиеииспользованиесвоейиконкидлякомпонента

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

Откройте Image Editor (Tools->Image Editor) и выберите File->New->Component Resourse File. Перед вами появится небольшое окно с надписью Untitled.dcr в нем будет только одно слово: Contents. Нажмите на него правой кнопкой и в появившемся меню выберите New->Bitmap. Откроется диалоговое окно для настройки параметров изображения. Они должны быть такими: Размер 32×32, цветовой режим VGA (16 colors). Теперь нажмите ok. Теперь надо нажать правой кнопкой на появившейся надписи Bitmap1 и выбрать пункт Rename. Название картинки должно совпадать с названием класса компонента, для которого вы делаете эту иконку (например, TMPanel). Нажмите два раза на Bitmap1 и перед вами появится окно для рисования. Нарисуйте, что вам надо и перейдите на окно с надписью Untitled.dcr и в меню File выберите Save. Имя файла ресурса компонента должно совпадать с именем модуля компонента (без расширения конечно же, например, Mpanel). Файл ресурса готов. Теперь установите ваш компонент заново и в палитре компонентов ваш компонент будет уже с новой иконкой.

Источник: https://delphid.dax