package Kunde;
import java.sql.*;
import java.util.Vector;
import javax.swing.event.TableModelEvent;
import datenbank.*;
import java.util.*;
import javax.swing.table.*;
public class TableData extends Thread
{
private volatile Thread myThread = this;
// Instanzvariable für den SQL-Befehl (Lesen der Daten aus der DB)
public static String SQLstmt;
// Instanzvariable für die Adresse des Tabellen-Modells
private MyTableModel myTM = null;
private MyTable tabelle = null;
private int bool = 0;
protected TableData(MyTableModel myTM, String SQLstmt)
{
// Referenz auf das Tabellen-Modell-Objekt speichern
this.myTM = myTM;
this.SQLstmt = SQLstmt;
}
protected TableData(MyTableModel myTM, String SQLstmt, MyTable tabelle)
{
// Referenz auf das Tabellen-Modell-Objekt speichern
this.myTM = myTM;
this.SQLstmt = SQLstmt;
this.tabelle = tabelle;
}
// Daten aus der DB lesen, auf Veränderungen prüfen und ggf. in die GUI schreiben
// Thread solange ausführen bis myThread = diesem Thraed ist
public void run()
{
Thread thisThread = Thread.currentThread();
while (myThread == thisThread)
{
getAktuelleDaten();
try {
Thread.sleep(500); // 15 sec warten
} catch (InterruptedException e) { }
// spaltenBreite();
try {
Thread.sleep(15000); // 15 sec warten
} catch (InterruptedException e) { }
}
}
// Die Methode stop() ist unsicher, deshalb wird myThraed auf "null" gesetzt
// und somit wird dieser Thread nicht mehr ausgeführt.
public void stopThread()
{
myThread = null;
}
public synchronized void getAktuelleDaten()
{
// Objekt für die Datenbankverbindung anlegen - die Informationen zur Datenbank-
// verbindung sind in der Datei dbverbindung.properties eingetragen
DatenbankVerbindung DB1;
DB1 = new DatenbankVerbindung("datenbank/config/dbHome.properties");
DB1.oeffneDBVerbindung();
DB1.useDB();
String query =
"SELECT LLfdNr,Name,Strasse,plz.PLZ ,Ort,Telefon,Fax,Mail"+
" FROM `kunden`,plz WHERE "+
" kunden.PLZNr = plz.PLZNr ORDER BY Name";
// Select-Abfrage absetzen
ResultSet myresultset = DB1.submitSelectQuery(query);
// ResultSet verarbeiten
// Spaltennamen feststellen
try
{
int spaltenzahl = myresultset.getMetaData().getColumnCount();
myTM.spaltenNamen = new Object[spaltenzahl];
myTM.spaltenTypen = new Object[spaltenzahl];
for (int i = 1; i <= spaltenzahl; i++)
{
myTM.spaltenNamen[i-1] = myresultset.getMetaData().getColumnName(i);
myTM.spaltenTypen[i-1] = myresultset.getMetaData().getColumnTypeName(i);
}
} catch (SQLException e) {}
// Daten aus Resultset lesen
myTM.daten = new Vector();
try
{
while(myresultset.next())
{
Vector newZeile = new Vector();
for (int i = 1; i <= myresultset.getMetaData().getColumnCount(); i++)
{
// Falls Typ boolean wird dieser in Vector gesetzt.
if (i==bool) {
if (myresultset.getObject(i).equals("true"))
newZeile.addElement(new Boolean(true));
else
newZeile.addElement(new Boolean(false));
}
else {
// alle anderen Werte werden einfach so übernommen
newZeile.addElement(myresultset.getObject(i));
}
}
myTM.daten.addElement(newZeile);
}
} catch (SQLException e) {}
datenVergleichenUndAktualisieren();
//Zwischenspeichern von in die Tabelle eingetragenen Daten
myTM.datenAlt = myTM.daten;
myTM.tdThread.spaltenBreite();
// ResultSet schließen
DB1.schliesseResultSet(myresultset);
// Datenbankverbindung schließen
DB1.schliesseDBVerbindung();
}
public synchronized void spaltenBreite()
{
try
{
// Hier wird die Spaltenbreite bestimmt!
int spalten = 0; // =0 falls Zähler aktiviert
for (Enumeration Enumm = tabelle.table.getColumnModel().getColumns();
Enumm.hasMoreElements(); ) {
Enumm.nextElement();
spalten++;
}
for (int i = 0; i < spalten; i++) {
TableColumn col = tabelle.table.getColumnModel().getColumn(i);
col.setPreferredWidth(110);
}
// ist nur für Material.... aber andere übernehmen es noch!
TableColumn col = null;
for (int s = 0; s < spalten; s++) {
switch (s) {
case 0:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(50);
break;
case 1:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(150);
break;
case 2:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(130);
break;
case 3:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(50);
break;
case 4:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(90);
break;
case 5:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(100);
break;
case 6:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(100);
break;
case 7:
col = tabelle.table.getColumnModel().getColumn(s);
col.setPreferredWidth(130);
break;
}
}
col = tabelle.table.getColumnModel().getColumn(spalten - 1);
}catch(Exception e){}
}
/** Aktuell gelesenen Datenbestand mit dem zuvor gelesenen Datenbestand
* vergleichen. Bei unterschiedlicher Zeilenzahl die gesamte Tabelle in der
* GUI neu aufbauen. Bei gleicher Zeilenzahl und veränderten Inhalten nur
* einzelne Zellen aktualisieren.
*/
private synchronized void datenVergleichenUndAktualisieren()
{
// Wenn noch keine Daten in der GUI angezeigt werden:
if (myTM.datenAlt == null)
{
// Update der Tabellendaten ist threadsicher, denn in der Dokumentation steht
// zur Methode fireTableChanged(..); Forwards the given notification event to
// all TableModelListeners that registered themselves as listeners for this table model.
// Strukturänderung der Tabelle, also Option HEADER_ROW
myTM.fireTableChanged(new TableModelEvent(myTM,TableModelEvent.HEADER_ROW));
}
// Wenn sich die Zeilenzahl der Tabelle geändert hat:
else if (myTM.datenAlt.size() != myTM.daten.size())
{
synchronized (myTM.datenAlt) {
myTM.fireTableChanged(new TableModelEvent(myTM,TableModelEvent.HEADER_ROW));
}
}
// Wenn sich die Zeilenzahl der Tabelle nicht geändert hat, alle Zellen auf Veränderungen
// überprüfen und ggf. Anzeige der jeweiligen Zelle in der GUI aktualisisieren
else
{
for (int zeileNr = 0; zeileNr < myTM.daten.size(); zeileNr++)
{
Vector zeile = (Vector) myTM.daten.get(zeileNr);
Vector zeileAlt = (Vector) myTM.datenAlt.get(zeileNr);
synchronized (zeile)
{
synchronized (zeileAlt)
{
int spaltenLaenge = zeile.size();
int spaltenLaengeAlt = zeileAlt.size();
if (spaltenLaenge != spaltenLaengeAlt) {
myTM.fireTableChanged(new TableModelEvent(myTM,TableModelEvent.HEADER_ROW));
}
else
{
for (int i = 0; i < zeile.size(); i++)
{
Object zelle = zeile.get(i);
Object zelleAlt = zeileAlt.get(i);
synchronized (zelle) {
synchronized (zelleAlt) {
// NullPointer abfangen
if (zelle == null || zelleAlt == null) {}
else
{
if (!zelle.equals(zelleAlt))
{
// Tabelleneintrag ändern
myTM.setValueAt(zelle, zeileNr, i);
}
}
}
}
}
}
}
}
}
}
}
}
