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

Tutorial: Programmierung mit dem JS-FCF 

Tutorial:
JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) –
Liste der Daten anzeigen und zur Bearbeitung auswählen

* 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-01



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 die erfaßten Daten (Projekt/Sprach-Kombinationen) in einer Liste angezeigt.
Aus dieser Liste kann ein Datensatz ausgewählt und dessen Daten im Detail angezeigt werden.

Bei der Anzeige der Detail-Daten können auch Daten, die nicht zum Anwender-bekannten-Schlüssel gehören (in diesem Tutorial nur das Datei-Verzeichnis), verändert werden.

Dazu ist folgender zusätzlicher Code und folgende sprach-abhängige Konfiguration notwendig:

Inhaltsverzeichnis:

Voriger Schritt: Client-Side BO-Set Klasse für eine Liste mit 'ProjectLanguage' Business-Objects 

Vorbemerkung 
Vorbedingungen 
Anzeigen der Liste 
* Object für das BOC-Set in der Klasse JS_ProjAssist_Project definieren und 'konstruieren' 
* Methode zur Anzeige der Liste codieren (in der Klasse JS_ProjAssist_Project__ActionHandler) 
* Methode zur Anzeige der Liste aufrufen 
* Sprachabhängigen Text in der Datei 'DisplayStrings.xml' erfassen 
Zwischen-Test 1 
Auswählen und Anzeigen der Daten eines BO 
* Importieren der notwendigen Bibliotheken 
* Methode zum Auswählen codieren 
* Reagieren auf den Schaltflächen-Klick (Event) 
Test 
Gesamter Code am Ende des Schrittes 
* Klasse JS_ProjAssist_Project 
* Klasse JS_ProjAssist_Project__ActionHandler 
Weitere Schritte und verwandte Dokumentation 

Nächste Schritte:
JavaScout ProjectAssist, Task-Frame Finalisierung (Java_Fatclient_01) – Verwenden des 'DocumentListener' und anderer 'Listener' 
(für die finalen Arbeiten am Task-Frame).
asdf 
(für die Implementierung der Client-Server-Funktionalität über den EJB-Mechanismus).


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.



▲ zum Inhaltsverzeichnis

Vorbedingungen:

▲ zum Inhaltsverzeichnis

Anzeigen der Liste

Um die Liste der bereits erfaßten Business-Objects mit der Projekt-/Sprach-Kombination anzeigen zu können, sind Änderungen des Codes in den Klassen JS_ProjAssist_Project und JS_ProjAssist_Project__ActionHandler notwendig.
Zusätzlich muß die Spalten-Überschrift und die Anordnung der Spalten in der XML-Struktur der Datei 'DisplayStrings.xml' festgelegt werden.

▲ zum Inhaltsverzeichnis

Objekt für das BOC-Set in der Klasse JS_ProjAssist_Project definieren und 'konstruieren'

Die Definition der Variable erfolgt in dem Block, in dem schon die BO für 'ProjectLanguage' zum Zeitpunkt des Lesens von der Datenbank und mit den aktuellen, auf der GUI eingegebenen, Werten definiert sind.

