Tableview automatische Zeilenhöhe Ändern der Größe - JavaFX

Question

Wenn ich einen TableView enthält eine TableColumn wie so haben:

private TableColumn<Foo, ObservableList<Foo2>> col; 

kann ich es schön für mich eine Liste angezeigt werden soll. Wenn die Größe dieser Liste jedoch zunimmt, bleibt die Größe der Zelle (und der Zeile) konstant, und so wird ein Teil meiner Zelle abgeschnitten. Wenn ich die Spalte manuell verändere, ändert die Tabelle die Höhe der Zeile korrekt und sieht so aus, wie sie sollte.

Muss ich die Höhe der Zeile/Zelle irgendwie an die Größe ObservableList binden, oder gibt es eine bessere Möglichkeit, die Tabelle automatisch ohne Benutzereingriff anzupassen?

Contained Beispiel:

import javafx.application.Application; 
import javafx.collections.FXCollections; 
import javafx.collections.ObservableList; 
import javafx.event.ActionEvent; 
import javafx.event.EventHandler; 
import javafx.scene.Scene; 
import javafx.scene.control.Button; 
import javafx.scene.control.ContentDisplay; 
import javafx.scene.control.Label; 
import javafx.scene.control.TableCell; 
import javafx.scene.control.TableColumn; 
import javafx.scene.control.TableView; 
import javafx.scene.control.cell.PropertyValueFactory; 
import javafx.scene.layout.GridPane; 
import javafx.stage.Stage; 
import javafx.util.Callback; 

public class CellResizing extends Application { 
    public static void main(String[] args) { 
     launch(args); 
    } 

    @Override 
    public void start(Stage primaryStage) { 

     GridPane root = new GridPane(); 
     ObservableList<MyFoo> list = FXCollections.observableArrayList(); 
     list.add(new MyFoo()); 
     list.get(0).foosProperty().get().add(new Foo2("First Item")); 

     TableView<MyFoo> table = new TableView<MyFoo>(); 
     TableColumn<MyFoo, ObservableList<Foo2>> col = new TableColumn<MyFoo, ObservableList<Foo2>>("List"); 
     col.setCellValueFactory(new PropertyValueFactory<MyFoo, ObservableList<Foo2>>("foos")); 
     Callback<TableColumn<MyFoo, ObservableList<Foo2>>, TableCell<MyFoo, ObservableList<Foo2>>> toolTipFactory = 
       new Callback<TableColumn<MyFoo, ObservableList<Foo2>>, TableCell<MyFoo, ObservableList<Foo2>>>() { 
      @Override 
      public TableCell<MyFoo, ObservableList<Foo2>> call(final TableColumn<MyFoo, ObservableList<Foo2>> param) { 
       final TableCell<MyFoo, ObservableList<Foo2>> cell = new TableCell<MyFoo, ObservableList<Foo2>>() { 
        @Override 
        public void updateItem(ObservableList<Foo2> item, boolean empty) { 
         super.updateItem(item, empty); 
         if (empty || item == null) { 
          setText(null); 
          setTooltip(null); 
         } else { 
          GridPane grid = new GridPane(); 
          int modulus; 
          if (item.size() < 4) { 
           modulus = 1; 
          } 
          else if (item.size() < 9) { 
           modulus = 2; 
          } 
          else { 
           modulus = 3; 
          } 
          for (int i = 0; i < item.size(); ++i) { 
           Label label = new Label(); 
           label.setText(item.get(i).toString()); 
           grid.add(label, i % modulus, (i % item.size())/modulus); 
          } 
          setGraphic(grid); 
          setContentDisplay(ContentDisplay.GRAPHIC_ONLY); 
         } 
        } 
       }; 
       return cell; 
      } 
     }; 
     col.setCellFactory(toolTipFactory); 
     table.getColumns().add(col); 

     Button button = new Button("Add to list");  
     button.setOnAction(new EventHandler<ActionEvent>() {    
      @Override 
      public void handle(ActionEvent event) { 
       list.get(0).foosProperty().get().add(new Foo2("Text")); 
      } 
     }); 
     table.setItems(list); 

     root.add(button, 0, 0); 
     root.add(table, 0, 1); 
     primaryStage.setScene(new Scene(root, 300, 250)); 
     primaryStage.show(); 
    } 
} 

und die Klassen MyFoo + foo2:

import javafx.beans.property.ListProperty; 
import javafx.beans.property.SimpleListProperty; 
import javafx.beans.property.SimpleStringProperty; 
import javafx.beans.property.StringProperty; 
import javafx.collections.FXCollections; 

public class MyFoo { 
    private ListProperty<Foo2> foos; 

    public MyFoo() { 
     foos = new SimpleListProperty<Foo2>(FXCollections.observableArrayList()); 
    } 

    public ListProperty<Foo2> foosProperty() { 
     return foos; 
    } 
} 

class Foo2 { 
    private StringProperty text; 

    public Foo2(String string) { 
     text = new SimpleStringProperty(string); 
    } 

    public StringProperty textProperty() { 
     return text; 
    } 

    @Override 
    public String toString() { 
     return text.get(); 
    } 

} 

Answer 1

Ich löste dies, indem ich einen Invalidierungs-Listener auf die Observable-Liste setzte, so dass updateItem jedes Mal aufgerufen wird, wenn sich die Listengröße ändert.

@Override 
public void updateItem(ObservableList<Foo2> item, boolean empty) { 
    super.updateItem(item, empty); 
    if (empty || item == null) { 
     setText(null); 
     setTooltip(null); 
    } else { 
     GridPane grid = new GridPane(); 
     int modulus; 
     if (item.size() < 4) { 
      modulus = 1; 
     } 
     else if (item.size() < 9) { 
      modulus = 2; 
     } 
     else { 
      modulus = 3; 
     } 
     for (int i = 0; i < item.size(); ++i) { 
      Label label = new Label(); 
      label.setText(item.get(i).toString()); 
      grid.add(label, i % modulus, (i % item.size())/modulus); 
     } 
     item.addListener(new InvalidationListener() { 
      @Override 
      public void invalidated(Observable observable) { 
       updateItem(item, empty); 
      } 
     }); 
     setGraphic(grid); 
     setContentDisplay(ContentDisplay.GRAPHIC_ONLY); 
    } 
} 

Answer 2

ersetzen textWrapper mit Ihrem Text Container und fügen Sie ein Ändern der Größe Kommando- und der Code funktioniert.