Wykład XVII

Object Pascal – Tworzenie

komponentów

Łatwość tworzenia nowych
komponentów i ich adaptacji jest
jednym z największych atutów Delphi.

Podstawy informatyki
Semestr II Transport

Kiedy tworzenie nowego

komponentu jest

uzasadnione ?

jeżeli zastosowanie tworzonego komponentu nie

ograniczy się do jednej aplikacji to praca włożona w jego

tworzenie zwraca się wielokrotnie
stworzenie nowych komponentów może przyczynić się do

bardziej przejrzystego i przyjaznego dla użytkownika

sposobu aplikacji, gdyż logiczny podział jej funkcji (z

punktu widzenia użytkownika) znajdzie odzwierciedlenie

w strukturze użytych komponentów
dla nietypowych zastosowań, gdy brak w środowisku

odpowiednich komponentów – stworzenie ich staje się

warunkiem koniecznym dla stworzenia aplikacji
sprzedaż uniwersalnych komponentów innym

projektantom aplikacji
może stanowić wyzwanie dla projektanta, być

sprawdzianem jego umiejętności

Etapy tworzenia nowego

komponentu

Szczegółowe określenie funkcji komponentu
Zaprojektowanie algorytmu działania komponentu
Sprecyzowanie oraz hierarchiczne i chronologiczne
uporządkowanie poszczególnych czynności
projektowych
Tworzenie komponentu (kodowanie) – powinno
odzwierciedlać logikę komponentu
Testowanie komponentu w ramach projektów
testowych
Zainstalowanie komponentu na palecie
komponentów

Programowe etapy tworzenia

komponentów

Wybór klasy bazowej
Stworzenie modułu źródłowego komponentu
Uzupełnienie definicji dziedziczonych z klasy
bazowej o charakterystyczne dla nowego
właściwości, metody i zdarzenia
Testowanie komponentu
Rejestracja komponentu w środowisku
programistycznym
Stworzenie plików pomocy opisującego
działanie i sposób korzystania z komponentu

Wybór klasy bazowej

Właściwy wybór klasy bazowej ma

decydujący wpływ na postać finalnego

komponentu i wymagany do jego powstania

nakład pracy.
Należy starać się dobrać klasę bazową tak,

by w jak największym stopniu wykorzystać

istniejące właściwości i metody.
Nie ma gotowej recepty na właściwy wybór

jest od wynikiem wiedzy, umiejętności i

doświadczenia programisty, czasem może

być nawet polem eksperymentów.

Tworzenie modułu

źródłowego

Nieodłącznym elementem każdego komponentu jest jego definicja w

kodzie źródłowym, domyślnie każdemu komponentowi odpowiada

oddzielny moduł źródłowy (unit). Definiowanie nowego komponentu

rozpoczyna się od wybrania opcji File|New|Component –

wyświetlenia eksperta komponentów. Umożliwia on wybór klasy

bazowej, określenie nazwy tworzonej klasy i jego modułu źródłowego,

wybór strony na palecie komponentów na której komponent zostanie

umieszczony. W rezultacie powstanie jedynie szkielet modułu

zawierający definicję klasy i procedurę rejestracyjną.

Delph

i 4

Delph

i 2

Definiowanie właściwości

prostych

TPrzykladowaKlasa=class(TCustomControl)

private
FIntegerProp: Interer;
FStringProp: String;
FCharProp: Char;
published
property IntererProp read FIntegerProp write

FIntegerProp;
property StringProp read FStringProp write

FStringProp;
property CharProp read FCharProp write FCharProp;

end;

Właściwości reprezentują liczby, wartości lub znaki

Definiowanie właściwości

wyliczeniowych

TPoryRoku=(prWiosna,prLato,prJesien,prZima);

TPrzykladowaKlasa=class(TCustomControl)
private

{pola wewnętrzne}

FPoryRoku: TPoryRoku;

FBooleanProp: Boolean;

published

{właściwości wyliczeniowe}

property PoryRoku read FPoryRoku write FPoryRoku;

