Delphi: How to assign dynamically an event handler without overwriting the existing event handler

delphievent handling

I need to loop through Components and assign an event handler (for example Dynamically assigning OnClick event for all TButton to

ShowMessage('You clicked on ' + (Sender as TButton).Name);

The problem is that in some cases I already assigned the TButton OnClick event.

Is there a way to solve the problem?

Let's imagine I have Button1 for which the harcoded onclick event handler is:

ShowMessage('This is Button1');

After my "parsing" I would like that the full event handler for Button1 becomes:

ShowMessage('This is Button1'); // design time event handler code
ShowMessage('You clicked on ' + (Sender as TButton).Name); // runtime added

Note: I am looking for a soliution that allows me to use TButton as it is without inheriting from it.

Best Answer

you could look for an assignment of OnClick before overwriting it, persist this and use it in your new handler - basically chaining the events.

Something like this:

  var original : TNotifyEvent;

  original := Component.OnClick;
  Component.OnClick := NewMethod;

and then in your NewMethod:

  if assigned(original) then original(Sender);

you'll likely not want a single original variable but instead hold a collection keyed on the component.

Related Solutions

C# dynamically add event handler

try:

 /* HERE IS WERE I NEED HELP */

 item.Click += new EventHandler(toolStripClick);

actual handler:

void toolStripClick(object sender, EventArgs e)
{
     ToolStripItem item = (ToolStripItem)sender;
     MessageBox.Show(item.Text);
}

Delphi – How to dynamically inject code into event handlers in Delphi

You can use the following scheme to rewire the datasets:

type
  TDataSetEventWrapper = class
  private
    FDataSet: TDataSet;
    FOrgAfterOpen: TDataSetNotifyEvent;
    FOrgBeforeOpen: TDataSetNotifyEvent;
    procedure MyAfterOpen(DataSet: TDataSet);
    procedure MyBeforeOpen(DataSet: TDataSet);
  protected
    property DataSet: TDataSet read FDataSet;
  public
    constructor Create(ADataSet: TDataSet);
    destructor Destroy; override;
  end;

constructor TDataSetEventWrapper.Create(ADataSet: TDataSet);
begin
  Assert(ADataSet <> nil);
  inherited Create;
  FDataSet := ADataSet;
  FOrgAfterOpen := FDataSet.AfterOpen;
  FOrgBeforeOpen := FDataSet.BeforeOpen;
  FDataSet.AfterOpen := MyAfterOpen;
  FDataSet.BeforeOpen := MyBeforeOpen;
end;

destructor TDataSetEventWrapper.Destroy;
begin
  FDataSet.AfterOpen := FOrgAfterOpen;
  FDataSet.BeforeOpen := FOrgBeforeOpen;
  inherited;
end;

procedure TDataSetEventWrapper.MyBeforeOpen(DataSet: TDataSet);
begin
  if Assigned(FOrgBeforeOpen) then
    FOrgBeforeOpen(DataSet);
end;

procedure TDataSetEventWrapper.MyAfterOpen(DataSet: TDataSet);
begin
  if Assigned(FOrgAfterOpen) then
    FOrgAfterOpen(DataSet);
end;

Inside MyAfterOpen and MyBeforeOpen you can bring in your code before, after or around the call to the original event handler.

Collect the wrapper objects in a TObjectList with OwnsObjects := true and everything will revert to the original when you clear or free the objectlist.

Caution: For this code to work the events have to be wired already when you create the wrappers and manually reassigning those events is forbidden.

Best Answer

Related Solutions

C# dynamically add event handler

Delphi – How to dynamically inject code into event handlers in Delphi

Related Topic