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

In diesem Dokument wird beschrieben, wie 'letzte Feinheiten' zur Gestaltung der Benutzeroberfläche implementiert werden.

Darunter werden folgende Teile der Codierung behandelt:

• Hinzufügen des 'DocumentListener's zu allen GUI-Elementen, bei denen der Benutzer Daten eingeben oder auswählen kann.
  Der 'DocumentListener' 'hört' auf Änderungen von Eingaben in GUI-Elementen und ruft bei einer Änderung vordefinierte Methoden auf.
  Die GUI-Elemente dieses Fensters (Start-Frame / CommandCenter) sind schon vollständig in den Basisklassen des JS-FCF enthalten; aus diesem Grund kann auch der 'DocumentListener' der Basisklassen verwendet werden.

• Einfärben der Ränder des Fensters, der Eingabe-Felder und der Schaltflächen.
  Damit erhält das Fenster ein freundlicheres Aussehen und eine bessere Führung des Benutzers.

• Setzen des 'Focus' auf das Feld für die Eingabe des Auswahl-Codes.
  Damit wird dem Benutzer ermöglicht, sofort einen Code einzugeben ohne zuerst das Auswahl-Feld mit der Maus anklicken zu müssen.

• Aktivieren bzw. Deaktivieren der Schaltflächen. Diese sind nach der 'Construction' generell aktiviert (enabled).
  Nachdem der Benutzer noch keinen Auswahl-Code eingegeben hat, darf er auch noch kein Teilprogramm (Task) aufrufen. Das wird durch die deaktivierte (disabled) Schaltfläche [ Weiter ] signalisiert.

Inhaltsverzeichnis:

Voriger Schritt:Einbindung von Funktionstasten 

Vorbemerkung 
Vorbedingungen 
Zusätzlicher Code 
* DocumentListener zu den GUI-Elementen hinzufügen 
* Borders (Ränder von GUI-Elementen) einfärben 
* Focus beim Programmstart auf das Eingabefeld für den Auswahl-Code setzen 
* Schaltfläche [ Weiter ] beim Programmstart deaktivieren 
* Wiederherstellen von Größe und Position des Fensters – so wie es beim letzten Schließen war 
Test 
Gesamter Code am Ende des Schrittes 
* Klasse JS_ProjAssist_CommandCenter 
* Klasse JS_ProjAssist_CommandCenter__ActionHandler 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt:
Die Entwicklung des Start-Frame (CommandCenter) ist jetzt abgeschlossen.
Wenn Sie noch nicht mit der Entwicklung des Task-Frames begonnen haben, setzen Sie bitte mit Klasse für das Task-Frame zur Verwaltung von Projekt und Sprache eröffnen fort.

Vorbemerkung

▲ zum Inhaltsverzeichnis

Vorbedingungen:

• Voriger Schritt Einbindung von Funktionstasten abgeschlossen.

▲ zum Inhaltsverzeichnis

Zusätzlicher Code

Der zusätzlichen Code ist eine Mischung aus nicht zusammenhängenden Verbesserungen.
Dadurch ist es möglich, nach jedem Abschnitt auch einen Test durchzuführen um zu sehen, wie sich der jeweils zusätzlich implementierte Code auswirkt.

DocumentListener zu den GUI-Elementen hinzufügen

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
. . . . . .
. . . . . .
 * Methode in den Basisklassen aufgerufen und der Code der wählbaren Geschäftsanwendung
 * oder die Nummer der geöffneten Geschäftsanwendung auf das JTextField für die
 * Auswahl (txt_Code) übertragen. */
      get_tree_SelectableTasks().addMouseListener(this);
      get_pnl_OpenTasksTable().addMouseListener(this);
/*
 * DocumentListener (Klasse aus den Basisklassen) 'konstruieren'. */
      structJSBS_StartFrame__DocumentListener = new JSBS_StartFrame__DocumentListener(this);
