> Inhalt: JavaScout-Fat-Client-Framework (JS-FCF) 

Tutorial: Programmierung mit dem JS-FCF 

Tutorial:
JavaScout ProjectAssist, Task-Frame Finalisierung (Java_Fatclient_01) –
Letzte Feinheiten

* Bitte beachten Sie die Hinweise und Bestimmungen bezüglich Urheberrecht, Haftungsausschluß und geschützte Marken oder Warenzeichen die für dieses Web-Dokument und möglicherweise auch für 'verlinkte' Dokumente gelten.

  • Der Betreiber dieser Web-Site (www.javascout.biz) ist nicht verantwortlich für den Inhalt von Web-Sites, die innerhalb dieses Web-Dokumentes oder anderer Dokumente von www.javascout.biz verlinkt sind.

  • Wenn dieses Web-Dokument oder andere Dokumente dieser Web-Site (www.javascout.biz) Rechte von Ihnen verletzen, oder sie glauben, daß Rechte Anderer (Dritter Personen) dadurch verletzt werden, informieren Sie bitte den Betreiber dieser Web-Site.
    Eine E-Mail können Sie ganz einfach durch anklicken des Symbols oder Textes im Frame rechts oben senden.

Dieses Dokument drucken.

 Letzte Bearbeitung dieses  Dokuments:
2008-06-12



Voraussetzungen für das Verständnis dieses Dokuments:

Grundkenntnisse in der Programmierung von Java (Klassen, Methoden, Schleifen) oder anderer Objekt-Orientierter Programmiersprachen (z.B. C++, Modula-2, Pascal).

Tutorial Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) durchgearbeitet.

Ungefährer Zeitbedarf zum Durcharbeiten dieses Dokuments:

Arbeitszeit:
Ca. 20 bis 60 Minuten; abhängig von der bei den vorigen Beispielen erworbenen Routine.

In diesem Schritt werden verschiedene Code-Teile implementiert die dem Anwendungsprogramm den 'letzten Schliff' geben.

Finalisiert werden:

Inhaltsverzeichnis:

Voriger Schritt: Verwenden des 'DocumentListener' und anderer 'Listener' 

Vorbemerkung 
Vorbedingungen 
Borders (Ränder von GUI-Elementen) einfärben (in Klasse JS_ProjAssist_Project) 
Focus und 'EnterTriggeredButton' beim Programmstart festlegen (in Klasse JS_ProjAssist_Project) 
Zwischen-Test 1 
Focus und 'EnterTriggeredButton' an weiteren Stellen festlegen (in Klasse JS_ProjAssist_Project__ActionHandler) 
Zwischen-Test 2 
Task-Frame in der Liste der 'Aufgerufenen Geschäftsanwendungen' des Start-Frames eintragen 
Zwischen-Test 3 
Funktionstasten zu den Schaltflächen zuordnen 
End-Test 
Gesamter Code am Ende des Schrittes 
* Klasse JS_ProjAssist_Project 
* Klasse JS_ProjAssist_Project__ActionHandler 
* Klasse JS_ProjAssist_Project__DocumentListener 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt:
Die Entwicklung des Task-Frame (Geschäftsanwendung) ist jetzt abgeschlossen.
Wenn Sie noch nicht mit der Implementierung des Codes für den Datenbank-Zugriff über EJB (Enterprise Java Beans) auf einem JAS (Java Application Server) begonnen haben, setzen Sie bitte mit asdf fort.
Alternativ können Sie sich auch mit weiteren Tutorials zu speziellen Themen vertraut machen.

Vorbemerkung

Obwohl Eclipse in 'deutscher Version' installiert werden kann, sind die Abbildungen in diesem Dokument mit der 'english Version' erstellt.
Grund ist, daß zum Zeitpunkt der Erstellung dieses Dokumentes (Oktober 2007) die Eclipse-Texte nur sehr unvollständig ins Deutsche übersetzt sind.
Damit ist (meiner Meinung nach)
1.) Eclipse in deutscher Version wesentlich schwerer verständlich als in englischer Version und
2.) wenn Eclipse weiter übersetzt wird, ist dieses Dokument stark abweichend von den dann vorhandenen deutschen Texten.



Die Verbesserungen der Benutzerführung in diesem Schritt sind nicht allgemein auf jedes Task-Frame übertragbar.

Das Auswählen jener Schaltfläche, die durch die Eingabe-Taste betätigt wird und das Setzen des Positionszeigers (Cursor) ist eine individuelle Entscheidung, die im wesentlichen davon abhängt, welchen Schritt der Anwender vermutlich als nächsten ausführen wird.

▲ zum Inhaltsverzeichnis

Vorbedingungen:

▲ zum Inhaltsverzeichnis

Borders (Ränder von GUI-Elementen) einfärben (in Klasse JS_ProjAssist_Project)

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
/* Methode zum Zuordnen des sprachabhängigen Textes zu den GUI-Elementen aufrufen. */
. . . . .
. . . . .
      structJSBS_EntryRules.addApplicationMandatoryGUIElement(get_txt_LanguageCode());
/*
 * Border (Ränder der GUI-Elemente) einfärben damit sie besser sichtbar sind. */
/* Zuerst jenes Elemente vom Typ JPanel festlegen, das eingefärbt werden soll. */
      arrayJPanelBordersToBeColored = new JPanel[1];
      arrayJPanelBordersToBeColored[0] = get_pnl_Main();
/* 
 * Methode aufrufen mit der die 'Border' eingefärbt werden. */
      JSBS_GUIServices.processBorders(this);
/* Methode zum Anzeigen der aktuell gültigen Projekt-/Sprach-Kombinationen aufrufen. */
      JS_ProjAssist_Project__ActionHandler.redisplayList(this);
. . . . .
. . . . .
    }

▲ zum Inhaltsverzeichnis

Focus und 'EnterTriggeredButton' beim Programmstart festlegen (in Klasse JS_ProjAssist_Project)

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
/* Methode zum Zuordnen des sprachabhängigen Textes zu den GUI-Elementen aufrufen. */
. . . . .
. . . . .
/* 
 * Methode aufrufen mit der die 'Border' eingefärbt werden. */
      JSBS_GUIServices.processBorders(this);
/* Methode zum Anzeigen der aktuell gültigen Projekt-/Sprach-Kombinationen aufrufen. */
      JS_ProjAssist_Project__ActionHandler.redisplayList(this);
