This page is also available in

Handbuch

Die folgende Dokumentation ist Bestandteil der BeeBase-Distribution und gibt es auch als PDF.

[ << ]

[ >> ]

[Anfang]

[Inhalt]

[Index]

[ ? ]

4. Tutorial

Erstellung einer Stammbaum-Datenbank

Dieses Kapitel ist ein kleines Tutorial, welches beschreibt, wie die Hauptelemente von BeeBase arbeiten. Innerhalb des Tutorials wird ein kleines Projekt entwickelt, das Ihnen erlaubt, Ihren Stammbaum zu verwalten. Das nach dem Durchführen aller Schritte entstandene Projekt dieses Tutorials können Sie als Projekt `FamilyTree.bbs' im `Demos'-Verzeichnis Ihrer BeeBase-Installation finden.

4.1 Wie BeeBase arbeitet

Man kann sagen, dass BeeBase in zwei verschiedenen Modi arbeitet: Datensatzbearbeitungs- und Strukturbearbeitungsmodus.

Im Datensatzbearbeitungsmodus ändern, löschen und fügen Sie Datensätze hinzu.

Der Struktureditor erlaubt Ihnen das Bearbeiten des Aussehens Ihrer Datenbank und welche Tabellen und Felder es enthalten soll.

Neben diesen beiden gibt es noch den Programmeditor, in dem Sie Programmfunktionen schreiben können, die entweder automatisch ausgeführt werden, wenn Sie Daten in ein Feld eingeben oder dann, wenn Sie einen Knopf drücken.

4.2 Ein Projekt beginnen: Der Struktureditor

Um eine Datenbank zu erstellen, müssen Sie zuerst dessen Inhalt festlegen. In BeeBase wird dies im Struktureditor durchgeführt. Um zum Struktureditor zu gelangen, wählen Sie den Menüpunkt `Struktureditor' aus dem `Projekt'-Menü. Sie werden drei verschiedene Bereiche vorfinden:

`Tabellen': Hier ändern, löschen und fügen Sie Tabellen hinzu.
`Felder': Hier ändern, löschen und fügen Sie Felder in der aktuell ausgewählten Tabelle hinzu.
`Anzeige': Hier legen Sie das Aussehen der Datenbank fest, d.h. wie Tabellen und Felder dargestellt werden sollen.

4.3 Hinzufügen einer Tabelle

Als erstes benötigen wir eine Tabelle. Dazu drückt man den Knopf `Neu' unterhalb der Liste im Bereich `Tabelle'. Es erscheint ein Fenster, das nach den folgenden Daten fragt:

`Name'

Hier geben Sie den Namen der Tabelle an.

Der Name muss mit einem Großbuchstaben beginnen und kann bis zu 20 Zeichen lang sein. Der Name kann später geändert werden. In diesem Tutorial setzen wir den Namen auf `Person' (1), da die Tabelle alle Namen der Personen speichern soll.

`Anzahl der Datensätze'

Eine Tabelle kann entweder nur aus genau einem oder unbegrenzt vielen Datensätzen bestehen. In diesem Fall setzen wir auf unbegrenzt, da wir mehr als nur eine Person hinzufügen wollen.

`Auslösefunktionen'

Das Hinzuzufügen und Löschen von Datensätzen kann durch Programmfunktionen geregelt werden. Diese Funktion werden hier angegeben. Nachdem wir bis jetzt noch keine Programmfunktion geschrieben haben, lassen wir die Felder leer.

Nachdem alles eingestellt ist, drückt man den Knopf `Ok'. Damit haben wir unsere erste Tabelle namens `Person'.

4.4 Hinzufügen eines Feldes

Jetzt brauchen wir ein Textfeld für diese Tabelle. Dazu drückt man den Knopf `Neu' im Bereich `Felder'. Auch Felder benötigen einige Einstellungen:

`Name': Wie bei einer Tabelle ist der erste Buchstabe ein Großbuchstabe und maximal 20 Zeichen sind zulässig. Dieses Feld wird auf `Name' gesetzt, da es die Namen der Personen speichern soll, die wir hinzufügen werden.
`Typ': Hier wählen wir aus, welchen Typ dieses Feld haben soll. Es gibt hier eine Menge verschiedener Typen, aber für dieses Feld benötigen wir ein Zeichenkettenfeld.
`max. Länge': Hier müssen Sie die maximale Anzahl der Zeichen angeben, die ein Benutzer für die Zeichenkette eingeben kann. Wie setzen dies auf 30.
`Vorgabewert': Es ist möglich, für einige Felder einen Vorgabewert für jeden neuen hinzugefügten Datensatz zu setzen. In diesem Einstellfeld gibt man diesen Wert an. Wir lassen diese Zeile leer.
`Auslösefunktion': Ein Feld kann auch eine Programmfunktion auslösen, die ausgeführt wird. Zum Beispiel können Sie ein Programm angeben, das nach einer Eingabe eines Namens prüft, ob der Name schon existiert.

4.5 Darstellen des Projekts

Nach dem Verlassen des Fensters bemerken Sie einige Veränderungen im Bereich `Anzeige'. Wechseln Sie über das Auswahlfeld oben im Anzeigebereich zum `Hauptfenster'. Nun sehen Sie, was das Hauptfenster beinhaltet, bis jetzt besteht es lediglich aus der Tabelle `Person'. Wechseln Sie nun mit dem Auswahlfeld wieder zurück zum `Tabellenschema' und Sie können sehen, wie die Tabelle `Person' dargestellt wird. Im Moment wird sie nur als ein Panel mit einem Feld angezeigt.

Nun doppel-klicken Sie auf `Person' am Beginn der Liste im Anzeigebereich und ein Fenster erscheint. Klicken Sie auf die `Panel'-Leiste und Sie können nun einstellen, wie das Panel angezeigt werden soll:

`Überschrift': Der Name einer Tabelle kann vom echten Namen abweichen. Unsere Tabelle heißt `Person', aber wir können es auf `THIS IS THE TABLE PERSON!' setzen, wenn wir es besser finden.
`Hintergrund': Der Hintergrund kann auf Ihren Geschmack passend eingestellt werden.
`Gadgets': Hier legen Sie fest, welche Knöpfe das Panel haben soll.

Nach dem Bestätigen durch Drücken von `OK' doppel-klicken wir im Anzeigebereich in der Liste auf `Name'. Dies öffnet ein Fenster, in dem die Einstellungen für die Darstellung des Zeichenkettenfeldes `Name' vorgenommen werden.

`Überschrift': Analog zum Panel wird die hier eingegebene Zeichenkette dargestellt, wenn BeeBase im Datensatzmodus ist.
`Tastenkürzel': Hier können Sie einen Buchstaben definieren, durch den zu diesem Feld im Datensatzmodus gesprungen werden kann. Hierzu muss der Buchstabe bei gehaltener Alt-Taste (Windows, Mac OS und Linux), bzw. Amiga-Taste gedrückt werden.
`Home': Veranlasst den Cursor, immer in dieses Feld zu springen, wenn ein neuer Datensatz angelegt wird. In unserem Fall werden wir immer oder meistens in einem neuen Datensatz den Namen zuerst eingeben, deshalb wird es gesetzt.
`Nur lesen?': Dieses Feld wird gesetzt, wenn es nur lesbar sein soll. Lassen Sie es ungesetzt.
`Gewichtung': Entscheidet darüber, wieviel vom Feld sichtbar sein soll, wenn es den Platz mit anderen Feldern teilen soll. Wenn z.B. drei Zeichenketten mit je 50 Zeichen in einem Fenster stehen, das nur Platz für 100 Zeichen hat, dann entscheidet diese Zahl, wieviel Platz die Zeichenkette relativ zu den anderen erhält. Lassen Sie es bei 100.
`Hintergrund': Analog zu Panel.
`Sprechblasenhilfe': Hier wird Text angegeben, der für den Benutzer hilfreich sein kann. Die Sprechblase erscheint, wenn Sie die Maus für einige Sekunden über dem Feld halten. Setzen Sie dieses Feld auf `Wenn Sie Hilfe brauchen, rufen Sie den Autor unter 112 an'.

