Go to the first, previous, next, last section, table of contents.


Tutorial

Erstellung einer Stammbaum-Datenbank

Dieses Kapitel ist ein kleines Tutorial, welches beschreibt, wie die Hauptelemente von MUIbase 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 im `Demos'-Verzeichnis Ihrer MUIbase-Installation finden.

Wie MUIbase arbeitet

Man kann sagen, daß MUIbase 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 enhalten 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.

Ein Projekt beginnen: Der Struktureditor

Um eine Datenbank zu erstellen, müssen Sie zuerst dessen Inhalt festlegen. In MUIbase wird dies im Struktureditor durchgeführt. Um zum Struktureditor zu gelangen, drücken Sie RAMIGA-s (rechte Amiga-Taste und den Buchstaben `s') oder durch Auswählen des Menüpunkts `Struktureditor ...' aus dem `Projekt'-Menü. Sie werden drei verschiedene Bereiche vorfinden:

`Tabellen'
In `Tabellen' ändern, löschen und fügen Sie die Tabellen hinzu, die Sie benötigen.
`Felder'
In `Felder' ändern, löschen und fügen Sie Felder hinzu. Diese Felder gehören jeweils zu einer oben erwähnten Tabelle.
`Anzeige'
In `Anzeige' legen Sie das Aussehen Ihrer Datenbank fest, d.h. wie es dargestellt werden soll.

Hinzufügen einer Tabelle

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

`Name'
Hier geben Sie den Namen der Tabelle an. Der Name muß 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 `Persontable' (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'
Jeder Aufruf des Benutzers, einen Datensatz hinzuzufügen oder zu löschen, kann durch eine Programmfunktion geregelt werden. An dieser Stelle setzt man diese Funktion, die jeweils aufgerufen wird. Nachdem wir bis jetzt noch keine Programmfunktion geschrieben haben, wird ein Blick in die Popup-Listen nichts anzeigen.

Nachdem alles getan ist, drückt man den Knopf `Ok' und wir haben unsere erste Tabelle namens Persontable.

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.

Darstellen des Projekts

Nach dem `Ok' 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, derzeit ist es `Persontable'. Wechseln Sie nun mit dem Auswahlfeld wieder zurück zum `Tabellenschema' und Sie können sehen, wie die Tabelle `Persontable' dargestellt wird. Im Moment wird sie nur als ein Panel mit einem Feld angezeigt.

Nun doppelklicken Sie auf das `Panel(Persontable)' am Beginn der Liste im Anzeigebereich und ein Fenster sollte erscheinen, in dem Sie einstellen können, wie das Panel angezeigt werden soll:

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

Nach dem `OK' doppelklicken 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 MUIbase im Datensatzmodus ist.
`Tastenkürzel'
Hier können Sie einen Buchstaben definieren, der zusammen mit RAMIGA verwendet wird, um zu diesem Feld zu springen, wenn MUIbase im Datensatzmodus ist.
`Home'
Veranlaßt 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 (RAMIGA-s oder `Struktureditor verlassen' im Menü `Projekt') und kehren in den Datensatzmodus zurück, um zu sehen, wie die Datenbank aussieht. Sie werden eine Überschrift sehen, die die Zeichenkette beinhaltet, den Sie im Anzeigebereich für das Panel eingegeben haben. Der Datensatzzähler sollte nun `#0/0' anzeigen, da wir noch keine Datensätze eingefügt haben. Dahinter ist der Filterknopf und zwei Fortschrittknöpfe. Unter all dem sollten Sie `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 Namen `Persontable' und das Zeichenkettenfeld den Namen `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 einer Sprechblase zu sehen bekommen.

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 wie es kurz selbst ausprobieren.

Wechseln sie wieder in den Struktureditor und fügen zwei weitere Felder zu `Persontable' 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 `Persontable' 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 zeigt auf die Tabelle `Persontable'.

Wie Sie vielleicht schon bemerkt gaben sollten, sind nun drei Felder im Anzeigebereicht sichtbar. Klicken Sie einmal auf `Father' und dann auf die Knöpfe `Rauf' 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'.

Datensätze hinzufügen

Jetzt sollten wir einige Datensätz hinzufügen. Verlassen Sie den Struktureditor. Um einen neuen Datensatz hinzuzufügen, drücken Sie einfach RAMIGA-n oder wählen Sie `Neuer Datensatz' aus dem Menü `Tabelle'. Der Cursor sollte nun automatisch in das Feld springen, bei dem wir vorhin im Anzeigebereich des Struktureditors `Home' gesetzt haben. Fügen Sie nun zwei Datensätze ein: einen mit dem Namen ihres Vaters in `Name' und einen mit dem Namen ihrer Mutter auch im Feld `Name' (2). 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 Listenansichtsknopf 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 Listenansichtsfenster 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 Cursor hoch/runter drücken.

Aber halt! Sie würden sagen, daß 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.

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, aber sie bleiben dennoch in der Datenbank, da sie nicht sichtbar sind.

Um den Filter einzugeben, drücken Sie LAMIGA-f oder wählen `Ändere Filter...' aus dem Menü `Tabelle'. Sie werden nun ein etwas merkwürdig aussehendes Fenster mit Unmengen von Operatoren sehen. Diese werden verwendet, um die Bedingungen zu setzen, die ein Datensatz erfüllen muß, damit er angezeigt wird.

In unserem kleinen Beispiel verwenden wir den Befehl LIKE, welcher einen Mustervergleich mit einem Feld ermöglicht. Drücken Sie rechts einmal auf den Knopf LIKE, doppelklicken 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 daß die ganze Zeichenkette schließlich (LIKE Name "*a*") enthält. Dies bedeutet, daß MUIbase nur die Datensätze anzeigt, die den Buchstaben `a' im Feld `Name' enthalten.

Drücken Sie nun `Ok' und Sie werden bemerken, daß 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. Gehen Sie in den Datensatzmodus, wenn Sie dies nun erledigt haben.

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.

Abfragen

Nachdem Sie die Filterfunktion kennengelernt haben, werden wir uns mit dem Abfragefeature von MUIbase beschäftigen. 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' oder drücken Sie `RAMIGA-*', 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. Es arbeitet sich durch die Datenbank und zeigt die Daten gemäß ihren Angaben an.
`Drucken...'
Druckt das Ergebnis der Abfrage aus.
`Laden und Speichern'
Lädt und Speichert jede ihrer Abfragen.

Das erste große Feld dient dem Eintragen 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 rechts ein. Im oberen großen Feld geben Sie folgendes ein:

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

Wenn Sie nun die Abfrage entweder mit RAMIGA-r oder über den Knopf `Ausführen...' abarbeiten lassen, wird MUIbase 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 Persontable WHERE
(AND (LIKE Name "*a*") (LIKE Name "*s*"))

Beachten Sie, daß wir immernoch den Befehl LIKE zur Auswahl von Datensätzen verwenden, die die Buchstaben `a' und `s' im Namen haben, aber der Befehl AND fordert, daß 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.

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 `Controltable' und setzen Sie die Anzahl der Datensätze auf `genau ein'. Schließen Sie das Fenster mit `Ok'. Klicken und halten Sie den Mausknopf auf der neuen Tabelle. Nun verschieben Sie den Eintrag etwas über die Mitte von `Persontable' und lassen den Mausknopf los. Im Bereich Tabelle erscheint nun `Controltable' oben und `Persontable' darunter.

Stellen Sie sicher, daß `Controltable' aktiviert ist und wählen `Neu' aus dem Bereich Felder. Ändern Sie den Typ auf `mehrzeiliger Text' und geben Sie dem Feld den Namen `Resultmemo'. Drücken Sie `Ok' und fügen ein weiteres Feld zu `Controltable' 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 den Knopf `Rauf' einmal drucken.

MUIbase 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 entweder durch Drücken von RAMIGA-p oder durch Auswählen von `Ändern...' aus dem Menü `Programm'. Der Editor hat drei Knöpfe:

`Kompilieren & Schließen'
MUIbase kompiliert das Programm und verläßt 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 MUIbase 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 `Resultmemo' anzeigt. Folgende Funktion `stammbaum' besteht genaugenommen aus drei Funktionen:

; Das Programm pedigree

(DEFUN pedigree ()
    (SETQ Controltable.Resultmemo
        (pedigree2memo (getpedigree Persontable NIL) 0 3)
    )
)

