\renewcommand{\reftextbefore}{auf der vorherigen Seite}
\renewcommand{\reftextfacebefore}{auf der gegenüberliegenden Seite}
\renewcommand{\reftextafter}{auf der nächsten Seite}
\renewcommand{\reftextfaceafter}{auf der gegenüberliegenden Seite}
\renewcommand{\figurename}{Listing}

\begin{document}

\title{König Artus' Tafelrunde und König Minos}
\ifx\shorttitle\undefined\else
\shorttitle{Artus' Tafelrunde und König Minos}
\fi

\author{Martin Bitter}

\begin{document}
\maketitle

\begin{center}
Mein Umgang mit xbigforth's GUI--Generator
\end{center}

\emph{Für Rechtschreibfans: Der englische König Arthur heißt im Deutschen meist Artus.
Der Genitiv im Englischen wäre also Arthur's und im Deutschen Artus' oder
Artusens (veraltet).}

% ----------------------------------------------------------------------------------
\begin{figure*}[b]
\begin{quote}
\listinginput[1]{1}{2010-0203/ka.fs}
\end{quote}
\caption{\label{Tafelrunde:ka.fs}\texttt{KingArthur}: König Artus' Tafelrunde als Forth--Konsolenprogramm}
\end{figure*}
% ----------------------------------------------------------------------------------

\section{Die Tafelrunde}

Begegnet ist mir die Aufgabenstellung auf der Wanderausstellung Mathematikum
[1], die im Jahr der Mathematik den Menschen der Republik Mathematik anschaulich
und faszinierend machen sollte. In eine runde Platte waren 7 oder 9 Leuchten mit
Tastern eingelassen. Auf Tasterdruck änderten jeweils drei Leuchten ihren
Zustand zwischen an und aus. Die Geschichte um König Artus habe ich mir als
(hoffentlich) Bereicherung ausgedacht.

\begin{multicols}{2}

Bekannt ist Artus' Tafelrunde. Dadurch, dass die Tafel (der Tisch)\footnote{das
Wort Tisch wiederum kommt von dem griechischen Diskus, und bezeichnet eine runde
(vormals Baum--) Scheibe. Eine Tafel ist, wie heute noch in vielen Schulen zu
sehen, rechteckig. \emph{Tafelrunde} wörtlich genommen ist also ein Widerspruch in
sich selbst.} rund war, gab es keinen hervorgehobenen Sitzplatz --- alle waren von
der Sitzordnung her gleich. Der König (Artus) selbst speiste an einem anderen
Tisch, um die Ordnung der Gleichen nicht zu stören. Die Anzahl der Ritter, die
an dem Tisch saßen, schwankte im Lauf der Zeit und je nach Überlieferung
zwischen 12 und 16 (siehe Wikipedia [2]). Hier in meinem Programm können es vier bis 12
Ritter sein. Die Ritter sind bereit, sich an einen rechteckigen\footnote{dies
hat programmtechnische Gründe} Tisch zu setzen. Dabei haben sie eine recht
verschrobene Art, Platz zu nehmen. Sobald ein Ritter Platz nimmt oder ihn
verlässt, hat dies Auswirkungen auf die benachbarten Sitze. Ist ein Nachbarsitz
unbesetzt, so setzt sich dort ein weiterer Ritter hin. Ist der Nachbarsitz
allerdings schon besetzt, so wird der dort sitzende Ritter ihn räumen. Es können
bei drei nebeneinander stehenden freien Stühlen sich drei Ritter gleichzeitig
setzen. Andererseits kann ein sich setzender Ritter zwei Ritter von ihren
Stühlen drängen. Genau das Gleiche gilt, wenn ein Ritter seinen Sitzplatz räumt.
Sind die Nachbarsitze besetzt, so werden die betreffenden Ritter sie verlassen.
Sind sie leer, so werden sich dort Ritter niederlassen. Etwas mathematischer und
klarer ausgedrückt: Jeder Stuhl kann zwei Zustände haben: \textsf{leer} (\texttt{false}) 
oder \textsf{besetzt} (\texttt{true}).
Wird der Zustand eines Stuhles geändert (durch Räumen oder Besetzen), so ändern
sich die Zustände der beiden benachbarten Stühle.

Wie oft nimmt ein Ritter Platz, wenn die Tafel für vier, fünf, \ldots\  12 Ritter
gedeckt ist? Für sechs, neun und 12 Plätze ist die Lösung einfach: jeder setzt
sich einmal hin --- wenn man es klug anstellt.

Die anderen Fälle kann man mit dem Programm \texttt{KingArthur} ausprobieren. Eine
ANS-94--Version für bigforth oder gforth ist schnell geschrieben (siehe \figurename\ \vref{Tafelrunde:ka.fs}).
Die Klammern in
Zeile 2 und 7 für gforth bitte entfernen\footnote{Die Klammern in Zeile 7 bügeln
ein unerwartetes Verhalten von \texttt{mod} in gforth wieder glatt.}. Mit Eingabe einer
Ziffer wird der entsprechende Platz in der unteren Reihe be-- oder ent--setzt. Die
Nachbarn folgen der Regel. Bedenken muss man nur eines: eine runde Tafel wird
hier auf eine gerade Anordnung projiziert. D.~h.\ die beiden Eckplätze
beeinflussen sich gegenseitig (der \emph{Kreis} ist ja genau hier geschlossen).
\setcounter{figure}{0}
\renewcommand{\figurename}{Screenshot}
Vergleiche \figurename\ \vref{Tafelrunde:ScreenshotText}: Hier wurde zuerst Taste 2 und dann die Taste 4 gedrückt.

% ----------------------------------------------------------------------------------
\begin{figure*}[t]
\begin{center}
\verb|  0    1    2    3    4    5    6    7  |\\
\verb|  0  255  255    0  255  255    0    0  |
\end{center}
\caption{\label{Tafelrunde:ScreenshotText}\texttt{KingArthur} nach dem Drücken der Tasten \texttt{2} und \texttt{4}}
\end{figure*}
% ----------------------------------------------------------------------------------

Es gibt eine kluge Lösungsstrategie, die die Ritter anwenden können. Bei vier
Rittern setze man sich in folgender Reihenfolge auf die Stühle: \texttt{1}, \texttt{3}, \texttt{2} und \texttt{4}.
Fertig!

% ----------------------------------------------------------------------------------

\begin{figure*}[b]
\begin{center}
\framebox{\begin{minipage}{0.98\textwidth}
\section{Über bigforth \ldots}
bigforth wurde von Bernd Pasysan in den 1990ern geschrieben und seitdem weiter gepflegt. Es läuft unter Linux und Windows (mit Einschränkungen). bigforth ist ein reines Konsolenprogramm, d.~h.\ ohne graphischen Schnick--schnack. Aber es bringt einen Bruder (eine Erweiterung) mit sich: xbigforth. Ein bigforth, das unter und mit dem graphischen Fenstersystenm X--Windows funktioniert.

bigforth kann jederzeit von Bernd Paysans Seite [3] heruntergeladen werden. Linux--Laien sei die Debian--Version empfohlen. Jene, die mit Linux und SVN vertraut sind, werden sich stets auf die aktuellste Version berufen können. Andererseits können auch Laien wie ich in den Genuss der SVN--Version kommen: (das Paket \texttt{subversion} muss installiert sein)

\texttt{svn co http://www.forth-ev.de/repos/bigforth}

danach in das frisch erzeugte (oder überschriebene) Verzeichnis bigforth wechseln und 

\begin{alltt}
autoconf\\
./configure\\
make install
\end{alltt}

eingeben. 

In der Datei \texttt{/usr/local/lib/bigforth/.xbigforthrc} bzw.\ \texttt{.bigforthrc} können jetzt Suchpfade und persönliche Einstellungen geändert werden.
\end{minipage}}
\end{center}
\end{figure*}
% ----------------------------------------------------------------------------------

\section{Bei Hofe}
Wirklich fertig? In der Überschrift ist von zwei Königen die Rede! Artus und \ldots\  Minos! Minos --- wer ist denn das? Ein uralt kretischer König, ein Bezwinger der Meere und Nennvater des Minotaurus, den zwar Minos' Frau gebar, dessen Vater er (Minos) aber nicht war. Und \ldots\  und \ldots\  und.

Minos nun kann mir helfen, das gleiche Problem, das mit einer kargen Textausgabe auf einem Screen gelöst werden konnte, mit mehr Aufwand und komplexeren Befehlsketten mit einem schönen GUI zu versehen. Minos war nämlich nicht nur der besagte König, Minos ist auch eine Forth--Bibliothek --- in xbigforth  --- die eine Unmenge an grafischen Elementen zur Verfügung stellt, um \emph{schöne} bunte Bilderoberflächen zu gestalten.

Buttons, Sliders, Radioknöpfe, Textfelder, Menus --- alles was man für ein \emph{schönes} GUI benötigt, ist vorhanden. Ja sogar fertige Leinwände und ein Editor gehören dazu. All' diese grafischen Elemente sind Forthwords, genauer Methoden. Sie lassen sich wie jedes word aufrufen. Parameter werden auf dem Stack übergeben. Man kann den Code für ein solches GUI word für word, Methode für Methode schreiben --- oder einen Gutteil der Arbeit dem GUI--Editor überlassen, der bei bigforth mitgeliefert wird.

\section{Nicht malen --- denken!}
Dieser GUI--Editor heißt Theseus und ist es wert, oft verwendet zu werden. Diejenigen, die ihn kennen, verwenden ihn gerne. Er führt dennoch (teilt er dies mit Forth?) das Dasein eines Mauerblümchens. Der vorliegende Artikel soll dazu ermuntern, ihn einmal auszuprobieren. 

Im Gegensatz zu anderen GUI--Editoren, die ich kenne (alte Erinnerungen aus der Windowswelt), verfolgt Theseus kein malendes, sondern ein logisches Konzept. In der Windowswelt erklickte ich einen Button, fasste und positionierte ihn dann mit der Maus. Beim Einfügen weiterer Buttons musste ich dann gelegentlich den ersten Button verschieben \ldots\  gelegentlich sogar oft.

Bei Theseus ist dies anders --- und nach der Eingewöhnungszeit empfindet man dies sogar als Erleichterung. Hier legt man nicht die Position einzelner Elemente fest, sondern die logische Anordnung. Es heißt nicht Button1 hierhin und Button2 dahin, sondern Button1 und Button2 neben(über)einander, den \emph{Rest} erledigt Theseus für mich. Ich muss mich zwingen, vor dem Basteln des GUIs die Logik --- einigermaßen --- zu überlegen. Daraus folgt eine Beschränkung: Ich kann (noch)\footnote{Ewald Rieger soll dazu in der Lage sein, „\ldots\  aber für eine Einführung ist das zu komplex.“} nicht die Lage einzelner Elemente frei bestimmen.

% ----------------------------------------------------------------------------------

\begin{figure*}[t]
\begin{center}
\framebox{\begin{minipage}{0.98\textwidth}
\section{Fallstricke}

Die Einstellungsdatei \texttt{.xbigforthrc} ist eine ganz normale Forthquelle, die interpretiert wird. Falls eine Eingabe zu einem Fehler führt, wird nicht nur forthtypisch an der Stelle des Fehlers abgebrochen, sondern der geänderte Pfad wird verworfen und der in der .bigforth angegebene Pfad verwendet.
bigforth unterscheidet seine Quelldateien anhand der Endungen: \texttt{.f} bedeutet: altes Screenformat 16 Zeilen a 64 Zeichen \textbf{ohne} LF oder CR Zeichen. \texttt{.fs} steht für ein (kürzeres) Fließtextformat mit CR und LF. Beim Laden werden zwischen den Formaten Unterschiede gemacht. \texttt{*.f}--Dateien werden über \emph{alte} Blockbefehle (\texttt{make use load}) angesprochen --- \texttt{*.fs}--Dateien über das modernere \texttt{include}: Also bei der Verwendung externer Editoren darauf achten, wie man seine Entwürfe benennt.
Tippfehler verzeiht bigforth im Allgemeinen. Groß--Klein--Schreibung spielt (default) keine Rolle. Außer beim Laden von Dateien: \texttt{Include Dateix.fs} legt zuerst ein internes word \texttt{Dateix.fs} an, sucht dann diese Datei in den Suchpfaden und lädt sie. Passiert hier ein Tippfehler z.~B., \texttt{include dateix.fs}, wird ein word \texttt{dateix.fs} erzeugt und die entsprechende Datei nicht gefunden (die heißt ja \texttt{Dateix.fs} mit großem \texttt{D}). Selbst ein nachfolgendes richtiges \texttt{include Dateix.fs} führt nun zu einer Fehlermeldung, weil das interne word \texttt{dateix.fs} angesprochen wird, das ja ins \emph{Leere} zeigt. Abhilfe: Neustart.

Natürlich ist es legitim, die von Theseus erzeugten \texttt{*.m}--Dateien mit einem externen Editor (im Textformat) zu bearbeiten. Manchmal ist das einfach schneller und bequemer (z.~B.\ Pfadangaben bei Icons ändern). Aber Vorsicht! Theseues öffnet eine solche Datei nicht nur, sondern er lädt sie, d.~h., sie wird interpretiert. Das Ergebnis dieser Interpretation wird im Theseusfenster angezeigt und eben \textbf{nur} dieses Ergebnis wird beim Speichern auch gesichert. Fügt man also Kommentar\textbf{zeilen} ein, so sind diese verloren. Schlimmer noch, hat man einen (vorerst unsichtbaren) Fehler provoziert, so findet man nach dem Abspeichern nur noch eine fast leere Rumpfdatei vor. Also: Immer Sicherheitskopien machen --- oder keine externen Editoren verwenden.
Manchmal kann es vorkommen, dass die Eingabemaske des Inspectors größer ist als der angezeigte Bereich. Ich habe so manchmal übersehen, dass noch einiges eingegeben werden musste. Also immer schön darauf achten, ob rechts im Inspector ein Slider auftaucht.
\end{minipage}}
\end{center}
\end{figure*}
% ----------------------------------------------------------------------------------

\section{Schritt für Schritt}
Als Appetitmacher dient mir König Artus' Tafelrunde. In einem ersten Teil, soll dieses Programm mit einem GUI versehen werden und erst einmal nur laufen. In einem zweiten kann es durch GUI--Standardelemente (Menu) erweitert werden. 
Ich möchte nicht den Umgang mit Theseus erklären\footnote{Hierzu sei die Lektüre der Dokumentation zu bigforth empfohlen, die ebenfalls bei Bernds Site zu bekommen ist. s.o.}, sondern zeigen, wie ich mit ihm arbeite --- vielleicht kann ja der eine oder andere, der mir Schritt für Schritt folgt, daraus für sich einen Gewinn ziehen. Wie immer stehen die Quelldateien zum Download bereit. Zu jedem Schritt gibt es je eine Datei \texttt{ka1.m}, \texttt{ka2.m}, \texttt{ka3.m} etc.\ Wer mag, kann diese laden und testen, wenn sie im folgenden Artikel erwähnt wird.

\section{Präludium}

Vorüberlegungen: Ich stelle die Tafelrunde als Grundriss dar. Gerne würde ich die Sitzplätze in einem Kreis anordnen, aber Theseus ist rechtwinklig angelegt. Also setzte ich die \emph{Ritter} an einen rechteckigen Tisch. Weiter: Ich möchte die Kopfseiten des Tisches besetzen, also benötige ich in meinem Grundriss drei Reihen: je eine Reihe mit Sitzplätzen an jeder Längsseite und den Tisch selbst mit den Sitzplätzen an den Kopfseiten. 
\parpic[r]{\includegraphics[width=0.27\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img2}}
Ich könnte pro Aufgabenstellung (vier, fünf, \ldots\  12 Sitzplätze) ein je eigenes Spielfeld (Dialog) basteln und dieses je nach Fall laden \ldots\  zu viel Arbeit. Also benötige ich eine Methode, Sitzplätze zu einem bestehenden Spielfeld hinzuzufügen oder zu entfernen. Da weiß ich (noch) nicht, wie das geht.

% ----------------------------------------------------------------------------------
\begin{figure*}[t]
\begin{center}
\framebox{\begin{minipage}{0.98\textwidth}
\section{Der Classbrowser}
Die Minos--Elemente sind Forthobjekte. Um sie, ihre Abhängigkeiten und Hierarchien, zu erkunden, kann man das altbekannte \texttt{words} benutzen. So listet die Eingabe \texttt{Spielfeld words} nicht nur die Unterobjekte und Funktionen von Spielfeld auf, sondern zeigt auch an, welche von \emph{außen} erreichbar sind (public) und welche nicht (private).

Einen schnelleren und informativeren Überblick bietet der Classbrowser im Menu \texttt{File} von xbigforth. Dort werden alle zur Zeit geladenen Methoden in einem hierarchischen Baumgraphen angezeigt und farblich gekennzeichnet (wobei ich noch nicht ganz durchschaue, was die Farben bedeuten). 
\end{minipage}}
\end{center}
\end{figure*}
% ----------------------------------------------------------------------------------

% ----------------------------------------------------------------------------------
\begin{figure*}[b]
\begin{center}
\framebox{\begin{minipage}{0.98\textwidth}
\section{Spielen}

Die \texttt{.m}--Datei erzeugt eine Klasse Spielfeld, die ich von außen nur bedingt ansprechen kann. Nachdem Laden von \texttt{ka0.m} kann ich zwar \texttt{Spielfeld words} eingeben, aber \texttt{Spielfeld Stuhl1 words} führt zu einem Busfehler.
Will ich \emph{spielen}, so muss ich mir erst einmal ein Object der Klasse \texttt{Spielfeld} erzeugen, auf das ich dann zugreifen kann. Das macht die Sequenz:

\begin{alltt}
Spielfeld ptr Spiel\\
Spielfeld new bind Spiel
\end{alltt}

mit \texttt{Spiel self 0 s"{} Spielwiese"{} open-component} öffne ich nun dieses Object und kann spielen.
\texttt{Spiel Stuhl1 words} zeigt mir jetzt die Methoden, die \texttt{Stuhl1} beherrscht.
Ich mache nun die Minos--Worte mit \texttt{minos also} sichtbar.
(Vorsicht beim \emph{Spielen}, es befriedigt zwar die schnelle Neugier, aber nicht alle Worte, die man damit erzeugt, sind später innerhalb der \texttt{.m}--Datei verwendbar!)
\end{minipage}}
\end{center}
\end{figure*}
% ----------------------------------------------------------------------------------


\section{Möge die Übung gelingen!}

xbigforth starten und im Menu \texttt{File} das Item \texttt{Theseus} anklicken. Im nun auftauchenden Fenster (siehe Doku zu bigforth) einmal (oben rechts) auf \texttt{vbox} klicken. Im Dialogfenster erscheint nun ein rot hervorgehobenes, durchge--x--tes Quadrat, dem wir den Namen (\texttt{Name:}) \texttt{Spielfeld} geben. Als Titel erhält es: (\texttt{Title:}) \texttt{König Artus' Tafelrunde}. Ich habe eine \texttt{vbox} (v=vertical) gewählt, weil ich innerhalb dieser box drei weitere Boxen senkrecht untereinander anordnen will. Das ist mit drei schnellen Klicks auf \texttt{hbox} erledigt. \texttt{hbox} (h=horizontal) wähle ich, weil in den drei Reihen die Elemente Tisch bzw.\ Stühle nebeneinander angeordnet werden sollen. Jetzt aktiviere ich durch Anklicken die obere der drei hboxen, und \ldots\  mhm, wie stelle ich jetzt einen leeren Sitzplatz dar?

\parpic[r]{\includegraphics[width=0.14\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img1}}Genaues Ansehen der Menus zeigt mir, dass einige Elemente mit Icons (das sind kleine Bilder) verbunden werden können: Icons eignen sich gut, \emph{versteckte} Buttons anzulegen. Darunter verstehe ich Buttons, die nicht 3D--artig hervorgehoben werden, sondern sich vom Hintergrund nicht abheben. Im Menu \texttt{Buttons} gibt es u.~a.\ \texttt{Icon-Button}, \texttt{Icon}, \texttt{Big-Icon} und im Menu \texttt{Toggles} gibt es: \texttt{Icon}, \texttt{Flip-Icon} und \texttt{Iconbutton}. Ich probiere mal alle der Reihe nach aus. Draufgeklickt und das Ergebnis gesichtet. Es bleiben zwei Möglichkeiten für \emph{versteckte} Buttons offen: Unter den \texttt{Buttons} ist es \texttt{Big-Icon} und bei den \texttt{Toggles} ist es: \texttt{Iconbutton}. Beide bieten nicht nur Platz für ein Icon, sondern auch für einen String, (die Beschriftung des Buttons). Jetzt benutze ich die Möglichkeit, die Elemente, die ich durch wildes Herumklicken erzeugt habe, wieder zu entfernen: Indem ich bei gedrückter Groß--Taste (Shift) ein Element mit der linken Maustaste anklicke, wird es aus dem Dialog entfernt. (Es ist nicht wirklich gelöscht, sondern liegt auf einem Objektstack, von dem es mit Groß--Taste+rechtem Mausklick wieder abgerufen werden kann. Eine copy--Funktion für Elemente gibt es nicht.) Wer jetzt neugierig ist, kann das Projekt schon mal speichern. Entweder über das Menu \texttt{File} oder über eines der kleinen Symbole in der linken Symbolleiste (mit der Maus darüber fahren, die aufpoppenden Texte erklären die Funktion). Wichtig ist es, nicht die Endung \texttt{.m} zu vergessen. Ich wähle hier als Dateinamen \texttt{ka0.m}. Das kann als \textbf{K}eine \textbf{A}hnung, oder als \textbf{K}ing \textbf{A}rthur gelesen werden.

\section{First Sight}
Im xbigforth--Fenster jetzt ein \texttt{include ka0.m} eingegeben und (hoffentlich) ein \texttt{ok} erhalten? Dann kann es weiter gehen mit \texttt{Spielfeld open-app}. Auf dem Bildschirm erscheint jetzt unser Spielfeld so, wie wir es von Theseus her kennen. Ein bisschen damit spielen: vergrößern, verkleinern, ziehen und bewegen geht, die Max--Min--Schließ--Felder tun es auch. Ich kann mir mit dem Classbrowser (siehe auch Kasten \emph{Der Classbrowser}\/) die internen Möglichkeiten von Spielfeld anschauen. :-)

\section{Stuhlgang?}
Jetzt weiter: Wieder Theseus gestartet und die Datei \texttt{ka0.m} geladen. Meine Überlegung ist ja, die Plätze (Ritter) um einen rechteckigen Tisch zu platzieren. Bei vier Rittern ist das: einer oben, einer rechts, einer links und einer unten.

\parpic[r]{\includegraphics[width=0.27\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img3}}Dazu klicke ich in die obere der drei hboxen (sie wird rot umrandet). Jetzt wähle ich aus dem Menu \texttt{Buttons} ein \texttt{Big-Icon}. In dem unteren Bereich des Theseus--Fensters öffnet sich eine Eingabemaske (Inspector genannt) in der ich dem neuen Objekt aus der Klasse Big--Icon einen Namen (\texttt{Stuhl1}) gebe. Das ist wichtig, weil ich dieses Objekt später nur (?) über seinen Namen ansprechen kann. Die Buttonbeschriftung brauche ich nicht, also lösche ich im Inspector jeden Inhalt, der zum Eingabefeld \texttt{String:} gehört. Jetzt muss ich noch einen (zu meinen Suchpfaden in \texttt{.xbigforthrc} passenden) Pfad angeben, der auf eine Bilddatei im \texttt{.png}--Format zeigt. Ich entscheide mich für \texttt{icons/piece0}\footnote{Wenn ich keinen Pfad angebe, sucht Minos die \texttt{.png}--Datei im Ordner \texttt{icons}}, eines der vielen Bilder, die im bigforth Paket enthalten sind.

Nun die zweite hbox anklicken und genauso wie oben zwei Plätze einfügen (\texttt{Stuhl4} und \texttt{Stuhl2}). Dann in der unteren hbox wieder einen Platz (\texttt{Stuhl3}) einfügen. (Speichern (\texttt{ka1.m}) und in bigforth laden: \texttt{include ka1.m} und dann \texttt{Spielfeld open-app}). 

\section{Bitte setzen!}
Das muss schöner werden, aber zuerst will ich \emph{spielen} (siehe Kasten \emph{Spielen}\/). Wie kann ich die Icons ändern? Ein Blick in die \texttt{ka1.m}--Datei zeigt mir die Wordsequenz, mit der die Big--Icons erzeugt werden\footnote{Auch der Classbrowser und Spielfeld words, sowie die Quelltexte sind hilfreich.}. Offenbar legt das word \verb|icon"| einen Stack für die Icons an, übergeben wird letztendlich eine Adresse. Leider führt die Eingabe von \verb|icons" icons/piece0"| zu einem \texttt{don't know icon} bzw.\ \texttt{compile only icon} --- aber ich kann es in einer Definition verwenden: \verb|: platz ( -- adr ) icon" icons/piece1"|. 

\parpic[r]{\includegraphics[width=0.14\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img4}}
Mithilfe von \texttt{Spielfeld words} bzw.\ \texttt{Spiel words} sehe ich, dass mein Objekt \texttt{Spielfeld} über die Unterobjekte \texttt{Stuhl1} bis \texttt{Stuhl4} verfügt. Ich weiß, dass diese Big--Icons sind. Über diese verrät mir der Classbrowser bzw. \texttt{Spiel Stuhl1 words}, dass sie eine Methode \texttt{assign} haben. Jetzt wird’s spannend. Ich gebe ein \texttt{platz Spiel Stuhl1 assign} und das gelbe Icon wird durch ein rotes ersetzt. Ha: ich bin König! Ich kann was! Nämlich Icons ändern.
Nun baue ich mir Bilder im \texttt{.png}--Format mit Gimp (oder einem x--beliebigen Zeichenprogramm) und mache sie mir leicht verfügbar mit 
\begin{verbatim}
: leer ( -- adr ) icon" leer.png" ; 
\end{verbatim}
und 
\begin{verbatim}
: voll (-- adr ) icon" voll.png" ;
\end{verbatim}
. Das Wort 
\begin{verbatim}
: Sitz1 ( adr -- ) spiel Stuhl1 assign ; 
\end{verbatim}
erlaubt mir dann im xbigforth--Fenster solche Dinge wie \texttt{voll Sitz1} bzw.\ 
\texttt{leer Sitz1}\footnote{Man beachte die Tücken des Spielens! (siehe Kasten \emph{Fallstricke})}. Da ich die Objekte \texttt{Stuhl1}, \texttt{Stuhl2}, \texttt{Stuhl3} und \texttt{Stuhl4} (noch) nur über ihre Namen ansprechen kann, muss ich mir für jeden Platz ein solches Wort schreiben. Also definiere ich mir analog zu \texttt{Sitz1} die Worte \texttt{Sitz2}, \texttt{Sitz3} und \texttt{Sitz4}.

\section{Sitzordnungen}
\parpic[r]{\includegraphics[width=0.2\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img5}}Genug gespielt! Es geht ernsthaft weiter mit Theseus/Minos. Wie schon erwähnt kann ich (noch?) nicht im laufenden Programm neue Big--Icons in den Spielfeld--Dialog einfügen bzw. entfernen. Also entwerfe ich (mit Gimp) eine dritte \texttt{.png}--Datei in der Größe der beiden Icons \texttt{leer.png} und \texttt{voll.png}, die nur einen transparenten Hintergrund enthält, und nenne sie \texttt{weg.png}. Nun öffne ich Theseus, lade \texttt{ka1.m}, aktiviere durch Anklicken das erste Big--Icon (\texttt{Stuhl1}) und klicke 4--mal darauf. Es werden vier neue Big--Icons in einer Reihe nebeneinander erzeugt. Jedes versehe ich mit der \texttt{voll.png} und lösche den Inhalt des Textfeldes. Ähnlich verfahre ich mit dem untersten Big--Icon (\texttt{Stuhl3}). Nun habe ich zwölf Big--Icons, die die zwölf möglichen Stühle in der Tafelrunde darstellen. Ich aktiviere jedes einzeln im Uhrzeigersinn und benenne es neu: \texttt{Stuhl1} bis \texttt{Stuhl12} (das hilft mir, später den Überblick zu bewahren) (\texttt{ka2.m}).

\parpic[l]{\includegraphics[width=0.08\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img6}}Zufriedenstellend sieht das ja nicht aus. Die Position der Icons ist durch Minos festgelegt --- aber nach meinen Vorgaben. Wie sag ich ihm, was ich will? In diesem Fall helfen die glue--Objekte. Obwohl \emph{to glue} kleben bedeutet, sind die glue--Objekte kein reiner \emph{Festkleber} sondern auch Verdränger. Da ich im Nachhinein etwas einfüge, ist es wichtig darauf zu achten, wohin meine neuen Objekte platziert werden. Darüber entscheiden die vier Buttons links im Theseus--Fenster und das darunterliegende Pfeil--Feld. Ich wähle: \texttt{Add after current Objekt}. Dann öffne ich das \texttt{Glues}--Menu, klicke auf den ersten Platz (aktiviere \texttt{Stuhl1}) und klicke auf das Item \texttt{Glue}. Dadurch wird ein Glue--Object rechts des jeweiligen Big--Icons eingefügt. Genauso verfahre ich mit \texttt{Stuhl2}, \texttt{Stuhl3}, \texttt{Stuhl4} und mit \texttt{Stuhl11}, \texttt{Stuhl10}, \texttt{Stuhl9}, \texttt{Stuhl8}. Bei all diesen ändere ich an der Standardeinstellung der Glues im Inspector nichts, d.~h., ich lasse sie auf \texttt{fill}. Die Big--Icons \texttt{Stuhl5}, \texttt{Stuhl6} und \texttt{Stuhl7} erhalten keinen Glue an ihrer rechten Seite. Zum Schluss aktiviere ich \texttt{Stuhl12} und füge dort ein weiteres Glue--Objekt ein, dem ich diesmal im Inspector die Eigenschaft \texttt{fillll} zuweise. Dieser (oder dieses?) Glue drängt nun die beiden Stühle \texttt{Stuhl6} und \texttt{Stuhl12} weit nach außen. Abstände berechnen oder gar Pixel zählen muss ich nicht! Mit diesem Ergebnis kann ich leben (\texttt{ka3.m}). (Wer mir bis hierher gefolgt ist, kann den Glue zwischen \texttt{Stuhl12} und \texttt{Stuhl6} durch ein Rechteck ersetzen, das den Tisch darstellt.)

\section{Was geht?}
Zwischenstand: Ich habe eine Anordnung von Big--Icons (Stühlen), die mir einigermaßen gefällt. Ich kann jedem \texttt{Stuhl} drei Zustände zuweisen: besetzt (voll), unbesetzt (leer) und verschwunden (weg).

\section{Weg da!}
\parpic[r]{\includegraphics[width=0.27\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img7}}Nun will ich dem Spieler die Möglichkeit geben, die Anzahl der Stühle zu variieren. Das kann später über ein Menu geschehen, hier und jetzt löse ich das über Buttons. Bei geöffnetem \texttt{ka3.m} klicke ich solange auf \texttt{Up in hierarchy} (links, Vierfachpfeil), bis ich in der obersten Ebene bin, wähle (links) \texttt{add after last in box} und füge eine vierte hbox ein. In diese füge ich (aus dem Menu \texttt{Buttons}) einen einfachen Button ein. Einen Namen gebe ich ihm nicht, da ich ihn im Programm nicht ansprechen muss. Wie schon bei den Stühlen beschrieben, füge ich acht weitere Buttons und dazwischenliegende Glues ein. In die Textfelder der Buttons trage ich die Zahlen 4 bis 12 ein (\texttt{ka4.m}). 

\section{\ldots\  und Action!}

\renewcommand{\figurename}{Listing}
\parpic[l]{\includegraphics[width=0.2\textwidth]{2010-0203/Koenig20Arthurs20Tafelrunde-img8}}Optisch bin ich jetzt fertig --- es fehlen noch die Aktionen, die durch Klicken auf die Stühle (Big--Icon) und Zahlen (button) ausgelöst werden. Jetzt kommen 5 weitere Symbole links unter der Objektleiste der Theseus--Oberfläche ins Spiel: \texttt{Dialog Editor}, \texttt{Edit Variables}, \texttt{Edit Methods}, \texttt{Show Dialog} und \texttt{Dialog Menu} (die Namen werden bei Mauskontakt angezeigt). Ich benutze davon \texttt{Edit Variables}, \texttt{Edit Methods} und \texttt{Dialog Menu}. Nach einem Klick auf \texttt{Edit Variables}, gebe ich
\verb|Variable leds#| (hier soll die Anzahl der jeweils aktiven Stühle gespeichert werden) ein. Damit wird eine Variable \verb|leds#| erzeugt, die zum Objekt \texttt{Spielfeld} gehört. Davon kann ich mich leicht überzeugen, indem ich die \texttt{ka5.m}--Datei in xbigforth lade (\texttt{include ka5.m}) und \texttt{Spielfeld words} eintippe. Dies zeigt mir, dass diese Variable im Bereich \texttt{public} liegt, das heißt, sie kann von \emph{außen} z.~B.\ mit Spielfeld \verb|leds# @| angesprochen werden.

Unter \texttt{Edit Methods} öffnet sich ein Texteditorfeld in dem ich --- wie im ganz normalen Forth --- words definieren kann. Diese words sind Methoden des jeweiligen Dialog(objektes) im \emph{privaten} Bereich.

% ----------------------------------------------------------------------------------
\begin{figure*}[t]
\begin{footnotesize}
\begin{quote}
\listinginput[1]{1}{2010-0203/Spielfeld.fs}
\end{quote}
\end{footnotesize}
\caption{\label{Tafelrunde:Spielfeld.fs}\texttt{Spielfeld.fs}}
\end{figure*}
% ----------------------------------------------------------------------------------

Unter den Items des kleinen \texttt{Dialog}--Menus klicke ich auf \texttt{Edit impl}. Theseus erzeugt nun aus dem Namen meines Dialoges (\texttt{Spielfeld}) einen Dateinamen \texttt{Spielfeld.fs} und versucht, eine solche Datei zu öffnen, findet sie nicht und beschwert sich (in der xbigforth Konsole) darüber. Nachdem ich diese Datei mit normalen Mitteln (außerhalb) angelegt habe, wird sie gefunden und in einem Editor geöffnet. An diesen Namensvorschlag muss ich mich nicht halten, in dem Textfeld hinter \texttt{Edit impl} kann ich bei Bedarf Pfad-- und Dateinamen ändern. In dieser Datei können wiederum alle Forthbefehle des xbigforth--Systems benutzt werden. Definitionen werden in der aktuellen Wortliste abgelegt und sind ohne Objekt--Methodenbedingte Einschränkungen nutzbar. Ich definiere mir einige allgemeine Dinge in \texttt{Spielfeld.fs} (siehe auch \figurename\ \vref{Tafelrunde:Spielfeld.fs}): die Höchstanzahl der darzustellenden Stühle, Icons für einen nicht vorhandenen, einen besetzten und einen leeren Stuhl, ein Array, in dem alle möglichen Sitzordnungen als Bitfelder gespeichert sind, und zwei Worte, die die Stühle zwischen besetzt (\texttt{ein}) und unbesetzt (\texttt{aus}) wechseln. Das Wort \verb|Zustand_schalten| schaut zuerst nach, ob der Stuhl an der betreffenden Position überhaupt vorhanden ist ($\ne 0$), und schaltet nur zwischen den Zuständen \texttt{1} und \texttt{2} um. Dabei hinterlegt es ein Flag, das ein erfolgreiches Umschalten anzeigt. Das Wort \texttt{umschalten} benutzt eben dieses Flag, um zu entscheiden, welche benachbarten Stühle ihren Zustand ändern müssen.

\section{Klick mich!}
Ein Programm reagiert meist auf innere oder äußere Ereignisse. Oft sind dies Benutzereingaben. Ein Programm mit einem GUI soll auf Mausklicks reagieren. Hier liegt nun eine Stärke von Minos/Theseus. Im Theseus--Editor kann ich zu jedem Element mit normalen Forth--Worten festlegen, auf welche Ereignisse und wie das jeweilige Element reagieren soll.

Dazu habe ich unter \texttt{Edit--Methods} (siehe oben) folgende Worte definiert:

\begin{description}
\item{\tt led ( icon Stuhl -- ) \verb|\|}\\
weist dem Icon/Stuhl mit der Nummern n ein Bild aus dem Iconstack zu 

\item{\tt schalten ( Zustand Stuhl -- ) \verb|\|}\\
weist dem Icon mit der Nummer n abhängig vom Zustand n ein Bild zu.

\item{\tt leds ( n -- ) \verb|\| Stuhlbild}\\
liest das zur Anzahl der Stühle passende Stuhlbild aus und erzeugt die entsprechenden Zustände für die einzelnen Stühle.

\item{\tt anzeigen ( -- ) \verb|\| Stühle zeichnen}\\
zeichnet alle Stühle, auch die \emph{unsichtbaren} (besetzt, frei, unsichtbar)

\item{\tt Spielzug ( n -- ) \verb|\|}\\
ändert betroffene Stühle und zeichnet die gesamte Sitzordnung neu.
\end{description}

Die Nummern--Buttons auf dem Spielfeld (4 bis 12) sollen die jeweilige Stuhlanordnung zeichnen.

Deshalb aktiviere ich im Theseus--Editor den Button 4 und gebe in seinem Codefeld (unten im Inspector) \texttt{4 leds} ein. Entsprechend verfahre ich mit den Buttons 5 bis 12. Das war's! Nun führen die Nummern--Buttons beim Anklicken die gewünschte Aktion aus. (\texttt{ka5.m} Zeile 30 bis 62)

Als (vorläufig) Letztes bleibt nun noch, den \emph{Stühlen} ihre Aktion zuzuweisen. Der Reihe nach aktiviere ich \texttt{Stuhl1} bis \texttt{Stuhl12} und gebe in ihrem Codefeld (siehe Inspector) \texttt{0 Spielzug}, \texttt{1 Spielzug} etc.\ ein. (\texttt{ka6.m} Zeile 65 bis 83).

\section{Fertig!}
Jetzt kann im geöffneten xbigforth--Konsolenfenster mittels \texttt{include ka6.m main} das fertige Spiel geladen und gespielt werden. Viel Spaß!

\section{Ausblick}
Falls es zu einem Nachfolgeartikel kommt, zeige ich, wie ich ein Menu gestalte und wie ich es schaffe, die Stühle in einem Kreis aufzustellen.
Schreibt mir, ob Ihr Interesse an einer Fortsetzung habt.

\section{Nachwort}
Bernd Paysan ist einer der ersten Leser dieses Artikels. Er sandte mir seinen Vorschlag, bei dem er die Einstellungen der Stühlezahl über ein Sliderobjekt gelöst hat. Damit der geneigte Leser dies nachvollziehen kann, füge ich die Datei \texttt{ka7.m} zum Download bei.

\end{multicols}

\section{Links}
{}[1] Wanderausstellung Mathematikum: \url{http://www.mathematikum-unterwegs.de/}\\
{}[2[ Wikipedia zu Tafelrunde: \url{http://de.wikipedia.org/wiki/Tafelrunde}\\
{}[3] Bernd Paysans Bigforth--Seite: \url{http://www.jwdt.com/~paysan/bigforth.html}\\


\framebox{\begin{minipage}{0.98\textwidth}
\section{Einladungen}
Über die Menuepunkte \texttt{edit impl} bzw.\ \texttt{edit decl} wird die Reihenfolge, in der Dateien (nach)geladen werden, festgelegt.
Eine \texttt{.fs}--Datei kann jederzeit eine \texttt{.m}--Datei laden.
Ebenso kann eine \texttt{.m}--Datei eine \texttt{.fs}--Datei laden. Dies entweder nachdem sie ihre Definitionen bzw. Zeiger darauf kompiliert oder bevor sie selbst irgendetwas definiert. 
Dies hat Auswirkungen darüber, welche Programmteile wie auf die jeweiligen Worte zugreifen können.
\end{minipage}}

\vfill
\begin{center}
\includegraphics[height=5cm]{2010-0203/Tafelrunde}\\
{\footnotesize Gral in der Mitte von Artus' Tafelrunde, französische Handschrift des 14. Jhs\\ Quelle: Wikimedia.org}
\end{center}

\newpage

\section{Programm 0 --- \texttt{ka0.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka0.m}
\end{quote}
\end{small}

\section{Programm 1 --- \texttt{ka1.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka1.m}
\end{quote}
\end{small}

\section{Programm 2 --- \texttt{ka2.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka2.m}
\end{quote}
\end{small}

\section{Programm 3 --- \texttt{ka3.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka3.m}
\end{quote}
\end{small}

\section{Programm 4 --- \texttt{ka4.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka4.m}
\end{quote}
\end{small}

\section{Programm 5 --- \texttt{ka5.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka5.m}
\end{quote}
\end{small}

\section{Programm 6 --- \texttt{ka6.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka6.m}
\end{quote}
\end{small}

\section{Programm 7 --- \texttt{ka7.m}}
\begin{small}
\begin{quote}
\listinginput[1]{1}{2010-0203/ka7.m}
\end{quote}
\end{small}

\end{document}