% Studienarbeit von Ilona Hachmann
%
% Universitaet Hamburg
% Fachbereich Informatik
% Arbeitsbereich DBIS
%
% Kapitel: Entwicklung graphischer Benutzeroberflaechen mit Tycoon und StarView

\chapter{Entwicklung graphischer Benutzeroberfl"achen mit {\ty} und {\sv}}
\label{demos}

Die Erstellung einer graphischen Benutzeroberfl"ache kann auf drei Wegen erfolgen:\\

$\rhd$ implizit: Generische Editoren zeigen Daten an.\\
$\rhd$ explizit: Die Funktionen der Graphikbibliotheken werden direkt angesprochen.\\
$\rhd$ interaktiv: Der Aufbau der Oberfl"ache wird mit einem Werkzeugkasten unterst"utzt.\\


Der explizite Weg erfolgt bei {\ty}/{\sv} "uber die Bibliothek {\em svenv}. "Uber die Bibliothek {\em sveditenv} ist der implizite Weg gew"ahlt. Eine interaktive Unterst"utzung liefert der {\de} von {\sv}. Es l"a"st sich pauschal nicht ein Weg als der beste festlegen. Je nach Komplexit"at der Fragestellung l"a"st sich entscheiden, welcher Weg f"ur welches graphische Problem geeignet ist.\\
Dieses Kapitel stellt die drei Wege vor, wobei der Schwerpunkt auf dem expliziten Weg liegt.


                    \section{Der implizite Weg} 

Die Bibliothek {\em sveditenv} ist der Nachfolger der Editorbibliothek {\em editenv} \cite{mus94}. Sie erm"oglicht das schnelle Entwerfen von typsicheren generischen Editoren. Allen so entworfenen Editoren ist ein eine einheitliche Pr"asentation ({\em look}) und Dialogsteuerung ({\em feel}) gemeinsam. Diese Editoren sind beliebig kombinierbar und zeigen sowohl atomare als auch hierarchisch strukturierte Werte des {\ty}-Objektspeichers an. Die Werte in den Editoren k"onnen vom Anwender ver"andert werden. Die Menge der Editoren l"a"st sich in drei Klassen einteilen: die Basiseditoren, die Verbundeditoren und die Massendateneditoren. {\ty} Basistypen werden mit Basiseditoren, {\ty} Typkonstruktoren mit Verbundeditoren und Massendaten mit Massendateneditoren angezeigt. In Abschnitt~\ref{bspbasis} findet sich ein Beispiel f"ur einen Basiseditor f"ur Zeichenketten. Abbildungen anderer Editoren finden sich in \cite{mus94}.\\ 
Das {\em editenv} basiert auf {\n}. Das {\em sveditenv} auf {\sv}. Die Abbildung~\ref{sveditenv} zeigt, wo diese beiden Bibliotheken einzuordnen sind. Die Schnittstellen der beiden Editorbibliotheken sind sich sehr "ahnlich. Kleine Unterschiede in den Funktionen der Bibliothek {\em sveditenv} zu  {\em editenv} sind in der Verwendung der {\sv} Bibliothek begr"undet. Die Darstellung der Editoren nach einem erfolgten Funktionsaufruf unter Verwendung der {\em sveditenv} ist nicht ganz identisch mit der Darstellung der Editoren, die mit {\em editenv} erzeugt worden sind, vom Grundaufbau jedoch "ahnlich.  

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=10cm \epsfysize=6cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/sveditenv.epsf}
\end{center}
\caption{Der implizite Weg}
\label{sveditenv}
\end{figure}


\subsection{Aufbau der Editoren}
Alle Editoren besitzen einen gleichen Rahmen, der eine Basisfunktionalit"at zur Verf"ugung stellt. Neben einer Titelzeile befinden sich in jedem Editor eine feste Anzahl von Kn"opfen. Die oberen drei Kn"opfe lassen sich als Men"u auffassen. Welche Eintr"age, Subeintr"age und Funktionalit"at sich hinter den Kn"opfen verbirgt ist in Tabelle~\ref{funktionalitaet} aufgef"uhrt und erl"autert. Nicht alle Funktionen stehen allen Editoren zur Verf"ugung. Nicht verf"ugbare Funktionen sollen vom Anwender nicht ausgew"ahlt werden k"onnen und sind deshalb als inaktiv markiert.
\begin{table}[hbt]
\begin{center}
\leavevmode
\begin{tabular}{|l|l|l|l|}   \hline
{\bf Men"u} &{\bf Eintrag}&{\bf Subeintrag}&{\bf Funktionalit"at}\\ \hline \hline
Quit        &             &                &Schlie"st Editor mit Nachfrage.\\ \hline
Edit        &Edit         &                &"Offnet Editor mit ausgew"ahltem Element.\\
            &New          &New             &F"ugt Element an aktueller Position ein.\\
            &             &New Behind      &F"ugt Element hinter aktueller Position ein.\\
            &Cut          &Cut             &L"oscht aktuelles Element bzw. setzt Grundwert.\\
            &             &Cut All         &L"oscht alle Elemente.\\
            &             &Cut Selected    &L"oscht ausgew"ahlte Elemente.\\
            &Copy         &                &Kopiert in Puffer.\\
            &Paste        &                &Kopiert aus Puffer.\\ \hline
View        &Properties   &                &Grundeinstellungen setzen.\\
            &Path\dots    &                &Zeigt Pfad zum Editor an.\\ \hline
\end{tabular}
\end{center}
\caption{Funktionalit"at des Men"us der Editoren}
\label{funktionalitaet}
\end{table}

Die unteren zwei Kn"opfe (der {\em Apply}- und {\em Reset}-Knopf) dienen dem Datenaustausch zwischen Anwendung und Editor. Mit dem {\em Apply}-Knopf wird der aktuelle Wert aus dem Editor in die Datenstruktur bzw. Variable unter Einhaltung von eventuellen Integrit"atsbedingungen zur"uckgeschrieben. Der {\em Reset}-Knopf liest den aktuellen Wert aus der betreffenden Datenstruktur bzw. Variablen heraus und zeigt ihn in dem Editor an.

