Java 类javafx.beans.property.ReadOnlyObjectWrapper 实例源码

static <T> TableView<ClassifierResult<T>> createClassifierTable() {
    TableView<ClassifierResult<T>> ret = new TableView<>();
    ret.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);

    TableColumn<ClassifierResult<T>, String> tab0 = new TableColumn<>("name");
    tab0.setCellValueFactory(data -> new ReadOnlyObjectWrapper<>(data.getValue().getClassifier().getName()));
    ret.getColumns().add(tab0);

    TableColumn<ClassifierResult<T>, String> tab1 = new TableColumn<>("score");
    tab1.setCellValueFactory(data -> new ReadOnlyObjectWrapper<>(String.format("%.2f", data.getValue().getScore())));
    ret.getColumns().add(tab1);

    TableColumn<ClassifierResult<T>, Double> tab2 = new TableColumn<>("weight");
    tab2.setCellValueFactory(data -> new ReadOnlyObjectWrapper<>(data.getValue().getClassifier().getWeight()));
    ret.getColumns().add(tab2);

    TableColumn<ClassifierResult<T>, String> tab3 = new TableColumn<>("w. score");
    tab3.setCellValueFactory(data -> new ReadOnlyObjectWrapper<>(String.format("%.2f", data.getValue().getScore() * data.getValue().getClassifier().getWeight())));
    ret.getColumns().add(tab3);

    ret.setItems(FXCollections.observableArrayList());

    return ret;
}

@FXML
private void initialize() {
    content.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
    content.setRowFactory(value -> new EditTableRow());

    nameColumn.setCellValueFactory((value) -> {
        return new ReadOnlyObjectWrapper<>(station.getFilterName(value.getValue()));
    });
    summaryColumn.setCellValueFactory((value) -> {
        return new ReadOnlyObjectWrapper<>(value.getValue().getSummary());
    });
    editColumn.setCellValueFactory((value) -> {
        return new ReadOnlyObjectWrapper<>(value.getValue());
    });
    editColumn.setSortable(false);
    editColumn.setCellFactory(value -> new TriggerRowEditCell<>());
}

@FXML
private void initialize() {
    content.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);

    contentPriorityColumn.setSortable(false);
    contentPriorityColumn.setCellValueFactory(value -> new ReadOnlyObjectWrapper<>(value.getValue().getStation().getContexts().indexOf(value.getValue()) + 1));

    nameColumn.setCellValueFactory((value) -> {
        return new ReadOnlyObjectWrapper<>(value.getValue().getName());
    });
    summaryColumn.setCellValueFactory((value) -> {
        return new ReadOnlyObjectWrapper<>(value.getValue().getSummary());
    });
    editColumn.setCellValueFactory((value) -> {
        return new ReadOnlyObjectWrapper<>(value.getValue());
    });
    editColumn.setSortable(false);
    editColumn.setCellFactory(value -> new TriggerRowEditCell<>());
    content.setRowFactory(ControlsHelper.dragDropReorderRowFactory(content, new EditTableRow()));

    content.setOnKeyPressed(keyEvent -> {
        if(keyEvent.getCode() == KeyCode.DELETE) {
            removeEntries();
        }
    });
}

@SuppressWarnings("unchecked")
private void init() {
    getStyleClass().add("hex-table-view");
    // setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);

    TableColumn<Integer, String> count = new TableColumn<>("OFFSET");
    count.setId("count-column");
    count.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper<String>(createCountItem(cellData.getValue())));

    TableColumn<Integer, String> hex = new TableColumn<>("00 01 02 03 04 05 06 07  08 09 0A 0B 0C 0D 0E 0F");
    hex.setId("hex-column");
    hex.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper<String>(createHexItem(cellData.getValue())));

    TableColumn<Integer, String> text = new TableColumn<>("TEXT");
    text.setId("text-column");
    text.setCellValueFactory(cellData -> new ReadOnlyObjectWrapper<String>(createItem(cellData.getValue())));

    getColumns().addAll(count, hex, text);
    sortPolicyProperty().set(t -> false);
    setColumnResizePolicy((param) -> true);
}