public class JS_ProjAssist_Project extends JSBS_TaskFrame {
. . . . .
. . . . .
/*
 * 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;
. . . . .
. . . . .

Zuletzt muß die Variable noch 'konstruiert' werden:

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

▲ zum Inhaltsverzeichnis

Methode zur Anzeige der Liste codieren (in der Klasse JS_ProjAssist_Project__ActionHandler)

In diesem Tutorial ist das Anzeigen der Liste mit den aktuell gültigen Projekt-/Sprache-Kombinationen einfach gestaltet.
Bei 'realen' Anforderungen wird wahrscheinlich erforderlich sein, Selektionskriterien als Parameter zu übergeben.

▲ zum Inhaltsverzeichnis

Methode zur Anzeige der Liste aufrufen

Die im vorigen Abschnitt codierte Methode zum Anzeigen der Liste wird an zwei Stellen aufgerufen.

▲ zum Inhaltsverzeichnis

Sprachabhängigen Text in der Datei 'DisplayStrings.xml' erfassen

Diese Datei wurde im Schritt Text für die GUI-Elemente von XML-Datei einlesen > Verzeichnis und Datei mit der XML-Struktur mit den sprachabhängigen Texten erstellen erstellt und ist im Verzeichnis 'TEXT.de' enthalten.
Innerhalb des Bereiches <FrameIndividual> wird die Definition der Überschriften der Tabellen-Spalten erfaßt.
Die sprachabhängigen Texte für die übrigen GUI-Elemente des Task-Frame wurden im Schritt Klasse für dasTask-Frame zur Verwaltung von Projekt und Sprache eröffnen > Datei mit der XML-Struktur mit den sprachabhängigen Texten erweitern erfaßt.

<root>
  <FrameIndividual> 
. . . . .
. . . . .
    </Frame>
    <Frame>
      <FrameClass>js_projassist.client.JS_ProjAssist_Project</FrameClass>
      <FrameTitle>Projekt- und Sprache-Verwaltung – ProjectAssist für das JavaScout Fat-Client-Framework / © 2008 www.javascout.biz</FrameTitle>
      <Element>
        <ElementName>pnl_SelectionListTable</ElementName>
        <TableHeaderColumns>
          <Column>
            <SymbolicName>Row-Number</SymbolicName>
            <ElementText>Ausw.</ElementText>
            <Width>3</Width>
          </Column>
          <Column>
            <SymbolicName>ProjectCode</SymbolicName>
            <ElementText>Projekt-Code</ElementText>
            <Width>10</Width>
          </Column>
          <Column>
            <SymbolicName>LanguageCode</SymbolicName>
            <ElementText>Sprach-Code</ElementText>
            <Width>10</Width>
          </Column>
        </TableHeaderColumns>
      </Element>
      <Element>
        <ElementName>btn_Help</ElementName>  
. . . . .
. . . . .

Eine detaillierte Beschreibung der Elemente finden Sie im Dokument Datei 'DisplayStrings.xml' mit sprachabhängigen Texten für die Anzeige auf der GUI.

▲ zum Inhaltsverzeichnis

Zwischen-Test 1

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

Daraufhin erscheint das Fenster mit der Benutzeroberfläche wie schon im vorigen Schritt.

Anmerkung:
Bei der zur Zeit der Erstellung dieses Tutorials (Mai 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.

Durch Anklicken der Auswahlmöglichkeit 'P- Projekt und Sprache verwalten' wird der Code in das Feld 'Auswahl' übertragen.

Nach Anklicken der Schaltfläche [ Weiter ] wird das Task-Frame aufgerufen.


 

Die Liste der bereits erfaßten Projekt-/Sprach-Kombinationen wird angezeigt.


 

Wird eine zusätzliche Project-/Sprach-Kombination erfaßt, wird diese sofort nach dem [ Speichern ] in der Liste angezeigt.


 


▲ zum Inhaltsverzeichnis

Auswählen und Anzeigen der Daten eines BO

Für die Auswahl eines BO und Anzeigen der Werte im Detail-Bereich ist eine Änderung des Codes in der Klasse JS_ProjAssist_Project__ActionHandler notwendig.

▲ zum Inhaltsverzeichnis

Importieren der notwendigen Bibliotheken

Für den zusätzlichen Code sind folgende Bibliotheken erforderlich:

package js_projassist.client;
. . . . .
. . . . .
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;
/**
 *

▲ zum Inhaltsverzeichnis

Methode zum Auswählen codieren

Um die Werte eines BO ändern, kann ein BO aus der Liste ausgewählt werden.
Dessen Werte werden dann im Detail in den GUI-Elementen für die Eingabe angezeigt und können geändert werden – sofern die Werte nicht Teil des Anwender-bekannten-Schlüssels sind.
Bedingt durch die Einfachheit dieses Tutorials kann nur ein anderes 'Stamm-Unterverzeichnis für die generierten Daten' ausgewählt werden.

▲ zum Inhaltsverzeichnis

Reagieren auf den Schaltflächen-Klick (Event)

Damit die Methode vom Anwender aufgerufen werden kann, muß auf die entsprechende Schaltfläche ([ Bearbeiten ]) reagiert werden.

/*
 * 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,
. . . . .
. . . . .
      if(cmd.equals("btn_Copy")) copy(parmTF);
      if(cmd.equals("btn_Get")) getForUpdate(parmTF);
    }

▲ zum Inhaltsverzeichnis

End-Test dieses Schrittes

Das Aufrufen des Task-Frames wurde bereits ausführlich beschrieben; zuletzt im Abschnitt Zwischen-Test 1 dieses Dokuments.
Aus diesem Grund beschränkt sich diese Beschreibung erst auf das Auswählen von Daten und das anschließende Anklicken der Schaltfläche [ Speichern ].

Nach dem Auswählen einer Zeile der angezeigten Liste und Anklicken der Schaltfläche [ Bearbeiten ] werden die Daten in den Eingabe-Feldern angezeigt.

Bedingt durch die Einfachheit des Beispiels kann nur das 'Stamm-Unterverzeichnis für generierte Dateien' geändert werden,

Bei Interesse können Sie die Daten auch [ Kopieren ] und das Ergebnis prüfen.


 

Bei Eingabe einer ungültigen Auswahl (und anschließendem Anklicken der Schaltfläche [ Bearbeiten ] wird der Hintergrund des Eingabefeldes rot gefärbt.


 


▲ 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 {
/*
 * 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());
    }
/* 
 * 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);
/* Methode zum Anzeigen der aktuell gültigen Projekt-/Sprach-Kombinationen aufrufen. */
      JS_ProjAssist_Project__ActionHandler.redisplayList(this);
    }
/* 
 * ******************************
 * 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 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 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");
    }
/*
 * 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);
      }
    }
}

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

Dokument

Inhalt

JavaScout ProjectAssist, Task-Frame Finalisierung (Java_Fatclient_01) – Verwenden des 'DocumentListener' und anderer 'Listener'  

In diesem Schritt des Tutorials werden die abschließenden Arbeiten begonnen.
Ziel der Finalisierung des Task-Frames ist, die Dateneingabe so klar und sicher zu gestalten, daß ein normaler Anwender des Anwendungsprogramm nur konsistente Daten erfassen kann.

asdf   

Alternativ kann begonnen werden, das Anwendungsprogramm um den notwendigen Code für eine Client-Server-Funktionalität zu erweitern.
Dabei wird für die Datenspeicherung der EJB-Mechanismus verwendet.

▲ zum Inhaltsverzeichnis