Tutorial:
JavaScout ProjectAssist, Start-Frame Grundlagen (Java_Fatclient_01) –
Auswählen der Geschäftsanwendung

Als letzter Schritt für die Grundlagen-Codierung eines Start-Frame wird erläutert:

• Das Hinzufügen eines MouseListener zu den GUI-Elementen für 'Wählbare Geschäftsanwendungen' und 'Aufgerufene Geschäftsanwendungen'.

• Das 'Holen' des ausgewählten Codes einer 'Wählbaren Geschäftsanwendung' aus dem GUI-Element vom Typ JTree.

• Das Behandeln eines Klicks auf die Schaltfläche btn_continue; dazu wird eine eigene Klasse ActionHandler erstellt.

Inhaltsverzeichnis:

Voriger Schritt: Weitere XML-Strukturen einlesen 

Vorbemerkung 
Vorbedingungen 
Verweis auf Theorie 
Zusätzlicher Code 
* Import der Bibliotherk java.awt.event.* 
* MouseListener hinzufügen 
* Methode actionPerformed codieren 
Klasse JS_ProjAssist_CommandCenter__ActionHandler eröffnen 
Code für JS_ProjAssist_CommandCenter__ActionHandler 
Test 
Gesamter Code am Ende des Schrittes 
* Klasse JS_ProjAssist_CommandCenter 
* Klasse JS_ProjAssist_CommandCenter__ActionHandler 
Weitere Schritte und verwandte Dokumentation 

Nächste Schritte:
JavaScout ProjectAssist, Start-Frame Finalisierung (Java_Fatclient_01) – Einbindung von Funktionstasten 
(für die finalen Arbeiten am Start-Frame).
JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – Klasse für das Task-Frame zur Verwaltung von Projekt und Sprache eröffnen 
(für den Beginn der Arbeiten am Task-Frame für die Verwaltung von Projekt und Sprache).

Vorbemerkung

▲ zum Inhaltsverzeichnis

Vorbedingungen:

• Tutorial Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) durchgearbeitet – und dessen Vorbedingungen auch.

• Voriger Schritt Text für die GUI-Elemente von XML-Datei einlesen abgeschlossen.

• Datenbank installiert; die Anleitungen in diesem Dokument gehen davon aus, daß eine MySQL-Datenbank so wie im Dokument MySQL Datenbank für die Verwendung mit Java-Programmen einrichten beschrieben eingerichtet wurde.

▲ zum Inhaltsverzeichnis

Verweis auf Theorie:

• Model-View-Controlle (noch zu schreiben).

▲ zum Inhaltsverzeichnis

Zusätzlicher Code

Der zusätzlich implementierte Code folgt dem Schema für die Behandlung von Klicks auf Schaltflächen wie es schon im Dokument Tutorial: Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) - ActionHandler ausführlich beschrieben wurde.

Neuer Code ist das Hinzufügen eines MouseListener zu den GUI-Elementen für die 'Wählbaren Geschäftsanwendungen' und die 'Aufgerufenen Geschäftsanwendungen'.

▲ zum Inhaltsverzeichnis

Import der Bibliothek java.awt.event.*

package js_projassist.client;
/*
 * Package mit den Klassen zum Bearbeiten von Events */
import java.awt.event.*;
/*
 * Package mit der Basisklasse für das StartFrame. */
import js_base.frame.*;


Diese Bibliothek enthält Klassen und Interfaces für die Behandlung von Ereignissen (events); darunter sind auch Klicks mit einer Maustaste auf GUI-Elemente.

▲ zum Inhaltsverzeichnis

MouseListener hinzufügen

/* 
 * Methode mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
. . . . . . . . . .
. . . . . . . . . .
      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) übertagen. */
      get_tree_SelectableTasks().addMouseListener(this);
      get_pnl_OpenTasksTable().addMouseListener(this);
    }
/*
 * 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. */

Das Hinzufügen der MouseListener bewirkt, daß die Methode mouseClicked (in der Basisklasse JSBS_StartFrame) aufgerufen wird wenn eines der GUI-Elemente angeklickt wird. In dieser Methode ist codiert, daß der Code für die 'Wählbare Geschäftsanwendung' bzw. die Nummer der 'Aufgerufenen Geschäftsanwendung' auf das Eingabefeld (txt_Code) übertragen wird.

▲ zum Inhaltsverzeichnis

Methode actionPerformed codieren

/*
 * 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);
    }

Diese Methode wird aufgerufen wenn ein GUI-Element vom Typ JButton, zu dem ein ActionListener hinzugefügt wurde, mit der Maus angeklickt wird. Das Hinzufügen des ActionListener erfolgte bereits in der Basisklasse JSBS_StartFrame.
Eine detaillierte Erklärung der Vorgänge ist im Dokument Tutorial: Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) - ActionHandler beschrieben.

Beim Codieren dieser Anweisung wird JS_ProjAssist_CommandCenter__ActionHandler als fehlerhaft markiert weil diese Klasse noch nicht existiert.

▲ zum Inhaltsverzeichnis

Klasse JS_ProjAssist_CommandCenter__ActionHandler eröffnen

Das Eröffnen der neuen Klasse wird nur in Stichworten und ohne Abbildungen dokumentiert.
Wenn Sie sich unsicher sind, sehen Sie bitte unter Schritt 2: Klasse für das StartFrame eröffnen nach, wie eine Klasse eröffnet wird.

Package: js_projassist.client
Name: JS_ProjAssist_CommandCenter__ActionHandler
[ ] public static void main(String[] args)   (nicht markiert)
[ ] Constructors from superclass   (nicht markiert)
[ ] Inherited abstract methods   (nicht markiert)

▲ zum Inhaltsverzeichnis

Code für JS_ProjAssist_CommandCenter__ActionHandler

Alle Methoden in dieser Klasse sind als static definiert.
Das bedeutet, daß kein Objekt der Klasse 'konstruiert' werden muß um eine Methode ausführen zu können.
Im Gegenzug gibt es aber nicht die Möglichkeit, Werte innerhalb eine Objektes zu speichern wenn eine Methode beendet ist;
in anderen Worten: die Klasse hat kein 'Gedächtnis'.

Zuerst wird der komplette Code der Klasse vorgestellt; spezieller, in vorausgesetzten Tutorials noch nicht erläuterter, Code wird anschließend erklärt.

package js_projassist.client;
 
import java.awt.event.*;
/**
 *
 * @author kurt@javascout.biz
 * @date 2008-03-12
 *
 * @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_CommandCenter__ActionHandler {
/*
 * Methode die ermittelt, bei welchem GUI-Element ein 'ActionEvent' ausgelöst wurde
 * und die entsprechende Methode aufruft. */
    public static void handleEvent(JS_ProjAssist_CommandCenter parmCC,
                                   ActionEvent parmActionEvent) {
/* Zuerst wird die 'Identifikation' des GUI-Element aus dem ActionEvent extrahiert. */
      String cmd = parmActionEvent.getActionCommand().trim();
/* In diesem Stadium des Tutorials wird nur auf Anklicken der Schaltfläche
 * btn_Continue reagiert. */
      if(cmd.equals("btn_Continue")) {
/* Die Prüfung, welcher Code gewählt wurde erfolgt in einer eigenen Methode. */
        openBusinessTask(parmCC);
      }
    }
/*
 * Methode zum Auslesen des gewählten Codes und Aufrufen der Geschäftsanenwendung.
 * Einschränkungen in diesem Stadium des Tutorial:
 * * Es wird nur der Code einer 'wählbaren' Anwendung verarbeitet
 *   (es können noch keine Geschäftsanwendungen geöffnet sein).
 * * Es kann noch keine Anwendung gestartet werden – stattdessen wird der interne Code
 *   auf der Konsole ausgegeben.
 *   (Die Geschäftsanwendung wird erst im nächsten Schritt programmiert.) */
    public static void openBusinessTask(JS_ProjAssist_CommandCenter parmCC) {
/* 
 * Methode der Basisklassen verwenden um den Internen Code der gewählten Anwendung
 * zu ermitteln. */
      String strInternalCode =
          parmCC.structJSBS_XML_Tasks.processParameterFields(
              parmCC.get_txt_Code(),
              parmCC.get_lbl_Parameter1(), parmCC.get_txt_Parameter1(),
              parmCC.get_lbl_Parameter2(), parmCC.get_txt_Parameter2(),
              parmCC.get_lbl_Parameter3(), parmCC.get_txt_Parameter3());
/* 
 * Ab hier kommt der Programm-Code mit dem entsprechend dem 'strInternalCode'
 * die zugehörige Geschäftsanwendung gestartet wird.
 * In diesem Schritt des Tutorial gibt es noch keine Geschäftsanwendung;
 * zur Überprüfung wird der Interne Code auf der Konsole ausgegeben. */
      System.out.println("Interner Code: " + strInternalCode);
    }
}

▲ zum Inhaltsverzeichnis

Methode openBusinessTask(. . .)

/*
 * Methode zum Auslesen des gewählten Codes und Aufrufen der Geschäftsanenwendung.
 * Einschränkungen in diesem Stadium des Tutorial:
 * * Es wird nur der Code einer 'wählbaren' Anwendung verarbeitet
 *   (es können noch keine Geschäftsanwendungen geöffnet sein).
 * * Es kann noch keine Anwendung gestartet werden – stattdessen wird der interne Code
 *   auf der Konsole ausgegeben.
 *   (Die Geschäftsanwendung wird erst im nächsten Schritt programmiert.) */
    public static void openBusinessTask(JS_ProjAssist_CommandCenter parmCC) {
/* 
 * Methode der Basisklassen verwenden um den Internen Code der gewählten Anwendung
 * zu ermitteln. */
      String strInternalCode =
          parmCC.structJSBS_XML_Tasks.processParameterFields(
              parmCC.get_txt_Code(),
              parmCC.get_lbl_Parameter1(), parmCC.get_txt_Parameter1(),
              parmCC.get_lbl_Parameter2(), parmCC.get_txt_Parameter2(),
              parmCC.get_lbl_Parameter3(), parmCC.get_txt_Parameter3());
/* 
 * Ab hier kommt der Programm-Code mit dem entsprechend dem 'strInternalCode'
 * die zugehörige Geschäftsanwendung gestartet wird.
 * In diesem Schritt des Tutorial gibt es noch keine Geschäftsanwendung;
 * zur Überprüfung wird der Interne Code auf der Konsole ausgegeben. */
      System.out.println("Interner Code: " + strInternalCode);
    }
}

Zur Wahrung der Übersichtlichkeit (nicht so sehr in diesem einfachen Programm – sondern wenn dieses Muster bei einem umfangreicheren Projekt angewandt wird) wird in dieser Methode der interne Code der Geschäftanwendung ermittelt.
In der Methode processParameterFields(. . .) wird auch geprüft, ob einzelne Parameter gleich im Command-Center erfaßt werden sollen und dementsprechend die entsprechenden Eingabefelder geöffnet oder gesperrt.
Die Steuerung erfolgt über die XML-Elemente <Parameter1Label>, <Parameter2Label>, und <Parameter3Label> in der Datei 'Tasks.xml'.

Zu diesem Zeitpunkt kann noch keine Geschäftsanwendung aufgerufen werden. Zur Kontrolle wird der interne Code auf der Konsole ausgegeben.

▲ 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 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() {
/* 
 * 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) übertagen. */
      get_tree_SelectableTasks().addMouseListener(this);
      get_pnl_OpenTasksTable().addMouseListener(this);
    }
/*
 * 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

package js_projassist.client;
 
import java.awt.event.*;
/**
 *
 * @author kurt@javascout.biz
 * @date 2008-03-12
 *
 * @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_CommandCenter__ActionHandler {
/*
 * Methode die ermittelt, bei welchem GUI-Element ein 'ActionEvent' ausgelöst wurde
 * und die entsprechende Methode aufruft. */
    public static void handleEvent(JS_ProjAssist_CommandCenter parmCC,
                                   ActionEvent parmActionEvent) {
/* Zuerst wird die 'Identifikation' des GUI-Element aus dem ActionEvent extrahiert. */
      String cmd = parmActionEvent.getActionCommand().trim();
/* In diesem Stadium des Tutorials wird nur auf Anklicken der Schaltfläche
 * btn_Continue reagiert. */
      if(cmd.equals("btn_Continue")) {
/* Die Prüfung, welcher Code gewählt wurde erfolgt in einer eigenen Methode. */
        openBusinessTask(parmCC);
      }
    }
/*
 * Methode zum Auslesen des gewählten Codes und Aufrufen der Geschäftsanenwendung.
 * Einschränkungen in diesem Stadium des Tutorial:
 * * Es wird nur der Code einer 'wählbaren' Anwendung verarbeitet
 *   (es können noch keine Geschäftsanwendungen geöffnet sein).
 * * Es kann noch keine Anwendung gestartet werden – stattdessen wird der interne Code
 *   auf der Konsole ausgegeben.
 *   (Die Geschäftsanwendung wird erst im nächsten Schritt programmiert.) */
    public static void openBusinessTask(JS_ProjAssist_CommandCenter parmCC) {
/* 
 * Methode der Basisklassen verwenden um den Internen Code der gewählten Anwendung
 * zu ermitteln. */
      String strInternalCode =
          parmCC.structJSBS_XML_Tasks.processParameterFields(
              parmCC.get_txt_Code(),
              parmCC.get_lbl_Parameter1(), parmCC.get_txt_Parameter1(),
              parmCC.get_lbl_Parameter2(), parmCC.get_txt_Parameter2(),
              parmCC.get_lbl_Parameter3(), parmCC.get_txt_Parameter3());
/* 
 * Ab hier kommt der Programm-Code mit dem entsprechend dem 'strInternalCode'
 * die zugehörige Geschäftsanwendung gestartet wird.
 * In diesem Schritt des Tutorial gibt es noch keine Geschäftsanwendung;
 * zur Überprüfung wird der Interne Code auf der Konsole ausgegeben. */
      System.out.println("Interner Code: " + strInternalCode);
    }
}

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis