konzeptionelle Gedanken optische Darstellung Stammbaum

[idefix2]

Zitat von hansklok:

Es get nur darum, dass das ganze Scrollbar sein soll.

Worin besteht das Problem?
Für die Darstellung der einzelnen Knoten nimmst du geeignete visuelle Komponenten. Die Komponenten wissen auch, wenn sie gescrollt werden, wann sie angeklickt werden, und du kannst in den entsprechenden Ereignisroutinen (onclick etc.) darauf reagieren. Um das Scrollen brauchst du dich nicht zu kümmern.

Die Bildschirmdarstellung sollte ausser der Bildschirmdarstellung nichts tun, insbesonders keine Strukturdaten enthalten. Auf Grund der Strukturdaten, die du in eigenen Klassen bereit hältst, die mit der Darstellung am Schirm gar nichts zu tun haben, erstellst du dann die visuellen Komponenten.

Also nicht: Visuelle Komponente enthält Referenz auf Datenbankwert
sondern - Aus der Datenbank erzeuge Baum bzw. Netzstruktur, und dann erzeuge für jeden Netzknoten adäquate visuelle Controls mit geeigneten Namen. Wenn ein Control angeklickt wurde, weisst du auf Grund des Parameters "Sender" in allen Ereignisbehandlungsroutinen, wer angeklickt wurde.

Zitat von Namenloser:

Und mehr brauchst du gar nicht. Die Kinder musst du gar nicht speichern, weil sie sich implizit ergeben: Das sind die Personen, wo entweder Father oder Mother das jeweilige Subjekt sind.

Es kann schon ganz praktisch sein, wenn von jedem Knoten weg in alle Richtungen verkettet wird:
Person -> Vater
Person -> Mutter
Person -> nächstälteres Geschwister
Person -> nächstjüngeres Geschwister
Person -> jüngstes (oder ältestes) Kind

edit
Wobei das mit den Geschwistern komplizierter ist, es gibt ja auch Halbgeschwister und dergleichen. Da ist es vielleicht wirklich am besten, wie Namenloser schreibt, nur die Eltern zu speichern und für alles andere die Liste aller Personen durchzugehen. So viele Leute können das nicht sein, dass da Performance Probleme drohen würden.

[Namenloser]

Zitat von idefix2:

Zitat von Namenloser:

Und mehr brauchst du gar nicht. Die Kinder musst du gar nicht speichern, weil sie sich implizit ergeben: Das sind die Personen, wo entweder Father oder Mother das jeweilige Subjekt sind.

Es kann schon ganz praktisch sein, wenn von jedem Knoten weg in alle Richtungen verkettet wird:
Person -> Vater
Person -> Mutter
Person -> nächstälteres Geschwister
Person -> nächstjüngeres Geschwister
Person -> jüngstes (oder ältestes) Kind

Redundanz ist in meiner Erfahrung immer schlecht und gilt es so gut es geht zu vermeiden. Man kann sich Methoden bauen, die einem die entsprechenden Familienmitglieder zurückgeben. Aber man sollte sie nicht explizit speichern.

[mkinzler]

In einer modernen Welt könnte man auch Father/Mother durch SPouse1/Spouse2 ersetzten oder noch besser die Eltereigenschaft getrennt setzen.

[hansklok]

So, um eines Vorweg zu nehmen, danke für Eure bisherigen Antworten.
Ich arbeite mich grade erst in die Materie ein. ANFÄNGER!!!! Ich bin wieder in die Delhpipraxis-Community zurückgekehrt, da ich früher hier sehr gute Erfahrungen gemacht habe. Ich entwickle unter OS X mit Xojo. An sich gibt es da sehr!!! viele Parallelen zu Delphi. Deswegen versuche ich es hier im Forum.

Von vorne: Die Beispieldatenbank hat folgende Tabellen:

1. Personen
   • Name
   • Geburtsdatum
2. Familien
   • MutterID
   • VaterID
3. Kinder
   • FamilienID

So, folgendes Szenario:

• Max Mustermann solle der Proband sein
• Seine Eltern sind Hans Mustermann und Elke Musterfrau
• Max ist das Zweitgeborene von 4 Kindern der Familie
• Max war zweimal verheiratet. Mit Maria Streifenmuster und Petra Kairomuster
• aus der ersten Ehe gingen 1 Kind (Ludwig) und aus der zweiten keines hervor.

An sich eine einfache Familienkonstellation. Via SQL-Abfrage wird nun erstmal der Proband innerhalb der Geschwister eingeordnet (Geburtsdatum), diese ordnen sich dann auf der gleichen Ebene links und rechts um ihn. Da er aber auch zwei Frauen hatte, werden diese rechts von ihm vor seinen 3. und 4. Geschwisterteil platziert. Unter die Frauen dann jeweils die Kinder. Ich finde, das ist bei einem solchen Beispiel schon ein sehr komplexes Ding.
Was mich also beschäftigt ist zum einen, wie baue ich um meinen Probanden, der stets zentriert im Fokus der grafischen Ausgabe sein soll, alles andere um ihn herum? Deswegen auch die Frage mit den Scrollbars!

Vielleicht besteht die Möglichkeit, dass wir hier Step by Step, Tutorialartig so etwas gemeinsam definieren können, das fände ich klasse

So würde die grafische Ausgabe zum Beispiel mal ausschauen:

[TiGü]

Was hast du denn bisher?
Zeig mal Quelltext!
Der Ansatz von Namenloser mit den Layern ist eigentlich ganz knuffig.

[hansklok]

Meine Gedanken (der Einfachheit halber mal eingedeutscht):

Delphi-Quellcode:

// es gibt mehrere Möglichkeiten der Darstellung, die mir vorschweben
//
// 1. der Proband ist eine Partnerschaft
// 2. der Proband ist eine einzelne Person

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// zu 1. (Nachteil hier, es werden keine weiteren Partner & Geschwister angezeigt)
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

TPerson = class
  const
    Width: 200;
    Height: 75;
  public
    Name: String;
    Vater: TPerson;
    Mutter: TPerson;
    procedure Draw(Canvas, TCanvas; x, y: Integer);
end;

TPartnerschaft = class // im Falle 1. wäre Partnerschaft dann der "Proband"
  public
    PartnerA: TPerson; // Mann oder Frau bei gleichgeschlechtlichen Partnerschaften
    PartnerB: TPerson; // Frau "
    Kinder: TList<TPerson>; // Reihenfolge der Kinder kann schon bei der SQL-Abfrage erfolgen
    procedure Draw(Canvas: TCanvas);
end;

procedure TPerson.Draw(Canvas: TCanvas; x, y: Integer);
begin
  Canvas.DrawRectangle(x, y, Width, Height);
  // später kann hier noch der Name der Person ausgegeben werden

  if Vater <> nil and Mother <> nil then begin
    // Eltern zeichnen dementsprechend versetzt über dem Probanden (x, y müssen angepasst werden)
  end else 
  if Vater <> nil and Mother = nil then begin
    // nur Vater zeichnen
  end else
  if Vater = nil and Mother <> Nil then begin
    // nur Mutter zeichnen
  end;
end;

procedure TPartnerschaft.Draw(Canvas: TCanvas);
begin
  // hier wird es nun kompliziert, da zunächst alle Kinder gezählt werden müssen, um den Probanden oberhalb zu zentrieren, ABER
  // sollte die Breite der Elterngenerationen (Eltern, Großeltern) breiter sein, als die der Kinder, so orientiert sich die Ausrichtung an diesen

  if PartnerA <> nil and PartnerB <> nil then begin
    // iterativ alle Elterngenerationen zeichnen, aber wie finde ich heraus, wieviele das sind, also durch Iteration?
    PartnerA.Draw(Canvas, x, y); // ???????
  end else 
  if PartnerA <> nil and PartnerB = nil then begin
    // nur PartnerA zeichnen
  end else
  if PartnerA = nil and PartnerB <> Nil then begin
    // nur PartnerB zeichnen
  end;

  for i as Integer = 0 to Kinder.Count do begin
    // auch hier müssen Koordinaten ausfindig gemacht werden, damit die Kinder unter dem Probanden und jeweils nebeneinander gezeichnet werden können
  end;
end;

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// zu 2. (Partner & Geschwister können angezeigt werden)
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// um diesen soll sich dann alles drehen, also der Stammbaum aufbauen
TProband = class(TPerson)
  public
    Geschwister: TList<TPerson>;
    Partner: TList<TPerson>;
    Kinder: TList<TPerson>;
    // Draw-Methoden müssten analog zu oben sein
end;

TStammbaum = class(TCanvas)
  puclic
    Proband: TProband; // oder eben TPartnerschaft
    // Draw-Methoden müssten analog zu oben sein
end;

Ist das ein prinzipiell falscher Ansatz?

[Sir Rufo]

