Zeige letzte Bearbeiter
1 {{aagon.priorisierung}}
2 160
3 {{/aagon.priorisierung}}
4
5 {{aagon.floatingbox/}}
6
7 = Aufteilung des Form Editors =
8
9 Nachdem Sie im vorigen Dialog den Button Form bearbeiten angeklickt haben, öffnet sich der Form Editor, über den Sie einen bereits bestehenden Dialog bearbeiten können. Andernfalls wird der Standard-Dialog zur Bearbeitung geöffnet.
10
11 {{figure}}
12 (% style="text-align:center" %)
13 [[image:hmfile_hash_180972ba.png]]
14
15 {{figureCaption}}
16 Aufteilung der Benutzeroberfläche des Form Editors
17 {{/figureCaption}}
18 {{/figure}}
19
20 Der Form Editor lässt sich in fünf Hauptbereiche aufteilen: Die Menüleiste (1), Schnellwahlleisten (2), Werkzeugpalette (3), Objekteigenschaften (Object Inspector) (4) und Arbeitsfläche (mit den Tabs Form und Quellcode) (5).
21
22 == Menüleiste und Schnellwahlleiste ==
23
24 In der Menüleiste sind die drei Menüpunkte Skript, Bearbeiten und Hilfe zu finden.
25
26 === Skript ===
27
28 Unterhalb dieses Menüpunktes finden Sie die Funktionen Code generieren, Syntax überprüfen und Ausführen. Diese Funktionen dienen dem automatischen Erstellen, Überprüfen und Testen der Form.
29
30
31 ==== Code generieren ====
32
33 Diese Funktion dient dem automatischen Erstellen einer Code-Basis, auf der schließlich die restliche Funktionalität entwickelt werden kann. So werden die Funktionen erstellt, welche beim Start bzw. beim Beenden der Form automatisch aufgerufen werden. Optional können dabei Werte aus einer Variablen geladen bzw. in diese gespeichert werden. Zusätzlich lassen sich die Standard-Buttons für die OK- bzw. Abbrechen-Funktionalität der Form festlegen.
34
35 {{aagon.infobox}}
36 Bei der Nutzung dieser Funktion wird der bereits existierende Code gelöscht und nur die Code-Basis neu eingefügt. Daher sollte diese Funktion nur zu Beginn der Code-Entwicklung genutzt werden.
37 {{/aagon.infobox}}
38
39 Über die Option Werte beim Start laden kann festgelegt werden, dass die angegebene Variable beim Start der Form ausgelesen wird. Enthält diese Variable eine bestimmte Syntax, können die Eigenschaften von Form-Elementen automatisch auf einen bestimmten Wert gesetzt werden. Die Option Werte beim Beenden sichern speichert die Eigenschaften aller Form-Elemente beim Beenden der Form in derselben Syntax und derselben Variablen.
40
41 {{figure}}
42 (% style="text-align:center" %)
43 [[image:hmfile_hash_0200591e.png]]
44
45 {{figureCaption}}
46 Code generieren
47 {{/figureCaption}}
48 {{/figure}}
49
50 Der Inhalt der Variablen hat dabei die Syntax Element.Eigenschaft=Wert,[…]. Soll die Variable beim Start der Form ausgelesen werden, um bestimmt Eigenschaften zu setzen, müssen Sie für den korrekten Inhalt einer Variablen vor dem Aufruf der Form im Client Command selbst sorgen, z.B. mit Hilfe der Kommandos der String-Kategorie (siehe [[Kategorie Strings>>doc:ACMP.64.ACMP-Solutions.Client Commands.Client Command erstellen.Client Commands neu hinzufügen.Client Command Editor.Commandlist.String.WebHome]]). Werden die Eigenschaften der Form-Elemente beim Beenden der Form gespeichert, wird genau dieselbe Syntax verwendet, wodurch eine Weiterverarbeitung der Daten relativ leicht fällt.
51
52 Um z.B. den Text eines Edit-Elements mit dem Namen Edit1 auf ‚Aagon‘ zu setzen und einen Radio-Button mit dem Namen Radio1 zu aktivieren, muss der Variableninhalt wie Folgt lauten:
53
54 {{code language="None"}}
55 Edit1.Text=Aagon,Radio0.Checked=true
56 {{/code}}
57
58 Welchen Namen ein Element trägt und welche Eigenschaften es besitzt, können Sie über den Object Inspector einsehen.
59
60 Zusätzlich zum Laden und Speichern von Eigenschaften von Form-Elementen, lassen sich der OK Button sowie der Abbrechen Button festlegen. Dazu werden in der DropDown-Liste alle bereits vorhandenen Buttons aufgelistet. Der Unterschied der beiden Buttons besteht darin, dass der OK Button die Form mit dem Ergebnis 0 beendet und vorher alle Eigenschaften der Form-Elemente in der angegebenen Variablen speichert, während der Abbrechen Button die Form mit dem Ergebnis 1 beendet und die Eigenschaften der Form-Elemente nicht speichert.
61
62
63 |**Funktion**|**Beschreibung**
64 |Syntax überprüfen|Über diese Funktion kann überprüft werden, ob die Syntax des Quellcode korrekt ist. Ist dies der Fall, wird eine kurze Information mit dem Inhalt Syntax korrekt. angezeigt. Andernfalls wird eine Fehlermeldung angezeigt, welche angibt, wo der Fehler liegt und von welcher Art der Fehler ist.
65 |Start|Über diese Funktion kann die Form so ausgeführt werden, wie sie später angezeigt wird. Dabei kann die Funktionalität bis auf eine Ausnahme getestet werden: Wird von einem Form-Element eine Variable genutzt, welcher im Client Command ein Wert dynamisch (d.h. ein anderer Wert als der Standardwert) zugeordnet wurde, ist dieser Wert hier nicht verfügbar. Dies ist dadurch bedingt, dass über die Funktion Ausführen lediglich die Form ausgeführt wird und nicht das komplette Client Command, wodurch die Variable nicht auf den entsprechenden Wert gesetzt werden konnte
66 |Bearbeiten|Unterhalb dieses Menüpunktes finden Sie die bekannten Funktionen Rückgängig, Wiederholen, Kopieren, Ausschneiden, Einfügen, Löschen, Alle auswählen, Suchen sowie Ersetzen. Die Funktionen Rückgängig, Wiederholen, Suchen sowie Ersetzen sind allerdings nur in der Quellcode-Ansicht (siehe [[Arbeitsfläche>>doc:||anchor="HArbeitsflE4che"]]) verfügbar.
67 |Hilfe|Unterhalb dieses Menüpunktes finden Sie die Funktionen Ausrichtungspalette anzeigen und Hinweise zu befehlen anzeigen.
68 Über Hinweise zu Befehlen anzeigen erreichen Sie die Befehlsreferenz, in der alle zur Verfügung stehenden Klassen, deren Methoden und Eigenschaften sowie Prozeduren und Konstanten aufgelistet werden. Diese werden auf der linken Seite, logisch in Units unterteilt, aufgelistet. Möchten Sie eine Methode, Prozedur oder Konstante verwenden, so müssen Sie die entsprechende Unit in der uses-Direktive im Code-Teil hinzufügen. Tragen Sie die Unit im Code-Teil manuell ein, oder markieren Sie die entsprechende Unit und klicken Sie auf hinzufügen
69 |Debug|Unterhalb dieses Menüpunktes finden Sie die Funktionen Trace into und Step over. Beide sind nur im Debugging-Modus aktiviert.
70 Mit Hilfe dieser Befehle können Sie den erstellten Quelltext gezielt debuggen. Step into bewirkt die schrittweise Verarbeitung. Step over bewirkt, dass gesamte Blöcke als ein Schritt bearbeitet. So kann verhindert werden, dass Wiederholungsstrukturen schrittweise abgearbeitet werden.
71 Die Funktion Ausrichtungspalette anzeigen öffnet ein kleines Fenster, über welches Sie die Ausrichtungen der aktuell markierten Objekte steuern können. Dazu markieren Sie vorher die betroffenen Elemente und klicken dann auf den entsprechenden Button der Ausrichtungsskala. Dies betrifft jedoch nur Objekte in der Form-Ansicht (siehe [[Arbeitsfläche>>doc:||anchor="HArbeitsflE4che"]]).
72
73 = Werkzeugpalette =
74
75 Die Werkzeugpalette beinhaltet alle grafischen Form-Elemente, die im Form-Editor genutzt werden können. Ein Element kann auf der Form eingefügt werden, indem es in der Werkzeugpalette angeklickt wird. Durch einen weiteren Klick auf die Form wird das Element an der aktuellen Mausposition eingefügt.
76 Die Elemente sind in die Gruppen Standard, Additional, Win32 und Dialogs eingeteilt, wobei es sich um Windows Standard Controls handelt:
77
78 |**Standard**| | |
79 |TMainMenu
80 TPopupMenu
81 TLabel
82 TEdit|(% style="width:274px" %)TMemo
83 TButton
84 TCheckbox|(% style="width:470px" %)TRadioButton
85 TListBox
86 TComboBox|TGroupbox
87 TPanel
88 TRadioGroup
89 |**Additional**| | |
90 |TBitBn
91 TSpeedButton
92 TMaskEdit
93 TImage|TShape
94 TBevel
95 TStaticText|TSplitter
96 TScrollBox
97 TCheckListBox|TLabeledEdit
98 TColorBox
99 TTimer
100 |**Win32**| | |
101 |TTabControl
102 TPageControl
103 TImageList|(% style="width:274px" %)TProgressBar
104 TTreeView
105 TListView|(% style="width:470px" %)TDateTimePicker
106 TMonthCalender
107 TRichEdit|TComPort
108 |**Dialogs**| | |
109 |TOpenDialog
110 TSaveDialog
111 TFontDialog|(% style="width:274px" %)TColorDialog
112 TPRintDialog
113 TPrinterSetupDialog|(% style="width:470px" %)TOpenPictureDialog
114 TSavePictureDialog
115 TFindDialog|TReplaceDialog
116 TPageSetupDialog
117
118 {{figure}}
119 (% style="text-align:center" %)
120 [[image:hmfile_hash_9c22f08e.png]]
121
122 {{figureCaption}}
123 Werkzeugpalette
124 {{/figureCaption}}
125 {{/figure}}
126
127 Da sich die genannten Form-Elemente – wie bereits erwähnt – alle stark an Delphi anlehnen, sind weitere Informationen über eine API im Internet zu finden.
128
129 == Standard Elemente ==
130
131 Die Elemente der Standardgruppe umfassen einige grundlegende grafische Bedienelemente.
132
133 |**Name**|**Beschreibung**
134 |TMainMenu|Erstellt eine horizontale Menüleiste am oberen Fensterrand. Elemente können über die Items Eigenschaft im Object Inspector eingefügt werden.
135 |TPopupMenu|Erstellt ein Popupmenü. Sie müssen dieses Menü einem anderen Element über die PopupMenü-Eigenschaft hinzufügen. Danach erscheint das Menü bei einem Rechtsklick auf das entsprechende Element.
136 |TLabel|Erstellt einfachen Text der frei platziert werden kann. Der Text kann vom Anwender nicht geändert werden.
137 |TEdit|Erstellt ein einfaches Textfeld, in das vom Anwender Text eingetragen kann. Mithilfe der Enabled-Eigenschaft kann das Feld nicht editierbar gemacht werden.
138 |TMemo|Erstellt ein mehrzeiliges Textfeld, welches sich ansonsten wie ein TEdit-Element verhält.
139 |TButton|Erstellt einen einfachen Button. Mithilfe der verschiedenen Events kann dem Button Funktionalität hinzugefügt werden.
140 |TCheckBox|Erstellt eine Checkbox. Auf diese Weise kann dem Anwender eine Auswahl an Optionen gegeben werden, wobei mehrere Optionen ausgewählt werden können
141 |TRadioButton|Erstellt einen Radio Button. Auf diese Weise kann dem Anwender eine Auswahl an Optionen gegeben werden, wobei im Unterschied zur Checkbox hier nur eine Auswahl getroffen werden kann. Eine Mehrfachauswahl ist nicht möglich.
142 |TListBox|Erstellt eine Liste. Je nach MultiSelect-Eigenschaft, kann der Anwender einen oder mehrere Einträge auswählen. Einträge werden über die Items-Eigenschaft hinzugefügt.
143 |TComboBox|Erstellt ein DropDown Feld. Einträge werden über die Items-Eigenschaft hinzugefügt.
144 |TGroupBox|Erstellt eine Groupbox zur logischen Strukturierung weiterer Elemente. Besonders wenn sich viele verschiedene Auswahlelemente in dem Fenster befinden, sorgt eine logische Einordnung für eine bessere Übersicht für den Anwender. Beachten Sie, dass Sie keine bestehenden Elemente zur GroupBox hinzufügen können. Erstellen Sie deshalb zuerst eine GroupBox und erzeugen Sie danach neue Elemente in dieser.
145 |TPanel|Erstellt ein Panel zur logischen Strukturierung weiterer Elemente. Das Panel bietet keine eigenen besonderen Eigenschaften. Es können jedoch alle Events genutzt werden, um auf verschiedene Ereignisse zu reagieren. Beachten Sie, dass Sie keine bestehenden Elemente zum Panel hinzufügen können. Erstellen Sie deshalb zuerst ein Panel und erzeugen Sie danach neue Elemente in diesem.
146 |TRadioGroup|Erstellt eine Gruppe von Radio Buttons. Innerhalb einer Gruppe kann immer nur ein Eintrag ausgewählt werden. Einträge werden über die Items-Eigenschaft hinzugefügt.
147
148 == Dialoge ==
149
150 Bei den Elementen der Dialogs Gruppe handelt es sich um verschiedene Dialoge, die die Interaktion mit dem Benutzer vereinfachen. Um einen Dialog zu benutzen, platzieren Sie ihn auf der Form. Während Sie im Formeditor arbeiten, wird der Dialog als kleines Icon auf der Form dargestellt, wird das Client Command später ausgeführt wird das Icon nicht angezeigt.
151
152 {{aagon.infobox}}
153 Alle Dialoge stellen lediglich eine Oberfläche zur Verfügung, dass bedeutet, sämtliche Funktionen müssen selber implementiert werden.
154 {{/aagon.infobox}}
155
156
157 |**Name**|**Beschreibung**
158 |TOpenDialog|Ein einfacher "Öffnen"-Dialog, der eine Dateiauswahl ermöglicht.
159 |TSaveDialog|Ein Dialog zum Auswählen eines Speicherortes.
160 |TFontDialog|Ermöglicht das Verändern von Schriftarten.
161 |TColorDialog|Mithilfe dieses Dialogs ist es möglich verschiedene Farben auszuwählen oder eine spezielle Farbe zu definieren.
162 |TPrintDialog|Öffnet einen einfachen Druckdialog, um Dokumente zu drucken.
163 |TPrinterSetupDialog|Öffnet einen Dialog, um verschiedene Druckereinstellungen festlegen zu können.
164 |TOpenPictureDialog|Verhält sich ähnlich wie TOpenDialog, allerdings lassen sich nur Bilddateien auswählen.
165 |TSavePictureDialog|Verhält sich ähnlich wie TSaveDialog, allerdings lassen sich nur eine Bilddatei speichern.
166 |TFindDialog|Öffnet einen Dialog um nach bestimmten Wörtern oder Wortteilen zu suchen
167 |TReplaceDialog|Erweitert den TFindDialog um die Möglichkeit Wörter zu ersetzen
168 |TPageSetupDialog|Ein Dialog um Papierseiteneinstellungen vorzunehmen.
169
170 = Object Inspector Form Editor =
171
172 |(% style="width:368px" %)(((
173 (% style="text-align:center" %)
174 [[image:hmfile_hash_b4e3e86a.png]]
175
176
177 )))|(% style="width:995px" %)(((
178 Der Object Inspector besitzt zwei Tabs: Eigenschaften und Events.
179 Über diese beiden Tabs können die Eigenschaften sowie die Ereignisse des aktuell markierten Form-Elements eingesehen und bearbeitet werden.
180 Über die Auswahlleiste kann ein Form-Element direkt ausgewählt werden.
181
182 Die Eigenschaften eines Elements werden unter dem Tab Eigenschaften aufgelistet. Die Werte können einfach bearbeitet und geändert werden. Besitzt eine Eigenschaft weitere Teileigenschaften, können diese über den +-Button vor der Eigenschaft angezeigt und ebenfalls bearbeitet werden.
183
184 Die Ereignisse eines Elements werden unter dem Tab Events aufgelistet. Dort kann für jedes mögliche Ereignis eine Funktion angegeben werden, welche aufgerufen wird, sobald das entsprechende Ereignis ausgelöst wird. Die Funktion kann dabei über eine Liste ausgewählt werden, in welcher alle bereits im Quellcode definierten Funktionen aufgelistet werden. Existiert noch keine Funktion, die einen passenden Code enthält, kann über einen Doppelklick auf die leere Auswahl automatisch eine neue Funktion im Quellcode erzeugt und angezeigt werden. Ein Doppelklick auf eine bereits ausgewählte Funktion zeigt die entsprechende Funktion an.
185 )))
186
187 = Arbeitsfläche =
188
189 Die Arbeitsfläche stellt den Hauptteil des Form Editors dar, wobei sie sich in die beiden beiden Tabs Form und Quellcode aufteilt. Der Tab Design beinhaltet die grafischen Komponenten, während der Tab Code den Programmcode enthält.
190
191 {{figure}}
192 (% style="text-align:center" %)
193 [[image:hmfile_hash_87cf5a66.png]]
194
195 {{figureCaption}}
196 Arbeitsfläche des Form Editors
197 {{/figureCaption}}
198 {{/figure}}
199
200 Über den Tab Design kann der komplette Dialog designed werden, ohne eine einzige Zeile Quellcode schreiben zu müssen. Dabei können Form-Elemente eingefügt, positioniert und über deren Eigenschaften bzw. Ereignisse konfiguriert werden.
201
202 Über den Tab Code kann der eigentliche Programmcode erstellt werden. Automatisch eingefügte Funktionen sind meist am Ende des bestehenden Programmcodes zu finden.
203
204
205 = Exemplarische Erstellung einer Form =
206
207 In diesem Abschnitt soll eine Beispiel-Form Schritt für Schritt erstellt werden, um die Handhabung des Form Editor vorzustellen. Die Form soll dabei eine Liste aller Clients enthalten, die automatisch beim Start der Form mit Daten aus der ACMP-Datenbank gelesen werden. Sobald ein Client markiert wird, sollen zusätzliche Eigenschaften des Clients geladen und angezeigt werden. Schließlich soll es möglich sein, die angezeigten Daten in einer Datei zu speichern.
208
209 {{figure}}
210 (% style="text-align:center" %)
211 [[image:hmfile_hash_b770d66e.png]]
212
213 {{figureCaption}}
214 Fertige Form
215 {{/figureCaption}}
216 {{/figure}}
217
218 Im [[ersten Schritt>>doc:||anchor="HClientsausderDatenbankauslesen"]] lernen Sie, wie Sie Informationen aus der ACMP-Datenbank auslesen und als Liste anzeigen können. Im [[zweiten Schritt>>doc:||anchor="HAuswahlbasierteClientdatenanzeigen"]] wird die Möglichkeit hinzugefügt für ausgewählte Clients weitere Details anzeigen zu lassen. Im [[letzten Schritt>>doc:||anchor="HClientdatenspeichern"]] lernen Sie den Umgang mit zusätzlichen Dialogen, um die Daten in eine Datei zu speichern.
219
220 Erstellen Sie über die ACMP Console zunächst ein neues Client Command und ziehen Sie das Kommando FormEditor in den Skript-Bereich. Anschließend klicken Sie in dem neuen Dialog auf Form Bearbeiten und öffnen so den FormEditor.
221
222 == Clients aus der Datenbank auslesen ==
223
224 Auf der leeren Form erstellen Sie nun ein Label und eine ListBox. Dazu klicken Sie in der Werkzeugpalette auf das jeweilige Symbol. Mit einem weiteren Klick auf die Form, wird die Komponente an der Mausposition erstellt. Über den Object Inspector können Sie nun die Eigenschaften der jeweils markierten Komponente ändern. Zum Beispiel lässt sich der Name des Labels auf Clients setzen sowie die Höhe der ListBox ändern.
225
226 {{figure}}
227 (% style="text-align:center" %)
228 [[image:hmfile_hash_6ce3643c.png]]
229
230 {{figureCaption}}
231 Hinzufügen der erforderlichen Elemente
232 {{/figureCaption}}
233 {{/figure}}
234
235 Damit die ListBox direkt beim Aufruf der Form alle Clients beinhaltet, muss der passende Programmcode in DelphiSkript erstellt werden. Klicken Sie auf den Tab Code unterhalb der Form. Es wird Ihnen nun der Quellcode für die Form angezeigt, wo Sie die beiden Funktionen OkButtonClick und CancelButtonClick finden. Diese Funktionen sind für den bereits vorhandenen OK- bzw. Cancel-Button gedacht, wodurch die Form über CloseForm() mit einem entsprechenden Rückgabewert beendet wird.
236
237 Erstellen Sie nun manuell die Funktion FormActivate, welche automatisch durchlaufen wird, sobald die Form aufgerufen wird. Hier deklarieren Sie zunächst die Variablen LSQL als String, LClients als TStringList und i als integer. Anschließend initialisieren Sie die Variable LClients. Diese Variablen werden benötigt, um im Folgenden auf die Datenbank zuzugreifen.
238
239 Als nächstes erstellen Sie ein SQL-Kommando, um den Computernamen aller Clients aus der ACMP Datenbank auszulesen und speichern es in der Variablen LSQL. Damit Sie Zugriff auf die ACMP Datenbank erhalten, müssen Sie zunächtst die AagonSQLQuery unit importieren. Öffnen Sie dazu die Befehlsreferenz, markieren Sie die AagonSQLQuery unit und klicken Sie auf hinzufügen. Nun muss die sqlquery ausgeführt werden, welche folgende Parameter benötigt:
240
241 |**Parameter**|**Beschreibung**
242 |SQLStatement|Das SQL-Statement selbst. Im Beispiel LSQL.
243 |ConnectionString|Verbindungsangaben zum SQL-Server in der Standardnotation. Wird im Beispiel nicht benötigt, da die Abfrage über den //ExecuteOnACMPServer //Parameter auf dem ACMP Server ausgeführt wird.
244 |Variable|Projektvariable in der das Ergebnis gespeichert werden kann.
245 |ResultList|String-Liste, in welcher die Ergebnisse gespeichert werden. Im Beispiel ist dies die Variable LClients.
246 |ExecuteOnACMPServer|Eine true/false-Angabe, ob die Abfrage auf der ACMP Datenbank ausgeführt werden soll. Bei der Angabe von true wird kein ConnectionString benötigt.
247
248 Nach dem Ausführen der Abfrage sind die Abfrageergebnisse in der Variablen LClients hinterlegt. Mit Hilfe einer for-Schleife werden nun die Ergebnisse durchlaufen und der ListBox hinzugefügt. Da die Ergebnisse in der Form Spaltenname=Wert sind, muss der Spaltenname (in diesem Fall Computername) inkl. des Gleichheit-Zeichens jedoch zuvor entfernt werden, was über die Funktion StringReplace erfolgt.
249
250 {{code language="None"}}
251 procedure FormActivate(Sender: TObject);
252
253 var
254 LSQL: String;
255 LClients: TStringList;
256 i: integer;
257 begin
258 LClients := TStringList.Create;
259 try
260 LSQL := 'Select COMPUTERNAME from CLT_CLIENTS_Table';
261 sqlquery(LSQL, '', '', LClients, true);
262 for i := 0 to LClients.count-1 do
263 begin
264 ListBox1.items.add(StringReplace(LClients.strings[i], 'COMPUTERNAME=', ''));
265 end;
266 finally
267 LClients.Free;
268 end;
269 end;
270 {{/code}}
271
272 Zuletzt werden die Ressourcen der Variable LClients über den Aufruf LClients.Free freigegeben. Ordnen Sie diese Funktion nun dem Event OnActive zu, sodass die Funktion automatisch ausgeführt wird.
273
274 {{aagon.infobox}}
275 Beachten Sie, dass Sie keine Komponente markiert haben, wenn Sie die Funktion FormActive dem Event OnActive-Event zuordnen.
276 {{/aagon.infobox}}
277
278 Wenn Sie die Form nun starten, werden die Computernamen aller Clients in der ListBox aufgelistet. Je nach Anzahl der Clients kann dies einige wenige Sekunden dauern.
279
280 == Auswahlbasierte Clientdaten anzeigen ==
281
282 Nachdem alle Clients in einer ListBox aufgelistet werden, sollen nun ein paar Daten des Clients aus der Datenbank geladen und angezeigt werden, welcher in der ListBox markiert wird. Die zu ladenden Daten werden hier nun auf die Computerdomain, die Computerbeschreibung, die IP Adresse, die MAC Adresse, den Betriebssystemnamen, die Betriebssystemversion und das aktuelle ServiePack festgelegt.
283
284 Für die genannten Daten fügen Sie für jeden Datensatz ein Label und ein Edit-Feld auf der Form ein. Die Label benennen Sie entsprechend dem Datensatz der in dem zugehörigen Edit-Feld angezeigt werden soll. Geben Sie den Edit-Feldern ebenfalls sprechende Namen über den Object Inspector, über welche die Felder angesprochen werden können. Im Beispiel sind dies die Namen EditDomain, EditBeschreibung, EditIP, EditMAC, EditOS, EditVersion und EditSP.
285
286 Damit die soeben erstellten Komponenten mit den Daten eines in der ListBox markierten Clients gefüllt werden können, muss die ListBox angepasst werden. Um die ListBox anzupassen, klicken Sie diese an und wählen Sie den Tab Events im Object Inspector an. Dort führen Sie einen Doppelklick auf das Leerfeld neben dem Event OnClick aus. Dadurch wird automatisch die Funktion ListBox1Click() im Quellcode erstellt, welche automatisch aufgerufen wird, sobald Sie einen Client in der ListBox markieren.
287
288 {{figure}}
289 (% style="text-align:center" %)
290 [[image:hmfile_hash_daf32a8f.png]]
291
292 {{figureCaption}}
293 Hinzufügen weiterer Elemente um Details anzeigen zu können
294 {{/figureCaption}}
295 {{/figure}}
296
297 Zunächst deklarieren Sie nun die Variablen LSqlID, LSqlPC und LSqlOS als String sowie LID, LPC und LOS als TStringList. Weiterhin werden die Strings pc und os und der integer pos benötigt. Anschließend müssen Sie die Variablen LID, LPC und LOS mit TStringList.Create initialisiert werden. In einem try/finally-Block werden nun die Daten des markierten Clients ausgelesen. Dazu wird die Variable LSqlID mit einem SQL-Statement gesetzt, welches die ClientID aus der Datenbank ausliest. Die ClientID wird hier über den Clientnamen des markierten Clients identifiziert. Der aktuell markierte Clientname lässt sich über listBox1.items.strings[listBox1.ItemIndex] herausfinden. Nachdem das SQL-Statement LSqlID über sqlquery ausgeführt wurde, befindet sich das Ergebnis in der TStringList-Variablen LID. Da sich das Ergebnis aber wieder im Format Spaltenname=Wert befindet, wird der eigentliche Wert mit Hilfe eines Copy ausgelesen und anschließend wieder in der gleichen Variablen gespeichert.
298
299 Da die ClientID des markierten Clients nun bekannt ist, können die Variablen LSqlPC und LSqlOS mit jeweils einem SQL-Statement versehen werden. Dabei liest das SQL-Statement der Variablen LSqlPC die Daten Domain, Beschreibung, IP Adresse und MAC Adresse aus der Datenbanktabelle CLT_CLIENTS. Das SQL-Statement der Variablen LSqlOS hingegen liest die Werte Betriebssystem, Version und ServicePack aus der Datenbanktabelle CLT_OPERATINGSYSTEM aus. Über die Where-Klausel in Verbindung mit der soeben ausgelesenen ClientID werden nur die Daten eines einzelnen Clients ausgelesen.
300
301 Die Ergebnisse der sqlquery-Abfragen mit den Variablen LSqlPC und LSqlOS befinden sich in den Variablen LPC und LOS. Damit die Ergebnisse weiterverarbeitet und korrekt angezeigt werden können, werden die Ergebnisstrings in den entsprechenden Variablen pc bzw. os gespeichert.
302
303 Die Ergebnisse liegen jetzt in dem Format Spaltenname=Wert,Spaltenname=Wert,[…] vor. Diese Ergebnisse werden nun von vorne nach hinten mit Delete-, Pos- und Copy-Funktionen zerteilt. Dadurch können die eigentlichen Werte aus dem Ergebnis herauskopiert und mit EditX.Text direkt in das entsprechende Edit-Feld geschrieben werden. Dies wird zunächst für die Variable pc und anschließend für die Variable os durchgeführt.
304
305 Zuletzt sollten Sie Ressourcen der Variablen LID, LPC und LOS mit .Free wieder freigeben. Wenn Sie die Form nun starten und einen Client markieren, sollten seine Werte angezeigt werden.
306
307 {{code language="None"}}
308 procedure ListBox1Click(Sender: TObject);
309
310 var
311 LSqlID, LSqlPC, LSqlOS: String;
312 LID, LPC, LOS: TStringList;
313 pc, os : String;
314 pos: integer;
315 begin
316 LID := TStringList.Create;
317 LPC := TStringList.Create;
318 LOS := TStringList.Create;
319 try
320 LSqlID := 'Select CLIENTID from CLT_CLIENTS_Table WHERE COMPUTERNAME='''
321 + listBox1.items.strings[listBox1.ItemIndex] + '''';
322 SqlQuery(LSqlID, '', '', LID, true);
323 if (LID.Count > 0) then
324 begin
325 LID.strings[0] := Copy(LID.strings[0], 10, Length(LID.strings[0]));
326 LSqlPC := 'Select COMPUTERDOMAIN, COMPUTERDESCRIPTION, PRIMARYIP, MACADDRESS'
327 + ' From CLT_CLIENTS_Table Where CLIENTID=' + quotedstr(LID.strings[0]);
328 LSqlOS := 'Select OSSTRING, PRODUCTTYPE, SERVICEPACK From CLT_OPERATINGSYSTEM'
329 + ' Where CLIENTID=' + quotedstr(LID.strings[0]);
330 SqlQuery(LSqlPC, '', '', LPC, true);
331 pc := LPC.strings[0];
332 SqlQuery(LSqlOS, '', '', LOS, true);
333 os := LOS.Strings[0];
334 Delete(pc, 1, 15); pos := Pos(',', pc);
335 EditDomain.Text := Copy(pc, 0, pos-1);
336 pos := Pos('=', pc);
337 Delete(pc, 1, pos);
338 pos := Pos(',', pc);
339 EditBeschreibung.Text := Copy(pc, 0, pos-1);
340 pos := Pos('=', pc);
341 Delete(pc, 1, pos);
342 pos := Pos(',', pc);
343 EditIP.Text := Copy(pc, 0, pos-1);
344 pos := Pos('=', pc);
345 Delete(pc, 1, pos);
346 EditMAC.Text := Copy(pc, 0, Length(pc));
347 Delete(os, 1, 9);
348 pos := Pos(',', os);
349 EditOS.Text := Copy(os, 0, pos-1);
350 pos := Pos('=', os);
351 Delete(os, 1, pos);
352 pos := Pos(',', os);
353 EditVersion.Text := Copy(os, 0, pos-1);
354 pos := Pos('=', os);
355 Delete(os, 1, pos);
356 EditSP.Text := Copy(os, 0, Length(os));
357 end;
358 finally
359 LID.Free;
360 LPC.Free;
361 LOS.Free;
362 end;
363 end;
364 {{/none}}
365 {{/code}}
366
367 == Clientdaten speichern ==
368
369 Die Daten des aktuell markierten Clients werden nun angezeigt. Die Funktion der Form soll jetzt um die Möglichkeit erweitert werden, die Daten eines Clients in einer Datei speichern zu können. Dazu platzieren Sie einen Button auf der Form und weisen ihm über den Object Inspector z.B. die Caption (Überschrift) In Datei speichern zu. Anschließend erstellen Sie über den Tab Events eine neue Funktion indem Sie einen Doppelklick in das leere Feld neben dem Event OnClick ausführen.
370
371 {{figure}}
372 (% style="text-align:center" %)
373 [[image:hmfile_hash_009b2bf0.png]]
374
375 {{figureCaption}}
376 Vervollständigen der Form
377 {{/figureCaption}}
378 {{/figure}}
379
380 Da der Benutzer später die Möglichkeit haben soll, die angezeigten Daten in einer beliebigen Datei speichern zu können, wird ein entsprechender (Standard-)Dialog benötigt, welcher eine Dateiauswahl zulässt. Um diesen zu erstellen, wechseln Sie von dem Code- zum Design-Tab und positionieren die Komponente TSaveDialog aus der Werkzeugpalette (unter Dialogs) auf der Form. Über den Object Inspector können Sie die z.B. die DefaultExt (Dateierweiterung) auf .txt und den Filter auf Text file (*.txt) | *.txt setzen. Die Komponente ist bei der Ausführung der Form allerdings nicht zu sehen.
381
382 Wechseln Sie nun wieder zur Quellcode-Ansicht in die Funktion Button1Click. Dort deklarieren Sie die TStringList-Variable data. Anschließend wird eine Sicherheitsabfrage eingebaut, welche kontrolliert, ob überhaupt ein Client in der ListBox markiert ist. Ist dies nicht der Fall, wird das Speichern über exit abgebrochen.
383
384 Dem TSaveDialog wird nun ein Dateiname zugewiesen. Dazu wird die markierte Clientname aus der ListBox ausgelesen, wie es bereits in der Funktion FormActivate geschieht. Anschließend wird der TSaveDialog in einer if-Abfrage ausgeführt. Dadurch öffnet sich der Standarddialog zum Speichern einer Datei. Als Dateiname ist bereits der eben zugewiesene Clientname als Vorschlag eingetragen. Wird der Dialog abgebrochen, wird ein Informationsdialog ausgegeben, dass das Speichern fehlgeschlagen ist.
385
386 Wird der Dialog bestätigt, wird in einem try/finally-Block die Variable data zunächst initialisiert und über die add()-Funktion mit den Daten aus den Edit-Feldern sowie dem Clientname aus der ListBox gefüllt. Anschließend wird die Methode SaveToFile aufgerufen, wodurch der Dateiinhalt in der ausgewählten Datei gespeichert wird. SaveDialog1.FileName beinhaltet dabei den ausgewählten Dateinamen.
387
388 Nach der Speicherung werden die Ressourcen der Variable data freigegeben. Die Form ist nun fertig und besitzt die verlangten Funktionen.
389
390 {{code language="None"}}
391 procedure Button1Click(Sender: TObject);
392 var
393 data : TStringList;
394 begin
395 if ListBox1.ItemIndex < 0 then
396 exit;
397 SaveDialog1.FileName := ListBox1.items.strings[ListBox1.ItemIndex] + '.txt';
398 if SaveDialog1.Execute(null) then
399 begin
400 try
401 data := TStringList.Create();
402 data.Add('Client = ' + ListBox1.items.strings[ListBox1.ItemIndex]);
403 data.Add('Domain = ' + EditDomain.Text);
404 data.Add('Beschreibung = ' + EditBeschreibung.Text);
405 data.Add('IP Adresse = ' + EditIP.Text);
406 data.Add('MAC Adresse = ' + EditMAC.Text);
407 data.Add('Betriebssystem = ' + EditOS.Text);
408 data.Add('Version = ' + EditVersion.Text);
409 data.Add('ServicePack = ' + EditSP.Text);
410 data.SaveToFile(SaveDialog1.FileName);
411 finally
412 data.Free;
413 ShowMessage('Daten wurden gespeichert in: ' + SaveDialog1.FileName);
414 end;
415 end;
416 else
417 ShowMessage('Speichern abgebrochen.');
418 end;
419 {{/code}}
420
421 = Erstellung eines AD-Formulars =
422
423 Der Form Editor in ACMP unterstützt auch die Verwendung der LDAP-Befehle Search und Modify. Im Folgenden wird aufgezeigt, wie Sie ein entsprechendes Formular erstellen. Sie werden kennenlernen, wie Sie ein Formular erstellen und einen LDAP-Suchfilter einrichten und wie Sie bei LDAP-Attribute über das Formular ändern können.
424
425 == Vorbereitung in der Code-Ansicht ==
426
427 Wechseln Sie in die Code-Ansicht des Formulars und fügen Sie zunächst die folgenden Units hinzu: //Classes//, //Graphics//, //Controls//, //Forms//, //Dialogs//, //ExtCtrls//, //StdCtrls//, //SysUtils//, //Buttons//, //AagonLDAP//;
428
429 Anschließend definieren Sie globale Variablen vom Typ String für den //Host//, den //Port//, den User, das //Passwort//, die //Basis der Suche//, den //Suchfilter //und für eine //Fehlermeldung //sowie eine gloabale Variable vom Typ TStringList für die Ergebnissliste.
430
431 **Codebeispiel**
432
433 {{code language="None"}}uses
434 Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls,
435 StdCtrls, SysUtils, Buttons, AagonLDAP;
436 var
437 llist : TStringList;
438 strHost, strPort, strUser, strPwd, strBaseDN, strFilter, strError: String; {{/code}}
439
440
441 Erstellen Sie eine Funktion, mit welcher Sie eingegebene Strings escapen können.
442
443 **Codebeispiel**
444
445 {{code language="None"}}function escapevalues(Value: String) : String;
446 begin
447 Value := '"'+StringReplace(Value,',','","')+'"';
448 Result := StringReplace(Value, '","","', ',');
449 end; {{/code}}
450
451
452 {{aagon.infobox}}
453 Diese Funktion muss sich immer oberhalb der erstellten Prozeduren befinden.
454 {{/aagon.infobox}}
455
456 Erstellen Sie nun eine Prozedur, in der Sie für die Variablen Werte festlegen:
457
458 |(% style="width:185px" %)**Wert**|(% style="width:678px" %)**Beschreibung**
459 |(% style="width:185px" %)Host|(% style="width:678px" %)Domänencontroller an den die Anfrage gestellt wird
460 |(% style="width:185px" %)Port|(% style="width:678px" %)Für die Anfrage verwendeter Port (Port 389: LDAP, Port 3268: Global Katalog)
461 |(% style="width:185px" %)User|(% style="width:678px" %)Benutzer für die Anfrage
462 |(% style="width:185px" %)Passwort|(% style="width:678px" %)Passwort des Benutzers
463 |(% style="width:185px" %)BaseDN|(% style="width:678px" %)Basis der Suche (DistinguishedName)
464 |(% style="width:185px" %)Filter|(% style="width:678px" %)LDAP-Suchfilter
465
466 **Codebeispiel**
467
468 {{code language="None"}}
469 procedure formActivate(Sender: TObject);
470 begin
471 strHost := '192.168.1.1';
472 strPort := '389';
473 strUser := 'MeinBenutzer@meine.domäne';
474 strPwd := 'meinGeheimesPasswort123';
475 strBaseDN := 'dc=meine,dc=domäne';
476 strFilter := '';
477 llist := TStringList.Create();
478 end;
479 {{/code}}
480
481 Wechseln Sie nun zurück in die Design-Ansicht und markieren Sie die Form. In der Event-Übersicht müssen Sie jetzt das Event OnActivate auswählen und die erstellte Prozedur "FormActivate" aus der Liste verknüpfen, damit diese vom Event ausgeführt wird. Zusätzlich legen Sie eine Liste an, in welcher Ihre Ergebnisse gespeichert werden sollen um diese im Formular anzuzeigen.
482
483 === Erstellen des Formulars ===
484
485 Wechseln Sie in die Design-Ansicht des Formulars und erstellen Sie ein Formular mit den folgenden Elementen:
486
487 * Ein Textfeld zur Eingabe des Suchfilters (hier kann optimal ein beschreibendes Label eingefügt werden)
488 * Einen Button, mit dem Sie den Suchfilter ausführen
489 * Eine Textarea, in der Ihnen die Suchergebnisse angezeigt werden (hier kann optional ein beschreibendes Label eingefügt werden)
490
491 {{figure}}
492 (% style="text-align:center" %)
493 [[image:hmfile_hash_b498888f.png]]
494
495 {{figureCaption}}
496 Beispiel des Formulars - Suche
497 {{/figureCaption}}
498 {{/figure}}
499
500 Damit Sie den Suchfilter nicht bei jedem Aufruf erneut vollständig eintragen müssen, markieren Sie das Feld und wählen am linken Fensterrand die Eigenschaft Text aus. Tragen Sie nun Ihren Suchfilter ein. In diesem Bespiel wird der folgende Filter verwendet:
501
502 {{code language="None"}}
503 (&(ObjectClass=User)(!(objectClass=Computer)))
504 {{/code}}
505
506 Das Textfeld ist nun schon mit dem Suchfilter vorgefüllt.
507
508
509 === Suchen-Button konfigurieren ===
510
511 Damit Sie die LDAP-Suche ausführen können, müssen Sie den Suchen-Button konfigurieren. Wechseln Sie hierzu in die Code-Ansicht des Formulars. Hier erstellen Sie nun die Prozedur SearchLdapClick.
512
513 Definieren Sie zunächst eine temporäre Liste sowie einen Integer. Damit Sie den im Textfeld edfilter bereitbestellten Suchfilter benutzen, weisen Sie den Text des Suchfilterfeldes Ihrer Filter-Variable zu. Führen Sie einen LDAPsearch aus. Hierbei geben Sie den Host, den Port, die Authentifizierungsmethode, den User, das Passwort, Ihren Einstiegspunkt, den Filter, den Suchbereich, die Ergebnisliste und einen String für eventuelle Fehlermeldungen an.
514
515 Die in der Variable llist enthaltenen Ergebnisse werden nun durchlaufen und der listbox1 hinzugefügt.
516
517 **Codebeispiel**
518
519 {{code language="None"}}
520 Procedure SearchLdapClick;
521 var
522 ltemp : TStringList;
523 i : Interger;
524 begin
525 ltemp := TStringList.Create();
526 strFilter := edfilter.Text;
527 llist.Clear();
528 ListBox1.Clear();
529 LDAPSearch(strHost, strPort, 2, strUser, strPwd, strBaseDN, strFilter, 2, llist, strError);
530 for i := 0 to llist.count-1 do
531 begin
532 ltemp.commatext := escapevalues(llist.Strings[i]);
533 listbox1.items.Add(ltemp.values['CN']);
534 end
535 ltemp.free();
536 end;
537 {{/code}}
538
539 Wechseln Sie nun zurück in die Design-Ansicht und markieren den Suchen-Button. In der Event-Übersicht wählen Sie für das Event OnClick die soeben erstelle Prozedur aus der Liste aus. Wenn Sie nun im Formular den Button Suchen klicken, werden Ihnen die Ergebnisse im Suchergebnisfeld angezeigt.
540
541 === Auslesen/ Anzeigen einzelner Werte ===
542
543 Damit Sie sich einzelne ausgelesene Werte für die Ergebnisse anzeigen lassen können, erstellen Sie nun in der Design-Ansicht die entsprechender Felder. Im Beispiel werden die Felder Vorname, Nachname und Telefonnummer angelegt.
544
545 {{figure}}
546 (% style="text-align:center" %)
547 [[image:hmfile_hash_12c11bb1.png]]
548
549 {{figureCaption}}
550 Beispiel der Formulars-Anzeige
551 {{/figureCaption}}
552 {{/figure}}
553
554 Damit Ihnen nun zu einem Ergebnis auch die richtigen Werte angezeigt werden, müssen Sie in der Code-Ansicht die folgende Prozedur erstellen:
555
556 **Codebeispiel**
557
558 {{code language="None"}}
559 Procedure UserSelect;
560 var
561 ltemp : TStringList;
562 begin
563 ltemp := TStringList.Create();
564 if ((ListBox1.ItemIndex > -1) AND (ListBox1.Count > 0)) then
565 begin
566 ltemp.commatext := escapevalues(llist.Strings[ListBox1.ItemIndex]);
567 edGivenname.Text := ltemp.Values['givenName'];
568 edSN.Text := ltemp.Values['SN'];
569 edTelephonenumber.Text := ltemp.Values['telephoneNumber'];
570 end
571 ltemp.Free();
572 end;
573 {{/code}}
574
575 Zum Anzeigen der Werte wechseln Sie nun in die Design-Ansicht und markieren das Suchergebnisfeld. Im linken Fensterbereich wählen Sie den Reiter Events und tragen bei OnClick die gerade erstellte Prozedur ein.
576
577 === Anpassen einzelner Werte ===
578
579 Erstellen Sie nun einen Button in der Design-Ansicht, mit dem Sie die Daten ändern wollen. Im Beispiel wird nur die Telefonnummer aktualisiert.
580
581 {{figure}}
582 (% style="text-align:center" %)
583 [[image:hmfile_hash_a04bb2f8.png]]
584
585 {{figureCaption}}
586 Beispiel des Formulars - Ändern
587 {{/figureCaption}}
588 {{/figure}}
589
590 Führen Sie nun in der Design-Ansicht einen Doppelklick auf den neu erstellten Button aus um in die Code-Ansicht zu wechseln.
591
592 Definieren Sie nun je eine Liste für das Attribut und die Ergebnismenge sowie einen Integer. Nachdem Sie geprüft haben, welches Ergebnis ausgewählt und angezeigt wurde, können Sie den im Anzeigefeld eingetragenen Wert (in diesem Beispiel die Telefonnummer) im markierten Ergebnis aktualisieren. Hierzu führen Sie einen LDAPmodify aus. Als notwendige Parameter geben Sie den Host, den Port, die Authentifizierungsmethode, den User, das Passwort, das anzupassende AD-Object und den anzupassenden Wert an. Abschließend geben Sie an, ob der eingegebene Wert den vorhandenen überschreiben soll (true) oder ob der eingegebene Wert an den bereits vorhandenen angefügt werden soll (false).
593
594 **Codebeispiel**
595
596 {{code language="None"}}
597 procedure ModifyLDAPObjectTelephonenumberClick;
598 var
599 lattrib, ltemp : TStringList;
600 strUserDN : String;
601 intEC : Integer;
602 begin
603 lattrib := TStringList.Create();
604 ltemp := TStringList.Create();
605 strUserDN := '';
606
607 ltemp.commatext := escapevalues(llist.Strings[ListBox1.ItemIndex]);
608
609 strUserDN := ltemp.Values['distinguishedName'];
610 lattrib.Add('telephonenumber='+edTelephonenumber.text);
611
612 intEC := LDAPModifyAttributes(strHost, strPort, 2, strUser, strPwd, strUserDN, lattrib, false);
613
614 lattrib.Free();
615 ltemp.Free();
616 end;
617 {{/code}}
618
619 == Parameter ==
620
621 === Authentifizierungsmethode ===
622
623 Die Authentifizierungsmethode gibt an, wie die LDAP-Verbindung hergestellt werden soll. Die folgenden 3 Werte sind möglich:
624
625 |(% style="width:68px" %)**Wert**|(% style="width:1295px" %)**Beschreibung**
626 |(% style="width:68px" %)0|(% style="width:1295px" %)Die Verbindung wird anonym aufgebaut.
627 |(% style="width:68px" %)1|(% style="width:1295px" %)Die Verbindung wird mit einem Windows-Benutzer hergestellt.
628 |(% style="width:68px" %)2|(% style="width:1295px" %)Die Verbindung wird mit anzugebenen Benutzerdaten (User und Passwort) hergestellt.
629
630 === Suchbereich ===
631
632 Sie können den Suchbereich festlegen, um die Ergebnismenge zu beschränken. Hierbei sind die folgenden 3 Werte möglich:
633
634 |**Wert**|**Beschreibung**
635 |0|Der Suchbereich beschränkt sich auf das angegebene Verzeichnis.
636 |1|Der Suchbereich beschränkt sich auf eine Ebene unter dem angegebenen Verzeichnis. Das Verzeichnis selbst ist hierbei nicht im Suchbereich.
637 |2|Der Suchbereich umfasst das angegebene Verzeichnis sowie alle untergeordneten Verzeichnisse.
638
639 == Nutzung von Projektvariablen ==
640
641 Eine Projektvariable kann dazu genutzt werden, Informationen und Daten aus dem aktuellen Client Command in eine mit dem Form Editor erstellte Form zu übertragen. Ebenso können Informationen und Daten aus der erstellten Form nach deren Schließung zurück in das aktuelle Client Command übertragen werden. Somit lässt sich der Ablauf des Client Command beliebig steuern.
642 Zunächst legen Sie dazu eine Projektvariable an. Wenn Sie anschließend das Kommando Form editor nutzen, können Sie über die Funktion Code generieren (siehe [[Menüleiste>>doc:ACMP.64.ACMP-Solutions.Client Commands.Client Command erstellen.Client Commands neu hinzufügen.Client Command Editor.Menüleiste.WebHome]]) einen Dialog aufrufen.
643
644 {{figure}}
645 (% style="text-align:center" %)
646 [[image:hmfile_hash_6d486a19.png]]
647
648 {{figureCaption}}
649 Code generieren
650 {{/figureCaption}}
651 {{/figure}}
652
653 Über diesen Dialog können Sie die entsprechende Projektvariable wählen. Markieren Sie nun die Option Werte beim Start laden bzw. die Option Werte beim Beenden speichern. Dadurch werden beim Start der Form die Werte für sämtliche Komponenten aus der angegebenen Variable geladen, falls diese existieren. Ebenso werden die Inhalte sämtlicher Komponenten beim Beenden der Form in der angegebenen Variable gespeichert.
654
655 Über die Option Werte beim Start laden wird der folgende Code in der automatisch generierten Funktion FormActivate() erstellt. Dadurch werden in diesem Beispiel alle Edit-Felder mit Informationen belegt, welche in der Variablen VAR zu finden sind:
656
657 {{code language="None"}}
658 EditDomain.Text := GetVarContent('VAR.EditDomain');
659 EditBeschreibung.Text := GetVarContent('VAR.EditBeschreibung');
660 EditIP.Text := GetVarContent('VAR.EditIP');
661 EditMAC.Text := GetVarContent('VAR.EditMAC');
662 EditOS.Text := GetVarContent('VAR.EditOS');
663 EditVersion.Text := GetVarContent('VAR.EditVersion');
664 EditSP.Text := GetVarContent('VAR.EditSP');
665 {{/code}}
666
667 In der automatisch generierten Funktion OkButtonClick (siehe Angabe im Screenshot) wird der Code zum Speichern aller Edit-Felder in der Variablen VAR generiert:
668
669 {{code language="None"}}
670 SetVarContent('VAR',
671 'EditDomain=' + EscapePropertyValue(EditDomain.Text) +
672 ',EditBeschreibung=' + EscapePropertyValue(EditBeschreibung.Text) +
673 ',EditIP=' + EscapePropertyValue(EditIP.Text) +
674 ',EditMAC=' + EscapePropertyValue(EditMAC.Text) +
675 ',EditOS=' + EscapePropertyValue(EditOS.Text) +
676 ',EditVersion=' + EscapePropertyValue(EditVersion.Text) +
677 ',EditSP=' + EscapePropertyValue(EditSP.Text));
678 {{/code}}
679
680 Die Variable VAR benötigt zum Laden der Informationen und Daten beim Start der Form ein bestimmtes Format. Ebenso werden die Informationen in einem bestimmten Format gespeichert. Dabei werden die Informationen und Daten mit der Syntax Element.Eigenschaft=Wert,[…] geladen bzw. gespeichert.
681
682 Im Client Command kann die Variablen VAR somit z.B. über String-Kommandos (siehe Kapitel Kategorie Strings) mit Informationen und Daten vor dem Start der Form belegt werden. Nach dem Beenden der Form lässt sich die Variable über die Angabe %Variable.Eigenschaft% einfach abfragen. Umso z.B. das Betriebssystem eines zuvor in der Form angezeigten Clients abzufragen, geben Sie einfach den String %VAR.EditOS% an.

Navigation

© Aagon GmbH 2024
Besuchen Sie unsere neue Aagon-Community