/* 
 * Prüfen und Aktivieren / Deaktivieren von Schaltflächen (JButtons). */
      structJS_ProjAssist_Project__DocumentListener.setButtonStatus();
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Datensatz.
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Selection().requestFocus();
/*
 * Festlegen der Schaltfläche (JButton) [ Bearbeiten ] als jene,
 * auf die mit der Enter-Taste ein Mausklick ausgelöst wird. */
      setEnterTriggeredButton(get_btn_Get());
    }

▲ zum Inhaltsverzeichnis

Zwischen-Test 1

Die Einstellungen und die Angabe der zu verwendenden Sprache als Parameter wurden schon im Schritt 2 ausgeführt und bleiben als Einstellung für das 'Project' erhalten.
Die Abfolge zum Starten wurde bereits in den beiden vorigen Schritten mit Abbildungen dokumentiert; deswegen folgen nur Stichworte:

Daraufhin erscheint das Fenster mit der Benutzeroberfläche.

Anmerkung:
Bei der zur Zeit der Erstellung dieses Tutorials (Februar 2008) installierten Version von Java und/oder Eclipse erscheinen die Elemente der Benutzeroberfläche erst nachdem die Größe des Fensters verändert wurde.
Dieser Fehler ist hoffentlich bereits behoben wenn Sie dieses Tutorial durcharbeiten.

Die Auswahl des Task-Frames (durch Eingabe des Codes 'P') wurde bereits ausführlich dokumentiert und wird deswegen nicht mehr mit Abbildungen dokumentiert.

Gegenüber vorigen Schritten sehen Sie folgende Veränderungen:

  • Das Fenster ist mit einem blauen Rahmen versehen.

  • Die Eingabe-Felder 'Projekt-Code' und 'ISO-Sprach-Code' sind mit einem roten Rahmen versehen.
    Das ist das Zeichen, daß bei diesen Feldern eine Eingabe erforderlich ist.

  • Der Positionszeiger ist auf das Feld 'Auswahl' gesetzt.

  • Die Schaltfläche [ Bearbeiten ] ist mit einem grünen Rand versehen.
    Das bedeutet, daß durch Betätigen der 'Eingabe'-Taste (auf der Tastatur) diese Schaltfläche 'angeklickt' wird.
    Die Simulation des 'Mausklicks' ist aber erst wirksam wenn die Schaltfläche 'aktiv' wird.


 

Nach der Eingabe einer gültigen Auswahl wird die Schaltfläche [ Bearbeiten ] 'aktiv'.


 

ENach dem Betätigen der 'Eingabe'-Taste (der Tastatur) wird der ausgewählte Datensatz im Detail-Bereich angezeigt.


 


▲ zum Inhaltsverzeichnis

Focus und 'EnterTriggeredButton' an anderen Stellen festlegen (in Klasse JS_ProjAssist_Project__ActionHandler)

Das Beispiel in diesem Tutorial ist sehr einfach um nicht zu verwirren.
Deswegen ist auch die Steuerung, unter welchen Umständen der Positionszeiger gesetzt wird und der 'EnterTriggeredButton' gewählt wird nicht besonders anspruchsvoll.

Die folgenden Beispiele sollen demonstrieren welche Überlegungen beim Entwurf eines umfangreicheren Task-Frames angestellt werden sollen.
Das Setzen des Positionszeigers in ein Eingabefeld und das Festlegen des 'EnterTriggeredButtons' soll die Zahl der Tastatur-Eingaben bzw. der Maus-Bewegungen für den Anwender auf ein Minimum beschränken.

Alle folgenden Teile des Codes werden in der Klasse JS_ProjAssist_Project__ActionHandler implementiert.



▲ zum Inhaltsverzeichnis

Zwischen-Test 2

Die Einstellungen und die Angabe der zu verwendenden Sprache als Parameter wurden schon im Schritt 2 ausgeführt und bleiben als Einstellung für das 'Project' erhalten.
Die Abfolge zum Starten wurde bereits in den beiden vorigen Schritten mit Abbildungen dokumentiert; deswegen folgen nur Stichworte:

Der einzige Unterschied zum Zwischen-Test 1 ist nur, daß nach dem Anklicken der Schaltfläche [ Kopieren ] der Positionszeiger in das Feld 'ISO-Sprach-Code' positioniert wird und die Schaltfläche [ Speichern ] durch die Eingabe-Taste 'angeklickt' wird.


 


▲ zum Inhaltsverzeichnis

Task-Frame in der Liste der 'Aufgerufenen Geschäftsanwendungen' des Start-Frames eintragen

Im Start-Frame (CommandCenter) ist eine Liste für die geöffneten Task-Frames ('Aufgerufene Geschäftsanwendungen') vorgesehen.
Diese ist bis jetzt noch nicht verwendet.

Um einen Task und die gerade bearbeiteten Daten anzuzeigen, müssen folgende Code-Teile implementiert werden.

▲ zum Inhaltsverzeichnis

Zwischen-Test 3

Die Einstellungen und die Angabe der zu verwendenden Sprache als Parameter wurden schon im Schritt 2 ausgeführt und bleiben als Einstellung für das 'Project' erhalten.
Die Abfolge zum Starten wurde bereits in den beiden vorigen Schritten mit Abbildungen dokumentiert; deswegen folgen nur Stichworte:

Nachdem ein Task-Frame aufgerufen wurde, wird im Command-Center der Auswahl-Code angezeigt.


 

 

Wenn ein Datensatz für die Anzeige der Details ausgewählt wurde, wird die Kurzform der angezeigten Daten ebenfalls angezeigt.


 

 

Es können auch mehrere Fenster für Geschäftsanwendungen geöffnet sein.


 

 

 

Durch Auswahl einer Nummer eine 'Aufgerufenen Geschäftsanwendung' und Anklicken der Schaltfläche [ Weiter ] kann der Focus auf die Geschäftsanwendung gelegt werden.
Die Auswahl kann durch Eingabe der entsprechendne Auswahl-Nummer oder anklicken der Zeile mit der linken Maustaste erfolgen.

Umgekehrt kann durch Anklicken der Schaltfläche [ CommandCenter ] der Focus auf das CommandCenter gelegt werden.


 

 



▲ zum Inhaltsverzeichnis

Funktionstasten zu den Schaltflächen zuordnen

Die Zuordnung von Funktionstasten wurde bereits unter Tutorial JavaScout ProjAssist, Start-Frame Finalisierung (Java_Fatclient_01) – Einbindung von Funktionstasten > Datei mit der XML-Struktur mit der Funktionstasten-Zuordnung erstellen erläutert.

Deswegen folgt nur mehr beispielhaft die zusätzlichen XML-Struktur für die Zuordnung weiterer Funktionstasten.

