|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.frame;
import
java.util.*;
import
javax.swing.*;/**
*
* @author kurt[at]javascout(dot)biz
* @date
2007-09-30
*
* @description
*
de:
* Struktur mit der Information über ein
geöffnetes Geschäftsfall-Fenster (Task-Frame)
*
das Teil des gesamten Anwendungsprogramms ist.
*
*
In einem Objekt der Klasse JSBS_StartFrame wird ein Vector gebildet,
der alle
* geöffneten Task-Frames zur
Bearbeitung von Geschäftsfällen enthält.
*
Diese Information kann bei Bedarf in einer List-Box (pnl_OpenTasks,
definiert in
* JSBS_StartFrame) angezeigt werden und
auch dazu verwendet werden, vom CommandCenter
*
(Start-Frame) aus ein Task-Frame in den Vordergrund zu
bringen.
*
* en: * Structure
to hold the information about an opened Task-Frame (window)
which is used
* to maintain a business-case and
is
part
of the application.
*
* A Vector is
constructed within an object of class JSBS_StartFrame and this Vector
* contains all opened Task-Frames.
*
This information can be used to display information about the opened
Task-Frames in a
* List-Box (pnl_OpenTasks, define in
JSBS_StartFrame) and allows to bring a certain
* Task-Frame
to front and give it the focus.
*
* @change-log
*
when who why
*
--------------------------------------------------------
*
*/public
class JSBS_OpenedTaskStructure
{/*
*
de:
* Eindeutige Identifikation des geöffneten
Geschäftsfall-Fensters (Task-Frame).
* Diese
Identifikation is notwendig wenn die angezeigten Daten des
Geschäftsfalls
* (z.B. der Produkt-Code eines
Produktes) geändert werden soll oder der Geschäftsfall
*
aus der Liste (Vector in JSBS_TaskFrame) entfernt werden soll nachdem
das Fenster
* für den Geschäftsfall geschlossen
wurde.
* en: *
Unique identifier for the Open Task.
* This identifier
is requiered again when the displayed Task-Data (e.g. the
Product-Code of a Product)
* should be modified or the
Open Task has to be removed from the list (Vector in
JSBS_TaskFrame)
* after the Task-Frame was closed.
*/ public
double dblTaskID;/*
*
de:
* Objekt des Task-Frames. Notwendig wenn das
Geschäftsfall-Fenster in den 'Vordergrund' gebracht
*
werden soll oder automatisch geschlossen werden soll wenn das
CommandCenter geschlossen wird. *
en:
* Object of the Task-Frame. Requiered when the Task
should be brought to the 'Front' or
* automatically be
closed when the CommandCenter is closed. */ public
JSBS_TaskFrame
frmTaskFrame;/*
*
de:
* Auswählbarer Code (dem Anwender bekannter Code
zum Aufrufen des Geschäftsfall-Fensters).
* Verwendet
zur Information des Anwenders welche Bedeutung die angezeigten Daten
in der Liste
* haben. Dieser Code wird aus der XML-Struktur
mit der Liste der Geschäftsfall-Fenster
* (Klasse
JSBS_XML_Tasks) ermittelt.
*
* en: * Selectable
Code (User-Known-Code of the Task).
* Used to inform
the user which Task-Data is displayed within a list.
* This
code is derived from the XML-file with the Task-List (see class
JSBS_XML_Tasks). */ public
String
strSelectableCode;/*
*
de:
* Text der vom Geschäftsfall zur Verfügung
gestellt wird. Dieser Text enthält zusätzliche
*
Information (z.B. den Produkt-Code eines Produktes). *
en:
* Text supplied by the Task; contains additional
information (e.g. the Product-Code of a Product). */ public
String
strTaskData;/*
* --------------------
*
CONSTRUCTOR */ public
JSBS_OpenedTaskStructure
(double
parmTaskID,
JSBS_TaskFrame
parmTaskFrame, String
parmSelectableCode, String parmTaskData) { dblTaskID
=
parmTaskID; frmTaskFrame
=
parmTaskFrame; strSelectableCode
=
parmSelectableCode; strTaskData
=
parmTaskData; }
/*
* *******************
*/
/*
* de:
* METHODE zum Prüfen ob der
eingegebene Auswahl-Wert auf ein geöffnetes
*
Geschäftsfall-Fenster zeigt.
* en:
* METHOD to
verify if the value entered in the field for selection 'points'
* to an Open Task. */ public
static boolean isOpenedTask(Vector
parmOpenedTasks, String parmCode) {/*
*
de:
* Variable mit dem eingegebenen numerischen Wert -
sofern eine gültige Nummer
* eingegeben wurde.
*
en:
* Variable that holds the numeric value entered –
if a valid number was entered. */ int
intNumericSelection;/*
* de: Numerischen Wert holen oder Ausnahme-Behandlung
verwenden um 'false' zurückzugeben.
* en: Get the
numeric variable entered or use the Exception-Handling to return
false. */ try
{/*
*
de:
* Innerhalb des 'try' Blocks wird geprüft ob ein
gültiger numerische Wert übergeben wurde.
* en:
* Within this 'try' block is verified if a valid numeric
value was passed. */
intNumericSelection
= (new
Integer(parmCode.trim())).intValue();/*
*
de:
* Prüfen ob die eingegebene Nummer gültig
ist für ein Elements innerhalb des Vectors
* mit den
geöffneten Geschäftsfallanwendungen.
* en:
*
Verify if the entered number is valid for an Element within the
Vector with the open Tasks. */ if
(intNumericSelection
< 1) return
false; if
(intNumericSelection
> parmOpenedTasks.size()) return
false;/*
*
de:
* Eingegebener numerischer Wert ist gültig;
*
diesen Status an die aufrufende Methode zurück liefern.
*
en:
* Entered numeric value is valid; return this status to
the calling method. */ return
true;
}
catch
(Exception
Exc) {/*
*
de:
* Der eingegebene Wert ist keine Nummer;
*
prüfen ob mindestens ein geöffnetes Geschäftsfall-Fenster
(Task)
* für den gesuchten (angezeigten) Auswahlcode
exisitert und entsprechenden
* boolschen Wert zurück
liefern.
* en:
* The entered value is not a
number;
* verify if at least one open Task exists for the
enteres (displayed) selection-code.
* Return the fitting
boolean value. */ Vector
vecFittingTasks
= getOpenedTasksByDisplayedCode(parmOpenedTasks,
parmCode); if
(vecFittingTasks.size()
> 0) return
true;
else
return false;
} }
/*
*
de: WRAPPER-METHODE für die obige Methode.
* en:
WRAPPER-METHOD for the method above. */ public
static boolean isOpenedTask(Vector
parmOpenedTasks, JTextField parmCode) {/*
*
de:
* Wert (als Zeichenkette) aus dem Eingabefeld
extrahieren und Methode aufrufen, die die Arbeit macht.
*
en:
* Extract the value (as String) from the entry-field and
call the method that is doing the work. */ return
isOpenedTask(parmOpenedTasks,
parmCode.getText().trim()); }
/*
* *******************
*/
/*
* de:
* METHODE um den 'Focus' auf ein
Task-Frame (Geschäftsfall-Fenster) zu setzen.
*
en: * METHOD
to bring the focus to a Task-Frame that was selected. */ public
static boolean focusOpenedTask(Vector
parmOpenedTasks, JTextField parmCode) {/*
*
de: Zuerst prüfen ob eine eingegebene Number gültig ist.
*
en: Verify first if an entered number is valid. */ if
(!
isOpenedTask(parmOpenedTasks, parmCode)) return
false;/*
*
de:
* Eingegebene Nummer gültig zur Auswahl eines
geöffneten Geschäftsfall-Fensters.
* Variable für
diesen numerischen Wert definieren.
* en:
*
Entered number valid to select an already opened Task-Frame.
*
Define the variable for this numeric value. */ int
intNumericSelection;/*
*
de:
* Numerische Variable holen oder Fehler-Behandlung
verwenden um 'false' zurückzuliefern.
* en:
*
Get the numeric variable entered or use the Exception-Handling to
return false. */ try
{
intNumericSelection
= (new
Integer(parmCode.getText().trim())).intValue();
}
catch
(Exception
Exc) {return
false;}/*
*
de:
* Prüfung auf gültigen Werte-Bereich nicht
notwendig weil diese Prüfung bereits beim
* Aufruf der
Methode 'isOpenedTask' erfolgt ist.
* Objekt mit dem
Task-Frame (Geschäftsfall-Fenster) für die weitere
Bearbeitung aus dem
* Vector holen.
* en:
*
No range-checks neccessary as that was check by calling the method
'isOpenedTask'.
* Get the object representing the
Task-Frame out of the Vector for further processing.
*/ JSBS_OpenedTaskStructure
structJSBS_OpenedTaskStructure =
(JSBS_OpenedTaskStructure)
parmOpenedTasks.elementAt(intNumericSelection - 1);/*
*
de:
* JFrame 'bearbeiten' und ihm dabei den 'Focus' geben
und in den Vordergrund bringen.
* Spezielle Behandlung wenn
das JFrame 'iconified' ist; dann das entsprechende Bit
*
ändern.
* en: * Process
the JFrame to give it the focus and bring it to the foreground.
*
Special treatment if the JFrame is 'iconified'; de-iconify it by
deactivating this bit. */ int
intFrameState
=
structJSBS_OpenedTaskStructure.frmTaskFrame.getExtendedState();
intFrameState
&=
~JFrame.ICONIFIED;
structJSBS_OpenedTaskStructure.frmTaskFrame.setExtendedState(intFrameState);/*
*
de:
* JFrame in den Vordergrund bringen (vor alle anderen
angezeigten Fenster) ihm den
* Focus geben.
*
en:
* Bring the JFrame to the Front (of all displayed
windows) and give it the focus.
*/ structJSBS_OpenedTaskStructure.frmTaskFrame.toFront(); structJSBS_OpenedTaskStructure.frmTaskFrame.requestFocusInWindow();/*
*
de: Alles wie erwartet; 'true' zurückliefern. *
en: Everything went as expected; return true. */
return
true; }
/*
*
de:
* METHODE um allen offenen Task-Frames
(Geschäftsfall-Fenster) den Befehl zum
* 'Schliessen'
zu senden.
* en: * METHOD
to send all open Task-Frames the command to 'close'. */ public
static void closeAllOpenTasks(Vector
parmOpenedTasks) {/*
*
de:
* Feststellen wie viele Einträge (offene Fenster)
im Vector vorhanden sind und
* Variable für den Index
definieren.
* en:
* Get the number of entries
(open Task-Frames) of the Vector and define
* a variable for
the index. */ int intVectorSize
= parmOpenedTasks.size(); int intVectorIndex
= 0;/*
*
de:
* In einer 'for'-Schleife jedes Task-Frame aus dem
Vector herausholen und
* die Methode zum Schliessen des
Fensters
aufrufen.
* en:
* Use a 'for'-loop to get each
Task-Frame out of the Vector and call the
* method to close
the window. */ for (intVectorIndex
= (intVectorSize - 1); intVectorIndex >= 0; intVectorIndex--)
{ JSBS_OpenedTaskStructure
structJSBS_OpenedTaskStructure
= (JSBS_OpenedTaskStructure)
parmOpenedTasks.elementAt(intVectorIndex); structJSBS_OpenedTaskStructure.frmTaskFrame.windowClosing(null);
} }
/*
* de:
* METHODE
um alle 'OpenedTaskStructure' (Daten der geöffneten
Geschäftsfall-Fenster)
* für den im
Parameter übergebenen Auswahl Code in einem Vector zurück
zu liefern.
* en: * METHOD
to return all 'OpenedTaskStructure' (data of the opened Task-Frames)
for the
* displayed Selection Code passed in the
parameter within a vector. */ public
static Vector
getOpenedTasksByDisplayedCode(Vector parmOpenedTasks, String
parmDisplayedCode) {/*
* de:
* Vector, der an die aufrufende Methode zurück
geliefert wird, definieren.
* en:
* Define
the vector that is returned to the calling method. */ Vector
vecReturn = new Vector();/*
* de:
* Feststellen wie viele Einträge (offene Fenster)
im Vector vorhanden sind und
* Variable für den
Index definieren.
* en:
* Get the number
of entries (open Task-Frames) of the Vector and define
* a
variable for the index. */ int intVectorSize
= parmOpenedTasks.size(); int intVectorIndex
= 0;/*
*
de:
* In einer 'for'-Schleife jedes Task-Frame aus dem
Vector herausholen und
* den angezeigten Code mit dem Wert
im Parameter vergleichen.
* en:
* Use a 'for'-loop
to get each Task-Frame out of the Vector and compare the
*
displayed code with the value in the parameter.
*/ for (intVectorIndex
= (intVectorSize - 1); intVectorIndex >= 0; intVectorIndex--)
{ JSBS_OpenedTaskStructure
structJSBS_OpenedTaskStructure
= (JSBS_OpenedTaskStructure)
parmOpenedTasks.elementAt(intVectorIndex);/*
* de:
* Vergleichen, ob der 'Task' zum gesuchten Auswahlcode
passt und in diesem Fall die Struktur
* in den Vector
für die Rückgabe einfügen.
* en:
* Compare if the 'Task' fits the requested Displayed
SelectionCode; in that case add the
* structure to
the vector that is returned.
*/ if (structJSBS_OpenedTaskStructure.strSelectableCode.compareTo(parmDisplayedCode)
== 0)
{
vecReturn.addElement(structJSBS_OpenedTaskStructure);
}
}/*
* de:
* Vector mit den gefundenen Tasks an die aufrufende
Methode zurück liefern.
* en:
* Return
the vector with the found tasks to the calling methods.
*/ return vecReturn; }}
xxx
|
Dokument |
Inhalt |
|
Dieser
Leitfaden enthält die notwendigen Tätigkeiten für
die Entwicklung eines StartFrame (auch als Command-Center
bekannt). |