Extender funcionalidad evento

[kamuspik]

Hola, revisando un poco de bibliografía he conseguido dar con lo que me interesaba. Lo pongo a continuación por si le sirve a alguien.

Código Delphi [-]
type
  TMiDataSource = class(TDataSource)
  private

    procedure MiDataSourceOnDataChange (Sender: TObject; Field: TField);
  protected

  public
    constructor Create(AOwner : TComponent); override;
    destructor Destroy; override;
  published
  end;

procedure Register;

implementation


procedure Register;
begin
  RegisterComponents('Componentes', [TMiDataSource]);
end;

constructor TMiDataSource.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);

  Self.OnDataChange := TMiDataSourceOnDataChange;  //instrucción necesaria para redefinir el evento OnDataChange

end;

destructor TMiDataSource.Destroy;
begin

  inherited destroy;
end;


procedure TMiDataSource.MiDataSourceOnDataChange (Sender: TObject; Field: TField);
begin
    ShowMessage('¡Entro aquí!');

    ....... //Codigo que extiende el comportamiento del evento

    inherited;  //instrucción que mantiene el comportamiento original

end;

end.

Un saludo.

[[maeyanes]]

Hola...

Y si a ese componente le asignas un método en su evento OnDataChange, ¿este sigue comportándose como deseas? Has la prueba y verás que no.

Para redefinir el comportamiento de un evento, primero debes identificar cual es el método que dispara ese evento, mayormente en la VCL estos métodos se pueden redefinir, pero parece que para la clase TDataSource el método que llama al evento es privado (DataEvent).

Dicho lo anterior, tu componente debe quedar de la siguiente forma para que funcione:

Código Delphi [-]
type
  TMiDataSource = class(TDataSource)
  private
    // Campo para guardar el manejador de evento definido en tiempo de diseño...
    FOldDataChangeEvent: TDataChangeEvent;

    procedure DoOnDataChange (Sender: TObject; Field: TField);
  protected
    procedure Loaded; override;
  end;

implementation

procedure TMiDataSource.DoOnDataChange(Sender: TObject; Field: TField);
begin
  // Llamamos el manejador de eventos asignado en tiempo de diseño...
  if Assigned(FOldDataChangeEvent) then
    FOldDataChangeEvent(Sender, Field);
  // Aquí pones tu código...
end;

procedure TMiDataSource.Loaded;
begin
  inherited;
  // Si estamos en tiempo de ejecución, sustituimos el manejador de evento de OnDataChange con el nuestro...
  if not csDesigning in ComponentState then
  begin
    FOldDataChangeEvent := OnDataChangeEvent;
    OnDataChangeEvent := DoOnDataChange
  end
end;

Toma en cuenta que este código lo hago al vuelo, así que podría fallar. También ten en cuenta que si se cambia el manejador de evento de OnDataChange en tiempo de ejecución, el comportamiento de este código ya no será el deseado.



Saludos...

[kamuspik]

Hola!
Gracias por tu respuesta, pensé que había resuelto el problema...de hecho el código parecía funcionar como quería. Voy a probar esto que has dicho y luego comento los resultados.

Un saludo

[kamuspik]

Hola maeyanes,
he probado tu código y funciona correctamente. Lo único que no consigo entender la diferencia entre lo que hacía yo y tu código.
A ver si me puedes ayudar a entenderlo, yo directamente asigno el procedimiento que quiero que se ejecute al evento y después hago un inherited.¿Por qué no se comporta como deseo?
En tu código guardas una copia del manejador de eventos y después la llamas antes de ejecutar el procedimiento ¿esto es para mantener el funcionamiento natural del evento no?¿Qué diferencia hay entre los dos comportamientos?

Muchas gracias por tu tiempo,

Un saludo.

[[maeyanes]]

Hola...

La única diferencia entre tu código y el mio, es que si se asigna un manejador de evento en tiempo de diseño, tú código ya no va a funcionar como lo tienes pensado, esto es por que al asignar el nuevo manejador de evento este sustituye al que tu asignaste por código en el constructor.

El código que yo te proporcioné prevee este caso y asigna el manejador de evento interno después de "cargar" el component desde el DFM, guardando en un campo la referencia al posible manejador de evento asignado en tiempo de diseño. Luego, al dispararse el evento, el manejador interno llama primero (y puedes hacerlo también al final, depende de lo que desees hacer) al manejador asignado en tiempo de diseño (si es que se asigno uno) y luego ejecuta el código de lo que deseas implementar.

Espero que con esta pequeña explicación te quede más claro.


Saludos...

[kamuspik]

Muchas gracias, ahora ya lo comprendo, el código que había puesto antes se comportaba de forma excluyente y mi intención era que se mantuviera la posibilidad de asignar un manejador de eventos en tiempo de diseño.

Un saludo