Module javafx.controls
Package javafx.scene.control.cell

## Class TreeItemPropertyValueFactory<S,​T>

- java.lang.Object
- - javafx.scene.control.cell.TreeItemPropertyValueFactory<S,​T>

- All Implemented Interfaces:
    `Callback<TreeTableColumn.CellDataFeatures<S,​T>,​ObservableValue<T>>`

      public class TreeItemPropertyValueFactory<S,​T>
      extends Object
      implements Callback<TreeTableColumn.CellDataFeatures<S,​T>,​ObservableValue<T>>

  A convenience implementation of the Callback interface, designed specifically for use within the `TreeTableColumn` `cell value factory`. An example of how to use this class is:

       TreeTableColumn<Person,String> firstNameCol = new TreeTableColumn<Person,String>("First Name");
       firstNameCol.setCellValueFactory(new TreeItemPropertyValueFactory<Person,String>("firstName"));

  In this example, `Person` is the class type of the `TreeItem` instances used in the `TreeTableView`. The class `Person` must be declared public. `TreeItemPropertyValueFactory` uses the constructor argument, `"firstName"`, to assume that `Person` has a public method `firstNameProperty` with no formal parameters and a return type of `ObservableValue<String>`.

  If such a method exists, then it is invoked, and additionally assumed to return an instance of `Property<String>`. The return value is used to populate the `TreeTableCell`. In addition, the `TreeTableView` adds an observer to the return value, such that any changes fired will be observed by the `TreeTableView`, resulting in the cell immediately updating.

  If no such method exists, then `TreeItemPropertyValueFactory` assumes that `Person` has a public method `getFirstName` or `isFirstName` with no formal parameters and a return type of `String`. If such a method exists, then it is invoked, and its return value is wrapped in a `ReadOnlyObjectWrapper` and returned to the `TreeTableCell`. In this situation, the `TreeTableCell` will not be able to observe changes to the property, unlike in the first approach above.

  For reference (and as noted in the TreeTableColumn `cell value factory` documentation), the long form of the code above would be the following:

       TreeTableColumn<Person,String> firstNameCol = new TreeTableColumn<Person,String>("First Name");

       firstNameCol.setCellValueFactory(new Callback<CellDataFeatures<Person, String>, ObservableValue<String>>() {
           public ObservableValue<String> call(CellDataFeatures<Person, String> p) {
               // p.getValue() returns the TreeItem<Person> instance for a particular
               // TreeTableView row, and the second getValue() call returns the
               // Person instance contained within the TreeItem.
               return p.getValue().getValue().firstNameProperty();
           }
        });

       }

  Deploying an Application as a Module

  If the referenced class is in a named module, then it must be reflectively accessible to the `javafx.base` module. A class is reflectively accessible if the module `opens` the containing package to at least the `javafx.base` module. Otherwise the `call(TreeTableColumn.CellDataFeatures)` method will log a warning and return `null`.

  For example, if the `Person` class is in the `com.foo` package in the `foo.app` module, the `module-info.java` might look like this:

      module foo.app {
          opens com.foo to javafx.base;
      }

  Alternatively, a class is reflectively accessible if the module `exports` the containing package unconditionally.

  Since:
    JavaFX 8.0
  See Also:
    `TreeTableColumn`, `TreeTableView`, `TreeTableCell`, `PropertyValueFactory`, `MapValueFactory`

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `TreeItemPropertyValueFactory​(String property)` | Creates a default PropertyValueFactory to extract the value from a given TableView row item reflectively, using the given property name.

  - ### Method Summary

    Modifier and Type | Method | Description
    --- | --- | ---
    `ObservableValue<T>` | `call​(TreeTableColumn.CellDataFeatures<S,​T> param)` | The `call` method is called when required, and is given a single argument of type P, with a requirement that an object of type R is returned.
    `String` | `getProperty()` | Returns the property name provided in the constructor.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### TreeItemPropertyValueFactory

          public TreeItemPropertyValueFactory​(String property)

      Creates a default PropertyValueFactory to extract the value from a given TableView row item reflectively, using the given property name.
      Parameters:
        `property` - The name of the property with which to attempt to reflectively extract a corresponding value for in a given object.

  - ### Method Detail

    - #### call

          public ObservableValue<T> call​(TreeTableColumn.CellDataFeatures<S,​T> param)

      The `call` method is called when required, and is given a single argument of type P, with a requirement that an object of type R is returned.
      Specified by:
        `call` in interface `Callback<S,​T>`
      Parameters:
        `param` - The single argument upon which the returned value should be determined.
      Returns:
        An object of type R that may be determined based on the provided parameter value.

    - #### getProperty

          public final String getProperty()

      Returns the property name provided in the constructor.
      Returns:
        the property name provided in the constructor