\subsection{Beispiel eines Basiseditors}
\label{bspbasis}
Dieses Beispiel erzeugt auf einfache Weise einen Editor f"ur Zeichenketten. Das nachfolgende {\ty}-Kodefragment erzeugt den in Abbildung~\ref{myfirsteditor} dargestellten Editor f"ur Zeichenketten.
\begin{xple}
\k{import}
  editor (* from sveditenv *)

\k{let var} name = ''Meyer''
\k{let var} continue = true
\k{let} quit = \k{fun}() continue := false
\k{let} dispatch = \k{fun}() continue 

\k{let} stringEditor = editor.newString(''My first Editor''
   \k{let} get = \k{fun}() name
   \k{let} set = \k{fun}(new :String) name := new)

editor.display(stringEditor quit editor.somewhere) (* display editor somewhere *)
editor.waitAndDispatch(dispatch)  (* start event loop *)
\end{xple}

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=6cm \epsfysize=3cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/myFirstEditor.ps}
\end{center}
\caption{Editor zum Anzeigen von Zeichenketten}
\label{myfirsteditor}
\end{figure}



\subsection{Aufbau der Editorbibliothek}
Die Editorbibliothek {\em sveditenv} umfa"st acht Module, die sich vier Schichten zuordnen lassen (siehe Abbildung~\ref{4schichten}). Die Abbildung gibt nicht die komplexen Importbeziehungen innerhalb der Editorbibliothek wieder.

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=7cm \epsfysize=7cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/editorbib.epsf}
\end{center}
\caption{Struktur der Editorbibliothek}
\label{4schichten}
\end{figure}

Die oberste Schicht ({\em Library Interface}) bildet das Modul {\em editor}; nur "uber dieses Modul ist ein Zugriff auf die Editorbibliothek m"oglich. Es erh"alt alle wichtigen Definitionen der anderen Module. In der {\em Generic Editor Implementation}-Schicht befinden sich die Module {\em simple\-Editors, record\-Editors} und {\em bulk\-Editors}, die eigentlichen Implementationen der Editoren. Ein Protokoll, "uber das die Editoren angesprochen werden, ist in der {\em Data Structures and Common Functions}-Schicht mit dem Modul {\em editorRep} definiert. In der untersten Schicht ({\em Utility Modules}) finden sich die Hilfsmodule {\em editorUtil, editorWindow} und {\em editorGlobal}. Eine genaue Beschreibung der Module findet sich in \cite{mus94}.


                   \section{Der explizite Weg}
Beim expliziten Weg (siehe Abbildung~\ref{svenv}) greift das Anwendungsprogramm direkt auf die {\sv}-Bibliothek zu. Es stehen alle Klassen und Funktionen zur Verf"ugung. 
\begin{figure}[ht]
\begin{center}
\leavevmode
\epsfxsize=10cm \epsfysize=6cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/svenv.epsf}
\end{center}
\caption{Der explizite Weg}
\label{svenv}
\end{figure}

Die folgenden Beispiele sollen Grundlagen f"ur eine Programmierung in {\tl} unter Verwendung der {\sv} Bibliothek liefern. Die Beispiele sind dem {\sv} Handbuch~\cite{busch93} entnommen und an {\tl} angepa"st worden.
Die ersten drei Beispiele bauen aufeinander auf. Der vollst"andige Quelltext der Beispiele findet sich in Anhang~\ref{beispiele}.

             \subsection{HelloWorld}
Dieses Beispiel wurde bereits in Abschnitt~\ref{helloW} schon einmal kurz vorgestellt.\\ 
Das Hauptfenster wird mit dem Konstruktor {\em new2} aus der Klasse {\em workWindow} erzeugt.

Das eigentliche Fenster wird in der Funktion {\em main} angelegt, wobei das {\em stylebit} {\em WB\_APP} daf"ur sorgt, da"s das Fenster zum Hauptfenster der Anwendung wird. Durch das {\em stylebit} {\em WB\_STDWORK} erh"alt das Hauptfenster alle f"ur ein Hauptfenster m"oglichen Eigenschaften: es ist verschiebbar, in der Gr"o"se ver"anderbar, minimierbar, maximierbar und schlie"sbar. Der Fenstertext wird "uber die Funktion {\em setText} aus der Klasse {\em window} gesetzt. Mit der Funktion {\em show} aus der Klasse {\em window} wird das Fenster sichtbar geschaltet. Die Ereignisverwaltung ({\em event loop}) wird mit der Funktion {\em execute} aus der Klasse {\em application} gestartet.

\begin{xple}
     \k{let} aMainWin = workWindow.new2(window.nilT 
                                        int.bitOr(window.WB\_STDWORK window.WB\_APP))
     window.setText(aMainWin ''StarView Hello World, mein erstes Fenster'')
     (* make window visible *)
     window.show(aMainWin)
     (* start event loop *)
     application.execute()
\end{xple}

Damit innerhalb des Fensters der Text ''Keine Panik'' erscheint, mu"s die Funktion {\em paint} aus der Klasse {\em window} "uberschrieben werden. Das "Uberschreiben wird in {\tl} durch die Funktion {\em setPaint} simuliert.\\ Innerhalb der "uberschriebenen Funktion wird die Ausgabefunktion {\em outputDevice.drawText} mit den Koordinaten und dem gew"unschten Text aufgerufen. Da noch kein Koordinatenpunkt existiert, wird einer mit {\em new3} aus der Klasse {\em point} konstruiert.

\begin{xple}
window.setPaint(aMainWin 
       \k{fun}(pEvt :rectangle.T) :\k{Ok}
         \k{begin}
            outputDevice.drawText(aMainWin point.new3(50 50) ''Keine Panik'')
         \k{end})
\end{xple}

                    \subsection{Painter}
Dieses Beispiel (siehe Abbildung~\ref{exa2}) zeigt neben den Grundelementen einer {\sv}-Anwendung ein Men"u, Verarbeitung von Mauseingaben und die Ausgabe mit einem der Ausgabewerkzeuge der Klasse {\em outputDevice} - dem {\em Pen}.\\

\begin{figure}[ht]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=10cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/example2.ps}
\end{center}
\caption{Das Hauptfenster des Beispiels ''Painter''}
\label{exa2}
\end{figure}