<FunctionKeyAssignments>
  <FrameIndividualAssignments>
  </FrameIndividualAssignments>
  <CommonAssignments>
    <FunctionKeyAssignment>
      <InternalKeyCode>F1</InternalKeyCode>
      <DisplayedKeyCode>F1</DisplayedKeyCode>
      <ButtonName>btn_Help</ButtonName>
      <IconFileName></IconFileName>
    </FunctionKeyAssignment>
    <FunctionKeyAssignment>
      <InternalKeyCode>F2</InternalKeyCode>
      <DisplayedKeyCode>F2</DisplayedKeyCode>
      <ButtonName>btn_Continue</ButtonName>
      <IconFileName>Icon_Continue.gif</IconFileName>
    </FunctionKeyAssignment>
    <FunctionKeyAssignment>
      <InternalKeyCode>F3</InternalKeyCode>
      <DisplayedKeyCode>F3</DisplayedKeyCode>
      <ButtonName>btn_Get</ButtonName>
      <IconFileName></IconFileName>
    </FunctionKeyAssignment>
    <FunctionKeyAssignment>
      <InternalKeyCode>F4</InternalKeyCode>
      <DisplayedKeyCode>F4</DisplayedKeyCode>
      <ButtonName>btn_Store</ButtonName>
      <IconFileName></IconFileName>
    </FunctionKeyAssignment>
    <FunctionKeyAssignment>
      <InternalKeyCode>F5</InternalKeyCode>
      <DisplayedKeyCode>F5</DisplayedKeyCode>
      <ButtonName>btn_Copy</ButtonName>
      <IconFileName></IconFileName>
    </FunctionKeyAssignment>
  </CommonAssignments>
</FunctionKeyAssignments>

Bei Interesse können Sie auch Symbole für alle oder einzelne Schaltflächen entwerfen und Zuordnen ;-).

▲ zum Inhaltsverzeichnis

End-Test

Die Einstellungen und die Angabe der zu verwendenden Sprache als Parameter wurden schon im Schritt 2 ausgeführt und bleiben als Einstellung für das 'Project' erhalten.
Die Abfolge zum Starten wurde bereits in den beiden vorigen Schritten mit Abbildungen dokumentiert; deswegen folgen nur Stichworte:

Daraufhin erscheint das Fenster mit der Benutzeroberfläche.

Anmerkung:
Bei der zur Zeit der Erstellung dieses Tutorials (Februar 2008) installierten Version von Java und/oder Eclipse erscheinen die Elemente der Benutzeroberfläche erst nachdem die Größe des Fensters verändert wurde.
Dieser Fehler ist hoffentlich bereits behoben wenn Sie dieses Tutorial durcharbeiten.

Die Auswahl des Task-Frames (durch Eingabe des Codes 'P') wurde bereits ausführlich dokumentiert und wird deswegen nicht mehr mit Abbildungen dokumentiert.

Gegenüber vorigen Schritten sehen Sie, daß die Schaltflächen mit dem Hinweis auf die zugeordneten Funktionstasten versehen sind.

Als weiteren Test können Sie das Programm mit den Funktionstasten steuern.


 



▲ zum Inhaltsverzeichnis

Gesamter Code am Ende des Schrittes

▲ zum Inhaltsverzeichnis

Klasse JS_ProjAssist_Project

package js_projassist.client;
/*
 * Packages mit den GUI-Elementen. */
import java.awt.*;
import javax.swing.*;
/*
 * Package mit den Klassen zum Bearbeiten von Events */
import java.awt.event.*;
/*
 * Package mit der Basisklasse für das TaskFrame. */
import js_base.frame.*;
/*
 * Package mit den Business-Objects. */
