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

\chapter{{\sv} und {\ty}}
\label{starview}

{\sv} ist eine portable C++ Klassenbibliothek, d.h. die Entwicklung und Gestaltung der graphischen Oberfl"ache kann unabh"angig vom jeweiligen Fenstersystem erfolgen.
Graphische Benutzeroberfl"achen zeichnen sich aus durch das Erscheinungsbild und die Funktionalit"at der Fenster und Interaktionselemente ({\em look}) einerseits und das Verhalten des Systems auf Benutzerinteraktionen ({\em feel}) andererseits. F"ur die Beibehaltung des {\em look and feel} des jeweils zugrundeliegenden Fenstersystems sorgt die Klassenhierarchie der {\sv} C++ Bibliothek.\\

Im Abschnitt~\ref{sysuebergr} "uber system"ubergreifende Bibliotheken wurden der Schnittmengen- und Obermengenansatz erl"autert.
{\sv} stellt eine Mischform der beiden Ans"atze dar \cite{geis95}.
Der Schnittmengenansatz sorgt f"ur eine hohe Portabilit"at, aber auch, wie bereits erw"ahnt, f"ur eine gro"se Einschr"ankung der Funktionalit"at.
Der Obermengenansatz kann die Portabilit"at sehr schnell wieder einschr"anken.
Man mu"s bei der Programmierung einer GUI-Anwendung mit einer system"ubergreifenden Klassenbibliothek (hier {\sv}) also darauf achten, nur Funktionalit"at zu verwenden, die auf allen unterst"utzten Fenstersystemen vorhanden ist, oder von vornherein wissen, da"s die Anwendung nur auf einem bestimmten System laufen soll. Ist das System bekannt, so kann gleich ein spezifisches Oberfl"achenentwicklungswerkzeug benutzen werden. Dieses Werkzeug bietet dann volle Funktionalit"at \cite{schw94}.

Dieses Kapitel gibt einen "Uberblick "uber die in {\sv} vorhandenen Klassen und nimmt eine Zuordnung der Klassen zu Funktionsgruppen vor. Das Kapitel schlie"st mit einem ersten einf"uhrenden Beispiel.

                  \section{Grundlegende GUI-Elemente}
                  \label{gui-elemente}

In diesem Abschnitt sollen die wichtigsten GUI-Elemente beschrieben werden.
Diese Elemente finden sich als Klassen in der StarView-Klassenhierarchie wieder.
Weitere, speziellere Elemente finden sich in den Beispielen.\\

\subsubsection*{Fenster ({\em windows})}
Fenster sind in Anwendungen mit graphischen Oberfl"achen wesentliches Medium der Interaktion. ''Sie dienen der Pr"asentation der Anwendungsdaten und der Entgegennahme der Eingaben des Benutzers'' [Geisler 95,~S.~36]. "Uber spezielle Interaktionselemente im Fenster werden die Eingaben entgegengenommen. Das Fenster mu"s in einem bestimmtem Status sein ({\em focus}), damit es Eingaben, z.B. Tastatureingaben, empfangen kann.

\subsubsection*{Interaktionselemente ({\em controls})}
Interaktionselemente erm"oglichen dem Benutzer die Kommunikation mit der Anwendung. Durch Maus oder Tastatur werden Schnittstellenelemente wie Kn"opfe, Eingabefelder, Men"us, Rollbalken etc. manipuliert. Diesen Elementen kann eine Funktionalit"at zugeordnet werden, die dann bei entsprechender Aktion des Benutzers ausgef"uhrt wird.

\subsubsection*{Dialoge}
Dialoge fassen mehrere Interaktionselemente zusammen. Aus einer Anzahl von Elementen w"ahlt der Benutzer die f"ur ihn wichtigen aus, die den weiteren Verlauf des Programms bestimmen. Dialoge steuern, welche Eingaben zu welchem Fenster geh"oren und garantieren damit eine zusammenh"angende Bearbeitung der Interaktionselemente. {\sv} unterscheidet zwischen {\em modalen} und {\em nichtmodalen} Dialogen. Modale Dialoge m"ussen, im Gegensatz zu nichtmodalen Dialogen, beendet werden, bevor in der Anwendung fortgefahren werden kann. Die Verwendung von modalen Dialogen kann die benutzergesteuerte Eingabe einschr"anken \cite{husha93}.

\subsubsection*{Datenaustausch}
Daten k"onnen zwischen mehreren Anwendungen transferiert werden. Dies unterst"utzen Verfahren wie Klemmbrett ({\em clipboard}) oder {\em drag \& drop}. Das Klemmbrett ist eine Art Zwischenspeicher, in den per Benutzeraktionen 'Ausschneiden' ({\em cut}) und 'Kopieren' ({\em copy}) Daten  gestellt werden. Mit der Benutzeraktion 'Einf"ugen' ({\em paste}) k"onnen Kopien von den im Klemmbrett befindlichen Daten angefordert werden.
Sind die Daten mit der Maus selektierbar (z.B. Zeichenketten und Zahlen), so kann man sie mit der Maus aufnehmen ({\em drag}), "uber den Bildschirm bewegen und in der gew"unschten Anwendung fallenlassen ({\em drop}).


                  \section{Die {\sv} Klassenhierarchie}

Abbildung~\ref{hierarchie} zeigt die Klassenhierarchie von {\sv}. Sie umfa"st z.Zt. dieser Arbeit mehr als 100 Klassen mit mehr als 500 Funktionen.\\


                  \subsection{Klassen"ubersicht nach Kategorie}
In der Tabelle~\ref{klassuebersicht} sind die am h"aufigsten benutzten {\sv} Klassen, eingeteilt nach Funktionsgruppen, aufgef"uhrt.\\

\begin{table}[hbt]
\begin{center}
\leavevmode
\begin{tabular}{|l|l|}   \hline
\hspace{.5in}{\bf Kategorie}&\hspace{.5in}{\bf Klassen}\\ \hline\hline
Applikation               &{\em application}\\ \hline
Fenster                   &{\em window, systemWindow, workWindow}\\ \hline
Ausgabe                   &{\em outputDevice}\\ \hline
Ausgabewerkzeuge          &{\em pen, brush, font, gdiMetaFile}\\ \hline
Eingabeger"ate            &{\em mouseEvent, keyEvent, keyCode}\\ \hline
Men"u                     &{\em menu} ({\em menuBar, popupMenu})\\ \hline
Accelerator               &{\em accelerator}\\ \hline
Interaktionselemente ({\em controls})&{\em control, button, 
                                              edit, listBox,} \\ 
und Dialogboxen           &{\em comboBox, scrollBar, fixedText,}\\
                          &{\em fixedBitmap, fixedIcon, groupBox,}\\
                          &{\em dialog, modalDialog}\\ \hline
Druck- und Druckvorschau  &{\em printer, preview}\\ \hline
Zwischenablage            &{\em clipboard}\\ \hline
Hilfe                     &{\em help, helpEvent}\\ \hline
Resource                  &{\em resource}\\ \hline
\end{tabular}

\end{center}
\caption{Klassen"ubersicht nach Kategorie}
\label{klassuebersicht}
\end{table}

\subsubsection*{Applikation}

Mit der Funktion {\em execute} aus der Klasse {\em application} wird die Anwendung gestartet.

\subsubsection*{Fenster}

Die wichtigsten Klassen zur Erstellung von Fenstern sind {\em window, systemWindow {\em und} workWindow}.
Diese Klassen besitzen neben einer Ausgabefunktionalit"at Funktionen f"ur die Benutzerinteraktion mit dem Fenstersystem und Funktionen zur Verarbeitung von Eingaben. Die Klasse {\em window} stellt die ereignisbearbeitenden Funktionen ({\em event handler}\footnote{Unter dem Begriff {\em handler} ist ein Wert zu verstehen, durch den auf ein Objekt zugegriffen werden kann. Frei "ubersetzt bedeutet {\em handler} so etwas wie ''Griff (T"urgriff)'' oder ''etwas handhaben'' (von {\em to handle}).}) f"ur die Eingaben in Form virtueller Methoden zur Verf"ugung. Diese {\em event handler} k"onnen je nach Bedarf "uberschrieben werden.

\subsubsection*{Ausgabe}

Die Klasse {\em outputDevice} stellt die Ausgabefunktionen als Basis f"ur eine ger"ateunabh"angige Ausgabe zur Verf"ugung. Sie ist Basisklasse f"ur alle Klassen, die Ausgaben darstellen k"onnen, z.B. f"ur {\em window, printer}.

\subsubsection*{Ausgabewerkzeuge}
Alle Ausgabefunktionen der Klasse {\em outputDevice} arbeiten mit dem Ausgabewerkzeugen {\em pen, brush {\em und} font}. Die Klasse {\em pen} repr"asentiert einen Stift f"ur Ausgabefunktionen. {\em Pens} k"onnen mit beliebiger Farbe und Strichst"arke erzeugt werden. Die Klasse {\em brush} repr"asentiert ein Muster f"ur Ausgabefunktionen. Es gibt {\em brushes} mit einem vordefinierten F"ullmuster oder mit einem benutzerspezifizierten Muster, das in Form einer {\em Bitmap} angegeben wird. Die Klasse {\em font} wird zur Ausgabe von Text verwendet. Mit der Klasse {\em gdiMetaFile} ist es m"oglich, alle Ausgaben in einem Ausgabemedium aufzuzeichnen und wieder abzuspielen.

\subsubsection*{Eingabeger"ate}

Die Klassen {\em mouseEvent, keyEvent {\em und} keyCode} stellen Funktionen zum Erfragen von Informationen "uber erfolgte Eingaben durch die Maus oder die Tastatur zur Verf"ugung.

\subsubsection*{Men"us}

Die Klasse {\em menu} bietet Funktionen f"ur die Verwaltung von Men"ueintr"agen sowie die Zuordnung von Men"ueintr"agen zu {\em Popup-Menus} als auch Funktionen f"ur die Verwaltung von {\em Menu Handlern}. Durch {\em Popup-Menus} kann eine kontextbezogene Benutzerf"uhrung realisiert werden.

\subsubsection*{Acceleratoren}

Funktionen einer Anwendung k"onnen nicht nur "uber Men"us ausgew"ahlt werden, sondern auch "uber zugeordnete Tasten oder Tastenkombinationen ({\em accelerators}). Dr"uckt der Benutzer die entsprechende Taste, wird der {\em Accelerator Handler} aufgerufen. Die Taste wird anschlie"send nicht als Tastatureingabe an die Anwendung weitergeleitet.

\subsubsection*{Interaktionselemente und Dialogboxen}

{\em Controls} sind Elemente zur Ein- und Ausgabe, die haupts"achlich in Dialogboxen verwendet werden.\\
Die Gruppe der Control-Klassen ist sehr umfangreich (siehe Abbildung~\ref{hierarchie}). In aktiven Controls k"onnen Benutzer Eingaben vornehmen. Zu den aktiven Controls geh"oren die Klasse {\em button} sowie die davon abgeleiteten speziellen Knopf-Klassen, die Klasse {\em edit} sowie deren abgeleitete Klassen, die Klassen {\em listbox} und {\em multiListBox}, die Klasse {\em comboBox} mit den davon abgeleiteten Klassen, die Klassen {\em scrollBar} und {\em autoScrollBar} sowie benutzerdefinierte Controls. Zu den statischen Controls, die nur zur Anzeige dienen und keine Eingaben entgegennehmen, geh"oren die Klassen {\em fixedText, fixedBitmap, fixedIcon} und {\em groupBox}.\\
Die Klasse {\em dialog} stellt die Funktionalit"at f"ur eine spezielle Fensterform zur Verf"ugung. In einem Dialog (Dialogbox) sind mehrere Interaktionselemente zusammengefa"st. Generell wird zwischen modalen und nichtmodalen Dialogboxen unterschieden. {\sv} bietet eine Anzahl von vordefinierten modalen Dialogen: die Messageboxen.

\subsubsection*{Druck und Druckvorschau}

Die Klassen {\em printer} und {\em preview} stellen die notwendige Funktionalit"at f"ur die Ausgabe auf einen Drucker bzw. f"ur eine m"oglichst genaue Druckvorschau ({\em preview}) auf dem Bildschirm zur Verf"ugung. Diese Klassen enthalten Funktionen zur Seiten- und Druckjobsteuerung.

\subsubsection*{Zwischenablage}

Die Klasse {\em clipboard} stellt eine Art Zwischenspeicher f"ur den Datenaustausch zwischen verschiedenen Anwendungen oder innerhalb einer Anwendung zur Verf"ugung. Im Zwischenspeicher kann nur ein Datenobjekt zur Zeit stehen.

\subsubsection*{Hilfe}

Zur Steuerung des Hilfesystems gibt es die Klassen {\em help} und {\em helpEvent}. Innerhalb einer Anwendung kann damit Hilfe zu einem Schl"usselwort angefordert werden.

\subsubsection*{Resourcen}

Alle bisher erw"ahnten Klassen sind von der Klasse {\em resource} abgeleitet.\\
Resourcen erlauben es, Informationen "uber Men"us, Dialogboxen, Zeichenketten usw. getrennt von der Anwendung zu verwalten. Dadurch ist es m"oglich, existierende Programme zu modifizieren, ohne sie erneut "ubersetzen zu m"ussen. Es werden nur die betreffenden Resource-Dateien "ubersetzt und an die Anwendung gebunden.



                \section{Grundelemente einer {\sv}-Anwendung}
\label{sv-anwendung}
Dieser Abschnitt soll anhand eines einfachen Beispiels (siehe Abbildung~\ref{erstesbeisp}) erl"autern, welche Elemente mindestens ben"otigt werden, um eine graphische Oberfl"ache mit {\sv} zu entwickeln\footnote{C++ Kode zu diesem Beispiel befindet sich im Anhang~\ref{cpp}, der vollst"andige {\tl} Kode in Anhang~\ref{anhanghello}.}.

\begin{figure}[hbt]
\begin{center}
\leavevmode
\epsfxsize=12cm \epsfysize=8cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/helloW2.ps}
\end{center}
\caption{Ein erstes {\sv} Beispiel}
\label{erstesbeisp}
\end{figure}

                \subsubsection*{Erzeugen des Hauptfensters}
\label{helloW}
Generell kann eine Anwendung mehrere Arten von Fenstern aufweisen. Ein Fenster ist das Hauptfenster. Wird dieses Fenster geschlossen, so terminiert die gesamte Anwendung. Das Hauptfenster wird mit einem Konstruktor des Abstrakten Datentyp {\em workWindow.T} und einem Attribut ({\em stylebit}) WB\_APP (das das Fenster zum Hauptfenster erkl"art) erzeugt. Die Attribute f"ur Fenster sind in der Klasse {\em window} zu finden.\\

Nach dem Erzeugen, der Initialisierung und dem Sichtbarschalten des Fensters mit {\em window.show(...)} wird die Ereignisverarbeitung ({\em event-loop}) (s. Abschnitt ~\ref{startdanwend}) gestartet.


\begin{xple}
    {\bf begin}
      (* create window *)
      {\bf let} aMainWin = workWindow.new2(window.nilT  
                                           int.bitOr(window.WB\_STDWORK window.WB\_APP))
      ...
      (* set window header text *)
      window.setText(aMainWin ''StarView Paint'')
      (* display window *)
      window.show(aMainWin)
      (* start event loop *)
      application.execute()
    {\bf end}
\end{xple}

Neben dem Grundelement ''Hauptfenster'' einer {\sv} Anwendung enth"alt dieses Programm eine "uberschriebene Funktion (siehe folgenden Abschnitt "uber Ereignisbearbeitung) zur Ausgabe eines Textes im Fenster. Zur Ausgabe des Textes wird die Funktion {\em drawText} aus der Klasse {\em outputDevice} unter Angabe der Koordinaten und des Textes benutzt.

\begin{xple}
(* define function paint and install it in win *)
window.setPaint(aMainWin
     {\bf fun}(pEvt :rectangle.T) :\k{Ok}
         {\bf begin}
           outputDevice.drawText(aMainWin  point.new3(50 50)  ''Keine Panik'')
         {\bf end})
\end{xple}

\subsubsection*{Ereignisbearbeitung}
\label{ereignisbe}

Jedes Ereignis, z.B. eine Benutzereingabe oder das Auftreten eines Fehlers, veranla"st {\sv}, eine benutzerdefinierte Funktion ({\em event handler}) aufzurufen. Der Benutzer erh"alt die M"oglichkeit, auf die Ereignisse zu reagieren und so den weiteren Verlauf der Anwendung zu bestimmen.\\
Die Anbindung eines {\em event handler} an ein Ereignis kann durch "Uberschreiben ({\em overriding}) der virtuellen Funktion einer abgeleiteten Klasse oder "uber einen von {\sv} gestellten Mechanismus ("uber die Klasse {\em link}) erfolgen.
Das "Uberschreiben von virtuellen Funktionen ist ein C++-Konzept. Die Funktionen werden per Klasse "uberschrieben, in {\tl} erfolgt dies per Objekt. Um das "Uberschreiben von Funktionen in {\tl} zu simulieren, wird jede virtuelle Funktion als Attribut eines Abstrakten Datentyps betrachtet, f"ur das ein Paar aus Schreib- und Lesefunktion existiert. Beispiel: {\em window.setPaint, window.getPaint}.\\


Die M"oglichkeit des "Uberschreibens wird haupts"achlich f"ur virtuelle Funktionen der Klasse {\em window} benutzt, von der der Programmierer h"aufig Klassen ableitet. Im folgenden Beispiel wird der {\em event handler} {\em MouseButtonDown} "uberschrieben, um die Position des Mauszeigers im Fenster ermitteln zu k"onnen.

\begin{xple}
 window.setMouseButtonDown(aMainWin (* Object *)
      {\bf fun}(mEvt :mouseEvent.T) :\k{Ok}
        {\bf begin}
          window.captureMouse(aMainWin)
          t.aLastPoint:= mouseEvent.getPosPixel(mEvt)
        {\bf end})
\end{xple}


Ist ein {\em event handler} in einer abgeleiteten Klasse nicht "uberschrieben worden, so ruft {\sv} die Standardimplementierung der Funktion der Basisklasse auf.\\


Die Anbindung von {\em event handlern} "uber die Klasse {\em link} ist f"ur ereignisbearbeitende Funktionen ({\em handler}) solcher Klassen, von denen der Programmierer nicht unbedingt eine Klasse ableiten mu"s (z.B. Kn"opfe, Rollbalken). Die folgende Funktion reagiert benutzerdefiniert auf ein Ereignis. Diese Bearbeitung des Ereignisses wird mit einem {\em link} an das betreffende Objekt gebunden (hier an ein Men"u).

\begin{xple}
{\bf let} colorSelect(win :T  pMenu :menu.T) :link.Handler =
          {\bf fun}() :\k{Ok}
            {\bf begin}
             ...
            {\bf end}
\end{xple}

Alle Klassen sind abgeleitet von der Klasse {\em linkHdl} (siehe Abbildung ~\ref{hierarchie}).

\subsubsection*{Starten der Anwendung}
\label{startdanwend}
Der Ablauf nach Starten der Anwendung ist in der Abbildung~\ref{eventloop} schematisch dargestellt.
Die Funktion {\em main} ruft nach einigen Initialisierungen die Funktion {\em application.execute} auf. Per {\em ccall} wird {\sv} aufgerufen und das System befindet sich nun in der Ereignisverarbeitung ({\em event-loop}). Erfolgt ein Ereignis ({\em event}), z. B. Mausklick auf eine Men"uleiste, so wird per {\em callback} die ereigniszugeh"orige {\tl}-Funktion aufgerufen. Die {\tl}-Funktion, die wiederum {\sv}-Funktionen aufruft, realisiert das per {\em ccall}.
Die graphischen Elemente werden mittels eines Graphik-Servers angezeigt.
Die Funktion {\em systemWindow.close} (bzw. ein Mausklick auf den {\em quit}-Knopf im Fenstermen"u) beendet die {\em event-loop} und kehrt zur {\em main}-Funktion zur"uck.\\
\begin{figure}[hb]
\begin{center}
\leavevmode
\epsfxsize=13cm \epsfysize=10cm
\epsffile{/usr/users/dbis1/stud/hachmann/Studienarbeit/Bilder/svtlloop.epsf}
\end{center}
\caption{Die Ereignisverarbeitung ({\em event-loop})}
\label{eventloop}
\end{figure}
