ListBox mit verknüpften StringLists sortieren

[delphihase]

Hallo,

jetzt hab ich (schon wieder :roll: ) ne Aufgabe. Und zwar:

Ich soll eine Verwaltung von mehreren Datenfeldern (gespeichert in StringLists) programmieren.

Dabei müssen diese paar StringLists aber nach einer StringList geordnet werden.
Konstillation z.B.
(sortiert nach Feld A)
Eintrag 1:
Feld A: Bärenstark
Feld B: Wert
Feld C: Wert

Eintrag 2:
Feld A: AAAA 1. Stelle
Feld B: Inhalt
Feld C: Inhalt

usw.
Ich habe 19 Felder, die die Daten speichern sollen. (Feld B & Feld C)
Es sind in Feld A & Feld B nur Buchstaben möglich.
Achja, wenn ich mehrere Einträge habe, die Feld A gleich sind, dann wird zusätzlich noch nach Feld B sortiert.

Soo - hat jemand das ganze verstanden? Wenn nein - fragen bitte !!


Außerdem: Was verwende ich dann am besten, um das ganze zu speichern? Die DB sollte auch recht groß werden können (So ca. 500 Einträge), hat aber auch recht viele Felder (werden so etwa 20, davon ist eine aber schon eine "Untertabelle". In dieser "Untertabelle" existiert nochmal eine "Untertabelle")

Wer das ganze jetzt nicht durchblickt hat:

- 1. Ebene: 20 Felder.
- Feld XX: Untertabelle 1
- Ebene 2: 10 Felder
- Feld YY: Untertabelle 2
- Ebene 3: 5 Felder

So sähe die Struktur etwa aus. Mit XML würde das gehen. Nur es sollte ja möglichst rasch geladen werden können.

[Sir Rufo]

Wie wäre es, wenn du das mal etwas strukturierter zusammenschreiben würdest?

Deine Beschreibung ist sehr konfus und abstrakt (und beschreibt wahrscheinlich auch nur das linke Ohr vom Eisbär)

Wenn du etwas nicht beschreiben kannst, dann mal es auf und schick ein Bild mit hoch.

[delphihase]

Vielleicht verstehst du es mit dieser Struktur besser?

XML-Code:

<liste>
   <eintrag>
      <typ>Eisbär</typ>
      <name>Robert</typ>
      <interessen>
         <unterListe typ="Fressen">
            <einstellung detail="pizza">Nein danke</einstellung>
            <einstellung detail="fische">Eher</einstellung>
         </unterListe>
         <unterListe typ="Hobbies">
            <einstellung detail="schach">Was ist das?</einstellung>
            <einstellung detail="fressen fangen">Eher</einstellung>
         </unterListe>
      </interessen>
   </eintrag>
   <eintrag>
      <typ>Rentier</typ>
      <name>Rudolf</name>
      <interessen>
         <unterListe typ="Fressen">
            <einstellung detail="-">keine Angabe</einstellung>
         </unterListe>
         <unterListe typ="Hobbies">
            <einstellung detail="Schlitten ziehen">Das macht Spaß!</einstellung>
            <einstellung detail="Für Weihnachtsmann arbeiten">Juhu!</einstellung>
         </unterListe>
      </interessen>
   </eintrag>
</liste>

In dem Fall wäre <interessen> die 1. Untertabelle. Darin gibt es dann die "unterListe", wo weitere <einstellung>'s gespeichert sind.

[Sir Rufo]

ok, also in kleinen Schritten ...

Was soll jetzt wie und wo in der ListBox (oder werden es mehrere?) angezeigt werden?

[Bjoerk]

Die Struktur ist mir nicht klar. Meinst du so ?

Delphi-Quellcode:

type
  TItem = class(TObject)
    Typ: string;
    List1: TStringlist;
    SubList1: array of TStringlist;
    List2: TStringlist;
    SubList2: array of TStringlist;
  end;
  TItemList = array of TItem;

[Impulz]

ich glaube er will 2 Ebenen in einer zusammenfassen.

hast du 2 listen die du in eine anzeige bringen willst? oder wie?

[delphihase]

Hmm - also:

ich habe eine ListBox (1). in der steht halt immer Feld1 und Feld2.

Dann gibt es Edit-Komponenten, um die ganzen Felder editieren zu können. Ja, soweit bin ich ja schon.