import js_projassist.boc.*;
/* */
public class JS_ProjAssist_Project extends JSBS_TaskFrame {
/*
 * Zugehöriges DocumentListener Objekt definieren. */
    protected JS_ProjAssist_Project__DocumentListener
                structJS_ProjAssist_Project__DocumentListener;
/*
 * Business-Objects (Client-Side-Klasse) definieren. */
    protected JS_ProjAssist_ProjectLanguage_BOC
                structJS_ProjAssist_ProjectLanguage_BOC_Read;
    protected JS_ProjAssist_ProjectLanguage_BOC
                structJS_ProjAssist_ProjectLanguage_BOC_Processed;
/*
 * Liste mit Business-Objects (Client-Side-Klasse) für die Anzeige definieren. */
    protected JS_ProjAssist_ProjectLanguage_BOC_Set
                structJS_ProjAssist_ProjectLanguage_BOC_Set;
/*
 * GUI-Elemente die für diesen Task-Frame spezifisch sind. */
    protected JLabel lbl_ProjectCode;
    protected JTextField txt_ProjectCode;
    protected JLabel lbl_LanguageCode;
    protected JTextField txt_LanguageCode;
    protected JLabel lbl_TargetDirectoryName;
    protected JTextField txt_TargetDirectoryName;
    protected JButton btn_TargetDirectorySelection;
/*
 * Constructor der Klasse.
 * Code darin wird aufgerufen wenn ein Objekt dieser Klasse erstellt wird.
 * Als Parameter wird das StartFrame (CommandCenter) übernommen;
 * das StartFrame enthält alle Einstellungen, die für die gesamte Anwendung gelten
 * und die Verbindung zu Datenbank oder Java-Application-Server (JAS). */
    public JS_ProjAssist_Project(JS_ProjAssist_CommandCenter parmCC) {
/*
 * Aufruf des Constructors der Basisklasse (JSBS_TaskFrame).
 * Darin werden die Klasse des StartFrames und eventuell Werte einzelner Variablen
 * in lokale Variablen übertragen. */
        super (parmCC);
/* 
 * Aufrufen der Methoden mit den individuellen Initialisierungen für diese Klasse. */
      initialize_before_frame();
      initialize_frame();
      initialize_after_frame();
    }
/* 
 * Methode mit den Initialisierungen die notwendig sind bevor das Frame (Window)
 * angezeigt wird. */
    private void initialize_before_frame() {
/* 
 * 'Konstruieren' der Business-Objects, die in diesem Task-Frame verwendet werden. */
      structJS_ProjAssist_ProjectLanguage_BOC_Read =
                new JS_ProjAssist_ProjectLanguage_BOC(this);
      structJS_ProjAssist_ProjectLanguage_BOC_Processed =
                new JS_ProjAssist_ProjectLanguage_BOC(this);
      structJS_ProjAssist_ProjectLanguage_BOC_Set =
                new JS_ProjAssist_ProjectLanguage_BOC_Set(this);
    }
/* 
 * Methode mit der das Frame (Window) angezeigt wird. */
    private void initialize_frame() {
/* Frame (Window) sichtbar machen (anzeigen). */
      setVisible(true);
/* Anfangsgröße festlegen. */
      setSize(800, 600);
/* Grund-Panel mit den weiteren GUI-Elementen anzeigen.
 * Die GUI-Elemente und deren Anordnung sind in der geerbten Klasse
 * (JSBS_StartFrame) festgelegt. */
      setContentPane(get_pnl_Main());
/* Mouse-Listener zu der JTable, in der die auswählbaren Business-Objects angezeigt
 * werden, hinzufügen. Damit wird beim Anklicken einer Zeile der JTable die Nummer der
 * Zeile in das JTextField für die Auswahl (txt_Selection) übertragen.
 * Das Feststellen der Zeile und das Übertragen wird durch eine Methode in der
 * geerbten Basisklasse durchgeführt. */
      get_pnl_SelectionListTable().addMouseListener(this);
    }
/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
/* Methode zum Zuordnen des sprachabhängigen Textes zu den GUI-Elementen aufrufen. */
      JSBS_GUIServices.processLanguageDependantElements(this);
/* DocumentListener konstruieren und anschlißend die Methode der geerbten Klasse
 * aufrufen mit der die notwendigen Listener zu den GUI-Elementen hinzugefügt werden. */
      structJS_ProjAssist_Project__DocumentListener =
          new JS_ProjAssist_Project__DocumentListener(this);
      addListeners(this.getContentPane(), structJS_ProjAssist_Project__DocumentListener);
/* GUI-Elemente, bei denen eine Eingabe zwingend erforderlich ist ('Mandatory'),
 * festlegen. Die Festlegung hier ist 'stärker' als eine eventuelle Prüf-Regel
 * in der Datei 'DisplayStrings.xml'. */
      structJSBS_EntryRules.addApplicationMandatoryGUIElement(get_txt_ProjectCode());
      structJSBS_EntryRules.addApplicationMandatoryGUIElement(get_txt_LanguageCode());
/*
 * Border (Ränder der GUI-Elemente) einfärben damit sie besser sichtbar sind. */
/* Zuerst jenes Elemente vom Typ JPanel festlegen, das eingefärbt werden soll. */
      arrayJPanelBordersToBeColored = new JPanel[1];
      arrayJPanelBordersToBeColored[0] = get_pnl_Main();
/* 
 * Methode aufrufen mit der die 'Border' eingefärbt werden. */
      JSBS_GUIServices.processBorders(this);
/* Methode zum Anzeigen der aktuell gültigen Projekt-/Sprach-Kombinationen aufrufen. */
      JS_ProjAssist_Project__ActionHandler.redisplayList(this);
/* 
 * Prüfen und Aktivieren / Deaktivieren von Schaltflächen (JButtons). */
      structJS_ProjAssist_Project__DocumentListener.setButtonStatus();
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Datensatz.
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Selection().requestFocus();
/*
 * Festlegen der Schaltfläche (JButton) [ Bearbeiten ] als jene,
 * auf die mit der Enter-Taste ein Mausklick ausgelöst wird. */
      setEnterTriggeredButton(get_btn_Get());
/*
 * Eintragen dieses Tasks in die Tabelle beim CommandCenter.
 * Der von der aufgerufenen Methode zurückgelieferte ID wird verwendet
 * wenn die angezeigten Daten verändert werden sollen.
 * Das Verändern der angezeigten Daten ist sinnvoll, wenn der Anwender einen
 * Datensatz aus der Liste auswählt (Methode 'getForUpdate(..)' in der Klasse
 * xxx__ActionHandler.
 * Der 2. Parameter beim Aufruf der Methode ist der interne Code dieser Klasse
 * in der Datei 'Tasks.xml'.
 * Der 3. Parameter ist eine Kurzfassung der angezeigten Daten.
 * dies Daten sind jetzt noch nicht vorhanden. */
      dblCC_TaskID = frmCC.addOpenTaskFrame(this, "P", "");
    }