/*
 * Verschiedene 'Listener's zu den GUI-Elementen hinzufügen
 * Dazu wird die rekursive Methode der Basisklasse verwendet. */
      addListeners(this, structJSBS_StartFrame__DocumentListener);
/*
 * Methode zur Definition einer Schaltfläche als 'Default-Button'.
 * Mit der Enter-Taste (Keyboard) wird auf diesen Button ein 'Klick' ausgelöst. */
      setEnterTriggeredButton(get_btn_Continue());
    }

Der 'DocumentListener' ist eine Klasse, die zu GUI-Elementen, in denen ein Benutzer Eingaben tätigen kann, hinzugefügt wird.
Erkennt die Klasse eine Eingabe dann werden bestimmte Methoden ausgeführt in denen Code platziert werden kann mit dem die Eingabe verarbeitet werden kann.

In diesem Tutorial werden ausschließlich die GUI-Elemente, die schon in der Basisklasse JSBS_StartFrame enthalten sind, verwendet.
Aus diesem Grund kann auch die Basisklasse JSBS_StartFrame__DocumentListener verwendet werden.
Die Implementierung einer speziellen Basisklasse wird im Dokument (noch zu schreiben) ausführlich beschrieben.

Die Anweisung structJSBS_StartFrame__DocumentListener = new JSBS_StartFrame__DocumentListener(this) führt eine 'Construction' des 'DocumentListener'-Objektes durch und übergibt als Parameter das eigene Objekt (this).
Damit hat das Objekt Zugriff auf alle Variablen und Methoden – soferne sie als public deklariert sind.
Damit kann der 'DocumentListener' z.B. auf die Variablen für die zu verwendende Hintergrundfarbe von GUI-Elementen, die in der Struktur structJSBS_UniversalParameters festgelegt ist, zugreifen.

Mit der Anweisung addListeners(this, struct_JSBS_StartFrame__DocumentListener) wird das Objekt für den 'DocumentListener' der Methode übergeben, die alle GUI-Elemente rekursiv untersucht und die jeweils passenden 'Listeners' zu den GUI-Elementen hinzufügt.

▲ zum Inhaltsverzeichnis

Borders (Ränder von GUI-Elmenten) einfärben

Zu einer besseren Unterscheidung der GUI-Elemente werden die Ränder bestimmter GUI-Elemente eingefärbt. Die Farb-Kombonationen sind im Bereich <Layout> der Datei 'DisplayStrings.xml' festgelegt.

package js_projassist.client;
/*
 * Package mit den Klassen zum Bearbeiten von Events. */
import java.awt.event.*;
/*
 * Package mit den Klassen für GUI-Elemente.
 * Benötigt weil Typ JPanel explizit behandelt wird. */
import javax.swing.*;
/*
 * Package mit der Basisklasse für das StartFrame. */

Da in dieser Klasse jetzt der Typ JPanel explizit behandelt wird ist es notwendig, das Java-Package dafür zu importieren.

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
. . . . . . .
. . . . . . .
/*
 * Verschiedene 'Listener's zu den GUI-Elementen hinzufügen
 * Dazu wird die rekursive Methode der Basisklasse verwendet. */
      addListeners(this, structJSBS_StartFrame__DocumentListener);
/*
 * 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 zur Definition einer Schaltfläche als 'Default-Button'.
 * Mit der Enter-Taste (Keyboard) wird auf diesen Button ein 'Klick' ausgelöst. */
. . . . . . .
. . . . . . .

Wenn alle JPanels mit der entsprechenden Farbe eingefärbt würden, wirkt das Erscheinungsbild der GUI etwas merkwürdig.
Daher ist ein Array in der Basisklasse JSBS_StartFrame vorgesehen, in das nur jene JPanels aufgenommen werden, deren Ränder eingefärbt werden sollen.
Sie können als Test ausprobieren, wie die GUI aussieht wenn Sie die Anweisung JSBS_GUIServices.processBorders(this) auskommentieren.

