JSBS_XML_Tasks – Basisklasse für das Verarbeiten der XML-Struktur mit der Liste der Task-Frames

Inhaltsverzeichnis

Code 
Erklärungen und Anwendungsbeispiele 
Verwandte Dokumentation 

Code

package js_base.xml;

import java.util.*;

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;

import org.jdom.*;
import js_base.frame.JSBS_StartFrame;
import js_base.structures.JSBS_UniversalParameters;
/**
 *
 * @author kurt[at]javascout(dot)biz
 * @date 2006-08-24
 *
 * @description
 *  de:
 *  Klasse mit speziellen Methoden zum Verarbeiten einer Task-List.
 *  Eine Task-List ist eine XML-Struktur mit den Auswählbaren Codes
 *  und den Beschreibungen für die Geschäftsfall-Anwendungen eines
 *  Anwendungsprogramms.
 *  Diese Klasse erbt JSBS_XML_Base und verwendet deren Methoden um
 *  die Datei mit der XML-Struktur zu lesen.
 *  en:
 *  Class with specialized methods to process a Task-List.
 *  A Task-List is a XML-structure containing selectable codes and
 *  descriptions for the (Sub-) Tasks of an application.
 *  This class inherits JSBS_XML_Base and uses its methods to read a file
 *  containing a XML-structure.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class JSBS_XML_Tasks extends JSBS_XML_Base {
/*
 * de:
 * Globale Variablen die von mehr als einer Methode verwendet werden.
 * en:
 * Global variables which are accessed by more than one method. */
/* 
 * de:
 * Indikator, dass der <DisplayedCode> (aus der XML-Struktur) und der eingebenen Code
 * (aus dem Feld der GUI) in Grossbuchstaben umgewandelt werden soll bevor er wieder
 * angezeigt oder für Vergleiche verwendet wird.
 * en:
 * Indicator, that <DisplayedCode> (from the XML-structure) and entered Code (at the GUI)
 * should be converted to upper-case before they are displayed or compared. */
    boolean bolUpperCase = false;
/* 
 * de:
 * Liste mit den Tasks, Anzahl der Elemente in der Liste und Index um eine Elements
 * aus der Liste adressieren zu können.
 * en:
 * List with the tasks, number of list-elements and index to access an element
 * within the list. */
    List listTasks;
    int intListTasksSize;
    int intListTasksIndex = 0;
/*
 * -------------------------------
 * CONSTRUCTOR der Klasse / CONSTRUCTOR of the class. */
    public JSBS_XML_Tasks(JSBS_StartFrame parmCC) {
/*
 * de: Ausführen des Codes im Constructor der geerbten Klasse.
 * en: Perform the code in the constructor of the inherited class. */
        super(parmCC);
/* 
 * de:
 * Erstellen des Dateinamens für die XML-Struktur mit dem sprach-abhängigen
 * Informationen zu den Geschäftsfall-Anwendungen (Tasks).
 * Das geschieht durch Zusammensetzen des Verzeichnisses mit den sprach-abhängigen
 * Dateien und des Dateinamens für die Datei mit der XML-Struktur.
 * en:
 * Get the filename for the XML-structure with the language dependant Task-information.
 * This is done by concatenating the directory with the language dependant files
 * and the filename for the file with the XML-structure. */
        String locstrFileName =
            parmCC.structJSBS_UniversalParameters.strTextElementsDirectoryName +
            JSBS_UniversalParameters.CONST_TASKLIST_FILE_NAME;
/* 
 * de:
 * Lesen des Root-Elements. Die Methode ist in der Superklasse - das ist die geerbte Klasse -
 * implementiert.
 * en:
 * Read the Root-Element. The method is implemented in the superclass - i.e. the class inherited. */
        readXMLFile(locstrFileName);
/*
 * de:
 * Verarbeitung abbrechen wenn der Status-Code etwas anderes als OK signalisiert.
 * en:
 * Break processing if StatusCode signals other than OK */
        if (StatusCode != CONST_OK) return;
/*
 * de:
 * Prüfen ob das <UpperCase> Element in der XML-Struktur vorhanden ist.
 * en:
 * Check if the <UpperCase> element is present in the XML-structure. */
      Element locElementUpperCase = XML_RootElement.getChild("UpperCase");
        bolUpperCase = (locElementUpperCase != null);
/* 
 * de:
 * Prüfen ob mindestens ein Element für einen Task in der XML-Struktur vorhanden ist.
 * en:
 * Check if there is at least one Element for a Task in the XML-structure. */
      Element locElementTask = XML_RootElement.getChild("Task");
      if (locElementTask == null) {
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
      }
    }
/*
 * ************************************************** */