/* 
 * ******************************
 * Methoden zum 'Construct' (Initialisierung) der einzelnen GUI-Elemente.
 * */
    protected JLabel get_lbl_ProjectCode() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (lbl_ProjectCode == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          lbl_ProjectCode = new JLabel();
          lbl_ProjectCode.setName("lbl_ProjectCode");
          lbl_ProjectCode.setHorizontalAlignment(SwingConstants.TRAILING);
        }
        catch (Throwable Exc) {
/* Fehler beim 'construct' ist sehr unwahrscheinlich und kann nur beim 'Starten'
 * des Tasks auftreten.
 * Deswegen werden Fehlermeldungen nur auf der Konsole ausgegeben. */
          System.out.println("Error while building lbl_ProjectCode in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return lbl_ProjectCode;
    }
/* */
    protected JTextField get_txt_ProjectCode() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (txt_ProjectCode == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          txt_ProjectCode = new JTextField();
          txt_ProjectCode.setName("txt_ProjectCode");
        }
        catch (Throwable Exc) {
          System.out.println("Error while building txt_ProjectCode in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return txt_ProjectCode;
    }
/* */
    protected JLabel get_lbl_LanguageCode() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (lbl_LanguageCode == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          lbl_LanguageCode = new JLabel();
          lbl_LanguageCode.setName("lbl_LanguageCode");
          lbl_LanguageCode.setHorizontalAlignment(SwingConstants.TRAILING);
        }
        catch (Throwable Exc) {
/* Fehler beim 'construct' ist sehr unwahrscheinlich und kann nur beim 'Starten'
 * des Tasks auftreten.
 * Deswegen werden Fehlermeldungen nur auf der Konsole ausgegeben. */
          System.out.println("Error while building lbl_LanguageCode in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return lbl_LanguageCode;
    }
/* */
    protected JTextField get_txt_LanguageCode() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (txt_LanguageCode == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          txt_LanguageCode = new JTextField();
          txt_LanguageCode.setName("txt_LanguageCode");
        }
        catch (Throwable Exc) {
          System.out.println("Error while building txt_LanguageCode in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return txt_LanguageCode;
    }
/* */
    protected JLabel get_lbl_TargetDirectoryName() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (lbl_TargetDirectoryName == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          lbl_TargetDirectoryName = new JLabel();
          lbl_TargetDirectoryName.setName("lbl_TargetDirectoryName");
          lbl_TargetDirectoryName.setHorizontalAlignment(SwingConstants.LEADING);
        }
        catch (Throwable Exc) {
/* Fehler beim 'construct' ist sehr unwahrscheinlich und kann nur beim 'Starten'
 * des Tasks auftreten.
 * Deswegen werden Fehlermeldungen nur auf der Konsole ausgegeben. */
          System.out.println("Error while building lbl_TargetDirectoryName in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return lbl_TargetDirectoryName;
    }
/* */
    protected JTextField get_txt_TargetDirectoryName() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (txt_TargetDirectoryName == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          txt_TargetDirectoryName = new JTextField();
          txt_TargetDirectoryName.setName("txt_TargetDirectoryName");
/* Direkte Eingabe nicht erlauben; nur über Auswahl aus der Verzeichnis-Struktur. */
          txt_TargetDirectoryName.setEnabled(false);
        }
        catch (Throwable Exc) {
          System.out.println("Error while building txt_TargetDirectoryName in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return txt_TargetDirectoryName;
    }
/* */
    protected JButton get_btn_TargetDirectorySelection() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (btn_TargetDirectorySelection == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          btn_TargetDirectorySelection = new JButton();
          btn_TargetDirectorySelection.setName("btn_TargetDirectorySelection");
/* 
 * Durch den 'ActionListener' wird beim Anklicken der Schaltfläche mit der Maustaste
 * die Methode 'actionPerformed' aufgerufen. */
          btn_TargetDirectorySelection.addActionListener(this);
/* 
 * Über den 'ActionCommand' kann in the Methode 'actionPerformed' abgefragt werden,
 * welche Schaltfläche angeklickt wurde. */
          btn_TargetDirectorySelection.setActionCommand("btn_TargetDirectorySelection");
        }
        catch (Throwable Exc) {
          System.out.println("Error while building btn_TargetDirectorySelection in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return btn_TargetDirectorySelection;
    }
/* 
 * ******************************
 * Methode zum 'Construct' (Initialisierung) des Panels mit den GUI-Elementen für
 * die Abwicklung des Geschäftsfalles.
 * Diese Methode überschreibt das 'Construct' des JPanel (mit gleichem Namen) in der
 * geerbten Methode aus der Klasse JSBS_TaskFrame.
 * */
    protected JPanel get_pnl_DetailFields() {
/* Zuerst Prüfen, ob die Variable bereits 'constructed' (initialisiert) ist. */
      if (pnl_DetailFields == null) {
/* Variable noch nicht 'constructed'; Code für die Initialisierung folgt. */
        try {
          pnl_DetailFields = new JPanel();
          pnl_DetailFields.setName("pnl_DetailFields");
/* 
 * Mit der folgenden Anweisung wird die Eigenschaft 'GridBagLayout festgelegt
 * 'GridBagLayout' unterteilt das JPanel in 'dehnbare' Felder; damit 'wachsen' oder
 * 'schrumpfen' darin platzierte GUI-Elemente abhängig von der Größe des JPanel. */
          pnl_DetailFields.setLayout(new GridBagLayout());
/* 
 * Die folgenden Anweisungen platzieren GUI-Elemente in den 'Feldern' des JPanel. */
/* Zuerst wird eine Variable für die Platzierungs-Eigenschaften erstellt. */
          GridBagConstraints gbc_lbl_ProjectCode = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_lbl_ProjectCode.gridx = 0;
          gbc_lbl_ProjectCode.gridy = 0;
          gbc_lbl_ProjectCode.fill = GridBagConstraints.HORIZONTAL;
          gbc_lbl_ProjectCode.weightx = 1;
          gbc_lbl_ProjectCode.anchor = GridBagConstraints.LINE_END;
          gbc_lbl_ProjectCode.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_lbl_ProjectCode(), gbc_lbl_ProjectCode);
/* 
 * Platzieren des nächsten GUI-Elements. */
          GridBagConstraints gbc_txt_ProjectCode = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_txt_ProjectCode.gridx = 1;
          gbc_txt_ProjectCode.gridy = 0;
          gbc_txt_ProjectCode.fill = GridBagConstraints.HORIZONTAL;
          gbc_txt_ProjectCode.weightx = 1;
          gbc_txt_ProjectCode.anchor = GridBagConstraints.LINE_START;
          gbc_txt_ProjectCode.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_txt_ProjectCode(), gbc_txt_ProjectCode);
/* 
 * Platzieren des nächsten GUI-Elements. */
          GridBagConstraints gbc_lbl_LanguageCode = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_lbl_LanguageCode.gridx = 0;
          gbc_lbl_LanguageCode.gridy = 1;
          gbc_lbl_LanguageCode.fill = GridBagConstraints.HORIZONTAL;
          gbc_lbl_LanguageCode.weightx = 1;
          gbc_lbl_LanguageCode.anchor = GridBagConstraints.LINE_END;
          gbc_lbl_LanguageCode.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_lbl_LanguageCode(), gbc_lbl_LanguageCode);
/* 
 * Platzieren des nächsten GUI-Elements. */
          GridBagConstraints gbc_txt_LanguageCode = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_txt_LanguageCode.gridx = 1;
          gbc_txt_LanguageCode.gridy = 1;
          gbc_txt_LanguageCode.fill = GridBagConstraints.HORIZONTAL;
          gbc_txt_LanguageCode.weightx = 1;
          gbc_txt_LanguageCode.anchor = GridBagConstraints.LINE_START;
          gbc_txt_LanguageCode.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_txt_LanguageCode(), gbc_txt_LanguageCode);
/* 
 * Platzieren des nächsten GUI-Elements. */
          GridBagConstraints gbc_lbl_TargetDirectoryName = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_lbl_TargetDirectoryName.gridx = 0;
          gbc_lbl_TargetDirectoryName.gridy = 2;
          gbc_lbl_TargetDirectoryName.fill = GridBagConstraints.HORIZONTAL;
          gbc_lbl_TargetDirectoryName.weightx = 1;
          gbc_lbl_TargetDirectoryName.anchor = GridBagConstraints.LINE_START;
          gbc_lbl_TargetDirectoryName.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_lbl_TargetDirectoryName(), gbc_lbl_TargetDirectoryName);
/* 
 * Platzieren des nächsten GUI-Elements. */
          GridBagConstraints gbc_txt_TargetDirectoryName = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_txt_TargetDirectoryName.gridx = 0;
          gbc_txt_TargetDirectoryName.gridy = 3;
          gbc_txt_TargetDirectoryName.fill = GridBagConstraints.HORIZONTAL;
          gbc_txt_TargetDirectoryName.weightx = 1;
          gbc_txt_TargetDirectoryName.anchor = GridBagConstraints.LINE_START;
          gbc_txt_TargetDirectoryName.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_txt_TargetDirectoryName(), gbc_txt_TargetDirectoryName);
/* 
 * Platzieren des nächsten GUI-Elements. */
          GridBagConstraints gbc_btn_TargetDirectorySelection = new GridBagConstraints();
/* Definition der Platzierungs-Eigenschaften. */
          gbc_btn_TargetDirectorySelection.gridx = 1;
          gbc_btn_TargetDirectorySelection.gridy = 2;
          gbc_btn_TargetDirectorySelection.fill = GridBagConstraints.BOTH;
          gbc_btn_TargetDirectorySelection.weightx = 1;
          gbc_btn_TargetDirectorySelection.gridheight = 2;
          gbc_btn_TargetDirectorySelection.anchor = GridBagConstraints.LINE_START;
          gbc_btn_TargetDirectorySelection.insets = new Insets(3, 3, 3, 3);
/* Platzieren des GUI-Elements auf dem JPanel. */
          get_pnl_DetailFields().add(get_btn_TargetDirectorySelection(), gbc_btn_TargetDirectorySelection);
        }
        catch (Throwable Exc) {
/* Fehler beim 'construct' ist sehr unwahrscheinlich und kann nur beim 'Starten'
 * des Tasks auftreten.
 * Deswegen werden Fehlermeldungen nur auf der Konsole ausgegeben. */
          System.out.println("Error while building pnl_DetailFields in class JS_ProjAssist_Project");
          Exc.printStackTrace();
        }
      }
      return pnl_DetailFields;
    }
/*
 * Methode die ausgeführt wird wenn ein Klick mit einer Maustaste
 * auf ein GUI-Element, dem der ActionListener hinzugefügt wurde, erfolgt. */
    public void actionPerformed(ActionEvent e) {
/*
 * Gleichnamige Methode in der geerbten Basisklasse aufrufen.
 * Damit werden die 'geerbten' Verarbeitungen (die für alle Anwendungsprogramme
 * gleich sein können) zuerst ausgeführt. */
      super.actionPerformed(e);
/*
 * Weitere Verarbeitung in einer eigenen Klasse mit statischen Methoden. */
      JS_ProjAssist_Project__ActionHandler.handleEvent(this, e);
    }
}

