TListBox.Items.Add overloaden

[iphi]

Hallo,

ich möchte mir eine Variante von TListBox kreieren (z.B. TLogListBox), bei der die Methode Items.Add durch meine eigene Variante überladen wird.
Darin möchte ich z.B. jedes hinzugefügte Item auch in eine Log-Datei schreiben.

Ich habe sowas (abgeleitetes Objekt mit geänderter Methode) noch nie gemacht.
Kann mir jemand bitte Starthilfe geben?

Oder gibt es eine einfachere Möglichkeit?

Danke.

P.S.

Soweit bin ich:

Delphi-Quellcode:

unit ULogListBox;

interface

uses
  Windows, Messages, SysUtils, Classes, StdCtrls;

type
  TLogStrings = class(TStrings)
  public
    function Add(const S: string): Integer; virtual;
  end;


type
  TLogListBox = class(TListBox)
  private
    _logfile: string;
  published
    property LogFile: String read _logfile write _logfile;
  end;

procedure Register;

implementation


function TLogStrings.Add(const S: string): Integer;
begin
  Result := GetCount;
  Insert(Result, S);
  writeln(s);
end;


procedure Register;
begin
  RegisterComponents('Samples', [TLogListBox]);
end;

end.

Wie verheirate ich die modifizierten TStrings mit TLogListBox?

[himitsu]

Erstmal ist dein Vererbung falsch.
TStrings ist nur der öffentliche Typ, aber Intern ist es ein TListBoxStrings.

Delphi-Quellcode:

type
  TLogStrings = class(TListBoxStrings)
  public
    function Add(const S: string): Integer; virtual;
  end;

Und genauso, wie beim TMemo/TMemoStrings, bist du hier total am Arsch, denn du kannst das nicht ableiten, weil jemand auf die saudämliche Idee kam und diesen Typen nur im Implementation der Vcl.StdCtrls (Delphi 7 ohne Vcl.) deklariert hat, wo du nicht ran kommst.


In der LitBox gibt es irgendwo das TListBoxStrings.Create für diese TStrings. (hier direkt im Contructor)
Da müsstest du schauen, ob es virtuel ist und du dort stattdessen deine Klasse erstellen kannst.


Aber mach es dir doch einfach.
Und löse dein Probleme mir einem Class-Helper.

Delphi-Quellcode:

type
  TLogStrings = class helper for TStrings
  public
    function Add(const S: string): Integer;
  end;

Da in der TListBox öffentlich TStrings definiert ist und kein "eigener" Typ, hängt dieser Helper zwar nun "überall", an allen TStrings (sobald deine Unit mit dem Helper im Uses steht), aber wenn dich das nicht stört, dann ist es die einfache Lösung.
Natürlich kannst den Helper auch nur lokal in diese eine Unit, in Interface oder Implementation deklarieren und nur dort an allen TStrings benutzen.

[edit]
Mit Delphi 7 bist du geliefert, da hast du keine Möglichkeit. (die Class-Helper gibt es dort noch nicht)
Tipp: Community-Edition?

[Delphi.Narium]

Wieso ist das so kompliziert?

Delphi-Quellcode:

unit LogListBox;

interface

uses
  SysUtils, Classes, Controls, StdCtrls, Dialogs;

type
  TLogListBox = class(TListBox)
  private
    { Private-Deklarationen }
    fLogFileName : String;
  protected
    { Protected-Deklarationen }
    procedure WriteLn(Item : String);
  public
    { Public-Deklarationen }
    function  Add(Item: string): Integer;
    procedure AddItem(Item: String; AObject: TObject); override;
  published
    { Published-Deklarationen }
    property LogFileName : String read fLogFileName write fLogFileName;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Samples', [TLogListBox]);
end;

procedure TLogListBox.WriteLn(Item : String);
begin
  // Hier kommt die Implementierung für das Schreiben in die Datei fLogFileName hin.
  ShowMessage(Item);
end;


procedure TLogListBox.AddItem(Item: String; AObject: TObject);
begin
  inherited AddItem(Item, AObject);
  WriteLn(Item);
end;

function TLogListBox.Add(Item: String) : Integer;
begin
  AddItem(Item, nil);
  Result := Items.Count;
end;

end.

Mit meinem Delphi 7 funktioniert das.

Aufrufmöglichkeiten:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
  LogListBox1.AddItem('** AddItem **',nil);
  LogListBox1.Add('** Add **');
end;

[iphi]

Danke für die Tipps!
Gute Idee, AddItem zu überladen, geht gut!

[KodeZwerg]

Ich bin der Meinung das man auch mit älteren Delphis "Intercepten" kann.
Bei Interesse einfach mal hier danach suchen.
So würde ich vorgehen.
Ohne Probleme neue Felder mit aufnehmen (Dateiverwaltung...), vorhandene Felder "inheriten" und abändern etc (save...)
Letzten Endes braucht man nur die "uses" am Ende um eine Unit erweitern, und je nach genutzen Feld ("fUseNew" als boolean in intercepted class zBsp) wird neue oder originale Variante genutzt.