public class Cell<T>
extends Labeled

API ячейки используется для виртуализованных элементов управления, таких как ListView, TreeView и TableView. Ячейка является Labeled Control и используется для отображения одной "строки" внутри ListView, TreeView или TableView. Ячейки также используются для каждой отдельной "ячейки" внутри TableView (т.е. каждой точки пересечения строки/столбца). Подробности см. в JavaDoc для каждого элемента управления отдельно.

Каждая ячейка связана с одним элементом данных (представленным свойством item). Ячейка отвечает за отображение этого элемента и, при необходимости, за редактирование элемента. Элемент внутри ячейки может быть представлен текстом или другим элементом управления, например, CheckBox, ChoiceBox или любым другим Node, таким как HBox, GridPane или даже Rectangle.

Поскольку TreeView, ListView, TableView и другие подобные элементы управления могут потенциально использоваться для отображения огромного количества данных, создание фактической ячейки для каждого элемента в элементе управления нецелесообразно. Мы представляем очень большие наборы данных, используя всего несколько ячеек. Каждая ячейка "перерабатывается" или повторно используется. Именно это мы имеем в виду, когда говорим, что эти элементы управления виртуализированы.

Поскольку ячейка является элементом управления, она по сути является "моделью". Ее кожа отвечает за определение внешнего вида и макета, а поведение отвечает за обработку всех событий ввода и использование этой информации для изменения состояния элемента управления. Кроме того, ячейка стилизуется с помощью CSS, как и любой другой элемент управления. Однако для большинства случаев использования ячейки реализовывать кожу необязательно. Это связано с тем, что можно установить фабрику ячеек — это подробно описано ниже.

Поскольку наиболее распространенным случаем использования ячеек является отображение текста пользователю, этот случай специально оптимизирован внутри ячейки. Это делается путем расширения ячейки от Labeled. Это означает, что подклассы ячейки должны только установить свойство text, а не создавать отдельный Label и устанавливать его внутри ячейки. Однако в ситуациях, когда требуется больше, чем просто обычный текст, можно разместить любой Node в свойстве graphic ячейки. Несмотря на термин, графикой может быть любой узел, и он будет полностью интерактивным. Например, ListCell можно настроить с Button в качестве графики. Текст кнопки можно привязать к свойству item ячейки. Таким образом, всякий раз, когда изменяется элемент в ячейке, текст кнопки автоматически обновляется.

Ячейка устанавливает focusTraversable в false.

Фабрики ячеек

Способ отображения по умолчанию ячейки item зависит от кожного покрова различных виртуализированных контейнеров. Например, ListView по умолчанию преобразует элемент в строку и вызывает Labeled.setText(java.lang.String) с этим значением. Если вы хотите специализировать ячейку, используемую для ListView (например), то вы должны предоставить реализацию обратного вызова cellFactory, определенного в ListView. Аналогичный API существует в большинстве элементов управления, использующих ячейки (например, TreeView, TableView, TableColumn и ListView).

Фабрика ячеек вызывается платформой всякий раз, когда определяется необходимость создания новой ячейки. Например, предположим, что ваш ListView содержит 10 миллионов элементов. Создание всех 10 миллионов ячеек было бы чрезвычайно дорогостоящим. Поэтому вместо этого реализация кожного покрова ListView может создавать только необходимое количество ячеек для отображения. Если ListView будет изменен на больший размер, система определит, что необходимо создать дополнительные ячейки. В этом случае она вызовет обратный вызов cellFactory (если он предоставлен) для создания реализации ячейки, которая должна использоваться. Если фабрика ячеек не предоставлена, будет использоваться встроенная реализация по умолчанию.

