TableView: Anzahl der sichtbaren Zeilen anpassen

Leider Konfiguration der visiblerowcount auf den Wert nicht unterstützt wird, in TableView (Sie können prüfen, die Einreichung einer feature-Anfrage in fx' jira - keine Notwendigkeit, schon vor Jahren). Und es ist nicht ganz einfach zu lassen, der Blick zurück ein prefHeight basierend auf einer solchen Präferenz: wir müssen Messen Sie die Größe Anforderungen der "echten" Zelle, und das ist irgendwie begraben innerhalb der Därme.

Nur zum Spaß, experimentiert mit der Ausweitung der ganze Stapel der Mitarbeiter:

• eine benutzerdefinierte tableView, eine Eigenschaft visiblerowcount auf den Wert
• Sie eine benutzerdefinierte skin, hört die Eigenschaft berechnet seine prefHeight je nach
• einige Wege auf die Höhe der "echten" Zelle - die einzige Klasse mit allen Informationen, um Sie zu Messen, ist die VirtualFlow. Als relevante Methode geschützt ist, erfordert dies entweder eine eigene VirtualFlow herausstellt, dass die Methode oder reflektierenden Zugang.

Code:

/**
 * TableView with visibleRowCountProperty.
 * 
 * @author Jeanette Winzenburg, Berlin
 */
public class TableViewWithVisibleRowCount<T> extends TableView<T> {

    private IntegerProperty visibleRowCount = new SimpleIntegerProperty(this, "visibleRowCount", 10);


    public IntegerProperty visibleRowCountProperty() {
        return visibleRowCount;
    }

    @Override
    protected Skin<?> createDefaultSkin() {
        return new TableViewSkinX<T>(this);
    }

    /**
     * Skin that respects table's visibleRowCount property.
     */
    public static class TableViewSkinX<T> extends TableViewSkin<T> {

        public TableViewSkinX(TableViewWithVisibleRowCount<T> tableView) {
            super(tableView);
            registerChangeListener(tableView.visibleRowCountProperty(), "VISIBLE_ROW_COUNT");
            handleControlPropertyChanged("VISIBLE_ROW_COUNT");
        }

        @Override
        protected void handleControlPropertyChanged(String p) {
            super.handleControlPropertyChanged(p);
            if ("VISIBLE_ROW_COUNT".equals(p)) {
                needCellsReconfigured = true;
                getSkinnable().requestFocus();
            }
        }

        /**
         * Returns the visibleRowCount value of the table.
         */
        private int getVisibleRowCount() {
            return ((TableViewWithVisibleRowCount<T>) getSkinnable()).visibleRowCountProperty().get();
        }

        /**
         * Calculates and returns the pref height of the 
         * for the given number of rows.
         * 
         * If flow is of type MyFlow, queries the flow directly
         * otherwise invokes the method.
         */
        protected double getFlowPrefHeight(int rows) {
            double height = 0;
            if (flow instanceof MyFlow) {
                height = ((MyFlow) flow).getPrefLength(rows);
            }
            else {
                for (int i = 0; i < rows && i < getItemCount(); i++) {
                    height += invokeFlowCellLength(i);
                }
            }    
            return height + snappedTopInset() + snappedBottomInset();

        }

        /**
         * Overridden to compute the sum of the flow height and header prefHeight.
         */
        @Override
        protected double computePrefHeight(double width, double topInset,
                double rightInset, double bottomInset, double leftInset) {
            //super hard-codes to 400 .. doooh
            double prefHeight = getFlowPrefHeight(getVisibleRowCount());
            return prefHeight + getTableHeaderRow().prefHeight(width);
        }

        /**
         * Reflectively invokes protected getCellLength(i) of flow.
         * @param index the index of the cell.
         * @return the cell height of the cell at index.
         */
        protected double invokeFlowCellLength(int index) {
            double height = 1.0;
            Class<?> clazz = VirtualFlow.class;
            try {
                Method method = clazz.getDeclaredMethod("getCellLength", Integer.TYPE);
                method.setAccessible(true);
                return ((double) method.invoke(flow, index));
            } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                e.printStackTrace();
            }
            return height;
        }

        /**
         * Overridden to return custom flow.
         */
        @Override
        protected VirtualFlow createVirtualFlow() {
            return new MyFlow();
        }

        /**
         * Extended to expose length calculation per a given # of rows.
         */
        public static class MyFlow extends VirtualFlow {

            protected double getPrefLength(int rowsPerPage) {
                double sum = 0.0;
                int rows = rowsPerPage; //Math.min(rowsPerPage, getCellCount());
                for (int i = 0; i < rows; i++) {
                    sum += getCellLength(i);
                }
                return sum;
            }

        }

    }

    @SuppressWarnings("unused")
    private static final Logger LOG = Logger.getLogger(TableViewWithVisibleRowCount.class
            .getName());
}

