Класс Cell<T>

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, но не имеет связанных с ней данных), то мы просто используем пустую строку.

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

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

 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, а не Cell. IndexedCell добавляет два других псевдокласса: "нечетный" и "четный". С помощью этого вы можете получить чередующиеся ряды, сделав что-то вроде этого в файле CSS:

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

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

Другой подход к первому примеру выше (форматирование списка чисел) заключался бы в использовании стилей. Предположим, у вас есть ObservableList чисел для отображения в ListView и вы хотите окрасить все отрицательные значения в красный цвет, а все положительные или нулевые — в черный. Один из способов достижения этого — использовать пользовательскую фабрику ячеек, которая изменяет styleClass ячейки в зависимости от того, отрицательно ли значение. Это просто добавление кода для проверки того, отрицательно ли число в ячейке, и добавление styleClass "negative". Если число не отрицательно, строка "negative" должна быть удалена. Этот подход позволяет задавать цвета из 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() — идеальное время для изменения визуализации ячейки. Например (и обратите внимание, что этот пример более подробно описан в документации UI-элементов управления для 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(), то на этой ячейке ничего не произойдёт.