Newsgroup: it.comp.lang.delphi
Titolo: Override di Eventi

Nella creazione dei componenti si ha la necessità di dover eseguire
l'override del  medoto  di un evento. Quand quest'ultimo è almeno protected
e virtual non ci sono problemi. I problemi vengono quando del suddetto
medoto non si ha la possibiltà di farne un override.
Io ho fatto cosi. Secondo voi è giusto?
per esempio devo aggiungere delle istruzioni nell'evento key press. NOn
potendo farne l'override (almeno credo, se  è possibile prendetelo come
esempio) faccio in questo modo.
Nel loaded del componente controllo se è stato scritto un evento key press.
In caso affermativo lo salvo creando una variabile punatatore a quel metodo
e reimposto OnKeyPRess con la mia procedura, che richiamerà l'evento poi
salvato.
Private
  FMyKeyPressEvent:TKeyPressEvent;/// salvo l'eventuale onkeypress event
scirtto
  procedure MyKeyPressEvent(Sender: TObject; var Key: Char);/// il mio
evento key press
published
....
procedure MyComponent.Loaded;
Begin
   ///Controllo se è stato scritto l'evento
    if Assigned(OnKeyPress) then
     ///se è Stato assegnato lo salvo assegnadolo ad una variabile puntatore
a quel tipo di evento
      FMyKeyPressEvent := OnKeyPress;
  ///Imposto il mio evento
  OnKeyPressEvent:= MyKeyPressEvent;
end;
  procedure MyComponet.MyKeyPressEvent(Sender: TObject; var Key: Char);
begin
      /// Se era stato definito un evento
      if Assigned(FMyKeyPressEvent ) then
         ///eseguo l'evento prima di tuto quest'ultimo
        FMyKeyPressEvent(Sender,Key) ;
       Mie Istruzioni
end;
Se non è corretto. mI potete suggerire un altro modo?
Grazie Marco.

 suddetto medoto non si ha la possibiltà di farne un override.
[...]
dovre bastare la ridichiarazione del metodo,
richiamando il metodo ereditato (se si vuole)
procedure TOggetto.Metodo(par);
begin
 inherited Metodo(par); // richiama metodo della classe ereditata
 // fai quello che vuoi
end;
Ciao,
Alan Solo

 wrote in message
8uc8mh$11s1s$1...@ID-44131.news.dfncis.de...


esempio) faccio in questo modo.
...
Un paio di cose: se a runtime viene creato il componente o cambiato il
gestore di evento che accade? 
Se non ho capito male si puo' ottenere _una specie_ di override
mascherando OnKeyPress del componente da cui erediti (v. sotto). 
Non so pero' cosa succeda se a runtime si assegna un gestore all'evento
di una istanza castata al tipo base (TEdit(MyTempEdit1).OnKeyPress :=
TForm1.Handler ????); probabilmente occorre aggiunger Setter/Getter del
campo evento.
Saluti
Paolo Arosio
ps. sui ng di Cantu' e' richiesto firmarsi con Nome Cognome completi
// -----------------------------
  TMyTempEdit = class(TEdit)
    private
      FOnKeyPress: TKeyPressEvent;
    protected
      procedure DoKeyPress(Sender: TObject; var Key: Char);
    public
      constructor Create(AOwner: TComponent); override;
      property OnKeyPress: TKeyPressEvent 
		read FOnKeyPress write FOnKeyPress;
  end;
(* dove OnKeyPress maschera l'evento di TEdit *)
{ TMyTempEdit }
constructor TMyTempEdit.Create(AOwner: TComponent);
begin
  inherited;
  inherited OnKeyPress := DoKeyPress;	// assegna gestore interno
end;
// Event handler di TEdit.OnKeyPress
procedure TMyTempEdit.DoKeyPress(Sender: TObject; var Key: Char);
begin
  // NB: il gestore della derivata puo' cambiare Key 
  //     quindi eseguo prima il mio codice
  Beep;	  // le mie istruzioni
  // chiama gestore della classe derivata
  if Assigned(FOnKeyPress) then	  
    FOnKeyPress(Sender, Key);	  
end;

   inherited OnKeyPress := DoKeyPress; // assegna gestore interno
non eredito il codice che era stato scritto ma brutalmente imposto il mio.
(inq uesto casoil nuovo doKeyPress);
Nei componenti standard esiste un metodo chiamato KeyPress che viene
chiamato prima di eseguire un probabile ONKEYPRESS
in effetti per utilizzarlo e aggiungere nuovo codice basta farne un
override, in questo modo viene eseguito sia il vecchio che il nuovo
evento.
Il mio problema è che non esiste o non è stato pubblicato un
"CAlcTitleImage" che possa essere ereditato e sul quale si possa compiere un
override
per poter aggiungere il mio codice.
Cosa mi suggerisci/suggerite?

non eredito il codice che era stato scritto ma brutalmente imposto il mio.
OnKeyPress non e' un metodo, e' un evento TOnKeyPressEvent (di fatto: un
puntatore a un metodo). Gli eventi sono li' apposta per attaccare il
proprio codice.
Di fatto il componente che ti ho postato fa Beep e poi esegue il codice
dell'utente, dopo aver fatto quello che fa normalmente un TEdit quando
gli schiacciano un tasto sopra (cioe' i tasti li prende).
Saluti
Paolo Arosio

| Non ho provato ma comunque penso che non si possa fare.  Per eseguire un
| inerithed bisogna che l'evento sia almeno public, protected e cosa piu
| importate virtual. Hai mai provato?
si', ma per sicurezza:
program Project1;
uses Dialogs;
type
  TOgg1 = class
    procedure Metodo;
  end;
  TOgg2 = class(TOgg1)
    procedure Metodo;
  end;
  procedure TOgg1.Metodo;
  begin
   ShowMessage('azioni fatte dalla classe madre');
  end;
  procedure TOgg2.Metodo;
  begin
   inherited Metodo;
   ShowMessage('azioni nuove');
  end;
begin
 with TOgg2.Create do begin
  Metodo;
  Free;
 end;
end.
Ciao,
Alan Solo

end.
attenzione:
procedure X(o: TOgg1);
begin
    o.Metodo;
end;
richiamera' sempre TOgg1.Metodo anche se passi un
TOgg2.