OpenKeyWord  Version: 426, Datum:
Öffentliche Methoden | Private Methoden | Private Attribute | Aufstellung aller Elemente
OKW.OK Klassenreferenz

Klasse OK representiert den Core Zustand OK. Mehr ...

Klassendiagramm für OKW.OK:
Inheritance graph
Zusammengehörigkeiten von OKW.OK:
Collaboration graph

Öffentliche Methoden

 OK (Core fp_OKW)
 Klasse representiert den Zustand "OK" des OKW-Kerns im Ausführungsmodus. Mehr ...
 
void BeginTest (string fpsTestname)
 Markiert den Anfang eines neuen Testfalls. Mehr ...
 
void ClickOn (string fpsFunctionalname)
 Klickt auf das gegebene Objekt. Mehr ...
 
void ClickOn (string fpsFunctionalname, string fpsClickType)
 Klickt auf das gegebene Objekt. Mehr ...
 
void EndTest ()
 Beendet den Test, bzw. den Testfall. Mehr ...
 
void LogCaption (string fpsFunctionalname)
 Keine Beschreibung zu "LogCaption" verfügbar. Mehr ...
 
void LogExists (string fpsFunctionalname)
 Protokolliert, ob das gegebene Objekt existiert. Mehr ...
 
void LogHasFocus (string fpsFunctionalname)
 Dokumentiert den Fokus-Status des gegebenen Objekts. Mehr ...
 
void LogIsActive (string fpsFunctionalname)
 Dokumentiert den Status des gegebenen Objekts. Mehr ...
 
void LogLabel (string fpsFunctionalname)
 Keine Beschreibung zu "LogLabel" verfügbar. Mehr ...
 
void LogSelected (string fpsFunctionalname)
 Dokumentiert den markierten Text des gegebenen Objekts. Mehr ...
 
void LogTablecellValue (string fpsFunctionalname, string fpsCol, string fpsRow)
 Dokumentiert den Wert der ausgewählten Zelle. Mehr ...
 
void LogTooltip (string fpsFunctionalname)
 Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts. Mehr ...
 
void LogValue (string fpsFunctionalname)
 Dokumentiert den Standartwert eines Objekts. Mehr ...
 
void MemorizeCaption (string fpsFunctionalname, string fps_MemKeyName)
 Keine Beschreibung zu "MemorizeCaption" verfügbar. Mehr ...
 
void MemorizeExists (string fpsFunctionalname, string fps_MemKeyName)
 Merkt sich den aktuell existierenden Zustand des Objekts. Mehr ...
 
void MemorizeHasFocus (string fpsFunctionalname, string fps_MemKeyName)
 Keine Beschreibung zu "MemorizeHasFocus" verfügbar. Mehr ...
 
void MemorizeIsActive (string fpsFunctionalname, string fps_MemKeyName)
 Merkt sich den Zustand des gegebenen Objekts. Mehr ...
 
void MemorizeLabel (string fpsFunctionalname, string fps_MemKeyName)
 Keine Beschreibung zu "MemorizeLabel" verfügbar. Mehr ...
 
void MemorizeSelectedValue (string fpsFunctionalname, string fps_MemKeyName)
 Keine Beschreibung zu "MemorizeSelectedValue" verfügbar. Mehr ...
 
void MemorizeTablecellValue (string fpsFunctionalname, string fpsCol, string fpsRow, string fps_MemKeyName)
 Merkt sich den Wert der gegebenen Zelle in der Tabelle. Mehr ...
 
void MemorizeTooltip (string fpsFunctionalname, string fps_MemKeyName)
 Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts. Mehr ...
 
void MemorizeValue (string fpsFunctionalname, string fps_MemKeyName)
 Keine Beschreibung zu "MemorizeLabel" verfügbar. Mehr ...
 
void Select (string fpsFunctionalname, string fpsValue)
 Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten. Mehr ...
 
void Select (string fpsFunctionalname, string fpsValue, string fpsClickType)
 Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten. Mehr ...
 
void SelectMenu (string fpsFunctionalname)
 Wählt den gegebenen Menüeintrag aus. Mehr ...
 
void SelectMenu (string fpsFunctionalname, string fpsValue)
 Wählt den gegebenen Menüeintrag aus. Mehr ...
 
void SelectTablecell (string fpsFunctionalname, string fpsCol, string fpsRow)
 Wählt die gegebene Tabellenzelle aus. Mehr ...
 
void SelectTablecell (string fpsFunctionalname, string fpsCol, string fpsRow, string fpsClickType)
 Wählt die gegebene Tabellenzelle aus. Mehr ...
 
void SelectWindow (string fpsFunctionalname)
 Setzt den Kontext auf das gegebene Fenster. Mehr ...
 
void Sequence (string fpsObjectName, string fpsSequenceName, string SEQ_ID)
 Ruft die Sequenz eines Fensters auf. Mehr ...
 
void SetFocus (string fpsFunctionalname)
 Setzt den Fokus auf das gegebene Fensterobjekt. Mehr ...
 
void SetLanguage (string Language)
 
void SetValue (string fpsFunctionalname, string fpsValue)
 Setzt den Wert des gegebenen Fensterobjekts auf den gegebenen Wert. Mehr ...
 
void StartApp (string fps_ApplikationName)
 Startet die gegebene Anwendung. Mehr ...
 
void StopApp (string fps_ApplikationName)
 Beendet eine gegebene Anwendung. Mehr ...
 
void TypeKey (string fpsFunctionalname, string fpsValue)
 Tastatureingaben von Daten in das aktive Fensterobjekt. Mehr ...
 
void TypeKeyTablecell (string fpsFunctionalname, string fpsCol, string fpsRow, string fpsValue)
 Eingabe von Daten in eine gegebene Tabellenzelle über die Tastatur. Mehr ...
 
void TypeKeyWindow (string fpsFunctionalname, string fpsValue)
 Tastatureingabe in ein bestimmtes Fensterobjekt. Mehr ...
 
void VerifyCaption (string fpsFunctionalname, string fpsExpectedValue)
 Keine Beschreibung zu "VerifyCaption" verfügbar. Mehr ...
 
void VerifyExists (string fpsFunctionalname, string fpsExpectedValue)
 Prüft, ob das gegebene Objekt existiert.
Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" existiert:
Mehr ...
 
void VerifyHasFocus (string fpsFunctionalname, string fpsExpectedValue)
 Vergleicht den Fokus-Zustand des gegebenen Objekts mit dem erwarteten Wert. Mehr ...
 
void VerifyIsActive (string fpsFunctionalname, string fpsExpectedValue)
 Vergleicht den Fokus-Status des gegebenen Objekts mit dem erwarteten Wert. Mehr ...
 
void VerifyLabel (string fpsFunctionalname, string fpsExpectedValue)
 Keine Beschreibung zu "VerifyLabel" verfügbar. Mehr ...
 
void VerifySelectedValue (string fpsFunctionalname, string fpsExpectedValue)
 Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert. Mehr ...
 
void VerifyTablecellValue (string fpsFunctionalname, string fpsCol, string fpsRow, string fpsExpectedValue)
 Vergleicht den Inhalt der gegebenen Tabellenzeile mit dem erwarteten Wert. Mehr ...
 
void VerifyTooltip (string fpsFunctionalname, string fpsExpectedValue)
 Keine Beschreibung zu "VerifyTooltip" verfügbar. Mehr ...
 
void VerifyValue (string fpsFunctionalname, string fpsExpectedValue)
 Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text). Mehr ...
 
void FileDelete (string fpsPathAndFileName)
 Löscht die gegebene Datei. Mehr ...
 
void VerifyFileExists (string fpsPathAndFileName, string fpsExpectedValue)
 Prüft, ob die gegebene Datei existiert. Mehr ...
 
void VerifyDirectoryExists (string fpsPath, string fpsExpectedValue)
 Prüft, ob das gegebene Verzeichnis existiert. Mehr ...
 

Private Methoden

void HandleException (Exception e)
 Zentrale Exception-Behandlung. Mehr ...
 

Private Attribute

OKWLanguage AL = OKWLanguage.Instance
 
LogMessenger LM = null
 
OKW_Docu MyOKWDocu = OKW_Docu.Instance
 
bool UNITTEST = true
 
Core _Kernel
 

Ausführliche Beschreibung

Klasse OK representiert den Core Zustand OK.

Testausführung mit GUI-Aktivität und es ist keine Exception ausgelöst worden.

Autor
Zoltán Hrabovszki
Datum
2013.03.02

Definiert in Zeile 60 der Datei OK.cs.

Beschreibung der Konstruktoren und Destruktoren

OKW.OK.OK ( Core  fp_OKW)

Klasse representiert den Zustand "OK" des OKW-Kerns im Ausführungsmodus.

Autor
Zoltán Hrabovszki
Datum
09.01.2014

Definiert in Zeile 84 der Datei OK.cs.

85  {
86  this._Kernel = fp_OKW;
87  this.LM = new LogMessenger(this.GetType().Name);
88  }

Dokumentation der Elementfunktionen

void OKW.OK.BeginTest ( string  fpsTestname)

Markiert den Anfang eines neuen Testfalls.

Beschreibung des Handlungsablaufes

Zu beachten
Alle Testfälle sollten mit BeginneTest afangen: Dieses Schlüsselwort initialisiert OKW und versetz diesen in einen initialen Zustand, d.h. als wäre OKW neu gestartet.
Parameter
fpsTestnameName oder Bezeichnung des Testfalls.
Autor
Zoltan Hrabovszki
Datum
2014-09-18/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 99 der Datei OK.cs.

100  {
101  Logger.Instance.LogFunctionStart("BeginTest",
102  "fpsTestname", fpsTestname);
103 
104  Logger.Instance.LogFunctionEnd();
105  }
void OKW.OK.ClickOn ( string  fpsFunctionalname)

Klickt auf das gegebene Objekt.

Beispiel: Klicke auf das Objekt mit Namen "MeinObjekt":

Klicke auf: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-18/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 112 der Datei OK.cs.

