Bash-Skripte sind meist nur für die Verwendung auf der Kommandozeile gedacht und schrecken Nicht-Experten mit unübersichtlichen Ausgaben ab. Das muss aber nicht so sein: Die Programme Dialog, Gdialog und Kdialog verstecken die Kommandozeile vollständig vor dem Benutzer.
Bash-Skripte erledigen in der Regel nur Kleinigkeiten. Administratoren und Programmierer benutzen die Bash praktisch ausschließllich, um alltägliche Standardaufgaben zu automatisieren, für die es sich nicht lohnt, ein ausgewachsenes Binärprogramm in einer Hochsprache zu schreiben.
Ein großes Manko fast aller Skripte stellen das rudimentäre Benutzer-Interface und die meist schlechte Benutzerführung dar. Der von KDE und Gnome verwöhnte Anwender findet es umständlich, erst eine Textkonsole zu öffnen und dann knappe Fragen mit Tastatureingaben zu beantworten. Die Kommandozeile schreckt insbesondere Einsteiger ab, die mit den Linux-Befehlen noch nicht vertraut sind.
Standardisierte Menüs
Das Programmdialog ermöglicht die Darstellung eines ansprechenderen Benutzer-Interfaces. Dialog war anfangs nur für die Kommandozeile gedacht und baute aus farbigen Hintergründen und einigen ASCII-Zeichen Rahmen und Menüs. Mit der zunehmenden Verbreitung von KDE und Gnome hat auch Dialog nachgezogen und verfügt mittlerweile über Ableger gebildet: kdialog für KDE und gdialog für Gnome.
Dialog und seine grafischen Pendants werden komplett über die Kommandozeile gesteuert. Genügen bei einfachen Abfragen noch eine Hand voll Parameter, gestalten sich große Auswahllisten oder Menüs schnell unübersichtlich. Dialog baut dann selbständig anhand der Kommandozeilen-Parameter die Bedienoberfläche auf und übernimmt die komplette Interaktion mit dem Benutzer.
Bei Menüs oder Abfragen liefert Dialog die Auswahl des Anwenders an das aufrufende Programm oder Skript zurück. Beim Ur-Dialog für die Kommandozeile muss dies über den Rückgabewert von Dialog oder die Standard-Fehlerausgabe (stderr) laufen. Die Standardausgabe (stdout) benötigt Dialog für die Interaktion mit dem Benutzer.
Grafische Oberfläche gefällig?
Bei den grafischen Varianten Gdialog und Kdialog wäre dies prinzipiell nicht erforderlich: Sie könnten die Auswahlen per Standard-Ausgabe zurück geben. Aus Kompatibilitätsgründen zu Dialog verwendet Gdialog jedoch weiterhin die Standard-Fehlerausgabe. Leider verwendet Kdialog statt dessen die Standardausgabe, was eine portable Programmierung erschwert.
Als Beispiel soll der Termin-Client eines Terminüberwachungs-Skripts dienen, das bereits im siebten Teil der Programming Corner aus LinuxUser 02/2002 [1] vorgestellt wurde. Der Client kommuniziert über Dialog, Gdialog oder Kdialog mit dem Benutzer. Währenddessen läuft der Server still im Hintergrund. Listing 1 enthält den um einige Kommentare verkürzten Quellcode des Termin-Clients.
Listing 1
Der Termin-Client
001 #!/bin/bash
002 if [ -n "`which gdialog 2>/dev/null`" ]; then
003 Dialog="`which gdialog`"
004 DialogRedirect="2>~/.termine.in"
005 elif [ -n "`which kdialog 2>/dev/null`" ]; then
006 Dialog="`which kdialog`"
007 DialogRedirect="1>~/.termine.in"
008 elif [ -n "`which dialog 2>/dev/null`" ]; then
009 Dialog="`which dialog`"
010 DialogRedirect="2>~/.termine.in"
011 else
012 echo "Sie benötigen dialog, kdialog oder gdialog,"
013 echo "um dieses Programm benutzen zu können."
014 exit 1
015 fi
016
017 COLUMNS=80
018 LINES=24
019
020 AuswahlMenue ()
021 {
022 Titel="\"$1\""
023 Tasten="$2"
024 Namen="$3"
025
026 IFS=$'\t'
027 set – $Tasten
028 i=1
029 while [ "$#" -gt "0" ]; do
030 Taste[$i]="\"$1\""
031 shift
032 i=$[$i+1]
033 done
034 Elemente="$i"
035
036 IFS=$'\t'
037 set – $Namen
038 i=1
039 while [ "$#" -gt "0" ]; do
040 Name[$i]="\"$1\""
041 shift
042 i=$[$i+1]
043 done
044
045 Menu=""
046 for ((i=1; $i<$Elemente; i=$[$i+1])); do
047 Menu="${Menu}${Taste[$i]}${IFS}${Name[$i]}${IFS}"
048 done
049
050 Overhead="7"
051 if [ "$[$Elemente+$Overhead]" -lt "$LINES" ]; then
052 DisplayLines="$[$Elemente+$Overhead]"
053 else
054 DisplayLines="$LINES"
055 fi
056 DialogParms="--menu $Titel $DisplayLines $[$COLUMNS-8] $[$Elemente-1] $Menu"
057 eval $Dialog $DialogParms $DialogRedirect
058 read < ~/.termine.in
059 }
060 TextEingabe ()
061 {
062 DialogParms="--inputbox \"$1\" 8 $[$COLUMNS-8] \"$2\""
063 eval $Dialog $DialogParms $DialogRedirect
064 read < ~/.termine.in
065 if [ "$REPLY" = "" ]; then
066 REPLY="$2"
067 fi
068 }
069 JaNein ()
070 {
071 DialogParms="--yesno \"$1\" 5 $[$COLUMNS-8]"
072 eval $Dialog $DialogParms $DialogRedirect
073 }
074 Fehler ()
075 {
076 DialogParms="--msgbox \"$1\" 5 $[$COLUMNS-8]"
077 eval $Dialog $DialogParms $DialogRedirect
078 }
079 TerminBearbeiten ()
080 {
081 Nr="$1"
082
083 while true; do
084 Keys="d${IFS}v${IFS}b${IFS}t${IFS}c${IFS}l${IFS}z${IFS}"
085 Menu="Datum: `date -d ${Datum[$Nr]} +%d.%m.%Y`${IFS}Vorwarnung: ${Vorwarnzeit[$Nr]} Tage${IFS}Betreff: ${Bezeichnung[$Nr]}${IFS}Text: ${Text[$Nr]}${IFS}CCs: ${CCs[$Nr]}${IFS}Löschen${IFS}Zurück"
086
087 AuswahlMenue "Termin bearbeiten:" "$Keys" "$Menu"
088 Auswahl="$REPLY"
089
090 case $Auswahl in
091 z|"")
092 break
093 ;;
094 l)
095 JaNein "Termin löschen: Sind Sie sicher?"
096
097 if [ "$?" = "0" ]; then
098 Termine=$[$Termine-1]
099
100 for ((i=$Nr; $i < $Termine; i=$[$i+1])); do
101 Datum[$i]=${Datum[$[$i+1]]}
102 Vorwarnzeit[$i]=${Vorwarnzeit[$[$i+1]]}
103 Bezeichnung[$i]=${Bezeichnung[$[$i+1]]}
104 Text[$i]=${Text[$[$i+1]]}
105 CCs[$i]=${CCs[$[$i+1]]}
106 done
107 fi
108 break
109 ;;
110 d)
111 TextEingabe "Datum, in der Form yyyy-mm-dd:" "`date -d ${Datum[$Nr]} +%Y-%m-%d`"
112 Datum[$Nr]="`date -d $REPLY +%Y%m%d`"
113 ;;
114 v)
115 TextEingabe "Vorwarnzeit in Tagen:" "${Vorwarnzeit[$Nr]}"
116 Vorwarnzeit[$Nr]="$REPLY"
117 ;;
118 b)
119 TextEingabe "Kurze Bezeichnung des Termins:" "${Bezeichnung[$Nr]}"
120 Bezeichnung[$Nr]="$REPLY"
121 ;;
122 t)
123 TextEingabe "Ausführliche Beschreibung, Anmerkungen:" "${Text[$Nr]}"
124 Text[$Nr]="$REPLY"
125 ;;
126 c)
127 TextEingabe "Zusätzliche Empfänger der Warnung (Komma-Trennung):" "${CCs[$Nr]}"
128 CCs[$Nr]="$REPLY"
129 ;;
130 esac
131 done
132 }
133
134 ##### Hauptprogramm #####
135
136 if [ -r ~/.termine ]; then
137 IFS=$'\r'
138 read -a TerminListe << EOF
139 `grep -v "^#" ~/.termine | tr "\n" "$IFS"`
140 EOF
141
142 IFS=$'\t'
143 i=1
144 while [ "${TerminListe[$i]}" != "" ]; do
145 set – ${TerminListe[$i]}
146 Datum[$i]=$1
147 Vorwarnzeit[$i]=$2
148 Bezeichnung[$i]=$3
149 Text[$i]=$4
150 CCs[$i]=$5
151 i=$[$i+1]
152 done
153 Termine="$i"
154 else
155 MailAdresse="${LOGNAME}@localhost"
156 Termine=1
157 fi
158
159 while true; do
160 IFS=$'\t'
161 Keys="0${IFS}\$Keys${IFS}n${IFS}q${IFS}x${IFS}"
162 Menu="Adresse: ${MailAdresse}\$Menu${IFS}Neuer Termin${IFS}Speichern und Ende${IFS}Ende ohne Speichern"
163 for ((i=1; $i < $Termine; i=$[$i+1])); do
164 Keys="${Keys/\$Keys/${IFS}$i\$Keys}"
165 Menu="${Menu/\$Menu/${IFS}`date -d ${Datum[$i]} +%d.%m.%Y`: ${Bezeichnung[$i]}\$Menu}"
166 done
167 Keys="${Keys/\$Keys}"
168 Menu="${Menu/\$Menu}"
169
170 AuswahlMenue "Hauptmenü" "$Keys" "$Menu"
171 Auswahl="$REPLY"
172
173 case $Auswahl in
174 q)
175 if [ ! -e ~/.termine ]; then
176 touch ~/.termine 2>/dev/null
177 fi
178 if [ -w ~/.termine ]; then
179 echo "$MailAdresse" > ~/.termine
180 IFS=$'\t'
181 for ((i=1; $i < $Termine; i=$[$i+1])); do
182 cat >> ~/.termine << EOF
183 ${Datum[$i]}${IFS}${Vorwarnzeit[$i]}${IFS}${Bezeichnung[$i]}${IFS}${Text[$i]}${IFS}${CCs[$i]}
184 EOF
185 done
186 break
187 else
188 Fehler "Die Termine-Datei (~/.termine) lässt sich nicht schreiben."
189 fi
190 ;;
191 x|"")
192 exit 1
193 ;;
194 n)
195 Datum[$Termine]="`date +%Y%m%d`"
196 Vorwarnzeit[$Termine]="2"
197 Bezeichnung[$Termine]=""
198 Text[$Termine]=""
199 CCs[$Termine]=""
200 Termine=$[$Termine+1]
201 TerminBearbeiten $[$Termine-1]
202 ;;
203 0)
204 TextEingabe "Ihre Email-Adresse:" "$MailAdresse"
205 MailAdresse="$REPLY"
206 ;;
207 *)
208 TerminBearbeiten $Auswahl
209 ;;
210 esac
211 done
Qual der Wahl
Die Zeilen 2 bis 15 legen das zu verwendende Frontend fest: gdialog bei Gnome, kdialog unter KDE oder das textbasierte dialog. Deutlich lässt sich in Zeile 7 die Sonderbehandlung von Kdialog erkennen: Hier wird die Standardausgabe in die Datei termine.in umgeleitet, während es bei Dialog und Gdialog die Standard-Fehlerausgabe ist:
dialog … 2>~/.termine.in kdialog … 1>~/.termine.in gdialog … 2>~/.termine.in
Leider akzeptiert die Bash keine Variable an Stelle der Umleitung, weshalb das folgende, kompaktere Listing nicht funktioniert:
#! /bin/bash Redirect="1>~/.termine.in" echo "Test" $Ausgabe
Einzig die eval-Anweisung ermöglicht, die Umleitung flexibel zu gestalten:
#! /bin/bash Redirect="1>~/.termine.in" eval echo "Test" $Ausgabe
Deshalb wird in den Zeilen 2 bis 11 zunächst bestimmt, welches der Programme installiert ist. Dementsprechend speichert das Sktipt den Programmnamen und die passende Umleitung in Variablen.
Weiterhin unterscheidet sich der Funktionsumfang der einzelnen Dialog-Varianten. Im Kasten “Portable Dialog-Funktionen” finden Sie eine Auswahl der Funktionen, die nach Erfahrung des Autors nahezu alle Dialog-Varianten auch in etwas älteren Versionen unterstützen. Damit sind Sie auf der sicheren Seite, wenn es darum geht, das Skript auch auf anderen Systemen einzusetzen. Würden Sie Funktionen verwenden, die etwa Kdialog in der auf Ihrem System installierten Version nicht versteht, bekämen Sie lediglich eine Fehlermeldung auf der (in dem Fall verborgenen) Kommandozeile zu sehen. Ihr Programm würde derweil möglicherweise in einer Endlosschleife festhängen, weil keine Eingabe erfolgt.
Das Listing 1 teilt sich in acht logische Blöcke: Die Anfangs-Definitionen (Zeile 2), fünf Funktionen (Zeile 20 bis 132), das Einlesen der Terminliste (Zeile 136) und das Hauptmenü (Zeile 159).
dialog (oben), gdialog (links unten) und kdialog (rechts unten) werden fast identisch angesteuert, unterscheiden sich aber in Aussehen und Bedienung.” width=”252″ height=”300″ />
dialog (oben), gdialog (links unten) und kdialog (rechts unten) werden fast identisch angesteuert, unterscheiden sich aber in Aussehen und Bedienung.Komplexe Menüs einfach verpackt
Die Funktion AuswahlMenue (Zeile 20 bis 59) präsentiert, wie der Name schon sagt, ein Auswahl-Menü. Der erste Parameter dieser Funktion gibt der Titel des Menüs an, im zweiten lagern die Tastenkürzel als Tabulator-getrennte Liste. Im dritten Parameter finden sich die Beschreibungen der einzelnen Menüpunkte, wiederum durch Tabulatoren getrennt. Die Tastenkürzel aus dem zweiten Parameter nutzt Dialog zudem als Rückgabewert, wenn ein Menüpunkt ausgewählt wurde.
In den Zeilen 26 bis 34 und 33 bis 43 trennt die Funktion die beiden Tabulator-separierten Listen mit Hilfe der IFS-Variablen und dem Befehl set in zwei Arrays auf. Bei der Gelegenheit bestimmt sie in Zeile 34 gleich die Anzahl der Auswahlpunkte des Menüs. Dieser Aufwand ist deshalb erforderlich, weil Dialog Menüs in folgender Schreibweise erwartet:
dialog --menu Titel Menühöhe in Zeilen MenübreiteInZeichen AnzahlMenüeinträge Tastenkürzel Menüpunkt Tastenkürzel Menüpunkt …
In den Zeilen 45 bis 48 baut die Funktion AuswahlMenue das Menü in der von Dialog benötigten Reihenfolge wieder zusammen und speichert das Ergebnis, jeweils mit Tabulator getrennt, in der Variablen Menu. Die Trennung mit Tabulatoren ist deswegen bemerkenswert und wichtig, weil die Menüpunkte selbst natürlich Leerzeichen enthalten können. Ohne Veränderung der Variablen ISF in Zeile 26 könnte Dialog später nicht zwischen einem Leerzeichen innerhalb zwei Worten eines Menüpunkts und der Trennung eines Tastenkürzels vom Text unterscheiden.
Die Variable Overhead in Zeile 50 ist nur für dialog nötig. Einer der Parameter gibt die Größe des Menü-Rahmens an. Dort müssen Dinge wie Überschrift, innere Rahmen und OK- sowie Abbruch-Schaltfläche berücksichtigt sein. Den Wert ermitteln Sie einfach durch Ausprobieren.
In Zeile 56 baut das Skript den Parameter-String für den Dialog-Aufruf zusammen. Dies sorgt dafür, dass jedes Menü in einheitlichem Design erscheint und zum Beispiel der Titel des Menüs stets mit eingebaut wird.
Benutzer-Eingaben per Fehlerausgabe
Die Antwort bei diesem Dialog-Aufruf bildet das Tastenkürzel (Buchstabe) des Menüpunkts, das der Benutzer ausgewählt hat. Dafür eignet sich der Rückgabewert (Exit Value) des Programms nicht, Dialog schreibt den Buchstaben auf die Standard-(Fehler-)Ausgabe. Deshalb ruft Zeile 57 die in den Zeilen 2 bis 10 gewählte Dialog-Variante schließlich mittels eval auf und leitet die Ausgabe, also die Auswahl des Benutzers, in die Datei ~/.termine.in um. Der read-Aufruf in Zeile 58 liest aus der Datei ~/.termine.in und speichert das Ergebnis in der Variablen REPLY.
Den Exit Value von Dialog berücksichtigt Zeile 57 nicht. Er lautet “0”, wenn der Benutzer eine Auswahl gemacht hat, oder “1”, wenn der Benutzer die Eingabe mit [Esc] oder Abbrechen verlässt.
Auch bei der Texteingabe mittels des Dialog-Parameters --inputbox in Zeile 62 und 63 reicht die Rückgabe eines Zahlenwerts via Exit Value nicht aus. Wie beim Menü schreibt Dialog die Eingabe des Benutzers auf die Standard-(Fehler-)Ausgabe. Bricht der Anwender die Eingabe ab, teilt Dialog das wie gehabt über den Exit Value mit.
Antwort als Exit Value
Anders laufen die Dinge bei einer einfachen Ja-Nein-Auswahl mit dem Parameter --yesno, wie in Zeile 71 und 72: Hier wird nur der Exit Value aus der Spezial-Variablen “$?” der Bash gelesen. “0” bedeutet an dieser Stelle “Ja”, “1” dagegen “Nein”.
Bei der Fehlerausgabefunktion in Zeile 74 bis 78 ist der Rückgabewert nicht von Belang. Dialog wird hier mit der Option --msgbox aufgerufen, was den dahinter stehenden Text in einem kleinen Fenster auf dem Bildschirm anzeigt. Der Benutzer hat nur die Möglichkeit, OK zu wählen.
Die Verwendung der Ausgabefunktionen von Zeile 20 bis 78 zeigt das Hauptprogramm ab Zeile 136. In den Zeile 161 und 162 sehen Sie das Hauptmenü des Termin-Clients: Tabulatoren trennen die Tastenkürzel in der Zeile 161; das gilt auch für die Beschreibungen der einzelnen Menüpunkte. Dies erlaubt, in den Beschreibungen Leerzeichen zu verwenden.
Menü-Aufbau im Hauptprogramm
Die Schleife von Zeile 163 bis 166 fügt dem Hauptmenü alle bereits vorhandenen Termine an, um sie bearbeiten zu können. Die Ausgabe über Dialog erfolgt schließlich in Zeile 170. Dazu rufen Sie einfach die Funktion auf und übergeben das Menü in zwei Variablen. Zeile 171 liest die Rückgabe des Aufrufs aus der Variablen REPLY, die von der Funktion AuswahlMenue gesetzt wurde.
Der Auswahlblock von Zeile 173 bis zum Ende des Programms behandelt die Eingabe des Benutzers, konkret das Tastenkürzel, das Dialog zurückgeliefert hat. Dialog interessiert sich nicht dafür, ob ein Tastenkürzel im Menü mehrfach vergeben wurde – bei der Auswertung der Rückgabe würde dies aber zu Chaos führen. Deshalb ist beim Aufbau des Hauptmenüs in Zeile 161 bis 166 besondere Umsicht geboten.
Will der Benutzer das Programm mit “q” verlassen, speichert der Termin-Client noch alle Termine und verlässt dann die Hauptschleife. Zeile 188 zeigt, wie Sie die Fehlerfunktion verwenden, falls das Speichern nicht geklappt hat.
Spitzfindigkeiten beim Datum
Das Tastenkürzel “0” ändert die eingestellte E-Mail-Adresse. Dazu benutzt das Programm die Funktion TextEingabe. Wie schon beim Menü übergeben Sie den anzuzeigenden Text sowie die Voreinstellung für die Eingabe einfach als Parameter der Funktion. Die Eingabe des Benutzers finden Sie in REPLY, wobei die Funktion wie oben beschrieben nicht berücksichtigt, dass der Benutzer die Eingabe auch abgebrochen haben könnte. In dem Fall ist die Variable REPLY leer.
Falls der Benutzer einen neuen Timer eingeben oder einen vorhandenen bearbeiten möchte, ruft das Hauptprogramm die Funktion TerminBearbeiten auf (Abbildung 2). Der Aufbau dieser Funktion ähnelt dem des Hauptmenüs.
dialog lassen sich Einstellungen sehr übersichtlich ändern, die Menüführung nimmt vielen unerfahrenen Benutzern die Angst vor der Kommandozeile.” width=”262″ height=”300″ />
Abbildung 2: Anpassen eines Termins: Mitdialog lassen sich Einstellungen sehr übersichtlich ändern, die Menüführung nimmt vielen unerfahrenen Benutzern die Angst vor der Kommandozeile.Eine Besonderheit versteckt sich in der Zeile 85: Die Terminliste speichert das Datum stets als achtstellige Zahl bestehend aus Jahr, Monat und Tag ohne Trennzeichen. Der Benutzer wünscht jedoch die Anzeige in der gewohnten Form Tag, Monat und Jahr getrennt durch Punkte. Der Befehl
date -d ${Datum[$Nr]} +%d.%m.%Y
wandelt deshalb am Anfang von Zeile 85 das kompakte Datum in die übliche deutsche Schreibweise um. Bei der Datumseingabe spielt uns jedoch date einen Streich: Das Kommando akzeptiert das Datum in der üblichen deutschen Schreibweise nicht, sondern nur in der englischen oder international gebräuchlichen. In der Zeile 111 erinnert der Termin-Client deshalb daran, dass an dieser Stelle nicht die übliche deutsche Schreibweise möglich ist.
Alles bunt!
Dialog beweist, dass selbst kleine Skripte eine ansprechende Benutzeroberfläche haben können und der Benutzer nicht genötigt werden muss, unübersichtliche Abfragen auf der Kommandozeile zu bedienen.
Die Kompatibilität von Gdialog und Kdialog zu Dialog erlaubt sogar, die Kommandozeile komplett vor dem Benutzer zu verbergen, sofern er mit einem grafischen System arbeitet. Der zusätzliche Programmieraufwand dafür hält sich in Grenzen, wie das Beispiel des Termin-Clients zeigt.
Als Lohn für die Mühe winkt meist eine größere Verbreitung des Skripts, wie der Autor selbst durch die Einführung des Dialog-basierten Installationssystem der Mini-Distribution LinVDR erlebt hat. Wenn die Kommandozeile nicht mehr zu Tage tritt, trauen sich auch viele Einsteiger den Umgang mit der Software zu.
Portable Dialog-Funktionen
Die folgenden Liste von Dialog-Funktionen basiert auf praktischen Erfahrungen des Autors und lässt sich über ein großes Versionsspektrum von dialog, gdialog und kdialog einsetzen.
Weitere Funktionen finden Sie in den jeweiligen Manual Pages der Programme. Bei älteren Versionen, wie sie zum Beispiel auf fremden Systemen noch im Einsatz sind, können diese Funktionen aber durchaus noch fehlen.
dialog --checklist Titel Anzeigehöhe Anzeigebreite Auswahlzeilen [ Kurztaste Beschreibung Status ]
Auswahlliste mit der Überschrift Titel. Das Fenster in der Größe Anzeigehöhe mal Anzeigebreite umfasst Auswahlzeilen Einträge. Jeder Eintrag besteht aus der Kurztaste Kurztaste sowie der zugehörigen Beschreibung Text und hat entweder den Status “on” oder “off”.
Beendet der Benutzer die Auswahl mit OK, endet Dialog mit dem Exit Value “0” und liefert die Kurztasten aller aktivierten Einträge, in Anführungszeichen eingeschlossen und mit Leerzeichen getrennt, über die Standard-(Fehler-)Ausgabe zurück. Bricht der Benutzer die Auswahl ab, liefert Dialog den Exit Value “1”; drückt er [Esc], gibt Dialog den Wert “255” zurück.
dialog --inputbox Text Anzeigehöhe Anzeigebreite [ Standardwert ]
Texteingabefeld der Größe Anzeigehöhe mal Anzeigebreite, in dem Text und eine Eingabezeile stehen. Wird Standardwert beim Aufruf übergeben, füllt Dialog die Eingabezeile entsprechend.
Die Länge der Eingabezeile ist theoretisch nicht begrenzt. Der Autor empfiehlt aber, keine Eingaben länger als 255 Zeichen abzufragen. Eine mehrzeile Eingabe lässt sich nicht realisieren.
Bestätigt der Benutzer die Eingabe mit OK, liefert Dialog den Inhalt der Eingabezeile per Standard-(Fehler)-Ausgabe zutück, der Exit Value lautet “0”. Bei Abbruch gibt Dialog als Exit Value “1” zurück; drückt der Benutzer [Esc], liefert es “255”.
dialog --menu Titel Anzeigehöhe Anzeigebreite Menüzeilen [ Kurztaste Menütext ]
Auswahlmenü, über dem Titel angezeigt wird. Das Fenster der Größe Anzeigehöhe mal Anzeigebreite umfasst Menüzeilen Menüeinträge. Jeder Menüeintrag besteht aus der Kurztaste Kurztaste und der zugehörigen Beschreibung des Menüpunkts, Menütext. Wird ein Menüpunkt ausgewählt, liefert Dialog die Kurztaste des betreffenden Menüpunkts über Standard-(Fehler-)Ausgabe zurück und endet mit dem Exit Value “0”. Bricht der Benutzer die Auswahl ab, liefert Dialog den Exit Value “1”; drückt er [Esc], gibt Dialog den Wert “255” zurück.
dialog --msgbox Meldung Anzeigehöhe Anzeigebreite
Benachrichtigungsfeld in der Größe Anzeigehöhe mal Anzeigebreite, in der die Meldung ausgegeben wird. Der Benutzer kann lediglich mit OK bestätigen. Dialog gibt dann den Exit Value “0” zurück. Drückt der Anwender [Esc], liefert es den Exit Value “255”.
dialog --radiolist Titel Anzeigehöhe Anzeigebreite Auswahlzeilen [ Kurztaste Beschreibung Status ]
Auswahlliste ähnlich --checkbox, über der Titel angezeigt wird. Das Fenster der Größe Anzeigehöhe mal Anzeigebreite umfasst Auswahlzeilen Einträge. Jeder Eintrag besteht aus der Kurztaste Kurztaste sowie der zugehörigen Beschreibung Text.
Im Unterschied zur --checkbox darf jedoch nur genau ein Eintrag den Status “on” haben. Alle anderen müssen den Status “off” haben, anderenfalls funktioniert die Auswahl nicht.
Der Benutzer kann nur genau einen Eintrag aktivieren. Beendet er die Auswahl mit OK, liefert Dialog die Kurztaste des aktivierten Eintrags über die Standard-(Fehler-)Ausgabe zurück und terminiert mit Exit Value “0”. Bricht der Benutzer die Auswahl ab, liefert Dialog den Exit Value “1”. Drückt er [Esc], beendet Dialog mit dem Rückgabewert “255”.
dialog --textbox Dateiname Anzeigehöhe Anzeigebreite
Dateibetrachter, der den Inhalt der Datei Dateiname in einem Fenster der Größe Anzeigehöhe mal Anzeigebreite anzeigt. Der Benutzer kann beliebig im Text blättern und den Betrachter mit Verlassen beenden, wobei Dialog den Exit Value “0” zurück liefert. Drückt der Benutzer [Esc], terminiert Dialog mit dem Exit Value 255.
dialog --yesno Meldung Anzeigehöhe Anzeigebreite
Ja/Nein-Abfrage in der Größe Anzeigehöhe mal Anzeigebreite, in der die Meldung ausgegeben wird. Im Gegensatz zum Benachrichtigungsfeld kann der Benutzer zwischen Ja (Exit Value “0”) und Nein (Exit Value “1”) wählen. Drückt er [Esc], lautet der Rückgabewert “255”.
Infos
[1] Mirko Dölle: “Komfortable Dialoge”, LinuxUser 02/2004, Seite 42; Online unter http://www.linux-user.de/ausgabe/2002/02/042-pcorner/pcorner7.html