property BooleanProp read FBooleanProp write

FBooleanProp;
end;
Wymaga zwykle uprzedniego zdefiniowania typu

wyliczeniowego, edycja w Object Inspectorze

pozwala wybierać wartość właściwości z listy

Definiowanie właściwości zbiorowych

TDni=(Poniedziałek,Wtorek,Środa,Czwartek,Piątek,Sobota,Nie

dziela);
TSetDni=Set of TDni;

TPrzykladowaKlasa=class(TCustomControl)
private

{pola wewnętrzne}

FDyzury: TSetDni;

published

{właściwości wyliczeniowe}

property Dyzury read FDyzury write FDyzury;
end;

Należy zdefiniować bazowy typ wyliczeniowy i oparty na nim

typ zbiorowy, a następnie można zdefiniować odpowiednią

właściwość zbiorową.

Definiowanie właściwości

obiektowych

Nic nie stoi na przeszkodzie,
by właściwością klasy, była
sama klasą lub komponentem.
Za przykład można podać
właściwość Font.

Definicja obiektu, który ma być właściwością innej
klasy powinna (bezpośrednio lub pośrednio)
wywodzić się z klasy TPersistent. Kreowanie
egzemplarza obiektu zawierającego właściwości
obiektowe musi tworzyć obiekt związany z
właściwością obiektową.Podobnie należy
postępować podczas niszczenia obiektu – należy
niszczyć obiekty podrzędne przed zniszczeniem
obiektu nadrzędnego. Konieczne jest zatem
przedefiniowanie konstruktora i destruktora.

Przykładowy obiekt

podrzędny

TJakisObiekt=class(TPersistent)

private
FProp1: Integer;
FProp2: String;
published
property Prop1: Integer read FProp1 write
FProp1;
property Prop2: String read FProp2 write
FProp2;
end;

Przykład definiowania

właściwości obiektowych

TObiektNadrzedny=class(TCustomControl)
private
FJakisObiekt: TJakisObiekt;
procedure SetJakisObiekt(Value: TJakisObiekt);
public
constructor Create(AOwner: TComponent);override;
destructor Destroy;override;
published
property JakisObiekt: TJakisObiekt read FJakisObiekt

write SetJakisObiekt;

end;

Tworzenie obiektów

wewnętrznych

obiekt podrzędny tworzymy w konstruktorze
po utworzeniu obiektu rodzica

constructor TObiektNadrzedny.Create(AOwner:

TComponent);

begin
inherited Create(Aowner);
FJakisObiekt:=TJakisObiekt.Create;
end;

Zwalnianie obiektów

wewnętrznych

obiekt dziecko niszczymy przed zwolnieniem
obiektu nadrzędnego w destruktorze

destructor TObiektNadrzedny.Destroy;
begin
FJakisObiekt.Destroy;
inherited Destroy;
end;

Przypisanie wartości

własności obiektowej

Należy sprawdzić czy przypisany jest jakiś
egzemplarz obiektu. Jeśli tak należy go zwolnić i
dopiero wówczas przypisać nową wartość
właściwości obiektowej

procedure TObiektNadrzedny.SetJakisObiekt(Value:

TJakisObiekt);

begin
if Assigned(FJakisObiekt) then FJakisObiekt.Free;
if Assigned(Value) then FJakisObiekt.Assign(Value)
end;

Redefinicja metody

Assign

Należy tu powiedzieć, że należałoby przedefiniować

metodę Assign obiektu dziecka tak aby obsługiwała

nowe właściwości obiektu

procedure TJakisObiekt.Assign(Source: TPersistant);
begin

if Source is TJakisObiekt then
begin
FProp1:=TJakisObiekt(Source).Prop1;
FProp2:=TJakisObiekt(Source).Prop2;
inherited Assign(Source);
end;

end;

Definiowanie właściwości

tablicowych

Jeśli chcielibyśmy je umieścić w Object

Inspektorze to należy zdefiniować specjalny

edytor właściwości
Właściwość tablicowa musi posiadać jeden lub

więcej indeksów (mogą być one dowolnego

typu)
Klauzule read i write w definicji właściwości

muszą określać metody dostępowe – nie jest

dozwolone specyfikowanie pól
Liczba i kolejność indeksów w odwołaniu do

właściwości być zgodna z jej deklaracją

Przykład typu z

właściwościami

tablicowymi

TPlanety=class(TComponent)
private
function GetPlanetName(const AIndex: Integer): String;
function GetPlanetPosition(const APlanetName: String):

Integer;

public
property PlanetName[const AIndex: Integer]: String

read GetPlanetName; default;

property PlanetPosition[const APlanetName: String]:

Integer
read GetPlanetPosition;

end;

Właściwości tablicowe -

Metody dostępowe

-

Przykład

function TPlanety.GetPlanetName

(const AIndex: Integer): String;

begin
if (AIndex<=0) or (AIndex>9) then
raise Exception.Create(‘Niepoprawny

numer planety. ‘+
’Wprowadź liczbę od 1 do 9’)

else Result::=PlanetNames[AIndex];
end;

Właściwości tablicowe -

Metody dostępowe –

Przykład

cd.

function TPlanety.GetPlanet Position

(const APlanetName: String): Integer;

var I: Integer;
begin
Result:=0; i:=0;
repeat
inc(i);
until (i>9) or

(ANSICompareStr(ANSIUpperCase(APlanetName),

ANSIUpperCase(PlanetNames[i]))=0);

if i<=9 then Result:=i;
end;

Metody dostępowe -

zmiana wartości właściwości

TJakisObiekt=class(TComponent)
{...} FWlasnosc:Integer;
procedure SetWlasnosc(Value: Integer);
{...}
property Wlasnosc: Integer read FWlasnosc write

SetWlasnosc;

{...}
procedure TJakisObiekt.SetWlasnosc(Value: Integer);
begin {...}
Wlasnosc:=Value;

{tu nieskończona rekursja – błąd – winno być np.

FWlasnosc:=Value}

{...}

end;

Zdarzenia

Zdarzenie jest wynikiem oddziaływania użytkownika, ,
systemu operacyjnego, bądź samej aplikacji
Reakcją obiektu na wystąpienie zdarzenia jest
wywołanie związanej z nim procedury zdarzeniowej
(event handler);
Każdemu zdarzeniu, na które zdolny jest reagować
obiekt danej klasy, odpowiada określona właściwość
zdarzeniowa (event property). Zapewnia ona dostęp
do pola, będącego wskaźnikiem do określonej
procedury zdarzeniowej.

Definiowanie zdarzeń

TJakasKontrolka=class(TComponent);
private
FOnClick: TNotifyEvent;
protected
procedure Click; dynamic;
property OnClick: TNotifyEvent read FOnClick write

FOnClick;

end;

Procedury zdarzeniowe w zależności od zdarzenia mają

na ogół różny zestaw parametrów. Typ TNotifyEvent

jest zdefiniowany następująco:

TNotifyEvent=procedure(Sender: TObject) of object

Procedura zdarzeniowa

procedure TJakasKontorlka.Click;
begin
if Assigned(FOnClick) then

FOnClick(Self);

end;

procedura sprawdza czy z obsługą

zdarzenia powiązano jakąś procedurę

(Assigned) i jeśli tak wywołuje ją.

Definiowanie metod

Podczas dodawania i przedefiniowywania metod
komponentów posługujemy się schematem przyjętym
dla klas Object Pascala.
Staramy się unikać wzajemnych powiązań między
metodami (unikać wymogu stosowania metody w
towarzystwie innych metod lub co gorsza, w określonej
sekwencji).
Żadna metoda nie powinna wprowadzać obiektu w stan,
w którym pewne zdarzenia lub właściwości nie są
właściwie obsługiwane.
Należy nadawać metodom nazwy sugerujące
wykonywane przez nie akcje
Właściwie dobieramy stopień widoczności metody

Przedefiniowywanie

konstruktorów

wymaga użycia klauzuli override;

constructor Create(AOwner: TComponent);override;