Dieses Programm bietet folgende Funktionalit"at:
 \begin{itemize}
  \item Der Benutzer kann mit Hilfe der Maus Linien in dem Fenster zeichnen.
  \item F"ur den {\em Pen} kann "uber ein Men"u eine Farbe und eine Strichbreite ausgew"ahlt werden.
  \item Nach der Fenstermen"uwahl {\em quit} ist "uber eine Messagebox zu entscheiden, ob die Anwendung tats"achlich beendet werden soll.
 \end{itemize}

Inhaltlich ergeben sich vier Teilbereiche, die im folgenden erl"autert werden:
\begin{itemize}
\item Aufbau und Umgang mit Men"us
\item Verarbeitung von Mauseingaben
\item Realisierung des Zeichenvorgangs
\item Realisierung der Messagebox
\end{itemize}

\subsubsection*{Das Men"u:}
Men"us sollen den Benutzer in der Kommunikation mit der Anwendung unterst"utzen. Ein Men"u enth"alt Eintr"age, die die M"oglichkeit der Einflu"snahme auf den Ablauf der Anwendung aufzeigen. Nach Auswahl eines Eintrages wird die damit verbundende Aktion ausgel"ost.


Zun"achst sichtbar ist die Men"uleiste, die nach dem Erzeugen und Zuordnen zu einer Anwendung am oberen Rand unter der Titelzeile des Hauptfensters (beim Mac am oberen Rand des Bildschirms) erscheint. Die Men"uleiste (siehe Abbildung~\ref{menuleiste}) enth"alt im Beispiel die Men"u-Eintr"age ({\em Items}) {\em Color} und {\em Width}. Die unterstrichenen Buchstaben ''C'' und ''W'' sind Tastenk"urzel, mit denen die Eintr"age mit der Tastatur statt der Maus ausgew"ahlt werden k"onnen.\\

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=11cm \epsfysize=0.8cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/menuleis.ps}
\end{center}
\caption{Die Men"uleiste des Beispiels ''Painter''}
\label{menuleiste}
\end{figure}

Beide Men"ueintr"age besitzen Popupmen"us.\\

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=3cm \epsfysize=3cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/menupop2.ps}
\end{center}
\caption{Das Popupmen"u {\em Color}}
\label{menupop}
\end{figure}

Zun"achst werden die Popupmen"us und die Men"uleiste (siehe Abbildung~\ref{menupop}) erzeugt:
\begin{xple}
    \k{let} aColorMenu = menu.newPopup1()
    \k{let} aWidthMenu = menu.newPopup1()
    \k{let} aMenuBar = menu.newBar1()
\end{xple}

"Uber benutzerdefinierte Konstanten ({\em Identifiers, ID's}) f"ur Men"ueintr"age kann auf die Eintr"age zugegriffen werden:

\begin{xple}
  \k{let} MID\_PENCOLOR    = 10
  \k{let} MID\_PENRED        = 11
  \k{let} MID\_PENBLUE      = 12
  \k{let} MID\_PENYELLOW = 13

  \k{let} MID\_PENWIDTH   = 20
  \k{let} MID\_PENSMALL    = 21
  \k{let} MID\_PENMEDIUM = 22
  \k{let} MID\_PENTHICK    = 23
\end{xple}

Eintr"age in Men"uleisten erfolgen "uber die Funktion {\em insertItem}, Folge-Men"ueintr"age in Pop\-up\-men"us "uber die Funktion {\em insertItem2}. Die Konstante {\em MENU\_APPEND} sorgt daf"ur, da"s neue Folge-Men"ueintr"age (in Popupmen"us) an den bisher letzten Folge-Men"ueintrag geh"angt werden. Men"ueintr"age sind markierbar, wenn das Attribut {\em MIB\_CHECKABLE} angegeben ist. Die Tastenk"urzel werden mit einer Tilde vor dem betreffenden Buchstaben festgelegt. Alle genannten Funktionen und das Attribut stammen aus der Klasse {\em menu}.

\begin{xple}
    menu.insertItem(aMenuBar MID\_PENCOLOR ''$\sim$Color'')

  ...

    menu.insertItem2(aColorMenu MID\_PENRED ''$\sim$Red'' 
                            menu.MENU\_APPEND menu.MIB\_CHECKABLE)
    menu.insertItem2(aColorMenu MID\_PENBLUE ''$\sim$Blue''
                            menu.MENU\_APPEND menu.MIB\_CHECKABLE)
    menu.insertItem2(aColorMenu MID\_PENYELLOW ''$\sim$Yellow''
                            menu.MENU\_APPEND menu.MIB\_CHECKABLE)
\end{xple}


Popupmen"us werden mit der Funktion {\em changePopupMenu} aus der Klasse {\em menu} der Men"uleiste zugeordnet. Die Funktion {\em changeAppMenu} aus der Klasse {\em application} erkl"art ein Men"u zur Men"uleiste der Anwendung.

\begin{xple}
    menu.changePopupMenu(aMenuBar MID\_PENCOLOR aColorMenu)
  ...
    application.changeAppMenu(aMenuBar)
\end{xple}


Die Funktion {\em pushSelectHdl} aus der Klasse {\em menu} bindet "uber einen {\em link} die benutzerdefinierten Funktionen {\em colorSelect} und {\em widthSelect} an den Aufruf aus der Men"uleiste.

\begin{xple}
\k{let} colorSelect(win :T  pMenu :menu.T) :link.Handler = 
  \k{fun}() :\k{Ok}
   ...    (* realization of menu item Color *)

menu.pushSelectHdl(aColorMenu
                            link.new(colorSelect(aMainWin aColorMenu)))
\end{xple}