Verlassen Sie den Struktureditor (`Struktureditor verlassen' im Menü `Projekt') und kehren in den Datensatzmodus zurück. Sie werden eine Überschrift sehen, die die Zeichenkette beinhaltet, den Sie im Anzeigebereich für das Panel eingegeben haben. Der Datensatzzähler sollte `#0/0' anzeigen, da wir noch keine Datensätze eingefügt haben. Dahinter ist der Filterknopf und zwei Knöpfe mit Rückwärts- und Vorwärtspfeil. Unter all dem sollten Sie das Feld `Name' und den Text sehen, den Sie im Anzeigebereich für dieses Feld angegeben haben. Wenn Sie keinen Text im Anzeigebereich geändert haben, dann wird das Panel den Text `Person' und das Zeichenkettenfeld den Text `Name' tragen. Bewegen Sie nun die Maus über das Feld `Name' und lassen Sie sie für ein paar Sekunden verharren. Wenn Sie etwas für die Sprechblasenhilfe eingegeben haben, werden Sie dessen Text in einem Hilfsfenster sehen.

4.6 Hinzufügen von zwei Datensatzbeziehungen

Jetzt werden wir zwei Datensatzbeziehungen hinzufügen. Beziehungsfelder weichen ein wenig von den anderen Feldern ab. Wie ihr Name schon andeutet, beziehen sie sich auf andere Datensätze. Sie werden dies besser verstehen, wenn wir es kurz mal ausprobieren.

Wechseln sie wieder in den Struktureditor und fügen zwei weitere Felder zu `Person' hinzu. Drücken Sie `Neu' im Bereich Felder, benennen es `Father' und ändern den Typ auf `Beziehung'. Eine Datensatzbeziehung hat nur eine Einstellung:

`Stelle Beziehung her zu': Legt die Tabelle fest, auf die sich das Feld beziehen soll. Es sollte schon auf `Person' verweisen. Lassen Sie es unverändert und drücken Sie `Ok'.

Fügen Sie ein weiteres Feld über `Neu' im Bereich Felder hinzu und nennen Sie es `Mother'. Der Typ sollte auch auf `Beziehung' gesetzt werden und auf Tabelle `Person' zeigen.

Wie Sie vielleicht schon bemerkt haben, sind nun drei Felder im Anzeigebereich sichtbar. Klicken Sie einmal auf `Father' und dann auf die Knöpfe `Hoch' und `Runter', die gleich links davon angeordnet sind. Dies verändert die Position des Feldes `Father' in der Datensatzansicht. Setzen Sie `Father' an den Anfang, `Name' in die Mitte und `Mother' an das Ende.

Nun müssen wir den Inhalt der Beziehungsfelder `Father' und `Mother' setzen, der aus den bezogenen Datensätzen angezeigt werden soll. Doppelklicken Sie auf `Father' im Anzeigebereich und wählen sie `Extras'. Dort wählen wir die Zeichenkette `Name' aus, die angezeigt werden soll und drücken `Ok'. Diese Vorgehensweise wiederholen wir mit `Mother'.

4.7 Datensätze hinzufügen

Jetzt sollten wir einige Datensätze hinzufügen. Verlassen Sie den Struktureditor. Um einen neuen Datensatz hinzuzufügen, wählen Sie `Neuer Datensatz' aus dem Menü `Tabelle' (dieses Menü ist in der Windows- und Linux-Version ein Popup-Menü, das durch drücken und halten der rechten Maustaste in der Tabelle sichtbar wird). Der Cursor sollte nun automatisch in das Feld springen, bei dem wir vorhin im Anzeigebereich des Struktureditors `Home' gesetzt haben. Geben Sie nun zwei Datensätze ein: einen mit dem Namen ihres Vaters in `Name' und nach Hinzufügen eines zweiten Datensatzes einen mit dem Namen ihrer Mutter auch im Feld `Name' Danach fügen sie einen weiteren Datensatz ein, der im Feld `Name' Ihren Namen erhalten soll.

Nun kommen wir zur Erklärung der Beziehungsfelder Drücken Sie auf den Listenansichtknopf bei `Father' und wir erhalten eine Liste aller Datensätze, auf die das Beziehungsfeld verweisen kann. Wählen Sie den Namen ihres Vaters und führen das gleiche mit dem Listenansichtfenster Ihrer Mutter durch.

Jetzt sollten wir drei Datensätze mit Ihnen, Ihrem Vater und Ihrer Mutter haben. In Ihrem Datensatz sollte dann oben im Feld `Father' der Name Ihres Vaters und im unterem Feld `Mother' der Name Ihrer Mutter stehen. Sie können nun die drei Datensätze durchblättern, wenn Sie Alt zusammen mit den Cursortasten Up oder Down drücken.

Aber halt! Sie würden sagen, dass Ihre Eltern auch Eltern haben/hatten. Daher fügen Sie weitere vier Datensätze für die dritte Generation ein. Fügen Sie einfach einen Datensatz nach dem anderen ein und tragen jeweils die Namen in `Name' ein. Wenn Sie die Namen nicht mehr wissen, dann tragen Sie `Vaters Vater', `Mutters Vater' oder ähnliches ein. Nun blättern Sie durch die Datensätze und setzen zu den einzelnen Datensätzen jeweils dazugehörend Vater und Mutter. Wenn Sie das erledigt haben, müssen Sie sieben Datensätze haben: Ihren Datensatz, zwei Ihrer Eltern und vier Ihrer Großeltern.

4.8 Filter

Nachdem wir nun einige Datensätze zum Verarbeiten haben, probieren wir die Filterfunktion aus. Der Filter kann Datensätze herausfiltern, die nicht angezeigt werden sollen. Diese verweilen dennoch in der Datenbank, sie sind einfach nur nicht mehr sichtbar.

Um den Filter einzugeben, wählen Sie `Ändere Filter' aus dem Menü `Tabelle'. Sie werden nun ein Fenster mit einer Menge von Operatoren sehen. Diese werden verwendet, um die Bedingungen zu setzen, die ein Datensatz erfüllen muss, damit er angezeigt wird.

In unserem kleinen Beispiel verwenden wir den Befehl LIKE, welcher einen Mustervergleich mit einem Feld ermöglicht. Drücken Sie zuerst einmal auf den Knopf LIKE, doppel-klicken dann auf den Eintrag `Name' in der linken Liste und (LIKE Name ) sollte nun im unteren Textfeld über den Knöpfen `Ok' und `Abbrechen' zu sehen sein. Fügen Sie nun "*a*" ein, so dass die ganze Zeichenkette schließlich (LIKE Name "*a*") enthält. Dies bedeutet, dass BeeBase nur die Datensätze anzeigt, die den Buchstaben `a' im Feld `Name' enthalten.

Drücken Sie nun `Ok' und Sie werden bemerken, dass Datensätze ohne `a' in `Name' nicht mehr sichtbar sind. Nachdem der Buchstabe `a' in den meisten Sprachen und Namen häufig verwendet wird, dürften möglicherweise alle Datensätze angezeigt werden, aber Sie können andere Buchstaben ausprobieren, um die Filterfunktion besser zu verstehen.

Wie weiter oben schon erwähnt, existiert ein Knopf im Panel, das `F' enthält. Dieses `F' zeigt an, ob der Filter aktiviert ist oder nicht. Schalten Sie den Filter aus, wenn Sie mit dem Testen fertig sind, dann werden wieder alle Datensätze sichtbar.

4.9 Abfragen

Nachdem Sie die Filterfunktion kennen gelernt haben, wenden wir uns der Abfragefunktion von BeeBase zu. Abfragen können verwendet werden, um Informationen aus einer Datenbank zu erhalten, die bestimmten Kriterien genügen.

Wählen Sie `Abfragen' aus dem Menü `Programm', um den Abfrageeditor zu öffnen. Es erscheint ein Fenster mit einigen Knöpfen am oberen Rand und zwei größeren Bereichen darunter. Das Textfeld oben links dient dem Eintragen eines Namens, unter dem Sie die Abfrage speichern wollen.

`Ausführen.': Kompiliert und führt die Abfrage aus.
`Drucken': Druckt das Ergebnis der Abfrage in eine Datei oder auf Ihrem Drucker aus.
`Laden und Speichern': Lädt und speichert Ihre Abfragen.

Das erste große Feld dient dem Eingeben der Abfrage und das zweite große Feld zeigt das Ergebnis der Abfrage an.

Nun werden wir eine Liste ausgeben lassen, die die Personen anzeigt, die wir zuvor per Filter ermittelt haben. Geben Sie `Personen, die ein a im Namen haben' in das Textfeld oben links ein. Im oberen großen Feld geben Sie folgendes ein:

SELECT Name FROM Person WHERE (LIKE Name "*a*")

Wenn Sie nun die Abfrage über den Knopf `Ausführen' abarbeiten lassen, wird BeeBase eine Liste aller Personen ausgeben, die ein `a' im Namen haben. Ändern Sie den Buchstaben, um verschiedene Ergebnisse zu erhalten.

Wir führen nun den Befehl AND ein. Wählen Sie den Listenansichtknopf vom linken oberen Textfeld, drücken Sie `Neu' und benennen es `Personen, die ein a und s im Namen haben'. Nun geben Sie ein:

SELECT Name FROM Person WHERE
(AND (LIKE Name "*a*") (LIKE Name "*s*"))

Beachten Sie, dass wir immer noch den Befehl LIKE zur Auswahl von Datensätzen verwenden, die die Buchstaben `a' und `s' im Namen haben, aber der Befehl AND fordert, dass beide Kriterien mit LIKE erfüllt sein müssen. Deshalb sind nach dem Ausführen der Abfrage nur Datensätze sichtbar, die die Buchstaben `a' und `s' im Namen haben.

4.10 Hinzufügen einer Tabelle mit einem mehrzeiligen Text und einem Knopf

Bisher wurden zwei Arten zur Auswahl und Anzeige der Datenbank aufgezeigt. Ein anderer Weg zum Darstellen kann über ein Programm geschehen. Um Daten darzustellen, können wir einen Feldtyp `mehrzeiliger Text' verwenden.

Wechseln Sie in den Struktureditor und wählen Sie `Neu' im Bereich `Tabelle'. Benennen Sie die Tabelle `Control' und setzen Sie die Anzahl der Datensätze auf `genau ein'. Schließen Sie das Fenster mit `Ok'. Klicken und halten Sie die Maustaste auf der neuen Tabelle. Nun verschieben Sie den Eintrag etwas über die Mitte von `Person' und lassen die Maustaste los. Im Bereich Tabelle erscheint nun `Control' oben und `Person' darunter.

Stellen Sie sicher, dass `Control' aktiviert ist und wählen `Neu' aus dem Bereich Felder. Ändern Sie den Typ auf `mehrzeiliger Text' und geben Sie dem Feld den Namen `Result'. Drücken Sie `Ok' und fügen ein weiteres Feld zu `Control' hinzu, indem Sie nochmal auf `Neu' im Bereich Felder klicken. Diesmal nennen wir das Feld `Pedigree' und setzen den Typ auf `Knopf'.

Um der Datenbank ein besseres Aussehen zu geben, klicken Sie einmal auf `Pedigree' im Anzeigebereich und schieben es nach oben, indem Sie einmal auf den Knopf `Hoch' drücken.

4.11 BeeBase programmieren, um einen Stammbaum zu erzeugen

Wir haben nun einen Knopf, um ein Programm zu starten, und einen mehrzeiligen Text, um Daten darin darzustellen. Nun ist es Zeit, den Programmeditor zu starten. Dies geschieht durch Auswählen von `Ändern' aus dem Menü `Programm'. Der Editor hat drei Knöpfe:

`Kompilieren & Schließen': BeeBase kompiliert das Programm und verlässt den Programmeditor.
`Kompilieren': Kompiliert das Programm, bleibt aber im Programmeditor.
`Rückgängig machen': Macht alle Änderung seit dem Öffnen des Programmeditors rückgängig.

Nachdem alle Programmfunktionen, die Sie schreiben, in diesem einen Fenster verbleiben, müssen wir sie voneinander trennen. In BeeBase wird dies durch den Befehl DEFUN erreicht. Im folgenden Beispiel ist alles zwischen zwei runden Klammern ein Teil der Funktion stammbaum:

(DEFUN stammbaum ()

; Dies ist DEFUN's abschließende Klammer
)

Mit diesem Sachverhalt geben wir unsere erste Funktion ein, die einen Stammbaum der gerade angezeigten Person aus der Datenbank im Feld `Result' anzeigt. Folgende Funktion `stammbaum' besteht genau genommen aus drei Funktionen:

pedigree, das `Control.Result' setzt, in dem eine andere Funktion aufgerufen wird.
getpedigree, das den Stammbaum in einer verschachtelten Liste zusammenträgt.
pedigree2memo, das diese Liste in einen mehrzeiligen Text umwandelt.

; Das Programm pedigree

(DEFUN pedigree ()
    (SETQ Control.Result
        (pedigree2memo (getpedigree Person NIL) 0 3)
    )
)


; Das Programm getpedigree

(DEFUN getpedigree (person:Person level:INT)
    (IF (AND person (OR (NULL level) (> level 0)))
        (LIST person.Name
            (getpedigree person.Father (1- level))
            (getpedigree person.Mother (1- level))
        )
    )
)


; Das Programm pedigree2memo

(DEFUN pedigree2memo (pedigree:LIST indent:INT level:INT)
    (IF (> level 0)
        (+
            (pedigree2memo (NTH 1 pedigree) (+ indent 8) (1- level))
            (IF pedigree (SPRINTF "%*s%s\n" indent "" (FIRST pedigree)) "\n")
            (pedigree2memo (NTH 2 pedigree) (+ indent 8) (1- level))
        )
        ""
    )
)

Achten Sie beim Eingeben des Programmes darauf, dass alle Klammern an der richtigen Stelle stehen. Zu viele oder zu wenig Klammern sind häufige Fehler, die beim Übersetzen des Programmes gemeldet werden. Die Fehlermeldung von BeeBase lautet in diesem Fall schlicht `Syntaxfehler'. Drücken Sie `Kompilieren & Schließen' und das Fenster wird geschlossen, was bedeutet, dass BeeBase keine Fehler im Program vorgefunden hat.

Machen Sie sich keine Sorgen, wenn Sie nicht alle Befehle sofort verstehen. Es gibt ein eigenes Kapitel (siehe BeeBase programmieren), das alle Programmfunktionen detailiert beschreibt.

Jetzt haben wir ein lauffähiges Programm, aber wir müssen noch die Programmfunktion mit dem Knopf `Pedigree' verbinden. Dazu wechseln wir in den Struktureditor, wählen `Control' aus dem Tabellenbereich und doppel-klicken auf das Feld `Pedigree' im Felderbereich. Dann klicken Sie auf die Listenansicht `Auslösefunktion'. In dieser Liste werden alle Programmfunktionen aufgelistet und im Moment sollten drei Funktionen zu sehen sein: pedigree, getpedigree und pedigree2memo. Doppelklicken Sie auf pedigree und diese Programmfunktion wird vom Knopf `Pedigree' ausgelöst. Drücken Sie schliesslich `Ok' und verlassen Sie den Struktureditor.

Wenn nun alles korrekt durchgeführt wurde, wird ein Druck auf den Knopf `Pedigree' einen Stammbaum der gerade angezeigten Person erzeugen. Wechseln Sie zu anderen Personen, um die verschiedenen Stammbäume zu sehen.

4.12 BeeBase programmieren, um die Kinder einer Person aufzulisten

Als Zusatz benötigt BeeBase weitere Datensätze. Sie sollten daher Ihre Geschwister hinzufügen. Wenn Sie keine haben, schreiben Sie einfach `Meine Pseudoschwester 1' und `Mein Pseudobruder 1', die natürlich die gleichen Eltern wie Sie haben.

Nun gehen Sie in den Programmeditor und geben folgendes zusätzlich ein, um ein weiteres Programm zu erstellen:

; Das Programm children zählt die Anzahl der Kinder einer Person.
; Zuerst definieren wir die Variablen, die wir benötigen,
; z.B. "names", das die Namen der Kinder enthält.

(DEFUN children ()
    (LET ( (names "") (count 0) (parent Person) )

    ; Über alle Datensätze in Tabelle Person wird folgendes durchgeführt:
    ; Wenn Variable parent als Vater oder Mutter in anderen Datensätzen
    ;    auftritt, dann:
    ;    - füge den Namen zur Variablen names hinzu
    ;    - erhöhe count um 1.

    (FOR ALL Person DO
        (IF (OR (= parent Father) (= parent Mother))
            (
                (SETQ names (+ names Name "\n"))
                (SETQ count (1+ count))
            )
        )
    )

    ; Anschließend schreiben wir das Ergebnis in Control.Result
    ; Wenn die Person keine Kinder hat, wird eine Zeichenkette ausgegeben. 
    ; Wenn er/sie Kinder hat, wird eine andere Zeichenkette ausgegeben.

    (SETQ Control.Result 
        (+ Person.Name (IF (> count 0)
            (+ " ist der stolze Vorfahr von " (STR count) " Kind(ern).")
            " hat (noch :-) keine Kinder."
        ))
    )

    ; Wenn die aktuelle Person Kinder hat, werden sie angehängt.

    (IF (<> count 0)
        (SETQ Control.Result 
            (+ Control.Result "\n\n"
                (IF (= count 1)
                    "Der Name des Kindes ist:"
                    "Die Namen der Kinder sind:"
                )
		"\n\n"
                names
            )
        )
    )

    ; Dies ist das Ende der Klammer vom Befehl LET.
    )

; Dies ist das Ende der Klammer vom DEFUN children.
)

Um Variablen zu erzeugen, verwenden wir den Befehl LET. Variablen, die mit dem Befehl LET erzeugt werden, sind lokal und nur sichtbar innerhalb der Klammern vom Befehl LET. Deshalb muss jeder Befehl, der auf diese Variablen zugreifen möchte, innerhalb dieser Klammern stehen.

Wir benötigen nun einen neuen Programmknopf, um das Programm auszuführen. Daher wechseln wir wieder in den Struktureditor und fügen einen Knopf in der Tabelle `Control' hinzu. Benennen Sie es `Children' und wählen Sie `children' als Programmfunktion, die ausgelöst werden soll.

Um Ordnung in das Layout der Tabelle `Control' zu bringen, wird es Zeit, Gruppen vorzustellen. Alle Objekte können in vertikal oder horizontal ausgerichteten Gruppen angeordnet werden.

Klicken Sie im Ansichtsbereich auf `Pedigree' und klicken dann bei gedrückter Shift-Taste auf `Children'. Danach klicken sie links daneben auf den Knopf `Gruppe'. Jetzt haben Sie zwei Programmknöpfe zusammen in einer vertikal ausgerichteten Gruppe angeordnet. Wir wollen sie jedoch horizontal angeordnet haben und doppel-klicken daher auf das `Vert.Gruppe', das im Anzeigebereich aufgetaucht ist. Dies öffnet ein Fenster, das es Ihnen erlaubt, die Einstellungen dieser Gruppe zu ändern. Setzen Sie die Überschrift auf `Programme' und aktivieren den Knopf `Horizontal'.

Wir können jetzt auch gleich den Namen von `Result' in `Control' entfernen. Doppelklicken Sie auf `Result' im Anzeigebereich und löschen Sie den Titel. Das Feld `Result' ist nach wie vor zu sehen, nur dessen Name ist nicht mehr sichtbar.

Um es leichter zu machen, wenn wir mehrere Programme oder Felder in `Control' hinzufügen wollen, sollten wir `Result' und `Programs' in eine vertikalen Gruppe fassen. Dazu wählen Sie `Programme' und `Result' aus und drücken dann auf `Gruppe'. Dies setzt `Programme' und `Result' in eine vertikalen Gruppe.

Verlassen Sie den Struktureditor und werfen Sie einen Blick auf das Ergebnis. Drücken Sie nun auf `Children', um die Anzahl und die Namen der Kinder der aktuellen Person zu sehen.

Dieses Beispiel könnte gut in ein gut ausgebautes Stammbaumprogramm erweitert werden. Wirkliche Grenzen dafür sind nur Ihre Fantasie und die Größe Ihrer Festplatte.