DialogBox¶

Mit der Funktion DialogBox können Dialogfelder mit den Dialogelementen Textfeld, Editierfeld, Listenfeld, mehrfach selektierbares Listenfeld, Reportliste (Liste mit mehreren Spalten), Kombinationsfeld (Combo-Box), Kontrollfeld (Check-Box), Propertyliste, Gruppenfeld, Baumlisten und Schaltfläche erzeugt werden.

svReturn = DialogBox(svTemplate)
svReturn = DialogBox(svTemplate, svInitString)
svReturn = DialogBox(svTemplate, svInitString, ssTitle)
svReturn = DialogBox(svTemplate, svInitString, ssTitle, ssHelpItem)
svReturn = DialogBox(svTemplate, svInitString, ssTitle, ssHelpItem, obj)
svReturn = DialogBox(svTemplate, svInitString, ssTitle, ssHelpItem, obj, ssWizard)

Returnwert

Wenn der Benutzer die OK-Schaltfläche drückt, ist svReturn ist ein Stringvektor mit den angezeigten Eingaben. Wenn der Benutzer die Schaltfläche Abbrechen betätigt hat, enthält svReturn[1] den Wert "DLG_CANCEL". Bei einem Fehler (fehlerhafte Eingabeparameter) gibt die Funktion den Zahlenwert -1 zurück.

Parameter

svTemplate: Der Parameter svTemplate ist ein Stringvektor. Für jede Zeile im Dialogfeld enthält der Vektor einen String. In jeder Zeile können Dialogelemente definiert werden. Jede Dialogelement-Definition beginnt und endet mit dem Oder-Zeichen ("|"). Dem einleitenden Oder-Zeichen folgen ein oder zwei Buchstaben (außer beim Editierfeld), die den Typ des Dialogelements beschreiben. Der String kann auch einfachen Text enthalten, der im Dialogfeld angezeigt wird. Die Höhe und Breite des Dialogfelds wird durch die Anzahl der Elemente sowie die größte Stringlänge bestimmt. Bei mehrzeiligen Dialogelementen, z. B. bei der Listbox, müssen entsprechend viele Leerzeilen im Dialogfeld vorgesehen werden, damit die Liste vollständig innerhalb des Dialogfelds liegt. Siehe Beispiele am Ende dieser Beschreibung. Das Dialogfeld kann so konfiguriert werden, das der Benutzer die Größe des Dialogs interaktiv ändern kann (siehe Dialogelement |F @ xxx_callback|). Liste der verfügbaren Dialogelemente:

Wert	Bedeutung
`"\| @ccc\|"`	Editierfeld. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert. (Löschen oder Zufügen eines Buchstabens).
`"\|x \|"`	Passwortfeld.
`"\|nn \|"`	Mehrzeiliges Editierfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. Im Initialisierungstext werden die Zeilen durch die Zeichenfolge `\r\n` getrennt.
`"\|Bxxx \|"`	Kontrollfeld. `xxx` ist eine Zeichenkette, die neben dem Kontrollkästchen ausgegeben wird.
`"\|Bxxx @ccc \|"`	Kontrollfeld. `xxx` ist eine Zeichenkette, die neben dem Kontrollkästchen ausgegeben wird. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert.
`"\|BR xxx @ccc\|"`	Radioschalter. `xxx` ist eine Zeichenkette, die neben dem Radioschalter ausgegeben wird (Leerzeichen hinter `\|BR` ist nötig). `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn der Schalter gedrückt wird. Über die Callbackfunktion können die anderen Schalter einer Gruppe von Radioschaltern abgewählt werden. Siehe Beispiel 18.
`"\|Lnn \|"`	Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an.
`"\|Lnn @ccc \|"`	Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert.
`"\|Mnn \|"`	Mehrfach selektierbares Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an.
`"\|Mnn @ccc \|"`	Mehrfach selektierbares Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert.
`"\|Cnn \|"`	Kombinationsfeld. Die optionale Zahl `nn` gibt an, wieviele Zeilen die aufgeklappte Liste anzeigen soll.
`"\|Cnn @ccc \|"`	Kombinationsfeld mit Callback-Funktion. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird.
`"\|CAnn @ccc \|"`	AutoComplete Kombinationsfeld mit optionaler Callback-Funktion. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird. Dieses Kombinationsfeld erleichert die Suche eines Elements, wenn die Liste eine größere Anzahl an Elementen enthält. Um ein Element zu suchen, tippt man die Anfangsbuchstaben in das Textfeld ein. Die Liste des Kombinationsfeldes zeigt dann alle Elemente an, die mit den eingetippten Buchstaben beginnen. Groß-/Kleinschreibung wird ignoriert. Falls der eingetippe Text nicht mit einem Element in der Liste übereinstimmt, kann das Feld nicht verlassen werden und es ertönt ein Beep.
`"\|+nnn \|"`	Leerfeld. Mit diesem Feld kann der horizontale Abstand zum nächsten Feld vergrößert werden. `nnn` ist eine Zahl zwischen 0 und 255. Damit kann die berechnete Ausdehnung von Texten korrigiert werden. Im Dialogfeld werden nicht proportionale Fonts verwendet, bei denen die Buchstabebreite variiert. UniPlot bestimmt die Ausdehnung von Texten anhand einer duchschnittlichen Buchstabenbreite und macht damit Rechenfehler. Diese Fehler können mit Leerfeldern korrigiert werden.
`"\|CSnn @ccc \|"`	Symbol-Kombinationsfeld mit optionaler Callback-Funktion. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird. Mit diesem Kombinationsfeld können Farben, Linienstile oder Marker ausgewählt werden. Siehe Beispiel 20.
`"\|-nnn \|"`	Leerfeld. Mit diesem Feld kann der horizontale Abstand zum nächsten Feld verkleinert werden. `nnn` ist eine Zahl zwischen 0 und 255.
`"\|Pxxx@ccc \|"`	Schaltfläche. `xxx` ist die Bezeichnung der Schaltfläche und `ccc` ist der Name einer UniScript-Funktion, die bei Betätigen der Schaltfläche aufgerufen wird.
`"\|Oxxx \|"`	Ändert die Bezeichnung der OK-Schaltfläche. Ein dem O folgendes S sorgt dafür, dass die Abbruch-Schaltfläche nicht angezeigt wird, z. B. `\|OS Schließen \|`.
`"\|Oxxx@ccc \|"`	`ccc` ist der Name einer UniScript-Funktion, die bei Betätigen der OK-Schaltfläche aufgerufen wird. Mit `xxx` kann der Text geändert werden. Z. B. `"\|O&Ausführen\|"`. Falls die UniScript-Funktion `ccc`, die aufgerufen wird, wenn die OK Schaltfläche gedrückt wird, TRUE (1) zurück liefert, wird der Dialog geschlossen. Falls die Funktion FALSE (0) zurück liefert, wird der Dialog nicht geschlossen. Die Callback-Funktion kann auch einen Stringvektor zurück geben, der dann von der Dialog-Box nur durchgereicht wird. Enthält die Dialogbox z. B. eine Listbox, und die Liste soll alle Elemente der Liste liefern, kann man den entsprechenden String in dieser Callback-Funktion erzeugen.
`"\|S \|"`	Static-Textfeld. Der anzuzeigende Text wird mit dem Parameter svInitString gesetzt. Der Text kann mit einer Callback-Funktion geändert werden.
`"\|Sf \|"`	Static-Textfeld mit Rahmen. Der anzuzeigende Text wird mit dem Parameter svInitString gesetzt. Der Text kann mit einer Callback-Funktion geändert werden. Falls der Text nicht vollständig sichtbar ist, kann horizontal gescrollt werden.
`"\|Snn \|"`	Mehrzeiliges Static-Textfeld. Der anzuzeigende Text wird mit dem Parameter svInitString gesetzt. Im Initialisierungstext werden die Zeilen durch die Zeichenfolge `\r\n` getrennt. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. Der Text kann mit einer Callback-Funktion geändert werden.
`"\|Sfnn \|"`	Mehrzeiliges Static-Textfeld mit Scroll-Möglichkeit.
`"\|SPnn \|"`	UniPlotseite: Mehrzeiliges Static-Feld, in dem eine UniPlot-Seite angezeigt werden kann. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an, und bestimmt damit die Höhe des Feldes. Der Handle der Seite, die angezeigt werden soll, wird im Init-String übergeben. Siehe Beispiel 19
`"\|E@ccc \|"`	Enable. Ein Feld im Parameter svTemplate kann ein Enable-Feld sein. Das Feld kann benutzt werden, um Dialogfelder zu aktivieren oder zu deaktivieren (grau anzeigen). `ccc` ist der Name der UniScript-Funktion. Die Funktion wird bei den folgenden Ereignissen aufgerufen: Kurz bevor das Dialogfeld angezeigt wird. Jedes Mal nachdem eine Callback-Funktion aufgerufen wurde. Jedes Mal, wenn sich der Wert eines Kontrollfeldes ändert. Die Enable-Callback-Funktion wird aufgerufen mit dem aktuellen Initialisierungs-Werten der Dialogbox (Stringvektor). Die Funktion muss einen Vektor zurückgeben, der für jedes Dialogfeld eine 0 (disable) oder eine 1 (enable) enthält. Schaltflächen, bis auf die OK, Abbruch- und Hilfe-Schaltfläche müssen mitgezählt werden.
`"\|Dnnn \|"`	Kombinationsfeld (Edit-Combobox), wobei der Text bearbeitet werden kann. Die optionale Zahl `nnn` gibt an, wieviele Zeilen die aufgeklappte Liste anzeigen soll.
`"\|Dnnn @ccc\|"`	Kombinationsfeld (Edit-Combobox), wobei der Text bearbeitet werden kann. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird.
`"\|Rnnn,xxx RowTitle1 \t RowTitle... \t @ccc\|"`	Liste mit Spalten (Report) und mit optionaler Callback-Funktion. Die optionale Zahl `nnn` gibt an, wieviele Zeilen die Liste anzeigen soll. Die optionale Zahl `xxx` gibt an, wie breit die Liste sein soll. Die Breite wird in Dialogbox-Einheiten angegeben. Dabei ist eine Einheit etwa so breit wie ein Buchstabe. Wenn die Breite nicht angeben wird, wird sie aus der Anzahl der Buchstaben bis zum schließenden `\|`-Zeichen bzw. bis zum ersten @-Zeichen bestimmt. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Listenfeldes aufgerufen wird. Die Spaltentitel werden durch `\t` getrennt.
`"\|RBnnn,xxx RowTitle1 \t RowTitle... \t @ccc\|"`	Liste mit Spalten (Report), die eine Checkbox für jede Zeile und eine optionale Callback-Funktion enthält. `ccc` ist der Name der optionalen UniScript- Funktion, die nach einer Änderung der Auswahl des Listenfeldes aufgerufen wird. Die Spaltentitel werden durch `\t` getrennt. Für die Checkbox (Kontrollkästchen) wird zusätzlich in der Initialisierungszeichenkette eine 1 für checked oder eine 0 für unchecked angegeben. Siehe Beispiel.
`"\|RMBnnn,xxx RowTitle1 \t RowTitle... \t @ccc\|"`	Liste mit Spalten (Report), Checkbox für jede Zeile und Callback-Funktion. Das M steht für mehrfache Selektion. Die selektierten Einträge werden durch Oder-Zeichen (senkrechter Strich `"\|"`) getrennt. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Listenfeldes aufgerufen wird. Die Spaltentitel werden durch `\t` getrennt. Für die Checkbox (Kontrollkästchen) wird zusätzlich in der Initialisierungszeichenkette eine 1 für checked oder eine 0 für unchecked angegeben. Siehe Beispiel.
`"\|Gnnn \|"`	Groupbox. Rechteck mit Text in der linken oberen Ecke. Der Text wird über den Initialisierungsvektor an das Feld übergeben. Siehe Beispiel.
`"\|Nnnn \|"`	Propertylistbox. Eine zweispaltige Liste. Die Elemente in der rechten Liste können bearbeitet werden. Die optionale Zahl `nnn` gibt an, wieviele Zeilen die Liste anzeigen soll. Siehe Kommentar und Beispiel weiter unten.
`"\|F @ccc \|"`	Dialogfeldgröße kann interaktiv geändert werden.
`"\|Ann @ccc \|"`	Treecontrol. Darstellung einer Baumstruktur. `ccc` hat bei diesem Control eine besondere Bedeutung. Siehe Treecontrol weiter unten.

svInitString: svInitString ist ein Stringvektor der für jedes Dialogelement einen String enthält, mit dem die Dialogelemente initialisiert werden. Bei dem Kontrollfeld kann der String entweder den Wert "1" haben um das Kontrollfeld zu markieren, oder den Wert "0". Bei Listenfeldern und Kombinationsfeldern müssen die einzelnen Feldinhalte durch das Zeichen \x01 oder ein Oder-Zeichen | getrennt sein. Falls \x01 als Trennzeichen verwendet wird, muss die Zeichenkette mit \x01 beginnen. Elemente, die selektiert sein sollen, müssen durch das Zeichen \x02 oder ein @-Zeichen getrennt sein (siehe 3. Beispiel). Die Zeichenkette kann mit der Funktion CreateListBoxText erzeugt werden. Bei der Reportliste müssen die Elemente einer Zeile durch ein \t getrennt sein. Für Schaltflächen wird kein Text übergeben.

ssTitle: ssTitle ist der Titel der Dialogbox.

ssHelpItem: ssHelpItem ist eine Zeichenkette der Form "helpitem@helpfile", z. B. "DialogBox@d:/Program Files/UniPlot/up-de.chm".

obj: Der Parameter obj kann optional angegeben werden. obj ist ein UniScript-Objekt, dass mit obj_create erzeugt worden ist. Wenn dieser Parameter angegeben wird, wird der Parameter als letzter Parameter an alle Callback-Funktionen des Dialogfelds durchgereicht.

ssWizard: Der Parameter ssWizard kann optional angegeben werden. Mit Hilfe dieses Parameters kann im Dialogfeld eine zweite OK-Schaltfläche angezeigt werden. Der Parameter legt den Text der Schaltfläche und den Namen einer Callback-Funktion fest. Die Callback-Funktion wird aufgerufen, wenn der Benutzer Schaltfläche gedrückt hat. Der Schaltertext und der Name der Callbackfunktion wird durch ein @-Zeichen getrennt, beispielsweise < Zurück@_MyDialog_back. Falls der Parameter ungültig ist, wird die Schaltfläche nicht angezeigt. Die Callback-Funktion entspricht der Ok-Schalter-Callbackfunktion. Im Beispiel 17 weiter unten finden Sie einen Wizard mit 3 Dialogfeldern.

Kommentar

Die Callback-Funktionen für das Dialogfeld werden mit einem Parameter aufgerufen, der einen Vektor von Strings enthält. Die Anzahl der Elemente entspricht der Anzahl der Felder im Dialog. Die Schaltflächen werden nicht berücksichtigt.

Die Funktion sollte als Return-Wert einen Vektor zur Initialisierung des Dialogs zurück liefern. Der Vektor sollte den gleichen Aufbau haben, wie der Parameter svInitString. Falls ein ungültiger Wert (z. B. der Wert 0) zurück geliefert wird, wird der Inhalt des Dialogs nicht geändert. Mit der Funktion GetListBoxText kann der Listeninhalt eines Kombinationsfeldes oder eines Listenfeldes in seine Elemente zerlegt werden.

Für Report-, Property-, Kombinations- oder Listenfelder kann die Callback-Funktion auch den Wert „DLG_IGNORE“ zurück geben. Dann wird die entsprechende Liste nicht neu initialisiert. Besonders bei Listen mit einer großen Elementanzahl (größer 1000) kann die Initialisierung etwas länger dauern.

Editierfeld¶

Wenn das Editierfeldern über eine Callbackfunktion geändert wird, kann ein Text an der Cursorposition eingefügt werden. Dazu wird vor dem Text der Wert \x01 eingegeben. Der Text schließt mit \x01 gefolgt von dem Einfügetext. Beispiel: An der Cursorposition soll der Text `` + `` eingefügt werden:

svInit[2] = "\x01" + svInit[2] + "\x01" + " + ";

Wird hinter dem zweiten \x01 kein Text eingeben, wird nur der Cursor an das Textende verschoben.

Propertylistbox¶

Eine Propertylistbox hat zwei Spalten. Die linke Spalte zeigt die Bezeichnung eines Wertes. Der Wert selbst wird in der rechten Spalte angezeigt. Der Wert kann über ein Kombinationsfelds (Combobox), ein AutoComplete-Kombinationsfeld (AutoCombo), über eine Schaltfläche (Button) oder mit Hilfe eines Textfelds (Edit) bearbeitet werden.

Mit den Tasten TAB und Shift-TAB kann von Feld zu Feld gewechselt werden.

Das Beispiel unten zeigt einen Initialisierungsstring. Die Elemente einer Zeile werden durch Tabulatorzeichen getrennt "\t", die Zeilen durch ein Zeilentrennzeichen "\n". Jede Zeile hat zwischen 2 und 5 Elementen:

Wert	Bedeutung
Spalte 1	Name. Bezeichnung die in der linken Spalte der Listbox angezeigt wird.
Spalte 2	Wert. Zeichenkette mit der der rechte Teil der Listbox initialisiert wird.
Spalte 3	Typ: „Edit“, „Combo“, „AutoCombo“, „Button“ oder eine leere Zeichenkette „“ für ein Statik-Feld. Bei Edit-Feldern kann zusätzlich die Anzahl der einzugebenden Buchstaben begrenzt werden. Die Buchstabenanzahl wird direkt hinter den Buchstaben „E“ eingegeben. „E20“ bedeutet beispielsweise, dass 20 Buchstaben eingegeben werden können.
Spalte 4	Callback-Funktion. Die Callback-Funktion wird aufgerufen, bevor eine ComboBox oder AutoComplete-ComboBox geöffnet wird oder nachdem eine Schaltfläche betätigt wurde.
Spalte 5	Extra-Text. String der an die Callback-Funktion übergeben wird.

AutoComplete-ComboBox: Dieses Kombinationsfeld erleichtert die Suche eines Elements, wenn die Liste eine größere Anzahl an Elementen enthält. Um ein Element zu suchen, tippt man die Anfangsbuchstaben in das Textfeld ein. Die Liste des Kombinationsfeldes zeigt dann alle Elemente an, die mit den eingetippten Buchstaben beginnen. Groß-/Kleinschreibung wird ignoriert. Falls der eingetippte Text nicht mit einem Element in der Liste übereinstimmt, kann das Feld nicht verlassen werden und es ertönt ein Beep. Die Länge eines Textes ist auf 1024 Zeichen begrenzt

ssInit = "Name der Vorlage\tKF.IPW\tButton\t__PL1_GetFileName\tc:/test/kf.ipw\n" + ..
         "x-Kanal\tN\tCombo\t__PL1_ChannelNames\n" + ..
         "y-Kanal\tMom\tCombo\t__PL1_ChannelNames\n" + ..
         "Titel\tOtto2\tEdit\n" + ..
         "Bearbeiter\tP. Müller"

Für die Combobox liefert die Callback-Funktion die möglichen Werte, die in der Combobox angezeigt werden sollen. Beispiel für eine Ja/Nein-Auswahl:

def __YesNo_Combo(svProp)
{
    return "Ja|Nein@" + svProp[2];
}

Alternativ kann die Funktion auch wie folgt aussehen:

def __YesNo_Combo(svProp)
{
    return CreateListBoxText(["Ja", "Nein"], svProp[2]);
}

Der Parameter svProp ist ein String-Vektor mit den drei Elementen [ssName, ssValue,*ssExtra*]. Das erste Element ist der Name, das zweite Element ist der aktuelle Wert und das dritte Element ist ein String der an die Callback-Funktion übergeben wird.

Die Funktion gibt einen String-Vektor mit zwei Elementen zurück. Das erste Element ist der String zur Initialisierung der ComboBox (Aufbau wie bei ComboBox beschrieben) und das zweite Element ist der Extra-Text.

Für den Button liefert die Callback-Funktion einen neuen Wert. Beispiel für eine Datei-Auswahl:

def __PL1_GetFileName(svProp)
{
    ssFileName = GetOpenFileName(svProp[3]);
    if (ssFileName == "") {
        return 0;
    }
    return [sum(SplitPath(ssFileName)[3,4]), ssFileName];
}

Der Parameter svProp ist ein String-Vektor mit den drei Elementen [ssName, ssValue,*ssExtra*]. Das erste Element ist der Name, das zweite Element ist der aktuelle Wert und das dritte Element ist ein String der an die Callback-Funktion übergeben wird.

Bei diesem Beispiel steht im Extra-Text der vollständige Pfadname. Im zweiten Element steht nur der Name mit Erweiterung. Die Funktion gibt einen String-Vektor mit zwei Elementen zurück. Das erste Element ist der String, der als Wert angezeigt wird (z. B. Dateiname mit Erweiterung) und das zweite Element ist der Extra-Text, z. B. der vollständige Pfadname.

Für das Edit-Feld wird zur Zeit noch keine Callback-Funktion aufgerufen.

Wenn im Dialogfeld die OK-Schaltfläche gedrückt wird, gibt die Funktion DialogBox für die Property-Listbox einen skalaren String zurück, bei dem die Elemente durch ein TAB \t und die Zeilen durch ein \n getrennt sind. Mit Hilfe der Funktion PropList_GetMatrix(ssRet) kann der Returnwert der Funktion DialogBox in eine dreispaltige Matrix zerlegt werden.

Mit Hilfe der Funktion strtok kann der String in seine Elemente zerlegt werden.

Treecontrol¶

Ein Treecontrol wird über die Templatezeichenkette "|Ann@ccc|" erzeugt. nn ist die Anzahl der Zeilen und ccc der Beginn des Namens (Prefix) der Callback-Funktionen. Damit können die 5 möglichen Callback-Funktion eines Treecontrols definiert werden. Der im Element ccc angegebene Name, z. B. _MyDialog_ wird den Namen der vordefinierten Funktionennamen vorangestellt (siehe Beispiel weiter unten).

Beim Drücken der OK-Schaltfläche liefert das Control einen String mit den Pfad und der IDs. Pfad und IDs sind durch das Trennzeichen \2 getrennt, die Elemente des Pfads und der IDs durch \1. Zum Zerlegen kann die Funktion strtok verwendet werden.

Callback-Funktionen

Die Callback-Funktionen werden von UniPlot aufgerufen.

cccGetImageList()

Die Funktion gibt einen Vektor mit den vollständige Pfadnamen von Bitmaps zurück.

Beispiel:

def _MyDialog_GetImageList()
{
    return GetRootDirectory() + "bitmaps/" + ["folder.bmp", "file.bmp", "file2.bmp"];
}

Das Bitmap muss eine Höhe von 16 Pixeln und eine Breite von 16 Pixeln haben. Falls ein Bitmap nicht gefunden wird, wird eine Meldung in der Ereignisanzeige ausgegeben.

cccSelChanged(svInit, svText, nItemID)

Die Funktion wird aufgerufen, wenn sich die Selektion im Baum ändert. Der Parameter svInit enthält für jedes Dialogelement den Init-String. svText enthält den Pfad zum markierten Element als String-Vektor. nItemID ist die ID des Elements. Die ID wird in der Callback-Funktion cccExpand festgelegt.

cccDblClicked(svInit, svText, nItemID)

Die Funktion wird aufgerufen, wenn der Benutzer ein Element doppelklickt. Die Aufrufparameter entsprechen cccSelChanged.

cccRClicked(svInit, svText, nItemID)

Die Funktion wird aufgerufen, wenn der Benutzer mit der rechten Maustaste auf ein Element klickt. Die Aufrufparameter entsprechen cccSelChanged.

cccExpand(svText, rvItemID)

Die Funktion wird aufgerufen, wenn die Dialogmaske geöffnet wird und wenn der Benutzer einen Knoten des Baums öffnet. Falls der Knoten bereits vorher einmal geöffnet worden ist, befinden sich die Elemente bereits im Speicher. Die Funktion deshalb nicht noch mal aufgerufen.

Die Funktion cccExpand soll eine Stringmatrix mit 4 Spalten zurück geben. Die Matrix soll für jedes Subelement eine Zeile enthalten.

Wert	Bedeutung
Spalte1	Die erste Spalte enthält den Text, der angezeigt werden soll.
Spalte2	Eindeutige ID. Hier soll eine eindeutige Zahl als String eingetragen werden. Falls keine ID benötigt wird, kann hier ein leerer String eingetragen werden („“).
Spalte3	Legt fest, ob ein Knoten Kinderelemente hat. Falls das Element keine Kinder hat, wird hier der Wert „0“ (Blatt) eingetragen, sonst der Wert „1“.
Spalte4	Legt das anzuzeigende Bitmap fest. Dazu wird hier der Index des Bitmaps als String eingetragen. Der Index beginnt mit „1“. Die Liste der Bitmaps wird über die Funktion `cccGetImageList()` dem Treecontrol übergeben.

Initialisierung:

Beim Aufruf der Funktion kann in den Initialisierungs-Vektor für das Treecontrol ein leerer String eingetragen werden. In diesem Fall werden nur die Wurzelelemente des Baums angezeigt.

Soll ein bestimmter Knoten geöffnet werden, übergibt man den Pfad zu dem Knoten, wobei die einzelnen Elemente durch das Trennzeichen "\x01" getrennt werden und hängt an den String noch die Schlüsselwörter RESET und SELECT getrennt durch das Trennzeichen "\x03".

Reset sorgt dafür, das ein bereits geladener Zweig des Baums erneut geladen wird. Mit SELECT kann man einen Zweig beim Erzeugen des Dialogs öffnen.

svInit[iTree] = svInit[iTree] + "\x03RESET\x03SELECT";

Ein vollständiges Beispiel finden Sie weiter unten.

Editierbarer Reportcontrol¶

Im Reportcontrol können die Zellen bearbeitet werden. Dazu muss im Template-Parameter eine dritte Callback-Funktion angegeben werden. Das Feld hat damit den folgenden Aufbau:

"|Rnnn,xxx RowTitle1 \t RowTitle... \t @@@ccc|"

"|RMnnn,xxx RowTitle1 \t RowTitle... \t @@@ccc|"

Der Reporttyp "|RB ...|" kann nicht verwendet werden.

Wichtig sind die drei @-Zeichen vor dem Namen der Callback-Funktion. Nach dem zweiten @-Zeichen kann noch eine optionale Sortierfunktion angegeben werden, die Aufgerufen wird, wenn der Benutzer einen der Schalter oberhalb der Spalten drückt. Damit können dann alle Records aufsteigend oder absteigend sortiert werden. Dazu kann beispielsweise die Funktion ReportControl_Sort angegeben werden.

ccc steht für den Beginn des Namens (Prefix) der Callback-Funktionen. Damit können die 3 möglichen Callback-Funktion eines editierbaren Reports definiert werden. Der im Element ccc angegebene Name, z. B. __test_props_ wird den Namen der vordefinierten Funktionennamen vorangestellt.

Beispiel:

"|R8 Name\tWert                      @@ReportControl_Sort@ __test_props_ |"

Es stehen die folgenden Zelltypen zur Verfügung:

Typ	Bedeutung
„Edit“	Editierfeld zum Eingeben von Zahlen und Buchstaben.
„StaticText“	Text im Edierfeld mit Schreibschutz (Read-Only). Der Text kann in die Zwischenablage kopiert weden.
„Text“	Text, der nicht bearbeitet werden kann.
„GreyText“	Text auf grauem Hintergrund, der nicht bearbeitet werden kann.
„Combo“	Kombinationsfeld (Combobox)
„AutoCombo“	AutoComplete-Kombinationsfeld (Combobox)
„Marker“	Kombinationsfeld für Auswahl von Markern, Linienstilen, Farben, etc. (Combobox)
„Checkbox“	Kontrollkästchen
„ShowButton“	Text auf Schalter, Schalter kann nicht gedrückt werden.
„Button“	Text mit kleinem Schalter rechts, der den Text „…“ zeigt.
„ButtonText“	Schalter mit Text. Der Schalter hat die Größe der Zelle.
„MarkerText“	Zelle kann einen Marker, Linienstil, Farbe, etc. anzeigen.
„ButtonEdit“	Editierfeld mit kleinem Schalter rechts, der den Text „…“ zeigt.
„ButtonStatic“	Text im Edierfeld mit Schreibschutz (Read-Only) mit kleinem Schalter rechts, der den Text „…“ zeigt. Der Text kann in die Zwischenablage kopiert werden bzw. im Textfeld kann gescrollt werden.

Für die Zelltypen „Combo“, „AutoCombo“, „Marker“ muss eine Callback-Funktion angegeben werden, die den Text für das Listenfeld der Combobox liefert. Für die Zelltypen „Button“, „Buttontext“, „ButtonEdit“, „ButtonStatic“ muss eine Callback-Funktion angegeben werden, in der die gewünschten Aktionen ausgeführt werden, wenn der Schalter gedrückt wird.

Callback-Funktionen

Die Callback-Funktionen werden von UniPlot aufgerufen.

cccGetOption(ssOption)

Die Funktion wird aufgerufen, bevor das Dialogfeld auf dem Monitor angezeigt wird.

Die Funktion wird von UniPlot 6 mal aufgerufen. Dabei wird bei jedem Aufruf im Parameter ssOption ein String übergeben, der den Optionstyp angibt. Falls der Parameter in der Funktion behandelt wird, soll je nach Option ein skalarer String ein String-Vektor oder eine String-Matrix zurück gegeben werden.

Werte des Parameters ssOption:

Typ	Bedeutung
„ColumnType“	Legt den Zelltyp der Zellen fest. Alle Zellen einer Spalte haben den gleichen Typ. Bei diesem Wert soll die Funktion eine zweispaltige Matrix zurück geben. In der ersten Spalte wird der Zelltyp festgelegt und in der zweiten Spalte wird der Name der Callback-Funktion angegeben (siehe Beipiel).
„CellType“	Legt den Zelltyp der Zellen fest. Jede Zelle kann einen unterschiedlichen Typ haben. Bei diesem Wert soll die Funktion eine Matrix mit den Typen der Zellen zurück liefern. Die Größe der Matrix entspricht datei der Anzahl Zeilen und Spalten im Report. Die Callback-Funktion wird dabei an den Typen-Namen, getrennt durch ein @-Zeichen angehängt, z. B. „Combo@__Test_VarNames“.
„Selection“	Legt fest, ob Zeilen im Report markiert werden können. Bei einem Wert von „0“ kann nicht markiert werden. Bei einem Wert größer „0“ wird die entsprechende Anzahl Spalten markiert.
„ColumnOrder“	Legt die Reihenfolge der Spalten fest. Die Reihenfolge wird nur für die Anzeige verwendet.
„ColumnWidth“	Legt die Breite in Pixeln der einzelen Spalten fest.
„EnableColumnDrag“	Legt fest, ob die Spalten vom Benutzer verschoben werden können. Gibt die Funktion den String „1“ zurück, kann der Benutzer die Spalten verschieben. Gibt die Funktion den String „0“ zurück, kann der Benutzer die Spalten nicht verschieben. Default-Wert is „0“.

cccOnCellChange(svInit, iControl, iRow, iCol)

Die Funktion wird aufgerufen, wenn sich der Inhalt einer Zelle geändert hat.

svInit ist ein String-Vektor mit dem Inhalt der einzelnen Felder. iControl ist die Nummer des Controls. Damit kann dann auf den Inhalt von svInit zugegriffen werden, beispielsweise svInit[iControl]. Die Parameter iRow und iCol enthalten die Zeilennummer und Spaltennummer der Zelle, die sich geändert hat. Die Funktion kann den Wert 0 zurück geben, wenn der Inhalt des Dialogfelds nicht geändert werden soll. Sollen Werte geändert werden, gibt die Funktion einen Vektor mit Zeichenketten zurück, der genauso viele Elemente wie svInit enthält (einschließlich Selektion).

cccOnCellActivate(svInit, iControl, iRow, iCol)

Die Funktion wird aufgerufen, wenn eine Zelle mit der Maus angeklickt wird.

cccSaveOption(ssOption, svVal)

Die Funktion wird aufgerufen, bevor das Dialogfeld geschlossen wird.

In der Funktion kann die Spaltenreihenfolge und die Spaltenbreite gespeichert werden.

Die Funktion wird von UniPlot zwei mal aufgerufen. Dabei wird bei jedem Aufruf einer der folgenden Strings im Parameter ssOption übergeben.

Typ	Bedeutung
„ColumnOrder“	Spaltenreihenfolge
„ColumnWidth“	Spaltenbreite

Der Parameter svVal ist ein String-Vektor, der für jede Spalte je nach dem Wert des Parameters ssOption die Spaltenbreite oder Spaltennummer enthält.

Beispiel für cccSaveOption:

def __test_props_SaveOption(ssOption, svVal)
{
    if (ssOption == "ColumnWidth") {
        WriteProfileString("test_props", "colwidth", strcat(svVal, ","));
    }
}

cccOnCellFillColor(iControl, iRow, iCol, ssCellText)

cccOnCellFillColor(iControl, iRow, iCol, ssCellText, obj)

Die Funktion liefert die Füllfarbe einer Zelle. Sie wird für jede im Fenster angezeigte Zelle aufgerufen.

iControl ist die Nummer des Controls. Die Parameter iRow und iCol enthalten die Zeilennummer und Spaltennummer. Die Werte beginnen bei 1. ssCellText ist der Text der entsprechenden Zelle. obj ist ein optionaler Parameter. Siehe Parameter obj der Funktion DialogBox.

Die Funktion gibt die Zellfarbe als COLORREF zurück. Die Farbe kann z.B. mit der Funktion Color_RGB_to_COLORREF(rvRGB) aus einer RGB-Farbe berechnet werden.

Soll die Defaultfarbe angezeigt werden, muss die Funktion einen leeren String („“) zurück geben.

Siehe Beispiel 23 unten.

Beispiel für cccOnCellFillColor (Beispiel aus Datensatzliste des Datenaustauschdialogs):

def __data_datasetlist_OnCellFillColor(iControl, iRow, iCol, ssCellText, obj)
{
   // If the cell text in column 4 contains a "!" set the cell color to red,
   // otherwise to green.
   if (iCol == 4) {
      if (strfind(ssCellText, "!")[1]) {
         return Color_RGB_to_COLORREF([255,220,220]);  // bright red
      } else {
         return Color_RGB_to_COLORREF([220,255,220]);  // bright green
      }
   }

   // every second ro in bright yellow
   if (iRow%2) {
      return Color_RGB_to_COLORREF([250,250,223]);
   } else {
      return Color_RGB_to_COLORREF([255,255,255]);
   }

   // return an empty string to display the default cell color
   // return "";
}

Callbackfunktionen für die Zelltypen Combo, AutoCombo, Marker, Button und Buttontext

Die Funktion hat die folgende Syntax:

ssInitCombo = __test_report_Combo(svInit, iControl, iRow, iCol)

oder

svInit = __test_report_Button(svInit, iControl, iRow, iCol)

Die Funktionsparameter entsprechen der Funktion cccOnCellChange. Der Returnwert hängt vom Zelltyp ab.

Für die Zelltypen Combo, AutoCombo und Marker soll die Callback-Funktion den Inhalt des Listenfeldes der Combobox liefern. Die Funktion wird aufgerufen, wenn der Benutzer die Combobox öffnet.

Bei Comboboxen (Kombinationsfeld) müssen die einzelnen Feldinhalte durch das Zeichen \x01 oder ein Oder-Zeichen | getrennt sein. Falls \x01 als Trennzeichen verwendet wird, muss die Zeichenkette mit \x01 beginnen. Elemente, die selektiert sein sollen, müssen durch das Zeichen \x02 oder ein @-Zeichen getrennt sein (siehe 3. Beispiel). Die Zeichenkette kann mit der Funktion CreateListBoxText erzeugt werden.

Bei der ComboBox „Marker“ soll die Funkion einen String liefern wie er auch von Textobjekten verwendet wird, siehe dazu Textobjekte.

Hilfsfunktionen für das Reportcontrol¶

Hilfsfunktionen für die „Marker“-ComboBox:

ReportControl_GetMarkerStyleNames()
ReportControl_GetMarkerStyle(svMarker)
ReportControl_GetLineStyleNames()
ReportControl_GetLineStyle(svPen)
ReportControl_GetColorNames()
ReportControl_GetColorRGB(svColor)
ReportControl_GetStyleNames()
ReportControl_GetStyles(svStyle)

Für die Zelltypen „Button“ und „ButtonText“ liefert die Callbackfunktion den Init-Vektor für die Controls zurück.

ReportControl_GetInit

Erzeugt aus einer Matrix smInit ein skalaren String. Wenn bUseSaveSep gleich TRUE ist, werden die Elemente im String durch \0x01 getrennt. Im dritten Parameter werden die selektierten Elemente angegeben, entweder als String Matrix oder als Index-Vektor:

ssInit = ReportControl_GetInit(smInit, bUseSaveSep, smSel)
ssInit = ReportControl_GetInit(smInit, bUseSaveSep, rvSel)

ReportControl_GetMatrix

Zerlegt den Returnwert eines Report-Controls wieder in eine Matrix smMat. Der Returnwert smSel ist eine Matrix mit den selektierten Elementen. rvSelRow ist ein Vektor mit den Indizes der selektierten Elemente:

<smMat, smSel, rvSelRow> = ReportControl_GetMatrix(ssRet)
<smMat, smSel> = ReportControl_GetMatrix(ssRet)
<smMat> = ReportControl_GetMatrix(ssRet)

ReportControl_GetMatrix

Siehe ReportControl_Sort:

svInit = ReportControl_Sort(svInit, iControl, iColumn, bAscending)

ReportControl_RemoveSelection

Entfernt die selektierten Elemente eines Report-Controls. Die Funktion kann z.B. über eine Schalter-Callback-Funktion aufgerufen werden:

ReportControl_RemoveSelection(svInit, iControl)

ReportControl_SelUpOrDown

Verschiebt die selktierten Elemente eines Report-Controls nach oben oder unten:

svInit = ReportControl_SelUpOrDown(svInit, iControl, bUp)

ReportControl_GetColorScaleNames

Liefert die Namen der Farblisten. Wird beispielweise im Kategorieplot-Dialog verwendet:

ssInit = ReportControl_GetColorScaleNames(ssSelectColorName)

ReportControl_GetColorScaleName

Liefert die Farben einer Farbliste mit dem Namen ssColor:

ReportControl_GetColorScaleName(ssColor)

Die Anzahl und Namen der Spalten und die Zelltypen können dynamisch geändert werden.

Spalten dynamisch ändern: Dazu wird an den Initstring der Text mit den Namen der Spalten, getrennt durch ein \x03, angehängt. Die Spaltennamen werden durch Tabs getrennt. Beispiel:

// 3 Spalten:
ssColNames = "ID\tName\tWert";
smMat = ["1", "Motor", "x12";
         "2", "Kolben", "k3";
         "3", "Öl", "15W40"];
ssMat = ReportControl_GetInit(smMat, TRUE);
ssInit = ssMat + "\x03" + ssColNames;

Zelltypen dynamisch ändern: Die Zelltypen bzw. Spaltentypen wird durch den Aufruf der Callbackfunktion cccGetOption(ssOption) festgelegt. Diese Callbackfunktion wird von der Dialogbox-Funktion beim Initialisieren der des Dialogfeldes aufgerufen. Durch die Zeichenkette "\x03reset" kann der nochmalige Aufruf der Callbackfunktion erzwungen werden. Beispiel:

// 3 Spalten:
ssColNames = "ID\tName\tWert";
smMat = ["1", "Motor", "x12";
         "2", "Kolben", "k3";
         "3", "Öl", "15W40"];
ssMat = ReportControl_GetInit(smMat, TRUE);
ssInit = ssMat + "\x03reset";

Hilfsfunktionen für das ComboBox- und Listbox-Control¶

CreateListBoxText

Erzeugt aus einem String-Vektor einen skalaren String für Comboboxen und Listen. Diese Funktionen verwenden als Trennzeichen \x01 und \x02:

ssComboInit = CreateListBoxText(svList, svSel)

GetListBoxText

Die Funktion zerlegt den Returnwert einer Combobox oder Liste in einen Vektor. Der Defaultwert für nSplit ist TRUE. Wenn bSplit gleich FALSE ist, wird svList und svSel nicht in Vektoren zerlegt:

svSel = GetListBoxText(ssText)
<svList, svSel> = GetListBoxText(ssText)
<svList, svSel, rvSelIndex> = GetListBoxText(ssText)
svSel = GetListBoxText(ssText, bSplit)
<svList, svSel> = GetListBoxText(ssText, bSplit)
<svList, svSel, rvSelIndex> = GetListBoxText(ssText, bSplit)

Wenn man den Inhalt der Liste zurückgeben möchte, muss man den Aufruf in die Callback-Funktion des OK-Schalters einfügen. Ansonsten liefert die DialogBox-Funktion bei Comboboxen und Listen nur die selektierten Elemente zurück.

Ein vollständiges Beispiel finden Sie weiter unten (Beispiel 16).

Für das Edit-Report Control liefert die DialogBox-Funktion den vollständigen Inhalt des Controls einschließlich der Selektion zurück.

In der Größe aufziehbare Dialogfelder¶

Um die Größe einer Dialogbox interaktiv ändern zu können muss ein Feld "|F @ccc|" in den Template-Parameter eingefügt werden. ccc steht für eine Callback-Funktion.

Das folgende Beispiel zeigt die Callback-Funktion des Dialogfelds Daten=>Datensatzliste:

def _DatasetListDialog_Resize(rvInit)
{
    nElements = rvInit[6];
    nAction = rvInit[5];
    if (nAction == 1) {
        ssI = GetProfileString("DialogSize", "DatasetListDialog");
        svI = strtok(ssI, "|");
        return strtod(svI);
    } else if (nAction == 2) {
        return [2,3;    // checkbox
                6,6;    // Report
                5,3;    // blank field
                5,3;    // Button
                5,3;    // Button
                5,3;    // Button
                5,3];    // Button
    } else if (nAction == 3) {
        ssI = smprintf("%d", rvInit[1,2,3,4], "|", "|");
        WriteProfileString("DialogSize", "DatasetListDialog", ssI);
        return 0;
    }
}

Die Funktion hat einen Parameter rvInit. rvInit ist ein reeller Vektor mit 6 Elementen:

Wert	Bedeutung
rvInit[1]	Position links in Pixel.
rvInit[2]	Position oben in Pixel.
rvInit[3]	Dialogfeldbreite in Pixel.
rvInit[4]	Dialogfeldhöhe in Pixel.
rvInit[5]	nAction: siehe Anmerkung
rvInit[6]	Anzahl der Dialogelemente in der Dialogbox. Diese Information kann zu Debugzwecken verwendet werden.

Anmerkung zu rvInit[5]

Falls rvInit[5] den Wert 1 hat, wird die anzuzeigende Größe erfragt. Die Funktion soll in diesem Fall einen Vektor mit 4 Elementen zurück liefern [left, top, width, height]. Bei 2 erfragt die Funktion, wie die Größe der einzelnen Dialogelemente verändert werden soll. Die Funktion soll in diesem Fall eine reelle Matrix mit zwei Spalten zurück liefern. Mit dem Wert 3 wird die Funktion aufgerufen, wenn die Dialogbox geschlossen wird. In diesem Fall wird im Beispiel oben die aktuelle Größe gespeichert.

Position und Größe der Dialogelemente

Falls bei nAction == 2 eine Matrix von ungültiger Größe zurück gegeben wird, z. B. return 0, werden alle Elemente des Dialogfelds auf Default-Werte gesetzt. Die Elemente werden dann proportional zu Größe des Dialogfelds verändert. Optional kann die horizontale und vertikale Position der Dialogelemente fixiert werden. Beispielsweise macht es Sinn, dass ein einzeiliges Editierfeld nicht in der Höhe geändert werden kann.

Für jedes Element des Dialogfelds muss für die horizontale und vertikale Ausdehnung eines Elements je ein Wert aus den folgenden zwei Tabellen ausgewählt werden. Die Werte werden von der Callback-Funktion zurück gegeben, wenn nAction == 2 ist. In die erste Spalte wird der horizontale Wert und in die zweite Spalte der vertikale Wert geschrieben. Dabei müssen alle Elemente berücksichtigt werden, außer Default-Button (OK, Abbruch, Hilfe) sowie die Elemente |+xxx| und |-xxx|. Texte (auch Leerzeichen) die nicht von ODER-Zeichen eingeschlossen werden müssen ebenfalls berücksichtigt werden.

Horizontale Fixierung:

Name	Wert	Bedeutung
kNoHFix	0	Default-Wert: Horizontale Größe proportional zur Dialoggröße ändern.
kWidth	1	Breite konstant. Element verschiebt sich proportional.
kLeft	2	Linke Kante verankert. Breite ändert sich propotional.
kRight	4	Rechte Kante verankert. Breite ändert sich propotional.
kWidthLeft	3	Linke Kante verankert. Breite konstant.
kWidthRight	5	Rechte Kante verankert. Breite konstant.
kLeftRight	6	Linke und rechte Seite behält den Abstand zur Dialogkante.

Vertikal Fixierung:

Name	Wert	Bedeutung
kNoVFix	0	Default-Wert: Vertikale Größe proportional zur Dialoggröße ändern.
kHeight	1	Höhe konstant. Element verschiebt sich proportional.
kTop	2	Obere Kante verankert. Höhe ändert sich propotional.
kBottom	4	Untere Kante verankert. Höhe ändert sich propotional.
kHeightTop	3	Obere Kante verankert, Höhe konstant.
kHeightBottom	5	Untere Kante verankert, Höhe konstant.
kTopBottom	6	Obere und untere Seite behält den Abstand zur Dialogkante.

def _MyDialog_Resize(svInfo)
{
    nAction = svInfo[5];
    if (nAction == 1) { // Init
        ssI = GetProfileString("DialogSize", "MyDialog");
        svI = strtok(ssI, "|");
        return strtod(svI);  // return the init size
    } else if (nAction == 2) { // resize
        // svInfo[6] tells you how many elements you have
        return [6,6; // Report control  see documentation for DialogBox
                5,3; // blank space
                5,3; // button1
                5,3; // space |+100|
                5,3]; // button2
    } else if (nAction == 3) { // Exit User pressd OK or cancel
        ssI = smprintf("%d", svInfo[1,2,3,4], "|", "|");
        WriteProfileString("DialogSize", "MyDialog", ssI);
        return 0;
    }
}
def _MyDialog_Dialog()
{
    svTemplate = ["|R10,100  Code Word |  |P Button1 @_MyDialog_Button1|", ...
                  "|+100|  |P Button2 @_MyDialog_Button2|", ...
                strempty(1,8), ...
                  "|F @_MyDialog_Resize|"];
    svRet = DialogBox(svTemplate, "", "Test");
    if (svRet[1] == "DLG_CANCEL") {
        return svRet[1];
    }
    return svRet;
}

Für ein weiteres Beispiel siehe Beispiel 15.

Beispiel

Beispiel 1: Der folgende Funktionsaufruf erzeugt eine einfache Dialogbox mit einem Editierfeld

DialogBox("Name: |        |");

Beispiel 2: In dem folgenden Dialogfeld kann eine Folge von Komma-separierten Zahlenwerten eingegeben werden. Die Zeichenkette wird mit der Funktion strtok in einen Vektor von Zeichenketten zerlegt und mit der Funktion strtod in einen Vektor von Zahlen umgewandelt.

sRet = DialogBox("Bitte \"1,2,3,4\" eingeben |                    |")
if (sRet != "DLG_CANCEL") {
    svRet = strtok(sRet, ",")
    rvData = strtod(svRet)
    MessageBox(sprintf("%10.5f\n", rvData'))
}

Beispiel 3: Das folgende Beispiel erzeugt eine Dialogbox mit einem Editierfeld und einer Combobox:

svTemplate = ["Leistung |           |   kW"; ...
              "Motor    |C          |     "];
svEngines = ["1.3", "1.6 l", "2.0 l"];
ssEngine = CreateListBoxText(svEngines, svEngines[2]) // Select the second item
svInitString = ["127", ssEngine];
ssTitle = "Motor-Auswahl";
DialogBox(svTemplate, svInitString, ssTitle);

Beispiel 4: Das folgende Beispiel erzeugt eine Dialogbox mit einer Listbox:

DialogBox(["|L4                       |", strempty(1,3)], ..
           "Zeile 1|Zeile 2|Zeile 3@Zeile 2", "Dialog 3")

Beispiel 5: Das folgende Programm ist ein Beispiel für eine Dialobox mit einem Editierfeld und einer Schalterfläche um einen Dateiauswahl-Dialog anzuzeigen. Wenn der Benutzer auf die Schaltfläche drückt, wird die Funktion PickFile aufgerufen. PickFile bekommt die aktuelle Dialogeinstellung im Parameter svInit übergeben. Die Funktion ändert svInit und gibt svInit mit dem neuen Wert zurück. Das Dialogfeld verwendet den neuen Wert von svInit um das Dialogfeld neu zu initialisieren.

def GetMyFile()
{
    DialogBox("File:|                           ||P ... @PickFile|")
}
def PickFile(svInit)
{
    ssFilter = "Daten-Datei (*.xyz)|*.xyz|Alle Dateien (*.*)|*.*|";
    ssFileName = GetOpenFileName(svInit[1], ssFilter);
    if (ssFileName == "") { // User clicked CANCEL
    return svInit;
    }
    svInit[1] = ssFileName;     return svInit;
}

Beispiel 6: Das folgende Beispiel zeigt eine Liste aller geladenen Funkionen an:

DialogBox(["|L10                     |", strempty(1,9)], CreateListBoxText(symbols(255)));

Beispiel 7: Das folgende Beispiel zeigt eine Liste mit Namen. Wird ein neuer Name eingegeben, wird der Name zur Liste zugefügt. Beim Schließen der Funktion werden die Namen gespeichert.

def __TestAddItemToList(svInit)
{
    svItem = strtok(svInit[1], "@");
    if (len(svItem) == 1) { return svInit; }
    svSel = strtok(svItem[2], "|");
    if (len(svSel) == 1) { return svInit;    }
    return svItem[1] + "|" + svSel[2] + "@" + svSel[1];
}
def __TEST_Ok(svInit)
{
    // Add last name to list:
    __TestAddItemToList(svInit);
    WriteProfileString("MyFiends", "Name", svInit[1]);
    return TRUE;
}
def TestDialog()
{
    svInit = _GetProfileStringEx("MyFiends", "Name", "Andy|Georg|Thomas|");
    // returns selected Name:
    return DialogBox("Friends:|D                  @__TestAddItemToList||O &OK@__TEST_Ok|", svInit);
}

Beispiel 8: Das folgende Beispiel zeigt einen Report mit drei Spalten.

smMat = ["1.6l 16V", "4", "Otto";
         "2.0l 16V", "4", "Otto";
         "1.9l","4", "Diesel"];
ssInit = ReportControl_GetInit(smMat, TRUE, 1);

DialogBox(["|R4,40 Engine\tCylinder\tType|", strempty(1,3)], ..
           ssInit, ..
           "Report-Dialog")

Beispiel 9: Das folgende Beispiel zeigt einen Report mit drei Spalten. Vor der ersten Spalte wird ein Kontrollkästchen angezeigt. Um an die Werte für die Kontrollkästchen zu gelangen, muss man eine Callback-Funktion für die OK-Schaltfläche schreiben.

../../_images/DialogBox6-ReportWithCheckbox-en.png

def TestCallback_OK9(svInit)
{
    return svInit;
}

def TestDialog_9()
{
   smData = ["1", "1.6l 16V", "4", "Otto";
         "0", "2.0l 16V", "4", "Otto";
         "0", "1.9l", "4", "Diesel"];

   // 5 rows, width=70
   svTemplate = ["|RB5,70 "  + "Engine\tCylinder\tType|", ..
               strempty(1, 4), ..
               "|OOk@TestCallback_OK9|"];

   ssTitle = "Report-Dialog";
   svInit = ReportControl_GetInit(smData, TRUE, 3);
    svRet = DialogBox(svTemplate, svInit, ssTitle);
    if (svRet[1] == "DLG_CANCEL") {
        return -1;
    }
   smMat = ReportControl_GetMatrix(svRet[1]);

   // Checkboxes, first column:
   r = strtod(smMat[;1]);
   return r;
}
TestDialog_9()

Beispiel 10: Das folgende Beispiel zeigt einen Dialog mit zwei Gruppen.

../../_images/DialogBox7-Groupbox-de.png

svTemplate = ["|G3                  | |G3                   |", ..
              " x =|           ||+6|dx =|            |", ...
              " y =|           ||+6|dy =|            |",..
              "", ..
              "|B Größe auf alle markierten Elemente anwenden|"]
DialogBox(svTemplate, ["Position","Größe", "0","10", "0", "10"], "Elemente Verschieben")

Beispiel 11: Das folgende Beispiel zeigt einen Dialog mit einer Property-Liste. Je nach Elementtyp kann das Element über ein Kombinationsfeld (Combo), Schaltfläche (Button) oder Textfeld (Edit) bearbeitet werden.

../../_images/DialogBox8-PropList-de.png

def PropList_GetMatrix(ssRet)
{
    sv = strtok(ssRet, "\n");
    n = len(sv);
    sm = strempty(n, 3);
    for (i in 1:len(sv)) {
        svT = strtok(sv[i], "\t")
        nn = len(svT);
        if (nn == 1) {
            sm[i;1] = svT;
        } else if (nn == 2) {
            sm[i;1:2] = svT;
        } else if (nn == 3) {
            sm[i;] = svT;
        }
    }
    return sm;
}
def PropList_GetFileName(svProp)
{
    ssFileName = GetOpenFileName(svProp[3]);
    if (ssFileName == "") {
        return 0;
    }
    return [sum(SplitPath(ssFileName)[3,4]), ssFileName];
}
def PropList_ChannelNames(svProp)
{
    return ["N|Mom|Mom_ewg|M_ACT|be@" + svProp[2], ""];
}
def _EngineDialog()
{
    ssInit = "Name der Vorlage\tKF.IPW\tButton\tPropList_GetFileName\tc:/test/kf.ipw\n" + ..
             "x-Kanal\tN\tCombo\tPropList_ChannelNames\n" + ..
             "y-Kanal\tMom\tCombo\tPropList_ChannelNames\n" + ..
             "z-Kanal\tMom\tAutoCombo\tPropList_ChannelNames\n" + ..
             "Titel\tOtto2\tEdit\n" + ..
             "Bearbeiter\tP. Müller"
    svRet = DialogBox(["|N8                                                      |", strempty(1,7), ..
           "|B Verwende Default Werte"], ..
           [ssInit, "0"], "Kurven-Parametrierung");
    if (svRet[1] == "DLG_CANCEL") {
        return svRet[1];
    }
    smMat = PropList_GetMatrix(svRet[1]);
    // Do something with smMat[;2]
}

Beispiel 12: Das folgende Beispiel zeigt einen Dialog mit einem mehrzeiligen Textfeld.

../../_images/DialogBox9-Multiline-en.png

DialogBox(["|5                       |", strempty(1,4)], ..
           "This is the first line\r\nThis is the second line", "Multiline-Edit")

Beispiel 13: Das folgende Beispiel prüft ob eine Zahl zwischen 1 und 10 eingegeben wurde:

def TestCallback(svInit)
{
    <n, ssStop> = strtod(strtrim(svInit, 3));
    if (n < 1 || n > 10 || ssStop != "") {
        MessageBox("Please type in a number in the range 1 to 10.", ["Error", "ICONSTOP"]);
        return FALSE;
    }
    return TRUE;
}
def TestDialog()
{
     ssRet = DialogBox("Number between 1 and 10: |                       ||OOK@TestCallback|", "0", "Edit");
     if (ssRet != "DLG_CANCEL") {
         MessageBox("Ok: You typed in " + ssRet + "!");
     }
}

Beispiel 14: Das folgende Beispiel zeigt eine Liste aller geladenen Funkionen an. Zusätzlich kann eine Funktion in der Liste markiert werden, um die Datei anzuzeigen, in der die Funktion definiert ist.

def __ShowSourceName(svInit)
{
    <a,b> = GetListBoxText(svInit[2]);
    svInit[1] = source(b);
    return svInit;
}
def _ListFunctions()
{
    DialogBox(["|Sf                                   ", ..
               "|L10                                @__ShowSourceName|", strempty(1,9)], ..
                ["", CreateListBoxText(symbols(255))]);
}

Beispiel 15: Das folgende Beispiel zeigt in einer Baumstruktur die Unterverzeichnisse und Dateien des UniPlot-Wurzelverzeichnisses. Das Dialogfeld kann in der Größe verändert werden.

def _MyDialogTree_GetImageList(obj)
{
    return GetRootDirectory() + "bitmap/" + ["folder.bmp", "file.bmp"];
}
def _MyDialogTree_SelChanged(svInit, svText, nItemID, obj)
{
    svInit[2] = obj.Path +strcat(svText, "/");
    return svInit;
}
def _MyDialogTree_DblClicked(svInit, svText, nItemID, obj)
{
    MessageBox("Path: " + obj.Path +strcat(svText, "/"));
}
def _MyDialogTree_RClicked(svInit, svText, nItemID, obj)
{
    MessageBox("Path: " + obj.Path +strcat(svText, "/"));
}
def _MyDialogTree_Expand(svText, rvItemID, obj)
{
    smFiles = FindFiles(obj.Path + strcat(svText, "/") + "/*");
    // remove . and ..
    if (nr(smFiles) < 3) {
        return "";
    }
    smFiles = strtrim(smFiles[3:nr(smFiles);], 3);
    nFiles = nr(smFiles);
    smName = strempty(nFiles, 4);
    for (i in 1:nFiles) {
        smName[i;1] = smFiles[i;1];
        smName[i;2] = "0"; // sprintf("%d", o.lastid);
        if (smFiles[i;3] == "16") {
            smName[i;3] = "1";
            smName[i;4] = "2";
        } else {
            smName[i;3] = "0";
            smName[i;4] = "1";
        }
    }
    return smName;
}
def _MyDialogTree_Resize(svInfo, obj)
{
    nAction = svInfo[5];
    if (nAction == 1) { // Init
        ssI = GetProfileString("DialogSize", "MyDialogTree");
        svI = strtok(ssI, "|");
        return strtod(svI);  // return the init size
    } else if (nAction == 2) { // resize
        return [6,6;
                6,5];
    } else if (nAction == 3) { // Exit User pressd OK or cancel
        ssI = smprintf("%d", svInfo[1,2,3,4], "|", "|");
        WriteProfileString("DialogSize", "MyDialogTree", ssI);
        return 0;
    }
}
def _MyDialogTree_Dialog()
{
    ssTreeSelection = GetProfileString("_MyDialogTree", "TreeSelection");
    ssTreeSelection = ssTreeSelection + "\x03select";
    svTemplate = ["|A10                                                             @_MyDialogTree_|", ...
                strempty(1,9), ...
                  "|Sf                                                                ||F @_MyDialogTree_Resize|"];
    svInit = [ssTreeSelection, ""];
    ssHelp = "";
    obj = obj_create();
    obj.Path = GetRootDirectory();
    svRet = DialogBox(svTemplate, svInit, "Browse " + obj.Path, ssHelp, obj);
    if (svRet[1] == "DLG_CANCEL") {
        return svRet[1];
    }
    svEle = strtok(svRet[1], "\2");
    svPfad = strtok(svEle[1], "\1");
    WriteProfileString("_MyDialogTree", "TreeSelection", strcat(svPfad, "\1"));
    return GetRootDirectory() + strcat(svPfad, "\");
}

Beispiel 16: Das folgende Beispiel zeigt ein ReportControl, in dem einige Zellen bearbeitbar sind. Die Spaltenbreite und Spaltenreihenfolge kann interaktiv geändert werden und wird gespeichert. Das Dialogfeld kann in der Größe verändert werden.

Aufruf siehe Funktion _test_report().

../../_images/DialogBox11-EditReport-en.png

def __test_report_Combo(svInit, iControl, iRow, iCol)
{
    <ssMat, svSel> =GetListBoxText(svInit[iControl], FALSE);
    smMat = ReportControl_GetMatrix(ssMat);
    return CreateListBoxText(["Otto","Diesel","DI-Otto"], smMat[iRow; iCol]);
}
def __test_report_Button(svInit, iControl, iRow, iCol)
{
    <ssMat, svSel> =GetListBoxText(svInit[iControl], FALSE);
    smMat = ReportControl_GetMatrix(ssMat);
    ssFile = GetOpenFileName();
    if (ssFile != "") {
        smMat[iRow; iCol] = ssFile;
        svInit[iControl] = ReportControl_GetInit(smMat, TRUE);
    }
    return svInit;
}
def __test_report_Color(svInit, iControl, iRow, iCol)
{
    svColor = ReportControl_GetColorNames();
    <ssMat, svSel> =GetListBoxText(svInit[iControl], FALSE);
    smMat = ReportControl_GetMatrix(ssMat);
    return CreateListBoxText(svColor, smMat[iRow;iCol]);
}
def __test_report_GetOption(ssOption)
{
    if (ssOption == "Selection") {
        return "255";
    } else if (ssOption == "EnableColumnDrag") {
        return "1";
    } else if (ssOption == "ColumnType") {
        return ["ShowButton", "";
                "Edit", "";
                "Combo", "__test_report_Combo";
                "Button", "__test_report_Button";
                "Checkbox", "";
                "Marker", "__test_report_Color"];
    } else if (ssOption == "ColumnWidth") {
        return _GetProfileStringEx("DialogSize", "_test_props_colwidth", "50,70,50,150,60,140");
    } else if (ssOption == "ColumnOrder") {
        return _GetProfileStringEx("DialogSize", "_test_props_colorder", "1,2,3,4,5,6");
    }
}
def __test_report_SaveOption(ssOption, svVal)
{
    if (ssOption == "ColumnWidth") {
        WriteProfileString("DialogSize", "_test_props_colwidth", strcat(svVal, ","));
    } else if (ssOption == "ColumnOrder") {
        WriteProfileString("DialogSize", "_test_props_colorder", strcat(svVal, ","));
    }
}
def __test_report_Resize(rvInit)
{
    nElements = rvInit[6];
    nAction = rvInit[5];
    if (nAction == 1) {
        ssI = GetProfileString("DialogSize", "_test_report");
        svI = strtok(ssI, "|");
        return strtod(svI);
    } else if (nAction == 2) {
        return [6,6];
    } else if (nAction == 3) {
        ssI = smprintf("%d", rvInit[1,2,3,4], "|", "|");
        WriteProfileString("DialogSize", "_test_report", ssI);
        return 0;
    }
}
def _test_report()
{
    svColor = ReportControl_GetColorNames();
    svTemplate = ["|R4,60 Engine\tComment\tType\tData File\tShow\tColor @@@__test_report_|", ..
                  strempty(1,2), ...
                  "|F @ __test_report_Resize |"];
    smData =["1.6l 16V",     "With AGR",             "Otto",         "","1", svColor[10];
         "2.0l 16V", "Without AGR",  "Otto",         "","0", svColor[11];
         "1.9l",             "",                             "Diesel",       "","2", svColor[12];
         "1.6l 16V", "",                             "Otto",         "","1", svColor[13];
         "1.6l 16V", "",                             "Otto",         "","1", svColor[14]];
    ssInit = ReportControl_GetInit(smData, TRUE);
    svRet = DialogBox(svTemplate, ssInit, "Edit-Report-Dialog")
    if (svRet[1] == "DLG_CANCEL") {
        return svRet;
    }
    smMat = ReportControl_GetMatrix(svRet[1]);
    rmColor = ReportControl_GetColorRGB(smMat[;6]);
    return svRet
}

Beispiel 17: Das folgende Beispiel zeigt einen Wizard mit drei Dialogfeldern.

Kurze Funktionsbeschreibung:

In der Funktion _TestWizard() wird ein Objekt erzeugt, in dem drei weitere Objekte mit den Nummern 1, 2 und 3 erzeugt werden. In jedem dieser Objekte werden die Parameter für die einzelnen Dialoge definiert, das sind Template, svInit, Title, Back und Help.

Nachdem alle Dialoge definiert sind, wird die Funktion WizardDialog aufgerufen. Die Funktion ruft die DialogBox-Funktion auf und übergibt die Parameter für obj.dialog_id == 1.

Für die Schaltflächen Next, Back und Finish wurde jeweils eine Callbackfunktion definiert, die den aktuellen Inhalt des Dialogfelds speichert und über das Element obj.dialog_id festlegt, welcher Dialog als nächstes angezeigt werden soll.

Im Template-Stringvektor wurden mit Hilfe von strempty Leerzeilen eingefügt, damit die Dialogfelder die gleiche Höhe haben und somit die Next- und Back-Schalter an gleicher Position auf dem Monitor angezeigt werden.

Die Benutzereingaben befinden sich in dem Element obj[i].svInit.

Aufruf siehe Funktion _TestWizard().

def _TestWizard_Next(svInit, obj)
{
    obj[obj.dialog_id].svInit = svInit;
    obj.dialog_id = obj.dialog_id + 1;
    return 1;
}
def _TestWizard_Back(svInit, obj)
{
    obj[obj.dialog_id].svInit = svInit;
    obj.dialog_id = obj.dialog_id - 1;
    return 1;
}
def _TestWizard()
{
    obj = obj_create();
    obj[1] = [.];
    obj[2] = [.];
    obj[3] = [.];
    obj.dialog_id = 1;
    obj[1].Template = [strempty(1,4), ..
                       "File1:|                                 |", ..
                       "File2:|                                 |", ..
                        strempty(1,4),"|OS Next>@_TestWizard_Next"];
    // If you remove the S in [[|OS Next>@_TestWizard_Next|]] a \b(Cancel)
    // button will be displayed.
    obj[1].svInit = ["c:/test1", "c:/test2"];
    obj[1].Title = "Step1: Select Files";
    obj[1].Back = "";    // No Back-Button
//  obj[1].Help = "";    // No Help-Button
    obj[1].Help = "DialogBox" + "@" + GetHelpFileName();

    obj[2].Template = ["Kanäle:|L10                             |", ..
                        strempty(1,9),"|OS Next>@_TestWizard_Next"];
    obj[2].svInit = CreateListBoxText(["speed","torque","nox"], "nox");
    obj[2].Title = "Step2: Select Channels";
    obj[2].Back = "<Back@_TestWizard_Back";
 // obj[2].Help = "";
    obj[2].Help = "DialogBox" + "@" + GetHelpFileName();

    obj[3].Template = [strempty(1,5), ..
                        "Title:|                                  |", ..
                        strempty(1,4), "|OS Finish@_TestWizard_Next"];
    obj[3].svInit = ["This is Text 1"];
    obj[3].Title = "Step3: Specify Title";
    obj[3].Back = "<Back@_TestWizard_Back";
    obj[3].Help = "";
    obj[3].Help = "DialogBox" + "@" + GetHelpFileName();
    ssRet = WizardDialog(obj);
    if (ssRet == "OK") {
        ssFile1 = obj[1].svInit[1];
        ssFile2 = obj[1].svInit[2];
        ssChannel = GetListBoxText(obj[2].svInit);
        ssTitle = obj[3].svInit[1];
        print obj[1].svInit, obj[2].svInit, obj[3].svInit
    } else {
        print "Wizard: Cancel";
    }
}
def WizardDialog(obj)
{
    while (obj.has_key(obj.dialog_id)) {
        od = obj[obj.dialog_id];
        svRet = DialogBox(od.Template, od.svInit, od.Title, od.Help, obj, od.Back);
        if (svRet[1] == "DLG_CANCEL") {
            return svRet[1];
        }
    }
    return "OK";
}

Beispiel 18: Das folgende Beispiel zeigt eine Dialogbox mit zwei Radioschalter-Gruppen

Bei Radioschaltern einer Gruppe sollte immer nur ein Schalter gedrückt sein. Wenn der Benutzer einen Radioschalter drückt, müssen die anderen Schalter abgewählt werden. Das kann mit Hilfe der Funktion RadioControl_Group erreicht werden. Im dritten Parameter wird der Funktion ein Vektor mit den Indizes der zur Gruppe gehörenden Radioschalter übergeben. Die Indizes beziehen sich auf den String-Vektor svInit.

def _Radio1(svInit, iRadio)
{
    return RadioControl_Group(svInit, iRadio, [2, 3, 4]);
}
def _Radio2(svInit, iRadio)
{
    return RadioControl_Group(svInit, iRadio, [6, 7, 8, 9]);
}
def RadioDialogBox()
{
    svTemplate = ["|G4                                  |", ..
                  "|BR Radio 1    @_Radio1|", ..
                  "|BR Radio 2    @_Radio1|", ..
                  "|BR Radio 3    @_Radio1|", ..
                  "", ..
                  "|G5                                  |", ..
                  "|BR Radio 1    @_Radio2|", ..
                  "|BR Radio 2    @_Radio2|", ..
                  "|BR Radio 3    @_Radio2|", ..
                  "|BR Radio 4    @_Radio2|", ..
                  ""];
    svInit = ["Group 1", "1", "0", "0", "Group2", "1", "0", "0", "0"];
    DialogBox(svTemplate, svInit, "Example 18");
}

Beispiel 19: Das folgende Beispiel zeigt eine Dialogbox mit einer UniPlot-Grafik.

../../_images/DialogBox19-IPWGraphic-en.png

Der Handle der Seite wird der Dialogbox im Initstring übergeben. Die optionale Callbackfunktion, im Beispiel __Test_Example19_UpdatePageSize, wird aufgerufen, wenn sich die Größe der Dialogbox ändert. Der Callbackfunktion wird im ersten Parameter eine Zeichenkette übergeben. Die Zeichenkette enthält duch Komma getrennt den Handle der Seite, sowie die Breite und Höhe des Controls in Zentimeter. Dieser String wird an alle Dialog-Callbackfunktionen übergeben.

Im Beispiel wird ein Objekt erzeugt, in dem die Handle gespeichert werden.

def __Test_Example19_Resize(rvInit)
{
    nAction = rvInit[5];
    if (nAction == 1) {
        ssI = GetProfileString("DialogSize", "Test_Example19");
        svI = strtok(ssI, "|");
        return strtod(svI);
    } else if (nAction == 2) {
        return [2,3; 6,3; 2,3; 6,3; 5,3; 6,6];
    } else if (nAction == 3) {
        ssI = smprintf("%d", rvInit[1,2,3,4], "|", "|");
        WriteProfileString("DialogSize", "Test_Example19", ssI);
        return 0;
    }
}
def __Test_Example19_Update(svInit, obj)
{
    LayerSetAxisTitle(obj.hLayer, "X", svInit[1]);
    LayerSetAxisTitle(obj.hLayer, "Y", svInit[2]);
    __Test_Example19_UpdatePageSize(svInit[3], obj)
    return svInit;
}
def __Test_Example19_UpdatePageSize(ssInfo, obj)
{
    rvInfo = strtod(strtok(ssInfo, ","));
    hPage = rvInfo[1];    // Page handle
    dx = rvInfo[2];     // control width in centimeter
    dy = rvInfo[3];        // control height in centimeter
    rvPosSize = OBJGetPosSize(obj.hLayer);
    rvPosSize[1] = 3;
    rvPosSize[2] = -rvInfo[3]-1;
    rvPosSize[3] = rvInfo[2]-1;
    rvPosSize[4] = rvInfo[3]-1;
    OBJSetPosSize(obj.hLayer, rvPosSize);
    return 0;
}
def Test_Example19()
{
    obj = [.];
    hDoc = DocCreate("", DOC_HIDDEN);
    hPage = PageCreate();
    DocAddPage(hDoc, hPage);
    hLayer = LayerCreate();
    LayerSetAutoScale(hLayer, "X", TRUE);
    LayerSetAutoScale(hLayer, "Y", TRUE);
    hData = XYCreate("Test", [1,2,3,4,5], [1,3,2,5,4]);
    PageAddLayer(hPage, hLayer);
    LayerAddDataset(hLayer, hData);
    obj.hPage = hPage;
    obj.hLayer =hLayer;
    obj.hData = hData;
    // Save Handle so the control knows what to plot
    ssPage = sprintf("%d", hPage);
    svInit = [LayerGetAxisTitle(hLayer, "X"),LayerGetAxisTitle(hLayer, "Y"), ssPage];
    svRet = DialogBox(["x-Title=|                 |", ...
                       "y-Title=|                 ||P Update @__Test_Example19_Update", ...
                       "|SP5                         @__Test_Example19_UpdatePageSize|" + ...
                       "|F @ __Test_Example19_Resize|", ...
                       strempty(1,4)], svInit, "Test Example 19", "", obj);
    DocDestroy(hDoc);
}

Beispiel 20: Dialogbox zur Auswahl von Farben, Linienstilen und Markern:

def Test_Example20()
{
    svColor = ReportControl_GetColorNames();
    ssColorList = CreateListBoxText(svColor, svColor[1]);
    svStyle = ReportControl_GetLineStyleNames();
    ssStyleList = CreateListBoxText(svStyle, svStyle[1]);
    svMarker = ReportControl_GetMarkerStyleNames();
    ssMarkerList = CreateListBoxText(svMarker, svMarker[1]);
    svRet = DialogBox(["Color: |CS15                               |", ...
                          "Line:  |CS15                               |",...
                       "Symbol:|CS15                               |"], ...
                        [ssColorList, ssStyleList, ssMarkerList], "Example 20");
    if (svRet[1] == "DLG_CANCEL") {
        return 0;
    }
    rvColor = ReportControl_GetColorRGB(svRet[1]);
    nLine = ReportControl_GetLineStyle(svRet[2])
    nMarker = ReportControl_GetMarkerStyle(svRet[3]);
}

Beispiel 21: Dialogbox zur Auswahl von Kanälen aus einer NC/NC2-Datei:

// Callback "Select All"
def _NC_Channel_Selection_SelectAll(svInit)
{
   <smMatrix, smSelMat, rvSelRow> = ReportControl_GetMatrix(svInit[1])
   if (len(smMatrix) == 1) {
      return 0;
   }
   smMatrix[;1] = "1";
   svInit[1] = ReportControl_GetInit(smMatrix, TRUE, rvSelRow);
   return svInit;
}

// Callback "Deselect All"
def _NC_Channel_Selection_DeselectAll(svInit)
{
   <smMatrix, smSelMat, rvSelRow> = ReportControl_GetMatrix(svInit[1])
   if (len(smMatrix) == 1) {
      return 0;
   }
   smMatrix[;1] = "0";
   svInit[1] = ReportControl_GetInit(smMatrix, TRUE, rvSelRow);
   return svInit;
}

// Callback "Toggle"
def _NC_Channel_Selection_Toggle(svInit)
{
   <smMatrix, smSelMat, rvSelRow> = ReportControl_GetMatrix(svInit[1])
   if (rvSelRow[1] == 0) {
      MessageBoxError(_s("Select at least one element in the list"));
      return 0;
   }
   ssSel = smMatrix[rvSelRow[1]; 1];
   if (ssSel == "1") {
      ssSel = "0";
   } else {
      ssSel = "1";
   }
   smMatrix[rvSelRow;1] = ssSel;
   svInit[1] = ReportControl_GetInit(smMatrix, TRUE, rvSelRow);
   return svInit;
}

// Callback "OK" button
def _NC_Channel_Selection_Dialog_OK(svInit)
{
   smVars = ReportControl_GetMatrix(svInit[1]);
   idx = find(smVars[;1] == "1");
   if (idx[1] == 0) {
      MessageBoxError("Bitte markieren Sie mindestens einen Kanal");
      return FALSE;
   }
   svVars = smVars[idx;2];
   return svVars;
}

// Callback "Dialog Resize"
def _NC_Channel_Selection_Resize(rvInit)
{
   nElements = rvInit[6];
   nAction = rvInit[5];
   if (nAction == 1) {
      ssI = GetProfileString("DialogSize", "NC_Channel_Selection_Dialog");
      svI = strtok(ssI, "|");
      return strtod(svI);
   } else if (nAction == 2) {
      return [6,6;
               5,3;
               5,3;
               5,3;
               5,3];
   } else if (nAction == 3) {
      ssI = smprintf("%d", rvInit[1,2,3,4], "|", "|");
      WriteProfileString("DialogSize", "NC_Channel_Selection_Dialog", ssI);
      return 0;
   }
}

// returns "" if Cancel is selected
def NC_Channel_Selection_Dialog(ssNCFile)
{
   svVarNames = NC_GetVarNames(ssNCFile);
   if (svVarNames[1] == "") {
      MessageBoxError("Ungültige Datendatei: %s", ssNCFile);
      return "";
   }

   ssTitle = "Kanalauswahl";
   svTemplate = ["|RMB10,65   Name@@ReportControl_Sort| " + ...
      " |P Alle auswählen         @ _NC_Channel_Selection_SelectAll |", ..
      "|+68||P Alle abwählen          @ _NC_Channel_Selection_DeselectAll |", ..
      "|+68||P Markierung an/abwählen @ _NC_Channel_Selection_Toggle|", ..
      "|O OK @_NC_Channel_Selection_Dialog_OK||F @_NC_Channel_Selection_Resize|", ..
      strempty(1, 6)]

   smVars = strempty(len(svVarNames), 2);
   smVars[;1] = "0"; // alle abwählen,
   smVars[;2] = svVarNames'

   svInit = ReportControl_GetInit(smVars, TRUE);
   svRet = DialogBox(svTemplate, svInit, ssTitle);
   if (svRet[1] == "DLG_CANCEL") {
      return "";
   }
   return svRet;
}

// Test
NC_Channel_Selection_Dialog(GetOpenFileName())

Beispiel 22: Property Listbox mit Farbauswahl, etc.:

def _MyProp_Button(svInit, iControl, iRow, iCol)
{
    <ssMat, svSel> =GetListBoxText(svInit[iControl], FALSE);
    smMat = ReportControl_GetMatrix(ssMat);
    ssFile = GetOpenFileName();
    if (ssFile != "") {
        smMat[iRow; iCol] = ssFile;
        svInit[iControl] = ReportControl_GetInit(smMat, TRUE);
    }
    return svInit;
}

def _MyProp_Color(svInit, iControl, iRow, iCol)
{
   if (nargsin() == 1) {
      return ReportControl_GetColorNames(Color_RGB_to_COLORREF(_sty_color_to_number(svInit)), " ");
   } else if (nargsin() == 2) {
      rvColor = ReportControl_GetColorRGB(svInit);
      return _sty_color_print(0, "", _sty_rgb(rvColor), "", FALSE);
   } else {
      svColor = [" ", ReportControl_GetColorNames()];
      <smMat, svSel, rsSel> = ReportControl_GetMatrix(svInit[iControl]);
      return CreateListBoxText(svColor, smMat[iRow;iCol]);
}

def _MyProp_LineWidth(svInit, iControl, iRow, iCol)
{
   if (nargsin() == 1) {
      if (svInit == "") {
         return " ";
      }
      nVal = strtod(svInit)
      if (nVal <= 0) {
         return "1";
      }
      if (nVal > 50) {
      return "50";
      }
      return svInit;
   } else if (nargsin() == 2) {
      if (svInit == " ") {
         return "";
      }
      return svInit;
   }
   <ssMat, svSel> =GetListBoxText(svInit[iControl], FALSE);
   smMat = ReportControl_GetMatrix(ssMat);
   return " |" + _CreateComboBoxNumbers(1, 50) + "@" + smMat[iRow; iCol];
}

def _MyProp_LineStyle(svInit, iControl, iRow, iCol)
{
   if (nargsin() == 1) {
      return ReportControl_GetLineStyleNames(_sty_curve_style_to_number(svInit), " ");
   } else if (nargsin() == 2) {
      rsLineStyle = ReportControl_GetLineStyle(svInit);
      return _sty_curve_style_print(0, "", rsLineStyle, "", FALSE);
   } else {
      svNames = [" ", ReportControl_GetLineStyleNames()];
      <smMat, svSel, rsSel> = ReportControl_GetMatrix(svInit[iControl]);
   return CreateListBoxText(svNames, smMat[iRow;iCol]);
   }
}


def _MyProp_Marker(svInit, iControl, iRow, iCol)
{
   if (nargsin() == 1) {
      return ReportControl_GetMarkerStyleNames(_sty_marker_style_to_number(svInit), " ");
   } else if (nargsin() == 2) {
      rsVal = ReportControl_GetMarkerStyle(svInit);
      return _sty_marker_style_print(0, "", rsVal, "", FALSE);
   } else {
      svNames = [" ", ReportControl_GetMarkerStyleNames()];
      <smMat, svSel, rsSel> = ReportControl_GetMatrix(svInit[iControl]);
      return CreateListBoxText(svNames, smMat[iRow;iCol]);
   }
}

// callback function to set the cell type
// The function name is the name behind the third @ character in dialog template
// folloed by the text GetOption
def _MyProp_GetOption(ssOption)
{
   if (ssOption == "CellType") {
         return ["GreyText", "Edit";
               "GreyText", "Button@_MyProp_Button";
               "GreyText", "Checkbox@_MyProp_OnOff";
               "GreyText", "Marker@_MyProp_Color";
               "GreyText", "Marker@_MyProp_LineStyle";
               "GreyText", "Combo@_MyProp_LineWidth";
               "GreyText", "Marker@_MyProp_Marker"];
      }
   }

def _Test_Prop_Dialog_Template()
   {
   ssTitle = "Property Dialog";
   svTemplate = ["|R8,90 Name\tValue @@@_MyProp_|", strempty(1,7)];
   // Create an object and return it
   return [. ssTitle = ssTitle, svTemplate = svTemplate];
}

def _MyProp_Dialog()
{
   dlg = _Test_Prop_Dialog_Template();
   ssColor = _MyProp_Color("RGB(0,255,0)"); //green  sprintf("RGB(%d,%d,%d)", r,b,g);
   ssLineStyle = _MyProp_LineStyle("1");
   ssMarker = _MyProp_Marker("5");

   smInit = ["Text", "This is Text";
            "File Name", "c:\\b.txt";
            "On/Off", "1";
           "Color", ssColor;
           "Line Type", ssLineStyle;
           "Line Width", "5";
           "Marker", ssMarker];

   svInit = ReportControl_GetInit(smInit, TRUE);  // TRUE is important!

   svRet = DialogBox(dlg.svTemplate, svInit, dlg.ssTitle);
   if (svRet[1] == "DLG_CANCEL") {
      return 0;
   }
   smMat = ReportControl_GetMatrix(svRet[1]);
   obj = [.];
   obj.ssText = smMat[1;2];
   obj.ssFile = smMat[2;2];
   obj.bOnOff = strtod(smMat[3;2]);
   obj.rvColor = ReportControl_GetColorRGB(smMat[4;2]);
   obj.nLineWidth = strtod(smMat[6;2]);
   obj.ssMarker = strtod(_MyProp_Marker(smMat[7;2], 1));

   return obj;
}

Beispiel 23: Das folgende Beispiel zeigt eine Matrix von Zufallszahlen. Je nach Wert werden die Zellen unterschiedlich eingefärbt.

../../_images/DialogBox23-OnCellFillColor-en.png

def __testdialog_23_OnCellFillColor(iControl, iRow, iCol, ssCellText)
{
   if (iCol == 1) {
      return Color_RGB_to_COLORREF([250,250,250]);  // bright grey
   }
   rsVal = strtod(ssCellText);

   if (rsVal >= -0.2 && rsVal <= 0.2) {
      return Color_RGB_to_COLORREF(sty_prop_color_to_RGB("lightgreen"));  // bright green
   } else if (rsVal <= -0.2) {
      return Color_RGB_to_COLORREF(color_html_to_rgb("#fa8072"));  // bright red
   } else {
      return Color_RGB_to_COLORREF(sty_prop_color_to_RGB("powderblue"));
   }
}

def TestCallback_23_OK9(svInit)
{
    return svInit;
}

def TestDialog_23()
{
   smData = smprintf("%g", rand(10,10)*2-1);
   svCols = strcat(smprintf("%d", 1:nc(smData)), "\t");
   svRows = smprintf("%d", 1:nr(smData))';

   svTemplate = ["|R12,100 \t" + svCols + "@@@__testdialog_23_|", ..
               strempty(1, 11), ..
               "|OOk@TestCallback_23_OK9|"];

   ssTitle = "Report-Dialog";
   svInit = ReportControl_GetInit([svRows, smData], TRUE, 3);
    svRet = DialogBox(svTemplate, svInit, ssTitle);
    if (svRet[1] == "DLG_CANCEL") {
        return -1;
    }
   smMat = ReportControl_GetMatrix(svRet[1]);
   return smMat;
}
TestDialog_23()

History

Version	Beschreibung
R2016.1	Callbackfunktion für Editfelder zugefügt.
R2015.4	OnCellFillColor beim ReportControl zugefügt.
R2013.12	OnCellActivate beim ReportControl zugefügt.
5.10.0	Symbol Kombinationsfeld zugefügt.
5.6.0	`"\x03reset"` zu Editreportcontrols zugefügt.
5.4.0	UniPlot-Grafik Element zugefügt. Siehe Beispiel 19
4.2.5	Radio-Schalter zugefügt.
4.2.4	Wizard-Parameter zugefügt.
4.2.2	Reportliste nun editierbar.
4.2.0	Treecontrol und Veränderung der Dialogfeld-Größe durch Aufziehen mit der Maus.

Siehe auch

Überblick Dialogboxen, MessageBox, GetSaveFileName, GetOpenFileName, GetDirectoryDialog

_id-2012604

Wert	Bedeutung
`"\| @ccc\|"`	Editierfeld. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert. (Löschen oder Zufügen eines Buchstabens).
`"\|x \|"`	Passwortfeld.
`"\|nn \|"`	Mehrzeiliges Editierfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. Im Initialisierungstext werden die Zeilen durch die Zeichenfolge `\r\n` getrennt.
`"\|Bxxx \|"`	Kontrollfeld. `xxx` ist eine Zeichenkette, die neben dem Kontrollkästchen ausgegeben wird.
`"\|Bxxx @ccc \|"`	Kontrollfeld. `xxx` ist eine Zeichenkette, die neben dem Kontrollkästchen ausgegeben wird. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert.
`"\|BR xxx @ccc\|"`	Radioschalter. `xxx` ist eine Zeichenkette, die neben dem Radioschalter ausgegeben wird (Leerzeichen hinter `\|BR` ist nötig). `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn der Schalter gedrückt wird. Über die Callbackfunktion können die anderen Schalter einer Gruppe von Radioschaltern abgewählt werden. Siehe Beispiel 18.
`"\|Lnn \|"`	Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an.
`"\|Lnn @ccc \|"`	Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert.
`"\|Mnn \|"`	Mehrfach selektierbares Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an.
`"\|Mnn @ccc \|"`	Mehrfach selektierbares Listenfeld. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. `ccc` ist der Name einer UniScript-Funktion, die aufgerufen wird, wenn sich die Selektion ändert.
`"\|Cnn \|"`	Kombinationsfeld. Die optionale Zahl `nn` gibt an, wieviele Zeilen die aufgeklappte Liste anzeigen soll.
`"\|Cnn @ccc \|"`	Kombinationsfeld mit Callback-Funktion. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird.
`"\|CAnn @ccc \|"`	AutoComplete Kombinationsfeld mit optionaler Callback-Funktion. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird. Dieses Kombinationsfeld erleichert die Suche eines Elements, wenn die Liste eine größere Anzahl an Elementen enthält. Um ein Element zu suchen, tippt man die Anfangsbuchstaben in das Textfeld ein. Die Liste des Kombinationsfeldes zeigt dann alle Elemente an, die mit den eingetippten Buchstaben beginnen. Groß-/Kleinschreibung wird ignoriert. Falls der eingetippe Text nicht mit einem Element in der Liste übereinstimmt, kann das Feld nicht verlassen werden und es ertönt ein Beep.
`"\|+nnn \|"`	Leerfeld. Mit diesem Feld kann der horizontale Abstand zum nächsten Feld vergrößert werden. `nnn` ist eine Zahl zwischen 0 und 255. Damit kann die berechnete Ausdehnung von Texten korrigiert werden. Im Dialogfeld werden nicht proportionale Fonts verwendet, bei denen die Buchstabebreite variiert. UniPlot bestimmt die Ausdehnung von Texten anhand einer duchschnittlichen Buchstabenbreite und macht damit Rechenfehler. Diese Fehler können mit Leerfeldern korrigiert werden.
`"\|CSnn @ccc \|"`	Symbol-Kombinationsfeld mit optionaler Callback-Funktion. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird. Mit diesem Kombinationsfeld können Farben, Linienstile oder Marker ausgewählt werden. Siehe Beispiel 20.
`"\|-nnn \|"`	Leerfeld. Mit diesem Feld kann der horizontale Abstand zum nächsten Feld verkleinert werden. `nnn` ist eine Zahl zwischen 0 und 255.
`"\|Pxxx@ccc \|"`	Schaltfläche. `xxx` ist die Bezeichnung der Schaltfläche und `ccc` ist der Name einer UniScript-Funktion, die bei Betätigen der Schaltfläche aufgerufen wird.
`"\|Oxxx \|"`	Ändert die Bezeichnung der OK-Schaltfläche. Ein dem O folgendes S sorgt dafür, dass die Abbruch-Schaltfläche nicht angezeigt wird, z. B. `\|OS Schließen \|`.
`"\|Oxxx@ccc \|"`	`ccc` ist der Name einer UniScript-Funktion, die bei Betätigen der OK-Schaltfläche aufgerufen wird. Mit `xxx` kann der Text geändert werden. Z. B. `"\|O&Ausführen\|"`. Falls die UniScript-Funktion `ccc`, die aufgerufen wird, wenn die OK Schaltfläche gedrückt wird, TRUE (1) zurück liefert, wird der Dialog geschlossen. Falls die Funktion FALSE (0) zurück liefert, wird der Dialog nicht geschlossen. Die Callback-Funktion kann auch einen Stringvektor zurück geben, der dann von der Dialog-Box nur durchgereicht wird. Enthält die Dialogbox z. B. eine Listbox, und die Liste soll alle Elemente der Liste liefern, kann man den entsprechenden String in dieser Callback-Funktion erzeugen.
`"\|S \|"`	Static-Textfeld. Der anzuzeigende Text wird mit dem Parameter svInitString gesetzt. Der Text kann mit einer Callback-Funktion geändert werden.
`"\|Sf \|"`	Static-Textfeld mit Rahmen. Der anzuzeigende Text wird mit dem Parameter svInitString gesetzt. Der Text kann mit einer Callback-Funktion geändert werden. Falls der Text nicht vollständig sichtbar ist, kann horizontal gescrollt werden.
`"\|Snn \|"`	Mehrzeiliges Static-Textfeld. Der anzuzeigende Text wird mit dem Parameter svInitString gesetzt. Im Initialisierungstext werden die Zeilen durch die Zeichenfolge `\r\n` getrennt. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an. Der Text kann mit einer Callback-Funktion geändert werden.
`"\|Sfnn \|"`	Mehrzeiliges Static-Textfeld mit Scroll-Möglichkeit.
`"\|SPnn \|"`	UniPlotseite: Mehrzeiliges Static-Feld, in dem eine UniPlot-Seite angezeigt werden kann. Die optionale Zahl `nn` gibt die Anzahl der anzuzeigenden Zeilen an, und bestimmt damit die Höhe des Feldes. Der Handle der Seite, die angezeigt werden soll, wird im Init-String übergeben. Siehe Beispiel 19
`"\|E@ccc \|"`	Enable. Ein Feld im Parameter svTemplate kann ein Enable-Feld sein. Das Feld kann benutzt werden, um Dialogfelder zu aktivieren oder zu deaktivieren (grau anzeigen). `ccc` ist der Name der UniScript-Funktion. Die Funktion wird bei den folgenden Ereignissen aufgerufen: Kurz bevor das Dialogfeld angezeigt wird. Jedes Mal nachdem eine Callback-Funktion aufgerufen wurde. Jedes Mal, wenn sich der Wert eines Kontrollfeldes ändert. Die Enable-Callback-Funktion wird aufgerufen mit dem aktuellen Initialisierungs-Werten der Dialogbox (Stringvektor). Die Funktion muss einen Vektor zurückgeben, der für jedes Dialogfeld eine 0 (disable) oder eine 1 (enable) enthält. Schaltflächen, bis auf die OK, Abbruch- und Hilfe-Schaltfläche müssen mitgezählt werden.
`"\|Dnnn \|"`	Kombinationsfeld (Edit-Combobox), wobei der Text bearbeitet werden kann. Die optionale Zahl `nnn` gibt an, wieviele Zeilen die aufgeklappte Liste anzeigen soll.
`"\|Dnnn @ccc\|"`	Kombinationsfeld (Edit-Combobox), wobei der Text bearbeitet werden kann. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Kombinationsfeldes aufgerufen wird.
`"\|Rnnn,xxx RowTitle1 \t RowTitle... \t @ccc\|"`	Liste mit Spalten (Report) und mit optionaler Callback-Funktion. Die optionale Zahl `nnn` gibt an, wieviele Zeilen die Liste anzeigen soll. Die optionale Zahl `xxx` gibt an, wie breit die Liste sein soll. Die Breite wird in Dialogbox-Einheiten angegeben. Dabei ist eine Einheit etwa so breit wie ein Buchstabe. Wenn die Breite nicht angeben wird, wird sie aus der Anzahl der Buchstaben bis zum schließenden `\|`-Zeichen bzw. bis zum ersten @-Zeichen bestimmt. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Listenfeldes aufgerufen wird. Die Spaltentitel werden durch `\t` getrennt.
`"\|RBnnn,xxx RowTitle1 \t RowTitle... \t @ccc\|"`	Liste mit Spalten (Report), die eine Checkbox für jede Zeile und eine optionale Callback-Funktion enthält. `ccc` ist der Name der optionalen UniScript- Funktion, die nach einer Änderung der Auswahl des Listenfeldes aufgerufen wird. Die Spaltentitel werden durch `\t` getrennt. Für die Checkbox (Kontrollkästchen) wird zusätzlich in der Initialisierungszeichenkette eine 1 für checked oder eine 0 für unchecked angegeben. Siehe Beispiel.
`"\|RMBnnn,xxx RowTitle1 \t RowTitle... \t @ccc\|"`	Liste mit Spalten (Report), Checkbox für jede Zeile und Callback-Funktion. Das M steht für mehrfache Selektion. Die selektierten Einträge werden durch Oder-Zeichen (senkrechter Strich `"\|"`) getrennt. `ccc` ist der Name einer UniScript-Funktion, die nach einer Änderung der Auswahl des Listenfeldes aufgerufen wird. Die Spaltentitel werden durch `\t` getrennt. Für die Checkbox (Kontrollkästchen) wird zusätzlich in der Initialisierungszeichenkette eine 1 für checked oder eine 0 für unchecked angegeben. Siehe Beispiel.
`"\|Gnnn \|"`	Groupbox. Rechteck mit Text in der linken oberen Ecke. Der Text wird über den Initialisierungsvektor an das Feld übergeben. Siehe Beispiel.
`"\|Nnnn \|"`	Propertylistbox. Eine zweispaltige Liste. Die Elemente in der rechten Liste können bearbeitet werden. Die optionale Zahl `nnn` gibt an, wieviele Zeilen die Liste anzeigen soll. Siehe Kommentar und Beispiel weiter unten.
`"\|F @ccc \|"`	Dialogfeldgröße kann interaktiv geändert werden.
`"\|Ann @ccc \|"`	Treecontrol. Darstellung einer Baumstruktur. `ccc` hat bei diesem Control eine besondere Bedeutung. Siehe Treecontrol weiter unten.

Inhalt

Vorheriges Thema

Nächstes Thema

Diese Seite