|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.frame;
import java.math.*;
import java.util.*;
import javax.swing.*;
/**
*
* @author kurt(at)javascout[dot]biz
* @date
2007-04-27
*
* @description
*
de:
* Klasse mit Regeln für die Prüfung der
Gültigkeit von Eingaben in Feldern der
* GUI
(Graphic User Interface / Grafische Benutzeroberfläche).
*
Diese Klasse ist in den Klassen JSBS_StartFrame und JSBS_TaskFrame
als Variable
* structJSBS_EntryRules definiert und
wird in diesen Klassen auch 'konstruiert' -
*
'structJSBS_EntryRules' steht damit in allen Klassen, die eine dieser
beiden
* Basisklassen erben zur Verfügung ohne
neuerlich als Variable definiert werden
* zu
müssen
*
* Die Regeln werden in 2
Vectors gehalten.
*
* *
vecApplicationMandatoryFields:
* Ein
Vector, dessen Elemente die Namen aller GUI-Elemente enthalten,
*
bei denen eine Eingabe notwendig ist, um eine korrekte
Verarbeitung
* innerhalb des
Anwendungs-Programms sicher zu stellen.
*
(z.B. der eindeutige, Anwender-bekannte-Schlüssel,
'Produkt-Code'
* muß einen Wert
enthalten.
* Dieser Vector muß im
CommandCenter (Start-Frame) oder einem Task-Frame
*
über die Methode 'addApplicationMandatoryField()' gefüllt
werden.
* Empfohlen wird der Aufruf
dieser Methode innerhalb von
*
'initialize_before_frame()'.
*
* *
vecEntryRules:
* Ein Vector der aus
Objekten der Klasse EntryRule besteht.
*
Eine EntryRule (Eingabe-Regel) kann im CommandCenter
(Start-Frame)
* oder in einem Task-Frame
definiert werden.
* Weiters können
Eingabe-Regeln auch aus der Datei 'DisplayStrings.xml'
*
(enthält die XML-Struktur mit den sprachabhängigen
Texten für GUI-Elemente)
* gefüllt
werden.
* Das geschieht in der Methode
'processEntryRules()' in der Klasse
*
JSBS_XML_DisplayStrings.
*
*
Für eine detaillierte Beschreibung der einzelnen Variablen in
der
* Klasse EntryRule sehen Sie bitte
dort nach.
*
* en: * Class
containing rules for checking the validity of entries to fields in
the GUI.
* This class is implemented and
constructed in JSBS_StartFrame and JSBS_TaskFrame -
* so
it is available to all frames without further defining it as
variable.
*
* The rules are hold
in 2 vectors.
*
* *
vecApplicationMandatoryFields:
* A
vector consisting of Strings holding the names of all GUI-fields
* to which an input is
mandatory for the correct processing within the
application
* (e.g.
unique, user-known-key, 'Product-Code' can not be left
blank).
* This vector has
to be filled within the CommandCenter or
* a
Task-Frame (recommended method 'initialize_before_frame()' )
* using the method
addApplicationMandatoryField().
*
* *
vecEntryRules:
* A vector
consisting of objects EntryRule.
* An
EntryRule can be defined within the CommandCenter or a Task-Frame
* or derived from the
file with the XML-structure containing the
* language-dependant-GUI-elements
(file 'DisplayStrings.xml') using
* the
method processEntryRules() in class
JSBS_XML_DisplayStrings.
*
* For
a detailed list of variables in class EntryRule and their
meaning
* please refer to
the description at class EntryRule.
*
*
@change-log
* when who why
*
--------------------------------------------------------
*
2008-06-03 KG
Changed Type of MinimumValue and MaximumValue
*
from BigInteger to BigDecimal.
*
2010-01-27 KG
Added method to check number of decimals and
*
called this method from the
checking-methods for BigDecimal.
* 2012-04-07 KG
Added method
rmoveEntryRule(...). *
*/public
class JSBS_EntryRules
{/*
*
VARIABLES
* ------------------- */
/*
* de:
* Vector mit den Feldern für Pflicht-Eingaben die
innerhalb des
* Anwendungs-Programms festgelegt werden.
*
en:
* Vector with the MandatoryFields defined within the
application. */ private
Vector
vecApplicationMandatoryFields
= new
Vector();/*
*
de: Vector mit den Objekten der Klasse 'EntryRule'.
* en:
Vector with the objects of class 'EntryRule'. */ private
Vector
vecEntryRules
= new
Vector();/*
*
de:
* Referenz auf das CommandCenter; übergeben wenn
dieses Object 'konstruiert'
* wird. Wird hier gehalten um
die Parameter, die an Methoden übergeben werden
*
müssen, zu reduzieren.
* en: *
Reference to the CommandCenter; passed when this object is
constructed.
* Introduced to reduce the parameters that
have to be passed for a method. */ private
JSBS_StartFrame
frmCC;/*
*
de:
* Klasse für eine Eingabe-Regel.
* Als
'Inner Class' definiert weil sie nur in dieser Klasse
(JSBS_EntryRules)
* verwendet wird.
* en: *
Class for one Entry-Rule.
* Defined as Inner Class as
it is used just by this class (JSBS_EntryRules) */ private
class JSBS_EntryRule
{/*
*
VARIABLEN für diese Inner-Class / VARIABLES for this
Inner-Class. */
/*
* de: Name des GUI-Elementes
(Eingabe-Feld) für den diese Regel gilt. *
en: Name of the GUI-element (entry-field) the Rule is valid for.
*/ protected
String
strGUIElementName
= null;/*
*
de:
* Indikator, ob die Eingabe verpflichtend ist.
*
Im Gegensatz zu den Feldern, die in
'vecApplicationMandatoryFields'
* definiert sind, kann diese
Variable verändert werden wenn es der
* Programmablauf
erfordert.
* en: * Indicator,
if the entry is mandatory.
* In contrast to fields
defined in 'vecApplicationMandatoryFields',
* this
variable can change its value if the flow of code requieres it.
*/ protected
Boolean
bolMandatory
= null;/*
*
de:
* Minimal-Wert. Wenn diese Variable einen anderen Wert
als 'null' enthält,
* dann muß ein eingegebener
Wert mindestens so groß sein wie der hier
* definierte
Wert.
* Wenn die eingebene Zeichenkette (die den Wert, der
geprüft werden soll,
* enthält) leer ist (Länge
0) und das Feld ist nicht als 'Mandatory' definiert,
* dann
wird diese Regel nicht angewandt.
* en: * Minimum
Value. If this variable is other than 'null',
* a
numeric value entered must be at least the value defined here.
* If
the text-string (representing the value to be checked) is empty
(length 0)
* and the EntryRule defines the field not
as Mandatory,
* then the rule is not applied.
*/ protected
BigDecimal bdMinimumValue
= null;/*
*
de:
* Maximal-Wert. Wenn diese Variable einen anderen Wert
als 'null' enthält,
* dann darf ein eingegebener Wert
maximal so groß sein wie der hier
* definierte
Wert.
* Wenn die eingebene Zeichenkette (die den Wert, der
geprüft werden soll,
* enthält) leer ist (Länge
0) und das Feld ist nicht als 'Mandatory' definiert,
* dann
wird diese Regel nicht angewandt.
* en: * Maximum
Value. If this variable is other than 'null',
* a
numeric value entered must not be greater than the value defined
here.
* If the text-string (representing the value to
be checked) is empty (length 0)
* and the EntryRule
defines the field not as Mandatory,
* then the rule is
not applied. */ protected
BigDecimal bdMaximumValue
= null;/*
*
de:
* Anzahl der Dezimalstellen. Wenn dieser Wert anders als
'null' ist,
* dann darf ein eingegebener numerischer Wert
nicht mehr Dezimalstellen
* (Stellen hinter dem Komma) haben
als der hier definierte Wert.
* en: * Number
of Decimals. If this variable is other than 'null',
* a
numeric value entered is not allowed to have more decimal
places
* than the value defined here.
*/ protected
Integer
intNumberOfDecimals
= null;/*
*
de:
* Minimale Länge des Textes. Wenn dieser Wert
anders als 'null' ist,
* dann muß eine eingegeben
Zeichenkette mindestens die hier festgelegte
* Anzahl von
Zeichen enthalten.
* Wenn die eingebene Zeichenkette leer
ist und das Feld ist nicht als
* 'Mandatory' definiert ist,
dann wird diese Regel nicht angewandt. *
en:
* Minimum Length of text. If this variable is other
than 'null',
* a text-string entered must have at least
the number of characters
* as the value defined
here.
* If the text-string is empty (length 0) and the
EntryRule defines the field
* not as Mandatory, then
the rule is not applied. */ protected
Integer
intMinimumLength
= null;/*
*
de:
* Maximale Länge des Textes. Wenn dieser Wert
anders als 'null' ist,
* dann darf eine eingegeben
Zeichenkette nicht mehr als die hier festgelegte
* Anzahl
von Zeichen enthalten.
* Wenn die eingebene Zeichenkette
leer ist und das Feld ist nicht als
* 'Mandatory' definiert
ist, dann wird diese Regel nicht angewandt. *
en:
* Maximum Length of text. If this variable is other
than 'null',
* a text-string entered must not have more
than the number of characters
* as the value defined
here.
* If the text-string is empty (length 0) and the
EntryRule defines the field
* not as Mandatory, then
the rule is not applied. */ protected
Integer
intMaximumLength
= null;/*
*
de:
* Regel ob ein Text dem festgelegten Format
enspricht.
* Muss erst im Detail definiert werden (K.G.
2007-04-27). *
en:
* Rules to check if a text entered follows the defined
format.
* Needs further definition (K.G. 2007-04-27).
*/ protected
String
strEntryFormat
= null;
}/*
*
CONSTRUCTORS */
/*
* --------------------
* de:
Constructor wenn diese Klasse innerhalb des StartFrame verwendet
wird. *
en: Constructor when this class is implemented within the StartFrame.
*/ public
JSBS_EntryRules(JSBS_StartFrame
parmfrmCC) {/*
* de: Referenz auf das StartFrame auf die vorgehenen
Variable übertragen.
* en: Keep the reference to
the StartFrame in the variable defined. */ frmCC
= parmfrmCC;
}/*
*
--------------------
* de: Constructor wenn diese Klasse
innerhalb eines TaskFrame verwendet wird. *
en: Constructor when this class is implemented within a TaskFrame.
*/ public
JSBS_EntryRules(JSBS_TaskFrame
parmfrmParent) {/*
*
de: Referenz auf das TaskFrame auf die vorgehenen Variable
übertragen.
* en: Keep the reference to the
StartFrame in the variable defined. */ frmCC
= parmfrmParent.frmCC;
}/*
* METHODEN
/ METHODS */
/*
* --------------------
*
de:
* Methode zum Einfügen des Namen eines GUI-Element,
das innerhalb des
* Anwendungsprogramms als 'Mandatory' (mit
verpflichtender Eingabe)
* definiert wurde.
* Die
'Mandatory'-Definition aus dem Anwendungsprogramm ist 'stärker'
als
* die 'Mandatory'-Definition aus der Datei
'DisplayStrings.xml'.
* Mit der
'Application-Mandatory'-Definition können Eingaben in Felder,
*
die für die Verarbeitung im Anwendungsprogramm unbedingt
erforderlich sind,
* erzwungen werden.
* Solche
'unbedingt notwendige' Eingaben sind für Felder, die den
*
'Anwender-bekannten-Schlüssel' bilden.
* en: * Method
to add the Name of a GUI-Element that is defined as 'Mandatory'
*
(entry requiered) within the application-program.
* The
'Mandatory'-definition within the application-program is
'stronger'
* than the 'Mandatory'-definition within the file
'DisplayStrings.xml'.
* With the
'application-Mandatory'-definition the entry of values can be
forced
* for fields where an entry is inevitable for the
processing within the
* application-program.
* Such
'inevitable' entry can be requiered for field which value is a
part
* of the 'user-known-key'. */ public
void addApplicationMandatoryGUIElement(String
parmstrGUIElementName) {/*
de: Prüfen, dass der übergebene Parameter nicht 'null'
ist.
* en: Check that the passed parameter is not 'null'. */
if
(parmstrGUIElementName
== null)
return;/*
de:
* Prüfen, ob der Namen bereits im Vector
'vecApplicationMandatoryFields'
* enthalten ist. In diesem
Fall die Methode beenden.
* en:
* Check if the
name is already within the Vector 'vecApplicationmandatoryFields'.
*
End this method in that case. */ if
(checkApplicationMandatory(parmstrGUIElementName))
return;/*
de:
* Wenn das Programm bis hierher gekommen ist dann ist
der Name noch nicht
* im Vector enthalten; Name in den
Vector einfügen.
* en:
* If the program run
to this point, then the name is not already within the.
*
Vector; add the name to the Vector.
*/ vecApplicationMandatoryFields.addElement(parmstrGUIElementName);
}/*
* --------------------
*
de:
* 'Wrapper'-Methoden zum direkten Übergeben eines
GUI-Elements.
* en: * Methods
as wrappers to directly pass a GUI-Element.
*/ public void addApplicationMandatoryGUIElement(JTextField
parmJTextField)
{
addApplicationMandatoryGUIElement(parmJTextField.getName());
}/*
***** */ public void addApplicationMandatoryGUIElement(JTextArea
parmJTextArea)
{
addApplicationMandatoryGUIElement(parmJTextArea.getName());
}/*
***** */ public void addApplicationMandatoryGUIElement(JComboBox
parmJComboBox)
{
addApplicationMandatoryGUIElement(parmJComboBox.getName());
}/* --------------------
*
de:
* Methode zum Einfügen einer EntryRule in
vecEntryRules oder zum Ändern einer
* bestehenden
Regel.
* Für die Bedeutung der Parameter sehen Sie
bitte in der Inner-Class JSBS_EntryRule
* nach.
*
en:
* Method to add a EntryRule to vecEntryRules or change
an existing one.
* For the meaning of the parameters
see the Inner-Class JSBS_EntryRule, please. */ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
BigDecimal
parmbdMinimumValue,
BigDecimal
parmbdMaximumValue,
Integer
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/* de:
Prüfen, ob der übergebenen Parameter nicht 'null' ist.
*
en: Check that the passed parameter is not 'null'. */ if
(parmstrGUIElementName
== null)
return;/* de:
* Flag, ob eine neue EntryRule konstruiert werden muss oder
eine besthende geändert werden muss.
* en:
*
Flag if a new EntryRule has to be constructed or an existing one has
to be updated. */ boolean
bolCreateEntryRuleObject
= false;/* de:
* Ein Objekt für eine EntryRule definieren und prüfen,
ob diese EntryRule bereits im Vector existiert.
* en:
*
Define an object for an EntryRule and see if it is already within the
vector. */ JSBS_EntryRule
structJSBS_EntryRule =
getEntryRuleObject(parmstrGUIElementName);/* de:
Wenn der zurück gelieferte Wert 'null' war, dann muss ein neues
Objekt erstellt werden.
* en: If the returned value was
'null' a new object has to be created. */ if
(structJSBS_EntryRule
== null)
{/* de:
Den Merker setzen dass das neue Objekt später zum Vector
hinzugefügt werden muss.
* en: Set the flag to keep
in mind that the new object has to be added to the vector later.
*/ bolCreateEntryRuleObject
= true;/* de:
Ein neues Objekt erstellen.
* en: Create a new object.
*/ structJSBS_EntryRule
= new
JSBS_EntryRule();/* de:
Den Namen des GUI-Elements setzen um zu wissen wofür die
EntryRule gilt.
* en: Set the name of the GUI-element to
know where the new EntryRule is valid for.
*/ structJSBS_EntryRule.strGUIElementName
= parmstrGUIElementName;
}/*
* de:
* Jeden Parameter überprüfen ob
ein 'null'-Wert übergeben wurde; wenn der Wert nicht
*
'null' ist dann den Parameter-Wert auf das EntryRule-Objekt
übertragen.
* en:
* Check every
parameter if a 'null'-value was passed; if not 'null'
* then
transfer the parameter value to the EntryRule-object. */ if
(parmbolMandatory
!= null)
structJSBS_EntryRule.bolMandatory
= parmbolMandatory; if
(parmbdMinimumValue
!= null)
structJSBS_EntryRule.bdMinimumValue
= parmbdMinimumValue; if
(parmbdMaximumValue
!= null)
structJSBS_EntryRule.bdMaximumValue
= parmbdMaximumValue; if
(parmintNumberOfDecimals
!= null)
structJSBS_EntryRule.intNumberOfDecimals
= parmintNumberOfDecimals; if
(parmintMinimumLength
!= null)
structJSBS_EntryRule.intMinimumLength
= parmintMinimumLength; if
(parmintMaximumLength
!= null)
structJSBS_EntryRule.intMaximumLength
= parmintMaximumLength; if
(parmstrEntryFormat
!= null)
structJSBS_EntryRule.strEntryFormat
= parmstrEntryFormat;/*
* de:
* Wenn das Objekt mit den EntryRules neu konstruiert wurde
dann in den Vector einfügen.
* en:
* If the
object with the EntryRules was newly constructed then add it to the
vector. */ if
(bolCreateEntryRuleObject)
vecEntryRules.addElement(structJSBS_EntryRule);
}/*
* de: Abwandlungen der Methode mit verschiedenen Typen für
die Parameter.
* en: Derivations of the method with
different types for the parameters. */ public
void setEntryRuleValues(String
parmstrGUIElementName,
boolean
parmbolMandatory,
BigInteger
parmintMinimumValue,
BigInteger
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
new
Boolean(parmbolMandatory),
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
parmintMinimumLength,
parmintMaximumLength,
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
int
parmintMinimumValue,
BigInteger
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
parmintMinimumLength,
parmintMaximumLength,
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
BigInteger
parmintMinimumValue,
int
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
parmintMinimumLength,
parmintMaximumLength,
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
int
parmintMinimumValue,
int
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
parmintMinimumLength,
parmintMaximumLength,
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
BigInteger
parmintMinimumValue,
BigInteger
parmintMaximumValue,
int
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
new
Integer(parmintNumberOfDecimals),
parmintMinimumLength,
parmintMaximumLength,
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
BigInteger
parmintMinimumValue,
BigInteger
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
int
parmintMinimumLength,
Integer
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
new
Integer(parmintMinimumLength),
parmintMaximumLength,
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
BigInteger
parmintMinimumValue,
BigInteger
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
Integer
parmintMinimumLength,
int
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
parmintMinimumLength,
new
Integer(parmintMaximumLength),
parmstrEntryFormat);
}/* ***
*/ public
void setEntryRuleValues(String
parmstrGUIElementName,
Boolean
parmbolMandatory,
BigInteger
parmintMinimumValue,
BigInteger
parmintMaximumValue,
Integer
parmintNumberOfDecimals,
int
parmintMinimumLength,
int
parmintMaximumLength,
String
parmstrEntryFormat) {/*
* de:
* Parameter in jene Typen, die von der
Kern-Methode benötigt werden, umwandeln
* und die
Kern-Methode aufrufen.
* en:
* Convert the
parameters to the type needed by the core-method and call the
core-method. */ setEntryRuleValues(parmstrGUIElementName,
parmbolMandatory,
new
BigDecimal(parmintMinimumValue),
new
BigDecimal(parmintMaximumValue),
parmintNumberOfDecimals,
new
Integer(parmintMinimumLength),
new
Integer(parmintMaximumLength),
parmstrEntryFormat);
}/*
* --------------------
*
de:
* Methode zum Entfernen der Prüfregeln (EntryRule)
für ein GUI-Element. *
en:
* Method to remove the verification-rules (EntryRule)
for a GUI-element. */ public void
removeEntryRule(String
parmstrGUIElementName) {/*
de: Prüfen, dass der übergebene Parameter nicht 'null'
ist.
* en: Check that the passed parameter is not 'null'. */
if (parmstrGUIElementName
== null)
return;/*
de:
* Durchsuchen des Vector ob für das im
Parameter übergebene GUI-Element eine
* Prüfregel
(EntryRule) enthalten ist.
* en:
* Search the
Vector if a verification-rule (EntryRule) is present for the
GUI-element
* passed as parameter. */ int
intVectorSize
= vecEntryRules.size(); JSBS_EntryRule
locJSBS_EntryRule;
for
(int
intVectorIndex
= intVectorSize - 1; intVectorIndex >= 0; intVectorIndex--)
{
locJSBS_EntryRule
= (JSBS_EntryRule) vecEntryRules.elementAt(intVectorIndex);/*
de:
* Vergleichen ob der gesuchte Name (als Parameter
übergeben) jener ist,
* der aus dem Vector-Element
ausgelesen wurde und das Vector-Element aus
* dem Vector
entfernen wenn der Vergleich stimmt.
* en:
* Compare
if the searched name (passed as parameter) is matching the one of the
* vector-element. If matching, remove the
vector-element out of the vector. */ if
(locJSBS_EntryRule.strGUIElementName.compareTo(parmstrGUIElementName)
== 0) vecEntryRules.removeElementAt(intVectorIndex);
}
}/*
* --------------------
*
de:
* Methoden zum Prüfen ob ein Eingabe-Feld eine
verpflichtende ('Mandatory')
* erfordert.
* In
diesen Methoden werden die Methoden zum Prüfen der im Programm
(Application)
* definierten und der über die XML-Datei
(Parameterized) definierten Felder
* aufgerufen. *
en:
* Methods to verify if a Entry-Field needs a mandatory
entry.
* Within this method, the methods to verify the
entry-fields defined within
* the apllication an in the
XML-file (parameterized) are called. */ public boolean
checkMandatory(String
parmGUIElementName)
{
return (checkApplicationMandatory(parmGUIElementName)
|| checkParameterizedMandatory(parmGUIElementName));
}/*
***** */ public boolean
checkMandatory(JTextField
parmJTextField)
{
return (checkApplicationMandatory(parmJTextField.getName())
|| checkParameterizedMandatory(parmJTextField.getName()));
}/*
***** */ public boolean
checkMandatory(JTextArea parmJTextArea)
{
return (checkApplicationMandatory(parmJTextArea.getName())
|| checkParameterizedMandatory(parmJTextArea.getName()));
}/*
***** */ public boolean
checkMandatory(JComboBox parmJComboBox)
{
return (checkApplicationMandatory(parmJComboBox.getName())
||
checkParameterizedMandatory(parmJComboBox.getName()));
}/* * --------------------
*
de:
* Methode zum Prüfen ob ein GUI-Element innerhalb
des Anwendungsprogramms
* als 'Mandatory' (mit
verpflichtender Eingabe) definiert wurde.
* (Das geschieht
durch die Methode 'addApplicationMandatoryGUIElement(...)'.)
*
Die Methode liefert 'true' zurück wenn der - im Parameter
übergebene - Namen
* des GUI-Elements im Vector
'vecApplicationMandatoryFields' enthalten ist.
*
en: * Method
to check if a GUI-element is defined as 'Mandatory' (input
requiered)
* within the application.
* (The
definition is done with method
'addApplicationMandatoryGUIElement(...)'.)
* The method
return 'true' if the Name of the GUI-Element - passed in the
*
parameter - is contained within the Vector
'vecApplicationMandatoryFields'.
* */ public
boolean checkApplicationMandatory(String
parmstrGUIElementName) {/*
de: Prüfen, dass der übergebene Parameter nicht 'null'
ist.
* en: Check that the passed parameter is not 'null'. */
if
(parmstrGUIElementName
== null)
return
false;/*
de: Zeichenkette für den Namen des GUI-Element-Namen aus dem
Vector.
* en: String holding the GUI-Element-name derived
from the Vector. */ String
strGUIElementName; /*
de:
* Durchsuchen des Vector if die als Parameter
übergebene Zeichenkette
* enthalten ist.
* en:
* Search the Vector if the string passed as parameter
is alredy there. */ int
intVectorSize
= vecApplicationMandatoryFields.size();
for
(int
intVectorIndex
= 0; intVectorIndex < intVectorSize; intVectorIndex++)
{
strGUIElementName
= (String)
vecApplicationMandatoryFields.elementAt(intVectorIndex);/*
de:
* Vergleichen ob der gesuchte Name (als Parameter
übergeben) jener ist,
* der aus dem Vector ausgelesen
wurde und 'true' zurückliefern wenn der
* Vergleich
stimmt.
* en:
* Compare if the searched name
(passed as parameter)
* is the one out of the vector
and return 'true' if matching. */ if
(strGUIElementName.compareTo(parmstrGUIElementName.trim())
== 0) return
true;
}/*
de: Name des gesuchten GUI-Elements nicht im Vector; 'false'
zurückliefern.
* en: Name of the searched GUI-element
not within the vector; return false. */ return
false;
}/*
* --------------------
*
de:
* Methode zum Prüfen ob ein Eingabe-Feld eine
verpflichtende ('Mandatory')
* erfordert. *
en:
* Method to verify if a Entry-Field needs a mandatory
entry. */ public
boolean checkParameterizedMandatory(String
parmstrGUIElementName) {/*
de: Prüfen dass der übergebene Parameter nicht 'null'
ist.
* en: Check that the passed parameter is not 'null'. */
if
(parmstrGUIElementName
== null)
return
false;/*
* de:
* Prüfen, ob das Feld in der
XML-Struktur in der Datei
* 'DisplayStrings.xml' als
'Mandatory' definiert ist.
* en:
* Verify if the
field is defined as 'Mandatory' within the
* XML-structure
in the file 'DisplayStrings.xml'. */ /*
* de: EntryRule-Objekt für den übergebenen
GUI-Element-Namen 'holen'.
* en: Get the EntryRule-object
for the passed GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: 'false' zurückliefern wenn keine EntryRule definiert ist.
*
en: Return false if no EntryRule defined. */ if
(structJSBS_EntryRule
== null)
return
false;/*
de:
* 'false' zurückliefern wenn keine Regel für
'Mandatory' in der EntryRule
* definiert ist.
*
en:
* Return false if 'Mandatory' in the EntryRule is not
already set. */ if
(structJSBS_EntryRule.bolMandatory
== null)
return
false;/*
de:
* Wenn das Programm bis hierher gekommen ist dann ist
eine Regel für
* 'Mandatory' festgelegt; diese
zurückliefern.
* en:
* Program running till
here means that 'Mandatory'-rule in the EntryRule was set;
*
return the value. */ return
structJSBS_EntryRule.bolMandatory.booleanValue();
}/*
* --------------------
*
de:
* Methode zum Prüfen ob der Wert nicht größer
ist als der erlaubte
* Maximal-Wert für das Feld.
*
Die Methode liefert 'true' zurück wenn der übergebene Wert
kleiner oder
* gleich als der erlaubte Maximal-Wert ist.
*
en: * Method
to verify if the value is not greater than the permitted maximum
value
* for the field.
* Method returns 'true'
if the passed value is less than or equal
* to the defined
maximum value. */ public
boolean checkMaximumValue(String
parmstrGUIElementName,
BigDecimal
parmbdValue) {/*
de: Prüfen, dass die übergebenen Parameter nicht 'null'
sind.
* en: Check that the passed parameters are not
'null'. */ if
(parmstrGUIElementName
== null)
return
false;
if
(parmbdValue
== null)
return
false;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: 'true' (Bedingung erfüllt) zurückliefern wenn keine
Entry-Rule existiert.
* en: Return 'true' (fulfilled) if no
EntryRule defined. */ if
(structJSBS_EntryRule
== null)
return
true;/* de:
'true' (Bedingung erfüllt) zurückliefern wenn kein
'Maximal-Wert' definiert ist.
* en: Return true if
'MaximumValue' in the EntryRule is not already set. */ if
(structJSBS_EntryRule.bdMaximumValue
== null)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist ein 'Maximal-Wert'
* in der EntryRule definiert; diesen
mit dem Parameter-Wert vergleichen.
* en:
* Come
till here means that MaximumValue in the EntryRule was set;
* compare with the parameter. */ if
(parmbdValue.compareTo(structJSBS_EntryRule.bdMaximumValue)
<= 0) return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist der Parameter-Wert
* größer als der in
der EntryRule definiert 'Maximal-Wert'.
* 'false'
zurückliefern weil die Prüfbedingung nicht erfüllt
ist
* en:
* Come till here means that the value
passed as parameter is greater than
* the 'maximum-value'
defined in the EntryRule.
* Return 'false' because the check
failed. */ return
false;
}/*
* --------------------
*
de:
* 'Wrapper'-Methoden zum Übergeben des
Vergleichswertes als anderer Typ.
* en: * Methods
as wrappers to pass other types for the value to be compared.
*/ public
boolean checkMaximumValue(String
parmstrGUIElementName,
BigInteger parmintValue)
{
return
checkMaximumValue(parmstrGUIElementName,
new
BigDecimal(parmintValue));
} public
boolean checkMaximumValue(String
parmstrGUIElementName,
Integer parmintValue) {
return
checkMaximumValue(parmstrGUIElementName,
new
BigDecimal(parmintValue));
} public
boolean checkMaximumValue(String
parmstrGUIElementName,
int parmintValue) {
return
checkMaximumValue(parmstrGUIElementName,
new BigDecimal(parmintValue));
}/*
* --------------------
*
de:
* Methode zum Prüfen ob der Wert nicht kleiner ist
als der erlaubte
* Minimal-Wert für das Feld.
*
Die Methode liefert 'true' zurück wenn der übergebene Wert
gleich oder
* größer als der erlaubte
Minimal-Wert ist.
* en: * Method
to verify if the value is not less than the permitted minimum
value
* for the field.
* Method returns 'true'
if the passed value is greater or equal
* to the defined
minimum value. */ public
boolean checkMinimumValue(String
parmstrGUIElementName,
BigDecimal
parmbdValue) {/*
de: Prüfen, dass die übergebenen Parameter nicht 'null'
sind.
* en: Check that the passed parameters are not
'null'. */ if
(parmstrGUIElementName
== null)
return
false;
if
(parmbdValue
== null)
return
false;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: 'true' (Bedingung erfüllt) zurückliefern wenn keine
Entry-Rule existiert.
* en: Return 'true' (fulfilled) if no
EntryRule defined. */ if
(structJSBS_EntryRule
== null)
return
true;/* de:
'true' (Bedingung erfüllt) zurückliefern wenn kein
'Minimal-Wert' definiert ist.
* en: Return true if
'MinimumValue' in the EntryRule is not already set. */ if
(structJSBS_EntryRule.bdMinimumValue
== null)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist ein 'Minimal-Wert'
* in der EntryRule definiert; diesen
mit dem Parameter-Wert vergleichen.
* en:
* Come
till here means that MinimumValue in the EntryRule was set;
* compare with the parameter. */ if
(parmbdValue.compareTo(structJSBS_EntryRule.bdMinimumValue)
>= 0) return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist der Parameter-Wert
* kleiner als der in der
EntryRule definiert 'Minimal-Wert'.
* 'false' zurückliefern
weil die Prüfbedingung nicht erfüllt ist
* en:
*
Come till here means that the value passed as parameter is less than
* the 'minimum-value' defined in the EntryRule.
*
Return 'false' because the check failed. */ return
false;
}/*
* --------------------
*
de:
* 'Wrapper'-Methoden zum Übergeben des
Vergleichswertes als anderer Typ.
* en: * Methods
as wrappers to pass other types for the value to be compared.
*/ public
boolean checkMinimumValue(String
parmstrGUIElementName,
BigInteger parmintValue)
{
return
checkMinimumValue(parmstrGUIElementName,
new
BigDecimal(parmintValue));
} public
boolean checkMinimumValue(String
parmstrGUIElementName,
Integer parmintValue) {
return
checkMinimumValue(parmstrGUIElementName,
new
BigDecimal(parmintValue));
} public
boolean checkMinimumValue(String
parmstrGUIElementName,
int parmintValue) {
return
checkMinimumValue(parmstrGUIElementName,
new
BigDecimal(parmintValue));
}/*
* --------------------
*
de:
* Methode zum Prüfen ob die Anzahl der Stellen nach
dem Komma innerhalb des
* festgelegten Wertes bleibt.
*
Die Methode liefert 'true' zurück wenn die Anzahl der
Dezimalstellen des
* BigDecimal-Wertes kleiner oder
gleich dem erlaubten Wert ist.
* en: * Method
to verify if the number of decimals is within the specified
value.
* Method returns 'true' if the number of
decimals of the BigDecimal-value
* is less than or equal to
the permitted value. */ public
boolean checkNumberOfDecimals(String
parmstrGUIElementName,
BigDecimal
parmbdValue) {/*
de: Prüfen, dass die übergebenen Parameter nicht 'null'
sind.
* en: Check that the passed parameters are not
'null'. */ if
(parmstrGUIElementName
== null)
return
false;
if
(parmbdValue
== null)
return
false;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: 'true' (Bedingung erfüllt) zurückliefern wenn keine
Entry-Rule existiert.
* en: Return 'true' (fulfilled) if no
EntryRule defined. */ if
(structJSBS_EntryRule
== null)
return
true;/* de:
'true' (Bedingung erfüllt) zurückliefern wenn kein Wert für
die 'Anzahl der Kommastellen'
* definiert ist.
*
en: Return true if 'NumberOfDecimals' in the EntryRule is not already
set. */ if
(structJSBS_EntryRule.intNumberOfDecimals
== null)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist ein Wert für die 'Anzahl der Kommastellen'
* in der
EntryRule definiert; diesen mit den Kommastellen aus dem
Parameter-Wert vergleichen.
* en:
* Coming till
here means that NumberOfDecimals in the EntryRule was set;
* compare with the number of decimals in the
parameter. */ if
(parmbdValue.scale()
<= structJSBS_EntryRule.intNumberOfDecimals.intValue())
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist die Anzahl der Kommastellen im Parameter-Wert
*
größer als der in der EntryRule definierte Wert für
'NumberOfDecimals'.
* 'false' zurückliefern weil die
Prüfbedingung nicht erfüllt ist
* en:
*
Come till here means that the number of decimals of the value passed
as parameter is greater than
* the 'number of decimals'
defined in the EntryRule.
* Return 'false' because the check
failed. */ return
false;
}/*
* --------------------
*
de:
* Methode zum Prüfen, ob der übergebene Wert
innerhalb des definierten Minimums
* und Maximums ist und
(bei BigDecimal) nicht zu viele Kommastellen enthält.
*
Die Methode liefert 'true' zurück wenn der zu prüfende Wert
gleich oder
* größer dem definierten
Minimal-Wert und kleiner oder gleich dem definierten
*
Maximal-Wert ist.
* Es sind mehrere Methoden mit
verschiedenen Typen für den zu vergleichenden
* Wert
implementiert.
* en: * Method
to check that the passed value is within the defined minimum and
maximum *
and (in case of BigDecimal) the number of decimals is not
exceeded.
* Method returns 'true' if the passed value
is greater or equal the defined minimum
* value and
less than or equal the defined maximum value.
* There
are several methods with different types for the value to be
compared. */ public
boolean checkValueRange(String
parmstrGUIElementName,
BigDecimal parmbdValue) {
return (
(checkMinimumValue(parmstrGUIElementName,
parmbdValue))
&&
(checkMaximumValue(parmstrGUIElementName,
parmbdValue))
&&
(checkNumberOfDecimals(parmstrGUIElementName,
parmbdValue)));
} public
boolean checkValueRange(String
parmstrGUIElementName,
BigInteger parmintValue) {
return (
(checkMinimumValue(parmstrGUIElementName,
parmintValue))
&&
(checkMaximumValue(parmstrGUIElementName,
parmintValue)));
} public
boolean checkValueRange(String
parmstrGUIElementName,
Integer parmintValue) {
return (
(checkMinimumValue(parmstrGUIElementName,
parmintValue))
&&
(checkMaximumValue(parmstrGUIElementName,
parmintValue)));
} public
boolean checkValueRange(String
parmstrGUIElementName,
int parmintValue) {
return (
(checkMinimumValue(parmstrGUIElementName,
parmintValue))
&&
(checkMaximumValue(parmstrGUIElementName,
parmintValue)));
}/*
* --------------------
*
de:
* Methode zum Prüfen ob die Länge der
eingegebenen Zeichenkette nicht kürzer
* ist als
die erlaubte Minimal-Länge für das Feld.
* Die
Methode liefert 'true' zurück wenn der übergebene Wert
gleich oder
* größer als der erlaubte
Minimal-Wert ist.
* en: * Method
to verify if the length of an entered string is not less
*
than the permitted minimum value for the field.
* Method
returns 'true' if the passed value is greater or equal
* to
the defined minimum value. */ public
boolean checkMinimumLength(String
parmstrGUIElementName,
Integer
parmintValue) {/*
de: Prüfen, dass die übergebenen Parameter nicht 'null'
sind.
* en: Check that the passed parameters are not
'null'. */ if
(parmstrGUIElementName
== null)
return
false;
if
(parmintValue
== null)
return
false;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: 'true' (Bedingung erfüllt) zurückliefern wenn keine
Entry-Rule existiert.
* en: Return 'true' (fulfilled) if no
EntryRule defined. */ if
(structJSBS_EntryRule
== null)
return
true;/* de:
'true' (Bedingung erfüllt) zurückliefern wenn kein
'Minimal-Wert' definiert ist.
* en: Return true if
'MinimumValue' in the EntryRule is not already set. */ if
(structJSBS_EntryRule.intMinimumLength
== null)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist eine 'Minimal-Länge'
* in der EntryRule definiert;
diesen mit dem Parameter-Wert vergleichen.
* en:
*
Come till here means that MinimumLength in the EntryRule was set;
* compare with the parameter. */ if
(parmintValue.compareTo(structJSBS_EntryRule.intMinimumLength)
>= 0)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist der Parameter-Wert
* kleiner als die in der
EntryRule definiert 'Minimal-Länge'.
* 'false'
zurückliefern weil die Prüfbedingung nicht erfüllt
ist
* en:
* Come till here means that the value
passed as parameter is less than
* the 'minimum-length'
defined in the EntryRule.
* Return 'false' because the check
failed. */ return
false;
}/*
* --------------------
*
de:
* 'Wrapper'-Methoden zum Übergeben des
Vergleichswertes als anderer Typ.
* en: * Methods
as wrappers to pass other types for the value to be compared.
*/ public
boolean checkMinimumLength(String
parmstrGUIElementName,
int
parmintValue) {
return
checkMinimumLength(parmstrGUIElementName,
new Integer(parmintValue));
}/*
* --------------------
*
de:
* Methode zum Prüfen ob die Länge der
eingegebenen Zeichenkette nicht länger
* ist als
die erlaubte Maximal-Länge für das Feld.
* Die
Methode liefert 'true' zurück wenn der übergebene Wert
gleich oder
* kleiner als der erlaubte Maximal-Wert ist.
*
en: * Method
to verify if the length of an entered string is not greater
*
than the permitted maximum length for the field.
* Method
returns 'true' if the passed value is smaller or equal
* to
the defined maximum length. */ public
boolean checkMaximumLength(String
parmstrGUIElementName,
Integer
parmintValue) {/*
de: Prüfen, dass die übergebenen Parameter nicht 'null'
sind.
* en: Check that the passed parameters are not
'null'. */ if
(parmstrGUIElementName
== null)
return
false;
if
(parmintValue
== null)
return
false;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: 'true' (Bedingung erfüllt) zurückliefern wenn keine
Entry-Rule existiert.
* en: Return 'true' (fulfilled) if no
EntryRule defined. */ if
(structJSBS_EntryRule
== null)
return
true;/* de:
'true' (Bedingung erfüllt) zurückliefern wenn kein
'Maximal-Wert' definiert ist.
* en: Return true if
'MaximumValue' in the EntryRule is not already set. */ if
(structJSBS_EntryRule.intMaximumLength
== null)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist eine 'Maximal-Länge'
* in der EntryRule definiert;
diesen mit dem Parameter-Wert vergleichen.
* en:
*
Come till here means that MaximumLength in the EntryRule was set;
* compare with the parameter. */ if
(parmintValue.compareTo(structJSBS_EntryRule.intMaximumLength)
<= 0)
return
true;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist der Parameter-Wert
* größer als die in
der EntryRule definiert 'Maximal-Länge'.
* 'false'
zurückliefern weil die Prüfbedingung nicht erfüllt
ist
* en:
* Come till here means that the value
passed as parameter is greater than
* the 'maximum-length'
defined in the EntryRule.
* Return 'false' because the check
failed. */ return
false;
}/*
* --------------------
*
de:
* 'Wrapper'-Methoden zum Übergeben des
Vergleichswertes als anderer Typ.
* en: * Methods
as wrappers to pass other types for the value to be compared.
*/ public
boolean checkMaximumLength(String
parmstrGUIElementName,
int
parmintValue) {
return
checkMaximumLength(parmstrGUIElementName,
new Integer(parmintValue));
}/*
* --------------------
*
de:
* Methode zum Prüfen, ob der übergebene Wert
innerhalb des definierten
* Minimums und Maximums für
die Länge einer Zeichenkette ist.
* Die Methode liefert
'true' zurück wenn der zu prüfende Wert gleich oder
*
größer dem definierten Minimal-Wert und kleiner oder
gleich dem definierten
* Maximal-Wert ist.
* Es
sind mehrere Methoden mit verschiedenen Typen für den zu
vergleichenden
* Wert implementiert.
*
en: * Method
to check that the passed value is within the defined minimum and
maximum *
for a string of characters.
* Method returns 'true' if
the passed value is greater or equal the defined minimum
* value and
less than or equal the defined maximum value.
* There
are several methods with different types for the value to be
compared. */ public
boolean checkLengthRange(String
parmstrGUIElementName,
int
parmintValue) {
return (
(checkMinimumLength(parmstrGUIElementName,
parmintValue))
&&
(checkMaximumLength(parmstrGUIElementName,
parmintValue)));
}/*
* --------------------
*
de:
* Methode zum 'Holen' des minimal erlaubten
Eingabewertes aus der
* Prüf-Regel für das
GUI-Element, dessen Name im Parameter übergeben wurde.
*
Wenn keine Prüf-Regel definiert ist oder bei der Prüf-Regel
kein
* Minimal-Wert festgelegt ist, dann wird der in Java
festgelegte
* kleinste Wert für die Klasse 'Integer'
zurückgeliefert.
* en: * Method
to 'get' the lowest permitted value to be entered out of the
*
Entry-Rule for the GUI-Element which name is passed as parameter.
*
If no Entry-Rule is defined or no Minimum-Value is defined with
the
* Entry-Rule, then the smallest value for the class
'Integer' (as defined
* within Java) is returned.
*/ public BigDecimal
getMinimumValue(String parmstrGUIElementName) {/*
de: * Prüfen,
dass der übergebene Parameter nicht 'null' ist. *
Bei 'null' den kleinsten in Java definierten Wert für die Klasse
'Integer' *
zurückliefern.
* en: * Check
that the passed parameter is not 'null'. *
If 'null', then return the smallest defined value for class
'Integer'. */ if
(parmstrGUIElementName
== null)
return
new BigDecimal(Integer.MIN_VALUE);/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: *
Wenn die gesuchte Prüf-Regel nicht definiert ist dann den
kleinsten in Java *
definierten Wert für die Klasse 'Integer'zurückliefern.
* en:
*
If the requested EntryRule is not defined, *
then return the smallest defined value for class 'Integer'. */
if
(structJSBS_EntryRule
== null)
return
new BigDecimal(Integer.MIN_VALUE);/*
de: *
Wenn die gesuchte Prüf-Regel existiert aber kein Minimal-Wert
definiert ist dann *
ebenfalls den kleinsten in Java definierten Wert für die
Klasse *
'Integer'zurückliefern.
* en: *
If the requested EntryRule exists but a Minimum-Value is not
defined, *
then return the smallest defined value for class 'Integer', too. */
if
(structJSBS_EntryRule.bdMinimumValue
== null)
return
new BigDecimal(Integer.MIN_VALUE);/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist ein 'Minimal-Wert'
* in der EntryRule definiert; diesen
zurückliefern.
* en:
* Come till here means
that MinimumValue in the EntryRule was set;
* return this
value. */ return
structJSBS_EntryRule.bdMinimumValue;
}/*
* --------------------
*
de:
* Methode zum 'Holen' des maximal erlaubten
Eingabewertes aus der
* Prüf-Regel für das
GUI-Element, dessen Name im Parameter übergeben wurde.
*
Wenn keine Prüf-Regel definiert ist oder bei der Prüf-Regel
kein
* Maximal-Wert festgelegt ist, dann wird der in Java
festgelegte
* größte Wert für die Klasse
'Integer' zurückgeliefert.
* en: * Method
to 'get' the highest permitted value to be entered out of the
*
Entry-Rule for the GUI-Element which name is passed as parameter.
*
If no Entry-Rule is defined or no Maximum-Value is defined with
the
* Entry-Rule, then the biggest value for the class
'Integer' (as defined
* within Java) is returned.
*/ public BigDecimal
getMaximumValue(String parmstrGUIElementName) {/*
de: * Prüfen,
dass der übergebene Parameter nicht 'null' ist. *
Bei 'null' den größten in Java definierten Wert für
die Klasse 'Integer' *
zurückliefern.
* en: * Check
that the passed parameter is not 'null'. *
If 'null', then return the biggest defined value for class 'Integer'.
*/ if
(parmstrGUIElementName
== null)
return
new BigDecimal(Integer.MAX_VALUE);/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: *
Wenn die gesuchte Prüf-Regel nicht definiert ist dann den
größten in Java *
definierten Wert für die Klasse 'Integer'zurückliefern.
* en:
*
If the requested EntryRule is not defined, *
then return the biggest defined value for class 'Integer'. */
if
(structJSBS_EntryRule
== null)
return
new BigDecimal(Integer.MAX_VALUE);/*
de: *
Wenn die gesuchte Prüf-Regel existiert aber kein Maximal-Wert
definiert ist dann *
ebenfalls den größten in Java definierten Wert für
die Klasse *
'Integer' zurückliefern.
* en: *
If the requested EntryRule exists but a Maximum-Value is not
defined, *
then return the biggest defined value for class 'Integer', too. */
if
(structJSBS_EntryRule.bdMaximumValue
== null)
return
new BigDecimal(Integer.MAX_VALUE);/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist ein 'Maximal-Wert'
* in der EntryRule definiert; diesen
zurückliefern.
* en:
* Come till here means
that MaximumValue in the EntryRule was set;
* return this
value. */ return
structJSBS_EntryRule.bdMaximumValue;
}/*
* --------------------
*
de:
* Methode zum 'Holen' der maximal erlaubten Anzahl der
Dezimalstellen aus der
* Prüf-Regel für das
GUI-Element, dessen Name im Parameter übergeben wurde.
*
Wenn keine Prüf-Regel definiert ist oder bei der Prüf-Regel
kein
* Wert für die Anzahl der Dezimalstellen
festgelegt ist, dann wird der in Java
* festgelegte größte
Wert für die Klasse 'Integer' zurückgeliefert.
*
en: * Method
to 'get' the highest permitted number of decimal digits to be entered
out of the
* Entry-Rule for the GUI-Element which name
is passed as parameter.
* If no Entry-Rule is defined or no
value for the decimal digits is defined with the
*
Entry-Rule, then the biggest value for the class 'Integer' (as
defined
* within Java) is returned. */ public Integer
getNumberOfDecimals(String parmstrGUIElementName) {/*
de: * Prüfen,
dass der übergebene Parameter nicht 'null' ist. *
Bei 'null' den größten in Java definierten Wert für
die Klasse 'Integer' *
zurückliefern.
* en: * Check
that the passed parameter is not 'null'. *
If 'null', then return the biggest defined value for class 'Integer'.
*/ if
(parmstrGUIElementName
== null)
return
new Integer(Integer.MAX_VALUE);/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: *
Wenn die gesuchte Prüf-Regel nicht definiert ist dann den
größten in Java *
definierten Wert für die Klasse 'Integer'zurückliefern.
* en:
*
If the requested EntryRule is not defined, *
then return the biggest defined value for class 'Integer'. */
if
(structJSBS_EntryRule
== null)
return
new Integer(Integer.MAX_VALUE);/*
de: *
Wenn die gesuchte Prüf-Regel existiert aber kein Wert für
die Anzahl der Dezimalstellen *
definiert ist dannebenfalls den größten in
Java definierten Wert für die Klasse *
'Integer' zurückliefern.
* en: *
If the requested EntryRule exists but a value for the decimal digits
is not defined, *
then return the biggest defined value for class 'Integer', too. */
if
(structJSBS_EntryRule.intNumberOfDecimals
== null)
return
new Integer(Integer.MAX_VALUE);/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist ein Wert für die Anzahl der Dezimalstellen
* in der
EntryRule definiert; diesen zurückliefern.
* en:
*
Come till here means that NumberOfDecimals in the EntryRule was set;
* return this value. */ return
structJSBS_EntryRule.intNumberOfDecimals;
}/*
* --------------------
*
de:
* Methode zum 'Holen' der minimal erlaubten Länge
für eine eingegebene
* Zeichenkette aus der Prüf-Regel
für das GUI-Element dessen Name
* im Parameter
übergeben wurde.
* Wenn keine Prüf-Regel definiert
ist oder bei der Prüf-Regel keine
* Minimal-Länge
festgelegt ist, dann wird der Wert '0' zurückgeliefert.
*
en: * Method
to 'get' the shortest permitted length of a string to be entered
*
for the GUI-Element which name is passed as parameter out of the
*
Entry-Rule.
* If no Entry-Rule is defined or no
Minimum-Length is defined with the
* Entry-Rule, then the
value '0' is returned. */ public
int
getMinimumLength(String parmstrGUIElementName) {/*
de: * Prüfen,
dass der übergebene Parameter nicht 'null' ist. *
Bei 'null' wird der Wert '0' zurückgeliefert.
* en:
* Check
that the passed parameter is not 'null'. *
If 'null', then return '0'. */ if
(parmstrGUIElementName
== null)
return 0;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: *
Wenn die gesuchte Prüf-Regel nicht definiert ist dann '0'
zurückliefern.
* en: *
If the requested EntryRule is not defined, *
then return '0'. */ if
(structJSBS_EntryRule
== null)
return 0;/*
de: *
Wenn die gesuchte Prüf-Regel existiert aber keine Minimal-Länge
definiert ist *
dann ebenfalls '0' zurückliefern.
* en: *
If the requested EntryRule exists but a Minimum-Length is not
defined, *
then return '0', too. */ if
(structJSBS_EntryRule.intMinimumLength
== null)
return 0;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist eine 'Minimal-Länge'
* in der EntryRule definiert;
diese zurückliefern.
* en:
* Come till here
means that MinimumLength in the EntryRule was set;
* return
this value. */ return
structJSBS_EntryRule.intMinimumLength;
}/*
* --------------------
*
de:
* Methode zum 'Holen' der maximal erlaubten Länge
für eine eingegebene
* Zeichenkette aus der Prüf-Regel
für das GUI-Element dessen Name
* im Parameter
übergeben wurde.
* Wenn keine Prüf-Regel definiert
ist oder bei der Prüf-Regel keine
* Maximal-Länge
festgelegt ist, dann wird der in Java festgelegte
* größte
Wert für die Klasse 'Integer' zurückgeliefert.
*
en: * Method
to 'get' the maximal permitted length of a string to be entered
*
out of the Entry-Rule for the GUI-Element which name is passed
as parameter.
* If no Entry-Rule is defined or no
Maximum-Length is defined with the
* Entry-Rule, then the
biggest value for the class 'Integer' (as defined
* within
Java) is returned. */ public
int
getMaximumLength(String parmstrGUIElementName) {/*
de: * Prüfen,
dass der übergebene Parameter nicht 'null' ist. *
Bei 'null' den größten in Java definierten Wert für
die Klasse 'Integer' *
zurückliefern.
* en: * Check
that the passed parameter is not 'null'. *
If 'null', then return the biggest defined value for class 'Integer'.
*/ if
(parmstrGUIElementName
== null) return Integer.MAX_VALUE;/*
de: EntryRule-Objekt für den übergebenen GUI-Element-Namen
holen.
* en: Get the EntryRule-object for the passed
GUI-element-name. */ JSBS_EntryRule
structJSBS_EntryRule = getEntryRuleObject(parmstrGUIElementName);/*
de: *
Wenn die gesuchte Prüf-Regel nicht definiert ist dann den
größten in Java *
definierten Wert für die Klasse 'Integer' zurückliefern.
* en:
*
If the requested EntryRule is not defined, *
then return the biggest defined value for class 'Integer'. */
if
(structJSBS_EntryRule
== null) return Integer.MAX_VALUE;/*
de: *
Wenn die gesuchte Prüf-Regel existiert aber keine Maximal-Länge
definiert ist, *
dann ebenfalls den größten in Java definierten Wert
für die Klasse *
'Integer'zurückliefern.
* en: *
If the requested EntryRule exists but a Maximum-Length is not
defined, *
then return the biggest defined value for class 'Integer', too. */
if
(structJSBS_EntryRule.intMaximumLength
== null) return Integer.MAX_VALUE;/*
de:
* Wenn der Algorithmus bis hierher gekommen ist, dann
ist eine 'Maximal-Länge'
* in der EntryRule definiert;
diesen Wert zurückliefern.
* en:
* Come till
here means that a MaximumLength in the EntryRule was set;
*
return this value. */ return
structJSBS_EntryRule.intMaximumLength;
}/* --------------------
*
de:
* Methode zum 'Herausholen' der EntryRule für einen
gegebenen Namen eins GUI-Elements.
* Die Methode liefer
'null' zurück wenn keine EntryRule definiert ist.
*
en: *
Method to get the EntryRule for the given GUI-element name.
*
Method returns 'null' if an EntryRule is not defined. */ private
JSBS_EntryRule
getEntryRuleObject(String
parmstrGUIElementName) {/*
de: Prüfen, dass der übergebene Parameter nicht 'null'
ist.
* en: Check that the passed parameter is not 'null'. */
if
(parmstrGUIElementName
== null)
return
null;/*
de: Struktur zum halten einer EntryRule aus dem Vector.
*
en: Structure holding one EntryRule out of the vector.
*/ JSBS_EntryRule
structJSBS_EntryRule =
null;/*
de:
* Durchsuchen des Vectors ob die als Parameter
übergebene Zeichenkette enthalten ist.
* en:
*
Search the vector if the string passed as parameter is alredy there.
*/ int
intVectorSize
= vecEntryRules.size();
for
(int
intVectorIndex
= 0; intVectorIndex < intVectorSize; intVectorIndex++)
{
structJSBS_EntryRule
= (JSBS_EntryRule) vecEntryRules.elementAt(intVectorIndex);/*
de:
* Vergleichen ob der gesuchte Name jener innerhalb des
Vectors ist und 'true' zurück liefern
* wenn der
Vergleich erfolgreich ist.
* en:
* Compare if the
searched name is the one out of the vector and return 'true' if
matching. */ if
(structJSBS_EntryRule.strGUIElementName.compareTo(parmstrGUIElementName.trim())
== 0)
return
structJSBS_EntryRule;
}/*
de: Keine passende EntryRule gefunden; 'null' zurück liefern.
*
en: No matching EntryRule found; return 'null'. */ return
null;
}
}
xxx
|
Dokument |
Inhalt |
|
Dieser
Leitfaden enthält die notwendigen Tätigkeiten für
die Entwicklung eines StartFrame (auch als Command-Center
bekannt). |