Java 类javafx.scene.control.TreeTableCell 实例源码

protected Point2D getPoint(TreeTableView<?> treeTableView, int rowIndex, int columnIndex) {
    Set<Node> treeTableRowCell = treeTableView.lookupAll(".tree-table-row-cell");
    TreeTableRow<?> row = null;
    for (Node tableRow : treeTableRowCell) {
        TreeTableRow<?> r = (TreeTableRow<?>) tableRow;
        if (r.getIndex() == rowIndex) {
            row = r;
            break;
        }
    }
    Set<Node> cells = row.lookupAll(".tree-table-cell");
    for (Node node : cells) {
        TreeTableCell<?, ?> cell = (TreeTableCell<?, ?>) node;
        if (treeTableView.getColumns().indexOf(cell.getTableColumn()) == columnIndex) {
            Bounds bounds = cell.getBoundsInParent();
            Point2D localToParent = cell.localToParent(bounds.getWidth() / 2, bounds.getHeight() / 2);
            Point2D rowLocal = row.localToScene(localToParent, true);
            return rowLocal;
        }
    }
    return null;
}

@Override
public TreeTableCell<ReferenceDescription, ReferenceDescription> call(TreeTableColumn<ReferenceDescription, ReferenceDescription> param) {
  return new TreeTableCell<ReferenceDescription, ReferenceDescription>() {

    @Override
    protected void updateItem(ReferenceDescription item, boolean empty) {
      super.updateItem(item, empty);
      if (!empty && item != null) {
        setText(item.getDisplayName().getText());
        setGraphic(createGraphicNode(item));
      } else {
        setText(null);
        setGraphic(null);
      }
    }
  };
}

protected static Range getVisibleRange(final Wrap<? extends Control> testedControl) {
    int[] visibleIndices;

    if (testedControl.getControl() instanceof TableView) {
        visibleIndices = org.jemmy.fx.control.TableUtils.shown(
                testedControl.getEnvironment(),
                testedControl,
                new org.jemmy.fx.control.TableUtils.TableViewIndexInfoProvider((TableViewWrap) testedControl), TableCell.class);
    } else {
        visibleIndices = org.jemmy.fx.control.TableUtils.shown(
                testedControl.getEnvironment(),
                testedControl,
                new org.jemmy.fx.control.TableUtils.TreeTableViewIndexInfoProvider((TreeTableViewWrap) testedControl), TreeTableCell.class);
    }

    return new Range(visibleIndices[1], visibleIndices[3]);
}

@Override
public boolean check(IndexedCell control) {
    if (control.isVisible() && control.getOpacity() == 1.0) {
        if (isTreeViewTests) {
            if (control instanceof TreeCell) {
                if ((((TreeCell) control).getTreeItem() != null) && ((TreeCell) control).getTreeItem().equals(item)) {
                    return true;
                }
            }
        } else {
            if (control instanceof TreeTableCell) {
                if ((((TreeTableCell) control).getTreeTableRow().getTreeItem() != null) && ((TreeTableCell) control).getTreeTableRow().getTreeItem().equals(item)) {
                    return true;
                }
            }
        }
    }
    return false;
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {
        NumberFormat formatter = MZmineCore.getConfiguration().getMZFormat();
        Double doubleValue = Double.parseDouble(object.toString());
        setText(formatter.format(doubleValue));
      }
    }
  };
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {

        try {
          NumberFormat formatter = new DecimalFormat("#0.00");
          Double doubleValue = Double.parseDouble(object.toString());
          setText(formatter.format(doubleValue));
        } catch (NumberFormatException e) {
          setText(object.toString());
        }

      }
    }
  };
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {
        Integer integerValue = Integer.parseInt(object.toString());
        setText(integerValue.toString());
      }
    }
  };
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {
        Range rangeValue = (Range) object;
        NumberFormat formatter = MZmineCore.getConfiguration().getMZFormat();
        String value = formatter.format(rangeValue.lowerEndpoint()) + " - "
            + formatter.format(rangeValue.upperEndpoint());
        setText(value);
      }
    }
  };
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {
        Double doubleValue = Double.parseDouble(object.toString());
        NumberFormat formatter = MZmineCore.getConfiguration().getIntensityFormat();
        setText(formatter.format(doubleValue));
      }
    }
  };
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {
        NumberFormat formatter = MZmineCore.getConfiguration().getRTFormat();
        Float floatValue = Float.parseFloat(object.toString());
        setText(formatter.format(floatValue));
      }
    }
  };
}