▲ zum Inhaltsverzeichnis

Klasse JS_ProjAssist_Project__ActionHandler

package js_projassist.client;
/*
 * Package mit den Klassen zum Bearbeiten von Events. */
import java.awt.event.*;
/*
 * Package mit den Klassen der GUI-Elemente. */
import java.awt.*;
/*
 * Package und Klassen mit den Status-Codes zum Prüfen auf erfolgreiche Durchführung oder
 * Fehler bei einer Datenbank-Operation. */
import js_base.bo.JSBS_BO;
/*
 * Package und Klassen mit Methoden zum Auslesen von Werten aus GUI-Elementen bzw.
 * Anzeigen von Werten in GUI-Elementen. */
import js_base.frame.JSBS_GUIServices;
/*
 * Package und Klasse für ein zu bearbeitendes Business-Object. */
import js_projassist.bo.JS_ProjAssist_ProjectLanguage_BO;
/**
 *
 * @author kurt@javascout.biz
 * @date 2008-05-10
 *
 * @description
 *  Klasse mit statischen Methoden die ausgeführt werden wenn ein 'event'
 *  (z.B. der Klick einer Maustaste auf eine Schaltfläche) aufgetreten ist.
 *  Detail-Dokumentation finden Sie bei den einzelnen Methoden.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class JS_ProjAssist_Project__ActionHandler {
/*
 * Name der Klasse als Konstante festlegen weil bei statischen Methoden der
 * Name der Klasse nicht über 'getClass().getName() ermittelt werden kann. */
    private static String CONST_ClassName = "JS_ProjAssist_Project__ActionHandler";
/*
 * Methode die ermittelt, bei welchem GUI-Element ein 'ActionEvent' ausgelöst wurde
 * und die entsprechende Methode aufruft. */
    protected static void handleEvent(JS_ProjAssist_Project parmTF,
                                   ActionEvent parmActionEvent) {
/* Zuerst wird die 'Identifikation' des GUI-Element aus dem ActionEvent extrahiert. */
      String cmd = parmActionEvent.getActionCommand().trim();
/* In diesem Stadium des Tutorials wird zur Kontrolle der Action-Command
 * auf der Konsole ausgegeben. */
      System.out.println("ActionCommand: " + cmd);
/* Abfragen von welchem GUI-Element der Event ausgelöst wurde und
 * Aufrufen der entsprechenden Methode. */
      if(cmd.equals("btn_TargetDirectorySelection")) processSelectDirectory(parmTF);
      if(cmd.equals("btn_Store")) store(parmTF);
      if(cmd.equals("btn_Copy")) copy(parmTF);
      if(cmd.equals("btn_Get")) getForUpdate(parmTF);
    }
/*
 * Methode die ausgeführt wird wenn das Stamm-Verzeichnis für generierte Dateien
 * ausgewählt werden soll. */
    private static void processSelectDirectory(JS_ProjAssist_Project parmTF) {
/* 
 * Sprachabhängigen Text für die 'Title-Bar' des File-Dialog-Fensters aus
 * der XML-Datei 'auslesen'. */
      String strTitle =
        parmTF.frmCC.structJSBS_XML_DisplayStrings.getSupplementaryText(
        "Project__ActionHandler*FD_TitleBar");
/* 
 * Fenster für den 'File-Dialog' aufrufen;
 * in diesem kann der Benutzer eine Datei auswählen. */
      FileDialog fd = new FileDialog(parmTF,
                                     strTitle,
                                     FileDialog.LOAD);
/* 
 * Anfangswerte für Verzeichnis und Dateiname setzen und Fenster sichtbar machen. */
      fd.setFile("");
      fd.setDirectory("");
      fd.setVisible(true);
/* 
 * Name für gewähltes Verzeichnis aus dem 'File-dialog' holen und in einen String übertragen. */
      String strDirectoryName = fd.getDirectory();
/* 
 * Verzeichnis im entsprechenden Feld anzeigen. */
      parmTF.get_txt_TargetDirectoryName().setText(strDirectoryName);
    }