Aber: ich brauche dann eine weitere ListBox (2), die dann die Einträge der von Bjoerk genannten SubList1 anzeigen. Wieder Feld1 und Feld2.
Dann ändern sich auf "Change" der ListBox2 wieder ein paar Felder, eben die der SubList1.

In der SubList 1 gibt es nochmal eine ListBox (3). Auf das OnChange dieser sehe ich dann Inhalte der SubList2.

@Bjoerk: Ich habe aber in der SubList2 mehrere Felder, nicht nur eines. nämlich zwei Stück.

[DeddyH]

Vielleicht könnte man die Struktur so abbilden (Fehler vorbehalten):

Delphi-Quellcode:

type
  TInteresse = class
  private
    FDetailTyp: string;
    FDetail: string;
  public
    property DetailTyp: string read FDetailTyp write FDetailTyp;
    property Detail: string read FDetail write FDetail;
  end;
  
  TInteressenKategorie = class
  private
    FInteressen: TObjectList<TInteresse>;
    FTyp: string;
    function GetInteresse(Index: integer): TInteresse;
  public
    constructor Create;
    destructor Destroy; override;
    procedure AddInteresse(Value: TInteresse);
    procedure Sortiere;
    property Typ: string read FTyp write FTyp;
    property Interesse[Index: integer]: TInteresse read GetInteresse;
  end;
  
  TEintrag = class
  private
    FKategorien: TObjectList<TInteressenKategorie>;
    FTyp: string;
    FName: string;
    function GetKategorie(Index: integer): TInteressenKategorie;
  public
    constructor Create;
    destructor Destroy; override;
    procedure AddKategorie(Value: TInteressenKategorie);
    procedure Sortiere;
    property Typ: string read FTyp write FTyp;
    property Kategorie[Index: integer]: TInteressenKategorie read GetKategorie;
  end;
  
  TListe = TObjectList<TEintrag>;

[Bjoerk]

Zitat:

Zitat von delphihase (Beitrag 1142594)

Hmm - also:

ich habe eine ListBox (1). in der steht halt immer Feld1 und Feld2.

Dann gibt es Edit-Komponenten, um die ganzen Felder editieren zu können. Ja, soweit bin ich ja schon.

Aber: ich brauche dann eine weitere ListBox (2), die dann die Einträge der von Bjoerk genannten SubList1 anzeigen. Wieder Feld1 und Feld2.
Dann ändern sich auf "Change" der ListBox2 wieder ein paar Felder, eben die der SubList1.

In der SubList 1 gibt es nochmal eine ListBox (3). Auf das OnChange dieser sehe ich dann Inhalte der SubList2.

@Bjoerk: Ich habe aber in der SubList2 mehrere Felder, nicht nur eines. nämlich zwei Stück.

Das heißt, du hast eine Hypertextstruktur? Jeder Item sieht so aus, stimmt das ?

Code:

X
X.1    X.2
X.1.1  X.2.1
X.1.2  X.2.2

[delphihase]

@Bjoerk: Ja, so meine ich es.

[Bjoerk]

Dann ist das ein z.b. ein array of Record oder Tlist oder objectlist, keine stringlist. ich poste dir gleich mal ein beispiel, muss suchen...

[Bjoerk]

Zu Übungszwecken können wir ja mal ein array nehmen. Du kannst das weiter anpassen, ich hab die Variablen des Records jetzt einfach mal X usw. genannt. Die sortierten Einträge dann einfach in die Listbox eintragen. Wenn du nach anderen Werten sortieren willst, einfach eine weietre Sort Methode hinzufügen.

Delphi-Quellcode:

unit uArrayBeispielUnit;

interface

type
  TItem = record
    X,
    X1, X11, X12,
    X2, X21, X22: string;
  end;
  TItemList = class(TObject)
  private
    FItems: array of TItem;
    FCount: integer;
    procedure SetCount(NewCount: integer);
    function GetItem(Index: integer): TItem;
    procedure SetItem(Index: integer; const Item: TItem);
  public
    procedure AddItem(const Item: TItem);
    procedure DelItem(Index: integer);
    procedure InsItem(Index: integer; const Item: TItem);
    procedure Clear;
    function IndexOf(Value: string): integer;
    procedure Exchange(Index1, Index2: integer);
    procedure Sort;
    property Items[Index: integer]: TItem Read GetItem Write SetItem; default;
    property Count: integer Read FCount;
    constructor Create;
    destructor Destroy; override;
  end;

implementation

constructor TItemList.Create;
begin
  inherited Create;
  FCount:= 0;
end;

destructor TItemList.Destroy;
begin
  Clear;
  inherited Destroy;
end;

procedure TItemList.SetCount(NewCount: integer);
begin
  FCount:= NewCount;
  SetLength(FItems, FCount);
end;

procedure TItemList.Clear;
begin
  while FCount > 0 do DelItem(FCount-1);
end;

function TItemList.GetItem(Index: integer): TItem;
begin
  Result:= FItems[Index];
end;

procedure TItemList.SetItem(Index: integer; const Item: TItem);
begin
  Items[Index]:= Item;
end;

procedure TItemList.AddItem (const Item: TItem);
begin
  SetCount(FCount+1);
  FItems[FCount-1]:= Item;
end;

procedure TItemList.InsItem(Index: integer; const Item: TItem);
var
  I: integer;
begin
  SetCount(FCount+1);
  for I:= FCount-1 downto Index+1 do
    FItems[I]:= FItems[I-1];
  SetItem(Index, Item);
end;

procedure TItemList.DelItem(Index: integer);
var
  I: integer;
begin
  for I:= Index to FCount-2 do
    FItems[I]:= FItems[I+1];
  SetCount(FCount-1);
end;

function TItemList.IndexOf(Value: string): integer;
var
  I: integer;
begin
  Result:= -1;
  for I:= 0 to FCount-1 do
    if FItems[I].X = Value then
    begin
      Result:= I;
      Break;
    end;
end;

procedure TItemList.Exchange(Index1, Index2: integer);
var
  T: TItem;
begin
  T:= FItems[Index1];
  FItems[Index1]:= FItems[Index2];
  FItems[Index2]:= T;
end;

procedure TItemList.Sort;
var
  I, J: integer;
begin
  for I:= 0 to FCount-2 do
    for J:= I+1 to FCount-1 do
      if FItems[I].X > FItems[J].X then Exchange(I, J);
end;

end.

Delphi-Quellcode:

unit BeiepielUnit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,  StdCtrls, uArrayBeispielUnit;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    FItemList: TItemList;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FItemList:= TItemList.Create;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FItemList.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Item: TItem;
  I: integer;
begin
  FItemList.Clear;
  for I:= 1 to 3 do
  begin
    Item.X:= 'X.'+IntToStr(3-I);
    Item.X1:= 'X1.'+IntToStr(3-I);
    Item.X2:= 'X2.'+IntToStr(3-I);
    Item.X11:= 'X11.'+IntToStr(3-I);
    Item.X12:= 'X12.'+IntToStr(3-I);
    Item.X21:= 'X21.'+IntToStr(3-I);
    Item.X22:= 'X22.'+IntToStr(3-I);
    FItemList.AddItem(Item);
  end;
  for I:= 0 to FItemList.Count-1 do
    ShowMessage(FItemList[I].X);
  FItemList.Sort;
  for I:= 0 to FItemList.Count-1 do
    ShowMessage(FItemList[I].X);
end;

end.

[Bummi]

***deleted***

[delphihase]

@Bjoerk: Das stimmt so nicht ganz.

Du hast die Ebene 1 X genannt (daraus: Ebene 2 = y, Ebene 3 = z)

In deinem Code ist die Anzahl von Y (x.1, x.2) fix definiert; nämlich genau auf zwei. Das muss aber auch variabel sein, Ebenso wie das der Ebene 3 (Z).

Also bräuchte ich Funktionen für:
- Einfügen auf Ebene 1
- Einfügen auf Ebene 2
- Einfügen auf Ebene 3
- Löschen auf Ebene 1
- Löschen auf Ebene 2
- Löschen auf Ebene 3
- Ändern auf Ebene 1
- Ändern auf Ebene 2
- Ändern auf Ebene 3

Sortiert wird NUR die Ebene 1, nicht aber die Ebenen 2 & 3.
Sobald ich etwas ändere, soll das ganze neu sortiert werden - also die GANZE Ebene 1.

[Bjoerk]

Sorry, aber dann ist die Aufgabenstellung immer noch nicht klar bzw. hat sich geändert bzw. entspricht nicht deiner Aussage in #10. :roll:

[delphihase]

Stimmt, ich habe es mit der Hyperstruktur etwas falsch verstanden.

Sorry. :oops: