<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">\chapter{Scripting}

Damit auch Shell-Skripte mit einer interaktiven CUI Benutzerschnittstelle
versehen werden k"onnen, wurde die libCUI um die Funktion einer Shell-API
erweitert. Dabei wurde bewusst auf die Einbindung einer Skript-Sprache wie
Perl oder Python verzichtet, da damit die Integration in ein Basissystem,
wie das von eisfair, problematisch w"are. Statt dessen stehen die Funktionen
direkt f"ur die Bash zur Verf"ugung, die als Hintergrundprozess von einem
Frontend-Programm ausgef"uhrt wird.

Die Programmierung entspricht in weiten Teilen der CUI-Programmierung
in der Sprache C. Darum ist es in jedem Fall ratsam, das Kapitel ''Elementare
Fenstertechnik'' gelesen zu haben. Zudem wird hier lediglich eine
prinzipielle Beschreibung der Einbindung von Shell-Skripten geliefert.
Eine Refenrez aller API-Funktionen befindet sich im Anhang A.

\section{Funktionsprinzip}

Damit ein Shell-Skript eine CUI-Oberfl"ache benutzen kann, muss es als
Hintergrundprozess von einem Frontend-Programm ausgef"uhrt werden. Das
Frontend f"ur allgemeine Skripte hei"st ''shellrun.cui'', aber auch der
Konfigurationseditor, ''edit-conf.cui'', kann Skripte als Co-Prozess
ausf"uhren.

Im Falle von ''shellrun.cui'' wird das jeweilige Skript dem Frontend-Programm
als Argument "ubergeben. Man kann damit z.B. Curses-Men"us zur Auswahl von
Funktionen o."a. realisieren, wie sie h"aufig Paketentwicklung vorkommen.
Man kann aber auch Oberfl"achen schreiben, mit denen der Anwender seine
Daten pflegen oder Dateien ausw"ahlen kann. Generell ist hier nahezu
alles denkbar, was mit einem Shell-Skript machbar ist.

Auch der Konfigurationseditor (allgemein als ECE bezeichnet) verf"ugt "uber
die M"oglichkeit Shell-Skripte
auszuf"uhren. Dies dient dazu, die Eingabezeile im ECE gegen einen Dialog
zu ersetzen, der z.B. eine Auswahlliste f"ur Werte anbietet oder die
Benutzereingabe auf andere Weise erleichtert. Welches Skript aufgerufen
werden soll ermittelt das Programm dabei aus der Paketkonfiguration.

Das Frontend-Programm erzeugt nach dem Programmstart zwei Named-Pipes f"ur
die Client-Server Kommunikation (\$HOME/.cui/&lt;proc-id&gt;rp und
\$HOME/.cui/&lt;proc-id&gt;wp) und erwartet von dem Shell-Skript, dass
dieses die Pipes "offnet und eine Verbindung initiiert.
Dazu gibt es bereits vorbereitete Funktionen
die in das Shell-Skript auf einfache Weise eingebunden werden k"onnen.

Ist die Verbindung einmal hergestellt, dann fungiert das Frontend als
eine Art Window-Manager (Server), der vom Shell-Skript (Client) API-Befehle
z.B. zur Konstruktion von Fenstern entgegen nimmt. Letzteres wiederum wird
vom Frontend mit Informationen "uber Benutzereingaben in Form von
Call-Back Routinen benachrichtigt.

Der Programmablauf in der Shell erfolgt nicht mehr, wie gewohnt, in
linearer Form, sondern ist Ereignisorientiert, wie man das von
der Programmierung graphischer Oberfl"achen her kennt. Diese Vorgehensweise
ist f"ur einen routinierten Skript-Programmierer anf"anglich sicher
etwas ungewohnt.

Der grundlegende Aufbau eines CUI-f"ahigen Shell-Skripts sieht wie folgt aus:

\begin{verbatim}
    #!/bin/sh

    . /var/install/include/cuilib
    [ evtl. weitere includes ]

    [ Skript-Funktionen ]

    cui_init
    cui_run

    exit 0
\end{verbatim}

Die vollst"andige Funktionalit"at des Skriptes steckt in Funktionen,
die vom Frontend aufgerufen werden. Der Programmfluss l"auft linear bis
zu der Funktion ''cui\_run'' durch und bleibt dort ein einer Schleife
h"angen, die st"andig die Eingabe-Pipe "uberwacht. Trifft dort ein
Funktionsaufruf vom Frontend ein
(Ereignis), dann wird eine Funktion unter dem entsprechenden Namen aufgerufen.
Diese sollte nat"urlich unbedingt im Skript existieren! Da bis auf die
Einstiegsfunktioin alle
Ereignisroutinen vom Shell-Programmierer explizit beim Frontend angemeldet werden,
ist das aber kein Problem. Wichtig ist jedoch, dass die Funktionen oberhalb von
''cui\_run'' und nach dem Source-Include der cuilib implementiert sind.

Welche Funktion vom Frontend zuerst aufgerufen wird (Einstiegsfunktion), ist vom
jeweiligen Programm abh"angig. Bei shellrun.cui hei"st sie ''init'' beim ECE
werden nacheinander die Funktionen ''setdata'', ''exec\_dialog'' und ''getdata''
aufgerufen. In jedem Fall beendet sich die Warteschleife in ''cui\_run'',
wenn die Funktion ''exit'' aufgerufen wird (die nicht implementiert sein muss / darf).

Eine Funktion, die vom Frontend aufgerufen wurde, muss unbedingt mit ''cui\_return''
beendet werden. Anderenfalls wartet das Frontend vergeblich auf eine R"uckmeldung,
was ein beliebter Fehler ist, nach dem man beliebig lange suchen kann. Die
"ubergabeparameter vom Frontend an das Skript sind in den Variablen \$p2..\$pn
gespeichert (das ist f"ur die jeweilige Funktion fest definiert). Der
R"uckgabewert wird an ''cui\_return'' "ubergeben.

Innerhalb der Funktionen, die vom Frontend aus aufgerufen werden, kann das Skript
wiederum API-Funktionen des Frontends nutzen. Diese sind in der Referenz im Anhang
aufgef"uhrt und dienen zum Anlegen und Steuern von Kontrollelementen und vielem mehr.

Der R"uckgabewert der API-Script-Funktion (\$?) zeigt an, ob der Aufruf erfolgreich
war oder ob w"ahrend der Verarbeitung etwas schiefgegangen ist. Bei den meisten
Funktionen kann man ihn ignorieren. Die R"uckgabewerte des Frontends wiederum
sind wiederum in den Variablen \$p2..\$pn zu finden und f"ur die jeweilige
API-Funktion genau definiert.

Beispiel:

\begin{verbatim}
    local ctrl="0"

    cui_window_getctrl "$win" "$IDC_COLORS"
    if [ "$p2" != "0" ]
    then
        ctrl="$p2"     # gefunden!
    fi
\end{verbatim}

sucht das Kindfenster von \$win mit der ID \$IDC\_COLORS. Der R"uckgabewert
in \$p2 ist das Window-Handle des Kindfensters oder 0, falls dieses nicht
gefunden wurde.

Wichtig ist, dass man in Funktionen, wann immer es m"oglich ist, mit lokalen
Variablen arbeitet. Daf"ur kennt die bash das Schl"usselwort ''local''.
Anderenfalls riskiert man, dass die gleichlautende Variable in einer
anderen Funktion unbemerkt "uberschrieben wird.

\section{Ablaufverfolgung}

Die Ausgabe von Text "uber die Standardausgabe ist unter dem Curses-Frontend
(z.B. mit echo) nicht mehr m"oglich. F"ur Debug Zwecke gibt es jedoch den
Kommandozeilenschalter $-$$-$debug "uber den sowohl die Frontend-Backend
Kommunikation, als auch die Standardausgabe in die Datei
/tmp/outcui.log ausgegeben wird. Mit

less +F /tmp/outcui.log

erh"alt man eine Art Trace-Output, "uber den der Programmablauf in Echtzeit
verfolgt werden kann.

Der Trace ist vor allem immer dann interessant, wenn man
verfolgen m"ochte, welche API-Funktionen und Callbacks in welcher Reihenfolge
aufgerufen werden, da auf diese Weise sichtbar wird wo sich ggf. die
Kommunikation aufgeh"angt oder das Backend-Skript beendet hat.

Ein Ausschnitt aus einem typischen Trace sieht beispielsweise wie folgt aus:

\begin{verbatim}
-&gt; H    init
&lt;- C    1               0       0       0       0       45058
-&gt; R    0       134624472
&lt;- C    32      134624472       DESKTOP
-&gt; R    0
&lt;- C    40      134624472       Eisfair User Manager
-&gt; R    0
&lt;- C    44      134624472       Commands: F10=Exit
-&gt; R    0
&lt;- C    45      134624472       V1.0.0
-&gt; R    0
...
&lt;- H    1
\end{verbatim}

In der ersten Spalte steht in welche Richtung die Daten geflossen sind und
um welche Art von Aufruf es sich handelt. Dies entspricht der folgenden Tabelle:

\begin{tabularx}{\textwidth}[t]{l|X}
\bf{Aufruf}&amp; \bf{Bedeutung}\\
\hline
-&gt; H  &amp; Der Server Ruft eine Hook-Funktion auf. Der Name der Funktion
        steht im ersten Parameter. \\
&lt;- H  &amp; Der Client beendet eine Hook-Funktion mit ''cui\_return''. Der
        R"uckgabewert steht im ersten Parameter. \\
&lt;- C  &amp; Der Client ruft eine API-Funktion auf. Die Nummer der Funktion
        steht im ersten Parameter. \\
-&gt; R  &amp; Das Frontend beendet eine API-Funktion. Der erste Parameter
        ist bei Erfolg immer 0, dann folgen die R"uckgabewerte. \\
\end{tabularx}

API-Aufrufe werden durch ihre Nummer repr"asentiert. Die entsprechenden Nummern
k"onnen in der Datei ''/var/install/include/cuilib'' nachgelesen werden. F"ur
das Beispiel oben finden sich z.B. die folgenden Definitionen in der Datei:

API\_WINDOWNEW = 1 \\
API\_WINDOWCOLSCHEME = 32 \\
API\_WINDOWSETTEXT = 40 \\
API\_WINDOWSETLSTATUSTEXT = 44 \\
API\_WINDOWSETRSTATUSTEXT = 45 \\

\section{Scriptf"ahige Anwendungen und deren API}

\subsection{shellrun.cui}

Mit ''shellrun.cui'' lassen sich eigenst"andige interaktive CUI Skript-Programme
realisieren. Die Einstiegsfunktion die ''shellrun.cui'' im Skript-Programm zwingend
voraussetzt hei"st ''init()''. Alles weitere h"angt davon ab, wie die Anwendung
in der Initialisierungsfunktion eingerichtet wurde.

Das wohl einfachste Programm f"ur ''shellrun.cui'' sieht folgenderma"sen aus:

\begin{verbatim}

#!/bin/sh

. /var/install/include/cuilib

#-----------------------------------------------------------------
# init routine (entry point of all shellrun.cui based programs)
#    $p2 --&gt; desktop window handle
#-----------------------------------------------------------------

init()
{
    cui_message "$p2" "Hallo Welt" "Hallo" "$MB_OK"
    cui_return 0
}

#-----------------------------------------------------------------
# main routines (always at the bottom of the file)
#-----------------------------------------------------------------

cui_init
cui_run

exit 0

\end{verbatim}

Im vorliegenden Fall wird in der init-Routine lediglich ein Mitteilungsfenster angezeigt.
Anschlie"send wird die Routine beendet, ohne dass weitere Fenster erzeugt werden. Gibt es
nach Beenden von ''init()'' kein aktives Fenster mehr, dann beendet sich ''shellrun.cui''
automatisch - wurden dagegen Fenster angelegt, dann l"auft das Programm weiter,
bis die Funktion ''cui\_window\_quit'' explizit aufgerufen wird.

Der Aufruf von ''cui\_message'' "offnet ein modales Mitteilungsfenster und zeigt darin den
angegebenen Text an. Der Programmfluss bleibt bei ''cui\_message'' stehen, bis der Anwender
das Fenster mit OK schlie"sst. Die Definition der API-Funktion ''cui\_message'' kann der
Referenz entnommen werden.

Wurde das Programm unter dem Namen ''sayhallo.sh'' abgespeichert, dann gibt es
zwei M"oglichkeiten es aufzurufen - direkt und indirekt:

\begin{verbatim}
eis # /var/install/bin/shellrun.cui ./sayhallo.sh
\end{verbatim}

oder

\begin{verbatim}
eis #./sayhallo.sh
\end{verbatim}

im zweiten Fall sorgt das Skript selbst f"ur den Aufruf von ''shellrun.cui''.

Ein f"ur ''shellrun.cui'' erstelltes Skript-Programm kann selbstverst"andlich um
einiges komplexer sein als das hier gezeigte Beispiel. F"ur eine weiterf"uhrende
Beschreibung wird an anderer Stelle ein Tutorial entstehen.

\subsection{edit-conf.cui}

Der Konfigurationseditor ''edit-conf.cui'' zeigt im Normalfall einen Dialog mit
einer einfachen Eingabezeile um einen Wert in der Konfiguration zu bearbeiten.
Dieses Verhalten l"a"st sich mit einem Shell-Skript "andern, das im Verzeichnis
''/var/install/dialog.d'' abgelegt wird. Man kann auf diese Weise Dialoge
schreiben, die beispielsweise Auswahllisten anzeigen oder komplexe Werte aus
mehreren Eingabeelementen zusammensetzen.

Soll eine Konfigurationsvariable bearbeitet werden, dann sucht der Editor
im Verzeichnis ''/var/install/dialog.d'', ob dort eine Datei liegt, die sich
einer Pr"ufregel der Variablen aus der Datei ''/etc/check.d/\$package'' zuordnen
l"a"st. Wird eine solche Datei gefunden, dann wird sie als Shell-Skript ausgef"uhrt.

Beispiel:

Eine Zeile in der Datei ''/etc/check.d/foo''...

\begin{verbatim}
FOO_VALUE       -           -         FOO_EDIT
\end{verbatim}

...veranlasst den Editor im Verzeichnis ''/var/install/dialog.d'' nach einer
Datei mit dem Namen ''FOO\_EDIT.sh'' zu suchen. Ist sie vorhanden, dann wird sie als
Backend-Skript ausgef"uhrt. Anderenfalls wird der Standarddialog verwendet.

Das Programm ''edit-conf.cui'' erwartet drei Einstiegsfunktionen im Skriptprogramm:
''setdata()'', ''exec\_dialog()'' und ''getdata()''. Zun"achst wird die Funktion
''setdata()'' aufgerufen, "uber die dem Skript der aktuelle Wert der zu "andernden
Variablen mitgeteilt wird. Anschlie"send f"uhrt ''edit-conf.cui'' die Funktion
''exec\_dialog()'' aus, die den Dialog zur Bearbeitung des Wertes anzeigt.
Wird ''exec\_dialog()'' mit dem R"uckgabewert ''\$IDOK'' beendet, dann wird der
ge"anderte Wert "uber ''getdata()'' abgerufen, gepr"uft und der Variablen zugewiesen.
Ein R"uckgabewert von ''\$IDCANCEL'' dagegen f"uhrt dazu, dass die Bearbeitung ohne
Zuweisung abgebrochen wird.

Ein einfaches (und zugleich v"ollig sinnloses) Beispielprogramm sieht wie folgt aus:

\begin{verbatim}

#!/bin/sh

. /var/install/include/cuilib

value=""

#-----------------------------------------------------------------
# setdata routine (set value to be modified)
#    $p2 --&gt; value
#-----------------------------------------------------------------

setdata()
{
    value="$p2"
    cui_return 1
}

#-----------------------------------------------------------------
# getdata routine (return modified value)
#-----------------------------------------------------------------

getdata()
{
    cui_return "$value"
}

#-----------------------------------------------------------------
# exec_dialog routine (show edit dialog)
#    $p2 --&gt; parent window handle
#    $p3 --&gt; name of config variable
#-----------------------------------------------------------------
exec_dialog()
{
    local dlg="$p2"

    cui_message "$dlg" "Wert wirklich "andern?" "Frage" "$MB_YESNO"
    if [ "$p2" == "$IDYES" ]
    then
        value="ge"andert"
        cui_return "$IDOK"
    else
        cui_return "$IDCANCEL"
    fi
}

#-----------------------------------------------------------------
# main routines (always at the bottom of the file)
#-----------------------------------------------------------------

cui_init
cui_run

exit 0

\end{verbatim}

Die Programmierung von Dialogen f"ur den ECE l"a"st sich vereinfachen, indem
die Include-Datei ''/var/install/include/ecelib'' in das Skript eingebunden
wird. Sie implementiert die Funktionen ''getdata()'' und ''setdata()'' und
bietet ein paar Standarddialoge f"ur Auswahllisten und "ahnliche Standardaufgaben.

\subsubsection{ece\_select\_list\_dlg}

Der in der ecelib definierte Dialog ''ece\_select\_list\_dlg'' implementiert eine
einfache Auswahlliste, die zentriert "uber dem Editorfenster angezeigt wird. Der
Anwender kann dabei aus einer Reihe m"oglicher Werte w"ahlen und den gew"unschten
Wert (z.B. mit Enter) best"atigen. Die Auswahl wird dann in die bearbeitete
Konfigurationsvariable des ECE "ubertragen.

Eine m"ogliche Verwendung des Dialogs ist im folgenden Listing dargestellt:

\begin{verbatim}
#!/bin/sh

. /var/install/include/cuilib
. /var/install/include/ecelib

#-----------------------------------------------------------------
# exec_dailog
# ece --&gt; request to create and execute dialog
#         $p2 --&gt; main window handle
#         $p3 --&gt; name of config variable
#-----------------------------------------------------------------
exec_dialog()
{
    local win="$p2"

    sellist="BLACK,RED,GREEN,BROWN,BLUE,MAGENTA,CYAN,LIGHTGRAY,"
             DARKGRAY,LIGHTRED,LIGHTGREEN,YELLOW,LIGHTBLUE,
             LIGHTMAGENTA,LIGHTCYAN,WHITE"

    ece_select_list_dlg "$win" "Colors" "$sellist"
}

#-----------------------------------------------------------------
# main routine
#-----------------------------------------------------------------

cui_init
cui_run

#-----------------------------------------------------------------
# end
#-----------------------------------------------------------------

exit 0

\end{verbatim}

Bei diesem Beispiel wird folgende Auswahlliste ausgegeben:
\begin{verbatim}
+----------[ Colors ]-----------+
|                               |
| +-------------------------+^| |
| | BLACK                   | | |
| | RED                     | | |
| |&lt;GREEN =================&gt;| | |
| | BROWN                   | | |
| | BLUE                    | | |
| | MAGENTA                 | | |
| | CYAN                    | | |
| +-------------------------+v+ |
|     [&lt; OK &gt;] [ Cancel ]       |
|                               |
+-------------------------------+
\end{verbatim}

Zu beachten ist, dass die Funktion ''ece\_select\_list\_dlg''
die Behandlung des R"uckgabewertes an den ECE "ubernimmt. Deshalb ist
der Aufruf von ''cui\_return'' in der Funktion ''exec\_dialog'' nicht
mehr n"otig und auch nicht mehr erlaubt.

\subsubsection{ece\_comment\_list\_dlg}

Der Dialog ''ece\_comment\_list\_dlg'' ist eine Erweiterung des ''ece\_select\_list\_dlg''
Dialogs. Hier ist es m"oglich neben den Auswahloptionen Kommentare anzugeben, die
gemeinsam mit den Auswahlwerten in einer zweispaltigen Auswahlliste dargestellt
werden. Auf diese Weise sieht der Anwender nicht nur die Optionen (die f"ur sich gesehen
u.U. vergleichsweise nichtssagend sind), sondern auch einen erkl"arenden Text, der die Auswahl
erleichtert.

Ein Beispiel ist im folgenden Listing dargestellt:

\begin{verbatim}
#!/bin/sh

. /var/install/include/cuilib
. /var/install/include/ecelib

#-----------------------------------------------------------------
# exec_dailog
# ece --&gt; request to create and execute dialog
#         $p2 --&gt; main window handle
#         $p3 --&gt; name of config variable
#-----------------------------------------------------------------
exec_dialog()
{
    local win="$p2"

    sellist="option1|Dies ist Option1,option2|Dies ist Option2,
             option3|Dies ist Option3,option4|Dies ist Option4"

    ece_comment_list_dlg "$win" "Optionen" "$sellist"
}

#-----------------------------------------------------------------
# main routine
#-----------------------------------------------------------------

cui_init
cui_run

#-----------------------------------------------------------------
# end
#-----------------------------------------------------------------

exit 0

\end{verbatim}

Bei diesem Beispiel wird folgende Auswahlliste ausgegeben:
\begin{verbatim}
+-------------[ Optionen ]----------------+
|                                         |
| +-----------------------------------+^| |
| | option1    | Dies ist Option1     | | |
| | option2    | Dies ist Option2     | | |
| |&lt;option3 ===| Dies ist Option3 ===&gt;| | |
| | option4    | Dies ist Option4     | | |
| +-----------------------------------+v+ |
|          [&lt; OK &gt;] [ Cancel ]            |
|                                         |
+-----------------------------------------+
\end{verbatim}

Wie schon beim vorhergehenden Beispiel darf die Funktion ''exec\_dialog'' auch hier
nicht mit einem Aufruf von ''cui\_return'' abgeschlossen werden, da dies
bereits im Dialog selbst erfolgt ist.

\subsubsection{ece\_select\_cblist\_dlg}

    Der in der ecelib definierte Dialog ''ece\_select\_cblist\_dlg'' implementiert
    eine Auswahlliste unter Nutzung von Check Boxen, die zentriert "uber dem
    Editorfenster angezeigt wird.
    Der Anwender kann dabei einer Reihe m"oglicher Werte unter Nutzung der
    Cursortasten ansteuern und "uber die Space Taste ausw"ahlen. Ausgew"ahlte
    Werte werden mit [x] markiert. Nicht ausgew"ahlte Werte
    haben die Markierung [ ]. Die gew"unschten Werte k"onnen (z.B. mit Enter)
    best"atigen werden. Die Auswahl wird dann in die
    bearbeitete Konfigurationsvariable des ECE "ubertragen.

Beispiel f"ur die Verwendung des Dialogs ece\_select\_cblist\_dialog :
\begin{verbatim}
#!/bin/sh

. /var/install/include/cuilib
. /var/install/include/ecelib

#-----------------------------------------------------------------
# exec_dailog
# ece --&gt; request to create and execute dialog
#         $p2 --&gt; main window handle
#         $p3 --&gt; name of config variable
#-----------------------------------------------------------------
exec_dialog()
{
  local win="$p2"

  sellist='apache2,ldapserver,mail,mini_httpd,partimg,pure-ftpd,ssmtp'

  ece_select_cblist_dlg "$win" \
      "Select one or more elements from a list" "$sellist"
}

#-----------------------------------------------------------------
# main routine
#-----------------------------------------------------------------

cui_init
cui_run

#-----------------------------------------------------------------
# end
#-----------------------------------------------------------------

exit 0
\end{verbatim}

Bei diesem Beispiel wird folgende Auswahlliste ausgegeben:
\begin{verbatim}
+-[ Select one or more elements from a list ]-+
|                                             |
|  [x] apache2                                |
|  [ ] ldapserver                             |
|  [ ] mail                                   |
|  [ ] mini_httpd                             |
|  [ ] partimg                                |
|  [x] pure-ftpd                              |
|  [ ] ssmtp                                  |
|                                             |
|           [&lt;  OK  &gt;]  [ Cancel ]            |
|                                             |
+---------------------------------------------+
\end{verbatim}

F"ur maximal 15 Elemente ist Platz auf einem 80/25 Display,
daher wird bei mehr als 15 Elemente eine Fehlermeldung erzeugt:
\begin{verbatim}
+----[ Checkbox selection ]----+
|                              |
|  Too many elements (16/15).  |
|                              |
|          [&lt;  OK  &gt;]          |
+------------------------------+
\end{verbatim}
Es k"onnen selbstverst"andlich auch l"angere Elemente angezeigt
und ausgew"ahlt werden, allerdings ist die Ausgabe auf 58 Zeichen
begrenzt. Die restlichen Zeichen werden durch ein .. angedeutet.

Beispiel:
\begin{verbatim}
+-----------[ Select one or more elements from a list ]------------+
|                                                                  |
|  [ ] dies ist ein ziemlich langer Text der auch ziemlich viel U..|
|  [ ] dies nicht                                                  |
|                                                                  |
|                      [&lt;  OK  &gt;]  [ Cancel ]                      |
|                                                                  |
+------------------------------------------------------------------+
\end{verbatim}


ACHTUNG:
Es wird nicht gepr"uft, ob ein Element mehrfach vorkommt.

Mittels der Variablen ECE\_SELECT\_CBLIST\_VAL\_SEPARATOR
kann der Separator der Select-Liste eingestellt werden.

ECE\_SELECT\_CBLIST\_VAL\_SEPARATOR=':'\\
setzt z.B. den Separator auf den Doppelpunkt.
</pre></body></html>