113  {
114  Logger.Instance.LogFunctionStart("ClickOn", "fpsFunctionalname", fpsFunctionalname);
115 
116  try {
117  CurrentObject.Instance.SetChildName(fpsFunctionalname);
118  CurrentObject.Instance.CallMethod("ClickOn");
119  } catch (Exception e) {
120  this.HandleException(e);
121  } finally {
122  Logger.Instance.LogFunctionEnd();
123  }
124  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.ClickOn ( string  fpsFunctionalname,
string  fpsClickType 
)

Klickt auf das gegebene Objekt.

Beispiel: Klicke auf das Objekt mit Namen "MeinObjekt":

Klicke auf: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsClickTypeDoppelklick" um mit Doppelklick auszuwählen, "Einfachklick" um mit einfachem Klick
Autor
Zoltan Hrabovszki
Datum
2014-09-18/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 131 der Datei OK.cs.

132  {
133  Logger.Instance.LogFunctionStart("ClickOn", "fpsFunctionalname", fpsFunctionalname, "fpsClickType", fpsClickType);
134 
135  try {
136  CurrentObject.Instance.SetChildName(fpsFunctionalname);
137  CurrentObject.Instance.CallMethod("ClickOn_Clicktype", fpsClickType);
138  } catch (Exception e) {
139  this.HandleException(e);
140  } finally {
141  Logger.Instance.LogFunctionEnd();
142  }
143  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.EndTest ( )

Beendet den Test, bzw. den Testfall.

Beschreibung der Arbeitsweise.

Zu beachten
Zusätzliche Bemerkungen zum Schlüsselwort
Autor
Zoltan Hrabovszki
Datum
2014-09-18/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 150 der Datei OK.cs.

151  {
152  Logger.Instance.LogFunctionStart("EndTest");
153 
154  Logger.Instance.LogFunctionEnd();
155  }
void OKW.OK.FileDelete ( string  fpsPathAndFileName)

Löscht die gegebene Datei.

Inder Pfadangabe sind

  • OKW-Parser angaben sind erlaubt ${umgebungsvariable}, ${merkewertschlüssel}.
  • im Dateinamen sind Wildcards * + ? erlaubt.
Zu beachten
Dieses Schlüsselwort stellt sicher, dass nach der Ausführung die angegebene Datei oder Dateien nicht (mehr) existiert/existieren. Falls die gegebene Datei nicht existiert, dann wird ohne Fehlermeldung und auslösen einer Ausnahme das Schlüsselwort beendet.
Beispiel
DE.LöscheDatei( "C:\temp\meineDatei.txt" ) - Löscht die Datei meineDatei.txt im Verzeichniss C: DE.LöscheDatei( "C:\temp\*.*" ) - Löscht alle Dateien im Verzeichniss C:
Siehe auch
Parameter
fpsPathAndFileNameVollständiger Pfad und Dateiname.
Autor
Zoltán Hrabovszki
Datum
2015.08.20

Implementiert OKW.IOKW_State.

Definiert in Zeile 1508 der Datei OK.cs.

1509  {
1510  string lvsPathAndFileName = string.Empty;
1511 
1512  Logger.Instance.LogFunctionStart("FileDelete", "fpsPathAndFileName", fpsPathAndFileName);
1513  try
1514  {
1515  // Prüfen ob ignoriert werden muss...
1516  if (fpsPathAndFileName == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsPathAndFileName == String.Empty)
1517  {
1518  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
1519  Logger.Instance.LogPrintDebug(this.LM.GetMessage("FileDelete", "Ignore"));
1520  }
1521  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1522  else
1523  {
1524  // 1. Parsen der Pfad-Eingabe
1525  lvsPathAndFileName = MyParser.ParseMe(fpsPathAndFileName);
1526  // 2. Konvertieren des Pfad separators.
1527  lvsPathAndFileName = OKW_FileHelper.ConvertDirectorySeperator(lvsPathAndFileName);
1528 
1529  string lsvLog = this.LM.GetMessage("FileDelete", "ResolvedPath", lvsPathAndFileName);
1530  Logger.Instance.LogPrint(lsvLog);
1531 
1532  // Basis-Funktion aufrufen...
1533  OKW_FileHelper.FilesDelete(lvsPathAndFileName);
1534  }
1535  }
1536  catch (Exception e)
1537  {
1538  HandleException(e);
1539  }
1540  finally
1541  {
1542  Logger.Instance.LogFunctionEnd();
1543  }
1544  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.HandleException ( Exception  e)
private

Zentrale Exception-Behandlung.

Methode führt folge Aktivitäten aus:

  1. Exception wird als Log ausgegeben.
  2. Daten des aktuellen Objektes werden für eine Fehler-Analyse ausgegeben (CurrentObject.Instance.LogObjectData()).
  3. Wechselt den Zustand auf NOK.
  4. Wenn OKW in NUNIT/UNIT aufgerufen wird (this.UNITTEST = true sein) dann wird an das Unittest-Framework die Exception weitergereicht.
Parameter
eException aus der OK-Schlüsselwort-Methode
Autor
Zoltán Hrabovszki
Datum
02.03.2013

Definiert in Zeile 1472 der Datei OK.cs.

1473  {
1474  Logger.Instance.LogPrint("==========================================================================");
1475  Logger.Instance.LogException(string.Format("{0}", e.Message));
1476  Logger.Instance.LogPrint("--------");
1477 
1478  // Das ist nicht schön aber Notwendig. LogObjektData ist
1479  if (!e.GetType().IsAssignableFrom(typeof(OKWFrameObjectParentNotFoundException))) {
1480  CurrentObject.Instance.LogObjectData();
1481  }
1482 
1483  Logger.Instance.LogPrint("--------");
1484  Logger.Instance.LogPrint(" Stack:");
1485  Logger.Instance.LogException(string.Format("{0}", e.StackTrace));
1486 
1487  Logger.Instance.LogPrint("-------");
1488  Logger.Instance.LogPrint(" Source:");
1489  Logger.Instance.LogException(string.Format("{0}", e.Source));
1490 
1491  Logger.Instance.LogPrint("-------");
1492  Logger.Instance.LogPrint(" TargetSite:");
1493  Logger.Instance.LogException(string.Format("{0}", e.TargetSite));
1494 
1495  Logger.Instance.LogPrint("==========================================================================");
1496 
1497  // Change State to NOK
1498  this._Kernel.SetCurrentState(new NOK(this._Kernel));
1499 
1500  if (this.UNITTEST) {
1501  throw e;
1502  }
1503  }
OKW.Core.SetCurrentState
void SetCurrentState(IOKW_State fp_CurrentState)
Setter zum Setzen des aktuellen Zustandes.
Definition: Core.cs:318

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void OKW.OK.LogCaption ( string  fpsFunctionalname)

Keine Beschreibung zu "LogCaption" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-18/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 162 der Datei OK.cs.

163  {
164  Logger.Instance.LogFunctionStart("LogCaption",
165  "fpsFunctionalname", fpsFunctionalname);
166 
167  try {
168  CurrentObject.Instance.SetChildName(fpsFunctionalname);
169  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogCaption");
170 
171  Logger.Instance.ResOpenList("Log... ");
172 
173  foreach (string Value in ActualValues) {
174  Logger.Instance.LogPrint(">>" + Value + "<<");
175  }
176 
177  Logger.Instance.ResCloseList();
178  } catch (Exception e) {
179  this.HandleException(e);
180  } finally {
181  Logger.Instance.LogFunctionEnd();
182  }
183  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogExists ( string  fpsFunctionalname)

Protokolliert, ob das gegebene Objekt existiert.

Beispiel: Protokolliert, ob das Objekt mit Namen "Mein Objekt" vorhanden ist:

logge vorhanden: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-18/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 190 der Datei OK.cs.

191  {
192  Logger.Instance.LogFunctionStart("LogExists",
193  "fpsFunctionalname", fpsFunctionalname);
194 
195  try {
196  CurrentObject.Instance.SetChildName(fpsFunctionalname);
197  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("LogExists");
198  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
199 
200  string lvsLM = this.LM.GetMessage("LogExists", "LogValue", lvsActual);
201 
202  Logger.Instance.LogPrint(lvsLM);
203  } catch (Exception e) {
204  this.HandleException(e);
205  } finally {
206  Logger.Instance.LogFunctionEnd();
207  }
208  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogHasFocus ( string  fpsFunctionalname)

Dokumentiert den Fokus-Status des gegebenen Objekts.

Beispiel: Protokolliert den Fokus-Zustand von "Mein Objekt":

Logge hat Fokus: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 215 der Datei OK.cs.

216  {
217  Logger.Instance.LogFunctionStart("LogHasFocus",
218  "fpsFunctionalname", fpsFunctionalname);
219 
220  try {
221  CurrentObject.Instance.SetChildName(fpsFunctionalname);
222  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("LogHasFocus");
223  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
224 
225  string lvsLM = this.LM.GetMessage("LogIsActive", "LogValue", lvsActual);
226 
227  Logger.Instance.LogPrint(lvsLM);
228  } catch (Exception e) {
229  this.HandleException(e);
230  } finally {
231  Logger.Instance.LogFunctionEnd();
232  }
233  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogIsActive ( string  fpsFunctionalname)

Dokumentiert den Status des gegebenen Objekts.

Beispiel: Protokolliert den Aktivzustand von "Mein Objekt":

LoggeIstAktiv: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 240 der Datei OK.cs.

241  {
242  Logger.Instance.LogFunctionStart("LogIsActive",
243  "fpsFunctionalname", fpsFunctionalname);
244 
245  try {
246  CurrentObject.Instance.SetChildName(fpsFunctionalname);
247  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("LogIsActive");
248 
249  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
250 
251  string lvsLM = this.LM.GetMessage("LogIsActive", "LogValue", lvsActual);
252 
253  Logger.Instance.LogPrint(lvsLM);
254  } catch (Exception e) {
255  this.HandleException(e);
256  } finally {
257  Logger.Instance.LogFunctionEnd();
258  }
259  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogLabel ( string  fpsFunctionalname)

Keine Beschreibung zu "LogLabel" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 266 der Datei OK.cs.

267  {
268  Logger.Instance.LogFunctionStart("LogLabel",
269  "fpsFunctionalname", fpsFunctionalname);
270 
271  try {
272  CurrentObject.Instance.SetChildName(fpsFunctionalname);
273  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogLabel");
274 
275  Logger.Instance.ResOpenList("Log... ");
276 
277  foreach (string Value in ActualValues) {
278  Logger.Instance.LogPrint(">>" + Value + "<<");
279  }
280 
281  Logger.Instance.ResCloseList();
282  } catch (Exception e) {
283  this.HandleException(e);
284  } finally {
285  Logger.Instance.LogFunctionEnd();
286  }
287  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogSelected ( string  fpsFunctionalname)

Dokumentiert den markierten Text des gegebenen Objekts.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 294 der Datei OK.cs.

295  {
296  Logger.Instance.LogFunctionStart(
297  "LogSelected",
298  "fpsFunctionalname",
299  fpsFunctionalname);
300 
301  try {
302  CurrentObject.Instance.SetChildName(fpsFunctionalname);
303  List<string> actualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogSelected");
304 
305  string lvsLM = this.LM.GetMessage("LogSelected", "LogValue");
306 
307  Logger.Instance.LogPrint(lvsLM);
308 
309  Logger.Instance.ResOpenList(lvsLM);
310 
311  foreach (string Value in actualValues) {
312  Logger.Instance.LogPrint("'" + Value + "'");
313  }
314 
315  Logger.Instance.ResCloseList();
316  } catch (Exception e) {
317  this.HandleException(e);
318  } finally {
319  Logger.Instance.LogFunctionEnd();
320  }
321  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogTablecellValue ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow 
)

Dokumentiert den Wert der ausgewählten Zelle.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsColSpaltennummer der zu wählenden Zelle, beginnend mit 1.
fpsRowZeilennummer der zu wählenden Zelle, beginnend mit 1.
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>Beschreibung überprüfen

Implementiert OKW.IOKW_State.

Definiert in Zeile 328 der Datei OK.cs.

329  {
330  Logger.Instance.LogFunctionStart(
331  "LogTablecellValue",
332  "fpsCol", fpsCol,
333  "fpsRow", fpsRow,
334  "fpsFunctionalname", fpsFunctionalname);
335 
336  try {
337  CurrentObject.Instance.SetChildName(fpsFunctionalname);
338  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogTablecellValue", fpsCol, fpsRow);
339 
340  Logger.Instance.ResOpenList("Log... ");
341 
342  foreach (string Value in ActualValues) {
343  Logger.Instance.LogPrint(">>" + Value + "<<");
344  }
345 
346  Logger.Instance.ResCloseList();
347  } catch (Exception e) {
348  this.HandleException(e);
349  } finally {
350  Logger.Instance.LogFunctionEnd();
351  }
352  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogTooltip ( string  fpsFunctionalname)

Dokumentiert die Kurzinfo zu einem Werkzeug des gegebenen Objekts.

Beispiel: Protokolliert den Kurzinformationstext (Tooltip) von "Mein Objekt":

LoggeTooltip: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 359 der Datei OK.cs.

360  {
361  Logger.Instance.LogFunctionStart("LogTooltip",
362  "fpsFunctionalname", fpsFunctionalname);
363 
364  try {
365  CurrentObject.Instance.SetChildName(fpsFunctionalname);
366  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogTooltip");
367 
368  Logger.Instance.ResOpenList("Log... ");
369 
370  foreach (string Value in ActualValues) {
371  Logger.Instance.LogPrint(">>" + Value + "<<");
372  }
373 
374  Logger.Instance.ResCloseList();
375  } catch (Exception e) {
376  this.HandleException(e);
377  } finally {
378  Logger.Instance.LogFunctionEnd();
379  }
380  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.LogValue ( string  fpsFunctionalname)

Dokumentiert den Standartwert eines Objekts.

Der Standardwert des Objektes (in den meisten Fällen ist dies der angezeigte Text) wird ausgelesen und in der aktuellen Dokumentationsdatei ausgegeben.
Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "Django" entspricht:

Prüfe Wert: "MeinObjekt", "Django"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 387 der Datei OK.cs.

388  {
389  Logger.Instance.LogFunctionStart("LogValue",
390  "fpsFunctionalname", fpsFunctionalname);
391 
392  try {
393  CurrentObject.Instance.SetChildName(fpsFunctionalname);
394  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("LogValue");
395 
396  Logger.Instance.ResOpenList("Log... ");
397 
398  foreach (string Value in ActualValues) {
399  Logger.Instance.LogPrint(">>" + Value + "<<");
400  }
401 
402  Logger.Instance.ResCloseList();
403  } catch (Exception e) {
404  this.HandleException(e);
405  } finally {
406  Logger.Instance.LogFunctionEnd();
407  }
408  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeCaption ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Keine Beschreibung zu "MemorizeCaption" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 415 der Datei OK.cs.

416  {
417  Logger.Instance.LogFunctionStart("MemorizeCaption",
418  "fpsFunctionalname", fpsFunctionalname,
419  "fps_MemKeyName", fps_MemKeyName);
420 
421  try {
422  CurrentObject.Instance.SetChildName(fpsFunctionalname);
423  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeCaption");
424 
425  string lvsToMemorize = OKW_Const.Instance.ConcatSEP(ActualValues);
426 
427  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
428  } catch (Exception e) {
429  this.HandleException(e);
430  } finally {
431  Logger.Instance.LogFunctionEnd();
432  }
433  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeExists ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Merkt sich den aktuell existierenden Zustand des Objekts.

Der Wert wird unter dem als Parameter übergebenen Schlüssel gespeichert.
Beispiel: Merkt sich den vorhandenen Zustand des Objektes "MeinObjekt" unter dem Schlüssel "Mein Schlüssel".:

Merke Existiert: "MeinObjekt", "Mein Schlüssel"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 440 der Datei OK.cs.

441  {
442  Logger.Instance.LogFunctionStart("MemorizeExists",
443  "fpsFunctionalname", fpsFunctionalname,
444  "fps_MemKeyName", fps_MemKeyName);
445 
446  try {
447  // Prüfen ob ignoriert werden muss...
448  if (fps_MemKeyName == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fps_MemKeyName == String.Empty) {
449  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
450  Logger.Instance.LogPrintDebug(this.LM.GetMessage("MemorizeExists", "Ignore"));
451  }
452  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
453  else
454  {
455  CurrentObject.Instance.SetChildName(fpsFunctionalname);
456  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("MemorizeExists");
457 
458  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
459 
460  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsActual);
461  }
462  } catch (Exception e) {
463  this.HandleException(e);
464  } finally {
465  Logger.Instance.LogFunctionEnd();
466  }
467  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeHasFocus ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Keine Beschreibung zu "MemorizeHasFocus" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 474 der Datei OK.cs.

475  {
476  Logger.Instance.LogFunctionStart("MemorizeHasFocus",
477  "fpsFunctionalname", fpsFunctionalname,
478  "fps_MemKeyName", fps_MemKeyName);
479 
480  try {
481  // Prüfen ob ignoriert werden muss...
482  if (fps_MemKeyName == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fps_MemKeyName == String.Empty) {
483  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
484  Logger.Instance.LogPrintDebug(this.LM.GetMessage("MemorizeHasFocus", "Ignore"));
485  }
486  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
487  else
488  {
489  CurrentObject.Instance.SetChildName(fpsFunctionalname);
490  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("MemorizeHasFocus");
491 
492  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
493 
494  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsActual);
495  }
496  } catch (Exception e) {
497  this.HandleException(e);
498  } finally {
499  Logger.Instance.LogFunctionEnd();
500  }
501  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeIsActive ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Merkt sich den Zustand des gegebenen Objekts.

Der Wert wird unter dem als Parameter übergebenen Schlüssel gespeichert.
Beispiel: Merkt den Zustand des Objektes "MeinObjekt" unter dem Schlüssel "Mein Schlüssel":

Merke Ist Aktiv: "MeinObjekt", "Mein Schlüssel"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 508 der Datei OK.cs.

509  {
510  Logger.Instance.LogFunctionStart("MemorizeIsActive",
511  "fpsFunctionalname", fpsFunctionalname,
512  "fps_MemKeyName", fps_MemKeyName);
513 
514  try {
515  CurrentObject.Instance.SetChildName(fpsFunctionalname);
516  bool lvbActual = CurrentObject.Instance.CallMethodReturn_Boolean("MemorizeIsActive");
517 
518  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
519 
520  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsActual);
521  } catch (Exception e) {
522  this.HandleException(e);
523  } finally {
524  Logger.Instance.LogFunctionEnd();
525  }
526  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeLabel ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Keine Beschreibung zu "MemorizeLabel" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 533 der Datei OK.cs.

534  {
535  Logger.Instance.LogFunctionStart("MemorizeLabel",
536  "fpsFunctionalname", fpsFunctionalname,
537  "fps_MemKeyName", fps_MemKeyName);
538 
539  try {
540  CurrentObject.Instance.SetChildName(fpsFunctionalname);
541  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeLabel");
542 
543  string lvsToMemorize = OKW_Const.Instance.ConcatSEP(ActualValues);
544 
545  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
546  } catch (Exception e) {
547  this.HandleException(e);
548  } finally {
549  Logger.Instance.LogFunctionEnd();
550  }
551  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeSelectedValue ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Keine Beschreibung zu "MemorizeSelectedValue" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 558 der Datei OK.cs.

559  {
560  Logger.Instance.LogFunctionStart("MemorizeSelectedValue",
561  "fpsFunctionalname", fpsFunctionalname,
562  "fps_MemKeyName", fps_MemKeyName);
563 
564  try {
565  CurrentObject.Instance.SetChildName(fpsFunctionalname);
566  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeSelectedValue");
567 
568  string lvsToMemorize = OKW_Const.Instance.ConcatSEP(ActualValues);
569 
570  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
571  } catch (Exception e) {
572  this.HandleException(e);
573  } finally {
574  Logger.Instance.LogFunctionEnd();
575  }
576  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeTablecellValue ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fps_MemKeyName 
)

Merkt sich den Wert der gegebenen Zelle in der Tabelle.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
fpsColSpaltennummer der zu wählenden Zelle, beginnend mit 1.
fpsRowZeilennummer der zu wählenden Zelle, beginnend mit 1.
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 583 der Datei OK.cs.

584  {
585  Logger.Instance.LogFunctionStart("MemorizeTablecellValue",
586  "fpsFunctionalname", fpsFunctionalname,
587  "fpsCol", fpsCol,
588  "fpsRow", fpsRow,
589  "fps_MemKeyName", fps_MemKeyName);
590 
591  try {
592  CurrentObject.Instance.SetChildName(fpsFunctionalname);
593  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeTablecellValue", fpsCol, fpsRow);
594 
595  string lvsToMemorize = OKW_Const.Instance.ConcatSEP(ActualValues);
596 
597  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
598  } catch (Exception e) {
599  this.HandleException(e);
600  } finally {
601  Logger.Instance.LogFunctionEnd();
602  }
603  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeTooltip ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Dokumentiert den Tooltip-Text (Kurzinformation) des gegebenen Objekts.

Beispiel Dokumentiert den Tooltip-Text des Objektes "MeinObjekt":

Logge Tooltip: "MeinObjekt"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 610 der Datei OK.cs.

611  {
612  Logger.Instance.LogFunctionStart("MemorizeTooltip",
613  "fpsFunctionalname", fpsFunctionalname,
614  "fps_MemKeyName", fps_MemKeyName);
615 
616  try {
617  CurrentObject.Instance.SetChildName(fpsFunctionalname);
618  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeTooltip");
619 
620  string lvsToMemorize = OKW_Const.Instance.ConcatSEP(ActualValues);
621 
622  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
623  } catch (Exception e) {
624  this.HandleException(e);
625  } finally {
626  Logger.Instance.LogFunctionEnd();
627  }
628  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.MemorizeValue ( string  fpsFunctionalname,
string  fps_MemKeyName 
)

Keine Beschreibung zu "MemorizeLabel" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsMemKeyNameName des Schlüssels
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 635 der Datei OK.cs.

636  {
637  Logger.Instance.LogFunctionStart("MemorizeValue",
638  "fpsFunctionalname", fpsFunctionalname,
639  "fpsMemKeyName", fps_MemKeyName);
640 
641  try {
642  CurrentObject.Instance.SetChildName(fpsFunctionalname);
643  List<string> ActualValues = CurrentObject.Instance.CallMethodReturn_ListString("MemorizeValue");
644 
645  string lvsToMemorize = OKW_Const.Instance.ConcatSEP(ActualValues);
646 
647  OKW_Memorize.Instance.Set(fps_MemKeyName, lvsToMemorize);
648  } catch (Exception e) {
649  this.HandleException(e);
650  } finally {
651  Logger.Instance.LogFunctionEnd();
652  }
653  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.Select ( string  fpsFunctionalname,
string  fpsValue 
)

Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten.

Tabellenspalten werden zeilenweise zusammengefasst, so dass Listen und Tabellen identisch verarbeitet werden. Die erste Zeile, welche die gegebenen Daten enthält, wird ausgewählt. Die Zeile wird über einen einfachen Klick angewählt. Die Übergabe des zusätzlichen Parameters "Doppelklick" führt zur Verwendung eines Doppelklicks. Die {HSEP}-Konstante kann verwendet werden, wenn definierte Werte in mehreren Spalten gefordert sind.
Beispiel 1: Wähle alle Zeilen aus, die den Text "Wert" enthalten:

Wähle aus: "MeineTabelle", "Wert"


Beispiel 2: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren zweite Spalte den Text "Wert2" enthält:

Wähle aus: "MeineTabelle", "Wert1{HSEP}, Wert2"


Beispiel 3: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren dritte Spalte den Text "Wert2" enthält:

Wähle aus: "MeineTabelle", "Wert1{HSEP}{HSEP}Wert2"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-19

Implementiert OKW.IOKW_State.

Definiert in Zeile 660 der Datei OK.cs.

661  {
662  Logger.Instance.LogFunctionStart("Select",
663  "fpsFunctionalname", fpsFunctionalname,
664  "fpsValue", fpsValue);
665  try {
666  // Prüfen ob ignoriert werden muss...
667  if (fpsValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
668  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
669  // \todo TODO: Meldung sprachabhägig auslagern!
670  Logger.Instance.LogPrintDebug("Ignore...");
671  } else {
672  // Sonst Methode des Objektes aufrufen....
673  List<string> lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
674 
675  lvlsValue = MyParser.ParseMe(lvlsValue);
676 
677  CurrentObject.Instance.SetChildName(fpsFunctionalname);
678  CurrentObject.Instance.CallMethod("Select", lvlsValue);
679  }
680  } catch (Exception e) {
681  this.HandleException(e);
682  } finally {
683  Logger.Instance.LogFunctionEnd();
684  }
685 
686  return;
687  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.Select ( string  fpsFunctionalname,
string  fpsValue,
string  fpsClickType 
)

Auswahl aller Zeilen einer Liste/Tabelle, welche die gegebenen Daten enthalten.

Tabellenspalten werden zeilenweise zusammengefasst, so dass Listen und Tabellen identisch verarbeitet werden. Die erste Zeile, welche die gegebenen Daten enthält, wird ausgewählt. Die Zeile wird über einen einfachen Klick angewählt. Die Übergabe des zusätzlichen Parameters "Doppelklick" führt zur Verwendung eines Doppelklicks. Die {HSEP}-Konstante kann verwendet werden, wenn definierte Werte in mehreren Spalten gefordert sind.
Beispiel 1: Wähle alle Zeilen aus, die den Text "Wert" enthalten:

Wähle aus: "MeineTabelle", "Wert"


Beispiel 2: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren zweite Spalte den Text "Wert2" enthält:

Wähle aus: "MeineTabelle", "Wert1{HSEP}, Wert2"


Beispiel 3: Wähle alle Zeilen aus, die mit dem Text "Wert1" beginnen und deren dritte Spalte den Text "Wert2" enthält:

Wähle aus: "MeineTabelle", "Wert1{HSEP}{HSEP}Wert2"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
fpsClickTypeDoppelklick" um mit Doppelklick, "Einfachklick" um mit einfachem Klick auszuwählen.
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 694 der Datei OK.cs.

695  {
696  Logger.Instance.LogFunctionStart("Select",
697  "fpsFunctionalname", fpsFunctionalname,
698  "fpsValue", fpsValue,
699  "fpsClickType", fpsClickType);
700  try {
701  // Prüfen ob ignoriert werden muss...
702  if (fpsValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
703  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
704  // \todo TODO: Meldung sprachabhägig auslagern!
705  Logger.Instance.LogPrintDebug("Ignore...");
706  } else {
707  List<string> lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
708 
709  lvlsValue = MyParser.ParseMe(lvlsValue);
710 
711  CurrentObject.Instance.SetChildName(fpsFunctionalname);
712 
713  // TODO: Select - Sprachabhängigkeit von KlickType einbauen...
714  CurrentObject.Instance.CallMethod("Select_Clicktype", lvlsValue, fpsClickType);
715  }
716  } catch (Exception e) {
717  this.HandleException(e);
718  } finally {
719  Logger.Instance.LogFunctionEnd();
720  }
721  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SelectMenu ( string  fpsFunctionalname)

Wählt den gegebenen Menüeintrag aus.

Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":

Wähle Aus Menü: "MeinMenü"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 728 der Datei OK.cs.

729  {
730  Logger.Instance.LogFunctionStart("SelectMenu",
731  "fpsFunctionalname", fpsFunctionalname);
732 
733  try {
734  CurrentObject.Instance.SetChildName(fpsFunctionalname);
735  CurrentObject.Instance.CallMethod("SelectMenu");
736  } catch (Exception e) {
737  this.HandleException(e);
738  } finally {
739  Logger.Instance.LogFunctionEnd();
740  }
741  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SelectMenu ( string  fpsFunctionalname,
string  fpsValue 
)

Wählt den gegebenen Menüeintrag aus.

Beispiel: Wähle Menüeintrag mit Namen "MeinMenü":

Wähle Aus Menü: "MeinMenü"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 748 der Datei OK.cs.

749  {
750  Logger.Instance.LogFunctionStart("SelectMenu",
751  "fpsFunctionalname", fpsFunctionalname,
752  "fpsValue", fpsValue);
753 
754  List<string> lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
755 
756  try {
757  CurrentObject.Instance.SetChildName(fpsFunctionalname);
758  CurrentObject.Instance.CallMethod("SelectMenu_Value", lvlsValue);
759  } catch (Exception e) {
760  this.HandleException(e);
761  } finally {
762  Logger.Instance.LogFunctionEnd();
763  }
764  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SelectTablecell ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow 
)

Wählt die gegebene Tabellenzelle aus.

Die Parameter für die Spalten- und Zeilenpositionen werden immer als Strings eingegeben. Wenn ein Positionsparameter mit einem Hash (#) beginnt, dann wird er als Zahl interpretiert, z.B. "#1". Wenn das Hashzeichen als Text interpretiert werden soll, dann muss dies über einen vorangestellten Backslash gekennzeichnet werden, z.B. "#1 Text mit vorangestellter Nummer".

Die Kopfzeile der Tabelle wird über den Index "0" angesprochen. Die erste Datenzeile beginnt mit dem Index 1. Für Tabellen mit mehrzeiligen Kopfzeilen kann im Objekt selbst der Offset zur ersten Datenzeile festgelegt werden. Der Spaltenindex beginnt mit der Nummer 1.
Beispiel 1: Auswahl der Zelle in Spalte 2 und Zeile 5: 

Wähle aus Tabellenzelle: "MeineTabelle", "#2", "#5"

Beispiel 2: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester": 

Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "Tester"

Beispiel 3: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile 3:

Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "#3"

Beispiel 4: Auswahl der Zelle in Spalte 1 und erster Zeile mit Text "42":

Wähle aus Tabellenzelle: "MeineTabelle", "#1", "42"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsColSpaltennummer der zu wählenden Zelle, beginnend mit 1.
fpsRowZeilennummer der zu wählenden Zelle, beginnend mit 1.
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 771 der Datei OK.cs.

772  {
773  Logger.Instance.LogFunctionStart("SelectTablecell",
774  "fpsFunctionalname", fpsFunctionalname,
775  "fpsCol", fpsCol,
776  "fpsRow", fpsRow);
777 
779 
780  try {
781  CurrentObject.Instance.SetChildName(fpsFunctionalname);
782  CurrentObject.Instance.CallMethod("SelectTablecell", fpsCol, fpsRow);
783  } catch (Exception e) {
784  this.HandleException(e);
785  } finally {
786  Logger.Instance.LogFunctionEnd();
787  }
788  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SelectTablecell ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fpsClickType 
)

Wählt die gegebene Tabellenzelle aus.

Die Parameter für die Spalten- und Zeilenpositionen werden immer als Strings eingegeben. Wenn ein Positionsparameter mit einem Hash (#) beginnt, dann wird er als Zahl interpretiert, z.B. "#1". Wenn das Hashzeichen als Text interpretiert werden soll, dann muss dies über einen vorangestellten Backslash gekennzeichnet werden, z.B. "#1 Text mit vorangestellter Nummer". Die Kopfzeile der Tabelle wird über den Index "0" angesprochen. Die erste Datenzeile beginnt mit dem Index 1. Für Tabellen mit mehrzeiligen Kopfzeilen kann im Objekt selbst der Offset zur ersten Datenzeile festgelegt werden. Der Spaltenindex beginnt mit der Nummer 1.
Beispiel 1: Auswahl der Zelle in Spalte 2 und Zeile 5: 

Wähle aus Tabellenzelle: "MeineTabelle", "#2", "#5"

Beispiel 2: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester": 

Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "Tester"

Beispiel 3: Auswahl der Zelle in erster Spalte mit Text "Toni" und Zeile 3:

Wähle aus Tabellenzelle: "MeineTabelle", "Toni", "#3"

Beispiel 4: Auswahl der Zelle in Spalte 1 und erster Zeile mit Text "42":

Wähle aus Tabellenzelle: "MeineTabelle", "#1", "42"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsClickTypeDoppelklick" um mit Doppelklick auszuwählen, "Einfachklick" um mit einfachem Klick
fpsRowZeilennummer der zu wählenden Zelle, beginnend mit 1.
fpsColSpaltennummer der zu wählenden Zelle, beginnend mit 1.
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 795 der Datei OK.cs.

796  {
797  Logger.Instance.LogFunctionStart(
798  "SelectTablecell",
799  "fpsFunctionalname",
800  fpsFunctionalname,
801  "fpsCol",
802  fpsCol,
803  "fpsRow",
804  fpsRow,
805  "fpsClickType",
806  fpsClickType);
807 
808  try {
809  CurrentObject.Instance.SetChildName(fpsFunctionalname);
810  CurrentObject.Instance.CallMethod("SelectTablecell_Clicktype", fpsCol, fpsRow, fpsClickType);
811  } catch (Exception e) {
812  this.HandleException(e);
813  } finally {
814  Logger.Instance.LogFunctionEnd();
815  }
816  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SelectWindow ( string  fpsFunctionalname)

Setzt den Kontext auf das gegebene Fenster.

Das Fenster wird aktiviert und in den Vordergrund geholt. Alle nachfolgen GUI-Schlüssleworte (z.B. Gib ein) beziehen sich auf das gegeben Fenster. Der Kontext wechselt erst mit dem nächsten Wähle aus Fenster auf ein anderes Fenster.

Noch zu erledigen:
zh: jnic die englische Beschreibung für Selectwindow anpassen.

Beispiel: Auswahl des Fensters mit dem Namen "MeinFenster": 

Wähle aus Fenster: "MeinFenster"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-19/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 823 der Datei OK.cs.

824  {
825  Logger.Instance.LogFunctionStart("SelectWindow",
826  "fpsFunctionalname", fpsFunctionalname);
827 
828  try {
829  CurrentObject.Instance.SetWindowName(fpsFunctionalname);
830  CurrentObject.Instance.CallMethod("SelectWindow");
831  } finally {
832  Logger.Instance.LogFunctionEnd();
833  }
834 
835  return;
836  }
void OKW.OK.Sequence ( string  fpsObjectName,
string  fpsSequenceName,
string  SEQ_ID 
)

Ruft die Sequenz eines Fensters auf.

Sequenzen sind je Fenster definiert und haben innerhalb des Fenster einen eindeutigen Sequenznamen. Einzugebende Datensätze werden mit der Sequenz-ID referenziert.

Beispiel: Aufrufen der Sequenz _Anmelden des Fensters Login mit dem Datensatz Administrator:_ 

Sequenz: "Login", "Anmelden" = "Administrator"
Parameter
fpsFunctionalnameFunktionaler Name des Fensterobjekts, in der die Sequenz definiert ist.
fpsSequenceNameName der Sequenz, die aufgerufen werden soll.
SEQ_IDSequenz ID des Datensatzes, die als Eingabe verwendet werden soll.
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic
Noch zu erledigen:
jnic–>Beschreibung erledigt 2014-10-26

Implementiert OKW.IOKW_State.

Definiert in Zeile 843 der Datei OK.cs.

844  {
845  Logger.Instance.LogFunctionStart("Sequence",
846  "fpsObjectName", fpsObjectName,
847  "fpsSequenceName", fpsSequenceName,
848  "SEQ_ID", SEQ_ID);
849 
850  try {
851  // Prüfen ob ignoriert werden muss...
852  if (SEQ_ID == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || SEQ_ID == String.Empty) {
853  // Wenn der 1. Wert = IGNORE ist -> Abbrechen...
854  // \todo TODO: Meldung sprachabhägig auslagern!
855  Logger.Instance.LogPrintDebug("Ignore...");
856  } else {
857  CurrentObject.Instance.SetWindowName(fpsObjectName);
858  CurrentObject.Instance.CallMethod(fpsSequenceName, SEQ_ID);
859  }
860  } catch (Exception e) {
861  this.HandleException(e);
862  } finally {
863  Logger.Instance.LogFunctionEnd();
864  }
865  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SetFocus ( string  fpsFunctionalname)

Setzt den Fokus auf das gegebene Fensterobjekt.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 872 der Datei OK.cs.

873  {
874  Logger.Instance.LogFunctionStart("SetFocus",
875  "fpsFunctionalname", fpsFunctionalname);
876 
877  try {
878  CurrentObject.Instance.SetChildName(fpsFunctionalname);
879  CurrentObject.Instance.CallMethod("SetFocus");
880  } catch (Exception e) {
881  this.HandleException(e);
882  } finally {
883  Logger.Instance.LogFunctionEnd();
884  }
885  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.SetLanguage ( string  Language)
Autor
Zoltán Hrabovszki
Datum
02.03.2013

Implementiert OKW.IOKW_State.

Definiert in Zeile 892 der Datei OK.cs.

893  {
894  this.AL.Language = Language;
895  }
OKW.OKWLanguage.Language
string Language
Gets or sets a string property.
Definition: OKWLanguage.cs:77
void OKW.OK.SetValue ( string  fpsFunctionalname,
string  fpsValue 
)

Setzt den Wert des gegebenen Fensterobjekts auf den gegebenen Wert.

Der Wert wird nicht durch die Simulation einzelner Tastatureingaben eingegeben, sondern direkt ins Objekte geschrieben:
Sollte z.B. in einem TextFeld bereits ein Wert vorhanden sein, dann wird dieser mit fpsValue überschrieben.

Beispiel: Setze den Wert des Objekts "MeinObjekt" auf "Hallo": 

Setze Wert: "MeinObjekt", "Hallo"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic
Noch zu erledigen:
–>jnic - Beschreibung bearbeitet 2014-10-26

Implementiert OKW.IOKW_State.

Definiert in Zeile 902 der Datei OK.cs.

903  {
904  Logger.Instance.LogFunctionStart("SetValue",
905  "fpsFunctionalname", fpsFunctionalname);
906 
907  List<string> lvlsValue;
908 
909  try {
910  // Prüfen ob ignoriert werden muss...
911  if (fpsValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
912  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
913  Logger.Instance.LogPrint(this.LM.GetMessage("SetValue", "Ignore"));
914  } else {
915  lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
916 
917  lvlsValue = MyParser.ParseMe(lvlsValue);
918 
919  CurrentObject.Instance.SetChildName(fpsFunctionalname);
920  CurrentObject.Instance.CallMethod("SetValue", lvlsValue);
921  }
922  } catch (Exception e) {
923  this.HandleException(e);
924  } finally {
925  Logger.Instance.LogFunctionEnd();
926  }
927  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.StartApp ( string  fps_ApplikationName)

Startet die gegebene Anwendung.

Beispiel: Befehl zum Starten der Anwendung "InternetExplorer": 

Starte Anwendung: "InternetExplorer"
Bemerkungen
Die Methode "StartApp()" muss in der Klasse "fpsApplikatioName" implementiert werden. Der fachliche Bezeichner muss nicht zwangsläufing mit dem Namen der Exe-Datei übereinstimmen: Hier findet ein Mapping/Zuordnung zwischen fachlichen Bezeichner und der aufzurufenden "*.exe" statt.
Ein Beispiel, wie eine Ausimplementierung aussehen kann, ist in SeInternetExplorerApp.StartApp zu finden.
Parameter
fpsApplicationNameDer fachliche Name der Anwendung.
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic
Noch zu erledigen:
jnic–>Beschreibung angepasst 2014-10-26

Implementiert OKW.IOKW_State.

Definiert in Zeile 934 der Datei OK.cs.

935  {
936  Logger.Instance.LogFunctionStart("StartApp",
937  "fps_ApplikationName", fps_ApplikationName);
938 
939  try {
940  CurrentObject.Instance.SetWindowName(fps_ApplikationName);
941  CurrentObject.Instance.CallMethod("StartApp");
942  } catch (Exception e) {
943  this.HandleException(e);
944  } finally {
945  Logger.Instance.LogFunctionEnd();
946  }
947  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.StopApp ( string  fps_ApplikationName)

Beendet eine gegebene Anwendung.

Beispiel: Befehl zum Starten der Anwendung "InternetExplorer": 

Beende Anwendung: "InternetExplorer"
Bemerkungen
Die Methode "StopApp()" muss in der Klasse "fpsApplikatioName" implementiert werden. Das Framework kann nicht wissen, wie eine spezielle Anwendung beendet werden muss. Das muss projektspezifisch ausimplementiert werden.
Ein Beispiel, wie eine Ausimplementierung aussehen kann, ist in SeInternetExplorerApp.StopApp zu finden.
Parameter
fpsApplicationNameDerf achliche Name der Anwendung
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic todo jnic–>Beschreibung angepasst 2014-10-26

Implementiert OKW.IOKW_State.

Definiert in Zeile 954 der Datei OK.cs.

955  {
956  Logger.Instance.LogFunctionStart("StopApp",
957  "fps_ApplikationName", fps_ApplikationName);
958 
959  try {
960  CurrentObject.Instance.SetWindowName(fps_ApplikationName);
961  CurrentObject.Instance.CallMethod("StopApp");
962  } catch (Exception e) {
963  this.HandleException(e);
964  } finally {
965  Logger.Instance.LogFunctionEnd();
966  }
967  }
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.TypeKey ( string  fpsFunctionalname,
string  fpsValue 
)

Tastatureingaben von Daten in das aktive Fensterobjekt.

Die Daten werden als Tastureingaben an das Kindobjekt des aktiven Fenters gesendet. Dies ermöglicht die Verwendung von Hotkeys und Funktionstasten als Eingabedaten. Wenn mit Hilfe des Wertseparators {SEP} mehrere Werte im Parameter übergeben werden, dann werden alle Werte als Tastatureingabe an das Fensterobjekt gesendet, getrennt durch einen Zeilenumbruch.

Beispiel "Einfache Eingabe":

Gib ein: "MeinFensterObjekt", "EingabeWert"

Beispiel "Eingabe einer Konstanten":

Gib ein: "MeinFensterObjekt", "{F2}"

Beispiel "Eingabe mehrerer Werte":

Gib ein: "MeinFensterObjekt", "Eingabewert1{SEP}Eingabewert2"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 974 der Datei OK.cs.

975  {
976  Logger.Instance.LogFunctionStart("TypeKey",
977  "fpsFunctionalname", fpsFunctionalname,
978  "fpsValue", fpsValue);
979 
980  List<string> lvlsValue;
981 
982  try {
983  // Prüfen ob ignoriert werden muss...
984  if (fpsValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
985  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
986  Logger.Instance.LogPrint(this.LM.GetMessage("TypeKey", "Ignore"));
987  } else {
988  lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
989 
990  lvlsValue = MyParser.ParseMe(lvlsValue);
991 
992  CurrentObject.Instance.SetChildName(fpsFunctionalname);
993  CurrentObject.Instance.CallMethod("TypeKey", lvlsValue);
994  }
995  } catch (Exception e) {
996  this.HandleException(e);
997  } finally {
998  Logger.Instance.LogFunctionEnd();
999  }
1000  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.TypeKeyTablecell ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fpsValue 
)

Eingabe von Daten in eine gegebene Tabellenzelle über die Tastatur.

Die Daten werden als Tastureingaben an die gegebene Zelle einer Tabelle gesendet. Dies ermöglicht die Verwendung von Hotkeys (Schnellzugang)und Funktionstasten als Eingabedaten. Die Parameter für die Spalten- und Zeilenpositionen werden immer als Strings eingegeben. Wenn ein Positionsparameter mit einem Hash (#) beginnt, dann wird er als Zahl interpretiert, z.B. "#1". Wenn das Hashzeichen als Text interpretiert werden soll, dann muss dies über einen vorangestellten Backslash gekennzeichnet werden, z.B. "#1 Text mit vorangestellter Nummer". Die Kopfzeile der Tabelle wird über den Index "0" angesprochen. Die erste Datenzeile beginnt mit dem Index 1. Für Tabellen mit mehrzeiligen Kopfzeilen kann im Objekt selbst der Offset zur ersten Datenzeile festgelegt werden. Der Spaltenindex beginnt mit der Nummer 1.
Beispiel 1: Einfache Eingabe in Zelle an Spalte 2 und Zeile 5: 

Gib ein Tabellenzelle: "MeineTabelle", 2, 5, "Eingabewert"

Beispiel 2: Einfache Eingabe in Zelle an erster Spalte mit Text "Toni" und Zeile mit dem Namen "Tester": 

Gib ein Tabellenzelle: "MeineTabelle", "Toni", "Tester", "Eingabewert"

Beispiel 3: Einfache Eingabe in Zelle an erster Spalte mit Text "Toni" und Zeile 3: 

Gib ein Tabellenzelle: "MeineTabelle": "MeineTabelle", "Toni", 3, "Eingabewert"

Beispiel 4: Einfache Eingabe in Zelle an Spalte 1 und Zeile mit Namen "Adresse": 

Gib ein Tabellenzelle: "MeineTabelle", 1, "Adresse", "Eingabewert"

Beispiel 5: Eingabe der Konstanten "F2" in Zelle an Spalte 1 und Zeile 1: 

Gib ein Tabellenzelle: "MeineTabelle", 1, 1, "{F2}"

Beispiel 6: Eingabe mehrerer Werte in Zelle an erster Spalte mit Test "Ernie" und Zeile 3: 

Gib ein Tabellenzelle: "MeineTabelle", "Ernie", 3, "Wer1{SEP}Wert2"

Beispiel 7: Eingabe des Wertes "HiHo" in Zelle an Spalte 1 und erster Zeile mit Text "42": 

Gib ein Tabellenzelle: "MeineTabelle", "#1", "42", "HiHo"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
fpsRowZeilennummer der zu wählenden Zelle, beginnend mit 1.
fpsColSpaltennummer der zu wählenden Zelle, beginnend mit 1.
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1007 der Datei OK.cs.

1008  {
1009  Logger.Instance.LogFunctionStart("TypeKeyTablecell",
1010  "fpsFunctionalname", fpsFunctionalname,
1011  "fpsColl", fpsCol,
1012  "fpsRow", fpsRow,
1013  "fpsValue", fpsValue);
1014 
1015  List<string> lvlsValue;
1016 
1017  try {
1018  // Prüfen ob ignoriert werden muss...
1019  if (fpsValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
1020  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1021  Logger.Instance.LogPrint(this.LM.GetMessage("TypeKeyTablecell", "Ignore"));
1022  } else {
1023  // Werte in fpsValue separieren
1024  lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
1025 
1026  lvlsValue = MyParser.ParseMe(lvlsValue);
1027 
1028  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1029  CurrentObject.Instance.CallMethod("TypeKeyTablecell", fpsCol, fpsRow, lvlsValue);
1030  }
1031  } catch (Exception e) {
1032  this.HandleException(e);
1033  } finally {
1034  Logger.Instance.LogFunctionEnd();
1035  }
1036  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.TypeKeyWindow ( string  fpsFunctionalname,
string  fpsValue 
)

Tastatureingabe in ein bestimmtes Fensterobjekt.

Die Daten werden als Tastureingaben an das Fensterobjekt gesendet. Dies ermöglicht die Verwendung von Hotkeys (Schnellzugang) und Funktionstasten als Eingabedaten. Mehrere Werte können mit Hilfe der Konstanten {SEP} eingegeben werden (siehe Beispiele). Die Werte werden dann bei der Eingabe durch Zeilenumbrüche getrennt.
Beispiel 1: Einfache Eingabe: 

Gib ein Fenster: "MeinFensterObjekt", "EingabeWert"

Beispiel 2: Eingabe einer Konstanten: 

Gib ein Fenster: "MeinFensterObjekt", "{F2}"

_Beispiel 3: Eingabe mehrerer Werte:_Beispiel 

Gib ein Fenster: "MeinFensterObjekt", "Eingabewert1{SEP}Eingabewert2"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsValueSich ergebender Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1043 der Datei OK.cs.

1044  {
1045  Logger.Instance.LogFunctionStart("TypeKeyWindow",
1046  "fpsFunctionalname", fpsFunctionalname,
1047  "fpsValue", fpsValue);
1048 
1049  try {
1050  // Prüfen ob ignoriert werden muss...
1051  if (fpsValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsValue == String.Empty) {
1052  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1053  Logger.Instance.LogPrint(this.LM.GetMessage("TypeKeyWindow", "Ignore"));
1054  } else {
1055  List<string> lvlsValue = OKW_Const.Instance.SplitSEP(fpsValue);
1056  lvlsValue = MyParser.ParseMe(lvlsValue);
1057 
1058  CurrentObject.Instance.SetWindowName(fpsFunctionalname);
1059  CurrentObject.Instance.CallMethod("TypeKey", lvlsValue);
1060  }
1061  } catch (Exception e) {
1062  this.HandleException(e);
1063  } finally {
1064  Logger.Instance.LogFunctionEnd();
1065  }
1066  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyCaption ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Keine Beschreibung zu "VerifyCaption" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic
Noch zu erledigen:
jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 1073 der Datei OK.cs.

1074  {
1075  Logger.Instance.LogFunctionStart("VerifyCaption",
1076  "fpsFunctionalname", fpsFunctionalname,
1077  "fpsExpectedValue", fpsExpectedValue);
1078 
1079  try {
1080  // Prüfen ob ignoriert werden muss...
1081  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1082  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1083  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyCaption", "Ignore"));
1084  } else {
1085  // Split giveneExpected Value
1086  List<string> lvlsExpected = OKW_Const.Instance.SplitSEP(fpsExpectedValue);
1087 
1088  // Get the actuel value from object
1089  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1090  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyCaption", lvlsExpected);
1091 
1092  // Verify:
1093  // 1. are the length of the lists equal?
1094  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyCaption", "VerifyListCount"));
1095  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1096 
1097  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyCaption", "VerifyValues"));
1098 
1099  for (int i = 0; i < Actual.Count; i++) {
1100  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1101  }
1102  }
1103  } catch (Exception e) {
1104  this.HandleException(e);
1105  } finally {
1106  Logger.Instance.LogFunctionEnd();
1107  }
1108  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyDirectoryExists ( string  fpsPath,
string  fpsExpectedValue 
)

Prüft, ob das gegebene Verzeichnis existiert.

Parameter
fpsPathAPfad des Verzeichnisses, die Geprüft werden soll
fpsExpectedValueErwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}"
Autor
Zoltan Hrabovszki
Datum
2015-06-26

Implementiert OKW.IOKW_State.

Definiert in Zeile 1600 der Datei OK.cs.

1601  {
1602  string lvsPath = string.Empty;
1603 
1604  Logger.Instance.LogFunctionStart("VerifyDirectoryExists",
1605  "fpsPath", fpsPath,
1606  "fpsExpectedValue", fpsExpectedValue);
1607  try
1608  {
1609  // Prüfen ob ignoriert werden muss...
1610  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty)
1611  {
1612  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
1613  Logger.Instance.LogPrintDebug(this.LM.GetMessage("VerifyDirectoryExists", "Ignore"));
1614  }
1615  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1616  else if (fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("NO"))
1617  {
1618  // Aktuellen Wert holen...
1619 
1620  // 1. Parsen der Pfad-Eingabe
1621  lvsPath = MyParser.ParseMe(fpsPath);
1622  // 2. Konvertieren des Pfad separators.
1623  lvsPath = OKW_FileHelper.ConvertDirectorySeperator(lvsPath);
1624 
1625  string lsvLog = this.LM.GetMessage("VerifyDirectoryExists", "ResolvedPath", lvsPath);
1626  Logger.Instance.LogPrint(lsvLog);
1627 
1628  // Basis-Funkton aufrufen...
1629  bool lvbActual = OKW_FileHelper.DirectoryExist(lvsPath);
1630 
1631  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
1632  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
1633 
1634  // Soll/Ist Vergleich...
1635  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyDirectoryExists", "VerifyValue"));
1636  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1637  }
1638  // Beide Bedingungen sind nicht erfüllt -> Exception da kein anderer Wert hier erlaubt ist.
1639  else
1640  {
1641  string ExceptionLog = LM.GetMessage("VerifyDirectoryExists", "OKWNotAllowedValueException", fpsExpectedValue);
1642  throw new OKWNotAllowedValueException(ExceptionLog);
1643  }
1644  }
1645  catch (Exception e)
1646  {
1647  this.HandleException(e);
1648  }
1649  finally
1650  {
1651  Logger.Instance.LogFunctionEnd();
1652  }
1653  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyExists ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Prüft, ob das gegebene Objekt existiert.
Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" existiert: 

Prüfe Existiert: "MeinObjekt", "JA"

_Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" nicht existiert: 

Prüfe Existiert: "MeinObjekt", "NEIN"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1115 der Datei OK.cs.

1116  {
1117  Logger.Instance.LogFunctionStart("VerifyExists",
1118  "fpsFunctionalname", fpsFunctionalname,
1119  "fpsExpectedValue", fpsExpectedValue);
1120 
1121  try {
1122  //Hier sind nur drei werte erlaubt: YES/NO/IGNORE
1123 
1124  // Prüfen ob ignoriert werden muss...
1125  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1126  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1127  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyExists", "Ignore"));
1128  }
1129  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1130  else if (fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("NO")) {
1131  // Sprachabhängiges YES/NO nach bool transformieren
1132  bool lvsbExpectedValue = OKW_Const.Instance.YesNo2Boolean(fpsExpectedValue);
1133 
1134  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1135  bool lvbActual = CurrentObject.Instance.CallMethodReturn_BooleanPb("VerifyExists", lvsbExpectedValue);
1136 
1137  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
1138 
1139  // Soll/Ist Vergleich...
1140  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyExists", "VerifyValue"));
1141 
1142  // LANGUAGE: Prüfen: Sprachabhängigen string-vergleich durchführen...
1143  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1144  }
1145  // Beide Bedingungen sind nicht erfüllt -> Exception da keinanderer Wert hier erlaubt ist.
1146  else {
1147  string ExceptionLog = this.LM.GetMessage("VerifyExists", "OKWNotAllowedValueException", fpsExpectedValue);
1148  throw new OKWNotAllowedValueException(ExceptionLog);
1149  }
1150  } catch (Exception e) {
1151  this.HandleException(e);
1152  } finally {
1153  Logger.Instance.LogFunctionEnd();
1154  }
1155  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyFileExists ( string  fpsPathAndFileName,
string  fpsExpectedValue 
)

Prüft, ob die gegebene Datei existiert.

Parameter
fpsPathAndFileNamePfad und Name der Datei, die Geprüft werden soll
fpsExpectedValueErwarteter Wert. Möglich Werte sind: "JA"/"NEIN"/"${IGNORIERE}"

/exception OKWFileDoesNotExistsException Wenn die gegeben Datei ein Verzeichniss ist, also eben keine Datei, dann wird ein OKWFileDoesNotExistsException ausgelöst.

Autor
Zoltan Hrabovszki
Datum
2015-06-26

Implementiert OKW.IOKW_State.

Definiert in Zeile 1547 der Datei OK.cs.

1548  {
1549  string lvsPathAndFileName = string.Empty;
1550 
1551  Logger.Instance.LogFunctionStart("VerifyFileExist",
1552  "fpsPathAndFileName", fpsPathAndFileName,
1553  "fpsExpectedValue", fpsExpectedValue);
1554  try
1555  {
1556  // Prüfen ob ignoriert werden muss...
1557  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1558  // Wenn der 1. Wert = IGNORE ist -> keine Weitere Aktion...
1559  Logger.Instance.LogPrintDebug(this.LM.GetMessage("VerifyFileExists", "Ignore"));
1560  }
1561  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1562  else if (fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("NO"))
1563  {
1564  // Aktuellen Wert holen...
1565 
1566  // 1. Parsen der Pfad-Eingabe
1567  lvsPathAndFileName = MyParser.ParseMe(fpsPathAndFileName);
1568  // 2. Konvertieren des Pfad separators.
1569  lvsPathAndFileName = OKW_FileHelper.ConvertDirectorySeperator(lvsPathAndFileName);
1570 
1571  string lsvLog = this.LM.GetMessage("VerifyFileExists", "ResolvedPath", lvsPathAndFileName);
1572  Logger.Instance.LogPrint( lsvLog );
1573 
1574  // Basis-Funkton aufrufen...
1575  bool lvbActual = OKW_FileHelper.FileExist(lvsPathAndFileName);
1576 
1577  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
1578  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
1579 
1580  // Soll/Ist Vergleich...
1581  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyIsActive", "VerifyValue"));
1582  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1583  }
1584  // Beide Bedingungen sind nicht erfüllt -> Exception da kein anderer Wert hier erlaubt ist.
1585  else
1586  {
1587  string ExceptionLog = LM.GetMessage("VerifyFileExists", "OKWNotAllowedValueException", fpsExpectedValue);
1588  throw new OKWNotAllowedValueException(ExceptionLog);
1589  }
1590  }
1591  catch (Exception e) {
1592  this.HandleException(e);
1593  }
1594  finally {
1595  Logger.Instance.LogFunctionEnd();
1596  }
1597  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyHasFocus ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Vergleicht den Fokus-Zustand des gegebenen Objekts mit dem erwarteten Wert.

Beispiel 1: Prüfe, ob das Objekt "MeinObjekt" den Fokus besitzt: 

Prüfe Hat Fokus: "MeinObjekt", "JA"

Beispiel 2: Prüfe, ob das Objekt "MeinObjekt" den Fokus NICHT besitzt: 

Prüfe Hat Fokus: "MeinObjekt", "NEIN"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert. Erlaubte Werte sind: "JA", "NEIN" und "IGNORIEREN".
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1162 der Datei OK.cs.

1163  {
1164  Logger.Instance.LogFunctionStart("VerifyHasFocus",
1165  "fpsFunctionalname", fpsFunctionalname,
1166  "fpsExpectedValue", fpsExpectedValue);
1167 
1168  try {
1169  // Prüfen ob ignoriert werden muss...
1170  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1171  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1172  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyHasFocus", "Ignore"));
1173  }
1174  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1175  else if (fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("NO")) {
1176  // Sprachabhängiges YES/NO nach bool transformieren
1177  bool lvsbExpectedValue = OKW_Const.Instance.YesNo2Boolean(fpsExpectedValue);
1178 
1179  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1180  bool lvbActual = CurrentObject.Instance.CallMethodReturn_BooleanPb("VerifyHasFocus", lvsbExpectedValue);
1181 
1182  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
1183 
1184  // Soll/Ist Vergleich...
1185  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyHasFocus", "VerifyValue"));
1186  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1187 
1188  // \todo LANGUAGE: Püfen aws dieser eintrag soll: Sprachabhängigen string-vergleich durchführen...
1189  }
1190  // Beide Bedingungen sind nicht erfüllt -> Exception da keinanderer Wert hier erlaubt ist.
1191  else {
1192  string ExceptionLog = this.LM.GetMessage("VerifyExists", "OKWNotAllowedValueException", fpsExpectedValue);
1193  throw new OKWNotAllowedValueException(ExceptionLog);
1194  }
1195  } catch (Exception e) {
1196  this.HandleException(e);
1197  } finally {
1198  Logger.Instance.LogFunctionEnd();
1199  }
1200  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyIsActive ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Vergleicht den Fokus-Status des gegebenen Objekts mit dem erwarteten Wert.

Beispiel: Prüfe, ob das Objekt "MeinObjekt" sich im Status "aktiv" befindet: 

Prüfe Ist Aktiv: "MeinObjekt", "JA"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert. Erlaubte Werte sind: "JA", "NEIN" und "IGNORIEREN".
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1207 der Datei OK.cs.

1208  {
1209  Logger.Instance.LogFunctionStart("VerifyIsActive",
1210  "fpsFunctionalname", fpsFunctionalname,
1211  "fpsExpectedValue", fpsExpectedValue);
1212  try {
1213  // Prüfen ob ignoriert werden muss...
1214  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1215  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1216  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyIsActive", "Ignore"));
1217  }
1218  // Püfen ob YES/NO als Sollwert vorgegeben worden ist.
1219  else if (fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("YES") || fpsExpectedValue == OKW_Const.Instance.GetConst4Internalname("NO")) {
1220  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1221 
1222  // Erwarteten Wert(YES/NO, Sprachabhänging) nach bool wandelen
1223  bool lvbExpectedValue = OKW_Const.Instance.YesNo2Boolean(fpsExpectedValue);
1224 
1225  // Aktuellen Wert holen...
1226  bool lvbActual = CurrentObject.Instance.CallMethodReturn_BooleanPb("VerifyIsActive", lvbExpectedValue);
1227 
1228  // Aktuellen Wert nach YES/NO, Sprachabhänging, wandel...
1229  string lvsActual = OKW_Const.Instance.Boolean2YesNo(lvbActual);
1230 
1231  // Soll/Ist Vergleich...
1232  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyIsActive", "VerifyValue"));
1233  Logger.Instance.LogVerify(lvsActual, fpsExpectedValue);
1234  }
1235  // Beide Bedingungen sind nicht erfüllt -> Exception da kein anderer Wert hier erlaubt ist.
1236  else {
1237  string ExceptionLog = this.LM.GetMessage("VerifyExists", "OKWNotAllowedValueException", fpsExpectedValue);
1238  throw new OKWNotAllowedValueException(ExceptionLog);
1239  }
1240  } catch (Exception e) {
1241  this.HandleException(e);
1242  } finally {
1243  Logger.Instance.LogFunctionEnd();
1244  }
1245  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyLabel ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Keine Beschreibung zu "VerifyLabel" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert. Erlaubte Werte sind: "JA", "NEIN" und "IGNORIEREN".
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic
Noch zu erledigen:
TODO: jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 1252 der Datei OK.cs.

1253  {
1254  Logger.Instance.LogFunctionStart("VerifyLabel",
1255  "fpsFunctionalname", fpsFunctionalname,
1256  "fpsExpected", fpsExpectedValue);
1257 
1258  try {
1259  // Prüfen ob ignoriert werden muss...
1260  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1261  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1262  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyLabel", "Ignore"));
1263  } else {
1264  // Split giveneExpected Value
1265  List<string> lvlsExpected = OKW_Const.Instance.SplitSEP(fpsExpectedValue);
1266 
1267  // Get the actuel value from object
1268  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1269  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyLabel", lvlsExpected);
1270 
1271  // Verify:
1272  // 1. are the List length equal?
1273  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyLabel", "VerifyListCount"));
1274  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1275 
1276  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyLabel", "VerifyValues"));
1277 
1278  for (int i = 0; i < Actual.Count; i++) {
1279  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1280  }
1281  }
1282  } catch (Exception e) {
1283  this.HandleException(e);
1284  } finally {
1285  Logger.Instance.LogFunctionEnd();
1286  }
1287  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifySelectedValue ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Vergleicht den ausgewählten Wert des gegebenen Listenobjekts mit dem erwarteten Wert.

Eine Liste ist eine einfache Liste, eine Tabelle oder eine Baumansicht. Bei erwarteten Werten in Baumansichten (Treeview) wird immer die gesamte Hierarchie angegeben (siehe Beispiel). Dabei werden die Hierarchie-Elemente über den Separator {SEP} getrennt.
Beispiel 1: Prüfe, ob das Element "Henry" in der Liste "MeineListe" ausgewählt ist: 

Prüfe Ausgewählter Wert: "MeineListe", "Henry"

Beispiel 2: Prüfe, ob das Element "Namen{SEP}Henry" in der Baumansicht "MeinTreeview" ausgewählt ist: 

Prüfe Ausgewählter Wert: "MeinTreeview", "Namen{SEP}Henry"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1294 der Datei OK.cs.

1295  {
1296  Logger.Instance.LogFunctionStart("VerifySelectedValue",
1297  "fpsFunctionalname", fpsFunctionalname,
1298  "fpsExpected", fpsExpectedValue);
1299 
1300  try {
1301  // Prüfen ob ignoriert werden muss...
1302  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1303  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1304  Logger.Instance.LogPrint(this.LM.GetMessage("VerifySelectedValue", "Ignore"));
1305  } else {
1306  // Split giveneExpected Value
1307  List<string> lvlsExpected = OKW_Const.Instance.SplitSEP(fpsExpectedValue);
1308 
1309  // Get the actuel value from object
1310  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1311  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifySelectedValue", lvlsExpected);
1312 
1313  // Verify:
1314  // 1. are the List length equal?
1315  Logger.Instance.LogPrint(this.LM.GetMessage("VerifySelectedValue", "VerifyListCount"));
1316  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1317 
1318  Logger.Instance.LogPrint(this.LM.GetMessage("VerifySelectedValue", "VerifyValues"));
1319 
1320  for (int i = 0; i < Actual.Count; i++) {
1321  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1322  }
1323  }
1324  } catch (Exception e) {
1325  this.HandleException(e);
1326  } finally {
1327  Logger.Instance.LogFunctionEnd();
1328  }
1329  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyTablecellValue ( string  fpsFunctionalname,
string  fpsCol,
string  fpsRow,
string  fpsExpectedValue 
)

Vergleicht den Inhalt der gegebenen Tabellenzeile mit dem erwarteten Wert.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert
fpsRowZeilennummer der zu wählenden Zelle, beginnend mit 1.
fpsColSpaltennummer der zu wählenden Zelle, beginnend mit 1.
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1336 der Datei OK.cs.

1337  {
1338  Logger.Instance.LogFunctionStart("VerifyTablecellValue",
1339  "fpsFunctionalname", fpsFunctionalname,
1340  "fpsCol", fpsCol,
1341  "fpsRow", fpsRow,
1342  "fpsExpected", fpsExpectedValue);
1343 
1344  try {
1345  // Prüfen ob ignoriert werden muss...
1346  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1347  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1348  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTablecellValue", "Ignore"));
1349  } else {
1350  // Split giveneExpected Value
1351  List<string> lvlsExpected = OKW_Const.Instance.SplitSEP(fpsExpectedValue);
1352 
1353  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1354  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyTablecellValue", fpsCol, fpsRow, lvlsExpected);
1355 
1356  // Verify:
1357  // 1. are the List length equal?
1358  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTablecellValue", "VerifyListCount"));
1359  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1360 
1361  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTablecellValue", "VerifyValues"));
1362 
1363  for (int i = 0; i < Actual.Count; i++) {
1364  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1365  }
1366  }
1367  } catch (Exception e) {
1368  this.HandleException(e);
1369  } finally {
1370  Logger.Instance.LogFunctionEnd();
1371  }
1372  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyTooltip ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Keine Beschreibung zu "VerifyTooltip" verfügbar.

Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/jnic
Noch zu erledigen:
TODO: jnic–>keine Beschreibung vorhanden

Implementiert OKW.IOKW_State.

Definiert in Zeile 1379 der Datei OK.cs.

1380  {
1381  Logger.Instance.LogFunctionStart("VerifyTooltip",
1382  "fpsFunctionalname", fpsFunctionalname,
1383  "fpsExpected", fpsExpectedValue);
1384 
1385  try {
1386  // Prüfen ob ignoriert werden muss...
1387  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1388  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1389  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTooltip", "Ignore"));
1390  } else {
1391  // Split giveneExpected Value
1392  List<string> lvlsExpected = OKW_Const.Instance.SplitSEP(fpsExpectedValue);
1393 
1394  // Get the actuel value from object
1395  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1396  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyTooltip", lvlsExpected);
1397 
1398  // Verify:
1399  // 1. are the List length equal?
1400  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTooltip", "VerifyListCount"));
1401  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1402 
1403  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyTooltip", "VerifyValues"));
1404 
1405  for (int i = 0; i < Actual.Count; i++) {
1406  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1407  }
1408  }
1409  } catch (Exception e) {
1410  this.HandleException(e);
1411  } finally {
1412  Logger.Instance.LogFunctionEnd();
1413  }
1414  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void OKW.OK.VerifyValue ( string  fpsFunctionalname,
string  fpsExpectedValue 
)

Prüft den Standardwert eines Objektes (in den meisten Fällen ist dies der angezeigte Text).

Beispiel: Prüfe, ob der Wert (Text) des Objekts "MeinObjekt" dem erwarteten Wert "Django" entspricht: 

Prüfe Wert: "MeinObjekt", "Django"
Parameter
fpsFunctionalnameFunktionaler Name des Objekts
fpsExpectedValueErwarteter Wert
Autor
Zoltan Hrabovszki
Datum
2014-09-21/ jnic

Implementiert OKW.IOKW_State.

Definiert in Zeile 1421 der Datei OK.cs.

1422  {
1423  Logger.Instance.LogFunctionStart("VerifyValue",
1424  "fpsFunctionalname", fpsFunctionalname,
1425  "fpsExpected", fpsExpectedValue);
1426 
1427  try {
1428  // Prüfen ob ignoriert werden muss...
1429  if (fpsExpectedValue == OKW_Const.Instance.GetOKWConst4Internalname("IGNORE") || fpsExpectedValue == String.Empty) {
1430  // Wenn der 1. Wert = IGNORE ist -> keine weitere Aktion...
1431  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyValue", "Ignore"));
1432  } else {
1433  // Split giveneExpected Value
1434  List<string> lvlsExpected = OKW_Const.Instance.SplitSEP(fpsExpectedValue);
1435 
1436  CurrentObject.Instance.SetChildName(fpsFunctionalname);
1437  List<string> Actual = CurrentObject.Instance.CallMethodReturn_ListString("VerifyValue", lvlsExpected);
1438 
1439  // Verify:
1440  // 1. are the List length equal?
1441  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyValue", "VerifyListCount"));
1442  Logger.Instance.LogVerify(Actual.Count.ToString(), lvlsExpected.Count.ToString());
1443 
1444  Logger.Instance.LogPrint(this.LM.GetMessage("VerifyValue", "VerifyValues"));
1445 
1446  for (int i = 0; i < Actual.Count; i++) {
1447  Logger.Instance.LogVerify(Actual[i], lvlsExpected[i]);
1448  }
1449  }
1450  } catch (Exception e) {
1451  this.HandleException(e);
1452  } finally {
1453  Logger.Instance.LogFunctionEnd();
1454  }
1455  }
OKW.LogMessenger.GetMessage
string GetMessage(string MethodName, string TextKey)
Holt die Log-Meldung für MethodeNmae/Textkey ohne weitere Parameter.
Definition: LogMessenger.cs:151
OKW.OK.HandleException
void HandleException(Exception e)
Zentrale Exception-Behandlung.
Definition: OK.cs:1472

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei: