Newsgroup: it.comp.lang.delphi
Titolo: oggetto che punta a VCL

Ciao a tutti, vorrei sviluppare un oggetto (o componente non visuale) che, 
tra le altre cose, abbia una proprietà un po' particolare. Vorrei che questa 
proprietà si riferisca ad una MemoBox che io imposto nel codice e sui cui 
andranno a finire le stringhe di output dell'oggetto. In altri termini 
vorrei aprire una form mettere dentro una MemoBox, istanziare il mio 
oggetto, associare alla proprietà in questione il nome della Memo e fa 
stampare i risultati nella memo.
Il problema sta nel fatto che non so come riferirmi (nell'oggetto) alla 
memo. Come posso, dall'oggetto riferirmi ad un componente TMemo (avere un 
puntatore penso) che sarà nell'applicazione.
Spero di essere stato chiaro.
Grazie mille a tutti.
Giuseppe 

 puntatore penso) che sarà nell'applicazione.
Nella maggior parte dei casi, basterebbe dotare la tua classe di un 
campo appartenente al tipo di controllo cui ti vuoi riferire ed 
eventualmente aggiungere una proprietà corrispondente; qualcosa di 
simile a questo:
TSomeClass = class
private
   FMemo: TMemo;
public
   property Memo: TMemo read FMemo write FMemo;
end;
A livello essenziale, sarebbe sufficiente.
Tuttavia, io sono abituato ad aggiungere altri meccanismi di sicurezza, 
poichè spesso i componenti cui faccio riferimento vengono distrutti e, 
pertanto, la classe deve essere a conoscenza del fatto che il Memo è 
stato cancellato per poter aggiornare il riferimento interno.
I componenti supportano un meccanismo di notifica che permette loro di 
sapere quando un determinato componente cui sono collegati viene distrutto.
Trattandosi di una classe che deriva da TObject, non abbiamo a che fare 
con un componente e quindi non possiamo utilizzare questo meccanismo; 
tuttavia, nulla vieta di crearsi un componente adatto allo scopo.
Ti riporto la mia abituale implementazione:
   TFreeNotifyEvent = procedure(Sender: TObject;
    Component: TComponent) of object;
{ TFreeNotifyComponent }
   TFreeNotifyComponent = class(TComponent)
   private
     FOnFreeNotify: TFreeNotifyEvent;
   protected
     procedure Notification(AComponent: TComponent;
      Operation: TOperation); override;
   public
     property OnFreeNotify: TFreeNotifyEvent
      read FOnFreeNotify write FOnFreeNotify;
   end;
{ TSomeClass }
   TSomeClass = class
   private
     FMemo: TMemo;
     FNotifyComponent: TFreeNotifyComponent;
     procedure SetMemo(Value: TMemo);
     procedure DoingFreeNotify(Sender: TObject; Component: TComponent);
   protected
   public
     constructor Create;
     destructor Destroy; override;
     property Memo: TMemo read FMemo write FMemo;
   end;
La classe *TFreeNotifyComponent* è un componente che viene utilizzato 
solamente per sapere quando un altro componente viene distrutto; ne creo 
un'istanza in *TSomeClass*, che invece è la classe che fa riferimento al 
TMemo e sfrutta il TFreeNotifyComponent per sapere quando questo viene 
distrutto (se accade). La memorizzazione del riferimento avviene sempre 
tramite un campo FMemo, ma ho aggiunto nella proprietà un metodo di 
assegnazione SetMemo in cui aggiunto l'iscrizione alla ricezione di 
notifiche quando il Memo viene distrutto.
Qui di seguito, riporto il codice di entrambe le classi:
{ TFreeNotifyComponent }
procedure TFreeNotifyComponent.Notification(AComponent: TComponent;
   Operation: TOperation);
begin
   inherited Notification(AComponent, Operation);
   if Assigned(FOnFreeNotify) then
     FOnFreeNotify(Self, AComponent);
end;
{ TSomeClass }
constructor TSomeClass.Create;
begin
   inherited Create;
   FNotifyComponent := TFreeNotifyComponent.Create(nil);
   FNotifyComponent.OnFreeNotify := DoingFreeNotify;
end;
destructor TSomeClass.Destroy;
begin
   if FNotifyComponent <> nil then
     FreeAndNil(FNotifyComponent);
   inherited Destroy;
end;
procedure TSomeClass.DoingFreeNotify(Sender: TObject; Component: 
TComponent);
begin
   if Component = FMemo then
     FMemo := nil;
end;
procedure TSomeClass.SetMemo(Value: TMemo);
begin
   if Value <> FMemo then
   begin
     if FMemo <> nil then
       FMemo.RemoveFreeNotification(FNotifyComponent);
     FMemo := Value;
     if FMemo <> nil then
       FMemo.FreeNotification(FNotifyComponent);
   end;
end;
Se alcune cose appaiono oscure, prova a cercarle sulla Guida in Linea di 
Delphi.
Se hai bisogno di chiarimenti, scrivi di nuovo.
La classe che ti ho postato, così come è fatta, è comunque pronta a 
diventare un componente se in futuro incontrerai tale necessità.
Ciao! :-)
-- 
Marco «Alka» Breveglieri
  ABLS Team S.n.c. - Software & Web
  Via De Gasperi, 14
  42019 Scandiano (Reggio Emilia)
 
http://www.abls.it

Fantastico! Hai colto nel segno tutto quello che mi serviva.
Ti ringrazio ancora molto.
Giuseppe
"Marco Breveglieri" <ma...@NOSPAM-abls.it> ha scritto nel messaggio 
news:jv8ad.24154$B06....@news.edisontel.com...
