Delphi-Komponentenentwicklung - Ereignisse in der Komponente weitergeben

Question

Ich versuche eine neue TEdit-Komponente zu entwickeln.

TDBFilterEdit = class(TEdit) 

Die Komponente soll ein zugeordnetes DataSet basierend auf der Zeichenfolge filtern, die in seinem Bearbeitungsfeld eingegeben wird.

das ist, was meine Komponente wie folgt aussieht: I Jetzt

type 
TDBFilterEdit = class(TEdit) 
    private 
    { Private-Deklarationen } 
    fFilter:String; 
    fDataSource:TDataSource; 
    fDataSet:TDataSet; 
    fText:string; 
    protected 
    { Protected-Deklarationen } 
    procedure SetFilter(value:String); 
    procedure SetDS(value:TDataSource); 
    procedure FilterRecords(DataSet:TDataSet; var Accept:Boolean); 
    procedure Change(Sender:TObject); 
    procedure SetText(value:String); 
    public 
    { Public-Deklarationen } 
    constructor Create(AOwner:TComponent); 
    published 
    { Published-Deklarationen } 
    property Text:String read fText write SetText; 
    property Filter:String read fFilter write SetFilter; 
    property DataSource:TDataSource read fDataSource write SetDS; 
    end; 

, ziemlich Anfänger bin, wenn es um Komponenten-Entwicklung kommt. Meine erste Idee war, die OnFilterRecord-Methode des Datasets zu überschreiben, sobald die DataSource meiner Komponente zugewiesen wird und diese ausgelöst wird, wenn sich der Text meiner Edit-Komponente ändert.

procedure TDBFilterEdit.SetDS(value:TDataSource); 
var 
    myaccept:Boolean; 
begin 
    fDataSource:=value; 
    fDataSet:=fDataSource.DataSet; 
    if fDataSet=nil then Exit; 

    fDataSet.OnFilterRecord:=FilterRecords; 
    if Filter<>'' then fDataSet.OnFilterRecord(fDataSet,myaccept); 
end; 

Mein Problem ist, ich weiß nicht, wie man die Komponente darauf aufmerksam macht, dass ihre Text-Eigenschaft aktualisiert wurde. Ich habe versucht, die OnChange-Methode mit folgendem Code

procedure TDBFilterEdit.Change(Sender:TObject); 
begin 
    Filter:=Text; 
    inherited Change(); 
end; 

jedoch bisher ohne Erfolg zu übersteuern.

Answer 1

Mein Problem ist, ich weiß nicht, wie Sie die Komponente darauf aufmerksam machen, dass ihre Text-Eigenschaft aktualisiert wurde.

Die -Eigenschaft wird von TControl übernommen. Wenn sich der Eigenschaftswert ändert, gibt TControl eine Benachrichtigungsnachricht an CM_TEXTCHANGED aus. Abgeleitete Klassen können diese Nachricht entweder handhaben:

1. mit einem message Handler:

   type 
       TDBFilterEdit = class(TEdit) 
       ... 
       procedure CMTextChanged(var Message: TMessage); message CM_TEXTCHANGED; 
       ... 
       published 
       ... 
       // DO NOT redeclare the Text property here! 
       // It is already published by TEdit... 
       end; 
   
   procedure TDBFilterEdit.CMTextChanged(var Message: TMessage); 
   begin 
       inherited; 
       // use new Text value as needed... 
       Filter := Text; 
   end; 
   

2. die virtuelle WndProc() Methode überschrieben.

   type 
       TDBFilterEdit = class(TEdit) 
       ... 
       protected 
       ... 
       procedure WndProc(var Message: TMessage); override; 
       ... 
       end; 
   
   procedure TDBFilterEdit.WndProc(var Message: TMessage); 
   begin 
       inherited; 
       if Message.Msg = CM_TEXTCHANGED then 
       begin 
       // use new Text value as needed... 
       Filter := Text; 
       end; 
   end; 
   

Wie für den Rest Ihrer Komponente, sollte es so aussehen:

type 
    TDBFilterEdit = class(TEdit) 
    private 
    { Private-Deklarationen } 
    fDataSource: TDataSource; 
    fDataSet: TDataSet; 
    fFilter: String; 
    procedure FilterRecords(DataSet: TDataSet; var Accept: Boolean); 
    procedure SetDataSource(Value: TDataSource); 
    procedure SetDataSet(Value: TDataSet); 
    procedure SetFilter(const Value: String); 
    procedure StateChanged(Sender: TObject); 
    procedure UpdateDataSetFilter; 
    protected 
    { Protected-Deklarationen } 
    procedure Notification(AComponent: TComponent; Operation: TOperation); override; 
    procedure WndProc(var Message: TMessage); override; 
    public 
    { Public-Deklarationen } 
    destructor Destroy; override; 
    published 
    { Published-Deklarationen } 
    property DataSource: TDataSource read fDataSource write SetDataSource; 
    property Filter: String read fFilter write SetFilter; 
    end; 

... 

destructor TDBFilterEdit.Destroy; 
begin 
    SetDataSource(nil); 
    inherited; 
end; 

procedure TDBFilterEdit.FilterRecords(DataSet: TDataSet; var Accept: Boolean); 
begin 
    // ... 
end; 

procedure TDBFilterEdit.Notification(AComponent: TComponent; Operation: TOperation); 
begin 
    inherited Notification(AComponent, Operation); 
    if Operation = opRemove then 
    begin 
    if AComponent = fDataSource then 
    begin 
     SetDataSet(nil); 
     fDataSource := nil; 
    end 
    else if AComponent = fDataSet then 
    begin 
     fDataSet := nil; 
    end; 
    end; 
end; 

procedure TDBFilterEdit.SetFilter(const Value: String); 
begin 
    if fFilter <> Value then 
    begin 
    fFilter := Value; 
    UpdateDataSetFilter; 
    end; 
end; 

procedure TDBFilterEdit.SetDataSource(Value: TDataSource); 
begin 
    if fDataSource <> Value then 
    begin 
    SetDataSet(nil); 

    if fDataSource <> nil then 
    begin 
     fDataSource.RemoveFreeNotification(Self); 
     fDataSource.OnStateChange := nil; 
    end; 

    fDataSource := Value;  

    if fDataSource <> nil then 
    begin 
     fDataSource.FreeNotification(Self); 
     fDataSource.OnStateChange := StateChanged; 
     SetDataSet(fDataSource.DataSet); 
    end; 
    end; 
end; 

procedure TDBFilterEdit.SetDataSet(Value: TDataSet); 
begin 
    if fDataSet <> Value then 
    begin 
    if fDataSet <> nil then 
    begin 
     fDataSet.RemoveFreeNotification(Self); 
     fDataSet.OnFilterRecord := nil; 
    end; 

    fDataSet := Value; 

    if fDataSet <> nil then 
    begin 
     fDataSet.FreeNotification(Self); 
     fDataSet.OnFilterRecord := FilterRecords; 
     UpdateDataSetFilter; 
    end; 
    end; 
end; 

procedure TDBFilterEdit.StateChanged(Sender: TObject); 
begin 
    if fDataSource.DataSet <> fDataSet then 
    SetDataSet(fDataSource.DataSet); 
end; 

procedure TDBFilterEdit.UpdateDataSetFilter; 
begin 
    if fDataSet <> nil then 
    begin 
    fDataSet.Filter := fFilter; 
    fDataSet.Filtered := fFilter <> ''; 
    end; 
end; 

procedure TDBFilterEdit.WndProc(var Message: TMessage); 
begin 
    inherited; 
    if Message.Msg = CM_TEXTCHANGED then 
    Filter := Text; 
end; 

---

UPDATE: sorry, mein schlecht. Die CM_TEXTCHANGED Nachricht wird nur gesendet, wenn die Eigenschaft programmgesteuert in Code aktualisiert wird. Zu erkennen, wenn der Benutzer den Text geändert wird, müssen Sie die Win32 EN_CHANGE Benachrichtigung behandeln statt:

1. eine message Handler:

   type 
       TDBFilterEdit = class(TEdit) 
       ... 
       procedure CMTextChanged(var Message: TMessage); message CM_TEXTCHANGED; 
       procedure CNCommand(var Message: TWMCommand); message CN_COMMAND; 
       ... 
       published 
       ... 
       // DO NOT redeclare the Text property here! 
       // It is already published by TEdit... 
       end; 
   
   procedure TDBFilterEdit.CMTextChanged(var Message: TMessage); 
   begin 
       inherited; 
       // use new Text value as needed... 
       Filter := Text; 
   end; 
   
   procedure TDBFilterEdit.CNCommand(var Message: TWMCommand); 
   begin 
       inherited; 
       if Message.NotifyCode = EN_CHANGE then 
       begin 
       // use new Text value as needed... 
       Filter := Text; 
       end; 
   end; 
   

2. die virtuelle WndProc() Methode überschrieben.

   type 
       TDBFilterEdit = class(TEdit) 
       ... 
       protected 
       ... 
       procedure WndProc(var Message: TMessage); override; 
       ... 
       end; 
   
   procedure TDBFilterEdit.WndProc(var Message: TMessage); 
   begin 
       inherited; 
       case Message.Msg of 
       CM_TEXTCHANGED: begin 
        // use new Text value as needed... 
        Filter := Text; 
       end; 
       CN_COMMAND: begin 
        if TWMCommand(Message).NotifyCode = EN_CHANGE then 
        begin 
        // use new Text value as needed... 
        Filter := Text; 
        end; 
       end; 
       end; 
   end; 
   

In der Tat behandelt TCustomEdit bereits EN_CHANGE für Sie, und wird seine virtuelle Change() Methode aufrufen (seine OnChange Ereignis ausgelöst), die Sie überschreiben können:

type 
     TDBFilterEdit = class(TEdit) 
     ... 
     protected 
     ... 
     procedure Change; override; 
     ... 
     end; 

    procedure TDBFilterEdit.Change; 
    begin 
     inherited; 
     // use new Text value as needed... 
     Filter := Text; 
    end;