; Das Programm getpedigree

(DEFUN getpedigree (person:Persontable 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))
        )
        ""
    )
)

Dies sind die fertigen Programmfunktionen. Geben Sie sie ein und achten Sie darauf, daß alle Klammern auch da stehen, wo sie sein sollen. Zu viele oder zu wenig Klammern sind beliebte Fehler, wenn MUIbase Ihre Programme vorkompiliert. Die Fehlermeldung von MUIbase wird in diesem Fall vermutlich `Syntax Error' lauten. Drücken Sie `Kompilieren & Schließen' und hoffen wir, daß MUIbase das Fenster schließt, was bedeutet, daß MUIbase keine Fehler während des Kompilierens gefunden hat.

Machen Sie sich zunächst keine Gedanken darüber, was die Befehle im einzelnen bedeuten. Wie bei allen Programmiersprachen benötigt es etwas Zeit und Übung, um sie zu meistern.

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 `Controltable' aus dem Tabellenbereich und doppelklicken 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 schließlich `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.

MUIbase programmieren, um die Kinder einer Person aufzulisten

Als Zusatz benötigt MUIbase 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, die eine Person besitzt.
; Zuerst definieren wir die Variablen, die wir benötigen,
; wie z.B. "children", das auf "\n\n\" gesetzt wird.

(DEFUN children ()
    (LET ( (children "\n\n") (nrofchildren 0) (currentperson Persontable) )

    ; Über alle Datensätze in Persontable wird folgendes durchgeführt:
    ; Wenn die aktuelle Person als Vater oder Mutter in anderen Datensätzen
    ;    auftritt, dann:
    ;    - füge den Namen zur Variable children hinzu
    ;    - erhöhe die Anzahl der Kinder um 1.

    (FOR ALL Persontable DO
        (IF (OR (= currentperson Father) (= currentperson Mother))
            (
                (SETQ children (+ children Name "\n"))
                (SETQ nrofchildren (+ nrofchildren 1))
            )
        )
    )

    ; Anschließend schreiben wir das Ergebnis in das mehrzeilige Textfeld
    ;    von Controltable: Resultmemo
    ; Wenn die aktuelle Person keine Kinder hat, wird eine Zeichenkette
    ;    ausgegeben.
    ; Wenn er/sie Kinder hat, wird eine andere Zeichenkette ausgegeben.

    (SETQ Controltable.Resultmemo
        (+ Persontable.Name (IF (> nrofchildren 0)
            (+ " ist der stolze Vorfahr von " (STR nrofchildren) " Kind(ern).")
            " hat (noch :-) keine Kinder."
        ))
    )

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

    (IF (<> nrofchildren 0)
        (SETQ Controltable.Resultmemo
            (+ Controltable.Resultmemo "\n\n"
                (IF (= nrofchildren 1)
                    "Der Name des Kindes ist:"
                    "Die Namen der Kinder sind:"
                )
                children
            )
        )
    )

    ; 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 muß jeder Befehl, der auf diese Variablen zugreifen möchte, innerhalb dieser Klammern stehen.

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

Um Ordnung in das Layout der Tabelle `Controltable' 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 sie mit SHIFT 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 doppelklicken 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 `Resultmemo' in `Controltable' entfernen. Doppelklicken Sie auf `Resultmemo' im Anzeigebereich und löschen den Namen. `Resultmemo' ist nach wie vor zu sehen, aber dessen Name ist nicht mehr sichtbar.

Um es leichter zu machen, wenn wir mehrere Programme oder Felder in `Controltable' hinzufügen wollen, sollten wir `Resultmemo' und `Programs' in eine vertikalen Gruppe fassen. Seien Sie sicher, daß sie nur die Gruppe `Programs' und `Resultmemo' ausgewählt haben und drücken Sie `Gruppe'. Dies setzt `Programs' und `Resultmemo' 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 Ihre Fantasie und die Größe Ihrer Festplatte.

(Anm.d.Übersetzers: Durch die etwas eigenwillige Sprache des Tutorialschreibers wird der Text einigen etwas merkwürdig vorkommen. Dennoch bietet er eine gute Übersicht über die wesentlichsten Funktionen von MUIbase.)


Go to the first, previous, next, last section, table of contents.