[Neue Fragen] Listbox und Klasse

[MacWomble]

Hallo,

bevor ich hier wieder ein seltsames Konstrukte erstelle, frage ich lieber nach.
Ich habe einige identisch aufgebaute TobjectList mit ID und Bezeichnung je Objekt. (Die Daten sind in einer DB gesichert)
Nun möchte ich in einer 'Form' die Bezeichnungen editieren, Erstellen und Löschen können.

Da es mehrere Listen aus verschiedenen Klassen, jedoch dem selben Aufbau sind, dachte ich das ganze nur ein mal zu erstellen.

Ich habe also eine Form mit einer TListbox, in welche die Daten (Bezeichnungen) eingelesen werden und einigen Buttons (Erstellen, Löschen, Bearbeiten, Fertig, Abbruch).
In der Listbox kann ich dann die gewünschten Funktionen auch ausführen. So weit ist auch alles klar.

Bei Verlassen der Form soll nun die ursprüngliche TObjectlist aktualisiert bzw. mit der Listbox synchronisiert werden.
Hierbei soll die ursprüngliche ID erhalten bleiben.

Beispiel (F ist die Form, Abteilungen die Objektliste mit den Daten aus der Datenbank, lbListe die Listbox):
Ich habe eine TObjektliste Abteilungen.

Code: Alles auswählen

 
    for i := 0 to Abteilungen.Count - 1 do
       F.lbListe.Items.AddObject(Abteilungen.Items[i].Bezeichnung, TObject(IntPtr(Abteilungen.Items[i].ID)));
    if F.ShowModal = mrOk then
    begin        ...
 

Meine Idee ist nun - da beide Listen sortiert sind - in einer verschachtelten Schleife Eintrag für Eintrag zu prüfen und ggf. die gewünschte Aktion auszuführen.

Eine zweite Möglichkeit wäre, die Objektliste an die Form zu übergeben (müsste ich Property machen) und direkt zu bearbeiten, aber wenn ich TObjektlist als Typ verwende, ist in der Form ja noch keine ID und Bezeichnung bekannt. (wie gesagt, ich habe viele solcher Objektlisten, weswegen ich eine universale Form zur Bearbeitung möchte)

Aber wie ich euch Spezialisten kenne, gibt es bestimmt noch eine elegantere Lösung?

[Warf]

Bin grad am Handy, kann also ned die ausführlichste Antwort geben, ich würd aber einfach ein Interface schreiben IDescribeable, worüber du ID und Beschreibung veröffebtlichst, welches du dann in allen Objekten benutzt, und du übergibst der Form dan eine Liste der interfaces, und lässt die vtable das dispatching handeln

Nach dem showmodal der edit Form returned hat, kannst du dann die geupdateten Infos wieder auslesen und in deine objectivist schreiben

Eine andere Option wäre das Delegator Muster, das du einen IDescriptionList delegator hast, der createNew, deleteItem, getItem und ItemCount bereitstellt, und die Form so indirekt auf die Liste zugreifen kann

[Warf]

Hab dir hier mal ein beispiel mit dem Delegator angehängt, konnte es aber nicht testen, da Lazarus auf meinem Mac nicht läuft (will einfach GUI Anwendungen nicht kompilieren).

[MacWomble]

Danke für die gute Anregung. Ich versuche das zu verstehen und in meinem Projekt umzusetzen.
So ganz habe ich es aber nicht hin bekommen. Das hängt aber irgendwie mit der Struktur zusammen.
Ich habe die Klassendefinition in cuabteilung, ein Datenmodul dmdaten, in welchem die Klasse created und befüllt wird und die Form mit der Listbox.
Letztere soll möglichst aus allen anderen Modulen des Projekts aufgerufen werden können. Hierzu habe ich in der cuabteilung eine Funktion (analog in den anderen Klassen)