Реализация фабрики ячеек отвечает не только за создание экземпляра ячейки, но и за конфигурацию этой ячейки таким образом, чтобы она реагировала на изменения ее состояния. Например, если я создал бы пользовательскую ячейку, которая форматирует числа таким образом, что они отображаются как типы валют, я мог бы сделать это так:

 public class MoneyFormatCell extends ListCell<Number> {

     public MoneyFormatCell() {    }

     @Override protected void updateItem(Number item, boolean empty) {
         // calling super here is very important - don't skip this!
         super.updateItem(item, empty);

         // format the number as if it were a monetary value using the
         // formatting relevant to the current locale. This would format
         // 43.68 as "$43.68", and -23.67 as "-$23.67"
         setText(item == null ? "" : NumberFormat.getCurrencyInstance().format(item));

         // change the text fill based on whether it is positive (green)
         // or negative (red). If the cell is selected, the text will
         // always be white (so that it can be read against the blue
         // background), and if the value is zero, we'll make it black.
         if (item != null) {
             double value = item.doubleValue();
             setTextFill(isSelected() ? Color.WHITE :
                 value == 0 ? Color.BLACK :
                 value < 0 ? Color.RED : Color.GREEN);
         }
     }
 }

Этот класс затем можно использовать внутри ListView следующим образом:

 ObservableList<Number> money = ...;
 final ListView<Number> listView = new ListView<Number>(money);
 listView.setCellFactory(new Callback<ListView<Number>, ListCell<Number>>() {
     @Override public ListCell<Number> call(ListView<Number> list) {
         return new MoneyFormatCell();
     }
 });

В этом примере создается анонимный внутренний класс, который просто возвращает экземпляры MoneyFormatCell всякий раз, когда он вызывается. Класс MoneyFormatCell расширяет ListCell, переопределяя метод updateItem. Этот метод вызывается всякий раз, когда изменяется элемент в ячейке, например, когда пользователь прокручивает ListView или изменяется содержимое базовой модели данных (и ячейка повторно используется для представления другого элемента в ListView). Из-за этого нет необходимости управлять связями — просто реагировать на изменения элементов, когда происходит этот метод. В примере выше, всякий раз, когда изменяется элемент, мы обновляем свойство текста ячейки и также изменяем цвет текста, чтобы обеспечить правильное визуальное представление. Кроме того, если ячейка "пустая" (то есть используется для заполнения места в ListView, но не имеет связанных с ней данных), мы просто используем пустую строку.

Обратите внимание, что существуют дополнительные методы с префиксом "обновить", которые могут представлять интерес, поэтому внимательно ознакомьтесь с документацией API для ячейки и подклассов ячейки.

Конечно, мы также можем использовать API привязки вместо переопределения методов "обновить". Ниже приведен очень тривиальный пример того, как это можно сделать.

 public class BoundLabelCell extends ListCell<String> {

     public BoundLabelCell() {
         textProperty().bind(itemProperty());
     }
 }
 

Основные цели разработки

• Эффективность во времени и памяти для больших наборов данных
• Простота создания и использования библиотек для пользовательских ячеек
• Простота настройки внешнего вида ячейки
• Простота настройки форматирования отображения (12.34 как $12.34 или 1234% и т.д.)
• Простота расширения для пользовательского визуального оформления
• Простота создания "панелей" данных для визуализации
• Простота анимации размера ячейки или других свойств

Основные варианты использования

Ниже приведены ряд ключевых вариантов использования, используемых для разработки API ячеек, вместе с примерами кода, демонстрирующими, как эти варианты использования удовлетворяются этим API. Это ни в коем случае не должен считаться окончательным списком возможностей или функций, а скорее должно служить руководством по использованию API ячеек. Приведенные ниже примеры сосредоточены на ListView, но та же философия применяется к TreeCells или другим видам ячеек.

Изменение цветов ячейки

Это должно быть невероятно просто в JavaFX. Каждая ячейка может быть стилизована непосредственно из CSS. Например, если вы хотите изменить фоновый цвет каждой ячейки в ListView на БЕЛЫЙ, вы можете сделать следующее в CSS:

 .list-cell {
   -fx-padding: 3 3 3 3;
   -fx-background-color: white;
 }

Если вы хотите установить цвет выделенных ячеек ListView в синий, вы можете добавить это в свой файл CSS:

 .list-cell:selected {
   -fx-background-color: blue;
 }

Большинство реализаций ячеек расширяются от IndexedCell, а не от ячейки. IndexedCell добавляет два других состояния псевдокласса: "нечетное" и "четное". С помощью этого вы можете получить чередование строк, выполнив действия в файле CSS:

 .list-cell:odd {
   -fx-background-color: grey;
 }

Каждый из этих примеров не требует изменений в коде. Просто обновите свой файл CSS для изменения цветов. Вы также можете использовать псевдоклассы "наведение курсора" и другие псевдоклассы в CSS, как и с другими элементами управления.

Другой подход к первому примеру выше (форматирование списка чисел) — использование стилей классов. Предположим, у вас есть ObservableList чисел для отображения в ListView и вы хотите окрашивать все отрицательные значения в красный цвет, а все положительные или нулевые значения — в черный. Один из способов достижения этого — настройка пользовательской фабрики ячеек, которая изменяет styleClass ячейки в зависимости от того, является ли значение отрицательным или положительным. Это так же просто, как добавить код для проверки, является ли число в ячейке отрицательным, и добавления styleClass "отрицательное". Если число не отрицательное, строка "отрицательное" должна быть удалена. Этот подход позволяет определять цвета из CSS, что обеспечивает простоту настройки. Файл CSS затем будет содержать что-то вроде следующего:

 .list-cell {
   -fx-text-fill: black;
 }

 .list-cell .negative {
   -fx-text-fill: red;
 }

Редактирование

Большинство виртуализированных элементов управления, использующих архитектуру ячеек (например, ListView, TreeView, TableView и TreeTableView) поддерживают концепцию редактирования значений непосредственно через ячейку. Подробнее о контроллере-специфических деталях редактирования см. в разделе 'редактирование' в документации по классам для связанных выше элементов управления. Остальная часть этого раздела будет охватывать некоторые детали редактирования с помощью ячеек.

Общий поток редактирования следующий (обратите внимание, что в этих шагах используется элемент управления ListView в качестве примера, но аналогичный API существует для всех упомянутых выше элементов управления, и процесс в целом точно такой же):

1. Пользователь запрашивает ввод в ячейку (через команды клавиатуры или мыши), или разработчик запрашивает, чтобы ячейка перешла в режим редактирования (вызванием метода, такого как ListView edit). Примечание: Если пользователь дважды щелкнет или выполнит соответствующую команду клавиатуры для начала редактирования, он фактически вызывает соответствующий метод редактирования на элементе управления (т. е. метод ввода для редактирования, инициированного пользователем и разработчиком, является одинаковым).
2. Каждая ячейка в видимой области элемента управления получает уведомление о том, что текущий editing cell изменился, и проверяет, является ли она сама. В этот момент может произойти одно из трёх:
   1. Если индекс редактирования совпадает с индексом ячейки, на этой ячейке будет вызван startEdit(). Некоторые рекомендации:
      1. Рекомендуется, чтобы подклассы Cell переопределяли метод startEdit(), чтобы обновлять визуальное представление ячейки при переходе в состояние редактирования. Однако важно, чтобы подклассы, переопределяющие метод startEdit(), продолжали вызывать super.startEdit(), чтобы родительские классы могли обновлять дополнительное состояние, необходимое для успешного редактирования.
      2. В методе startEdit() идеально подходит время для изменения визуального представления ячейки. Например (и обратите внимание, что этот пример более подробно описан в javadoc для элемента управления интерфейсом ListView и т. д.), вы можете установить Labeled.graphicProperty() ячейки на TextField и установить Labeled.textProperty() в значение null. Это позволит конечным пользователям вводить данные и вносить изменения в вашу модель данных.
      3. Когда пользователь закончит редактирование, он захочет подтвердить или отменить изменения. Вы несете ответственность за обработку этого (например, путем настройки Enter для commit the edit, и клавиши ESC для cancel the edit). Вы делаете это, прикрепляя соответствующие обработчики событий к узлам, которые вы показываете во время редактирования.
   2. Если индекс редактирования не совпадает с индексом ячейки и если ячейка в настоящее время находится в состоянии editing state, на этой ячейке будет вызван cancelEdit(). Как и в случае с методом startEdit(), вы должны переопределить этот метод, чтобы очистить визуальное представление ячейки (и, скорее всего, вернуть Labeled.graphicProperty() обратно к null и установить Labeled.textProperty() в его (возможно, новое) значение. Опять же, убедитесь, что всегда вызываете super.cancelEdit(), чтобы гарантировать правильное обновление всего состояния.
   3. Если индекс редактирования не совпадает с индексом ячейки и если ячейка в настоящее время не находится в состоянии редактирования isEditing(), на этой ячейке ничего не произойдёт.