/*
 * Methode die ausgeführt wird wenn eingegebene Daten auf der Datenbank gespeichert
 * werden sollen. */
    private static void store(JS_ProjAssist_Project parmTF) {
/* 
 * Werte aus den GUI-Elementen auf die Variablen des BO übertragen.
 * Dabei die Methode der BOC-Klasse verwenden. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.getFromGUI(
        parmTF.get_txt_ProjectCode(), parmTF.get_txt_LanguageCode(),
        parmTF.get_txt_TargetDirectoryName());
/* 
 * Methode des BOC zum Speichern der Daten aufrufen. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.store();
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOC abfragen. */
      switch(parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.StatusCode) {
      case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Eingabefelder für die Werte, die den Anwender-bekannten Schlüssel bilden, sperren. */
        parmTF.get_txt_ProjectCode().setEditable(false);
        parmTF.get_txt_LanguageCode().setEditable(false);
/* Verarbeitetes BO (xxx_Processed) mit neuen Allgemeinen Attributen (Common Attributes) auf das
 * BO, das die Werte, so wie sie auf der Datenbank sind enthält (xxx_Read) kopieren.
 * Damit kann in einem späteren Schritt verglichen werden ob ein Attribut geändert wurde. */
        parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.
            copyFromJS_ProjAssist_ProjectLanguage_BO(
                parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed);
/* Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      case JSBS_BO.CONST_DUPLICATE_KEY:
/* Ein Datensatz mit den Werten, die den Anwender-bekannten Schlüssel bilden, existiert bereits.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode "DupKey") auch die Werte für den Anwender-bekannten
 * Schlüssel als Parameter übergeben. */
        parmTF.handleErrorEvent(CONST_ClassName, "DupKey",
          parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.ProjectCode,
          parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.LanguageCode);
/* Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      default:
/* Ein anderer Fehler ist beim Speichern der Daten aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode "DupKey") auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
        parmTF.handleErrorEvent(CONST_ClassName, "store_DBError",
          Integer.toString(parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.StatusCode),
          parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.StatusMsg);
      }
/*
 * Methode zum Anzeigen der Liste mit den aktuell gültigen Daten aufrufen. */
      redisplayList(parmTF);
/*
 * Methode zum Aktivieren / Deaktivieren von Schaltflächen (JButtons) aufrufen. */
        parmTF.structJS_ProjAssist_Project__DocumentListener.setButtonStatus();
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Datensatz.
 * Damit wird dem Benutzer sofort wieder ermöglicht, eine Auswahl einzugeben. */
      parmTF.get_txt_Selection().requestFocus();
/*
 * Festlegen der Schaltfläche (JButton) [ Bearbeiten ] als jene,
 * auf die mit der Enter-Taste ein Mausklick ausgelöst wird. */
      parmTF.setEnterTriggeredButton(parmTF.get_btn_Get());
    }
/*
 * Methode die ausgeführt wird wenn eingegebene Daten, die auf der Datenbank gespeichert
 * sind, verändert und als neuer Datensatz gespeichert werden sollen. */
    private static void copy(JS_ProjAssist_Project parmTF) {
/* 
 * Anwender darauf aufmerksam machen, daß der Anwender-bekannte Schlüssel
 * nicht gleich bleiben darf. In diesem Tutorial wird der Wert für die Sprache geändert. */
      parmTF.get_txt_LanguageCode().setText("");
/* 
 * Werte aus den GUI-Elementen auf die Variablen des BO übertragen.
 * Dabei die Methode der BOC-Klasse verwenden. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.getFromGUI(
        parmTF.get_txt_ProjectCode(), parmTF.get_txt_LanguageCode(),
        parmTF.get_txt_TargetDirectoryName());
/* 
 * BO kennzeichnen, daß es sich um ein neu eingegebenes BO handelt.
 * Ein 'neues' BO ist durch die Werte '0' im DataSetId und ObjectID zu erkennen. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.DataSetID = 0;
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.ObjectID = 0;
/* 
 * BO auf das BO mit den (von der Datenbank) gelesenen Daten kopieren.
 * Das hat in diesem Schritt des Tutorials noch keine Auswirkungen;
 * später wird aber das Aktivieren und Deaktivieren von Schaltflächen nach einer Datenänderung
 * über den Vergleich der Werte gesteuert. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.
        copyFromJS_ProjAssist_ProjectLanguage_BO(
        parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed);
/* 
 * Eingabefelder für die Werte, die den Anwender-bekannten Schlüssel bilden,
 * für die Eingabe öffnen. */
      parmTF.get_txt_ProjectCode().setEditable(true);
      parmTF.get_txt_LanguageCode().setEditable(true);
/*
 * Methode zum Aktivieren / Deaktivieren von Schaltflächen (JButtons) aufrufen. */
      parmTF.structJS_ProjAssist_Project__DocumentListener.setButtonStatus();
/*
 * Setzen des Focus auf das Feld für das Erfassen des Sprach-Codes.
 * Damit wird der Benutzer darauf hingewiesen, daß zum bestehenden Projekt-Code
 * ein neuer Sprach-Code eingegeben werden muß. */
      parmTF.get_txt_LanguageCode().requestFocus();
/*
 * Festlegen der Schaltfläche (JButton) [ Speichern ] als jene,
 * auf die mit der Enter-Taste ein Mausklick ausgelöst wird. */
      parmTF.setEnterTriggeredButton(parmTF.get_btn_Store());
    }
/*
 * Methode zum Anzeigen der Liste mit den aktuell gültigen Projekt-/Sprach-Kombinationen. */
    protected static void redisplayList(JS_ProjAssist_Project parmTF) {
/* 
 * Methode des BOC-Set zum Selektieren der Daten aufrufen. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.selectAllProjectLanguageCombinations();
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOC-Set abfragen. */
      switch(parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.StatusCode) {
      case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      case JSBS_BO.CONST_NOT_FOUND:
/* Noch keine Daten erfaßt; kein Fehler.
 * Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      default:
/* Ein anderer Fehler ist beim Selektieren aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode "DupKey") auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
        parmTF.handleErrorEvent(CONST_ClassName, "redisplay_DBError",
          Integer.toString(parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.StatusCode),
          parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.StatusMsg);
      }
/* 
 * Werte aus den BO des selektierten Sets auf die JTable der GUI übertragen.
 * Dabei die Methode der BOC-Set-Klasse verwenden.
 * Die Daten-Struktur 'structJSBS_FramePosition_BOC.columnWidthArrey01' ist in der
 * Basisklasse für das Task-Frame (JSBS_TaskFrame) definiert und enthält die Information
 * über die Spaltenbreite für die Tabelle.
 * Die Information über die Spaltenbreite wird in diesem Schritt des Tutorials noch nicht
 * verwendet – ist aber als Parameter für die Methode erforderlich. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.setToGUI(
        parmTF.get_pnl_SelectionListTable(),
        parmTF.structJSBS_FramePosition_BOC.ColumnWidthArray01);
/* 
 * Zuletzt wird noch ermittelt, wieviele BO in der Liste sind und damit die Eingabe-Regel
 * im GUI-Element für die Eingabe der Auswahl festgelegt.
 * Mit dieser Regel kann später (bei der Auswahl für die Detail-Anzeige) geprüft werden,
 * ob mit dem eingegeben Wert auch ein BO ausgewählt werden kann. */
      int intListSize =
            parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.vecRecordSet.size();
/* Die umfangreiche Parameterisierung der Eingabe-Regel wird derzeit nicht genutzt;
 * nicht verwendete Parameter werden durch 'null'-Werte ersetzt. */
      parmTF.structJSBS_EntryRules.setEntryRuleValues(
        parmTF.get_txt_Selection().getName(),
        null, 1, intListSize, null, null, null, null);
/* 
 * Als Service für den Anwender wird, wenn nur ein BO in der Liste enthalten ist,
 * diese gleich zur Auswahl vorgeschlagen. */
      if (intListSize == 1)
            parmTF.get_txt_Selection().setText("1");
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Datensatz.
 * Damit wird dem Benutzer sofort wieder ermöglicht, eine Auswahl einzugeben. */
      parmTF.get_txt_Selection().requestFocus();
    }
/*
 * Methode zum Auswählen eines Business-Objects aus der angezeigten Liste,
 * neuerliches Lesen des BO von der Datenbank (falls ein anderer Anwender in der
 * Zwischenzeit eine Veränderung vorgenommen hat) und Anzeigen der Werte im Detail-Bereich
 * (Teil der GUI mit den GUI-Elementen für die Eingabe von Werten) der GUI. */
    protected static void getForUpdate(JS_ProjAssist_Project parmTF) {
/* 
 * Nummer aus dem Auswahl-Feld der GUI auslesen.
 * Mit der verwendeten Methode wird die (in der Methode 'redisplayList(...)' parameterisierte)
 * Klasse 'JSBS_EntryRules' auf die erlaubten Grenzen für die eingegebene Ziffer geprüft.
 * Bei einem ungültigen Wert wird der Hintergrund rot gefärbt. */
      Integer intSelectedRow =
        JSBS_GUIServices.getInteger(parmTF.get_txt_Selection(), parmTF); 
/* 
 * Bei einer ungültigen Eingabe (auch wenn der Wert außerhalb der erlaubten Grenzen ist)
 * wird von der Methode ein 'null'-Wert zurückgeliefert.
 * In diesem Fall wird die Methode beendet; dem Anwender wird durch den roten Hintergrund
 * die fehlerhafte Eingabe signalisiert. */
      if (intSelectedRow == null) return;
/* 
 * Eingegebene Nummer ist gültig; indiziertes BO in eigenes Objekt übertragen.
 * Durch das eigene Objekt ist der folgende Code leichter lesbar. */
      int intListIndex = intSelectedRow.intValue() - 1;
      JS_ProjAssist_ProjectLanguage_BO structJS_ProjAssist_ProjectLanguage_BO =
        (JS_ProjAssist_ProjectLanguage_BO) 
        parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Set.vecRecordSet.elementAt(intListIndex);
/* 
 * Aktuell gültiges BO von der Datenbank lesen. */
      parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.selectByUserKnownKey(
        structJS_ProjAssist_ProjectLanguage_BO.ProjectCode,
        structJS_ProjAssist_ProjectLanguage_BO.LanguageCode);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOC-Set abfragen. */
      switch(parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.StatusCode) {
      case JSBS_BO.CONST_OK:
/* Datenbank-Operation wie erwartet.
 * Werte auf die GUI-Elemente übertragen. */
        parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.setToGUI(
          parmTF.get_txt_ProjectCode(), parmTF.get_txt_LanguageCode(),
          parmTF.get_txt_TargetDirectoryName());
/* Felder, die Teil des Anwender-bekannten-Schlüssels sind für die Eingabe sperren. */
        parmTF.get_txt_ProjectCode().setEditable(false);
        parmTF.get_txt_LanguageCode().setEditable(false);
/* Werte des BO mit den von der DB gelesenen Daten auf ein weiteres BO kopieren.
 * Dieses BO enthält dann (in einem späteren Schritt implementiert) die aktuell
 * auf der GUI eingegebenen Werte.
 * Damit können Änderungen erkannt werden und damit Schaltflächen aktiviert oder
 * deaktiviert werden. */
        parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Processed.
          copyFromJS_ProjAssist_ProjectLanguage_BO(
          parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read);
/* Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      case JSBS_BO.CONST_NOT_FOUND:
/* In der Liste angezeigtes BO wurde in der Zwischenzeit gelöscht. */
        parmTF.handleErrorEvent(CONST_ClassName, "getForUpdate_NotFound");
/* Verarbeitung innerhalb dieses 'case' mit 'break' beenden. */
        break;
      default:
/* Ein anderer Fehler ist beim Selektieren aufgetreten.
 * Fehlerbehandlungs-Methode (in der Basisklasse für das Task-Frame) aufrufen und zusätzlich
 * zur 'Location' (Klassenname, Locationscode "DupKey") auch den Status-Code und die
 * Fehler-Meldung des BOC als Parameter übergeben. */
        parmTF.handleErrorEvent(CONST_ClassName, "getForUpdate_DBError",
          Integer.toString(parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.StatusCode),
          parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.StatusMsg);
      }
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Datensatz.
 * Damit wird dem Benutzer sofort wieder ermöglicht, eine Auswahl einzugeben. */
      parmTF.get_txt_Selection().requestFocus();
/*
 * Festlegen der Schaltfläche (JButton) [ Bearbeiten ] als jene,
 * auf die mit der Enter-Taste ein Mausklick ausgelöst wird. */
      parmTF.setEnterTriggeredButton(parmTF.get_btn_Get());
/*
 * Bilden einer Kurzform der angezeigten Daten und aufrufen der Methode, die den Eintrag
 * in der angezeigten Liste 'Aufgerufene Geschäftsanwendungen' ändert. */
      parmTF.frmCC.updateOpenTaskFrame(parmTF.dblCC_TaskID,
              parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.ProjectCode + " / " +
              parmTF.structJS_ProjAssist_ProjectLanguage_BOC_Read.LanguageCode);
    }
}

▲ zum Inhaltsverzeichnis

Klasse JS_ProjAssist_Project__DocumentListener

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

Dokument

Inhalt

asdf  

In diesem Dokument wird begonnen, jenen Code zu implementieren, mit dem der Zugriff auf die Datenbank über den EJB- (Enterprise Java Bean) Mechanismus auf einem JAS (Java Application Server) stattfindet.

Weitere Tutorials zu speziellen Themen  

In diesem Abschnitt des Verzeichnis der Tutorials sind jene Dokumente enthalten, die die Implementierung verschiedener spezieller Anforderungen beschreibt.

▲ zum Inhaltsverzeichnis