@Override
public TreeTableCell<FeatureTableRow, Object> call(TreeTableColumn<FeatureTableRow, Object> p) {
  return new TreeTableCell<FeatureTableRow, Object>() {
    @Override
    public void updateItem(Object object, boolean empty) {
      super.updateItem(object, empty);
      setStyle("-fx-alignment: CENTER;"
          + "-fx-border-color: transparent -fx-table-cell-border-color -fx-table-cell-border-color transparent;");
      if (object == null) {
        setText(null);
      } else {
        // Default format to two decimals
        NumberFormat formatter = new DecimalFormat("#0.00");
        Double doubleValue = Double.parseDouble(object.toString());
        setText(formatter.format(doubleValue));
      }
    }
  };
}

private TreeTableCell<S, LocalDate> getTreeTableCell() {
    return new TreeTableCell<S, LocalDate>() {
        @Override
        protected void updateItem(LocalDate date, boolean empty) {
            super.updateItem(date, empty);
            this.setAlignment(Pos.CENTER);
            if (empty) {
                this.setText(null);
                this.setGraphic(null);
            } else {
                String dateFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy", Locale.getDefault()).format(date);
                this.setText(dateFormatter);
            }
        }
    };
}

public PgpKeyTreePane() {
    loadDynamicComponentFxml(PgpKeyTreePane.class, this);

    treeTableView.setShowRoot(false);
    treeTableView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    nameTreeTableColumn.setCellFactory(new Callback<TreeTableColumn<PgpKeyTreeItem<?>,String>, TreeTableCell<PgpKeyTreeItem<?>,String>>() {
        @Override
        public TreeTableCell<PgpKeyTreeItem<?>, String> call(TreeTableColumn<PgpKeyTreeItem<?>, String> param) {
            return new NameCell();
        }
    });

    checkedTreeItems.addListener(new SetChangeListener<PgpKeyTreeItem<?>>() {
        @Override
        public void onChanged(SetChangeListener.Change<? extends PgpKeyTreeItem<?>> change) {
            final PgpKeyTreeItem<?> elementAdded = change.getElementAdded();
            if (elementAdded != null)
                elementAdded.setChecked(true);

            final PgpKeyTreeItem<?> elementRemoved = change.getElementRemoved();
            if (elementRemoved != null)
                elementRemoved.setChecked(false);
        }
    });
}

@Override
public TreeTableCell<FileTreeItem<?>, String> call(TreeTableColumn<FileTreeItem<?>, String> param) {
    return new TreeTableCell<FileTreeItem<?>, String>() {
        @Override
        protected void updateItem(String value, boolean empty) {
            super.updateItem(value, empty);

            final FileTreeItem<?> treeItem = getTreeTableRow().getItem();

            if (value == null || treeItem == null || empty) {
                setText(null);
                setGraphic(null);
            } else {
                setText(value);
                setGraphic(treeItem2CollisionIconImageView.get(treeItem));
                updateGraphicAsync(this, treeItem);
            }
        }

    };
}

public TreeTableCell<?, ?> getTreeTableCellAt(TreeTableView<?> treeTableView, Point2D point) {
    point = treeTableView.localToScene(point);
    Set<Node> lookupAll = getTreeTableCells(treeTableView);
    TreeTableCell<?, ?> selected = null;
    for (Node cellNode : lookupAll) {
        Bounds boundsInScene = cellNode.localToScene(cellNode.getBoundsInLocal(), true);
        if (boundsInScene.contains(point)) {
            selected = (TreeTableCell<?, ?>) cellNode;
            break;
        }
    }
    return selected;
}

protected int getTreeTableColumnAt(TreeTableView<?> treeTableView, Point2D point) {
    TreeTableCell<?, ?> selected = getTreeTableCellAt(treeTableView, point);
    if (selected == null) {
        return -1;
    }
    return treeTableView.getColumns().indexOf(selected.getTableColumn());
}

protected int getTreeTableRowAt(TreeTableView<?> treeTableView, Point2D point) {
    TreeTableCell<?, ?> selected = getTreeTableCellAt(treeTableView, point);
    if (selected == null) {
        return -1;
    }
    return selected.getTreeTableRow().getIndex();
}

@SuppressWarnings("rawtypes") public TreeTableCell getVisibleCellAt(TreeTableView<?> treeTableView, int row, int column) {
    Set<Node> lookupAll = getTreeTableCells(treeTableView);
    TreeTableCell cell = null;
    for (Node node : lookupAll) {
        TreeTableCell<?, ?> cell1 = (TreeTableCell<?, ?>) node;
        TreeTableRow<?> tableRow = cell1.getTreeTableRow();
        TreeTableColumn<?, ?> tableColumn = cell1.getTableColumn();
        if (tableRow.getIndex() == row && tableColumn == treeTableView.getColumns().get(column)) {
            cell = cell1;
            break;
        }
    }
    return cell;
}