Code: Alles auswählen

 
type
 
  { TAbteilung }
 
  TAbteilung = class(TObject)
  private
    fIsChanged: boolean;
    fID: integer;
 
    fBezeichnung: string;
  public
    procedure SetBezeichnung(const aValue: string);
 
    procedure CopyFrom(AValue: TAbteilung);
 
    property IsChanged: boolean read fIsChanged write fIsChanged default False;
    property ID: integer read fID write fID default -1;
 
    property Bezeichnung: string read fBezeichnung write SetBezeichnung;
  end;
 
  { TAbteilungsListe }
 
  TAbteilungsListe = class(TObjectList)
  private
    procedure ReadListData(Query: string);
 
    function GetItem(AIndex: integer): TAbteilung;
    procedure SetItem(AIndex: integer; const AValue: TAbteilung);
  public
    procedure ReadAll;
    procedure WriteListData;
    procedure DeleteByID(aID: integer);
 
    property Items[AIndex: integer]: TAbteilung read GetItem write SetItem; default;
 
    function Editdata: string;
 
  end;          
 
...
 
function TAbteilungsListe.Editdata: string;
var
  F: TSimpleListEditor;
  i: integer;
begin
  F := TSimpleListEditor.Create(nil);
  F.lblName.Caption:='Abteilungen';
  try
    for i := 0 to Self.Count - 1 do
       F.lbListe.Items.AddObject(Self.Items[i].Bezeichnung, TObject(IntPtr(Self.Items[i].ID)));
    if F.ShowModal = mrOk then
    begin
      for i := 0 to F.lbListe.Count -1 do
        begin
 
        end;
 
    end;
  finally
    F.Free;
  end;
end;       
 

Der Aufruf erfolgt dann mit Abteilungsliste.EditData aus einem beliebigen Modul des Projekts. Das Anzeigen funktioniert so weit, auch das Bearbeiten der Liste (lbListe).

Code: Alles auswählen

unit fusimplelisteditor;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  Classes, SysUtils, Contnrs, Forms, Controls, Graphics, Dialogs, ExtCtrls,
  StdCtrls;
 
type
 
  { TSimpleListEditor }
 
  TSimpleListEditor = class(TForm)
    btnErstellen1: TButton;
    btnLoeschen: TButton;
    btnSpeichern: TButton;
    btnEdit: TButton;
    btnVerwerfen: TButton;
    lbListe: TListBox;
    lblName: TLabel;
    pnlHeader: TPanel;
    pnlButtonsRight: TPanel;
    procedure btnEditClick(Sender: TObject);
    procedure btnErstellen1Click(Sender: TObject);
    procedure btnLoeschenClick(Sender: TObject);
  private
 
  public
 
  end;
 
var
  SimpleListEditor: TSimpleListEditor;
 
 
implementation
 
uses
  dmdaten;
 
{$R *.frm}
 
{ TSimpleListEditor }
 
procedure TSimpleListEditor.btnEditClick(Sender: TObject);
begin
  lbListe.Items[lbListe.ItemIndex] := InputBox('Eintrag bearbeiten', 'Bezeichnung:', lbListe.Items[lbListe.ItemIndex]);
end;
 
procedure TSimpleListEditor.btnErstellen1Click(Sender: TObject);
begin
  lbListe.Items.Add(InputBox('Neuen Eintrag erstellen', 'Bezeichnung:', ''));
end;
 
procedure TSimpleListEditor.btnLoeschenClick(Sender: TObject);
begin
  if MessageDlg('Soll der aktuelle Eintrag wirklich gelöscht werden?', mtWarning, [mbYes, mbNo], 0) = mrYes then
    lbListe.Items.Delete(lbListe.ItemIndex);
end;
 
{ TSimpleListEditor }
 
 
end.

[Warf]

Dafür bietet sich das mit dem Delegator wirklich an.
Also erst mal brauchst du dafür die Interfaces:

Code: Alles auswählen