public VarsPanel(AppSession session) {
    this.session = session;        
    table = new TableView();
    table.setPrefWidth(300);
    table.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
    setCenter(table);
    TableColumn nameCol = new TableColumn("Variable");
    nameCol.setMinWidth(120);
    nameCol.setMaxWidth(250);
    nameCol.setCellValueFactory(new PropertyValueFactory("name"));
    nameCol.setCellFactory(c -> new StringTooltipCell());
    TableColumn typeCol = new TableColumn("Type");
    typeCol.setMinWidth(45);
    typeCol.setMaxWidth(60);
    typeCol.setCellValueFactory(new PropertyValueFactory("type"));
    TableColumn<Var, ScriptValue> valueCol = new TableColumn("Value");
    valueCol.setCellValueFactory(c -> new ReadOnlyObjectWrapper(c.getValue().getValue()));        
    valueCol.setCellFactory(c -> new VarValueCell());
    table.getColumns().addAll(nameCol, typeCol, valueCol);
    table.setItems(session.getVars());
    table.setRowFactory(tv -> {
        TableRow<Var> row = new TableRow<>();
        row.setOnMouseClicked(e -> {
            if (e.getClickCount() == 2 && !row.isEmpty()) {
                Var var = row.getItem();
                session.logVar(var);
            }
        });
        return row ;
    });        
}

/**
 * Creates a new source tree table. It comes pre-populated with a key and a value column.
 */
public SourceTreeTable() {
  keyColumn.prefWidthProperty().bind(widthProperty().divide(2).subtract(2));
  valueColumn.prefWidthProperty().bind(widthProperty().divide(2).subtract(2));

  keyColumn.setCellValueFactory(
      f -> new ReadOnlyStringWrapper(getEntryForCellData(f).getViewName()));
  valueColumn.setCellValueFactory(
      f -> new ReadOnlyObjectWrapper(getEntryForCellData(f).getValueView()));
  Label placeholder = new Label();
  placeholder.textProperty().bind(EasyBind.monadic(sourceType)
      .map(SourceType::getName)
      .map(n -> "No data available. Is there a connection to " + n + "?")
      .orElse("No data available. Is the source connected?"));
  setPlaceholder(placeholder);

  getColumns().addAll(keyColumn, valueColumn);
}

/**
 * If the entry is a recurrence (see {@link #recurrenceProperty()}) then
 * this property will store a reference to the entry for which the
 * recurrence was created.
 *
 * @return the entry that was the source of the recurrence
 */
public final ReadOnlyObjectProperty<Entry<T>> recurrenceSourceProperty() {
    if (recurrenceSource == null) {
        recurrenceSource = new ReadOnlyObjectWrapper<Entry<T>>(this, "recurrenceSource") { //$NON-NLS-1$
            @Override
            public void set(Entry<T> newEntry) {
                super.set(newEntry);
                if (newEntry != null) {
                    setRecurrence(true);
                } else {
                    setRecurrence(false);
                }
            }
        };
    }

    return recurrenceSource.getReadOnlyProperty();
}

public VideosView(final VideosController controller) {
    videosController = controller;
    FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("videos.fxml"));
    fxmlLoader.setRoot(this);
    try {
        fxmlLoader.load();
    } catch (IOException exception) {
        throw new RuntimeException(exception);
    }

    lookupViews();

    setItems(MediaLibrary.instance().getVideos());

    setPlaceholder(new Label("Choose a Directory to play videos"));
    titleCol.setCellValueFactory(p -> new ReadOnlyObjectWrapper<>(p.getValue().getTitle()));
    durationCol.setCellValueFactory(p -> p.getValue().durationProperty());

    // Subtract 20 total to leave room for the scrollbar
    titleCol.prefWidthProperty().bind(widthProperty().multiply(0.7).subtract(10));
    durationCol.prefWidthProperty().bind(widthProperty().multiply(0.3).subtract(10));

    getSelectionModel().selectedItemProperty().addListener(videosController.selectionListener(getItems()));
}

private ValidSpecification importSpec(String name) throws
    ImportException {
  List<Type> typeContext = Arrays.asList(TypeInt.INT, TypeBool.BOOL, new TypeEnum("colors",
      Arrays.asList("red", "green", "blue")));
  List<CodeIoVariable> codeIoVariables = new LinkedList<>();

  ConstraintSpecification constraintSpec = ImporterFacade.importConstraintSpec(getClass().getResourceAsStream(name), ImporterFacade
      .ImportFormat.XML);
  FreeVariableListValidator freeVariableListValidator = new FreeVariableListValidator(new
      SimpleObjectProperty<>(typeContext), constraintSpec
      .getFreeVariableList());
  List<ValidFreeVariable> freeVariables = freeVariableListValidator.validFreeVariablesProperty().get();
  this.freeVariables = freeVariables;
  ConstraintSpecificationValidator recognizer = new ConstraintSpecificationValidator(
      new SimpleObjectProperty<>(typeContext),
      new SimpleObjectProperty<>(codeIoVariables),
      new ReadOnlyObjectWrapper<>(freeVariables),
      constraintSpec);
  List<SpecProblem> specProblems = recognizer.problemsProperty().get();
  specProblems.stream().map(SpecProblem::getErrorMessage).forEach(System.err::println);

  return recognizer.getValidSpecification();
}

private ValidSpecification importSpec(String name) throws
    ImportException {
  List<Type> typeContext = Arrays.asList(TypeInt.INT, TypeBool.BOOL, new TypeEnum("colors",
      Arrays.asList("red", "green", "blue")));
  List<CodeIoVariable> codeIoVariables = new LinkedList<>();

  ConstraintSpecification constraintSpec = ImporterFacade.importConstraintSpec(getClass().getResourceAsStream(name), ImporterFacade
      .ImportFormat.XML);
  FreeVariableListValidator freeVariableListValidator = new FreeVariableListValidator(new
      SimpleObjectProperty<>(typeContext), constraintSpec
      .getFreeVariableList());
  List<ValidFreeVariable> freeVariables = freeVariableListValidator.validFreeVariablesProperty().get();
  this.freeVariables = freeVariables;
  ConstraintSpecificationValidator validator = new ConstraintSpecificationValidator(
      new SimpleObjectProperty<>(typeContext),
      new SimpleObjectProperty<>(codeIoVariables),
      new ReadOnlyObjectWrapper<>(freeVariables),
      constraintSpec);
  List<SpecProblem> specProblems = validator.problemsProperty().get();
  specProblems.stream().map(SpecProblem::getErrorMessage).forEach(System.out::println);

  return validator.getValidSpecification();
}

private ReadOnlyObjectWrapper<DockTabPane> tabPanePropertyImpl() {
    if (tabPane == null) {
        tabPane = new ReadOnlyObjectWrapper<DockTabPane>(this, "tabPane") {
            private WeakReference<DockTabPane> oldParent;

            @Override
            protected void invalidated() {
                if (oldParent != null && oldParent.get() != null) {
                    oldParent.get().disabledProperty().removeListener(parentDisabledChangedListener);
                }
                updateDisabled();
                DockTabPane newParent = get();
                if (newParent != null) {
                    newParent.disabledProperty().addListener(parentDisabledChangedListener);
                }
                oldParent = new WeakReference<DockTabPane>(newParent);
                super.invalidated();
            }
        };
    }
    return tabPane;
}

public MakeBusinessFrameComposite(String title, Object userParam) throws IOException {
    // FXMLLoader loader = new FXMLLoader();
    // loader.setLocation(MakeBusinessFrameComposite.class.getResource("MakeTriggerFrameView.fxml"));
    // loader.setRoot(this);
    // loader.setController(this);
    // loader.load();

    FxUtil.loadRoot(MakeBusinessFrameComposite.class, this, err -> {
        LOGGER.error(ValueUtil.toString(err));
    });

    properties = new ArrayList<>();
    titleProperty.set(title);
    this.userParam = new ReadOnlyObjectWrapper<Object>(userParam);
    this.currentPage.addListener(currentPageChangeListener);
}

private DockNode() {

        station = new SimpleObjectProperty<>(null);

        floatableProperty = new SimpleBooleanProperty(true);
        closeableProperty = new SimpleBooleanProperty(true);
        resizableProperty = new SimpleBooleanProperty(true);
        maximizableProperty = new SimpleBooleanProperty(true);

        floatingProperty = new ReadOnlyBooleanWrapper(false);
        draggingProperty = new ReadOnlyBooleanWrapper(false);
        resizingProperty = new ReadOnlyBooleanWrapper(false);
        maximizingProperty = new ReadOnlyBooleanWrapper(false);

        container = new ReadOnlyObjectWrapper<>(null);

    }