private Set<Node> getTreeTableCells(TreeTableView<?> treeTableView) {
    Set<Node> l = treeTableView.lookupAll("*");
    Set<Node> r = new HashSet<>();
    for (Node node : l) {
        if (node instanceof TreeTableCell<?, ?>) {
            r.add(node);
        }
    }
    return r;
}

public static void reset() {
    add(Node.class, JavaFXElement.class);
    add(TextInputControl.class, JavaFXTextInputControlElement.class);
    add(HTMLEditor.class, JavaFXHTMLEditor.class);
    add(CheckBox.class, JavaFXCheckBoxElement.class);
    add(ToggleButton.class, JavaFXToggleButtonElement.class);
    add(Slider.class, JavaFXSliderElement.class);
    add(Spinner.class, JavaFXSpinnerElement.class);
    add(SplitPane.class, JavaFXSplitPaneElement.class);
    add(ProgressBar.class, JavaFXProgressBarElement.class);
    add(ChoiceBox.class, JavaFXChoiceBoxElement.class);
    add(ColorPicker.class, JavaFXColorPickerElement.class);
    add(ComboBox.class, JavaFXComboBoxElement.class);
    add(DatePicker.class, JavaFXDatePickerElement.class);
    add(TabPane.class, JavaFXTabPaneElement.class);
    add(ListView.class, JavaFXListViewElement.class);
    add(TreeView.class, JavaFXTreeViewElement.class);
    add(TableView.class, JavaFXTableViewElement.class);
    add(TreeTableView.class, JavaFXTreeTableViewElement.class);
    add(CheckBoxListCell.class, JavaFXCheckBoxListCellElement.class);
    add(ChoiceBoxListCell.class, JavaFXChoiceBoxListCellElement.class);
    add(ComboBoxListCell.class, JavaFXComboBoxListCellElemnt.class);
    add(CheckBoxTreeCell.class, JavaFXCheckBoxTreeCellElement.class);
    add(ChoiceBoxTreeCell.class, JavaFXChoiceBoxTreeCellElement.class);
    add(ComboBoxTreeCell.class, JavaFXComboBoxTreeCellElement.class);
    add(TableCell.class, JavaFXTableViewCellElement.class);
    add(CheckBoxTableCell.class, JavaFXCheckBoxTableCellElement.class);
    add(ChoiceBoxTableCell.class, JavaFXChoiceBoxTableCellElement.class);
    add(ComboBoxTableCell.class, JavaFXComboBoxTableCellElemnt.class);
    add(TreeTableCell.class, JavaFXTreeTableCellElement.class);
    add(CheckBoxTreeTableCell.class, JavaFXCheckBoxTreeTableCell.class);
    add(ChoiceBoxTreeTableCell.class, JavaFXChoiceBoxTreeTableCell.class);
    add(ComboBoxTreeTableCell.class, JavaFXComboBoxTreeTableCell.class);
}

@Override public String _getValue() {
    TreeTableCell<?, ?> cell = (TreeTableCell<?, ?>) node;
    Node graphic = cell.getGraphic();
    JavaFXElement component = (JavaFXElement) JavaFXElementFactory.createElement(graphic, driver, window);
    if (graphic != null && component != null) {
        if (graphic instanceof CheckBox) {
            String cellText = cell.getText() == null ? "" : cell.getText();
            return cellText + ":" + component._getValue();
        }
        return component._getValue();
    }
    return super._getValue();
}

@SuppressWarnings({ "unchecked", "rawtypes" }) private Node getEditor() {
    TreeTableCell cell = (TreeTableCell) getPseudoComponent();
    cell.getTreeTableView().edit(cell.getTreeTableRow().getIndex(), cell.getTableColumn());
    Node cellComponent = cell.getGraphic();
    cellComponent.getProperties().put("marathon.celleditor", true);
    cellComponent.getProperties().put("marathon.cell", cell);
    return cellComponent;
}

@Override public void click(int button, Node target, PickResult pickResult, int clickCount, double xoffset, double yoffset) {
    Node cell = getPseudoComponent();
    target = getTextObj((TreeTableCell<?, ?>) cell);
    Point2D targetXY = target.localToParent(xoffset, yoffset);
    targetXY = node.localToScene(targetXY);
    super.click(button, target, new PickResult(target, targetXY.getX(), targetXY.getY()), clickCount, xoffset, yoffset);
}

private Node getTextObj(TreeTableCell<?, ?> cell) {
    for (Node child : cell.getChildrenUnmodifiable()) {
        if (child instanceof Text) {
            return child;
        }
    }
    return cell;
}

@Override public Object _makeVisible() {
    TreeTableView<?> treeTableView = (TreeTableView<?>) getComponent();
    TreeTableCell<?, ?> cell = (TreeTableCell<?, ?>) getPseudoComponent();
    if (cell == null) {
        treeTableView.scrollToColumnIndex(viewColumn);
        treeTableView.scrollTo(getTreeTableNodeIndex(treeTableView, path));
        return false;
    }
    return true;
}

public String getTreeTableCellValueAt(TreeTableView<?> treeTableView, int row, int column) {
    if (row == -1 || column == -1) {
        return null;
    }
    TreeTableCell<?, ?> treeTableCell = getCellAt(treeTableView, row, column);
    RFXComponent cellComponent = getFinder().findRCellComponent(treeTableCell, null, recorder);
    return cellComponent == null ? null : cellComponent.getValue();
}

@Override public String _getText() {
    if (row != -1 && column != -1) {
        TreeTableCell<?, ?> treeTableCell = getCellAt((TreeTableView<?>) node, row, column);
        if (treeTableCell != null) {
            return treeTableCell.getText();
        }
    }
    return getTreeTableSelection((TreeTableView<?>) node);
}

private TreeTableCell<T,Object> getCellFactory(TreeTableColumn<T,Object> tc)
{
    return new TreeTableCell<T,Object>()
    {
        @Override
        protected void updateItem(Object item, boolean empty)
        {
            super.updateItem(item, empty);

            if(empty)
            {
                setText(null);
                setGraphic(null);
            }
            else
            {
                if(renderer == null)
                {
                    String text = formatter.toString(item);
                    setText(text);
                    setGraphic(null);
                    setAlignment(alignment);
                }
                else
                {
                    Node n = renderer.apply(item);
                    setText(null);
                    setGraphic(n);
                }
            }
        }
    };
}

private Callback createCellFactory()
{
    return new Callback<TreeTableColumn<T,?>,TreeTableCell<T,?>>()
    {
        @Override
        public TreeTableCell<T,?> call(TreeTableColumn<T,?> column)
        {
            return new TreeTableCell()
            {
                @Override
                protected void updateItem(Object item, boolean empty)
                {
                    if(item == getItem())
                    {
                        return;
                    }

                    super.updateItem(item, empty);

                    if(item == null)
                    {
                        super.setText(null);
                        super.setGraphic(null);
                    }
                    else if(item instanceof Node)
                    {
                        super.setText(null);
                        super.setGraphic((Node)item);
                    }
                    else
                    {
                        super.setText(item.toString());
                        super.setGraphic(null);
                    }
                }
            };
        }
    };
}

protected Wrap getDisclosureNode(final Wrap<? extends IndexedCell> cellWrap) {

        final IndexedCell cell = cellWrap.getControl();
        final String arrowStyle = "tree-disclosure-node";

        if (TreeCell.class.isAssignableFrom(cell.getClass())) {
            return cellWrap.as(Parent.class, Node.class).lookup(new ByStyleClass(arrowStyle)).wrap();
        } else if (TreeTableCell.class.isAssignableFrom(cell.getClass())) {
            final NodeWrap<IndexedCell> nodeWrap = new NodeWrap(cellWrap.getEnvironment(), cellWrap.getControl().getParent());
            Parent cellAsParent = nodeWrap.as(Parent.class, IndexedCell.class);
            return cellAsParent.lookup(new ByStyleClass(arrowStyle)).wrap();
        } else {
            throw new IllegalStateException();
        }
    }

public boolean check(Node control) {
    if (TableCell.class.isAssignableFrom(control.getClass())) {
        return getColumnIndex((TableCell) control) == column
                && getRowIndex((TableCell) control) == row;
    } else if (TreeTableCell.class.isAssignableFrom(control.getClass())) {
        return getColumnIndex((TreeTableCell) control) == column
                && getRowIndex((TreeTableCell) control) == row;
    } else {
        return false;
    }
}

public static int getRowIndex(final TreeTableCell tableCell) {
    return new GetAction<Integer>() {
        @Override
        public void run(Object... os) throws Exception {
            setResult(tableCell.getTreeTableRow().getIndex());
        }
    }.dispatch(Root.ROOT.getEnvironment());
}

public static int getColumnIndex(final TreeTableCell tableCell) {
    return new GetAction<Integer>() {
        @Override
        public void run(Object... os) throws Exception {
            setResult(tableCell.getTreeTableView().getVisibleLeafIndex(tableCell.getTableColumn()));
        }
    }.dispatch(Root.ROOT.getEnvironment());
}

static Wrap getCell(TreeTableViewDock treeTable, final TreeTableItemDock treeItem) {
    return treeTable.wrap().as(Parent.class, TreeTableCell.class)
            .lookup(TreeTableCell.class,
            new LookupCriteria<TreeTableCell>() {
        public boolean check(TreeTableCell control) {
            return control.getTreeTableRow().getTreeItem()
                    == treeItem.getItem();
        }
    }).wrap();
}

@BeforeClass
public static void setUpClass() {
    if (isTreeViewTests) {
        TreeViewApp.main(null);
    } else {
        TreeTableAsOldTreeApp.main(null);
    }
    scene = Root.ROOT.lookup().wrap();
    parent = scene.as(Parent.class, Node.class);
    if (isTreeViewTests) {
        tree = parent.lookup(TreeView.class).wrap();
    } else {
        tree = parent.lookup(TreeTableView.class).wrap();
    }
    treeAsMultiSelectable = tree.as(Selectable.class, TreeItem.class);
    treeAsParent = tree.as(Parent.class, TreeItem.class);
    treeAsTreeSelector = tree.as(Tree.class, String.class);
    multipleSelection = parent.lookup(CheckBox.class, new ByID<CheckBox>(TreeViewApp.MULTIPLE_SELECTION_ID)).wrap();
    treeAsNodeParent = tree.as(Parent.class, Node.class);
    if (isTreeViewTests) {
        cellClass = TreeCell.class;
    } else {
        cellClass = TreeTableCell.class;
    }

    ThemeDriverFactory factory = (ThemeDriverFactory) ThemeDriverFactory.getThemeFactory();
    CaspianDriverFactory caspianFactory = null;
    if (factory instanceof CaspianDriverFactory) {
        caspianFactory = (CaspianDriverFactory) factory;
        caspianFactory.setDragDelta(11);
    }
}

@Override
public boolean check(TreeTableCell control) {
    if (control.isVisible() && control.getOpacity() == 1.0) {
        return control.getTableColumn().equals(column) && control.getTreeTableRow().getIndex() == row;
    }
    return false;
}

@Shortcut
public void scrollTo(int row, int column) {
    if (scroll == null) {
        scroll = new TableTreeScroll(this);
    }
    scroll.checkScrolls();
    TableUtils.<TreeTableCell>scrollTo(getEnvironment(), this,
            scroll.hScroll, scroll.vScroll,
            row, column,
            new TableUtils.TreeTableViewIndexInfoProvider(this), TreeTableCell.class);
}

private TreeTableCell<T,Object> getCellFactory(TreeTableColumn<T,Object> tc)
{
    return new TreeTableCell<T,Object>()
    {
        @Override
        protected void updateItem(Object item, boolean empty)
        {
            super.updateItem(item, empty);

            if(empty)
            {
                item = null;
            }

            if(renderer == null)
            {
                String text = formatter.toString(item);
                setText(text);
                setGraphic(null);
                setAlignment(alignment);
            }
            else
            {
                Node n = renderer.apply(item);
                setText(null);
                setGraphic(n);
            }
        }
    };
}

private TreeTableCell<T,Object> getCellFactory(TreeTableColumn<T,Object> tc)
{
    return new TreeTableCell<T,Object>()
    {
        @Override
        protected void updateItem(Object item, boolean empty)
        {
            super.updateItem(item, empty);

            if(empty)
            {
                setText(null);
                setGraphic(null);
            }
            else
            {
                if(renderer == null)
                {
                    String text = formatter.toString(item);
                    setText(text);
                    setGraphic(null);
                    setAlignment(alignment);
                }
                else
                {
                    Node n = renderer.apply(item);
                    setText(null);
                    setGraphic(n);
                }
            }
        }
    };
}

private Callback createCellFactory()
{
    return new Callback<TreeTableColumn<T,?>,TreeTableCell<T,?>>()
    {
        @Override
        public TreeTableCell<T,?> call(TreeTableColumn<T,?> column)
        {
            return new TreeTableCell()
            {
                @Override
                protected void updateItem(Object item, boolean empty)
                {
                    if(item == getItem())
                    {
                        return;
                    }

                    super.updateItem(item, empty);

                    if(item == null)
                    {
                        super.setText(null);
                        super.setGraphic(null);
                    }
                    else if(item instanceof Node)
                    {
                        super.setText(null);
                        super.setGraphic((Node)item);
                    }
                    else
                    {
                        super.setText(item.toString());
                        super.setGraphic(null);
                    }
                }
            };
        }
    };
}