{$interfaces CORBA} // Damit du keine referenzgezählten COM interfaces hast, die sind hier fehl am platz
type
  IBezeichenbar = Interface // Das ist das was für den Editor sichtbar ist, der braucht ja nur ID und Bezeichner
    // ID bereitstellen
    function GetID: Integer;
    // Bezeichner bereitstellen
    procedure SetBezeichnung(const AValue: String);
    function GetBezeichnung: String;
  end;
 
  IBezeichenbarList = Interface // Der delegator über den mit der original liste "gesprochen" wird
    // Listen funktionen die der Editor braucht:
    function getBezeichenbarCount: Integer; // Anzahl
    function getBezeichenbarItem(AIndex: Integer); // Item zugriff
    function CreateNewBezeichenbar: Integer; // Erzeugt ein neues element, denn der Editor weiß ja nicht was hinter IBezeichenbar für ne klasse steckt
    procedure DeleteBezeichenbar(AValue: Integer); // Löscht das Objekt aus der liste
  end;

TAbteilung muss dafür das IBezeichenbar erben:

Code: Alles auswählen

  TAbteilung = class(TObject, IBezeichenbar)
  private
    fIsChanged: boolean;
    fID: integer;
 
    fBezeichnung: string;
  public
    procedure SetBezeichnung(const aValue: string);
    function GetBezeichnung: string;
 
    function GetID: Integer;  
 
    ...
  end;

Dann muss deine TAbteilungsListe von IBezeichenbarList erben (der einfachheit halber schreib ich was die funktion machen muss als kommentar hinten dran):

Code: Alles auswählen

  TAbteilungsListe = class(TObjectList, IBezeichenbarList)
  ...
  public
    function getBezeichenbarCount: Integer; // Result := Count
    function getBezeichenbarItem(AIndex: Integer); // Result := Items[AIndex];
    function CreateNewBezeichenbar: Integer; {
      newItem := TAbteilung.Create;
      [Was auch immer du mit newItem machen musst, ID auswählen, in db schreiben, etc.]
      Result := Self.Add(newItem);
    }
    procedure DeleteBezeichenbar(AValue: Integer); // Self.Delete(AValue); bzw. noch mehr wenn du mehr machen musst, z.B. aus der DB löschen
   ... 
  end; 

Dann kannst du die Interfaces der Form bereitstellen:

Code: Alles auswählen

  TSimpleListEditor = class(TForm)
    ...
    procedure FormShow(Sender: TObject); // OnShow event
  private
    FListHandler: IBezeichenbarList; // Initialisiere mit nil
  public
    function ShowForEditing(ListHandler: IBezeichenbarList): TModalResult;
  end;
...
function TSimpleListEditor.ShowForEditing(ListHandler: IBezeichenbarList): TModalResult;
begin
  FListHandler := ListHandler;
  Result := ShowModal;
  FListHandler := nil;
end;
 
procedure TSimpleListEditor.FormShow(Sender: TObject);
var i: Integer;
begin
  if not Assigned(FListHandler) then
  begin
    ShowMessage('Not initialized properly');
    Close;
  end;
  lbListe.Items.BeginUpdate; // Verhindert das während dem befüllen nach jedem Item neu gezeichnet wird, massiver performance boost
  lbListe.Clear;
  try
    for i:=0 to FListHandler.getBezeichenbarCount - 1 do // Liste füllen
     lbListe.Items.Add(FListHandler.getBezeichenbarItem(i).GetBezeichnung);
  finally
    lbListe.Items.EndUpdate; // fertig mit dem editieren der Listbox
  end;
end;
 
procedure TSimpleListEditor.btnEditClick(Sender: TObject);
var newBezeichnung: String;
begin
  newBezeichnung := InputBox('Eintrag bearbeiten', 'Bezeichnung:', lbListe.Items[lbListe.ItemIndex]);
  lbListe.Items[lbListe.ItemIndex] := newBezeichnung;
  FListHandler.getBezeichenbarItem(lbListe.ItemIndex).setBezeichnung(newBezeichnung);
end;
 
procedure TSimpleListEditor.btnErstellen1Click(Sender: TObject);
var newBezeichnung: String;
  newIndex: Integer;
begin
  newBezeichnung := InputBox('Neuen Eintrag erstellen', 'Bezeichnung:', '');
  newIndex := FListHandler.CreateNewBezeichenbar;
  FListHandler.getBezeichenbarItem(newIndex).setBezeichnung(newBezeichnung);
  lbListe.Items.Insert(newIndex, newBezeichnung); // Hinzufügen an dem Index an dem es auch in der original liste steht
end;
 
procedure TSimpleListEditor.btnLoeschenClick(Sender: TObject);
begin
  if MessageDlg('Soll der aktuelle Eintrag wirklich gelöscht werden?', mtWarning, [mbYes, mbNo], 0) = mrYes then
  begin
    FListHandler.DeleteBezeichenbar(lbListe.ItemIndex);
    lbListe.Items.Delete(lbListe.ItemIndex);
  end;
end;

Der aufruf ist dann nur noch:

Code: Alles auswählen

function TAbteilungsListe.Editdata: string;
var
  F: TSimpleListEditor;
  i: integer;
begin
  F := TSimpleListEditor.Create(nil);
  F.lblName.Caption:='Abteilungen';
  try
    F.ShowForEditing(self);
  finally
    F.Free;
  end;
end; 

(Du kannst auch eine einzige Instanz der form offen haben, musst nicht jedes man ne neue erzeugen, während showModal kann man ja eh nix anderes machen)

Was aber hier passiert ist das die daten direkt geändert werden wenn sie in der Form geändert werden, es gibt also keine option einen Cancle button hinzuzufügen. Dafür ist das Delegator muster nicht gemacht. Wenn du das so willst solltest du eine eigene liste z.B. von Records übergeben die wirklich nur den Bezeichner und die ID enthalten, die du am ende ausliest (die stringliste von der Listbox zu lesen und zu schreiben halte ich für äußerst unsauber). Vor allem da so etwas TObject(IntPtr(Self.Items.ID)) zwar unter x86 funktioniert, aber auf anderen Architekturen mal ganz schnell in die hose gehen kann. ARM verwendet soweit ich weiß aligned pointer (also wird ein Pointer immer auf einen teiler von 4 oder so gerundet) was heist das IntPtr(Pointer(SomeInteger)) kann eventuell was anderes rauskommen als SomeInteger (kann mich irren das das bei ARM so war, aber in der regel kannst du dich nicht drauf verlassen das es ein 1-1 mapping von Integer auf pointer gibt)

[MacWomble]

Wow ! Herzlichen Dank !

Ich werde versuchen, das alles zu verstehen, nur dann macht es auch Sinn für mich. Aber so kompliziert ist das ja auch nicht wirklich.
Die zusätzlichen Hinweise sind eventuell richtig, aber da ich nur für X86 erstellen muss nicht (oder noch nicht) wirklich relevant. Dennoch ist es gut, so etwas zu wissen!.

Ich verstehe das noch nicht so richtig, der Teil mit den Interfaces:

Verstanden habe ich:
Da die Änderungen unmittelbar vollzogen werden ist ein Verwerfen nicht direkt möglich - nicht so wichtig, sind nur kurze Listen mit Vorgaben (Anreden, Funkitnen, Abteilungen etc.)
Die Interfaces stellen die Schnittstelle zur tatsächlichen Klasse dar.
Deswegen muss ich das beim definieren der Klassen mit angeben.

Was ich nicht verstehe:
Wo müssen dann die Interfaces hin? Ich denke, das kann ich in eine extra Unit packen?

[Warf]

Die Interfaces stellen die Schnittstelle zur tatsächlichen Klasse dar.
Deswegen muss ich das beim definieren der Klassen mit angeben.

Genau, Interfaces geben praktisch eine schnittstelle an die eine Funktion erfüllen muss. Was genau für funktionalität dahinter steht ist dem Interface nutzer egal, mit dem Implementieren eines Interfaces garantierst du nur das es die im interface angegebenen funktionen gibt. Somit kannst du in anderen Klassen diese Funktionalität benutzen ohne wissen zu müssen was um für eine Klasse es sich wirklich handelt.

Am besten dafür betrachtet man sich einfach mal das beispiel des List interfaces in java. Java kennt verschiedenene Listen Klassen, Array Lists, Linked Lists, Double Linked lists, etc. alle implementieren auf einer Oberflächlichen ebene die selbe funktionalität, sind aber in ihrem Laufzeitverhalten anders. Daher gibt es das Interface List, das alle grundfunktionen (Add, Remove, getItem, etc.) bereitstellt, sodass du bis auf beim Instanziieren der Liste (z.B. new ArrayList) nicht wissen musst was tatsächlich dahinter steht. Der mechanismus ist dabei in etwa der selbe wie bei abstrakten Elternklassen, nur das du mehrere Interfaces pro Klasse implementieren kannst.

Tatsächlich wird das bei Lazarus/Pascal recht selten verwendet, ist aber zur sauberen Code kapselung ein mächtiges werkzeug, vor allem vermeidet es z.B. zyklische referenzen (Unit1 benutzt Unit2 und Unit2 benutzt Unit1)

Was ich nicht verstehe:
Wo müssen dann die Interfaces hin? Ich denke, das kann ich in eine extra Unit packen?

Entweder das, oder in die Unit in der die TSimpleListEditor Klasse ist. Ich würde sie zur TSimpleListEditor klasse stecken, da sie genau dafür gebaut sind, und nicht sonderlich allgemeingültig sind. Falls du sie aber noch wo anders einsetzen willst, würde ich sie in eine eigene Unit schreiben. Du möchtest falls möglich nur Zyklische abbhängigkeiten vermeiden, also nicht in die Unit die TAbteilungsListe enthält, sonst hast du TSimpleListEditor benötigt TAbteilungsListe und umgekehrt. Ist aber komplett dir überlassen. Wie gesagt mMn. gehört das logisch mit TSimpleListEditor zusammen, ist aber mehr persönliche preferenz als ein echter grund

[MacWomble]

Ok, ich glaube ich habe das jetzt so weit.
Da das Interface nur die Schnittstelle ist, brauch ich auch im Interface nichts weiter zu implementieren, wenn ich das jetzt richtig interpretiert habe.

Ich versuche das ganze in meinem Projekt umzusetzen und bedanke mich nochmals für die ausführlichen und verständlichen Erklärungen und Hilfen !

[MacWomble]

OffTopic:

... da Lazarus auf meinem Mac nicht läuft (will einfach GUI Anwendungen nicht kompilieren).

Eventuell kann ich dir hier etwas zurück geben:
Verusche mal CodeTyphon (CT) von PilotLogic, das ist um einiges weiter als Lazarus und für viele Plattformen optimiert.
CT basiert ursprünglich auf Lazarus, verwendet die aktuellen FPC-Sourcen und ist in vielen Punkten erweitert und verbessert.
Außerdem haben die einen exzellenten Entwicklersupport.
Aufpassen, die Dateiendungen sind bei CT anders (ist aber ein Projekt-Konverter im Typhon Center {das ist ein Verwaltungstool} dabei).
Ebenso sind einige Pakete logisch umbenannt worden (kennt der Konverter auch).

[MacWomble]

Ich habe das etwas anders gelöst, aber:

Es taucht doch noch ein weiteres Problem auf (bezogen auf dein Beispiel:

Code: Alles auswählen

function getBezeichenbarItem(AIndex: Integer); // Item zugriff

Die Funktion benötigt einen Rückgabewert, was muss da verwendet werden?

[Warf]

Die Funktion benötigt einen Rückgabewert, was muss da verwendet werden?

IBezeichenbar, du weißt ja nicht die echte Klasse des Objekts, also musst du das Interface benutzen

[MacWomble]

OK, werde ich mir merken. Danke!

[af0815]

Nur ein kleiner Hinweis zu programmieren auf Interfaces - Lazarus hat Probleme wenn du Interfaces im published Teil verwendest und dann mit der IDE arbeitest. Da hat die IDE und der OI Probleme damit. Dazu gabs auch Einträge im Bugtracker von mir.
An und für sich ist das Programmieren auf Interfaces eine gute und stabile Sache. Vor allen weil die Programme damit viel besser wartbar werden.

[MacWomble]

Danke für den Hinweis.

Ansonsten habe ich das mit dem Interface hin bekommen und nun auch verstanden, funktioniert wunderbar
Jetzt, wo ich die Interfaces kennen gelernt habe:
Auf Anhieb sind mir gleich weitere Sachen in meinem Projekt in den Sinn gekommen, wo Interfaces hilfreich sein können