Wenn ich mir das Bild so anschaue, dann kann man die Daten zu dieser Anzeige hiermit abbilden (die Bilder habe ich jetzt mal weggelassen):

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.Generics.Collections;

type
  TLocationDateTime = record
    Location: string;
    Timestamp: TDateTime;
  end;

  TPersonViewModel = class
  private
    FID: TGUID;
    FLastName: string;
    FFirstName: string;
    FBorn: TLocationDateTime;
    FDied: TLocationDateTime;
  public
    property ID: TGUID read FID write FID;
    property LastName: string read FLastName;
    property FirstName: string read FFirstName;
    property Born: TLocationDateTime read FBorn;
    property Died: TLocationDateTime read FDied;
  end;

  TParentViewModel = class( TPersonViewModel )
  private
    FFather: TPersonViewModel;
    FMother: TPersonViewModel;
  public
    property Father: TPersonViewModel read FFather;
    property Mother: TPersonViewModel read FMother;
  end;

  TChildViewModel = class( TPersonViewModel )
  private
    FEngagedTo: TList<TPersonViewModel>;
  public
    property EngagedTo: TList<TPersonViewModel> read FEngagedTo;
  end;

  TRelationViewModel = class( TPersonViewModel )
  private
    FChildren: TList<TChildViewModel>;
  public
    property Children: TList<TChildViewModel> read FChildren;
  end;

  TSelectedPersonViewModel = class( TPersonViewModel )
  private
    FFather: TParentViewModel;
    FMother: TParentViewModel;
    FRelations: TList<TRelationViewModel>;
    FSiblings: TList<TChildViewModel>;
  public
    property Father: TParentViewModel read FFather;
    property Mother: TParentViewModel read FMother;
    property Siblings: TList<TChildViewModel> read FSiblings;
    property Relations: TList<TRelationViewModel> read FRelations;
  end;

implementation

end.

[hansklok]

Zitat von Sir Rufo:

Wenn ich mir das Bild so anschaue, dann kann man die Daten zu dieser Anzeige hiermit abbilden (die Bilder habe ich jetzt mal weggelassen):

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.Generics.Collections;

type
  TLocationDateTime = record
    Location: string;
    Timestamp: TDateTime;
  end;

  TPersonViewModel = class
  private
    FID: TGUID;
    FLastName: string;
    FFirstName: string;
    FBorn: TLocationDateTime;
    FDied: TLocationDateTime;
  public
    property ID: TGUID read FID write FID;
    property LastName: string read FLastName;
    property FirstName: string read FFirstName;
    property Born: TLocationDateTime read FBorn;
    property Died: TLocationDateTime read FDied;
  end;

  TParentViewModel = class( TPersonViewModel )
  private
    FFather: TPersonViewModel;
    FMother: TPersonViewModel;
  public
    property Father: TPersonViewModel read FFather;
    property Mother: TPersonViewModel read FMother;
  end;

  TChildViewModel = class( TPersonViewModel )
  private
    FEngagedTo: TList<TPersonViewModel>;
  public
    property EngagedTo: TList<TPersonViewModel> read FEngagedTo;
  end;

  TRelationViewModel = class( TPersonViewModel )
  private
    FChildren: TList<TChildViewModel>;
  public
    property Children: TList<TChildViewModel> read FChildren;
  end;

  TSelectedPersonViewModel = class( TPersonViewModel )
  private
    FFather: TParentViewModel;
    FMother: TParentViewModel;
    FRelations: TList<TRelationViewModel>;
    FSiblings: TList<TChildViewModel>;
  public
    property Father: TParentViewModel read FFather;
    property Mother: TParentViewModel read FMother;
    property Siblings: TList<TChildViewModel> read FSiblings;
    property Relations: TList<TRelationViewModel> read FRelations;
  end;

implementation

end.

Genau Rufo, dein Entwurf ist sehr gut nachvollziehbar und Bilder genau das ab, worum es mir ging. Dankeschön.
Bleibt nach wie vor zu klären, wie man den Baum "günstig" grafisch in einer Paintbox ausgibt, sodass er sich auch scrollen lässt (Zoom wäre natürlich super). und, wie lässt es sich umsetzen, bei so einem verschachtelten Modell, dass jeder Eintrag sich auf der Zeichenfläche anklicken lässt?

P.S. Was macht EngagedTo?

[Sir Rufo]

Das war nur eine begriffliche Entgleisung und sollte MarriedWith, oder welche Art der Beziehung du dort abbilden möchtest.

Siehe Geschwister und Kinder auf dem Bild, da sind noch 0..2 Personen darunter.