|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.frame;/*
*
de:
* Package und Klasse für die Bearbeitung eines
Vectors.
* Damit werden die Texte, die in einer Combobox
angezeigt werden sollen, gruppiert.
* en:
*
Package and classes to process a Vector.
* That is
nneeded to group the texts that should be listet in a combo-box.
*/import
java.util.Vector;/*
*
de: Package und Klasse für eine Combobox.
* en:
Package and class for a combo-box. */
import
javax.swing.JComboBox;
/*
*
de: Package für Start-und Task-Frame und GUI-bezogenen
Methoden.
* en: Package for Start- and Task-Frame and
GUI-related methods. */
import
js_base.frame.*;
/**
*
* @author kurt[at]javascout(dot)biz
* @date
2011-10-21
*
* @description
*
*
de:
* Klasse mit statischen Methoden zur Anzeige von fixen
Werten in den Sprachen,
* die in einem Anwendungsprogramm
festgelegt sind.
* Diese Klasse muss durch eine
entsprechende Klasse im Anwendungsprogramm geerbt werden.
*
In dieser erbenden Klasse können dann die Arrays mit den fixen
Werten implementiert
* werden.
* Innerhalb dieser
Basisklasse ist als Muster eine Gruppe von Arrays mit den Werten
*
für die Mehrwertsteuerregel (diese werden beim Land / 'Country'
benötigt) festgelegt.
* *
en:
* class with static methods to display fixed values in
the languages that are defined
* within an application
program.
* This class has to be inherited by a fitting class
within the application program.
* Within this inheriting
class, the arrays with the fixed values can be implemented.
*
As a sample, a group of arrays with the values for the VAT-Rule
(needed with the
* 'Country') is defined within this
base-class.
*
* @change-log
*
when who why
*
--------------------------------------------------------
*
*/public
class JSBS_ApplicationFixedValues
{/*
*
de:
* Array mit den internen Werten (diese werden auf der
Datenbank gespeichert) für die
* einzelnen
Auswahl-Möglichkeiten der Mehrwertsteuerregel. *
en:
* Array with the internal values (those are stored on
the database) for the individual
* selections of the
VAT-Rule. */ public
static String[]
arrayVAT_Rule_InternalCodes
= {"I",
"EV",
"EE",
"A"};/*
*
de:
* Array mit den angezeigten Werten für die einzelnen
Auswahl-Möglichkeiten der Mehrwertsteuerregel.
* Die
Reihenfolge der Sprachen muss gleich sein wie im Array
'arrayApplicationImplementedLanguages'
* in der Klasse
'JSBS_StartFrame' bzw. einer überschreibenden Variablen in einer
erbenden Klasse. *
en:
* Array with the displayed values for the individual
selections of the VAT-Rule.
* The sequence of the languages
has to follow the sequence in array
'arrayApplicationImplementedLanguages'
* within class
'JSBS_StartFrame', or an overwriting variable in an inheriting class,
respectively. */ public
static String[][]
arrayVAT_Rule_Displayed
= {
{"I
- Inland",
"EV
- EU-Versandlandsteuersatz",
"EE
- EU-Empfängerlandsteuersatz",
"A
– Ausland (nicht EU)"},
{"D
- Domestic",
"ED
– EU country of dispatch rule",
"ER
– EU recipient country rule",
"F
– Foreign (non EU)"},
{"I
- Intérieur",
"EE
– UE règle de pays exportateur",
"ED
- UE règle de pays destinataire",
"E
– Étranger (non UE)"}};/* *
-------------------------------
*
de: BLOCK mit ALLGEMEINEN Methoden.
*
en: BLOCK with COMMON methods.
*
-------------------------------
*
de: METHODE zum Übertragen eines Arrays mit Werten der Klasse String
in einen Vector. *
en: METHOD transfer an array with values of class String into a
Vector. */
protected
static Vector<String>
convertStringArrayToVector(String[] parmStringArray) {/*
de: Definition der Variable des Vectors, der von dieser Methode
zurück geliefert wird. *
en: Definition of the variable for the vector that is returned by
this method. */
Vector<String>
vecReturn = new
Vector<String>(); /*
*
de: *
Prüfen, ob der übergebene Parameter einen null-Wert enthält. *
In diesem Fall diese Methode sofort beenden und einen leeren Vector
zurück liefern. *
en: *
Verify, if the passed parameter contains a null-value. *
In that case end the method immediately and return an empty vector.
*/
if (parmStringArray
== null)
return
vecReturn; /*
*
de: *
Variable für die Steuerung der for-Schleife definieren und
for-Schleife beginnen. *
en: *
Define the variables to control the for-loop and start the for-loop.
*/
int
intArraySize = parmStringArray.length;
int
intArrayIndex;
for (intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) { /*
*
de: *
Ein Object der Klasse String definieren und den Wert aus dem
indizierten Array-Element *
übertragen. Anschließend den String in den Vector einfügen. *
en: *
Define an object of class String and transfer the value from the
indexed array-element. *
Insert the string to the vector thereafter. */
String locString = parmStringArray[intArrayIndex];
vecReturn.addElement(locString);
}/*
*
de: 'Gefüllten' Vector an die aufrufende Methode zurück liefern. *
en: Return the 'filled' vector to the calling method. */
return
vecReturn;
}/* *
------------------------------- *
de: *
METHODE zum Prüfen, ob ein Element des als Parameter übergebenen
Vectors mit der *
Zeichenkette beginnt, die im Parameter 'parmValueToCompare' übergeben
wird. *
*
en: *
METHOD to verify if an element of the vector passes as parameter
starts with the *
string passed in parameter 'parmValueToCompare'. */
protected
static boolean
isValueInVector(Vector<String> parmVector, String
parmValueToCompare) {/*
*
de: *
Prüfen, ob die übergebenen Parameter einen null-Wert enthalten. *
In diesem Fall diese Methode sofort beenden und 'false' zurück
liefern. *
en: *
Verify, if the passed parameters contain null-values. *
In that case end the method immediately and return 'false'. */
if (parmVector
== null)
return
false;
if (parmValueToCompare
== null)
return
false;
/*
*
de: *
Spezielle Prüfung weil bei einer leeren Zeichenkette im Parameter
der *
folgende Code immer ein 'true' zurück liefern würde. *
en: *
Special verification as with an empty string passed in the parameter,
*
the following code would alwasy return 'true'. */
if (parmValueToCompare.length()
<= 0) return
false;
/*
*
de: Zeichenkette für das Bearbeiten eines Elements aus dem
Vector. *
en: String to process one element of the vector. */
String strVectorElement;/*
*
de: *
Variable für die Steuerung der for-Schleife definieren und
for-Schleife beginnen. *
en: *
Define the variables to control the for-loop and start the for-loop.
*/
int
intVectorSize = parmVector.size();
int
intVectorIndex;
for (intVectorIndex
= 0; intVectorIndex < intVectorSize; intVectorIndex++) { /*
*
de: Indiziertes Element aus dem Vector auslesen. *
en: Read the indexed element out of the vector. */
strVectorElement = (String) parmVector.elementAt(intVectorIndex);/*
*
de: *
Die Prüf-Bedingung ist erfüllt wenn die Zeichenkette des
Vector-Elements mit *
dem zu vergleichenden Wert beginnt. Methode beenden; 'true' zurück
liefern. *
en: *
The verification is fulfilled if the string of the vector-element
starts with *
the value of the string to be compared. */
if
(strVectorElement.indexOf(parmValueToCompare) == 0)
return true;
}/*
*
de: *
Beim Durchlauf der for-Schleife wurde kein Vector-Element gefunden,
das mit der *
im Parameter 'parmValueToCompare' übergebenen Wert beginnt. *
Deswegen 'false' an die aufrufende Methode zurück liefern. *
en: *
Within the for-loop a vector-element beginning with the value passed
in *
parameter 'parmValueToCompare' was not found. *
Therefore return 'false' to the calling method. */
return
false;
}/*
* --------------------
*
de:
* METHODE zum Ermitteln des internen Codes aus der
angezeigten Auswahl in der gewählten Sprache.
* Diese
Methode ist allgemein verwendbar; das Array mit den internen Codes
und das
* Array mit den angezeigten Werten in den
definierten Sprachen werden als Parameter
* übergeben.
*
en:
* METHOD to derive the internal code from the
displayed selection in the choosen language.
* This
method is designed for common usage; the array with the internal
codes and the array with
* the displayed values in the
defined languages are passed as parameters. */
public
static String
getInternalCode(String
parmDisplayedValue,
String[]
parmInternalCodeArray,
String[][]
parmDisplayedArray,
JSBS_StartFrame
parmCC,
String
parmLanguage) {/*
*
de:
* Festlegen des Rückgabe-Wertes; vorerst als leere
Zeichenkette falls die Methode wegen eines
* Fehlers
vorzeitig beendet werden muss.
* en: * Define
the return-value; initialized with an empty string in case the method
terminates early
* due to an error. */ String
strReturn = "";/*
*
de: *
Prüfen, ob die übergebenen Parameter einen null-Wert enthalten. *
In diesem Fall diese Methode sofort beenden und die zuvor mit ""
initialisierte Variable *
zurück liefern. *
en: *
Verify, if the passed parameters contain null-values. *
In that case end the method immediately and return the variable just
initialised with "". */
if (parmDisplayedValue
== null)
return
strReturn;
if (parmInternalCodeArray
== null)
return
strReturn;
if (parmDisplayedArray
== null)
return
strReturn;
if (parmCC
== null)
return
strReturn;
if (parmLanguage
== null)
return
strReturn;
/*
*
de: *
Index, welches Unter-Array die angezeigten Werte für die gewählte
Sprache enthält. *
Die Variable wird mit einem negativen Wert initialisiert; damit kann
geprüft werden *
ob überhaupt angezeigte Werte für die gewählte Sprache vorhanden
sind. *
en: *
Index which sub-array contains the displayed values for the selected
language. *
The variable is initialized with a negative value; this allows to
check if displayed *
values exist for the selected value at all. */
int
intLanguageIndex = -1;/*
*
de: *
Variable für die Steuerung der for-Schleifen definieren und
for-Schleife für *
die Ermittlung des Sub-Arrays mit der gewählten Sprache beginnen. *
en: *
Define the variables to control the for-loop and start the for-loop
to determine *
the sub-array for the selected language. */
int
intArraySize =
parmCC.arrayApplicationImplementedLanguages.length;
int
intArrayIndex;
for (intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) { /*
*
de: Zuerst prüfen ob der Wert innerhalb des Arrays gültig ist. *
en: Verify first if the value within the array is valid. */
if
(parmCC.arrayApplicationImplementedLanguages[intArrayIndex]
!= null)
{/*
*
de: *
Element des Arrays hat gültigen Wert; mit der im Parameter
übergebenen Sprache vergleichen. *
en: *
Element of the array has a valid value; compare with the language
passed as parameter. */
if
(parmCC.arrayApplicationImplementedLanguages[intArrayIndex].compareTo(parmLanguage)
== 0) {/*
*
de: Index des zur Sprache passenden Sub-Array aufheben und
for-Schleife beenden. *
en: Keep the index of the fitting sub-array and end the for-loop. */
intLanguageIndex
= intArrayIndex;
break;
}
}
}/*
*
de: *
Prüfen, ob die im Parameter übergebene Sprache überhaupt in der
Anwendung definiert ist. *
Sonst die leere Zeichenkette an die aufrufende Methode zurück
liefern. *
en: *
Verify, if the language passed with the parameter is defined within
the application. *
Otherwise return the empty string to the calling method. */
if
(intLanguageIndex < 0) return
strReturn;/*
*
de: *
Sub-Array für die gewählte Sprache in ein eigenes Array
übertragen. *
Dadurch wird der nachfolgende Code leichter lesbar. *
en: *
Transfer the sub-array for the language into a seperate array. *
That makes the following code easier to read. */
String[]
arrayDisplayedForLanguage = parmDisplayedArray[intLanguageIndex];/*
*
de: *
Länge des Sub-Arrays (für die gewählte Sprache) ermitteln und
for-Schleife für *
den Vergleich des angezeigten Wertes ('parmDisplayedValue')
beginnen. *
en: *
Determine the length of the sub-array (for the selected language) and
start the *
for-loop to compare the displayed value ('parmDisplayedValue'). */
intArraySize = arrayDisplayedForLanguage.length;
for (intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) { /*
*
de: Zuerst prüfen ob der Wert innerhalb des Arrays gültig ist. *
en: Verify first if the value within the array is valid. */
if
(arrayDisplayedForLanguage[intArrayIndex] != null)
{/*
*
de: *
Element des Arrays hat gültigen Wert; *
mit dem im Parameter übergebenen angezeigten Wert vergleichen. *
en: *
Element of the array has a valid value; *
compare with the displayed value passed as parameter. */
if
(arrayDisplayedForLanguage[intArrayIndex].compareTo(parmDisplayedValue)
== 0) {/*
*
de: Dazu passenden internen Code an die aufrufende Methode zurück
liefern. *
en: Return the fitting internal code to the calling method. */
return
parmInternalCodeArray[intArrayIndex];
}
}
}/*
*
de: *
Im Array mit den angezeigten Bezeichnungen wurde keine passende zu
dem im Parameter *
'parmDisplayedCode' übergebenen Wert gefunden. *
Die leere Zeichenkette (zu Beginn dieser Methode definiert) an die
aufrufende Methode zurück liefern. *
en: *
Within the array with the displayed values none was found that fits
the value passed in parameter *
'parmDisplayedCode'. *
Return the empty string (defined at the begin of this method) to the
calling method. */
return
strReturn;
}/*
*
de:
* Wrapper-METHODE zum Ermitteln des internen Codes
aus der angezeigten Auswahl in der gewählten Sprache.
* Als
Sprache wird jene verwendet, die vom Anwender gewählt wurde. *
en:
* Wrapper-METHOD to derive the internal code from
the displayed selection in the choosen language.
* The
language chosen by the user is used. */
public
static String
getInternalCode(String
parmDisplayedValue,
String[]
parmInternalCodeArray,
String[][]
parmDisplayedArray,
JSBS_StartFrame
parmCC) {/*
*
de:
* Sprach-Code aus der Struktur mit den allgemeinen
Parametern ermitteln und jene Methode aufrufen,
* in der die
wirkliche Arbeit ausgeführt wird.
* en: * Get
the language-code from the structure with the common parameters and
call the method
* where the real work is done.
*/ return
getInternalCode(parmDisplayedValue, parmInternalCodeArray,
parmDisplayedArray,
parmCC, parmCC.structJSBS_UniversalParameters.strLanguageCode);
}/*
* --------------------
*
de:
* METHODE zum Ermitteln der angezeigten
Bezeichnung in der jeweiligen Sprache aus dem internen Code.
* Diese
Methode ist allgemein verwendbar; das Array mit den internen Codes
und das
* Array mit den angezeigten Werten in den
definierten Sprachen werden als Parameter
* übergeben.
*
en:
* METHOD to derive the displayed text in the
choosen language from the internal code.
* This method
is designed for common usage; the array with the internal codes and
the array with
* the displayed values in the defined
languages are passed as parameters. */
public
static String
getDisplayedString(String
parmInternalCode,
String[]
parmInternalCodeArray,
String[][]
parmDisplayedArray,
JSBS_StartFrame
parmCC,
String
parmLanguage) {/*
*
de:
* Festlegen des Rückgabe-Wertes; vorerst als leere
Zeichenkette falls die Methode wegen eines
* Fehlers
vorzeitig beendet werden muss.
* en: * Define
the return-value; initialized with an empty string in case the method
terminates early
* due to an error. */ String
strReturn = "";/*
*
de: *
Prüfen, ob die übergebenen Parameter einen null-Wert enthalten. *
In diesem Fall diese Methode sofort beenden und die zuvor mit ""
initialisierte Variable *
zurück liefern. *
en: *
Verify, if the passed parameters contain null-values. *
In that case end the method immediately and return the variable just
initialised with "". */
if (parmInternalCode
== null)
return
strReturn;
if (parmInternalCodeArray
== null)
return
strReturn;
if (parmDisplayedArray
== null)
return
strReturn;
if (parmCC
== null)
return
strReturn;
if (parmLanguage
== null)
return
strReturn;
/*
*
de: *
Index, welches Unter-Array die angezeigten Werte für die gewählte
Sprache enthält. *
Die Variable wird mit einem negativen Wert initialisiert; damit kann
geprüft werden *
ob überhaupt angezeigte Werte für die gewählte Sprache vorhanden
sind. *
en: *
Index which sub-array contains the displayed values for the selected
language. *
The variable is initialized with a negative value; this allows to
check if displayed *
values exist for the selected value at all. */
int
intLanguageIndex = -1;/*
*
de: *
Variable für die Steuerung der for-Schleifen definieren und
for-Schleife für *
die Ermittlung des Sub-Arrays mit der gewählten Sprache beginnen. *
en: *
Define the variables to control the for-loop and start the for-loop
to determine *
the sub-array for the selected language. */
int
intArraySize =
parmCC.arrayApplicationImplementedLanguages.length;
int
intArrayIndex;
for (intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) { /*
*
de: Zuerst prüfen ob der Wert innerhalb des Arrays gültig ist. *
en: Verify first if the value within the array is valid. */
if
(parmCC.arrayApplicationImplementedLanguages[intArrayIndex]
!= null)
{/*
*
de: *
Element des Arrays hat gültigen Wert; mit der im Parameter
übergebenen Sprache vergleichen. *
en: *
Element of the array has a valid value; compare with the language
passed as parameter. */
if
(parmCC.arrayApplicationImplementedLanguages[intArrayIndex].compareTo(parmLanguage)
== 0) {/*
*
de: Index des zur Sprache passenden Sub-Array aufheben und
for-Schleife beenden. *
en: Keep the index of the fitting sub-array and end the for-loop. */
intLanguageIndex
= intArrayIndex;
break;
}
}
}/*
*
de: *
Prüfen, ob die im Parameter übergebene Sprache überhaupt in der
Anwendung definiert ist. *
Sonst die leere Zeichenkette an die aufrufende Methode zurück
liefern. *
en: *
Verify, if the language passed with the parameter is defined within
the application. *
Otherwise return the empty string to the calling method. */
if
(intLanguageIndex < 0) return
strReturn;/*
*
de: *
Sub-Array für die gewählte Sprache in ein eigenes Array
übertragen. *
Dadurch wird der nachfolgende Code leichter lesbar. *
en: *
Transfer the sub-array for the language into a seperate array. *
That makes the following code easier to read. */
String[]
arrayDisplayedForLanguage = parmDisplayedArray[intLanguageIndex];/*
*
de: *
Länge des Sub-Arrays (für die gewählte Sprache) ermitteln und
for-Schleife für *
den Vergleich des angezeigten Wertes ('parmDisplayedValue')
beginnen. *
en: *
Determine the length of the sub-array (for the selected language) and
start the *
for-loop to compare the displayed value ('parmDisplayedValue'). */
intArraySize = parmInternalCodeArray.length;
for (intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) { /*
*
de: Zuerst prüfen ob der Wert innerhalb des Arrays gültig ist. *
en: Verify first if the value within the array is valid. */
if
(parmInternalCodeArray[intArrayIndex] != null)
{/*
*
de: *
Element des Arrays hat gültigen Wert; *
mit dem im Parameter übergebenen angezeigten Wert vergleichen. *
en: *
Element of the array has a valid value; *
compare with the displayed value passed as parameter. */
if
(parmInternalCodeArray[intArrayIndex].compareTo(parmInternalCode) ==
0) {/*
*
de: *
Dazu passenden sprach-spezifischen angezeigten Text an die aufrufende
Methode zurück liefern. *
en: *
Return the fitting text for display – specific for the selected
language - to the calling method. */
return
arrayDisplayedForLanguage[intArrayIndex];
}
}
}/*
*
de: *
Im Array mit den internen Codes wurde kein Passender zu dem im
Parameter *
'parmInternalCode' übergebenen Wert gefunden. *
Die leere Zeichenkette (zu Beginn dieser Methode definiert) an die
aufrufende Methode zurück liefern. *
en: *
Within the array with the internal codes none was found that fits the
value passed in parameter *
'parmInternalCode'. *
Return the empty string (defined at the begin of this method) to the
calling method. */
return
strReturn;
}/*
*
de:
* Wrapper-METHODE zum Ermitteln des angezeigten
Textes in der gewählten Sprache für einen internen Code.
* Als
Sprache wird jene verwendet, die vom Anwender gewählt wurde. *
en:
* Wrapper-METHOD to derive the displayed text in
the choosen language for a given internal code.
* The
language chosen by the user is used. */
public
static String
getDisplayedString(String
parmInternalCode,
String[]
parmInternalCodeArray,
String[][]
parmDisplayedArray,
JSBS_StartFrame
parmCC) {/*
*
de:
* Sprach-Code aus der Struktur mit den allgemeinen
Parametern ermitteln und jene Methode aufrufen,
* in der die
wirkliche Arbeit ausgeführt wird.
* en: * Get
the language-code from the structure with the common parameters and
call the method
* where the real work is done.
*/ return
getDisplayedString(parmInternalCode, parmInternalCodeArray,
parmDisplayedArray,
parmCC, parmCC.structJSBS_UniversalParameters.strLanguageCode);
}/*
* --------------------
*
de:
* METHODE zum Füllen einer Combobox mit den
Werten aus einem Sub-Array des im Parameter
* 'parmDisplayedArray'
übergebenen Arrays mit Texten in allen implementierten
Sprachen.
* Aus welchem Sub-Array die Texte angezeigt
werden wird durch den Sprach-Code im
* Parameter
'parmLanguageCode' bestimmt.
* Zusätzlich kann ein
Vector als Parameter 'parmExclusionList' übergeben werden
* in
dem angezeigte Werte oder interne Codes enthalten sein können.
* Die
Werte in diesem Vector werden nicht in der Combobox
angzeigt.
* Diese Methode ist allgemein verwendbar; für
die Anzeige der 'wirklichen' Werte
* muss eine eigene
Methode geschrieben werden in der diese Methode aufgerufen
wird
* und die Arrays mit den anzuzeigenden Texten und
internen Codes als Parameter an
* diese Methode
übergeben werden. *
en:
* METHOD to fill a combo-box with the values of a
sub-array of the array passed in
* parameter
'parmDisplayedArray'. The array passed in the parameter contains
texts in
* all implemented languages.
* texts
of which aub-array should be displayed is determined by the value
passed in
* parameter
'parmLanguageCode'.
* Additionally, a Vector can be
passed as parameter 'parmExclusionList' which contains
* displayed
values or internal codes. The values within this vector will not be
displayed
* within the combo-box.
* This
method is designed for common usage; to display' the 'real' values,
an own method
* has to be written where this method is
called and the arrays with the texts to be displayed
* and
the internal codes are passed as parameters to this method.
*/
protected
static void
fillComboBoxWithExclusions(JComboBox
parmJComboBox,
String[]
parmInternalCodeArray,
String[][]
parmDisplayedArray,
JSBS_StartFrame
parmCC,
String
parmLanguageCode,
Vector<String>
parmExclusionList) {/*
*
de: *
Prüfen, ob die übergebenen Parameter null-Werte enthalten. *
In diesem Fall eine Korrektur ausführen oder, wenn eine Korrektur
nicht möglich ist, *
die Methode sofort beenden. *
en: *
Verify, if the passed parameters contain null-values. *
In that case perform a correction or, if a correction is not
possible, end the method immediately. */
if (parmJComboBox
== null)
return;
if (parmDisplayedArray
== null)
return;
if (parmCC
== null)
return;
/*
*
de: *
Ob der Wert im Parameter 'parmInternalCodeArray' null ist wird
innerhalb des folgenden Codes verarbeitet. *
en: *
If the value of parameter 'parmInternalCodeArray' is null is
processed within the following code. */ /*
*
de: *
Wenn kein Wert für die Sprache übergeben wird, dann wird jene
Sprache, die dem Anwender zugeordnet ist, *
verwendet. *
en: *
If no value for the language is passed, the language assigned to the
user is used. */
if (parmLanguageCode
== null)
parmLanguageCode
= parmCC.structJSBS_UniversalParameters.strLanguageCode;
/*
*
de: *
Wenn kein Wert für die Liste mit den nicht anzuzeigenden Werte
übergeben wird, dann wird ein *
'leerer' Vector erstellt. *
en: *
If no value for the list with the values, that should not be
displayed in the combo-box, is passed, *
an empty vector is created now. */
if (parmExclusionList
== null)
parmExclusionList = new
Vector<String>(); /*
*
de: *
Index, welches Unter-Array die angezeigten Werte für die gewählte
Sprache enthält. *
Die Variable wird mit einem negativen Wert initialisiert; damit kann
geprüft werden *
ob überhaupt angezeigte Werte für die gewählte Sprache vorhanden
sind. *
en: *
Index which sub-array contains the displayed values for the selected
language. *
The variable is initialized with a negative value; this allows to
check if displayed *
values exist for the selected value at all. */
int
intLanguageIndex = -1;/*
*
de: *
Variable für die Steuerung der for-Schleifen definieren und
for-Schleife für *
die Ermittlung des Sub-Arrays mit der gewählten Sprache beginnen. *
en: *
Define the variables to control the for-loop and start the for-loop
to determine *
the sub-array for the selected language. */
int
intArraySize =
parmCC.arrayApplicationImplementedLanguages.length;
int
intArrayIndex;
for (intArrayIndex
= 0; intArrayIndex < intArraySize; intArrayIndex++) { /*
*
de: Zuerst prüfen ob der Wert innerhalb des Arrays gültig ist. *
en: Verify first if the value within the array is valid. */
if
(parmCC.arrayApplicationImplementedLanguages[intArrayIndex]
!= null)
{/*
*
de: *
Element des Arrays hat gültigen Wert; mit der im Parameter
übergebenen Sprache vergleichen. *
en: *
Element of the array has a valid value; compare with the language
passed as parameter. */
if
(parmCC.arrayApplicationImplementedLanguages[intArrayIndex].
compareTo(parmLanguageCode)
== 0) {/*
*
de: Index des zur Sprache passenden Sub-Array aufheben und
for-Schleife beenden. *
en: Keep the index of the fitting sub-array and end the for-loop. */
intLanguageIndex
= intArrayIndex;
break;
}
}
}/*
*
de: *
Array definieren, in das später das Sub-Array mit den anzuzeigenden
Texten für *
die gewählte Sprache übertragen wird. *
Das hier definierte Array wird 'leer' gelassen. Damit wird bewirkt,
dass eine leere *
Combobox angezeigt wird wenn für die im Parameter übergebenen
Sprache keine *
Bezeichnungen gefunden wurden. *
en: *
Define the array where the sub-array with the texts to be displayed
for the chosen *
language will be transferred later. *
The array defined here is left 'empty'. That is done to display an
empty combo-box *
if no text is found for the language passed in the parameter. */
String[]
arrayDisplayedForLanguage = new
String[0];/*
*
de: *
Prüfen, ob die im Parameter übergebene Sprache überhaupt in der
Anwendung definiert ist. *
Dann das Sub-Array für die gewählte Sprache in ein eigenes Array
übertragen. *
Dadurch wird der nachfolgende Code leichter lesbar. *
en: *
Verify, if the language passed with the parameter is defined within
the application. *
In that cas, transfer the sub-array for the language into a seperate
array. *
That makes the following code easier to read. */
if
(intLanguageIndex >= 0) arrayDisplayedForLanguage =
parmDisplayedArray[intLanguageIndex];/*
*
de: *
Array in einen Vector umwandeln; darus können leichter einzelne
Elemente entfernt werden. *
en: *
Convert the array into a Vector; so it is easier to remove singular
elments. */
Vector<String>
vecDisplayedForLanguage =
convertStringArrayToVector(arrayDisplayedForLanguage);/*
*
de: *
Hilfsvariablen zum Prüfen, ob einzelne Werte nicht in der Combobox
angezeigt werden sollen. *
en: *
Auxilliary variables to check, if singular values should not be
displayed in the combo-box. */
String
strDisplayedToInspect;
String
strInternalCodeToInspect;/*
*
de: *
In der folgenden for-Schleife werden alle Elemente im Vector darauf
geprüft, ob deren Wert in der *
Ausnahmeliste (Parameter 'parmExclusionList') enthalten sind; d.h.
nicht in der Combobox angezeigt *
werden sollen. *
en: *
Within the following for-loop, all elements in the vector are checked
if their value is within the *
exclusion-list (parameter 'parmExclusionList'). If they are in the
exclusion-list, then those *
values will not be displayed within the combo-box. */
intArraySize
= vecDisplayedForLanguage.size();
for (intArrayIndex
= intArraySize - 1; intArrayIndex >= 0; intArrayIndex--) { /*
*
de: *
Zuerst wird geprüft, ob der angezeigte Text in der Ausnahmeliste
enthalten ist. *
Dazu den Wert aus dem bearbeiteten Element des Vectors in die
Hilf-Variable übertragen. *
Dann die Methode aufrufen, die prüft, ob dieser Wert im Vector mit
der Ausnahmeliste enthalten ist. *
en: *
Verify first if the displayed text is in the exclusion-list. *
To do this, the value of the processed element of the vector is
transferred to the *
auxilliary variable. *
Then, the method to check if this value is in the vector with the
exclusion-list, is called. */
strDisplayedToInspect
= vecDisplayedForLanguage.elementAt(intArrayIndex);/*
*
de: Zur Sicherheit prüfen, ob das Element einen gültigen Wert
hat. *
en: Do a safety-check if the element has a valid value. */
if
(strDisplayedToInspect != null)
{/*
*
de: *
Methode, in der geprüft wird ein Wert (aprach-spezifischer Text für
die Anzeige in der Combobox) im Vector *
(mit den nicht anzuzeigenden Werten; als Parameter übergeben)
enthalten ist, aufrufen. *
en: *
Call the method that checks if a value (language-specific text for
display within the combo-box) is within *
the vector (with the values that should not be displayed; passed as
parameter). */
if
(isValueInVector(parmExclusionList, strDisplayedToInspect))/*
*
de: Text im Vector mit den Ausnahmen gefunden; aus dem Vector für
die Anzeige in der Combobox entfernen. *
en: Text found within the vector with the exclusions; remove from the
vector for display in the combo-box. */
vecDisplayedForLanguage.removeElementAt(intArrayIndex);/*
*
de: *
Wenn der sprach-spezifische Text nicht gefunden wurde dann prüfen,
ob der interne Code im Vector mit *
den nicht anzuzeigenden Werten enthalten ist. *
en: *
If the language-specific text was not found then check, if the
internal code is within the vector with *
the values that should not be displayed; passed as parameter. */
else
{/*
*
de: *
Zuerst prüfen, ob überhaupt ein Array mit den internen Codes
übergeben wurde. *
Dann Methode zum Ermitteln des internen Codes aufrufen. *
en: *
Verify fist if an array with the internal codes was passed. *
Call the method to get the internal code thereafter. */
if
(parmInternalCodeArray != null)
{
strInternalCodeToInspect
=
getInternalCode(strDisplayedToInspect,
parmInternalCodeArray,
parmDisplayedArray,
parmCC,
parmLanguageCode);/*
*
de: Zur Sicherheit prüfen, ob die Zeichenkette einen gültigen Wert
hat. *
en: Do a safety-check if the string has a valid value. */
if
(strInternalCodeToInspect != null)
{/*
*
de: *
Methode, in der geprüft wird ein Wert (interner Code) im Vector
enthalten ist, aufrufen. *
en: *
Call the method that checks if a value (internal code) is within the
vector. */
if
(isValueInVector(parmExclusionList, strInternalCodeToInspect))/*
*
de: *
Interne Code im Vector mit den Ausnahmen gefunden; aus dem Vector für
die Anzeige in der Combobox entfernen. *
en: *
Internal Code found within the vector with the exclusions; remove
from the vector for display in the combo-box. */
vecDisplayedForLanguage.removeElementAt(intArrayIndex);
}
}
}
}
}/*
*
de: Methode zum Füllen der Combobox mit den Werten des Vectors
aufrufen. *
en: Call the method to fill the combo-box with the values of the
Vector. */
JSBS_GUIServices.setListToJComboBox(parmJComboBox,
vecDisplayedForLanguage);
}/*
*
de:
* Wrapper-METHODE zum Füllen der Combobox ohne
Liste mit den nicht anzuzeigenden Werden (Exclusion-Liste). *
en:
* Wrapper-METHOD to fill the combo-box without the
list with the values not to be displayed (exclusion-list).
*/
protected
static void fillComboBox(JComboBox
parmJComboBox,
String[]
parmInternalCodeArray,
String[][]
parmDisplayedArray,
JSBS_StartFrame
parmCC,
String
parmLanguageCode) {/*
*
de:
* Methode zum Füllen der Combobox mit Exclusion-List
aufrufen.
* Als Parameter für die Exclusion-List wird ein
'null'-Wert übergeben.
* en: * Call
the method to fill the combo-box with the exclusion-list.
* A
'null'-value is passed as parameter for the exclusion-list.
*/ fillComboBoxWithExclusions(parmJComboBox,
parmInternalCodeArray, parmDisplayedArray,
parmCC, parmLanguageCode,
null);
}/*
*
de:
* Zusätzliche Wrapper-METHODEN MIT EINER
VERRINGERTEN ANZAHL VON PARAMETERN können bei jenen Methoden, die
konkrete
* fixe Werte anzeigen, implementiert
werden.
* Beispiele dazu sind in den folgenden Methoden
für das Füllen einer Combobox mit den Mehrwertsteuer-Regeln. *
en:
* Additional Wrapper-METHODS WITH A REDUCED NUMBER
OF PARAMETERS can be implemented at the methods that
display
* concrete fix values.
* Examples
are shown in the following methods to fill a combo-box with the
VAT-rules.
* ------------------------------ *//*
==============================
* de:
* Wrapper-METHODEN
zum Füllen der Combobox mit den konkreten Werten für die
Mehrwertsteuer-Regeln.
* Zuerst die Methoden mit der
Möglichkeit, eine Ausnahmeliste (mit Werten, die nicht in der Liste
der Combobox
* angezeigt werden sollen) zu übergeben
und allen möglichen Parametern. *
en:
* Wrapper-METHODS to fill the combo-box with the
concrete values for the VAT-rules.
* First the methods
with the option to pass an exclusion-list (with the values that shold
not be displayed
* in the list within the combo-box)
and all possible parameters. */
public
static void fillVAT_RuleComboBoxWithExclusions(JComboBox
parmJComboBox,
JSBS_StartFrame
parmCC,
String
parmLanguageCode,
Vector<String>
parmExclusionList) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmCC,
parmLanguageCode, parmExclusionList);
}/*
* de:
* Wrapper-METHODE ohne Parameter für
die Sprache, in der der Text angezeigt werden soll.
* Als
Sprache wird jene verwendet, die dem Benutzer zugeordnet ist. *
en:
* Wrapper-METHOD without a paramater for the
language.
* The language assigned to the user is
used. */
public
static void fillVAT_RuleComboBoxWithExclusions(JComboBox
parmJComboBox,
JSBS_StartFrame
parmCC,
Vector<String>
parmExclusionList) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmCC,
null,
parmExclusionList);
}/*
* de:
* Wrapper-METHODE mit einem Parameter
für das Task-Frame (statt dem Start-Frame).
* Das
verkürzt den Code baim Aufrufen dieser Methode etwas. *
en:
* Wrapper-METHOD with a parameter for the
Task-Frame (instaed of the Start-Frame).
* This
shortens the code to call this method a little bit. */
public
static void fillVAT_RuleComboBoxWithExclusions(JComboBox
parmJComboBox,
JSBS_TaskFrame
parmTF,
String
parmLanguageCode,
Vector<String>
parmExclusionList) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmTF.frmCC,
parmLanguageCode, parmExclusionList);
}/*
* de:
* Wrapper-METHODE ohne Parameter für
die Sprache, in der der Text angezeigt werden soll.
* Als
Sprache wird jene verwendet, die dem Benutzer zugeordnet
ist.
* Statt dem Start-Frame wird ein Parameter für
das Task-Frame vorgesehen.
* Das verkürzt den Code
beim Aufrufen dieser Metthode etwas. *
en:
* Wrapper-METHOD without a paramater for the
language.
* The language assigned to the user is
used.
* Instaed of the Start-Frame a parameter for the
Task-Frame is introduced.
* This shortens the code to
call this method a little bit. */
public
static void fillVAT_RuleComboBoxWithExclusions(JComboBox
parmJComboBox,
JSBS_TaskFrame
parmTF
,
Vector<String>
parmExclusionList) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmTF.frmCC
,
null,
parmExclusionList);
}/*
--------------------
* de:
* Wrapper-METHODEN
zum Füllen der Combobox mit den konkreten Werten für die
Mehrwertsteuer-Regeln.
* Die folgenden Methoden sind
ohne die Möglichkeit, eine Ausnahmeliste (mit Werten, die nicht in
der
* Liste der Combobox angezeigt werden sollen) zu
übergeben und allen möglichen Parametern. *
en:
* Wrapper-METHODS to fill the combo-box with the
concrete values for the VAT-rules.
* The following
methods are without the options to pass an exclusion-list (with the
values that
* should not be displayed in the list
within the combo-box) and all possible parameters. */
public
static void fillVAT_RuleComboBox(JComboBox
parmJComboBox,
JSBS_StartFrame
parmCC,
String
parmLanguageCode) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmCC,
parmLanguageCode, null);
}/*
* de:
* Wrapper-METHODE ohne Parameter für
die Sprache, in der der Text angezeigt werden soll.
* Als
Sprache wird jene verwendet, die dem Benutzer zugeordnet ist. *
en:
* Wrapper-METHOD without a paramater for the
language.
* The language assigned to the user is
used. */
public
static void fillVAT_RuleComboBox(JComboBox
parmJComboBox,
JSBS_StartFrame
parmCC) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmCC,
null,
null);
}/*
* de:
* Wrapper-METHODE mit einem Parameter
für das Task-Frame (statt dem Start-Frame).
* Das
verkürzt den Code baim Aufrufen dieser Methode etwas. *
en:
* Wrapper-METHOD with a parameter for the
Task-Frame (instaed of the Start-Frame).
* This
shortens the code to call this method a little bit. */
public
static void fillVAT_RuleComboBox(JComboBox
parmJComboBox,
JSBS_TaskFrame
parmTF,
String
parmLanguageCode) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmTF.frmCC,
parmLanguageCode, null);
}/*
* de:
* Wrapper-METHODE ohne Parameter für
die Sprache, in der der Text angezeigt werden soll.
* Als
Sprache wird jene verwendet, die dem Benutzer zugeordnet
ist.
* Statt dem Start-Frame wird ein Parameter für
das Task-Frame vorgesehen.
* Das verkürzt den Code
beim Aufrufen dieser Metthode etwas. *
en:
* Wrapper-METHOD without a paramater for the
language.
* The language assigned to the user is
used.
* Instaed of the Start-Frame a parameter for the
Task-Frame is introduced.
* This shortens the code to
call this method a little bit. */
public
static void fillVAT_RuleComboBox(JComboBox
parmJComboBox,
JSBS_TaskFrame
parmTF) {/*
*
de:
* Allgemeine Methode aufrufen und die Arrays mit den
Werten für die Mehrwertsteuer-Regeln übergeben.
*
en: * Call
the general method and pass the arrays with the values for the
VAT-Rules. */ fillComboBoxWithExclusions(parmJComboBox,
arrayVAT_Rule_InternalCodes,
arrayVAT_Rule_Displayed,
parmTF.frmCC
,
null,
null);
}
}
Die Methoden dieser Klasse werden nur von Methoden innerhalb des JavaScout Basis-Systems aufgerufen und sind nicht für eine allgemeine Verwendung gedacht.
|
Dokument |
Inhalt |
|
|
|