@Override
public void initialize(URL location, ResourceBundle resources) {
    browseSourceDirButton.disableProperty().bind(manualTitledPane.expandedProperty());
    srcPathTextField.disableProperty().bind(manualTitledPane.expandedProperty());
    fileTable.setPlaceholder(new Label("Let's add some files!"));
    fileTable.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
    fileNameColumn.setCellValueFactory(
            p -> new ReadOnlyObjectWrapper<String>(p.getValue().getPath()));
    fileNameColumn.setCellFactory(view -> new FileNameCell());
    // indexOf operation might not be very fast. Also the code should ensure that the list with
    // items contains only unique values.
    numberColumn.setCellValueFactory(p -> new ReadOnlyObjectWrapper<String>(
            String.valueOf(p.getTableView().getItems().indexOf(p.getValue()) + 1)));
    manualPaneDotsAnima = new ThreeDotsAnimation(
            "Editing list of <filetype> files", '.',
            manualTitledPane.textProperty(), 1, 500, Timeline.INDEFINITE);
    setValidationForFileTableWithDelay.setCycleCount(1);
    fileTable.getSelectionModel().selectedItemProperty().addListener((o, oldVal, newVal) -> {
        sampleFile.set(newVal);
    });
    initializeListeners();
    // Set tooltips showing file paths.
    GUIUtil.createAndBindTooltipToTextfield(srcPathTextField);
}

private void loadData(List<Map<String, String>> data) {
    batchDataTable.getColumns().clear();

    TableColumn<Map<String, String>, String> numberCol = new TableColumn("");
    numberCol.setCellValueFactory(row -> new ReadOnlyObjectWrapper(
            (row.getTableView().getItems().indexOf(row.getValue()) + 1) + ""));
    batchDataTable.getColumns().add(numberCol);
    numberCol.setMinWidth(50);

    data.get(0).keySet().forEach(varName -> {
        TableColumn<Map<String, String>, String> varCol = new TableColumn(varName);
        varCol.setCellValueFactory(row -> new ReadOnlyObjectWrapper(row.getValue().get(varName)));
        batchDataTable.getColumns().add(varCol);
    });

    batchDataTable.setItems(new ObservableListWrapper<>(data));
}

private DockNode() {

        station = new SimpleObjectProperty<>(null);

        floatableProperty = new SimpleBooleanProperty(true);
        closeableProperty = new SimpleBooleanProperty(true);
        resizableProperty = new SimpleBooleanProperty(true);
        maximizableProperty = new SimpleBooleanProperty(true);

        floatingProperty = new ReadOnlyBooleanWrapper(false);
        draggingProperty = new ReadOnlyBooleanWrapper(false);
        resizingProperty = new ReadOnlyBooleanWrapper(false);
        maximizingProperty = new ReadOnlyBooleanWrapper(false);

        container = new ReadOnlyObjectWrapper<>(null);

    }

private void setDateColumnCellFactory() {
    dateColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    dateColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null && !empty) {
                                setGraphic(new AutoTooltipLabel(formatter.formatDateTime(item.getTrade().getDate())));
                            } else {
                                setGraphic(null);
                            }
                        }
                    };
                }
            });
}

private void setAmountColumnCellFactory() {
    amountColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    amountColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null && !empty)
                                setGraphic(new AutoTooltipLabel(formatter.formatCoinWithCode(item.getTrade().getTradeAmount())));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setPriceColumnCellFactory() {
    priceColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    priceColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null && !empty)
                                setGraphic(new AutoTooltipLabel(formatter.formatPrice(item.getPrice())));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setVolumeColumnCellFactory() {
    volumeColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    volumeColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null && !empty)
                                setGraphic(new AutoTooltipLabel(formatter.formatVolumeWithCode(item.getTrade().getTradeVolume())));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setPaymentMethodColumnCellFactory() {
    paymentMethodColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    paymentMethodColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null && !empty)
                                setGraphic(new AutoTooltipLabel(model.getPaymentMethod(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setMarketColumnCellFactory() {
    marketColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    marketColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getMarketLabel(item)));
                        }
                    };
                }
            });
}

private void setRoleColumnCellFactory() {
    roleColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    roleColumn.setCellFactory(
            new Callback<TableColumn<PendingTradesListItem, PendingTradesListItem>, TableCell<PendingTradesListItem,
                    PendingTradesListItem>>() {
                @Override
                public TableCell<PendingTradesListItem, PendingTradesListItem> call(
                        TableColumn<PendingTradesListItem, PendingTradesListItem> column) {
                    return new TableCell<PendingTradesListItem, PendingTradesListItem>() {
                        @Override
                        public void updateItem(final PendingTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null && !empty)
                                setGraphic(new AutoTooltipLabel(model.getMyRole(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setDateColumnCellFactory() {
    dateColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    dateColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getDate(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setMarketColumnCellFactory() {
    marketColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    marketColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getMarketLabel(item)));
                        }
                    };
                }
            });
}

private void setStateColumnCellFactory() {
    stateColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    stateColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getState(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setAmountColumnCellFactory() {
    amountColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    amountColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getAmount(item)));
                        }
                    };
                }
            });
}

private void setPriceColumnCellFactory() {
    priceColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    priceColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getPrice(item)));
                        }
                    };
                }
            });
}

private void setVolumeColumnCellFactory() {
    volumeColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    volumeColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getVolume(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setDirectionColumnCellFactory() {
    directionColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    directionColumn.setCellFactory(
            new Callback<TableColumn<ClosedTradableListItem, ClosedTradableListItem>, TableCell<ClosedTradableListItem,
                    ClosedTradableListItem>>() {
                @Override
                public TableCell<ClosedTradableListItem, ClosedTradableListItem> call(
                        TableColumn<ClosedTradableListItem, ClosedTradableListItem> column) {
                    return new TableCell<ClosedTradableListItem, ClosedTradableListItem>() {
                        @Override
                        public void updateItem(final ClosedTradableListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getDirectionLabel(item)));
                        }
                    };
                }
            });
}

private void setDateColumnCellFactory() {
    dateColumn.setCellValueFactory((openOfferListItem) -> new ReadOnlyObjectWrapper<>(openOfferListItem.getValue()));
    dateColumn.setCellFactory(
            new Callback<TableColumn<OpenOfferListItem, OpenOfferListItem>, TableCell<OpenOfferListItem,
                    OpenOfferListItem>>() {
                @Override
                public TableCell<OpenOfferListItem, OpenOfferListItem> call(
                        TableColumn<OpenOfferListItem, OpenOfferListItem> column) {
                    return new TableCell<OpenOfferListItem, OpenOfferListItem>() {
                        @Override
                        public void updateItem(final OpenOfferListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getDate(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setAmountColumnCellFactory() {
    amountColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    amountColumn.setCellFactory(
            new Callback<TableColumn<OpenOfferListItem, OpenOfferListItem>, TableCell<OpenOfferListItem,
                    OpenOfferListItem>>() {
                @Override
                public TableCell<OpenOfferListItem, OpenOfferListItem> call(
                        TableColumn<OpenOfferListItem, OpenOfferListItem> column) {
                    return new TableCell<OpenOfferListItem, OpenOfferListItem>() {
                        @Override
                        public void updateItem(final OpenOfferListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getAmount(item)));
                        }
                    };
                }
            });
}

private void setPriceColumnCellFactory() {
    priceColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    priceColumn.setCellFactory(
            new Callback<TableColumn<OpenOfferListItem, OpenOfferListItem>, TableCell<OpenOfferListItem,
                    OpenOfferListItem>>() {
                @Override
                public TableCell<OpenOfferListItem, OpenOfferListItem> call(
                        TableColumn<OpenOfferListItem, OpenOfferListItem> column) {
                    return new TableCell<OpenOfferListItem, OpenOfferListItem>() {
                        @Override
                        public void updateItem(final OpenOfferListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getPrice(item)));
                        }
                    };
                }
            });
}

private void setVolumeColumnCellFactory() {
    volumeColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    volumeColumn.setCellFactory(
            new Callback<TableColumn<OpenOfferListItem, OpenOfferListItem>, TableCell<OpenOfferListItem,
                    OpenOfferListItem>>() {
                @Override
                public TableCell<OpenOfferListItem, OpenOfferListItem> call(
                        TableColumn<OpenOfferListItem, OpenOfferListItem> column) {
                    return new TableCell<OpenOfferListItem, OpenOfferListItem>() {
                        @Override
                        public void updateItem(final OpenOfferListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getVolume(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setDirectionColumnCellFactory() {
    directionColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    directionColumn.setCellFactory(
            new Callback<TableColumn<OpenOfferListItem, OpenOfferListItem>, TableCell<OpenOfferListItem,
                    OpenOfferListItem>>() {
                @Override
                public TableCell<OpenOfferListItem, OpenOfferListItem> call(
                        TableColumn<OpenOfferListItem, OpenOfferListItem> column) {
                    return new TableCell<OpenOfferListItem, OpenOfferListItem>() {
                        @Override
                        public void updateItem(final OpenOfferListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getDirectionLabel(item)));
                        }
                    };
                }
            });
}

private void setMarketColumnCellFactory() {
    marketColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    marketColumn.setCellFactory(
            new Callback<TableColumn<OpenOfferListItem, OpenOfferListItem>, TableCell<OpenOfferListItem,
                    OpenOfferListItem>>() {
                @Override
                public TableCell<OpenOfferListItem, OpenOfferListItem> call(
                        TableColumn<OpenOfferListItem, OpenOfferListItem> column) {
                    return new TableCell<OpenOfferListItem, OpenOfferListItem>() {
                        @Override
                        public void updateItem(final OpenOfferListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getMarketLabel(item)));
                        }
                    };
                }
            });
}

private void setDateColumnCellFactory() {
    dateColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    dateColumn.setCellFactory(
            new Callback<TableColumn<FailedTradesListItem, FailedTradesListItem>, TableCell<FailedTradesListItem,
                    FailedTradesListItem>>() {
                @Override
                public TableCell<FailedTradesListItem, FailedTradesListItem> call(
                        TableColumn<FailedTradesListItem, FailedTradesListItem> column) {
                    return new TableCell<FailedTradesListItem, FailedTradesListItem>() {
                        @Override
                        public void updateItem(final FailedTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getDate(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setMarketColumnCellFactory() {
    marketColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    marketColumn.setCellFactory(
            new Callback<TableColumn<FailedTradesListItem, FailedTradesListItem>, TableCell<FailedTradesListItem,
                    FailedTradesListItem>>() {
                @Override
                public TableCell<FailedTradesListItem, FailedTradesListItem> call(
                        TableColumn<FailedTradesListItem, FailedTradesListItem> column) {
                    return new TableCell<FailedTradesListItem, FailedTradesListItem>() {
                        @Override
                        public void updateItem(final FailedTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getMarketLabel(item)));
                        }
                    };
                }
            });
}

private void setStateColumnCellFactory() {
    stateColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    stateColumn.setCellFactory(
            new Callback<TableColumn<FailedTradesListItem, FailedTradesListItem>, TableCell<FailedTradesListItem,
                    FailedTradesListItem>>() {
                @Override
                public TableCell<FailedTradesListItem, FailedTradesListItem> call(
                        TableColumn<FailedTradesListItem, FailedTradesListItem> column) {
                    return new TableCell<FailedTradesListItem, FailedTradesListItem>() {
                        @Override
                        public void updateItem(final FailedTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            if (item != null)
                                setGraphic(new AutoTooltipLabel(model.getState(item)));
                            else
                                setGraphic(null);
                        }
                    };
                }
            });
}

private void setAmountColumnCellFactory() {
    amountColumn.setCellValueFactory((offer) -> new ReadOnlyObjectWrapper<>(offer.getValue()));
    amountColumn.setCellFactory(
            new Callback<TableColumn<FailedTradesListItem, FailedTradesListItem>, TableCell<FailedTradesListItem,
                    FailedTradesListItem>>() {
                @Override
                public TableCell<FailedTradesListItem, FailedTradesListItem> call(
                        TableColumn<FailedTradesListItem, FailedTradesListItem> column) {
                    return new TableCell<FailedTradesListItem, FailedTradesListItem>() {
                        @Override
                        public void updateItem(final FailedTradesListItem item, boolean empty) {
                            super.updateItem(item, empty);
                            setGraphic(new AutoTooltipLabel(model.getAmount(item)));
                        }
                    };
                }
            });
}