Sind Men"ueintr"age als markierbar definiert ("uber das Attribut {\em MIB\_CHECKABLE}), besteht die M"oglichkeit, mit der Funktion {\em checkItem} aus der Klasse {\em menu} und Angabe der ID, diesen Men"ueintrag mit einer Markierung zu versehen. Mit dem gesetzten Parameter {\em false} in der Funktion {\em checkItem2} aus der Klasse {\em menu} werden bestehende Markierungen gel"oscht. Die Funktion {\em getCurItemId} aus der Klasse {\em menu} liefert die ben"otigte ID des momentan selektierten Men"ueintrags.

\begin{xple}
\k{let} colorSelect(win :T  pMenu :menu.T) :link.Handler = 
  \k{fun}() :\k{Ok}
    \k{begin}
      (* if there is a mark, delete it *)
      \k{if} win.nColor != 0 \k{then}
         menu.checkItem2(pMenu win.nColor false)
      \k{end}
       (* the tuple component nColor gets the ID of chosen color *)
       win.nColor:= menu.getCurItemId(pMenu)
       (* the chosen color is checked *)
       menu.checkItem(pMenu win.nColor)
      ... 
    \k{end}
\end{xple}


\subsubsection*{Die Mauseingaben:}
Neben der Tastatur ist die Maus gerade bei Anwendungen mit Fenstern ein wichtiges Eingabemedium. Zu den Aktionen einer Maus geh"oren der Mausklick mit einer Maustaste und das Bewegen und Positionieren des Mauszeigers in einer Anwendung, z.B. auf einen Knopf. Nicht alle Plattformen unterst"utzen alle drei Maustasten (der Mac z.B. unterst"utzt nur eine Maustaste). {\sv} bietet hier Funktionen, die die Besonderheiten der Systeme sowie der verwendeten Maustypen ber"ucksichtigt. Alle Aktionen k"onnen unter allen Voraussetzungen ausgef"uhrt werden.


In dem Beispielprogramm hat der Benutzer die M"oglichkeit, mit Hilfe der Maus Linien in dem Anwendungsfenster zu zeichnen. Bevor der Zeichenvorgang ausgel"ost wird, m"ussen erst die vom Benutzer erfolgten Mausaktionen von der Anwendung verarbeitet werden.\\

Die Funktionen, die die Mausaktionen festlegen, m"ussen in der Klasse {\em window} "uberschrieben werden (siehe Abschnitt~\ref{ereignisbe} "uber Ereignisbearbeitung). Von Interesse in diesem Beispiel sind der {\em MouseButtonDown-Handler} und der {\em MouseMove-Handler}. Der {\em MouseButtonDown-Handler} wird gerufen, wenn eine Maustaste gedr"uckt wird, der {\em MouseMove-Handler} bei jeder Mausbewegung "uber dem Fenster.\\
In der vom Programmierer "uberschriebenen Funktion {\em MouseButtonDown} mu"s die Position des Mauszeigers im Fenster ermittelt werden, damit Anfangs- und Endpunkt der zu zeichnenden Linie bestimmt werden kann:
\begin{xple}
    window.setMouseButtonDown(aMainWin 
      \k{fun}(mEvt :mouseEvent.T) :\k{Ok}
        \k{begin}
          ...
          t.aLastPoint:= mouseEvent.getPosPixel(mEvt)
        \k{end})
\end{xple}

Mit der "uberschriebenen Funktion {\em MouseMove} wird "uberpr"uft, ob es sich bei der Mausbewegung um die gew"unschte Art der Bewegung {\no} Bewegung mit gedr"uckter Taste {\no} handelt:
\begin{xple}
    window.setMouseMove(aMainWin 
      \k{fun}(mEvt :mouseEvent.T) :\k{Ok}
        \k{if} mouseEvent.isLeft(mEvt) \k{then}
        ... 
        \k{end})
\end{xple}


\subsubsection*{Die Ausgabe (Realisierung des Zeichenvorgangs):}
Alle Ausgabefunktionen stellt die Klasse {\em outputDevice} zur Verf"ugung. Diese Ausgabefunktionen arbeiten mit verschiedenen Ausgabewerkzeugen, f"ur die eigene {\sv}-Klassen existieren. F"ur Textausgaben wird die Klasse {\em Font} verwendet, f"ur Graphik (Punkte, Linien, Figuren etc.) die Klasse {\em Pen} und zum Ausmalen von Fl"achen mit einer Farbe und einem Muster die Klasse {\em Brush}.


In diesem Beispiel wird zum Zeichnen einer Linie zwischen zwei Punkten die Funktion {\em drawLine} aus der Klasse {\em outputDevice} verwendet. Die Ausgabe erfolgt "uber das Ausgagewerkzeug {\em Pen}.\\
Ein {\em Pen} ist ein Zeichenstift, der Spuren in einem Fenster hinterl"a"st. {\em Pens} haben drei Attribute: Strichbreite, Farbe und Linientyp (durchgezogen, gestrichelt etc.).\\

Der {\em Pen} erh"alt durch die Funktionen {\em pen.changeColor} und {\em pen.changeWidth} die "uber das Men"u ausgew"ahlte Farbe und Breite. Durch die Funktion {\em outputDevice.changePen} wird der neu ausgew"ahlte {\em Pen} der aktuelle {\em Pen}. Als Farbe wird ein Objekt der Klasse {\em color} "ubergeben:
\begin{xple}
\k{let} colorSelect(win :T  pMenu :menu.T) :link.Handler = 
  \k{fun}() :\k{Ok}
    \k{begin}
      \k{if} win.nColor != 0 then
         menu.checkItem2(pMenu win.nColor false)
      \k{end}
       win.nColor:= menu.getCurItemId(pMenu)
       menu.checkItem(pMenu win.nColor)
      \k{let} aPen = outputDevice.getPen(win.win)
      (* if chosen color red then *)
      \k{if} win.nColor == MID\_PENRED \k{then}
         (* change pencolor to red *)
         pen.changeColor(aPen color.new2(color.COL\_RED))
      \k{elsif} win.nColor == MID\_PENBLUE \k{then}
         pen.changeColor(aPen color.new2(color.COL\_BLUE))
      \k{else}
         pen.changeColor(aPen color.new2(color.COL\_YELLOW))
      \k{end}
       (* new chosen color is applied to pen *)
       outputDevice.changePen(win.win aPen)
    \k{end}
\end{xple}


\subsubsection*{Die Messagebox:}
H"aufig ergeben sich Situationen in einer Anwendung, die eine Nachricht an den Benutzer erforderlich machen, z.B. wenn nicht gen"ugend Speicherplatz vorhanden ist, eine angegebene Datei nicht existiert, bei Sicherheitsabfragen etc. Damit sichergestellt ist, da"s der Benutzer die Nachricht auch erh"alt, wird die Anwendung unterbrochen, eine Messagebox angezeigt und erst nach Beantworten der Messagebox wieder freigegeben. Messageboxen sind daher modale Dialogboxen. {\sv} stellt verschiedene Messageboxen zur Verf"ugung. Die {\em InfoBox} f"ur Informationszwecke, die {\em WarningBox} f"ur Warnungen an den Benutzer, die {\em ErrorBox} f"ur Fehlermeldungen und die {\em QueryBox} f"ur Nachfragen. Die Boxen unterscheiden sich im Informationssymbol und Anzahl der Kn"opfe. Die Messagebox in Abbildung~\ref{querybox} zeigt das Informationssymbol ''?'' und zwei Kn"opfe


Dieses Beispiel benutzt eine Messagebox, um nachzufragen, ob die Anwendung tats"achlich beendet werden soll. Es wird also ein Objekt der Klasse {\em queryBox} erzeugt. Diese {\em QueryBox} enth"alt einen {\em Ok}- und einen {\em Cancel}-Knopf (vergleiche Abbildung~\ref{querybox}).\\ 

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=3cm \epsfysize=3cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/exitpaint.ps}
\end{center}
\caption{Die Messagebox zum Verlassen von ''Painter''}
\label{querybox}
\end{figure}

Die Messagebox wird mit der Funktion {\em messBox.execute} aktiviert. Diese Funktion liefert an die Anwendung den Kode des Knopfes, der vom Benutzer ausgew"ahlt wurde. In diesem Beispiel wurde der OK-Knopf mit der Funktion {\em systemWindow.setClose} verbunden, wodurch die Anwendung mit einer Nachfrage beendet wird. Diese Funktion "uberschreibt die Funktion {\em systemWindow.close}, die trotzdem innerhalb der neuen definierten Funktion mit alter Funktionsweise aufgerufen werden kann.
\begin{xple}
systemWindow.setClose(t.win
      \k{fun}() :Bool
        \k{begin}
          \k{let} aBox = 
               queryBox.new(t.win  int.bitOr(window.WB\_OK\_CANCEL window.WB\_DEF\_OK)
                             ''Exit Paint'')
          \k{if} messBox.execute(aBox) == messBox.RET\_OK \k{then}
             systemWindow.close(t.win)
          \k{else}
             false
          \k{end}
	       \k{end})
\end{xple}

                     \subsection{PainterWithAboutBox}
\label{painterwithaboutbox}

Dieses Beispiel (siehe Abbildung~\ref{exa3}) ist eine Erweiterung des vorigen Beispiels. Zwei weitere {\sv}-Klassengruppen werden eingef"uhrt:
die Dialog-Klassen und die Control-Klassen.\\

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=10cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/exa3.ps}
\end{center}
\caption{Das Hauptfenster des Beispiels ''PainterWithAboutBox''}
\label{exa3}
\end{figure}

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=11cm \epsfysize=0.8cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/menu3.ps}
\end{center}
\caption{Die Men"uleiste des Beispiels ''PainterWithAboutBox''}
\label{menuleiste3}
\end{figure}

Die Funktionalit"at vom Beispiel {\em Painter} bleibt erhalten. Dieses Beispiel wird um einen Eintrag in der Men"uleiste (siehe Abbildung~\ref{menuleiste3}), der zwei Eintr"age enth"alt (siehe Abbildung~\ref{file3}), erweitert. Wird der Eintrag ''About...'' ausgew"ahlt, so "offnet sich im Hauptfenster eine {\em AboutBox} mit verschiedenen farbigen geometrischen Figuren, einem Text und einem Ok-Knopf. Eine aktivierte {\em AboutBox} wird mit Anklicken des Ok-Knopfs wieder geschlossen. Bei Auswahl des Eintrags ''Exit'' wird die Anwendung beendet.\\
Die {\em AboutBox} (siehe Abbildung~\ref{about3}) geh"ort zu den modalen Dialogboxen. In der {\em AboutBox} des Beispiels sind zwei Interaktionselemente ({\em controls}) enthalten: Ein fester Text (hier ein Copyright-Vermerk) und ein Ok-Knopf, der bei Anklicken mit der Maus das Terminieren der Box veranla"st.\\

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=3cm \epsfysize=3cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/file3.ps}
\end{center}
\caption{Das Popupmen"u {\em File} des Beispiels ''PainterWithAboutBox''}
\label{file3}
\end{figure}

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=5cm \epsfysize=5cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/about31.ps}
\end{center}
\caption{Die {\em AboutBox} des Beispiels ''PainterWithAboutBox''}
\label{about3}
\end{figure}

Der feste Text wird mit einer Funktion aus der Klasse {\em fixedText} erzeugt. Der Ok-Knopf mit einer Funktion aus der Klasse {\em okButton}. Die Klassen {\em fixedText} und {\em okButton} geh"oren zu den Control-Klassen. {\em Controls} sind eigenst"andige Bedienelemente, die einem Eltern-Fenster ({\em parent window}) (hier der {\em AboutBox}) zugeordnet sind. Das Eltern-Fenster (die {\em AboutBox}) ist eine modale Dialogbox und wird mit einem Konstruktor aus der Klasse {\em modalDialog} erzeugt.
\begin{xple}
\k{let} modDiag = modalDialog.new2(parent window.WB\_STDMODAL)
\k{let} aText = fixedText.new1(modDiag)
\k{let} aBut = okButton.new2(modDiag int.bitOr(window.WB\_DEFBUTTON 
                                                            window.WB\_TABSTOP))
\end{xple}

Ein Ok-Knopf ist ein spezielles Interaktionselement, er enth"alt als Text automatisch ''OK''. Beim Anklicken des Ok-Knopfs ruft {\sv} intern die Standardfunktion des Eltern auf. In diesem Beispiel ist der Elter eine modale Dialogbox, somit wird eine Funktion zum Beenden der {\em AboutBox} aufgerufen. Durch Setzen eines {\em links} f"ur den Ok-Knopf kann eine andere Aktion an den Knopf gebunden werden. Damit der Ok-Knopf auch durch Bet"atigen der Eingabetaste ausgel"ost werden kann, wird das Attribut {\em WB\_DEFBUTTON} zugewiesen.\\
Position und Gr"o"se sowohl der {\em AboutBox} als auch des festen Textes und des Ok-Knopfs k"onnen, da sie Fenster sind, mit den Funktionen {\em changePosPixel} und {\em changeSizePixel} aus der Klasse {\em window} gesetzt werden. Der Ausgabebereich des Fensters (der {\em AboutBox}) wird mit der Funktion {\em window.changeOutputSizePixel} festgelegt. Die Positionsangabe bei der {\em AboutBox} bezieht sich auf den Bildschirm. Bei den beiden Interaktionselementen (Ok-Knopf und fester Text), die Kindfenster sind, wird die Position relativ zu ihrem Elter (hier der {\em AboutBox}) interpretiert. Der feste Text erh"alt "uber die Funktion {\em window.setText} seinen Text. Der Ok-Knopf erh"alt automatisch seinen Text ''OK''. Die Objekte ''fester Text'' und Ok-Knopf werden mit der Funktion {\em window.show} sichtbar geschaltet.
\begin{xple}
window.setText(modDiag ''Paint'')
window.changeOutputSizePixel(modDiag size.new3(200 180))
window.setText(aText ''StarView Paint$\setminus$n (c) STAR DIVISION$\setminus$n 1992-1994'')
  
window.changePosPixel(aText point.new3(25 80))
window.changeSizePixel(aText size.new3(150 50))
window.show(aText)

window.changePosPixel(aBut point.new3(65 135))
window.changeSizePixel(aBut size.new3(70 25))
window.show(aBut)

\end{xple}

F"ur die Ausgabe der farbigen Figuren der {\em AboutBox} wird in diesem Beispiel die Funktion {\em paint} der Klasse {\em window} "uberschrieben. In der neuen {\em paint}-Funktion werden mit den Funktionen {\em drawRect, drawEllipse} und {\em drawPolygon} die drei geometrischen Figuren definiert. F"ur die Hintergrundfarbe f"ur jede der Figuren wird jeweils ein Objekt der Klasse {\em brush} erzeugt, das durch die Funktion {\em outputDevice.changeFillInBrush} zur entsprechend aktuellen Hintergrundfarbe wird.
\begin{xple}
\k{let} paint(rect :rectangle.T) :\k{Ok} =
    \k{begin}
      \k{let} aOldBrush = 
              outputDevice.changeFillInBrush(modDiag brush.new4(color.new2(color.COL\_RED)))
      outputDevice.drawRect(modDiag rectangle.new3(point.new3(20 10) 
                                                                       point.new3(80 50)))

      outputDevice.changeFillInBrush(modDiag
                                                 brush.new4(color.new2(color.COL\_YELLOW)))
      outputDevice.drawEllipse(modDiag rectangle.new3(point.new3(60 20)
                                                                          point.new3(130 60)))

                                         
      outputDevice.changeFillInBrush(modDiag 
                                                 brush.new4(color.new2(color.COL\_GREEN)))
      \k{let} poly = polygon.new2(3)
      polygon.changePoint(poly point.new3(110 70) 0)
      polygon.changePoint(poly point.new3(140 30) 1)
      polygon.changePoint(poly point.new3(170 70) 2)
      outputDevice.drawPolygon(modDiag poly)

      outputDevice.changeFillInBrush(modDiag aOldBrush)
   \k{end}

window.setPaint(modDiag paint)
\end{xple}
Das Polygon wird mit Angabe der Anzahl seiner Ecken erzeugt. Mit der Funktion {\em changePoint} aus der Klasse {\em polygon} werden die Koordinaten festgelegt.\\
Das Zuordnen des neuen Popupmen"us ({\em File}), das Einf"ugen seiner beiden Eintr"age (''About...'' und ''Exit...'') erfolgen analog zu dem im vorigen Beispiel erkl"arten Verfahren. Bei der Auswahl des Eintrags ''About...'' wird "uber den {\em link} die Funktion {\em fileSelect} aufgerufen und somit ein Objekt der Klasse {\em aboutBox} erzeugt und durch die Funktion {\em modalDialog.execute} ge\-star\-tet. Bei Auswahl des Eintrags ''Exit...'' wird die (bereits aus vorigem Beispiel bekannte) Messagebox aktiviert.

\begin{xple}
(* link the function fileSelect *)
menu.pushSelectHdl(aFileMenu
                   link.new(fileSelect(aMainWin aFileMenu)))


\k{let} fileSelect(win :T pMenu :menu.T) :link.Handler =
    \k{fun}() :\k{Ok}
      	\k{if} menu.getCurItemId(pMenu) == ABOUT \k{then}
           modalDialog.execute(about3.newAboutBox(win.win))
           \k{ok}
        \k{else}
          \k {let} aBox = queryBox.new(win.win int.bitOr(window.WB\_OK\_CANCEL 
                                                                     window.WB\_DEF\_OK)
                                             ''Exit Paint'')
          \k{if} messBox.execute(aBox) == messBox.RET\_OK \k{then}
             systemWindow.close(win.win)
          \k{else}
             false
          \k{end}
        \k{end}
\end{xple}



                \section{Der interaktive Weg}  

Der {\de} von {\sv} ist ein Resource Editor (siehe Abschnitt~\ref{resed}), der die M"oglichkeit bietet, die Resource Dateien einer {\sv}-Anwendung interaktiv zu erstellen. Eine komplette Anwendung kann nicht mit dem {\de} erstellt werden. Es ist eine Kombination mit dem expliziten Weg n"otig, weil keine graphische Umgebung f"ur den Entwurf von Aktionen auf Ereignisse existiert\\
Mit dem {\de} (siehe Abbildung~\ref{de}) sollen besonders einfach Dialogboxen und Men"us erstellt werden k"onnen \cite{busch93}. Die ausgew"ahlten Resource Objekte werden entweder "uber Editoren oder Dialogboxen bearbeitet. Die Eigenschaften von Basistypen, wie z.B. String, Pen, Brush oder Font, werden in Dialogboxen festgelegt. F"ur den Entwurf von komplexeren Resource Objekten, wie z.B. Dialogboxen, Fenster und Men"us, gibt es spezielle Editoren (Abbildung~\ref{deress} zeigt einen Editor zum Bearbeiten von Fenstern), in denen die Objekte und deren Sub-Resourcen (z.B. Ok-Kn"opfe, Bildlaufleisten und Textfelder in einem Fenster) bearbeitet werden k"onnen.

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=10cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/designed.ps}
\end{center}
\caption{Der {\de}}
\label{de}
\end{figure}