▲ zum Inhaltsverzeichnis

Focus beim Programmstart auf das Eingabefeld für den Auswahl-Code setzen

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
. . . . . . .
. . . . . . .
/*
 * Methode zur Definition einer Schaltfläche als 'Default-Button'.
 * Mit der Enter-Taste (Keyboard) wird auf diesen Button ein 'Klick' ausgelöst. */
      setEnterTriggeredButton(get_btn_Continue());
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Task.
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Code().requestFocusInWindow();
/*
 * Deaktivieren (disable) der Schaltfläche [ Weiter ]. Diese Anweisung ist notwendig weil
 * nach dem Aufruf des Programms alle Schaltflächen (Buttons) aktiviert (enabled) sind
 * und eine Prüfung erst nach Eingabe eines Auswahl-Codes erfolgend würde. */
      structJSBS_StartFrame__DocumentListener.setButtonStatus();
    }

Erklärung der Anweisung: siehe Kommentar im Code ;-) .

▲ zum Inhaltsverzeichnis

Schaltfläche [ Weiter ] beim Programmstart deaktivieren

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
. . . . . . .
. . . . . . .
/*
 * Methode zur Definition einer Schaltfläche als 'Default-Button'.
 * Mit der Enter-Taste (Keyboard) wird auf diesen Button ein 'Klick' ausgelöst. */
      setEnterTriggeredButton(get_btn_Continue());
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Task.
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Code().requestFocusInWindow();
/*
 * Deaktivieren (disable) der Schaltfläche [ Weiter ]. Diese Anweisung ist notwendig weil
 * nach dem Aufruf des Programms alle Schaltflächen (Buttons) aktiviert (enabled) sind
 * und eine Prüfung erst nach Eingabe eines Auswahl-Codes erfolgend würde. */
      structJSBS_StartFrame__DocumentListener.setButtonStatus();
    }

Erklärung der Anweisung: siehe Kommentar im Code ;-) .

▲ zum Inhaltsverzeichnis

Wiederherstellen von Position und Größe des Fensters – so wie es beim letzten Schließen war

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
. . . . . . .
. . . . . . .
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Code().requestFocusInWindow();
/*
 * Deaktivieren (disable) der Schaltfläche [ Weiter ]. Diese Anweisung ist notwendig weil
 * nach dem Aufruf des Programms alle Schaltflächen (Buttons) aktiviert (enabled) sind
 * und eine Prüfung erst nach Eingabe eines Auswahl-Codes erfolgend würde. */
      structJSBS_StartFrame__DocumentListener.setButtonStatus();
/*
 * Methode aufrufen, die die Größe und Position des Fensters beim letzten Schliessen
 * wieder herstellen.
 * Die dafür notwendige Datenstruktur und die aufgerufene Methode ist in der
 * geerbten Basisklasse codiert. */
      setFramePosition();
    }

Erklärung der Anweisung: siehe Kommentar im Code ;-) .

▲ zum Inhaltsverzeichnis

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:

• Zum Starten wird Run > Open Run Dialog ausgewählt.

• Im anschließend erscheinenden Fenster (Run) werden die Einstellungen nicht verändert und durch Anklicken der Schaltfläche [ Run ] das Programm gestartet.

▲ zum Inhaltsverzeichnis

Gesamter Code am Ende des Schrittes

▲ zum Inhaltsverzeichnis

Klasse JS_ProjAssist_CommandCenter

package js_projassist.client;
/*
 * Package mit den Klassen zum Bearbeiten von Events. */
import java.awt.event.*;
/*
 * Package mit den Klassen für GUI-Elemente.
 * Benötigt weil Typ JPanel explizit behandelt wird. */
import javax.swing.*;
/*
 * Package mit der Basisklasse für das StartFrame. */
import js_base.frame.*;
/*
 * Package mit der Basisklasse für die Struktur mit Parametern. */
import js_base.structures.*;
/*
 * Package mit der Basisklasse für die Bearbeitung von
 * Dateien mit XML-Strukturen. */
import js_base.xml.*;
/*
 * Package mit der Basisklasse für die Verbindungen zu Datenbank
 * und Java Application Server (JAS). */
import js_base.connections.*;
/* */
public class JS_ProjAssist_CommandCenter extends JSBS_StartFrame {
/*
 * Constructor der Klasse.
 * Code darin wird aufgerufen wenn ein Objekt dieser Klasse erstellt wird. */
    public JS_ProjAssist_CommandCenter(String parmstrLanguageCode) {
/* 
 * Aufrufen des Constructors der geerbten Klasse;
 * Dort werden die Standard-Initialisierungen ausgeführt. */
      super();
/* 
 * Aufrufen der Methoden mit den individuellen Initialisierungen für diese Klasse. */
      initialize_before_frame(parmstrLanguageCode);
      initialize_frame();
      initialize_after_frame();
    }
/* 
 * Methode mit den Initialisierungen die notwendig sind bevor das Frame (Window)
 * angezeigt wird. */
    private void initialize_before_frame(String parmstrLanguageCode) {
/* 
 * Festlegen mit welcher Art von Datenzugriff das Programm arbeitet.
 * Für dieses Tutorial wird der direkte Zugriff auf eine Datenbank verwendet -
 * nicht die Verwendung eine Java-Application-Servers. */
      RunVersion = CONST_StandAlone;
/* 
 * Initialisieren der Struktur mit den Parametern, die für die gesamte Applikation
 * (inklusive der Task-Frames) gelten.
 * Diese Struktur ist in der geerbten Klasse (JSBS_StartFrame) definiert. */
      structJSBS_UniversalParameters =
                 new JSBS_UniversalParameters(parmstrLanguageCode);
/* 
 * 'Construct' der XML-Struktur mit den sprachabhängigen Texten für GUI-Elemente.
 * Im Constructor wird die XML-Struktur aus der Datei 'DisplayStrings.xml'
 * im Verzeichnis 'TEXT.ls' gelesen wobei 'ls' der ISO-Code der gewählten Sprache
 * (als Parameter der Methode 'main' mitgegeben) ist. */
      structJSBS_XML_DisplayStrings =
                 new JSBS_XML_DisplayStrings(structJSBS_UniversalParameters);
/* 
 * Prüfen ob die XML-Struktur fehlerfrei gelesen werden konnte. */
      if (structJSBS_XML_DisplayStrings.StatusCode != structJSBS_XML_DisplayStrings.CONST_OK) {
/* Fehler beim Einlesen der XML-Struktur; Fehlermeldung und Status-Code auf der Konsole ausgeben.
 * Eine Beschreibung des Fehler-Codes ist in der Interface JSBS_XML_Constants zu finden. */
        System.out.println("Fehler beim Einlesen von 'DisplayStrings.xml'; StatusCode: " +
                           Integer.toString(structJSBS_XML_DisplayStrings.StatusCode));
      }
/* 
 * 'Construct' der XML-Struktur mit den Tasks (Geschäftsanwendungen).
 * Im Constructor wird die XML-Struktur aus der Datei 'Tasks.xml'
 * im Verzeichnis 'TEXT.ls' gelesen wobei 'ls' der ISO-Code der gewählten Sprache
 * (als Parameter der Methode 'main' mitgegeben) ist. */
      structJSBS_XML_Tasks =
                 new JSBS_XML_Tasks(structJSBS_UniversalParameters);
/* 
 * Prüfen ob die XML-Struktur fehlerfrei gelesen werden konnte. */
      if (structJSBS_XML_Tasks.StatusCode != JSBS_XML_Constants.CONST_OK) {
/* Fehler beim Einlesen der XML-Struktur; Fehlermeldung und Status-Code auf der Konsole ausgeben.
 * Eine Beschreibung des Fehler-Codes ist in der Interface JSBS_XML_Constants zu finden. */
        System.out.println("Fehler beim Einlesen von 'Tasks.xml'; StatusCode: " +
                           Integer.toString(structJSBS_XML_Tasks.StatusCode));
      }
      else {
/* XML-Struktur ohne Fehler eingelesen; Methode zum 'bauen' eines JTree mit der
 * Task-Hierarchie aufrufen und den JTree auf das GUI-Element übertragen. */
        tree_SelectableTasks = structJSBS_XML_Tasks.getTaskTree();
      }
    }
/* 
 * 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());
    }
/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
/* 
 * 'Construct' der XML-Struktur mit der Zuordnung der Funktionstasten zu den Buttons
 * (Schaltflächen).
 * Im Constructor wird die XML-Struktur aus der Datei 'FunctionKeys.xml'
 * im Verzeichnis 'TEXT.ls' gelesen wobei 'ls' der ISO-Code der gewählten Sprache
 * (als Parameter der Methode 'main' mitgegeben) ist. */
      structJSBS_XML_FunctionKeys =
                 new JSBS_XML_FunctionKeys(structJSBS_UniversalParameters);
/* 
 * Prüfen ob die XML-Struktur fehlerfrei gelesen werden konnte. */
      if (structJSBS_XML_FunctionKeys.StatusCode != structJSBS_XML_FunctionKeys.CONST_OK) {
/* Fehler beim Einlesen der XML-Struktur.
 * Nachdem die GUI bereits initialisiert ist wird die Graphische Warnungs- und Fehleranzeige
 * benutzt. */
           handleErrorEvent(this.getClass().getName(), "construct_JSBS_XML_FunctionKeys",
                 (new Integer(structJSBS_XML_FunctionKeys.StatusCode)).toString());
/* Über die Methode 'handleErrorEvent' wird das Programm auch beendet. */
      }
/* 
 * Methode aufrufen mit der alle (in der Datei 'DisplayStrings.xml' definierten)
 * GUI-Elemente mit Text, Font und ToolTipText versehen werden. */
      JSBS_GUIServices.processLanguageDependantElements(this);
/* 
 * Abfragen mit welcher Art von Datenzugriff das Programm arbeitet.
 * Für das Tutorial wird der direkte Zugriff auf die Datenbank verwendet.
 * Um den Code als Beispiel für später verwenden zu können wird trotzdem
 * mit der Abfrage der Datenzugriffs-Version gearbeitet – allerdings bleibt
 * der Teil für den Datenzugriff über eine Java Application Server noch ohne Code. */
      if ((RunVersion == CONST_StandAlone) || (RunVersion == CONST_MobileClient)) {
/* Direkter Zugriff auf die Datenbank notwendig: Connection-Manager konstruieren.
 * Dabei werden die Parameter für den Datenbankzugriff aus der Datei 'Connections.xml'
 * gelesen. */
        structJSBS_DB_ConnectionManager =
            new JSBS_DB_ConnectionManager(structJSBS_UniversalParameters);
/* Prüfen ob die Verbindung zur Datenbank fehlerfrei hergestellt werden konnte. */
        if (structJSBS_DB_ConnectionManager.StatusCode != JSBS_XML_Constants.CONST_OK) {
/* Fehler beim Verbinden zur Datenbank.
 * Nachdem die GUI bereits initialisiert ist wird die Graphische Warnungs- und Fehleranzeige
 * benutzt. */
           handleErrorEvent(this.getClass().getName(), "construct_JSBS_DB_ConnectionManager",
                 (new Integer(structJSBS_DB_ConnectionManager.StatusCode)).toString());
/* Über die Methode 'handleErrorEvent' wird das Programm auch beendet. */
        }
      }
      if ((RunVersion == CONST_FatClient) || (RunVersion == CONST_MobileClient)) {
/* Datenzugriff über JAS notwendig; wird in diesem Tutorial nicht verwendet. */
      }
/*
 * Mouse-Listener zu den Listen mit den wählbaren Geschäftsanwendungen und den
 * geöffneten Geschäftsanwendungen hinzufügen.
 * Damit wird bei einem Mausklick auf eine Auswahlmöglichkeit die entsprechende
 * Methode in den Basisklassen aufgerufen und der Code der wählbaren Geschäftsanwendung
 * oder die Nummer der geöffneten Geschäftsanwendung auf das JTextField für die
 * Auswahl (txt_Code) übertragen. */
      get_tree_SelectableTasks().addMouseListener(this);
      get_pnl_OpenTasksTable().addMouseListener(this);
/*
 * DocumentListener (Klasse aus den Basisklassen) 'konstruieren'. */
      structJSBS_StartFrame__DocumentListener = new JSBS_StartFrame__DocumentListener(this);
/*
 * Verschiedene 'Listener's zu den GUI-Elementen hinzufügen
 * Dazu wird die rekursive Methode der Basisklasse verwendet. */
      addListeners(this, structJSBS_StartFrame__DocumentListener);
/*
 * 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 zur Definition einer Schaltfläche als 'Default-Button'.
 * Mit der Enter-Taste (Keyboard) wird auf diesen Button ein 'Klick' ausgelöst. */
      setEnterTriggeredButton(get_btn_Continue());
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Task.
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Code().requestFocusInWindow();
/*
 * Deaktivieren (disable) der Schaltfläche [ Weiter ]. Diese Anweisung ist notwendig weil
 * nach dem Aufruf des Programms alle Schaltflächen (Buttons) aktiviert (enabled) sind
 * und eine Prüfung erst nach Eingabe eines Auswahl-Codes erfolgend würde. */
      structJSBS_StartFrame__DocumentListener.setButtonStatus();
/*
 * Methode aufrufen, die die Größe und Position des Fensters beim letzten Schliessen
 * wieder herstellen.
 * Die dafür notwendige Datenstruktur und die aufgerufene Methode ist in der
 * geerbten Basisklasse codiert. */
      setFramePosition();
    }
/*
 * Methode main(); diese macht diese Klasse 'startbar'.
 * Diese Methode wird aufgerufen wenn ein Objekt dieser Klasse vom Java-Runtime-Environment
 * als 'Start-Klasse' aufgeruffen wird. */
    public static void main(String[] args) {
/*
 * Übernehmen des Wertes der als Parameter beim Start der Klasse mitgeliefert wurde. */
      String locstrLanguageCode = "";
      if (args.length > 0) locstrLanguageCode = args[0];
      try {
/*
 * 'Construct' eines Objekts dieser Klasse;
 * damit wird der übrige Code dieser Klasse ausgeführt. */
        JS_ProjAssist_CommandCenter aJS_ProjAssist_commandCenter =
             new JS_ProjAssist_CommandCenter(locstrLanguageCode);
      }
      catch (Throwable Exc) {
/* Unerwarteter Fehler beim 'Construct' des Objekts; Fehlermeldung ausgeben. */
        System.out.println("Fehler beim 'construct' der Klasse 'JS_ProjAssist_CommandCenter'.");
        Exc.printStackTrace();
      }
    }
/*
 * 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_CommandCenter__ActionHandler.handleEvent(this, e);
    }
}

▲ zum Inhaltsverzeichnis

Klasse JS_ProjAssist_CommandCenter__ActionHandler

Diese KIasse wurde in diesem Schritt nicht verändert.

Die für diesen Schritt zutreffende Version des Codes finden Sie unter Tutorial: JavaScout ProjectAssist, Start-Frame Grundlagen (Java_Fatclient_01) – Auswählen der Geschäftsanwendung > Gesamter Code am Ende des Schrittes > Klasse JS_ProjAssist_CommandCenter_ActionHandler.

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis