.. highlightlang:: us .. index:: DialogBox .. _dialogbox: DialogBox ========= .. us.tag DialogBox GERMAN DialogBoxes Changed360 Changed420 Changed422 Changed425 Changed540 Changed560 Changed5100 Mit der Funktion :ref:`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. .. function:: 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) .. us.return **Returnwert** Wenn der Benutzer die :guilabel:`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. .. us.params **Parameter** .. uparam:: 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: .. list-table:: :header-rows: 1 * - 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. .. uparam:: 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 :ref:`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. .. uparam:: ssTitle *ssTitle* ist der Titel der Dialogbox. .. uparam:: ssHelpItem *ssHelpItem* ist eine Zeichenkette der Form ``"helpitem@helpfile"``, z. B. ``"DialogBox@d:/Program Files/UniPlot/up-de.chm"``. .. uparam:: obj Der Parameter *obj* kann optional angegeben werden. *obj* ist ein UniScript-Objekt, dass mit :ref:`obj_create` erzeugt worden ist. Wenn dieser Parameter angegeben wird, wird der Parameter als letzter Parameter an alle Callback-Funktionen des Dialogfelds durchgereicht. .. uparam:: 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. .. us.comment **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 :ref:`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 :kbd:`TAB` und :kbd:`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: .. list-table:: :header-rows: 1 * - 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 :ref:`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 :ref:`DialogBox` in eine dreispaltige Matrix zerlegt werden. Mit Hilfe der Funktion :ref:`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 :ref:`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. .. list-table:: :header-rows: 1 * - 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 :ref:`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: .. list-table:: :header-rows: 1 * - 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*: .. list-table:: :header-rows: 1 * - 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. .. list-table:: :header-rows: 1 * - 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 :ref:`CreateListBoxText` erzeugt werden. Bei der ComboBox "Marker" soll die Funkion einen String liefern wie er auch von Textobjekten verwendet wird, siehe dazu :ref:`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. .. index:: ReportControl_GetInit **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) .. index:: ReportControl_GetMatrix **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:: = ReportControl_GetMatrix(ssRet) = ReportControl_GetMatrix(ssRet) = ReportControl_GetMatrix(ssRet) .. index:: ReportControl_GetMatrix **ReportControl_GetMatrix** Siehe :ref:`ReportControl_Sort`:: svInit = ReportControl_Sort(svInit, iControl, iColumn, bAscending) .. index:: ReportControl_RemoveSelection **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) .. index:: ReportControl_SelUpOrDown **ReportControl_SelUpOrDown** Verschiebt die selktierten Elemente eines Report-Controls nach oben oder unten:: svInit = ReportControl_SelUpOrDown(svInit, iControl, bUp) .. index:: ReportControl_GetColorScaleNames **ReportControl_GetColorScaleNames** Liefert die Namen der Farblisten. Wird beispielweise im Kategorieplot-Dialog verwendet:: ssInit = ReportControl_GetColorScaleNames(ssSelectColorName) .. index:: ReportControl_GetColorScaleName **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 ..................................................... .. index:: CreateListBoxText **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) .. index:: GetListBoxText **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) = GetListBoxText(ssText) = GetListBoxText(ssText) svSel = GetListBoxText(ssText, bSplit) = GetListBoxText(ssText, bSplit) = 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 :ref:`datendatensatzliste`: :: 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: .. list-table:: :header-rows: 1 * - 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: .. list-table:: :header-rows: 1 * - 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: .. list-table:: :header-rows: 1 * - 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. .. us.example **Beispiel** **Beispiel 1**: Der folgende Funktionsaufruf erzeugt eine einfache Dialogbox mit einem Editierfeld .. image:: S:/uniplot-obj/images/DialogBox1.* :: DialogBox("Name: | |"); **Beispiel 2**: In dem folgenden Dialogfeld kann eine Folge von Komma-separierten Zahlenwerten eingegeben werden. Die Zeichenkette wird mit der Funktion :ref:`strtok` in einen Vektor von Zeichenketten zerlegt und mit der Funktion :ref:`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: .. image:: S:/uniplot-obj/images/DialogBox2.* :: 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: .. image:: S:/uniplot-obj/images/DialogBox3.* :: 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. .. image:: S:/uniplot-obj/images/DialogBox4.* :: 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: .. image:: S:/uniplot-obj/images/DialogBox5-en.* :: 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. .. image:: S:/uniplot-obj/images/DialogBox5-Report-en.* :: 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. .. image:: S:/uniplot-obj/images/DialogBox6-ReportWithCheckbox-en.* :: 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. .. image:: S:/uniplot-obj/images/DialogBox7-Groupbox-de.* :: 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. .. image:: S:/uniplot-obj/images/DialogBox8-PropList-de.* :: 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. .. image:: S:/uniplot-obj/images/DialogBox9-Multiline-en.* :: 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: .. image:: S:/uniplot-obj/images/DialogBox13-en.* :: def TestCallback(svInit) { = 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. .. image:: S:/uniplot-obj/images/DialogBox14-en.* :: def __ShowSourceName(svInit) { = 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. .. image:: S:/uniplot-obj/images/DialogBox10-Tree-en.* :: 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(). .. image:: S:/uniplot-obj/images/DialogBox11-EditReport-en.* :: def __test_report_Combo(svInit, iControl, iRow, iCol) { =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) { =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(); =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 :ref:`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. .. image:: S:/uniplot-obj/images/DialogBox17-Wizard-en.* 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 = " = 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) { = 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) { = 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.: .. image:: S:/uniplot-obj/images/DialogBox22-en.* :: def _MyProp_Button(svInit, iControl, iRow, iCol) { =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()]; = 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; } =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()]; = 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()]; = 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. .. image:: S:/uniplot-obj/images/DialogBox23-OnCellFillColor-en.* :: 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() .. us.history **History** .. list-table:: :header-rows: 1 * - 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. .. seealso:: :ref:`uberblick-dialogboxen`, :ref:`MessageBox`, :ref:`GetSaveFileName`, :ref:`GetOpenFileName`, :ref:`GetDirectoryDialog` :sub:`id-2012604`