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); } } }; }