Beachten Sie, dass Sie möglicherweise Weg mit einem einfachen überschreiben der Tabelle prefHeight, wenn man eine Feste Zelle-Größe, nicht versuchen, dass - no risk no fun 🙂

InformationsquelleAutor der Antwort kleopatra

Gibt es einen Weg, es zu tun... ja, was Sie tun müssen, ist, wenn Sie die Tabelle erstellen (da Sie Sie neu erstellen jedes mal, wenn Sie eine neue Nummer), die Sie benötigen, um zu berechnen, was die Höhe des Tisches ist mit der aktuellen Anzahl der Einträge und verwenden Sie dann die setPrefHeight() Eigentum der TableView, um die Tabelle kleiner zu machen nur diese Zeilen.

Spielte ich mit ihm ein wenig, und ich fand keine schnellen Lösungen, um diese zu berechnen, die Größe des Tisches richtig, so habe ich keinen code für Sie, aber das ist, was Sie tun müssen. Man könnte auch den 'Stil' der Tabelle nicht die abwechselnde Farbgebung, die machen würde, die Zeilen unten, auf die Daten schauen "leeren", auch wenn es einige Leerzeichen.

Glück!

InformationsquelleAutor der Antwort WillBD

Wenn Sie nicht verheiratet Bindungen, eine einfache Möglichkeit, dies zu tun ist, um die Berechnung der gewünschten Höhe auf der Grundlage der festen Größe der Zelle (cf. Fred Danna Antwort) und aktualisieren Sie es mit einem listener auf die Tabelle data.

static void setTableHeightByRowCount(TableView table, ObservableList data) {
  int rowCount = data.size();
  TableHeaderRow headerRow = (TableHeaderRow) table.lookup("TableHeaderRow");
  double tableHeight = (rowCount * table.getFixedCellSize())
    //add the insets or we'll be short by a few pixels
    + table.getInsets().getTop() + table.getInsets().getBottom()
    //header row has its own (different) height
    + (headerRow == null ? 0 : headerRow.getHeight())
    ;

  table.setMinHeight(tableHeight);
  table.setMaxHeight(tableHeight);
  table.setPrefHeight(tableHeight);
}

In start(Stage) wir erstellen die Tabelle und fügen Sie eine ListChangeListener:

TableView<String> table = new TableView<>();
table.setFixedCellSize(24);
table.getItems().addListener((ListChangeListener<String>) c ->
  setTableHeightByRowCount(table, c.getList()));

//init scene etc...

stage.show();
table.getItems().addAll("Stacey", "Kristy", "Mary Anne", "Claudia");

Beachten Sie, dass die table-header-Zeile nicht vorhanden ist, bis nach stage.show(), so die einfachste Sache zu tun ist, zu warten, legen Sie die Tabelle Daten bis dahin.
Alternativ könnten wir mit der Aufstellung der Daten in Tabelle Bauzeit, und rufen Sie dann setTableHeightByRowCount() ausdrücklich:

TableView<String> table = new TableView<>(
  FXCollections.observableArrayList("Stacey", "Kristy", "Mary Anne", "Claudia")
);

//add listener, init scene etc...

stage.show();
setTableHeightByRowCount(table, table.getItems());

InformationsquelleAutor der Antwort David Moles