/*
 *
 * de:
 * METHODE zum füllen eines GUI-Elements vom Typ JTree mit der Task-Struktur.
 * en:
 * METHOD to fill a GUI-element of type JTree with the Task-structure. */
    public JTree getTaskTree() {
/* 
 * de: Oberstes Element des JTree.
 * en: Root-Node of the JTree. */
      DefaultMutableTreeNode BaseLayer = new DefaultMutableTreeNode();
/* 
 * de:
 * Prüfen ob mindestens ein Element für einen Task in der XML-Struktur vorhanden ist.
 * en:
 * Check if there is at least one Element for a Task in the XML-structure. */
      Element ElementTask = XML_RootElement.getChild("Task");
      if (ElementTask == null) {
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
        return new JTree();
      }
/* 
 * de:
 * Liste mit allen Task-Elementen aus der XML-Struktur herausholen und
 * die Subroutine den Aufbau des JTree ausführen lassen.
 * en:
 * Get the list with all Task-elements out of the XML-structure
 * and let the subroutine do the building of the JTree. */
      listTasks = XML_RootElement.getChildren("Task");
      intListTasksSize = listTasks.size();
      do {
          BaseLayer.add(buildSubTree());
          intListTasksIndex++;
      } while(intListTasksIndex < intListTasksSize);
/* 
 * de:
 * Einen JTree, der auf dem DefaultMutableTreeNode basiert und die
 * komplette Task-Hierarchie enthält, aufbauen.
 * en:
 * Make a JTree based on the DefaultMutableTreeNode which contains
 * the complete Task-Hierarchy now. */
      return new JTree(BaseLayer);
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODE zum aufbauen eines Task-Baumes.
 * Regel für das Zuordnen einer untergeordneten Ebene zu einem 'parent' ist:
 * Alle Elemente die mit dem/den gleichen Buchstaben beginnen und in der
 * XML-Struktur unmittelbar hinter dem 'parent' sind:
 * z.B. wenn in der XML-Liste die Einträge P, PM, PL, PLA, PLB, PI sind,
 * dann sind PM, PL und PI eine Ebene unterhalb von P – sie sind untergeordnete
 * untergeordnete Teilprogramme von P.
 * PLA und PLB sind eine Ebenen unterhalb von PL – sie sind untergeordnete
 * untergeordnete Teilprogramme von PL.
 * Das Erstellen einer solchen Baum-Struktur im GUI-Element JTree erlaubt
 * Anwendern den auswählbaren Code anzuzeigen oder zu verbergen.
 * en:
 * METHOD to build a Task-Tree.
 * Rule for attaching lower levels to a 'parent' is:
 * All elements that start with the same letter(s) as the 'parent' and follow
 * to the 'parent' in the XML-structure:
 * e.g. if the XML-list is P, PM, PL, PLA, PLB, PI
 * then PM, PL and PI are one level below P – they are subtasks of P.
 * PLA and PLB are on level below PL – they are subtasks of PL.
 * Creating such a tree-structure in the GUI-element JTree allows users
 * to show or hide all selectable code belonging to a lower level. */
    private DefaultMutableTreeNode buildSubTree() {
/*
 * ----- Variable / Variables ----- */
/* de:
 * Am Ende dieser Methode enthält dieser 'Baum' die untergeordneten Strukturen
 * (alle Ebenen darunter).
 * en:
 * At the end of the method this 'tree' contains the sub-structure (all levels down). */
      DefaultMutableTreeNode structTaskTree;
/* de: XML-Element mit allen Informationen (Elementen) für einen Task (Teilprogramm).
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de:
 * XML-Element mit dem angezeigten Code (<DisplayedCode>); das ist jener Code den ein
 * Anwender auswählen kann und dessen Buchstaben über die Gruppierung entscheiden.
 * en:
 * XML-element with the <DisplayedCode>; that is the one the user can choose
 * and that letters decide about grouping. */
      Element elementDisplayedCode;
/* de:
 * Text des angezeigten Codes (<DisplayedCode>) auf den der globale Index gezeigt hat als
 * diese Methode aufgerufen wurde. Verwendet für den Vergleich ob nachfolgende <DisplayedCode>s
 * für untergeordnete Teilprogramme sind.
 * en:
 * Text of the <DisplayedCode> the global index was pointing when this method was entered.
 * Used to compare if following <DisplayedCode>s are for SubTasks. */
      String strDisplayedCodeWhenMethodEntered = "";
/* de:
 * Text des untersuchten <DisplayedCode>; das ist jener auf den der globale Index aktuell zeigt.
 * en:
 * Text of inspected <DisplayedCode>; i.e. where the global index is actually pointing. */
      String strDisplayedCodeAtNextIndex = "";
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Oberstes Element der Baum-Struktur die innerhalb dieser Methode gebildet wird, erstellen.
 * Der angezeigte Text wird durch das Unterprogramm 'buildTaskText()' erstellt.
 * en:
 * Create the top-element of the tree-structure created within this method.
 * The displayed text is build by the subroutine 'buildTaskText()'. */
      structTaskTree = new DefaultMutableTreeNode(buildTaskText());
/* 
 * de:
 * Text des <DisplayedCode> aufheben um ihn später mit jenem der folgenden XML-Elemente
 * in den folgenden untergeordneten Tasks vergleichen zu können.
 * en:
 * Keep the text of <DisplayedCode> to compare later if following XML-elements in the
 * list are SubTasks. */
      elementTask = (Element) (listTasks.get(intListTasksIndex));
      elementDisplayedCode = elementTask.getChild("DisplayedCode");
      strDisplayedCodeWhenMethodEntered = elementDisplayedCode.getTextTrim();
/* 
 * de: Nächste(s) XML-Element(e) in der Liste untersuchen ob sie untergeordnete Tasks sind.
 * en: Inspect the next XML-Element(s) in the list if they are Sub-Tasks. */
      while (intListTasksIndex < intListTasksSize - 1) {
        elementTask = (Element) (listTasks.get(intListTasksIndex + 1));
        elementDisplayedCode = elementTask.getChild("DisplayedCode");
        strDisplayedCodeAtNextIndex = elementDisplayedCode.getTextTrim();
/* 
 * de:
 * Untersuchen, ob der <DisplayedCode> des nächsten XML-Elements in der Liste mit dem
 * gleichen Buchstaben beginnt als der <DisplayedCode>, der gespeichert wurde als diese
 * Methode begonnen wurde.
 * en:
 * See if the <DisplayedCode> of the next XML-element in the list starts with the
 * same letter as the <DisplayedCode> that was stored when this method was entered. */
        if (strDisplayedCodeAtNextIndex.indexOf(strDisplayedCodeWhenMethodEntered) == 0) {
/* 
 * de:
 * Beginnt mit dem/den gleichen Buchstaben; also muss es ein untergeordneter Task sein.
 * Diese Methode wieder als Subroutine aufrufen; das führt eine Untersuchung, ob weitere
 * untergeordnete Tasks existieren, aus und erstellt in diesem Fall die untergeordnete
 * Baum-Struktur erstellen.
 * Dann die komplette, von der Subroutine erstellte, Baumstruktur in jene Baum-Struktur,
 * die von dieser Methode erstellt wird, einfügen.
 * en:
 * Starts with the same letter(s); so must be a SubTask.
 * Call this method as a subroutine (this does an inspection if there are Sub-SubTask
 * and builds the tree-structure if there are).
 * Then add the complete tree-structure build by the subroutine to the tree-structure
 * that is build in this method. */
          intListTasksIndex++;
          structTaskTree.add(buildSubTree());
        }
        else {
/* 
 * de:
 * <DisplayedCode> des nächsten XML-Elements in der Liste started nicht mit dem/den gleichen
 * Buchstaben: Erstellen dieser untergeordneten Baum-Struktur ist abgeschlossen.
 * en:
 * <DisplayedCode> in the next XML-element of the list does not start with the same letter(s):
 * Building of this Sub-Tree-structure is completed. */
          return structTaskTree;
        }
      }
/* 
 * de:
 * Wenn keine weiteren XML-Elemente mehr in der Liste vorhanden sind:
 * Die Baum-STruktur, die in dieser Methode erstellt wurde, an die aufrufende Methode zurück liefern.
 * en:
 * If there are no more XML-elements in the list: Return the tree-structure build in this method. */
      return structTaskTree;
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODE zum Erstellen der Zeichenkette mit dem angezeigten Text.
 * Die erstellte Zeichenkette ist eine Abfolge von:
 * Wert von <DisplayedCode>, " - " (Bindestrich als konstanter Wert) und Wert von <Description>.
 * en:
 * METHOD to build a string with the text to be displayed.
 * The built String is a concatenation of the following:
 * value of <DisplayedCode>, " - " (Dash as a constant value) and value of <Description>. */
    private String buildTaskText() {
/*
 * ----- Variable / Variables ----- */
/* de: XML-Element mit der gesamten Information (alle Elemente) eines Tasks.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de:
 * Mehrfach verwendeten XML-Element zum Auslesen verschidenenr untergeordneter Elemente
 * eines Task-Elements.
 * en:
 * Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/* de: Text von <DisplayedCode>.
 * en: Text of the <DisplayedCode>. */
      String strDisplayedCode;
/* de: Text mit der (längeren) Beschreibung des Tasks; Wert von <Description>.
 * en: Text with the (longer) description of the Task; value of <Description>. */
      String strDescription;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de: Herausholen des XML-Elements, auf das der globale Index zeigt, aus der Liste.
 * en: Get the XML-element of the list where the global index is pointing at. */
      elementTask = (Element) (listTasks.get(intListTasksIndex));
/* de: Herausholen der Werte die für die Zeichenkette gebraucht werden.
 * en: Get the values that are needed for the string to be displayed. */
      elementMultiUsed = elementTask.getChild("DisplayedCode");
      strDisplayedCode = elementMultiUsed.getTextTrim();
      elementMultiUsed = elementTask.getChild("Description");
      strDescription = elementMultiUsed.getTextTrim();
/*
 * de: Prüfen, ob der <DisplayedCode> in Grossbuchstaben angezeigt werden soll.
 * en: Check if the <DisplayedCode> should be shown in UpperCase. */
      if (bolUpperCase) {
        return strDisplayedCode.toUpperCase() + " - " + strDescription;
      }
      else {
        return strDisplayedCode + " - " + strDescription;
      }
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODE zum Prüfen ob der (als Parameter übergebene) Code ein gültiger <DisplayedCode> ist.
 * en:
 * METHOD to check if a Code (passed as parameter) is a valid <DisplayedCode>. */
    public boolean isValidDisplayedCode(String parmDisplayedCode) {
/*
 * ----- Variable / Variables ----- */
/* de: XML-Element mit der gesamten Information (Elemente) für einen Task.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de:
 * Mehrfach verwendetes XML-Element zum Herausholen der untergeordneten Elemente eines
 * Task-Elements.
 * en:
 * Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/* de: Text des <DisplayedCode>.
 * en: Text of the <DisplayedCode>. */
      String strDisplayedCode;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* 
 * de: Prüfen ob zumidest ein Element für einen Task in der XML-Struktur ist.
 * en: Check if there is at least one Element for a Task in the XML-structure. */
      Element ElementTask = XML_RootElement.getChild("Task");
      if (ElementTask == null) {
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
        return false;
      }
/* 
 * de:
 * Liste mit allen Task-Elementen aus der XML-Struktur herausholen für einen
 * späteren Vergleich ob eines den gesuchten <DisplayedCode> enthält.
 * en:
 * Get the list with all Task-elements out of the XML-structure
 * for further comparison if one has the searched <DisplayedCode>. */
      listTasks = XML_RootElement.getChildren("Task");
      intListTasksSize = listTasks.size();
/* 
 * de:
 * Untersuchen des/der XML-Elements/e in der Liste ob sie den gesuchten <DisplayedCode> enthalten.
 * en:
 * Inspect the XML-element(s) in the list if they have the requested <DisplayedCode>. */
      for (intListTasksIndex = 0; intListTasksIndex < intListTasksSize; intListTasksIndex++) {
        elementTask = (Element) (listTasks.get(intListTasksIndex));
        elementMultiUsed = elementTask.getChild("DisplayedCode");
        strDisplayedCode = elementMultiUsed.getTextTrim();
/* 
 * de:
 * Vergleichen ob der <DisplayedCode> des untersuchten <Task> ist der gleiche als der gesuchte.
 * Der Vergleich hängt vom <UpperCase> Element der XML-Struktur ab.
 * en:
 * Compare if the <DisplayedCode> of the inspected <Task> is the same as the searched one.
 * The comparison depends on the <UpperCase> element of the XML-structure. */
        if ( (strDisplayedCode.compareTo(parmDisplayedCode.trim()) == 0)
            || (bolUpperCase && (strDisplayedCode.compareToIgnoreCase(parmDisplayedCode.trim()) == 0))
           ) {
          StatusCode = CONST_OK;
          return true;
        }
      }
/* 
 * de: Task mit dem gesuchten <DisplayedCode> nicht gefunde; Fehler zurück liefern.
 * en: Task with the requested <DisplayedCode> not found; return error. */
      StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
      return false;
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODE die nach der Eingabe eines Auswahl-Codes das entsprechende XML-Element
 * für den Task sucht, die JLabels für die Eingabe von zusätzlichen Parametern
 * mit dem entsprechenden Text füllt und JTextField nach Bedarf für die Eingabe
 * öffnet oder die Eingabe verhindert.
 * Der Text für die JLabels und die Steuerung der JTextFields ist im XML-Element
 * für den Task definiert.
 * en:
 * METHOD which finds the fitting XML-element for the Task after a Selection-Code
 * was entered, sets the text of the JLabels for the parameter-entry and
 * enables/disables the JTextFields for parameter-entry
 * according to the definitions in the XML-structure. */
    public String processParameterFields(JTextField parmtxtCode,
               JLabel parmlblParameter1, JTextField parmtxtParameter1,
               JLabel parmlblParameter2, JTextField parmtxtParameter2,
               JLabel parmlblParameter3, JTextField parmtxtParameter3) {
/*
 * ----- Variable / Variables ----- */
/* de:
 * XML-Element mit allen Informationen (in untergeordneten XML-Elementen) für einen
 * Task (Geschäftsfall-Anwendung).
 * en:
 * XML-element with all information (in Sub-XML-elements) for one task. */
      Element elementTask;
/* de:
 * Mehrfach verwendetes XML-Element um verschiedene Unter-Elemente aus einem
 * Task-Element auslesen zu können.
 * en:
 * Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/* 
 * de:
 * Vom Anwender eingegebener Code; 'Text' des Parameters parmtxtCode;
 * Für den Vergleich mit <DisplayedCode> (aus der XML-Struktur).
 * en:
 * User entered code; 'Text' of the parameter parmtxtCode;
 * to be compared with <DisplayedCode> (out of the XML-structure). */
      String strSelectedCode = parmtxtCode.getText().trim();
/*
 * de: Eventuell bestehende 'ToolTip'-Texte löschen.
 * en: Maybe existing 'TollTip'-texts are cleared. */
      if (parmlblParameter1 != null) parmlblParameter1.setToolTipText("");
      if (parmtxtParameter1 != null) parmtxtParameter1.setToolTipText("");
      if (parmlblParameter2 != null) parmlblParameter2.setToolTipText("");
      if (parmtxtParameter2 != null) parmtxtParameter2.setToolTipText("");
      if (parmlblParameter3 != null) parmlblParameter3.setToolTipText("");
      if (parmtxtParameter3 != null) parmtxtParameter3.setToolTipText("");
/* 
 * de:
 * Prüfen ob mindesten ein Element für einen Task in der XML-Struktur vorhanden ist.
 * en:
 * Check if there is at least one Element for a Task in the XML-structure. */
      elementTask = XML_RootElement.getChild("Task");
      if (elementTask == null) {
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
/*
 * de: Wenn JLabel-Elemente übergeben wurden: Leere Zeichenkette für den Text setzen.
 * en: If there were JLabel-elements passed: set the text of them to 'empty String'. */
        if (parmlblParameter1 != null) parmlblParameter1.setText("");
        if (parmlblParameter2 != null) parmlblParameter2.setText("");
        if (parmlblParameter3 != null) parmlblParameter3.setText("");
/* de: Wenn JTextField-Element übergeben wurden: Feld für die Eingabe Sperren.
 * en: If there were JTextField-elements passed: set themto 'disabled'. */
        if (parmtxtParameter1 != null) parmtxtParameter1.setEnabled(false);
        if (parmtxtParameter2 != null) parmtxtParameter2.setEnabled(false);
        if (parmtxtParameter3 != null) parmtxtParameter3.setEnabled(false);
        return "";
      }
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(strSelectedCode);
      if (elementTask != null) {
/* de: Task mit dem gesuchten <DisplayedCode> gefunden; Status auf OK setzen.
 * en: Task with the requested <DisplayedCode> found; set the status to OK. */
        StatusCode = CONST_OK;
/* 
 * de:
 * Übertragen des Textes für die 'Parameter'-Label, sperren/öffnen für die Eingabe bei
 * 'Parameter'-JTextFields und setzen des Tool-Tip-Texts.
 * Aber nur wenn diese übergeben wurden (nicht 'null' sind).
 * en:
 * Transfer the Text for the 'Parameter'-labels, enable/disable the 'Parameter'-JTextFields
 * and set the Tool-Tip-Text. Do this only, if they were passed (not 'null'). */
/* 
 * Ausführen für <Parameter1>. / Do this for <Parameter1>. */
        elementMultiUsed = elementTask.getChild("Parameter1Label");
        if (elementMultiUsed == null) {
/* de:
 * Kein XML-Element für <Parameter1> vorhanden; leere Zeichenkette für das Label
 * und Eingabe für das Text-Feld sperren.
 * en:
 * No XML-element for <Parameter1> defined; set empty String to label and disable text-field. */
          if (parmlblParameter1 != null) parmlblParameter1.setText("");
          if (parmtxtParameter1 != null) parmtxtParameter1.setEnabled(false);
        }
        else {
          if (parmlblParameter1 != null) parmlblParameter1.setText(elementMultiUsed.getTextTrim());
          if (parmtxtParameter1 != null) {
            parmtxtParameter1.setEnabled(true);
/* de:
 * Methode aufrufen in der geprüft wird, ob Eingabeprüfungen definiert sind, und die Prüfregel
 * in die Liste von structJSBS_EntryRules (definiert im StartFrame / CommandCenter) übernommen werden.
 * en:
 * Call the Method with the verification if verification rules for entered values are defined and
 * transfer the rule to the list of structJSBS_EntryRules (defined in the StartFrame / CommandCenter). */
            setParameter1EntryRuleForVerification(strSelectedCode);
          }
/* de:
 * Tool-Tip-Text aus der XML-Struktur auslesen und (wenn vorhanden) auf Label und
 * Text-Feld übertragen.
 * en:
 * Read the Tool-Tip-Text out of the XML-structure and (if present) transfer it to
 * the label and text-field. */
          elementMultiUsed = elementTask.getChild("Parameter1ToolTipText");
          if (elementMultiUsed != null) {
            if (parmlblParameter1 != null) parmlblParameter1.setToolTipText(elementMultiUsed.getTextTrim());
            if (parmtxtParameter1 != null) parmtxtParameter1.setToolTipText(elementMultiUsed.getTextTrim());
          }
        }
/* 
 * Ausführen für <Parameter2>. / Do this for <Parameter2>. */
        elementMultiUsed = elementTask.getChild("Parameter2Label");
        if (elementMultiUsed == null) {
          if (parmlblParameter2 != null) parmlblParameter2.setText("");
          if (parmtxtParameter2 != null) parmtxtParameter2.setEnabled(false);
        }
        else {
          if (parmlblParameter2 != null) parmlblParameter2.setText(elementMultiUsed.getTextTrim());
          if (parmtxtParameter2 != null) {
            parmtxtParameter2.setEnabled(true);
/* de:
 * Methode aufrufen in der geprüft wird, ob Eingabeprüfungen definiert sind, und die Prüfregel
 * in die Liste von structJSBS_EntryRules (definiert im StartFrame / CommandCenter) übernommen werden.
 * en:
 * Call the Method with the verification if verification rules for entered values are defined and
 * transfer the rule to the list of structJSBS_EntryRules (defined in the StartFrame / CommandCenter). */
            setParameter2EntryRuleForVerification(strSelectedCode);
          }
/* ***** */
          elementMultiUsed = elementTask.getChild("Parameter2ToolTipText");
          if (elementMultiUsed != null) {
            if (parmlblParameter2 != null) parmlblParameter2.setToolTipText(elementMultiUsed.getTextTrim());
            if (parmtxtParameter2 != null) parmtxtParameter2.setToolTipText(elementMultiUsed.getTextTrim());
          }
        }
/* 
 * Ausführen für <Parameter3>. / Do this for <Parameter3>. */
        elementMultiUsed = elementTask.getChild("Parameter3Label");
        if (elementMultiUsed == null) {
          if (parmlblParameter3 != null) parmlblParameter3.setText("");
          if (parmtxtParameter3 != null) parmtxtParameter3.setEnabled(false);
        }
        else {
          if (parmlblParameter3 != null) parmlblParameter3.setText(elementMultiUsed.getTextTrim());
          if (parmtxtParameter3 != null) {
            parmtxtParameter3.setEnabled(true);
/* de:
 * Methode aufrufen in der geprüft wird, ob Eingabeprüfungen definiert sind, und die Prüfregel
 * in die Liste von structJSBS_EntryRules (definiert im StartFrame / CommandCenter) übernommen werden.
 * en:
 * Call the Method with the verification if verification rules for entered values are defined and
 * transfer the rule to the list of structJSBS_EntryRules (defined in the StartFrame / CommandCenter). */
            setParameter3EntryRuleForVerification(strSelectedCode);
          }
/* ***** */
          elementMultiUsed = elementTask.getChild("Parameter3ToolTipText");
          if (elementMultiUsed != null) {
            if (parmlblParameter3 != null) parmlblParameter3.setToolTipText(elementMultiUsed.getTextTrim());
            if (parmtxtParameter3 != null) parmtxtParameter3.setToolTipText(elementMultiUsed.getTextTrim());
          }
        }
/*
 * de: Zuletzt den internen Code für den Task auslesen und den Wert zurückliefern,
 * en: Finally derive the <InternalCode> for the task and return the value. */
        elementMultiUsed = elementTask.getChild("InternalCode");
        if (elementMultiUsed != null) return elementMultiUsed.getTextTrim();
        else return "";
      }
      else {
/* 
 * de: Task mit dem gesuchten <DisplayedCode> nicht gefunden; Fehler zurückliefern.
 * en: Task with the requested <DisplayedCode> not found; return error. */
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
/* de: Wenn JLabel-Elemente übergeben wurden: Text leeren.
 * en: If there were JLabel-elements passed: set the text of them to 'empty String'. */
        if (parmlblParameter1 != null) parmlblParameter1.setText("");
        if (parmlblParameter2 != null) parmlblParameter2.setText("");
        if (parmlblParameter3 != null) parmlblParameter3.setText("");
/* de: Wenn JTextField-Element übergeben wurden: dieser für die Eingabe sperren.
 * en: If there were JTextField-elements passed: set themto 'disabled'. */
        if (parmtxtParameter1 != null) parmtxtParameter1.setEnabled(false);
        if (parmtxtParameter2 != null) parmtxtParameter2.setEnabled(false);
        if (parmtxtParameter3 != null) parmtxtParameter3.setEnabled(false);
        return "";
      }
    }
/*
 * ************************************************** */
/* de:
 * Methode zum Ermitteln des <DisplayedCode> bei bekanntem <InternalCode>
 * (der als Parameter übergeben wurde).
 * en:
 * Method to get the <DisplayedCode> for an <InternalCode> (passed as parameter). */
    public String getDisplayedCode(String parmInternalCode) {
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/* de: Text von <InternalCode>.
 * en: Text of the <InternalCode>. */
      String strInternalCode;
/* de: Text von <DisplayedCode>
 * en: Text of the <DisplayedCode>. */
      String strDisplayedCode;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de: Prüfen ob mindesten ein Element für einen Task in der XML-Struktur ist.
 * en: Check if there is at least one Element for a Task in the XML-structure. */
      Element ElementTask = XML_RootElement.getChild("Task");
      if (ElementTask == null) {
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
        return "";
      }
/* de:
 * Liste mit alle Task-Elementen aus der XML-Struktur holen damit nachher
 * verglichen werden kann ob eines den gesuchten <InternalCode> enthält.
 * en:
 * Get the list with all Task-elements out of the XML-structure
 * for further comparison if one has the searched <InternalCode>. */
      listTasks = XML_RootElement.getChildren("Task");
      intListTasksSize = listTasks.size();
/* de:
 * Untersuchen der XML-Elemente in der Liste ob eines den gesuchten <InternalCode>
 * enthält.
 * en:
 * Inspect the XML-element(s) in the list if one has the requested <InternalCode>. */
      for (intListTasksIndex = 0;
          intListTasksIndex < intListTasksSize;
          intListTasksIndex++) {
        elementTask = (Element) (listTasks.get(intListTasksIndex));
        elementMultiUsed = elementTask.getChild("InternalCode");
/* de:
 * Prüfen ob ein <InternalCode> innerhalb dieses Elementes definiert ist.
 * Es gibt Elemente die nur die Funktion einer 'Verzweigung' haben und denen
 * kein aufrufbarer 'Task' zugeordnet ist.
 * en:
 * Verify if there is an <InternalCode> defined with this element.
 * There are elements that just have the function as 'branches' without starting
 * a 'task'. */
        if ( elementMultiUsed == null) continue;
        strInternalCode = elementMultiUsed.getTextTrim();
/* de:
 * Vergleichen ob der <InternalCode> des untersuchten <Task> der gleich ist
 * als der gesuchte (aus dem Parameter).
 * In den Vergleich wird auch das <UpperCase> Element der XML-Struktur einbezogen.
 * en:
 * Compare if the <InternalCode> of the inspected <Task> is the same as the
 * searched one.
 * The comparison depends on the <UpperCase> element of the XML-structure. */
        if ( (strInternalCode.compareTo(parmInternalCode.trim()) == 0)
            || (bolUpperCase && (strInternalCode.compareToIgnoreCase(parmInternalCode.trim()) == 0))
           ) {
          StatusCode = CONST_OK;
/* de: Task mit dem gesuchten <InternalCode> gefunden; <DisplayedCode> filtern.
 * en: Task with the requested <InternalCode> found; derive <DisplayedCode>. */
          elementMultiUsed = elementTask.getChild("DisplayedCode");
          strDisplayedCode = elementMultiUsed.getTextTrim();
/* de:
 * Wenn die Codes nur in Großbuchstaben erscheinen sollen dann wird der
 * <DisplayedCode> jetzt umgewandelt.
 * en:
 * If the codes should be in upper-case only then transform the <DisplayedCode> now. */
          if (bolUpperCase) strDisplayedCode = strDisplayedCode.toUpperCase();
          return strDisplayedCode;
        }
      }
/* de: Task mit dem gesuchten <DisplayedCode> nicht gefunden; Fehler zurückgeben.
 * en: Task with the requested <DisplayedCode> not found; return error. */
      StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
      return "";
    }
/*
 * ************************************************** */
/* de:
 * Methode zum Ermitteln des <InternalCode> bei bekanntem <DisplayedCode>
 * (der als Parameter übergeben wurde).
 * en:
 * Method to get the <InternalCode> for an <DisplaedCode> (passed as parameter). */
    public String getInternalCode(String parmDisplayedCode) {
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null) {
/* de: Task mit dem gesuchten <DisplayedCode> nicht gefunden; Fehler zurückgeben.
 * en: Task with the requested <DisplayedCode> not found; return error. */
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
        return "";
      }
      else {
/* de: Task mit dem gesuchten <DisplayedCode> gefunden; <InternalCode> filtern.
 * en: Task with the requested <DisplayedCode> found; derive <InternalCode>. */
          elementMultiUsed = elementTask.getChild("InternalCode");
/* de:
 * Prüfen ob ein <InternalCode> innerhalb dieses Elementes definiert ist.
 * Es gibt Elemente die nur die Funktion einer 'Verzweigung' haben und denen
 * kein aufrufbarer 'Task' zugeordnet ist.
 * en:
 * Verify if there is an <InternalCode> defined with this element.
 * There are elements that just have the function as 'branches' without starting
 * a 'task'. */
          if ( elementMultiUsed == null) return "";
/* de: <InternalCode> an aufrufende Methode zurückliefern.
 * en: Return <InternalCode> to the calling method. */
          return elementMultiUsed.getTextTrim();
        }
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODEN zum Auslesen der 'Info-Message' für die Parameter-Felder.
 * Die 'Info-Message' wird im unteren Bereich des Fensters angezeigt wenn das
 * entsprechende Feld den 'Focus' erhält.
 * en:
 * METHODS to get the 'info-message' for the parameter-fields.
 * The 'info-message' is shown in the lower area of the window when the
 * concerned field gets the 'focus'. */
    public String getParameter1InfoMessage(String parmDisplayedCode) {
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null) {
/* de:
 * Kein XML-Element für den gesuchten Code gefunden. Leere Zeichenkette zurückliefern.
 * en:
 * No XML-element for the requested Code found. Return an empty string. */
        return "";
      }
      else {
/* de:
 * XML-Element für den gesuchten Code gefunden;
 * Info-Message für das Parameter-Feld auslesen.
 * en:
 * XML-element for the requested Code found;
 * get the Info-Message for the parameter-field. */
        elementMultiUsed = elementTask.getChild("Parameter1InfoMessage");
/* de:
 * Prüfen ob das gesuchte XML-Element vorhanden ist.
 * Wenn keine Info-Message definiert ist dann wird eine leere Zeichenkette
 * zurückgeliefert. Sonst wird der Wert des XML-Elements zurück geliefert.
 * en:
 * Verify if the requested XML-element exists.
 * If an Info-Message is not defined then an empty string is returned.
 * Otherwise the value of the XML-element is returned. */
        if (elementMultiUsed == null) return "";
        return elementMultiUsed.getTextTrim();
      }
    }
/* ************************************************** */
    public String getParameter2InfoMessage(String parmDisplayedCode) {
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null) {
/* de:
 * Kein XML-Element für den gesuchten Code gefunden. Leere Zeichenkette zurückliefern.
 * en:
 * No XML-element for the requested Code found. Return an empty string. */
        return "";
      }
      else {
/* de:
 * XML-Element für den gesuchten Code gefunden;
 * Info-Message für das Parameter-Feld auslesen.
 * en:
 * XML-element for the requested Code found;
 * get the Info-Message for the parameter-field. */
        elementMultiUsed = elementTask.getChild("Parameter2InfoMessage");
/* de:
 * Prüfen ob das gesuchte XML-Element vorhanden ist.
 * Wenn keine Info-Message definiert ist dann wird eine leere Zeichenkette
 * zurückgeliefert. Sonst wird der Wert des XML-Elements zurück geliefert.
 * en:
 * Verify if the requested XML-element exists.
 * If an Info-Message is not defined then an empty string is returned.
 * Otherwise the value of the XML-element is returned. */
        if (elementMultiUsed == null) return "";
        return elementMultiUsed.getTextTrim();
      }
    }
/* ************************************************** */
    public String getParameter3InfoMessage(String parmDisplayedCode) {
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null) {
/* de:
 * Kein XML-Element für den gesuchten Code gefunden. Leere Zeichenkette zurückliefern.
 * en:
 * No XML-element for the requested Code found. Return an empty string. */
        return "";
      }
      else {
/* de:
 * XML-Element für den gesuchten Code gefunden;
 * Info-Message für das Parameter-Feld auslesen.
 * en:
 * XML-element for the requested Code found;
 * get the Info-Message for the parameter-field. */
        elementMultiUsed = elementTask.getChild("Parameter3InfoMessage");
/* de:
 * Prüfen ob das gesuchte XML-Element vorhanden ist.
 * Wenn keine Info-Message definiert ist dann wird eine leere Zeichenkette
 * zurückgeliefert. Sonst wird der Wert des XML-Elements zurück geliefert.
 * en:
 * Verify if the requested XML-element exists.
 * If an Info-Message is not defined then an empty string is returned.
 * Otherwise the value of the XML-element is returned. */
        if (elementMultiUsed == null) return "";
        return elementMultiUsed.getTextTrim();
      }
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODEN zum Auslesen der 'Prüfregeln' für die Parameter-Felder und übernehmen
 * in das Objekt für die Prüfung von Eingaben.
 * Die 'Prüfregel' wird ausgeführt wenn im Parameter-Feld Text eingegeben wird.
 * en:
 * METHODS to get the 'verification-rules' for the parameter-fields and transfer it
 * into the object for the verification of entries.
 * The 'verification-rule' is executed when text is entered in the parameter-field. */
    private void setParameter1EntryRuleForVerification(String parmDisplayedCode) {
/*
 * de: Zuallererst eventuell noch existierende Prüfregel löschen.
 * en: First of all, remove propably still existing verification-rule. */
      frmCC.structJSBS_EntryRules.removeEntryRule(frmCC.get_txt_Parameter1().getName());
/*
 * de: Wenn kein Parameter-Wert übergeben wurde dann die Methode sofort beenden.
 * en: If no parameter-value was passed then end the method immediately. */
      if (parmDisplayedCode == null) return;
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null)
/* de: Kein XML-Element für den gesuchten Code gefunden. Methode beenden.
 * en: No XML-element for the requested Code found. End this method. */
        return;
/*
 * de:
 * XML-Element für den gesuchten Code gefunden; Name des allgemein gültigen GUI-Elements auslesen.
 * Über dieses allgemein gültige GUI-Element wird später die Prüfregel für den Parameterwert ermittelt.
 * en:
 * XML-element for the requested Code found; get the name of the common GUI-Element.
 * The common GUI-Element is used later to get the verification-rule for the parameter-value. */
      elementMultiUsed = elementTask.getChild("Parameter1CommonElementForVerification");
/* de:
 * Prüfen ob das gesuchte XML-Element vorhanden ist.
 * Wenn kein Verweis auf das GUI-Element mit einer Prüfregel existiert dann wird die Methode beendet.
 * en:
 * Verify if the requested XML-element exists.
 * If a reference to the GUI-element with a verification-rule does not exist, then this method is terminated. */
      if (elementMultiUsed == null) return;
/*
 * de: Name des allgemein gültigen GUI-Elements aus dem XML-Element auslesen.
 * en: Get the name of the common GUI-Element out of the XML-element. */
      String strCommonElementName = elementMultiUsed.getTextTrim();
/* de: Prüfen ob das XML-Element einen Text enthält; sonst die Methode beenden.
 * en: Verify if the XML-element contains text; otherwise end this method. */
      if (strCommonElementName == null) return;
/*
 * de: XML-Element für das allgemein gültige GUI-Element auslesen.
 * en: Get the XML-element for the common GUI-element. */
      elementMultiUsed = frmCC.structJSBS_XML_DisplayStrings.getCommonElement(strCommonElementName);
/* de: Prüfen ob das XML-Element existiert; sonst die Methode beenden.
 * en: Verify if the XML-element exists; otherwise end this method. */
      if (elementMultiUsed == null) return;
/* 
 * de:
 * 'Auslesen' der Eingabe-Regeln für minimale und maximale Text-Länge.
 * Wenn keine Regel existiert dann wird der Wert 'null' von der jeweiligen Methode zurückgeliefert.
 * en:
 * 'Read' the Entry-Rules for minimum and maximum length of text.
 * If no Rule exist, then a value of 'null' is returned by each of the called methods. */
      Integer intMinimumLength =
            frmCC.structJSBS_XML_DisplayStrings.getProperty_MinimumLength(elementMultiUsed);
      Integer intMaximumLength =
            frmCC.structJSBS_XML_DisplayStrings.getProperty_MaximumLength(elementMultiUsed);
/* 
 * de: Einfügen der Werte in die Struktur mit den Eingabe-Regeln.
 * en: Insert the values into the structure with the Entry-Rules. */
      frmCC.structJSBS_EntryRules.setEntryRuleValues(
            frmCC.get_txt_Parameter1().getName(), null, null, null,
            null, intMinimumLength, intMaximumLength, null);
    }
/*
 * ************************************************** */
    private void setParameter2EntryRuleForVerification(String parmDisplayedCode) {
/*
 * de: Zuallererst eventuell noch existierende Prüfregel löschen.
 * en: First of all, remove propably still existing verification-rule. */
      frmCC.structJSBS_EntryRules.removeEntryRule(frmCC.get_txt_Parameter2().getName());
/*
 * de: Wenn kein Parameter-Wert übergeben wurde dann die Methode sofort beenden.
 * en: If no parameter-value was passed then end the method immediately. */
      if (parmDisplayedCode == null) return;
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null)
/* de: Kein XML-Element für den gesuchten Code gefunden. Methode beenden.
 * en: No XML-element for the requested Code found. End this method. */
        return;
/*
 * de:
 * XML-Element für den gesuchten Code gefunden; Name des allgemein gültigen GUI-Elements auslesen.
 * Über dieses allgemein gültige GUI-Element wird später die Prüfregel für den Parameterwert ermittelt.
 * en:
 * XML-element for the requested Code found; get the name of the common GUI-Element.
 * The common GUI-Element is used later to get the verification-rule for the parameter-value. */
      elementMultiUsed = elementTask.getChild("Parameter2CommonElementForVerification");
/* de:
 * Prüfen ob das gesuchte XML-Element vorhanden ist.
 * Wenn kein Verweis auf das GUI-Element mit einer Prüfregel existiert dann wird die Methode beendet.
 * en:
 * Verify if the requested XML-element exists.
 * If a reference to the GUI-element with a verification-rule does not exist, then this method is terminated. */
      if (elementMultiUsed == null) return;
/*
 * de: Name des allgemein gültigen GUI-Elements aus dem XML-Element auslesen.
 * en: Get the name of the common GUI-Element out of the XML-element. */
      String strCommonElementName = elementMultiUsed.getTextTrim();
/* de: Prüfen ob das XML-Element einen Text enthält; sonst die Methode beenden.
 * en: Verify if the XML-element contains text; otherwise end this method. */
      if (strCommonElementName == null) return;
/*
 * de: XML-Element für das allgemein gültige GUI-Element auslesen.
 * en: Get the XML-element for the common GUI-element. */
      elementMultiUsed = frmCC.structJSBS_XML_DisplayStrings.getCommonElement(strCommonElementName);
/* de: Prüfen ob das XML-Element existiert; sonst die Methode beenden.
 * en: Verify if the XML-element exists; otherwise end this method. */
      if (elementMultiUsed == null) return;
/* 
 * de:
 * 'Auslesen' der Eingabe-Regeln für minimale und maximale Text-Länge.
 * Wenn keine Regel existiert dann wird der Wert 'null' von der jeweiligen Methode zurückgeliefert.
 * en:
 * 'Read' the Entry-Rules for minimum and maximum length of text.
 * If no Rule exist, then a value of 'null' is returned by each of the called methods. */
      Integer intMinimumLength =
            frmCC.structJSBS_XML_DisplayStrings.getProperty_MinimumLength(elementMultiUsed);
      Integer intMaximumLength =
            frmCC.structJSBS_XML_DisplayStrings.getProperty_MaximumLength(elementMultiUsed);
/* 
 * de: Einfügen der Werte in die Struktur mit den Eingabe-Regeln.
 * en: Insert the values into the structure with the Entry-Rules. */
      frmCC.structJSBS_EntryRules.setEntryRuleValues(
            frmCC.get_txt_Parameter2().getName(), null, null, null,
            null, intMinimumLength, intMaximumLength, null);
    }
/*
 * ************************************************** */
    private void setParameter3EntryRuleForVerification(String parmDisplayedCode) {
/*
 * de: Zuallererst eventuell noch existierende Prüfregel löschen.
 * en: First of all, remove propably still existing verification-rule. */
      frmCC.structJSBS_EntryRules.removeEntryRule(frmCC.get_txt_Parameter3().getName());
/*
 * de: Wenn kein Parameter-Wert übergeben wurde dann die Methode sofort beenden.
 * en: If no parameter-value was passed then end the method immediately. */
      if (parmDisplayedCode == null) return;
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de:
 * Aufrufen der Methode zum Holen des gesamten XML-Elementes für den Task und prüfen
 * ob ein XML-Element gefunden wurde.
 * en:
 * Call the method to get the complete XML-element fot the task and verify if a
 * XML-element was found. */
      elementTask = getTaskElementByDisplayedCode(parmDisplayedCode);
      if (elementTask == null)
/* de: Kein XML-Element für den gesuchten Code gefunden. Methode beenden.
 * en: No XML-element for the requested Code found. End this method. */
        return;
/*
 * de:
 * XML-Element für den gesuchten Code gefunden; Name des allgemein gültigen GUI-Elements auslesen.
 * Über dieses allgemein gültige GUI-Element wird später die Prüfregel für den Parameterwert ermittelt.
 * en:
 * XML-element for the requested Code found; get the name of the common GUI-Element.
 * The common GUI-Element is used later to get the verification-rule for the parameter-value. */
      elementMultiUsed = elementTask.getChild("Parameter3CommonElementForVerification");
/* de:
 * Prüfen ob das gesuchte XML-Element vorhanden ist.
 * Wenn kein Verweis auf das GUI-Element mit einer Prüfregel existiert dann wird die Methode beendet.
 * en:
 * Verify if the requested XML-element exists.
 * If a reference to the GUI-element with a verification-rule does not exist, then this method is terminated. */
      if (elementMultiUsed == null) return;
/*
 * de: Name des allgemein gültigen GUI-Elements aus dem XML-Element auslesen.
 * en: Get the name of the common GUI-Element out of the XML-element. */
      String strCommonElementName = elementMultiUsed.getTextTrim();
/* de: Prüfen ob das XML-Element einen Text enthält; sonst die Methode beenden.
 * en: Verify if the XML-element contains text; otherwise end this method. */
      if (strCommonElementName == null) return;
/*
 * de: XML-Element für das allgemein gültige GUI-Element auslesen.
 * en: Get the XML-element for the common GUI-element. */
      elementMultiUsed = frmCC.structJSBS_XML_DisplayStrings.getCommonElement(strCommonElementName);
/* de: Prüfen ob das XML-Element existiert; sonst die Methode beenden.
 * en: Verify if the XML-element exists; otherwise end this method. */
      if (elementMultiUsed == null) return;
/* 
 * de:
 * 'Auslesen' der Eingabe-Regeln für minimale und maximale Text-Länge.
 * Wenn keine Regel existiert dann wird der Wert 'null' von der jeweiligen Methode zurückgeliefert.
 * en:
 * 'Read' the Entry-Rules for minimum and maximum length of text.
 * If no Rule exist, then a value of 'null' is returned by each of the called methods. */
      Integer intMinimumLength =
            frmCC.structJSBS_XML_DisplayStrings.getProperty_MinimumLength(elementMultiUsed);
      Integer intMaximumLength =
            frmCC.structJSBS_XML_DisplayStrings.getProperty_MaximumLength(elementMultiUsed);
/* 
 * de: Einfügen der Werte in die Struktur mit den Eingabe-Regeln.
 * en: Insert the values into the structure with the Entry-Rules. */
      frmCC.structJSBS_EntryRules.setEntryRuleValues(
            frmCC.get_txt_Parameter3().getName(), null, null, null,
            null, intMinimumLength, intMaximumLength, null);
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODE um ein komplettes XML-Element für einen 'Task' aus der XML-Struktur
 * zurückzuliefern. Das XML-Element wird durch den als Parameter übergebenen 
 * Auswahl-Code (DisplayedCode) bestimmt.
 * Das zurück gelieferte XML-Element wird in anderen Methoden weiter verarbeitet.
 * en:
 * METHOD to get a complete XML-Element for a 'Task' out of the XML-structure.
 * The XML-element is defined by the DisplayedCode which is passed as parameter.
 * The returned XML-Element is used for further processing in other methods. */
    private Element getTaskElementByDisplayedCode(String parmDisplayedCode) {
/*
 * ----- Variablen / Variables ----- */
/* de: XML-Element mit allen Informationen (Elemente) für einen 'Task'.
 * en: XML-element with all information (elements) for one task. */
      Element elementTask;
/* de: XML-Element für mehrfache Verwendung zum Bearbeiten verschiedener
 *     Unter-Elemente eines Task-Elements.
 * en: Multiple used XML-element to get various sub-elements of a Task-element. */
      Element elementMultiUsed;
/* de: Text von <DisplayedCode>
 * en: Text of the <DisplayedCode>. */
      String strDisplayedCode;
/*
 * ----- Beginn des Codes / Begin of Code ----- */
/* de: Prüfen ob mindesten ein Element für einen Task in der XML-Struktur ist.
 * en: Check if there is at least one Element for a Task in the XML-structure. */
      Element ElementTask = XML_RootElement.getChild("Task");
      if (ElementTask == null) {
        StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
        return null;
      }
/* de:
 * Liste mit alle Task-Elementen aus der XML-Struktur holen damit nachher
 * verglichen werden kann ob eines den gesuchten <DisplayedCode> enthält.
 * en:
 * Get the list with all Task-elements out of the XML-structure
 * for further comparison if one has the searched <DisplayedCode>. */
      listTasks = XML_RootElement.getChildren("Task");
      intListTasksSize = listTasks.size();
/* de:
 * Untersuchen der XML-Elemente in der Liste ob eines den gesuchten <DisplayedCode>
 * enthält.
 * en:
 * Inspect the XML-element(s) in the list if one has the requested <DisplayedCode>. */
      for (intListTasksIndex = 0;
          intListTasksIndex < intListTasksSize;
          intListTasksIndex++) {
        elementTask = (Element) (listTasks.get(intListTasksIndex));
        elementMultiUsed = elementTask.getChild("DisplayedCode");
/* de:
 * Prüfen ob ein <DisplayedCode> innerhalb dieses Elementes definiert ist.
 * Es gibt Elemente die nur die Funktion einer 'Verzweigung' haben und denen
 * kein aufrufbarer 'Task' zugeordnet ist.
 * en:
 * Verify if there is an <DisplayedCode> defined with this element.
 * There are elements that just have the function as 'branches' without starting
 * a 'task'. */
        if (elementMultiUsed == null) continue;
        strDisplayedCode = elementMultiUsed.getTextTrim();
/* de:
 * Vergleichen ob der <DisplayedCode> des untersuchten <Task> der gleiche ist
 * wie der gesuchte (aus dem Parameter).
 * In den Vergleich wird auch das <UpperCase> Element der XML-Struktur einbezogen.
 * en:
 * Compare if the <DisplayedCode> of the inspected <Task> is the same as the
 * searched one.
 * The comparison depends on the <UpperCase> element of the XML-structure. */
        if ( (strDisplayedCode.compareTo(parmDisplayedCode.trim()) == 0)
            || (bolUpperCase && (strDisplayedCode.compareToIgnoreCase(parmDisplayedCode.trim()) == 0))
           ) {
          StatusCode = CONST_OK;
/* de: Task mit dem gesuchten <DisplayedCode> gefunden; ganzes XML-Element für den Task zurückliefern.
 * en: Task with the requested <DisplayedCode> found; return the whole XML-element for the Task. */
          return elementTask;
        }
      }
/* de: Task mit dem gesuchten <DisplayedCode> nicht gefunden; Fehler zurückgeben.
 * en: Task with the requested <DisplayedCode> not found; return error. */
      StatusCode = CONST_NO_TASK_ELEMENT_PRESENT;
      return null;
    }
/*
 * ************************************************** */
/*
 * de:
 * METHODE um den eingegebenen Text eines GUI-Elements der Klasse JTextField zu holen.
 * Der eingegebene Text wird nur zurück geliefert wenn das JTextField 'enabled' ist.
 * Diese Methode blockiert das 'Auslesen' von eingegebenem Text in Parameter-Feldern
 * die nicht für einen bestimmten Auswahl-Code verwendet werden und aus diesem
 * Grund 'disabled' sind.
 * en:
 * METHOD to get the entered text out of a GUI-element of class JTextField.
 * The text is only returned if the JTextField is 'enabled'.
 * This method blocks the 'reading' of entered text in parameter-fields that are not
 * used for a certain Selection-Code and therefore the JTextField was disabled. */
    public static String filterParameterField(JTextField parmtxtParameter) {
/*
 * de: Inhalt des Feldes nur zurück liefern wenn das Feld 'enabled' ist.
 * en: Return the content of the field only if the field is 'enabled'. */
      if (parmtxtParameter.isEnabled()) return parmtxtParameter.getText();
      else return "";
    }
}