|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.xml;
import
java.awt.Component;
import
java.util.*;
import
javax.swing.*;
import
org.jdom.*;
import
js_base.frame.*;
import
js_base.structures.JSBS_UniversalParameters;
import
js_base.utilities.JSBS_SystemServices;
/**
*
* @author kurt[at]javascout(dot)biz
* @date
2007-09-05
*
* @description
* de:
*
Klasse mit spezialisierten Methoden zum Ermitteln der Zuordnung
* von Funktionstasten (der Tastatur) und Dateien mit
Grafischen Symbolen (Icons)
* zu Schaltflächen
auf der Benutzeroberfläche (GUI).
* Diese Klasse
erbt JSBS_XML_Base und verwendet dessen Methoden zum lesen
*
der Datei, die die XML-Struktur enthält.
* en: *
Class with specialized methods for assigning an Icon and a
Function-Key-Code
* to a JButton.
* This
class inherits JSBS_XML_Base and uses its methods to read a
file
* containing a XML-structure.
*
*
@change-log
*
when who why
*
--------------------------------------------------------
*
*/
public
class JSBS_XML_FunctionKeys
extends
JSBS_XML_Base
{
/*
* de:
* Variable für die Struktur mit den
Universal-Parametern.
* Diese enthält die gewählte
Sprache (verwendet beim Anzeigen des Funktionstasten-Namens
*
in der gewählten Sprache) und den Namen des Dateiverzeichnisses
mit den Dateien mit den
* grafischen Symbolen (Icons).
*
en:
* Variable for the structure with the
Universal-Parameters.
* It contains the chosen language for
the user (used to display the Function-Key-Names
* in the
chosen language) and the directory-name where the files for the icons
are stored. */
JSBS_UniversalParameters
structJSBS_UniversalParameters;
/*
*
-------------------------------
* de:
* CONSTRUCTOR
der Klasse.
* Der Name der zu öffnenden Datei wird aus
der Struktur UniversalParameters ermittelt.
* en:
* CONSTRUCTOR of the class.
* The name
of the file to be opened is derived from the UniversalParameters.
*/
public
JSBS_XML_FunctionKeys(JSBS_StartFrame
parmCC) {
/*
* de: Ausführen des Codes im Constructor der geerbten
Klasse.
* en: Perform the code in the constructor of the
inherited class */
super(parmCC);
/*
* de:
* Aufheben der Struktur mit den
Universal-Parametern; diese enthält die gewählte Sprache
*
für den Anwender und den Namen des Datei-Verzeichnisses in dem
die Dateien für die grafischen
* Symbole (Icons)
gespeichert sind
* en:
* Keep the
Universal-Parameter-structure; it contains the language chosen by the
user
* and the directory-name where the files for the icons
are stored. */
structJSBS_UniversalParameters
=
parmCC.structJSBS_UniversalParameters
;
/*
*
de:
* Holen des Dateinamens für die XML-Struktur mit
den Funktionstasten-Zuordnungen.
* Dazu wird das
Datei-Verzeichnis mit den sprach-spezifischen Dateien und der
* Datei-Name für die Datei mit der XML-Struktur
zusammen gesetzt.
* en:
* Get the filename for the
XML-structure with the function-key-assignments.
* This
is done by concatenating the directory with the language dependant
files
* and the filename for the file with the
XML-structure. */
String
locstrFileName
=
parmCC.structJSBS_UniversalParameters.strTextElementsDirectoryName
+
JSBS_UniversalParameters.CONST_FUNCTIONKEYS_FILE_NAME;
/*
*
de:
* RootElement der XML-Struktur lesen,
* Die
Methode ist in der Superklasse - das ist die geerbte Klasse -
implementiert.
*
en:
* Read the RootElement of the XML-structure.
*
The method
implemented in the superclass - i.e. the class inherited.
*/
readXMLFile(locstrFileName);
}
/*
*
-------------------------------
* de:
* CONSTRUCTOR
der Klasse.
* Der Name der zu öffnenden Datei (und das
Vezeichnis) wird als Parameter übergeben.
* en:
*
CONSTRUCTOR of the class.
* The name of the file (and
directory) to be opened is passed as parameter.
*/
public JSBS_XML_FunctionKeys(String
parmDirectoryAndFileName) {
/*
*
de: Ausführen des Codes im Constructor der geerbten Klasse.
*
en: Perform the code in the constructor of the inherited class
*/ super(null);
/*
*
de:
* RootElement der XML-Struktur lesen,
* Die
Methode ist in der Superklasse - das ist die geerbte Klasse -
implementiert.
*
en:
* Read the RootElement of the XML-structure.
*
The method
implemented in the superclass - i.e. the class inherited.
*/
readXMLFile(parmDirectoryAndFileName);
}/*
*
************************************************** */
/* de:
*
Methode zum 'Holen' eines XML-Elementes das die Spezifikation
einer
* Funktions-Taste abbildet.
*
Auswahlkriterien sind Name der JFrame-Klasse in der der
zugehörige
* JButton enthalten ist und Name des
JButton.
* en:
* Method to 'get' a XML-Element
defining a Function-Key and belonging
* to the
<FrameIndividualAssignments> division of the XML-structure.
*
Selection-criteria are the JFrame-classe containing the JButton
and
* the name of the JButton.
*/
private
Element
getKeyByButtonName(String parmstrFrameClassName,
String
parmstrButtonName) {
/*
*
Variablen / Variables:
*/
/* de:
* Element für
den Bereich <FrameIndividualAssignments>,
* Element
für ein <FrameIndividualAssignment>,
* Element
für einen <FrameClassName>, Zeichenkette mit dem Namen der
FrameClass,
* Element für eine Funktionstaste innerhalb
von <FrameIndividualAssignment>,
* Element für
einen <ButtonName> und die Zeichenkette mit dem Namen der
Schaltfläche
* - damit wird der gesuchte 'ButtonName'
aus den Parametern verglichen.
* en:
* element for
the <FrameIndividualAssignments> Division,
* element
for one <FrameIndividualAssignment>,
* element for the
<FrameClassName>, String with the name of the FrameClass,
*
element for one Key within the <FrameIndividualAssignment>,
*
element for the <ButtonName> and String with the name of the
button
* - to compare it to the searched one.
*/
Element
elementFrameIndividualAssignments;
Element
elementFrameIndividualAssignment;
Element
elementFrameClassName;
String
strFrameClassName;
Element
elementFunctionKeyAssignment;
Element
elementButtonName;
String
strButtonName;
/*
de:
* Liste alle <FrameIndividualAssignment>-Elemente;
* Anzahl und Index zum Durchsuchen der Liste.
*
en:
* List of all <FrameIndividual Assignment>-elements;
* size and index for searching it. */
List
listFrameIndividualAssignment;
int
intlistFrameIndividualAssignmentSize;
int
intlistFrameIndividualAssignmentIndex
= 0;
/*
de:
* Liste alle <FunctionKeyAssignment>-Elemente;
*
Anzahl und Index zum Durchsuchen der Liste.
* en:
*
List of all <FunctionKeyAssignment>-elements,
* size
and index for searching it. */
List
listFunctionKeyAssignment;
int
intlistFunctionKeyAssignmentSize;
int
intlistFunctionKeyAssignmentIndex
= 0;
/*
de:
* Status-Code setzen; damit kann am Ende der Methode
geprüft werden, ob etwas
* unerwünscht gelaufen
ist.
* en: * Set
the StatusCode to OK to see at the end of the method if anything went
wrong. */
StatusCode
=
CONST_OK;
/*
de:
* Prüfen ob überhaupt eine XML-Struktur
vorhanden ist.
* en:
* Initial verification of
there is any XML-structure present. */
if
(XML_RootElement
==
null)
{
/*
de:
* Keine XML-Struktur in der Datei; Status-Code setzen
und
* 'null' Wert zurückliefern.
* en:
*
XML-structure not present within the file; set Status-Code and
*
return a 'null'-value. */
StatusCode
=
CONST_NOT_WELL_FORMED;
return
null;
}
/*
de:
* Allgemeine Prüfung ob ein untergeordnetes
XML-Element für den Bereich
*
<FrameIndividualAssignments> vorhanden ist.
* en:
* General
check if there are child-elements named
* <FrameIndividualAssignments>
present. */
elementFrameIndividualAssignments
=
XML_RootElement.getChild("FrameIndividualAssignments");
if
(elementFrameIndividualAssignments
== null)
{
/*
de:
* Bereich <FrameIndividualAssignments> nicht
vorhanden.
*
Definitionen könnten im Bereich <CommonAssignments>
sein;
* Deswegen vorerst nur den Status-Code
setzen.
* en:
* <FrameIndividualAssignments>-Division
not present.
* Definitions might be in the
<CommonAssignments> division;
* so only the
Status-Code is set for now. */
StatusCode
=
CONST_FRAMEINDIVIDUAL_DIVISION_NOT_PRESENT;
}
/*
de:
* Lesen der Liste mit den
<FrameIndividualAssignment>-Elementen
* und ermitteln
der Anzahl dieser.
* en:
* Get the list
of <FrameIndividualAssignment>-elements
* and
the number of elements within. */
listFrameIndividualAssignment
=
elementFrameIndividualAssignments.getChildren();
intlistFrameIndividualAssignmentSize
= listFrameIndividualAssignment.size();
if
(intlistFrameIndividualAssignmentSize
== 0) {
/*
de:
* Bereich <FrameIndividualAssignments> nicht
vorhanden.
*
Definitionen könnten im Bereich <CommonAssignments>
sein;
* Deswegen vorerst nur den Status-Code
setzen.
* en:
* <FrameIndividualAssignments>-Division
not present.
* Definitions might be in the
<CommonAssignments> division;
* so only the
Status-Code is set for now. */
StatusCode
=
CONST_FRAMECLASS_NOT_PRESENT;
}
/*
de:
* Jedes Element der Liste untersuchen ob der Name der
JFrame-Klasse
* mit jenem Namen übereinstimmt,
*
en: * Inspect
each element of the list to find the element
fitting
the Class-Name of the JFrame passed as parameter. */
for
(intlistFrameIndividualAssignmentIndex
= 0;
intlistFrameIndividualAssignmentIndex <
intlistFrameIndividualAssignmentSize;
intlistFrameIndividualAssignmentIndex++)
{
elementFrameIndividualAssignment
= (Element)
listFrameIndividualAssignment.get(intlistFrameIndividualAssignmentIndex);
/* de:
*
Element <FrameClassName> holen und dessen Wert mit dem Namen
der Klasse,
* die als Parameter übergeben wurde,
vergleichen.
* en: * Get
the element with the <FrameClassName> to compare its content
* with the Class-Name of the passed
parameter. */
elementFrameClassName
=
elementFrameIndividualAssignment.getChild("FrameClassName");
if
(elementFrameClassName
== null)
{
StatusCode
=
CONST_FRAMECLASS_NOT_PRESENT;
}
else
{
strFrameClassName =
elementFrameClassName.getTextTrim();
if
(strFrameClassName.compareTo(parmstrFrameClassName)
== 0) {
/*
de: *
Passendes <FrameClassName>-Element innerhalb der Liste
gefunden. *
Liste mit den <FunctionKeyAssignment>-Elementen bilden und
jedes untersuchen. * en: * Fitting
<FrameClassName>-element found within the list;
* extract
the list of <FunctionKeyAssignment>s and inspect each of
it. */
listFunctionKeyAssignment
=
elementFrameIndividualAssignment.getChildren("FunctionKeyAssignment");
intlistFunctionKeyAssignmentSize
= listFunctionKeyAssignment.size();
if
(intlistFunctionKeyAssignmentSize
==
0) {
StatusCode
=
CONST_GUI_ELEMENT_NOT_PRESENT;
}
for
(intlistFunctionKeyAssignmentIndex
= 0;
intlistFunctionKeyAssignmentIndex
< intlistFunctionKeyAssignmentSize;
intlistFunctionKeyAssignmentIndex++) {
elementFunctionKeyAssignment
=
(Element)
listFunctionKeyAssignment.get(intlistFunctionKeyAssignmentIndex);
/*
de: *
Vergleichen ob der <ButtonName> des XML-Elements
<FunctionKeyAssignment> *
jenem entspricht der als Parameter übergeben wurde. * en: *
Check
if the <ButtonName> of the inspected <FunctionKeyAssignment>
*
fits
the searched one passed as parameter. */
elementButtonName
=
elementFunctionKeyAssignment.getChild("ButtonName");
if
(elementButtonName
!=
null)
{
strButtonName = elementButtonName.getTextTrim();
if
(strButtonName
!=
null)
{
if
(strButtonName.compareTo(parmstrButtonName)
== 0)
/*
de: *
XML-Element für
den gesuchten ButtonName und FrameClassName gefunden;
*
XML-Element an die aufrufende Methode zurückgeben. * en: *
XML-element
for searched ButtonName and FrameClassName found; *
return
the XML-element. */
return
elementFunctionKeyAssignment;
}
}
}
}
}
}
/*
de:
* Gesuchtes Element bis jetzt nicht in der XML-Struktur
gefunden;
* Bereich <CommonAssignments> durchsuchen
und zurückliefern was dort gefunden wird.
*
en: *
Searched element not found within the XML-structure till now;
* search the <CommonAssignments> division and return
what is found there. */
StatusCode
=
CONST_GUI_ELEMENT_NOT_PRESENT;
return getCommonKeyByButtonName(parmstrButtonName);
}
/*
*
************************************************** */
/* de:
*
Methode zum 'Holen' eines XML-Elementes das die Spezifikation
einer
* Funktions-Taste abbildet.
*
Auswahlkriterien sind Name der JFrame-Klasse in der der
zugehörige
* JButton enthalten ist und der interne Code
der Funktionstaste.
* Der 'interne Code' ist jene
Zeichenkette die innerhalb von Java verwendet wird.
* en:
*
Method to 'get' a XML-Element defining a Function-Key and belonging
* to the <FrameIndividualAssignments> division of the
XML-structure.
* Selection-criteria are the JFrame-classe
containing the JButton and
* the internal code of the
function-key.
* The 'internal code' is the string of
characters that is used within Java.
*/
private
Element
getKeyByInternalKeyCode(String parmstrFrameClassName,
String parmstrInternalKeyCode) {
/*
*
Variablen / Variables:
*/
/* de:
* Element für
den Bereich <FrameIndividualAssignments>,
* Element
für ein <FrameIndividualAssignment>,
* Element
für einen <FrameClassName>, Zeichenkette mit dem Namen der
FrameClass,
* Element für eine Funktionstaste innerhalb
von <FrameIndividualAssignment>,
* Element für
einen <InternalKeyCode> und die Zeichenkette mit dem internen
Code
* der Funktionstaste
* - damit wird der
gesuchte 'InternalKeyCode' aus den Parametern verglichen.
*
en:
* element for the <FrameIndividualAssignments>
Division,
* element for one <FrameIndividualAssignment>,
*
element for the <FrameClassName>, String with the name of the
FrameClass,
* element for one Key within the
<FrameIndividualAssignment>,
* element for the
<InternalKeyCode> and String with the internal code of the
*
function-key
* - to compare it to the searched one passed
as parameter. */
Element
elementFrameIndividualAssignments;
Element
elementFrameIndividualAssignment;
Element
elementFrameClassName;
String
strFrameClassName;
Element
elementFunctionKeyAssignment;
Element
elementInternalKeyCode;
String
strInternalKeyCode;
/*
de:
* Liste alle <FrameIndividualAssignment>-Elemente;
* Anzahl und Index zum Durchsuchen der Liste.
*
en:
* List of all <FrameIndividual Assignment>-elements;
* size and index for searching it. */
List
listFrameIndividualAssignment;
int
intlistFrameIndividualAssignmentSize;
int
intlistFrameIndividualAssignmentIndex
= 0;
/*
de:
* Liste alle <FunctionKeyAssignment>-Elemente;
*
Anzahl und Index zum Durchsuchen der Liste.
* en:
*
List of all <FunctionKeyAssignment>-elements,
* size
and index for searching it. */
List
listFunctionKeyAssignment;
int
intlistFunctionKeyAssignmentSize;
int
intlistFunctionKeyAssignmentIndex
= 0;
/*
de:
* Status-Code setzen; damit kann am Ende der Methode
geprüft werden, ob etwas
* unerwünscht gelaufen
ist.
* en: * Set
the StatusCode to OK to see at the end of the method if anything went
wrong. */
StatusCode
=
CONST_OK;
/*
de:
* Prüfen ob überhaupt eine XML-Struktur
vorhanden ist.
* en:
* Initial verification of
there is any XML-structure present. */
if
(XML_RootElement
==
null)
{
/*
de:
* Keine XML-Struktur in der Datei; Status-Code setzen
und
* 'null' Wert zurückliefern.
* en:
*
XML-structure not present within the file; set Status-Code and
*
return a 'null'-value. */
StatusCode
=
CONST_NOT_WELL_FORMED;
return
null;
}
/*
de:
* Allgemeine Prüfung ob ein untergeordnetes
XML-Element für den Bereich
*
<FrameIndividualAssignments> vorhanden ist.
* en:
* General
check if there are child-elements named
* <FrameIndividualAssignments>
present. */
elementFrameIndividualAssignments
=
XML_RootElement.getChild("FrameIndividualAssignments");
if
(elementFrameIndividualAssignments
== null)
{
/*
de:
* Bereich <FrameIndividualAssignments> nicht
vorhanden.
*
Definitionen könnten im Bereich <CommonAssignments>
sein;
* Deswegen vorerst nur den Status-Code
setzen.
* en:
* <FrameIndividualAssignments>-Division
not present.
* Definitions might be in the
<CommonAssignments> division;
* so only the
Status-Code is set for now. */
StatusCode
=
CONST_FRAMEINDIVIDUAL_DIVISION_NOT_PRESENT;
}
/*
de:
* Lesen der Liste mit den
<FrameIndividualAssignment>-Elementen
* und ermitteln
der Anzahl dieser.
* en:
* Get the list
of <FrameIndividualAssignment>-elements
* and
the number of elements within. */
listFrameIndividualAssignment
=
elementFrameIndividualAssignments.getChildren();
intlistFrameIndividualAssignmentSize
= listFrameIndividualAssignment.size();
if
(intlistFrameIndividualAssignmentSize
== 0) {
/*
de:
* Bereich <FrameIndividualAssignments> nicht
vorhanden.
*
Definitionen könnten im Bereich <CommonAssignments>
sein;
* Deswegen vorerst nur den Status-Code
setzen.
* en:
* <FrameIndividualAssignments>-Division
not present.
* Definitions might be in the
<CommonAssignments> division;
* so only the
Status-Code is set for now. */
StatusCode
=
CONST_FRAMECLASS_NOT_PRESENT;
}
/*
de:
* Jedes Element der Liste untersuchen ob der Name der
JFrame-Klasse
* mit jenem Namen übereinstimmt,
*
en: * Inspect
each element of the list to find the element
fitting
the Class-Name of the JFrame passed as parameter. */
for
(intlistFrameIndividualAssignmentIndex
= 0;
intlistFrameIndividualAssignmentIndex <
intlistFrameIndividualAssignmentSize;
intlistFrameIndividualAssignmentIndex++)
{
elementFrameIndividualAssignment
= (Element)
listFrameIndividualAssignment.get(intlistFrameIndividualAssignmentIndex);
/* de:
*
Element <FrameClassName> holen und dessen Wert mit dem Namen
der Klasse,
* die als Parameter übergeben wurde,
vergleichen.
* en: * Get
the element with the <FrameClassName> to compare its content
* with the Class-Name of the passed
parameter. */
elementFrameClassName
=
elementFrameIndividualAssignment.getChild("FrameClassName");
if
(elementFrameClassName
== null)
{
StatusCode
=
CONST_FRAMECLASS_NOT_PRESENT;
}
else
{
strFrameClassName =
elementFrameClassName.getTextTrim();
if
(strFrameClassName.compareTo(parmstrFrameClassName)
== 0) {
/*
de: *
Passendes <FrameClassName>-Element innerhalb der Liste
gefunden. *
Liste mit den <FunctionKeyAssignment>-Elementen bilden und
jedes untersuchen. * en: * Fitting
<FrameClassName>-element found within the list;
* extract
the list of <FunctionKeyAssignment>s and inspect each of
it. */
listFunctionKeyAssignment
=
elementFrameIndividualAssignment.getChildren("FunctionKeyAssignment");
intlistFunctionKeyAssignmentSize
= listFunctionKeyAssignment.size();
if
(intlistFunctionKeyAssignmentSize
==
0) {
StatusCode
=
CONST_GUI_ELEMENT_NOT_PRESENT;
}
for
(intlistFunctionKeyAssignmentIndex
= 0;
intlistFunctionKeyAssignmentIndex
< intlistFunctionKeyAssignmentSize;
intlistFunctionKeyAssignmentIndex++) {
elementFunctionKeyAssignment
=
(Element)
listFunctionKeyAssignment.get(intlistFunctionKeyAssignmentIndex);
/*
de: *
Vergleichen ob der <InternalKeyCode> des XML-Elements
<FunctionKeyAssignment> *
jenem entspricht der als Parameter übergeben wurde. * en: *
Check
if the <InternalKeyCode> of the inspected
<FunctionKeyAssignment> *
fits
the searched one passed as parameter. */
elementInternalKeyCode
=
elementFunctionKeyAssignment.getChild("InternalKeyCode");
if
(elementInternalKeyCode
!=
null)
{
strInternalKeyCode =
elementInternalKeyCode.getTextTrim();
if
(strInternalKeyCode
!=
null)
{
if
(strInternalKeyCode.compareTo(parmstrInternalKeyCode)
== 0)
/*
de: *
XML-Element für
den gesuchten InternalKeyCode und FrameClassName gefunden;
*
XML-Element an die aufrufende Methode zurückgeben. * en: *
XML-element
for searched InternalKeyCode and FrameClassName found; *
return
the XML-element. */
return
elementFunctionKeyAssignment;
}
}
}
}
}
}
/*
de:
* Gesuchtes Element bis jetzt nicht in der XML-Struktur
gefunden;
* Bereich <CommonAssignments> durchsuchen
und zurückliefern was dort gefunden wird.
*
en: *
Searched element not found within the XML-structure till now;
* search the <CommonAssignments> division and return
what is found there. */
StatusCode
=
CONST_GUI_ELEMENT_NOT_PRESENT;
return getCommonKeyByInternalKeyCode(parmstrInternalKeyCode);
}
/*
*
************************************************** */
/* de:
*
Methode zum 'Holen' eines XML-Elementes aus dem Bereich
<CommonAssignments>
* mit dem als Parameter
übergebenem Namen des zugehörigen Buttons
(Schaltfläche).
* en: *
Method to 'get' a XML-Element belonging to the <CommonAssignments>
division *
with the name of the assigned button which was passed as parameter.
*/
private
Element
getCommonKeyByButtonName(String parmstrButtonName)
{
/*
* Variables:
*/
/*
de:
* Element für den Bereich <CommonAssignments>,
* Element für ein <FunctionKeyAssignment>,
*
Element für den <ButtonName> und
* Zeichenkette
für den Wert des Elementes <ButtonName>.
* en:
*
Element for the <CommonAssignments> Division,
*
element for one <FunctionKeyAssignment>,
* element for
the <ButtonName> and
* String with the assigned Name
of the Button. */
Element
elementCommonAssignments;
Element
elementFunctionKeyAssignment;
Element
elementButtonName;
String
strButtonName;
/*
de:
* Liste mit allen Elementen <FunctionKeyAssignment>,
Anzahl und Index.
* en:
* List of all
<FunctionKeyAssignment>-elements, size and index. */
List
listFunctionKeyAssignment;
int
intlistFunctionKeyAssignmentSize;
int
intlistFunctionKeyAssignmentIndex
= 0;
/*
de:
* Prüfen ob überhaupt eine XML-Struktur
vorhanden ist.
* en:
* Initial verification of
there is any XML-structure present. */
if
(XML_RootElement
==
null)
{
/*
de:
* Keine XML-Struktur in der Datei; Status-Code setzen
und
* 'null' Wert zurückliefern.
* en:
*
XML-structure not present within the file; set Status-Code and
*
return a 'null'-value. */
StatusCode
=
CONST_NOT_WELL_FORMED;
return
null;
}
/* de:
*
Allgemeine Prüfung ob ein
<FunctionKeyAssignment>-Element
vorhanden ist.
* en:
* General check if there are
child-elements named <CommonAssignments>
present. */
elementCommonAssignments
= XML_RootElement.getChild("CommonAssignments");
if
(elementCommonAssignments
== null)
{
StatusCode
=
CONST_COMMONELEMENTS_DIVISION_NOT_PRESENT;
return
null;
}
/* de:
*
Erstellen der Liste mit den <FunctionKeyAssignment>-Elementen
und
* die Anzahl der Elemente in der Liste.
*
en:
* Get the list of <FunctionKeyAssignment>-elements
and
* the number of elements
within. */
listFunctionKeyAssignment
=
elementCommonAssignments.getChildren();
intlistFunctionKeyAssignmentSize
= listFunctionKeyAssignment.size();
if
(intlistFunctionKeyAssignmentSize
== 0) {
StatusCode
=
CONST_COMMONELEMENTS_DIVISION_NOT_PRESENT;
return
null;
}
/* de:
*
Untersuchen jedes Elements der Liste um jenes zu finden bei dem
*
der Wert von <ButtonName>
mit
dem übergebenen Parameter übereinstimmt.
* en:
*
Inspect each element of the list to find the element
fitting
the Button-Name passed as parameter. */
for
(intlistFunctionKeyAssignmentIndex
= 0;
intlistFunctionKeyAssignmentIndex <
intlistFunctionKeyAssignmentSize;
intlistFunctionKeyAssignmentIndex++)
{
elementFunctionKeyAssignment
=
(Element)
listFunctionKeyAssignment.get(intlistFunctionKeyAssignmentIndex);
/* de:
*
Holen des XML-Elements <ButtonName>
damit
sein Wert mit dem
*
übergebenen Parameter verglichen werden kann.
* en:
*
Get the XML-element <ButtonName> to compare its value
*
with the passed parameter. */
elementButtonName
= elementFunctionKeyAssignment.getChild("ButtonName");
if
(elementButtonName
!= null)
{
/* de:
*
Vergleichen ob das gesuchte Element gefunden wurde;
* sonst
beim nächsten
Element in der Liste mit dem Vergleichen weitermachen.
*
en:
* Compare if the element was found;
*
otherwise skip and continue the comparison with the next element of
the list. */
strButtonName
= elementButtonName.getTextTrim();
if
(strButtonName.compareTo(parmstrButtonName)
== 0) {
/* de:
*
Passendes
<FunctionKeyAssignment>-Element
in der Liste gefunden;
* an die aufrufende Methode zurück
geben !
*
en:
* Fitting <FunctionKeyAssignment>-element found
within the list; return it ! */
return
elementFunctionKeyAssignment;
}
}
}
/* de:
*
Gesuchter ButtonName nicht in der XML-Struktur gefunden; Fehler
zurückgeben
!
*
en:
* Searched ButtonName not found within the
XML-structure; return the error. */
StatusCode
=
CONST_GUI_ELEMENT_COMMON_NOT_PRESENT;
return
null;
}
/*
*
************************************************** */
/* de:
*
Methode zum 'Holen' eines XML-Elementes aus dem Bereich
<CommonAssignments>
* mit dem als Parameter
übergebenem internem Code der Funktionstaste.
* en: *
Method to 'get' a XML-Element belonging to the <CommonAssignments>
division *
with the internal code of the function-key which was passed as
parameter. */
private
Element
getCommonKeyByInternalKeyCode(String parmstrInternalKeyCode)
{
/*
* Variables:
*/
/*
de:
* Element für den Bereich <CommonAssignments>,
* Element für ein <FunctionKeyAssignment>,
*
Element für den <InternalKeyCode> und
*
Zeichenkette für den Wert des Elementes <InternalKeyCode>.
*
en:
* Element for the <CommonAssignments> Division,
* element for one <FunctionKeyAssignment>,
*
element for the <InternalKeyCode> and
* String with
the assigned value of <InternalKeyCode>. */
Element
elementCommonAssignments;
Element
elementFunctionKeyAssignment;
Element
elementInternalKeyCode;
String
strInternalKeyCode;
/*
de:
* Liste mit allen Elementen <FunctionKeyAssignment>,
Anzahl und Index.
* en:
* List of all
<FunctionKeyAssignment>-elements, size and index. */
List
listFunctionKeyAssignment;
int
intlistFunctionKeyAssignmentSize;
int
intlistFunctionKeyAssignmentIndex
= 0;
/*
de:
* Prüfen ob überhaupt eine XML-Struktur
vorhanden ist.
* en:
* Initial verification of
there is any XML-structure present. */
if
(XML_RootElement
==
null)
{
/*
de:
* Keine XML-Struktur in der Datei; Status-Code setzen
und
* 'null' Wert zurückliefern.
* en:
*
XML-structure not present within the file; set Status-Code and
*
return a 'null'-value. */
StatusCode
=
CONST_NOT_WELL_FORMED;
return
null;
}
/* de:
*
Allgemeine Prüfung ob ein
<FunctionKeyAssignment>-Element
vorhanden ist.
* en:
* General check if there are
child-elements named <CommonAssignments>
present. */
elementCommonAssignments
= XML_RootElement.getChild("CommonAssignments");
if
(elementCommonAssignments
== null)
{
StatusCode
=
CONST_COMMONELEMENTS_DIVISION_NOT_PRESENT;
return
null;
}
/* de:
*
Erstellen der Liste mit den <FunctionKeyAssignment>-Elementen
und
* die Anzahl der Elemente in der Liste.
*
en:
* Get the list of <FunctionKeyAssignment>-elements
and
* the number of elements
within. */
listFunctionKeyAssignment
=
elementCommonAssignments.getChildren();
intlistFunctionKeyAssignmentSize
= listFunctionKeyAssignment.size();
if
(intlistFunctionKeyAssignmentSize
== 0) {
StatusCode
=
CONST_COMMONELEMENTS_DIVISION_NOT_PRESENT;
return
null;
}
/* de:
*
Untersuchen jedes Elements der Liste um jenes zu finden bei dem
*
der Wert von <InternalKeyCode>
mit
dem übergebenen Parameter übereinstimmt.
* en:
*
Inspect each element of the list to find the element
fitting
the internal-key-code passed as parameter. */
for
(intlistFunctionKeyAssignmentIndex
= 0;
intlistFunctionKeyAssignmentIndex <
intlistFunctionKeyAssignmentSize;
intlistFunctionKeyAssignmentIndex++)
{
elementFunctionKeyAssignment
=
(Element)
listFunctionKeyAssignment.get(intlistFunctionKeyAssignmentIndex);
/* de:
*
Holen des XML-Elements <InternalKeyCode>
damit
sein Wert mit dem
*
übergebenen Parameter verglichen werden kann.
* en:
*
Get the XML-element <InternalKeyCode> to compare its value
*
with the passed parameter. */
elementInternalKeyCode
=
elementFunctionKeyAssignment.getChild("InternalKeyCode");
if
(elementInternalKeyCode
!= null)
{
/* de:
*
Vergleichen ob das gesuchte Element gefunden wurde;
* sonst
beim nächsten
Element in der Liste mit dem Vergleichen weitermachen.
*
en:
* Compare if the element was found;
*
otherwise skip and continue the comparison with the next element of
the list. */
strInternalKeyCode
= elementInternalKeyCode.getTextTrim();
if
(strInternalKeyCode.compareTo(parmstrInternalKeyCode)
== 0) {
/* de:
*
Passendes
<FunctionKeyAssignment>-Element
in der Liste gefunden;
* an die aufrufende Methode zurück
geben !
*
en:
* Fitting <FunctionKeyAssignment>-element found
within the list; return it ! */
return
elementFunctionKeyAssignment;
}
}
}
/* de:
*
Gesuchter InternalKeyCode nicht in der XML-Struktur gefunden; Fehler
zurückgeben
!
*
en:
* Searched InternalKeyCode not found within the
XML-structure; return the error. */
StatusCode
=
CONST_GUI_ELEMENT_COMMON_NOT_PRESENT;
return
null;
}
/*
*****
* METHODE, die den JSBS-internen Code einer Funktionstaste
aus dem XML-Element
* <InternalKeyCode> ermittelt.
* en: *
METHOD to get the KeyCode used internally within the JSBS out of a XML-element
* <InternalKeyCode>. */
private
String
getProperty_InternalKeyCode(Element parmelementKey) {
/*
* de: Auslesen des XML-Elements für den <DisplayedKeyCode>.
* en: Get
the XML-element representing <DisplayedKeyCode>.
*/
Element
elementKeyCode =
parmelementKey.getChild("InternalKeyCode");
/*
* de:
* Prüfen ob das XML-Element für <InternalKeyCode> vorhanden ist und auch ein Wert
* vorhanden ist. Dann den JSBS-internen Wert (Zeichenkette) zurück liefern.
* en:
* Verify if the XML-element for the <InternalKeyCode> exists and if it contains a
* value, too. In that case return the value (as a string).
*/ if
(elementKeyCode != null) {
String strInternalKeyCode = elementKeyCode.getTextTrim();
if
(strInternalKeyCode != null)
return strInternalKeyCode;
}
/*
* de:
* XML-Element <InternalKeyCode> nicht vorhanden. Sollte zwar nicht passieren - rechtfertigt
* nicht einen Absturz oder Fehler. Leere Zeichenkette zurück liefern.
* en:
* XML-element <InternalKeyCode> is missing. Should not happen - but not severe enough to
* dump the program or return an error. Return an empty string.
*/ return
"";
}
/*
*****
* METHODE, die den angezeigten Code einer Funktionstaste
aus dem XML-Element
* <DisplayedKeyCode> ermittelt.
* Ist kein <DisplayedKeyCode> in der XML-Struktur definiert damm wird der <InternalKeyCode>
* aus der XML-Struktur ermittelt und
dazu der anzuzeigende Code aus der Klasse
* mit den
System-Services geholt.
* en: *
METHOD to get the KeyCode to be displayed out of a XML-element
<DisplayedKeyCode>.
* If there is no <DisplayedKeyCode> defined within the XML-structure then the
* <InternalKeyCode> is read out of the XML-structure and the language-specific
Key-Code
* to be displayed is read out of the class with the
system-services. */
private
String
getProperty_DisplayedKeyCode(Element parmelementKey) {
/*
* de: Auslesen des XML-Elements für den <DisplayedKeyCode>.
* en: Get
the XML-element representing <DisplayedKeyCode>.
*/
Element
elementKeyCode =
parmelementKey.getChild("DisplayedKeyCode");
/*
* de:
* Prüfen ob das XML-Element für <DisplayedKeyCode> vorhanden ist und auch ein Wert
* vorhanden ist. Dann den Wert (anzuzeigende Zeichenkette) zurück liefern.
* en:
* Verify if the XML-element for the <DisplayedKeyCode> exists and if it contains a
* value, too. In that case return the value (string to be displayed).
*/ if
(elementKeyCode != null) {
String strDisplayedKeyCode = elementKeyCode.getTextTrim();
if
(strDisplayedKeyCode != null)
return strDisplayedKeyCode;
}/*
* de: Auslesen des XML-Elements für den <InternalKeyCode>.
* en: Get
the XML-element representing <InternalKeyCode>.
*/
elementKeyCode =
parmelementKey.getChild("InternalKeyCode");
/*
* de:
* Wenn auch kein <InternalKeyCode> definiert ist dann eine leere Zeichenkette zurück liefern.
* en:
* If an <InternalKeyCode> is missing too, then return an empty string.
*/ if
(elementKeyCode
== null)
return
"";
String strInternalKeyCode = elementKeyCode.getTextTrim();
if
(strInternalKeyCode
== null)
return
"";
/*
de:
* Das XML-Element <InternalKeyCode> enthält
einen gültigen Text;
* die Methode aus der Klasse mit
den System-Services benutzen um den
* sprach-spezifischen
Text für die Anzeige zu ermitteln.
* en:
* The
XML-element <InternalKeyCode> contains a valid Text; use the
method to get
* the language-specific Key-Code for display.
*/
return
JSBS_SystemServices.getDisplayedKeyCode(
strInternalKeyCode,
structJSBS_UniversalParameters.strLanguageCode);
}/*
*****
* de:
* METHODE zum Auslesen des Namens der Schaltfläche (Button); das ist die Referenz
* zum JButton der mit dieser Funktionstaste 'angeklickt' werden soll.
* en: * METHOD to get the Button-Name; that is the reference
to the JButton
* that should be triggered with the
Function-Key. */
private
String
getProperty_ButtonName(Element parmelementKey) {
/*
* de: Auslesen des XML-Elements mit dem <ButtonName>.
* en: Get
the XML-element representing <ButtonName>. */
Element
elementButtonName = parmelementKey.getChild("ButtonName");
if
(elementButtonName
!= null)
return
elementButtonName.getTextTrim();
else
return
"";
}
/*
*****
*
* de:
* METHODE zum Auslesen des Namens der Datei mit dem grafischen Symbol (Icon), das
* auf der Schaltfläche (JButton) oder dem Reiter (Tab) eines JTabbedPane angezeigt
* werden soll.
* en:
* METHOD to get the File-Name for the Icon to be
attached to the JButton or
* the Tab of a JTabbedPane. */
private
String
getProperty_IconFileName(Element parmelementKey) {
/*
* de: Auslesen des XML-Elements mit dem <IconFileName>.
* en: Get
the XML-element representing <IconFileName>. */
Element
elementIconFileName =
parmelementKey.getChild("IconFileName");
if
(elementIconFileName
!= null)
return
elementIconFileName.getTextTrim();
else
return
"";
}
/*
*****
*
* de:
* METHODE zum Auslesen des Namens der Datei mit dem grafischen Symbol (Icon), das
* als 'Warnungs-Hinweis' auf dem Reiter (Tab) eines JTabbedPane angezeigt werden soll.
* en:
* METHOD to get the File-Name for the Icon to be
attached to the Tab of a JTabbedPane
* in the case of a 'Warning'-condition. */
private
String
getProperty_WarningIconFileName(Element parmelementKey) {
/*
* de: Auslesen des XML-Elements mit dem <WarningIconFileName>.
* en: Get
the XML-element representing <WarningIconFileName>. */
Element
elementIconFileName =
parmelementKey.getChild("WarningIconFileName");
if
(elementIconFileName
!= null)
return
elementIconFileName.getTextTrim();
else
return
"";
}/*
* **************************************************
*/
/*
* de:
* Methode, um die Eigenschaften, die
in der XML-Struktur definiert sind,
* auf ein GUI-Element
vom Typ JButton zu übertragen.
* en: * Method
to transfer the properties defined in the XML-structure
* to
a GUI-element of type JButton. */
public
int processJButton(JButton
parmJButton, String parmFrameClassName) {
/*
* de:
* Passendes Element aus der XML-Struktur
finden und alle seine Unter-Elemente
* mit den Eigenschaften
die auf den JButtton übertragen werden sollen.
*
en:
* Find the fitting element out of the XML-structure
and all its
* sub-elements representing all properties to be
transferred to the JButton */
Element
elementKey;
/*
de:
* Prüfen, dass alle übergebenen Parameter
gültig sind; sonst besteht die Gefahr dass
* der Code
sich unvorhergesehen verhält.
* en:
* Verify
that the passed parameters are valid; otherwise there is
unpredicted behaviour. */
if
(parmFrameClassName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmJButton
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
*
de:
* Name des JButton ermitteln und zum Holen des passenden
XML-Elementes verwenden.
* en: * Get
the Name of the JButton; used as identifier to get the fitting <Key>
out of the XML-structure. */
String strButtonName = parmJButton.getName();
if
(strButtonName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
* Get
the fitting Key using the method implemented above. */
elementKey = getKeyByButtonName(parmFrameClassName,
strButtonName);
if
(elementKey
== null)
{
StatusCode
=
CONST_GUI_ELEMENT_NOT_PRESENT;
return
StatusCode;
}
/*
de:
* Im XML-Element <Key> definierte Eigenschaften
auf den JButton, der als
* Parameter übergeben wurde,
übertragen.
* en:
* Transfer the properties of
the XML-element <Key> to the JButton
* that is passed
as parameter. */
/*
First keep the text already assigned to the JButton.
* The text
will be prefixed with the language-specific Key-Code later. */
String strExistingText = parmJButton.getText();
/*
de: Sprach-spezifischen Tasten-Code aus den XML-Element ermitteln.
*
en: Get the language-specific Key-Code out of the XML-element.
*/
String strDisplayedKeyCode =
getProperty_DisplayedKeyCode(elementKey);
/*
de:
* Prüfen ob der Text des JButton bereits mit dem
Tasten-Code beginnt.
* Wenn nicht dann wird der anzuzeigende
Tasten-Code vor dem
* bereits bestehenden Text
eingefügt.
* en:
* Inspect if the text of the
JButton already begins with the Key-Code.
* If not, put
the Key-Code in front of the already assigned text. */
if
(strExistingText.indexOf(strDisplayedKeyCode)
!= 0)
parmJButton.setText(strDisplayedKeyCode
+ "
- " +
strExistingText);
/*
de: Graphisches Symbol (Icon) dem JButton zuordnen.
* en:
Assign the Icon to the JButton. */
String strIconFileName =
structJSBS_UniversalParameters.strGraphicElementsDirectoryName
+
getProperty_IconFileName(elementKey);
parmJButton.setIcon(new
ImageIcon(strIconFileName));
/*
* de:
* Status-Code dieser Klasse zurückliefern;
dieser reflektiert eventuell aufgetretene Fehler. *
en:
* Return the Status-Code of this class; it reflects if
errors occured during processing. */
return
StatusCode;
}
/*
* **************************************************
*/
/*
* de:
* METHODE zum Auslesen der Schaltfläche (JButton) die dem gesuchten Code für die Funktionstaste
* zugeordnet werden soll.
* en: * METHOD to get the name of a Button that is
attached to the searched Function-Key-Code. */
public
String
getButtonName(String parmFrameClassName,
String parmInternalKeyCode) {
/*
*
Variable / Variables:
*/
/*
* de:
* Passendes Element aus der XML-Struktur und
* Elemente die alle Eigenschaften, die dem JButton zugeordnet werden sollen, repräsentieren.
* en:
* Fitting element out of the XML-structure
and
* elements representing all properties to be
transferred to the JButton */
Element
elementKey;
/*
* de: Prüfen dass die übergebenen Parameter gültig sind um unerwartetes Verhalten zu vermeiden.
* en: Verify that the passed parameters are valid;,otherwise there is
unpredicted behaviour. */
if
(parmFrameClassName
== null)
return
"";
if
(parmInternalKeyCode
== null)
return
"";
/*
* de: Passende 'Funktionstaste' mit der weiter oben implementierten Methode auslesen. * en: Get
the fitting Key using the method implemented above */
elementKey = getKeyByInternalKeyCode(parmFrameClassName,
parmInternalKeyCode);
if
(elementKey
== null)
{
StatusCode
=
CONST_GUI_ELEMENT_NOT_PRESENT;
return
"";
}
/*
* de: Wert für <ButtonName> aus dem XML-Element auslesen und zurück liefern.
* en: Get the property for the <ButtonName> out of the XML-element and return it. */
return
getProperty_ButtonName(elementKey);
}
/*
* **************************************************
*/
/*
* de:
* METHODE, um die Eigenschaften, die
in der XML-Struktur definiert sind, auf die * Reiter ('Tabs') der untergeordneten JPanel innerhalb eines JTabbedPane zu übertragen. * Anmerkung: * Das Verarbeiten eines JTabbedPane wurde später in diese Klasse eingefügt weil die * Eigenschaften eines Reiters ('Tab') ähnlich jenen eines JButton sind. * Aus diesem Grund ist in Variablennamen und XML-Elementen oft 'JButton' enthalten; * die XML-Elemente und Variable gelten aber für beide GUI-Elemente gleich. * en: * METHOD
to transfer the properties defined in the XML-structure to the 'Tabs' of the
* subordinate JPanel of a JTabbedPane. * Remark: * The processing of a JTabbedPaned was added later to this class as the properties of * a Tab are similar to the ones of a JButton. * Therefore 'JButton' is used in names of variables and XML-elements; XML-elements and * variables are valid for both GUI-elements. */
public
int processJTabbedPane(JTabbedPane
parmJTabbedPane, String parmFrameClassName) {
/*
de:
* Prüfen, dass alle übergebenen Parameter
gültig sind; sonst besteht die Gefahr dass
* der Code
sich unvorhergesehen verhält.
* en:
* Verify
that the passed parameters are valid; otherwise there is
unpredicted behaviour. */
if
(parmFrameClassName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmJTabbedPane
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
* de:
* Die untergeordneten GUI-Elemente innerhalb des als Parameter übergebenen JTabbedPane
ermitteln
* und jedes einzelne innerhalb der for-Schleife bearbeiten. *
en:
* Get the subordinate GUI-Elements within the JTabbedPane passed as parameter and process each within
* the for-loop.
*/ int
intComponentCount = parmJTabbedPane.getComponentCount(); int
intComponentIndex; for
(intComponentIndex = 0; intComponentIndex < intComponentCount; intComponentIndex++) {
/* de:
* Herausholen des untergeordneten GUI-Elements und vergleichen, ob es von der Klasse 'JPanel' ist.
* Nur ein 'JPanel' wird weiter bearbeitet. *
en:
* Get the subordinate GUI-Element and compare if it is of class 'JPanel', Only a 'JPanel' is
* processed further.
*/ Component comp = parmJTabbedPane.getComponentAt(intComponentIndex);
if
(! (comp instanceof JPanel))
continue;
/* de:
* Component wieder einem JPanel zuweisen (cast) und den Namen des JPanel auslesen. *
en:
* Cast the Component to a JPanel again and get the name of the JPanel.
*/
JPanel locJPanel = (JPanel) comp;
String
strJPanelName = locJPanel.getName();
/* de:
* Wenn dem JPanel kein Name zugewiesen ist kann auch kein passendes XML-Element gefunden werden;
* weiter in der for-Schleife mit dem nächsten JPanel innerhalb des JTabbedPane. *
en:
* If a name was not assigned to the JPanel then it is impossible to find a fitting XML-element;
* in that case continue the for-loop with the next JPanel.
*/
if
(strJPanelName ==
null)
continue;
/* de:
* XML-Element für den Namen des JPanels aus der XML-Struktur auslesen. Wenn kein passendes XML-Element
* gefunden wurde dann weiter in der for-Schleife mit dem nächsten JPanel innerhalb des JTabbedPane. *
en:
* Get the XML-Element fitting to the name of the JPanel out of the XML-structure. If a fitting
* XML-element was not found then continue the for-loop with the next JPanel.
*/ Element
elementKey; elementKey
= getKeyByButtonName(parmFrameClassName, strJPanelName); if
(elementKey
== null)
continue;
/*
de:
* Im XML-Element <FunctionKeyAssignment> definierte Eigenschaften
auf den Reiter (Tab), der zum
* gerade bearbeiteten JPanel gehört, übertragen.
* en:
* Transfer the properties of
the XML-element <FunctionKeyAssignment> to the Tab belonging to
* the JPanel that is just processed. */
/*
de:
* Zuerst den Titel-Text des Reiters (Tab) aufheben. Damit wird im nächsten Schritt überprüft,
* ob bereits der Text der zugeordneten 'Mnemonic'-Taste am Beginn enthalten ist.
* en:
* First keep the text already assigned to the Tab. This is used in the next step to check, if
* the text of the assigne 'Mnemonic'-key is already shown. */
String strExistingText = parmJTabbedPane.getTitleAt(intComponentIndex);
/*
de: Sprach-spezifischen Tasten-Code aus den XML-Element ermitteln.
*
en: Get the language-specific Key-Code out of the XML-element.
*/
String strDisplayedKeyCode =
getProperty_DisplayedKeyCode(elementKey);
/*
de:
* Prüfen ob der Text des Reiters (Tab) bereits mit dem
Tasten-Code beginnt.
* Wenn nicht dann wird der anzuzeigende
Tasten-Code vor dem
* bereits bestehenden Text
eingefügt.
* en:
* Inspect if the text of the Tab already begins with the Key-Code.
* If not, put
the Key-Code in front of the already assigned text. */
if
(strExistingText.indexOf(strDisplayedKeyCode)
!= 0)
parmJTabbedPane.setTitleAt(intComponentIndex, strDisplayedKeyCode
+ "
- " +
strExistingText);
/*
de:
* 'Mnemonic'-Taste zuordnen. 'Mnemonic' ist jene Ziffer oder jener Buchstabe, der gemeinsam mit der 'Alt'-Taste
* bewirkt, das das betroffene JPanel des JTabbedPane in den Vordergrund gebracht wird und Eingaben in den
* enthaltenen GUI-Elementen gemacht werden können.
* Der Tasten-Code für die 'Mnemonic'-Taste hängt vom Betriebssystem ab und wird über den in der XML-Struktur
* zugeordneten JSBS-internen Code ermittelt. *
en:
* Assign the 'Mnemonic'-key. 'Mnemonic' is that number or letter, which causes - together with the 'Alt'-key -
* that the concerned JPanel is brought to front and entries can be made to the included GUI-elements.
* The key-code of the Mnemonic-key depends on the operating-system and is derived from the JSBS-internal
* key-code defined within the XML-structure.
*/
String strInternalKeyCode =
getProperty_InternalKeyCode(elementKey);
int intMnemonicKeyCode =
JSBS_SystemServices.getSystemKeyCodeForInternalKeyCode(strInternalKeyCode);
parmJTabbedPane.setMnemonicAt(intComponentIndex, intMnemonicKeyCode);/*
de: Methode zum zuordnen des graphischen Symbol (Icon) aufrufen.
* en: Call the method to assign the Icon. */
setNormalIcon(parmJTabbedPane, intComponentIndex, elementKey);
}
/*
* de: Status-Code auf OK (fehlerfrei) setzen und zurück liefern. *
en: Set the Status-Code to OK (without error) and return ist. */
StatusCode
=
CONST_OK;
return
StatusCode;
}
/*
* **************************************************
*/
/*
* de:
* METHODEN, um das entsprechende graphische Symbol (Icon) auf dem Reiter (Tab) eines JTabbedPane * zu anzuzeigen. * en: * METHODS
to show the adjacent graphic symbol (icon) on a tab of the JTabbedPane. */
private void setNormalIcon(JTabbedPane
parmJTabbedPane, int parmTabIndex, Element parmKeyElement) {
/*
de:
* Name der Datei mit dem graphischen Symbol (Icon) aus der XML-Struktur auslesen, Verzeichnis
* hinzufügen, Icon erstellen und auf dem Reiter (Tab) platzieren.
* en:
* Read the name of the file with the graphic symbol (Icon) out of the XML-structure, add the
* directory, build an Icon and place it on the Tab. */
String strIconFileName =
structJSBS_UniversalParameters.strGraphicElementsDirectoryName
+
getProperty_IconFileName(parmKeyElement);
parmJTabbedPane.setIconAt(parmTabIndex, new
ImageIcon(strIconFileName));
}/* *****
* Wrapper-Methode / Wrapper-method */
public int setNormalIcon(JTabbedPane
parmJTabbedPane, String parmFrameClassName, String parmPanelName) {
/*
de:
* Prüfen, dass alle übergebenen Parameter
gültig sind; sonst besteht die Gefahr dass
* der Code
sich unvorhergesehen verhält.
* en:
* Verify
that the passed parameters are valid; otherwise there is
unpredicted behaviour. */
if
(parmJTabbedPane
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmFrameClassName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmPanelName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
* de:
* Die untergeordneten GUI-Elemente innerhalb des als Parameter übergebenen JTabbedPane
ermitteln
* und jedes einzelne innerhalb der for-Schleife bearbeiten. *
en:
* Get the subordinate GUI-Elements within the JTabbedPane passed as parameter and process each within
* the for-loop.
*/ int
intComponentCount = parmJTabbedPane.getComponentCount(); int
intComponentIndex; for
(intComponentIndex = 0; intComponentIndex < intComponentCount; intComponentIndex++) {
/* de:
* Herausholen des untergeordneten GUI-Elements und vergleichen, ob es von der Klasse 'JPanel' ist.
* Nur ein 'JPanel' wird weiter bearbeitet. *
en:
* Get the subordinate GUI-Element and compare if it is of class 'JPanel', Only a 'JPanel' is
* processed further.
*/ Component comp = parmJTabbedPane.getComponentAt(intComponentIndex);
if
(! (comp instanceof JPanel))
continue;
/* de:
* Component wieder einem JPanel zuweisen (cast) und den Namen des JPanel auslesen. *
en:
* Cast the Component to a JPanel again and get the name of the JPanel.
*/
JPanel locJPanel = (JPanel) comp;
String
strJPanelName = locJPanel.getName();
/* de:
* Wenn dem JPanel kein Name zugewiesen ist kann auch kein passendes XML-Element gefunden werden;
* weiter in der for-Schleife mit dem nächsten JPanel innerhalb des JTabbedPane. *
en:
* If a name was not assigned to the JPanel then it is impossible to find a fitting XML-element;
* in that case continue the for-loop with the next JPanel.
*/
if
(strJPanelName ==
null)
continue;
/* de:
* Vergleichn ob das (dem JTabbedPane) untergeordnete JPanel den gleichen Namen hat wie der als
* Parameter übergebene. *
en:
* Compare if the subordinate (to the JTabbedPane) JPanel has the same name as the one passed as
* parameter.
*/
if
(strJPanelName.trim().compareTo(parmPanelName.trim()) == 0) {
/* de:
* XML-Element für den Namen des JPanels aus der XML-Struktur auslesen. Wenn kein passendes XML-Element
* gefunden wurde dann diese Methode beenden. *
en:
* Get the XML-Element fitting to the name of the JPanel out of the XML-structure. If a fitting
* XML-element was not found then end this method.
*/ Element
elementKey; elementKey
= getKeyByButtonName(parmFrameClassName, strJPanelName); if
(elementKey
== null) return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
de:
* Im XML-Element <FunctionKeyAssignment> definierte Eigenschaften für das graphische Symbol (Icon)
* auf den Reiter (Tab), der zum gerade bearbeiteten JPanel gehört, übertragen.
* en:
* Transfer the properties for the graphic symbol (icon) of
the XML-element <FunctionKeyAssignment> to
* the Tab belonging to the JPanel that is just processed. */
setNormalIcon(parmJTabbedPane, intComponentIndex, elementKey);
/*
* de: Status-Code auf OK (fehlerfrei) setzen und zurück liefern. *
en: Set the Status-Code to OK (without error) and return ist. */
StatusCode
=
CONST_OK;
return
StatusCode;
}
}
/*
* de:
* Kein XML-Element für die (in den Parametern übergebene) Kombination FrameClassName / PanelName
* in der XML-Struktur definiert; entsprechenden Status-Code setzen und zurück liefern. *
en:
* No fitting XML-element defined within the XML-structure for the combination FramClassName / PanelName
* (passed as parameters); set the status-code and return ist. */
StatusCode
= CONST_GUI_ELEMENT_NOT_PRESENT;
return
StatusCode;
}/* *****
* Wrapper-Methode / Wrapper-method */
public int setNormalIcon(JTabbedPane
parmJTabbedPane, JSBS_TaskFrame parmTF, JPanel parmJPanel) {
/*
de:
* Prüfen, dass alle übergebenen Parameter
gültig sind; sonst besteht die Gefahr dass
* der Code
sich unvorhergesehen verhält.
* en:
* Verify
that the passed parameters are valid; otherwise there is
unpredicted behaviour. */
if
(parmJTabbedPane
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmTF
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmJPanel
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
* de:
* Namen für das übergebene Task-Frame und das JPanel ermitteln und die dafür vorgesehene Methode aufrufen. *
en:
* Get the names for the passed Task-Frame and the JPanel and call the method processing them.
*/ return
setNormalIcon(parmJTabbedPane, parmTF.getClass().getName(), parmJPanel.getName());
}/*
* ********** */
private void setWarningIcon(JTabbedPane
parmJTabbedPane, int parmTabIndex, Element parmKeyElement) {
/*
de:
* Name der Datei mit dem graphischen Symbol (Icon) aus der XML-Struktur auslesen, Verzeichnis
* hinzufügen, Icon erstellen und auf dem Reiter (Tab) platzieren.
* en:
* Read the name of the file with the graphic symbol (Icon) out of the XML-structure, add the
* directory, build an Icon and place it on the Tab. */
String strIconFileName =
structJSBS_UniversalParameters.strGraphicElementsDirectoryName
+
getProperty_WarningIconFileName(parmKeyElement);
parmJTabbedPane.setIconAt(parmTabIndex, new
ImageIcon(strIconFileName));
}/* *****
* Wrapper-Methode / Wrapper-method */
public int setWarningIcon(JTabbedPane
parmJTabbedPane, String parmFrameClassName, String parmPanelName) {
/*
de:
* Prüfen, dass alle übergebenen Parameter
gültig sind; sonst besteht die Gefahr dass
* der Code
sich unvorhergesehen verhält.
* en:
* Verify
that the passed parameters are valid; otherwise there is
unpredicted behaviour. */
if
(parmJTabbedPane
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmFrameClassName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmPanelName
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
* de:
* Die untergeordneten GUI-Elemente innerhalb des als Parameter übergebenen JTabbedPane
ermitteln
* und jedes einzelne innerhalb der for-Schleife bearbeiten. *
en:
* Get the subordinate GUI-Elements within the JTabbedPane passed as parameter and process each within
* the for-loop.
*/ int
intComponentCount = parmJTabbedPane.getComponentCount(); int
intComponentIndex; for
(intComponentIndex = 0; intComponentIndex < intComponentCount; intComponentIndex++) {
/* de:
* Herausholen des untergeordneten GUI-Elements und vergleichen, ob es von der Klasse 'JPanel' ist.
* Nur ein 'JPanel' wird weiter bearbeitet. *
en:
* Get the subordinate GUI-Element and compare if it is of class 'JPanel', Only a 'JPanel' is
* processed further.
*/ Component comp = parmJTabbedPane.getComponentAt(intComponentIndex);
if
(! (comp instanceof JPanel))
continue;
/* de:
* Component wieder einem JPanel zuweisen (cast) und den Namen des JPanel auslesen. *
en:
* Cast the Component to a JPanel again and get the name of the JPanel.
*/
JPanel locJPanel = (JPanel) comp;
String
strJPanelName = locJPanel.getName();
/* de:
* Wenn dem JPanel kein Name zugewiesen ist kann auch kein passendes XML-Element gefunden werden;
* weiter in der for-Schleife mit dem nächsten JPanel innerhalb des JTabbedPane. *
en:
* If a name was not assigned to the JPanel then it is impossible to find a fitting XML-element;
* in that case continue the for-loop with the next JPanel.
*/
if
(strJPanelName ==
null)
continue;
/* de:
* Vergleichn ob das (dem JTabbedPane) untergeordnete JPanel den gleichen Namen hat wie der als
* Parameter übergebene. *
en:
* Compare if the subordinate (to the JTabbedPane) JPanel has the same name as the one passed as
* parameter.
*/
if
(strJPanelName.trim().compareTo(parmPanelName.trim()) == 0) {
/* de:
* XML-Element für den Namen des JPanels aus der XML-Struktur auslesen. Wenn kein passendes XML-Element
* gefunden wurde dann diese Methode beenden. *
en:
* Get the XML-Element fitting to the name of the JPanel out of the XML-structure. If a fitting
* XML-element was not found then end this method.
*/ Element
elementKey; elementKey
= getKeyByButtonName(parmFrameClassName, strJPanelName); if
(elementKey
== null) return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
de:
* Im XML-Element <FunctionKeyAssignment> definierte Eigenschaften für das graphische Symbol (Icon)
* auf den Reiter (Tab), der zum gerade bearbeiteten JPanel gehört, übertragen.
* en:
* Transfer the properties for the graphic symbol (icon) of
the XML-element <FunctionKeyAssignment> to
* the Tab belonging to the JPanel that is just processed. */
setWarningIcon(parmJTabbedPane, intComponentIndex, elementKey);
/*
* de: Status-Code auf OK (fehlerfrei) setzen und zurück liefern. *
en: Set the Status-Code to OK (without error) and return ist. */
StatusCode
=
CONST_OK;
return
StatusCode;
}
}
/*
* de:
* Kein XML-Element für die (in den Parametern übergebene) Kombination FrameClassName / PanelName
* in der XML-Struktur definiert; entsprechenden Status-Code setzen und zurück liefern. *
en:
* No fitting XML-element defined within the XML-structure for the combination FramClassName / PanelName
* (passed as parameters); set the status-code and return ist. */
StatusCode
= CONST_GUI_ELEMENT_NOT_PRESENT;
return
StatusCode;
}/* *****
* Wrapper-Methode / Wrapper-method */
public int setWarningIcon(JTabbedPane
parmJTabbedPane, JSBS_TaskFrame parmTF, JPanel parmJPanel) {
/*
de:
* Prüfen, dass alle übergebenen Parameter
gültig sind; sonst besteht die Gefahr dass
* der Code
sich unvorhergesehen verhält.
* en:
* Verify
that the passed parameters are valid; otherwise there is
unpredicted behaviour. */
if
(parmJTabbedPane
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmTF
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
if
(parmJPanel
== null)
return
CONST_GUI_ELEMENT_NOT_PRESENT;
/*
* de:
* Namen für das übergebene Task-Frame und das JPanel ermitteln und die dafür vorgesehene Methode aufrufen. *
en:
* Get the names for the passed Task-Frame and the JPanel and call the method processing them.
*/ return
setWarningIcon(parmJTabbedPane, parmTF.getClass().getName(), parmJPanel.getName());
}}
xxx
|
Dokument |
Inhalt |
| Datei 'FunctionsKeys.xml' mit der Zuordnung von Funktionstasten zu Schaltflächen (Buttons) | Dieses Dokument beschreibt den Aufbau der Datei 'FunctionKeys.xml'. Aus dieser Datei ('FunctionKeys.xml') werden die Werte mit den Methoden dieser Klasse (JSBS_XML_FunctionKeys) ausgelesen. |