Ganz im Gegenteil! Ich packe mir die Liste sogar meistens in ein ObjectProperty, so das Änderungen an der Liste auch von außen zu verfolgen und zu vollziehen sind.
private TableView clientTable;
private ObjectProperty<ObservableList<Client>> clients = new SimpleObjectProperty<ObservableList<Client>>();
//
@FXML
private void initialize()
{
ObservableList<Client> cList = holeDieDatenZBAusDerDatenbank();
clients.set(cList);
clientTable.itemsProperty().bindBidirectional(clients);
}
//
public ObjectProperty<ObservableList<Client>> clientsProperty()
{
return clients;
}```
Du erkennst hier schon ein bestimmtes Muster.
> Arbeitest du auch mit EMF? Ich danke das wird auch lange gehen bis ich es begriffen habe...
Nein, noch nicht.
Du wirst nie deine Tabelle “automatisch” über Databinding aktualisieren können, wenn sich irgendwas an der Datenbank geändert hat, dafür ist es auch nicht da…
Wenn ich das ganze jetzt noch in das ObjectProperty packe, wird die Table jedesmal bei einem verändern der Liste automatisch aktualisiert?[/QUOTE]
Kurz gesagt: ja. Bei einem Binding reagiert das gebundene Element auf alle Änderungen am bindenden Element. Wenn Du also deine Liste von deiner Datenbank aus updatest spiegelt sich das in deiner Tabelle wieder. Das erspart Dir einige Listener. Gewöhne Dich möglichst schnell an diese Denkweise, befasse Dich mit Properties und Binding, wenn Du es einmal begriffen hast möchtest Du gar nicht mehr in die Swing-Hölle zurück.
Ich will jetzt schon nicht mehr in die SwingHölle zurück Nie mehr…
Okey ich werd mir das nun zu gemüte führen
*** Edit ***
Das ist mir schon klar, aber ich kann es automatisch machen wenn sich etwas an der Liste geändert hat, falls ich dies richtig verstanden habe
*** Edit ***
Also ich habe jetzt genau das umgesetzt das du mir gesagt hast:
In meiner „Model“ Klasse stelle ich den Listener den Clients zur Verfügung.
* Uebergibt die Aenderungen an die Clients
*
* @return
*/
public ObjectProperty<ObservableList<Kunde>> clientsProperty() {
return clients;
}```
Bei jeder änderung an der Liste wird automatisch die Tabelle aktualisiert:
```kundenTable.itemsProperty().bindBidirectional(this.kundenModel.clientsProperty());```
soweit so gut ich habe es verstanden.
Nun kommt mein nächstes anliegen, ich klicke auf die Tabelle und der angewählte Eintrag soll editiert werden. Aber nicht in der Tabelle sondern in einer eigenen Eingabemaske. Diese wird erst geöffnet wenn der Benutzer in der Tabelle per Rechten Mausklick auf bearbeiten klickt. Im moment merke ich mir das angeklickte Objekt und übergebe es dem Bearbeiten View.
Wenn ich jetzt die binding geschichte aber richtig verstanden habe kann ich mir diesen Schritt auch sparen und es direkt über den ObjectProperty machen oder?
* Uebergibt die Aenderungen an die Clients
*
* @return
*/
public ObjectProperty<ObservableList<Kunde>> clientsProperty() {
return clients;
}```
Dieses ObjectProperty bemerkt ja jede änderung in der Liste und gibt diese auch weiter.
Wenn ich jetzt einen Listener hinzufügen möchte, egal wo in meinem Program, mache ich das vollgendermassen:
``` clients.addListener(new ChangeListener<Kunde>() {
@Override
public void changed(ObservableValue<? extends Kunde> observable, Kunde oldValue, Kunde newValue) {
// TODO Auto-generated method stub
}
});```
Dann motzt mir Eclipse:
Was mache und verstehe ich hier falsch?
clients ist deine ObjectProperty und nicht! die beobachtete Liste, schau dir mal genau den Konstruktor an. Binde diese property an eine andere!
Oder einen ListChangeListener an clients.get() bzw. clients.getValue() (gibt die Liste zurück) hängen.
Schau Dir vor allem die Fehlermeldung von Eclipse an, der sagt Dir unzweifelsfrei, dass Du einen ChangeListener an eine ObjectProperty<ObservableList> hängen möchtest. Diese ObjectProperty beobachtet aber eine Liste, und keinen Kunden.
Gibt es auch eine Möglichkeit, die angezeigten Spalten in der Tabelle variable zu gestalten? Das heißt, select je frei gestalten, mal 5, andermal 10 Spalten und diese dann inkl. Namen über fmxl anzuzeigen.
Nie mehr…