regułą powinno być również wywołanie konstruktora

klasy macierzystej (bazowej). Przedefiniowywany

konstruktor w klasie pochodnej musi mieć taką samą

strukturę parametryczną jak konstruktor oryginalny.

Klasa może mieć jednak kilka konstruktorów.

constructor TMojKomp.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{...}
end;

Przedefiniowywanie

destruktorów

wymaga również użycia klauzuli override;

destructor Destroy; override;

wewnątrz destruktora wywołanie destruktora klasy

bazowej jest obowiązkowe i powinno być wykonane

jako czynność ostatnia, np.

destructor TMojKomp.Destroy;
begin
FTimer.Free;
MyString.Free;
inherited Destroy;
end;

Zachowanie się

komponentu na etapie

budowania aplikacji

Konstruktor Create(...) komponentu
wywoływany jest nie tylko w czasie wykonywania
programu, lecz również w momencie wstawiania
go do formularza na etapie budowy aplikacji.
Wynika stąd czasem konieczność rozróżnienia
tych dwu etapów. Rozróżnienie jest możliwe
dzięki właściwości zbiorowej ComponentState.
Poszczególne elementy i ich znaczenie
przedstawia tabela

Znaczenie flag właściwości

ComponentState

csAncesto
r

komponent został odziedziczony z formularza
nadrzędnego

csDesigni
ng

aplikacja znajduje się na etapie projektowania

csFixups

do komponentu istnieje odwołanie z formularza,
który nie jest aktualnie załadowany; po
załadowaniu wszystkich formularzy flaga jest

wyłączana

csLoading odczytywanie danych komponentu ze strumienia
csReading flaga jest ustawiana w momencie utworzenia

komponentu (w wyniku odczytu ze strumienia) i
kasowania wówczas, gdy dany komponent oraz
wszystkie komponenty, od których jest on
zależny, mają już ustalone parametry

csUpdatin
g

komponent jest uaktualniany ze względu na
zmianę definicji z formularzu nadrzędnym

csWriting

trwa zapis komponentu do strumienia

Rejestracja komponentu

Rejestracja komponentu jest czynnością, powodującą
umieszczenie go na Palecie komponentów. Wykonuje ją
procedura o nazwie RegisterComponents():

procedure RegisterComponents(const Page: string;

ComponentClasses: array of TComponentClass);
Pierwszy parametr oznacza nazwę palety komponentów
Drugi zawiera nazwy klas rejestrowanych komponentów
Powyższa procedura musi być wywołana w treści
procedury o nazwie Register, zadeklarowanej także w
części publicznej modułu

Przykład rejestrowania

komponentów

unit MojComp;
interface
type TMojKomp=class(TComponent)

{...} end;

TInnyKomp=class(Tcomponent) {...} end;

procedure Register;
implementation{...}
procedure Register;
begin
RegisterComponents(‘MojeKomponenty’,[TMojKomp,

TInnyKomp]);

end;
end.

Testowanie

komponentu

Najczęstszym sposobem testowania
komponentu jest stworzenie projektu w
ramach którego obiekt będzie dynamicznie
tworzony i zwalniany.
Projekt ten powinien również pozwalać na
sprawdzenie wszystkich funkcji komponentu.
Należy pamiętać, że dobrze wykonany
komponent powinien być gotowy do
normalnego funkcjonowania już po
wykonaniu konstruktora.

Wybór ikony

komponentu

Komponent nie będzie kompletny, dopóki nie

zostanie opatrzony ikoną identyfikującą go w

palecie komponentów. Do tworzenia ikon można

wykorzystać Image Editor lub dowolny inny

edytor obsługujący pliki BMP.
Ikona musi mieć rozmiary 24x24 i musi być

przechowywana w pliku o takiej samej nazwie jak

nazwa modułu z komponentem i znajdować się w

tym samym co komponent katalogu.
Format pliku jest pod względem struktury

powinien być zgodny z plikami zasobów Windows

(.RES) lecz powinien mieć rozszerzenie .DCR.