Die M"oglichkeit Resourcen in einer Anwendung zu benutzen wird von {\sv} nicht auf allen Plattformen unterst"utzt, auf denen auch das {\ty}-System portiert wurde. So ist es nicht m"oglich, Teile von graphischen Oberfl"achen, von {\ty}-Anwendungen die auf PC und Mac laufen, aus Resourcen zu laden. {\sol} 2.x wird in Bezug auf Resourcen von {\sv} unterst"utzt. Damit jedoch {\ty}-Anwendungen mit einer graphischen Oberfl"ache ohne Probleme auf allen drei Plattformen funktionieren, sind die nicht portablen Funktionen f"ur den {\ty}-Programmierer nicht verf"ugbar. Die Funktionen werden wieder zug"anglich sein, sobald {\sv} diese Funktionen f"ur alle verwendeten Plattformen zur Verf"ugung stellt. Das folgende Beispiel f"uhrt trotzdem, zur vollst"andigen "Ubersicht, in die Arbeit mit Resourcen ein.

     \subsubsection*{''PainterWithAboutBox'' mit Verwendung von Resourcen}
Dieses Beispiel f"uhrt in die Arbeit mit Resourcen ein. Von der Funktionalit"at her ist es mit Beispiel ''PainterWithAboutBox'' (vgl. Absatz~\ref{painterwithaboutbox}) identisch, es erfolgt lediglich eine Umstellung auf Resourcen.\\
Resourcen erlauben es, bestimmte Daten einer Anwendung getrennt von dieser zu verwalten und zu bearbeiten. Bei "Anderung dieser Daten m"ussen nur die betreffenden Resource-Dateien ge"andert und neu "ubersetzt werden. Das schon "ubersetzte Hauptprogramm mu"s nicht noch  einmal "ubersetzt werden. Die Resourcen werden mit dem Resource-Compiler "ubersetzt. Die "ubersetzten Resourcen werden zur Laufzeit von der Anwendung geladen.\\
In diesem Beispiel sind die spezifischen Daten des Men"us und der AboutBox mit dem {\de} entworfen und in je einer Resource-Datei gespeichert worden. Die Resource-Dateien k"onnen sowohl mit einem Texteditor als auch mit dem {\de} erstellt werden.\\

{\bf Das Men"u aus Resourcen heraus geladen:}\\

Damit aus der Anwendung heraus auf die Resourcen eindeutig zugegriffen werden kann, ben"otigen sie einen Identifier. Die Resource-Datei f"ur das Men"u gibt zuerst die Resource-ID des Men"us (hier {\em MID\_MENUBAR}) an. F"ur jeden Men"ueintrag ({\em Menu-Item}) folgen der Text des Eintrags und die entsprechende {\em MenuItem-ID}.
\begin{xple}
Menu MID\_MENUBAR
\{
    ItemList =
    \{
        MenuItem
        \{
            Text       = ''$\sim$File'';
            Identifier = MID\_FILE;
            ...            
        \};

        MenuItem
        \{
            Text       = ''$\sim$Color'';
            Identifier = MID\_PENCOLOR;
            ...            
        \};

        MenuItem
        \{
            Text       = ''$\sim$Width'';
            Identifier = MID\_PENWIDTH ;
            ...            
       \};
    \};
\};
\end{xple}

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=10cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/deexa4file.ps}
\end{center}
\caption{Bearbeitung des Men"ueintrags {\em File} mit dem {\de}}
\label{deexa4file}
\end{figure}

Im {\de} wird das Men"u in einem speziellen Editor bearbeitet (siehe Abbildung~\ref{deexa4file}): dem Men"u-Editor. Hier k"onnen die Men"ueintr"age vorgenommen werden und bei Bedarf weiter bearbeitet werden. In der Abbildung~\ref{deexa4file} sind f"ur den Men"ueintrag ''File'' die Folge-Men"ueintr"age ''About...'' und ''Exit...'' zu sehen. Diese werden durch eine Trennlinie (Separator) sp"ater im Men"u getrennt sein.

Die Folge-Men"ueintr"age k"onnen direkt als Submen"u an den jeweiligen Men"ueintrag geh"angt werden. Sie werden automatisch beim Laden des Men"us mitgeladen.
    
\begin{xple}
MenuItem
\{
      Text       = ''$\sim$File'';
      Identifier = MID\_FILE;
      SubMenu    = Menu
      \{
           ItemList =
           \{
                MenuItem
                \{
                    Text       = ''$\sim$About...'';
                    Identifier = MID\_ABOUT;
                    About     = TRUE;
                \};
                MenuItem
                \{
                    Separator = TRUE;
                \};
                MenuItem
                \{
                    Text       = ''$\sim$Exit...'';
                    Identifier = MID\_QUIT;
                \};
            \};
       \};
\};
\end{xple}
Die Zuordnung dieser Folge-Men"ueintr"age zum jeweiligen Men"ueintrag im Hauptprogramm (wie im vorigen Beispiel ''PainterWithAboutBox'') ist nicht mehr notwendig. Damit jedoch die benutzerdefinierten Funktionen ({\em handler}) an die Men"ueintr"age gebunden werden k"onnen, mu"s vorher der Zugriff auf die  Men"ueintr"age gegeben sein. Dies erfolgt "uber die Funktion {\em menu.getPopupMenu}:
\begin{xple}
(* fetch menus to install Handler *)
\k{let} colorMenu = menu.getPopupMenu(menuBar PENCOLOR)
\k{let} widthMenu = menu.getPopupMenu(menuBar PENWIDTH)
\k{let} fileMenu = menu.getPopupMenu(menuBar FILE)

menu.pushSelectHdl(colorMenu link.new(colorSelect(mainWin colorMenu)))
menu.pushSelectHdl(widthMenu link.new(widthSelect(mainWin widthMenu)))
menu.pushSelectHdl(fileMenu link.new(fileSelect(mainWin fileMenu)))
\end{xple}


{\bf Die {\em AboutBox} aus Resourcen heraus geladen:}\\

In der Resource-Datei f"ur die {\em AboutBox} stehen Angaben zu Gr"o"se, Position und Text. "Uber Schl"usselw"orter werden die Eigenschaften der Box definiert.
\begin{xple}
ModalDialog RID\_ABOUTBOX
\{
    Size           = MAP\_PIXEL( 200, 180 );
    Text          = ''Paint'';
    OutputSize = TRUE;
    Moveable   = TRUE;
    Hide          = TRUE;
    \dots
\};
\end{xple}

Die Abbildung~\ref{deexa4abotext1} zeigt die aufgeklappte Liste der Schl"usselw"orter einer modalen Dialogbox. Bestimmte Eigenschaften k"onnen ausgew"ahlt und ver"andert werden. Nicht ver"anderte Eigenschaften erhalten Standardwerte.
 
\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=11cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/deexa4abotext1.ps}
\end{center}
\caption{Liste der Schl"usselw"orter der {\em AboutBox}}
\label{deexa4abotext1}
\end{figure}
Der Ok-Knopf und der feste Text der {\em AboutBox} k"onnen als Sub-Resourcen der {\em AboutBox} in der Resource-Datei angegeben werden:
\begin{xple}
ModalDialog RID\_ABOUTBOX
\{
   \dots
    OKButton RID\_OK
    \{
        PosSize     = MAP\_PIXEL( 65, 135, 70, 25 );
        DefButton = TRUE;
        TabStop    = TRUE;
    \};
\};
\end{xple}
Die Abbildung~\ref{deexa4about} zeigt die Bearbeitung der {\em AboutBox} mit dem {\de}.

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=10cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/deexa4about.ps}
\end{center}
\caption{Bearbeitung der {\em AboutBox} mit dem {\de}}
\label{deexa4about}
\end{figure}

