Fino ad ora abbiamo visto più o meno come utilizzare i molti componenti che sono
disponibili in Delphi. Ma cosa fare tra tutti questi componenti non troviamo quello che fa
al caso nostro? Semplice, possiamo crearcelo da soli oppure modificare le caratteristiche
di uno già esistente che assomiglia molto al componente che stiamo cercando. Questa non
è difficile costruire nuovi componenti o modificare quelli già esistenti, ma occorre
avere una discreta conoscenza dell'Object Pascal poichè la realizzazione di un
componente non prevede l'impiego di tool di sviluppo visuale (almeno direttamente forniti
con Delphi) e quindi è necessario scrivere tutto il codice a mano. Occorre altresì avere
una buona conoscenza dei componenti già esistenti e delle classi base messe a
disposizione da Delphi per evitare di riscrivere del codice o componenti già esistenti.
In questa sezione del corso vedremo prima di tutto come modificare un componente già
esistente e poi come costruire un semplicissimo componente "ex novo".
Quando si decide di realizzare un componente, è necessario analizzare attentamente i
componenti esistenti e tenere presente che non è possibile nascondere metodi o proprietà
di un componente. Per questo la scelta del componente (classe) da cui ereditare le
caratteristiche necessarie ha una grande importanza. Delphi come al solito, ci viene
incontro fornendoci delle classi base dei quasi tutti i componenti standard della VCL
(TEdit, TComboBox, ...).
Queste classi hanno nomi del tipo TCustomEdit, TCustomComboBox,
etc. Esse implementano tutte le funzionalità e proprietà dei componenti veri e propri ma
non le rendono visibili all'esterno. Le classi che implementano il componente vero e
proprio, non fanno altro che ereditare dalle classi base e rendere visibili all'esterno
tutti i metodi e proprietà della relativa classe base. Ciò permette di rendere visibili
solo alcuni dei metodi e proprietà che ci interessano.
Per creare un nuovo componente, possiamo seguire due strade: attraverso il menu
Component->New Component, oppure scrivendo da soli lo scheletro di base per il nostro
oggetto. Conviene comunque seguire la prima strada che risparmia, se non altro, il tempo
per la scrittura del codice. Cominciamo.
Apriamo la finestra di dialogo New Component come sopra descritto e digitiamo quanto
riportato nell'immagine seguente
Ancestor Type: indica la classe di base da cui far discendere il nostro nuovo
componente.
Class Name: è il nome che vogliamo dare alla nostra nuova classe; viene
automaticamente compilato quando si sceglie il tipo di classe da cui ereditare ma può
essere modificato a piacere. Il nome scelto per questo esempio è TMyEdit, ma nessuno
vieta di scegliere un altro nome. Occhio a non usare nomi di classi già esistenti!
Palette Page: è la pagina della Componente Palette di Delphi dove verrà posizionato
il componente quando andremo a registrarlo nell'IDE di Delphi. In questo esempio ho scelto
di posizionare il nuovo componente nella pagina Samples della component Palette, ma voi
potrete scegliere la pagina che preferite.
Unit File Name: è il nome, completo di percorso, che vogliamo dare alla unit che
conterrà il codice del nostro nuovo componente. In questa casella potete inserire il
percorso che preferite che sicuramente differirà da quello da me scelto.
Search Path: è l'elenco di percorsi all'interno dei quali Delphi ricercherà le unit
necessarie per il componente.
Completata questa fase, premiamo il tasto OK e vedremo che Delphi creerà una unit con
il nome da noi fornito contenente l'impalcatura della nostra nuova classe.
Ecco il codice che comparirà nell'Code Editor al termine dell'operazione
unit MyEdit;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics,
Controls, Forms, Dialogs, StdCtrls;
type
TMyEdit = class(TEdit)
private
{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
published
{ Published declarations }
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Samples', [TMyEdit]);
end;
{ TMyEdit }
end.
Come potete vedere, sono rintracciabili tutte le informazioni da noi fornite
all'interno della finestra di dialogo, ma non abbiamo dovuto scrivere una riga di codice!
Ora passiamo a modificare le impostazioni di default della classe TEdit. Vogliamo
impostare come colore di sfondo di default del componente TEdit il colore giallino
utilizzato nei ToolTips e impostare la sua lunghezza di default a 200 pixels. Bene,
procediamo con il fare l'override della procedura di creazione del componente. Aggiungiamo
nella sezione Public della dichiarazione della classe la ridichiarazione del costruttore
Create come segue
Constructor Create(AOwner : TComponent); override;
una volta scritto il codice sopra riportato, possiamo utilizzare la combinazione di
tasti Ctrl+Shift+C per dire a Delphi di completare il codice automaticamente. Questa
operazione porterà alla creazione del codice di implementazione del costruttore appena
definito nella forma seguente
constructor TMyEdit.Create(AOwner: TComponent);
begin
inherited;
end;
a questo punto possiamo aggiungere il codice necessario per personalizzare i nostri
valori di default; modifichiamo l'implementazione del costruttore come segue
constructor TMyEdit.Create(AOwner: TComponent);
begin
inherited;
width := 200;
Color := clInfoBk;
end;
Con queste righe di codice impostiamo a 200 pixels la lunghezza del controllo ed il
colore di sfondo al colore di sfondo correntemente attivo per i ToolTips.
La procedura Register serve a Delphi per registrare il componente in una pagina della
Components Palette; questa procedura chiama infattai la procedura RegistreComponents
passandogli come parametro il nome della pagina della Components Palette: se la pagina
esiste vi registra il componente altrimenti la crea e quindi vi registra il componente.
Questo è un semplicissimo esempio di come è possibile personalizzare alcune
caratteristiche di un componente già esistente. Si possono anche aggiungere funzionalità
ad un componente già esistente; per esempio, potremmo voler aggiungere al nostro
componente MyEdit una proprietà che contenga il testo digitato nel controllo con l'ordine
dei caratteri invertito. Vediamo come implementare questa caratteristica.
Aggiungiamo nella parte Private della nostra classe TMyEdit la funzione Reverse
dichiarandola come segue
Function Reverse : String;
ed implementandola come segue
function TMyEdit.Reverse: String;
Var I, L : Integer;
begin
L := Length(Text);
SetLength(Result, L);
For I := 1 to Length(Text) do
Result[(L+1) - I] := Text[I];
end;
Questa funzione legge la stringa contenuta nella proprietà Text del controllo
(ereditata dalla classe TEdit) e dispone i caratteri che la compongono in ordine inverso.
La proprietà Text contiene il testo digitato dall'utente. Ora occorre implementare una
proprietà che restituisca, in lettura, il testo invertito. Aggiungiamo nella parte di
dichiarazione Public della nostra classe TMyEdit la proprietà ReversedTxt nel seguente
modo:
Property ReversedTxt : String read GetreversedTxt;
Premendo Ctrl+C dopo aver digitato questa riga, otterremo il completamento automatico
della nostra proprietà con la creazione della funzione GetreversedTxt. Ecco come
apparirà la dichiarazione della nostra classe dopo queste modifiche
TMyEdit = class(TEdit)
private
{ Private declarations }
Function Reverse : String;
function GetreversedTxt: String;
protected
{ Protected declarations }
public
{ Public declarations }
Constructor Create(AOwner : TComponent); override;
Property ReversedTxt : String read GetreversedTxt;
published
{ Published declarations }
end;
Modifichiamo l'implementazione della funzione GetreversedTxt come segue
function TMyEdit.GetreversedTxt: String;
begin
Result := Reverse;
end;
Si può anche eliminare la funzione Reverse implementando il codice direttamente nella
funzione GetreversedTxt ma per questioni di chiarezza e modularità del software,
preferisco utilizzare questa struttura.
Per provare il nostro componente possiamo registrarlo in Delphi scegliendo dal menu
Component la voce "Install Component", il componente verrà installato nella
libreria dei componenti e la sua icona posta nella pagina della Components Palette da noi
scelta, oppure aggiungere la unit MyEdit nella clausola uses di una nuova form e creare il
componente a runtime come segue
procedure TForm1.FormCreate(Sender: TObject);
begin
MyEdit := TMyEdit.Create(Self);
MyEdit.Parent := Self; //
MyEdit.Top := 16; //Posizionamento del componente nella form
MyEdit.Left := 10; // " " " "
"
end;
e nell'evento OnDestroy della form aggiungiamo il seguente codice
procedure TForm1.FormDestroy(Sender: TObject);
begin
MyEdit.Free;
end;
per eliminare il componente da noi creato quando eliminiamo la form. Non dimenticatevi
di inserire una variabile MyEdit di tipo TMyEdit nella sezione Private della classe TForm1
...
private
{ Private declarations }
MyEdit : TMyEdit;
public
{ Public declarations }
end;
Potete scaricare il codice completo dell'esempio riportato per
vedere come funziona ed avere il codice a disposizione.
Per quanto riguarda la creazione di componenti, è molto difficile che si creino
componenti partendo completamente da zero, salvo in casi molto particolari.
Generalmente
si eredita dalla classe TComponent per i componenti non visibili e da TControl o da
TWinControl per i componenti visibili e da TGraphicControl per i componenti grafici.
Possiamo dire che queste sono le classi utili più "primitive" da cui iniziare a
creare nuovi componenti. La scrittura di codice per componenti richiede una discreta
conoscenza della programmazione ad oggetti in Object Pascal, delle classi da cui ereditare
e delle basi del sistema operativo, in questo caso Windows. Pertanto si rimanda alla
lettura dei manuali e alla lettura di testi specifici, come la serie Mastering Delphi di
Marco Cantù, in particolare "Delphi Developer's Handbook" e "Laboratorio
di Delphi" di Nando Dessena e Barbini, nonché frequentare i news group che trattano
di Delphi frequentati anche dai personaggi citati.