In der Hauptfunktion des Beispiels werden die ("ubersetzten) Resourcen geladen. Der Pfad der ("ubersetzten) Resource-Datei ist dem Resource-Manager mitzuteilen. Mit der Funktion {\em menu.newBarfromRes} und der Angabe eines Identifiers wird die Men"uleiste aus der Resource geladen. 

\begin{xple}
(* set resource manager to file painterWithResources.res *)
resource.setResManager(mainWin.win resMgr.new(''svenv\_examples/painterWithResources.res''))
\end{xple}

Damit s"amtliche Sub-Resourcen der ModalDialog\-Resource vom Resource-Manager aufgefunden und geladen werden k"onnen mu"s die Haupt-Resource der modalen Dialogbox bis zum erfolgten Laden der Sub-Resourcen gesperrt sein. Dieser automatische Vorgang wird mit Aufrufen der Funktion {\em resource.freeResource} nach dem Laden der Sub-Resourcen aufgehoben.

\begin{xple}
\k{let} self = modalDialog.newFromRes(parent resId.new(ABOUTBOX))
\k{let} text = fixedText.newFromRes(self resId.new(TEXT))
\k{let} but = okButton.newFromRes(self resId.new(OK))

resource.freeResource(self)
\end{xple}

Bei Beenden der Anwendung wird auch automatisch die geladene Resource freigegeben. Gleichzeitig werden die Popupmen"us, die als Elemente der Men"uleiste aus der Resource geladen wurden, entfernt.

               \section{Vor- und Nachteile der Wege}
In den letzten drei Abschnitten wurden der implizite, explizite und interaktive  Weg als M"oglichkeit zur Entwicklung von graphischen Benutzeroberfl"achen vorgestellt. Der implizite Weg spricht "uber eine Zwischenschicht ({\em sveditenv}) ausgew"ahlte Funktionen der {\sv} Bibliothek ({\em svenv}) an. Er erm"oglicht ein schnelles Entwerfen von verschiedenen, eventuell ineinander geschachtelten Editoren. Allen Editoren ist eine einheitliche Pr"asentation und Dialogsteuerung gemein. Der explizite Weg verwendet direkt alle Funktionen der {\sv} Bibliothek ({\em svenv}). Zur Zeit dieser Arbeit sind nicht alle {\sv} Funktionen verf"ugbar, weil nur Funktionen verwendet werden sollen, die auf allen Plattformen funktionieren, auf denen das {\ty}-System portiert worden ist. Der interaktive Weg wurde anhand des {\de} von {\sv} beschrieben. Leider ist der {\de} und somit die Benutzung von Resourcen zur Zeit dieser Arbeit aus dem oben genannten Grund nicht m"oglich.\\
Der Vorteil beim impliziten Weg liegt in der Zwischenebene, den Modulen {\em editenv} und {\em sveditenv}. Eine "Anderung der Implementation von einzelnen Funktionen aus diesen Modulen hat keinen Einflu"s auf die Anwendungsprogramme, die auf dieser Zwischenebene aufsetzen. Der Nachteil dieses Weges ist, da"s anwendungsspezifische Oberfl"achen nicht oder nur mit sehr viel Aufwand erstellt werden k"onnen.\\
Der Vorteil beim expliziten Weg ist die Verf"ugbarkeit aller Klassen und Funktionen der Bibliothek {\em svenv}. Hier kann eine "Anderung von Implementationen von Funktionen gro"sen Einflu"s auf Anwendungsprogramme haben. Die Tabelle~\ref{vorundnach} fa"st die obigen Punkte noch einmal zusammen.

\begin{table}[hbt]
\begin{center}
\leavevmode
\begin{tabular}{|l|l|l|l|}  \hline 
                    &{\bf expliziter Weg} &{\bf impliziter Weg}&{\bf interaktiver Weg}\\ \hline \hline
Aufwand bei         & hoch                & sehr hoch          & reduziert            \\
anwendungsspezifischen&                   &                    &                      \\ 
Oberfl"achen        &                     &                    &                      \\ \hline
Aufwand bei Editoren& hoch                & niedrig            & reduziert            \\ \hline
M"oglichkeiten      & viele               & eingeschr"ankt     & viele                \\ \hline
Funktionen          & (fast) alle         & eingeschr"ankt     & eingeschr"ankt       \\ \hline
Portabilit"at       & mittel              & hoch               & mittel               \\
zw. Fenstersystemen &                     &                    &                      \\ \hline
Portabilit"at       & mittel              & hoch               & mittel               \\
zw. Plattformen     &                     &                    &                      \\ \hline
Abh"angigkeit der   & sehr hoch           & niedrig            & hoch                 \\ 
Anwendungsprogramme &                     &                    &                      \\ 
von verwendeten     &                     &                    &                      \\
Funktionen          &                     &                    &                      \\ \hline
\end{tabular}
\end{center}
\caption{Bewertung der drei Wege}
\label{vorundnach}
\end{table}
