Javafx : ComboBoxTableCell - how to select a value in one click? - javafx

I have a TableView with a ComboBoxTableCell, when using the default implementation the user have to click three times to select a value from of the ComboBox's list.
I want when the user clicks on the cell to show the combo box list. I based my solution on this one:
JavaFX editable ComboBox in a table view
The cell does get into edit mode (startEdit() is called) but it takes another click to show the list of values, what am I missing?
table.addEventHandler(MouseEvent.MOUSE_CLICKED, (e) ->
{
if (table.getEditingCell() == null)
{
TablePosition focusedCellPos = table.getFocusModel().getFocusedCell();
table.edit(focusedCellPos.getRow(), focusedCellPos.getTableColumn());
}
});
Thanks.

Interesting problem - bubbling up again after quite a while :)
Looks like the approach of the OP is indeed working (as of fx11, some bugs around its editing seem to be fixed) - with a little help from the combo cell:
start editing in a single click handler on the tableView (from OP)
extend ComboBoxTableCell and override its startEdit to open the dropDown
Code snippet:
// set editable to see the combo
table.setEditable(true);
// keep approach by OP
table.addEventHandler(MouseEvent.MOUSE_CLICKED, (e) -> {
TablePosition<Person, ?> focusedCellPos = table.getFocusModel()
.getFocusedCell();
if (table.getEditingCell() == null) {
table.edit(focusedCellPos.getRow(),
focusedCellPos.getTableColumn());
}
});
// use modified standard combo cell shows its popup on startEdit
firstName.setCellFactory(cb -> new ComboBoxTableCell<>(firstNames) {
#Override
public void startEdit() {
super.startEdit();
if (isEditing() && getGraphic() instanceof ComboBox) {
// needs focus for proper working of esc/enter
getGraphic().requestFocus();
((ComboBox<?>) getGraphic()).show();
}
}
});

Maybe not the cleanest solution to this problem, but I found a workaround to make the ComboBoxTableCells drop down its menu in just 1 click:
column.setCellFactory(new Callback<TableColumn<Person, String>, TableCell<Person, String>>() {
#Override
public TableCell<Person, String> call(TableColumn<Person, String> column) {
ComboBoxTableCell cbtCell = new ComboBoxTableCell<>(cbValues);
cbtCell.setOnMouseEntered(new EventHandler<Event>() {
#Override
public void handle(Event event) {
// Without a Person object, a combobox shouldn't open in that row
if (((Person)((TableRow)cbtCell.getParent()).getItem()) != null) {
Robot r = new Robot();
r.mouseClick(MouseButton.PRIMARY);
r.mouseClick(MouseButton.PRIMARY);
}
}
});
return cbtCell;
}
});
PS: I know that this topic is a bit old, but I also stumbled upon this problem recently and could not find any working solution to it online. As I sad, it's not the cleanest workaround, but at least it does its job. ;)

Related

JavaFX tableview auto scroll to selected item when pressing a button to selectNext() or selectPrevious()

I'm writing a JavaFX program with a TableView called 'table' and 2 buttons called 'previous' & 'next'.
Here is part of the code:
previous.setOnAction(event -> {
table.getSelectionModel().selectPrevious();
});
next.setOnAction(event -> {
table.getSelectionModel().selectNext();
});
However, if I keep pressing the buttons, the table will not scroll automatically to keep the selected item visible. So I modified the code like this :
previous.setOnAction(event -> {
table.getSelectionModel().selectPrevious();
table.scrollTo(table.getSelectionModel().getSelectedItem());
});
next.setOnAction(event -> {
table.getSelectionModel().selectNext();
table.scrollTo(table.getSelectionModel().getSelectedItem());
});
But it will always try to keep the selected item at the top of the visible region. If I keep pressing 'next'. The selected item will stay at the top instead of staying at the bottom.
I want to mimic the natural behavior of a tableview in the way that if I press up or down on the keyboard with something selected, the tableview will scroll automatically to keep the selected item visible.
How should I modify the code to make the auto scrolling more natural when I press the buttons?
Thanks
The problem is
missing fine-grained control of scrollTo target location on application level
the (somewhat unfortunate) implementation of virtualizedControl.scrollTo(index) which (ultimately) leads to calling flow.scrollToTop(index)
There's a long-standing RFE (reported 2014!) requesting better control from application code. Actually, VirtualFlow has public methods (scrollToTop, scrollTo, scrollPixels) providing such, only they are not passed on to the control layer (getVirtualFlow in VirtualContainerBase is final protected), so can't be overridden in a custom skin. Since fx12, we can hack a bit, and expose the onSelectXX of Tree/TableViewSkin and use those, either directly in application code (example below) or in a custom TableView.
Example code:
public class TableSelectNextKeepVisible extends Application {
/**
* Custom table skin to expose onSelectXX methods for application use.
*/
public static class MyTableSkin<T> extends TableViewSkin<T> {
public MyTableSkin(TableView<T> control) {
super(control);
}
/**
* Overridden to widen scope to public.
*/
#Override
public void onSelectBelowCell() {
super.onSelectBelowCell();
}
/**
* Overridden to widen scope to public.
*/
#Override
public void onSelectAboveCell() {
super.onSelectAboveCell();
}
}
private Parent createContent() {
TableView<Locale> table = new TableView<>(FXCollections.observableArrayList(Locale.getAvailableLocales())) {
#Override
protected Skin<?> createDefaultSkin() {
return new MyTableSkin<>(this);
}
};
TableColumn<Locale, String> country = new TableColumn<>("Column");
country.setCellValueFactory(new PropertyValueFactory<>("displayLanguage"));
table.getColumns().addAll(country);
Button next = new Button("next");
next.setOnAction(e -> {
table.getSelectionModel().selectNext();
// scrolls to top
// table.scrollTo(table.getSelectionModel().getSelectedIndex());
((MyTableSkin<?>) table.getSkin()).onSelectBelowCell();
});
Button previous = new Button("previous");
previous.setOnAction(e -> {
table.getSelectionModel().selectPrevious();
// scrolls to top
// table.scrollTo(table.getSelectionModel().getSelectedIndex());
((MyTableSkin<?>) table.getSkin()).onSelectAboveCell();
});
BorderPane content = new BorderPane(table);
content.setBottom(new HBox(10, next, previous));
return content;
}
#Override
public void start(Stage stage) throws Exception {
stage.setScene(new Scene(createContent()));
stage.show();
}
public static void main(String[] args) {
launch(args);
}
}
try using getSelectedIndex as follows instead of using getSelectedItem
previous.setOnAction(event -> {
table.getSelectionModel().selectPrevious();
table.scrollTo(table.getSelectionModel().getSelectedIndex());
});
Platform.runLater( () -> TABLE_NAME.scrollTo(TABLE_INFORMATION_LIST.getList().size()-index) );
should work if you call it whenever you add information to the table.

Using setRowFactory to style rows doesn't work on visible rows (JavaFX 11)

I have a TableView which is updated from an ObservableList. It has two columns. When a file is loaded, the list is populated and the table updates, (initially just the first column is populated). After validation of the items in the list the second column is populated with a success or failure flag. Using the setRowFactory I update the background style of the row to either green for success or red for failure. Some items don't get validated and are styled with "". The table has about a dozen rows visible out of a couple of thousand rows total. The problem I have is that the visible rows don't get their background style updated until they're scrolled out of view and then back in again.
I've been able to overcome this by using the table's refresh() method, but that causes another problem. The first column is editable to allow the data to be corrected before re-validation. If the refresh() method is used then it breaks the ability to edit a cell. The textfield still appears, but is disabled, (no focus border and no ability to highlight or edit its content).
If I leave out the refresh() method editing works just fine. Include the refresh() and the table displays correctly without the need for scrolling, but editing is broken.
So I can either have editable cells or properly displayed rows, but not both. Apart from this problem the code works fine. I've read countless examples and TableView issues, and associated solutions, and nothing I've tried has fixed the problem. In my efforts I can see that the overriden updateItem method is only ever called when the row is redrawn after becoming visible again. My thinking is that I need another mechanism to style the rows on the validationResponse change but this is where I get stuck.
So my question is how to have the visible table rows get their style updated without scrolling while not breaking cell editing? Thanks!!
Edit:
Reproducible code example follows. Click the first button to populate the table with initial data. Click the second button to simulate validation. The second column will update with the validation response, but the styling doesn't take effect until the rows are scrolled out of view and then back in to view. At this point first column is editable. If you uncomment the tblGCode.refresh() line and re-run the test the styling is applied immediately without scrolling, but editing a cell in the first column no longer works.
Main class:
public class TableViewTest extends Application {
private final ObservableList<GCodeItem> gcodeItems = FXCollections.observableArrayList(
item -> new Observable[]{item.validatedProperty(), item.errorDescriptionProperty()});
private final TableView tblGCode = new TableView();
#Override
public void start(Stage stage) {
TableColumn<GCodeItem, String> colGCode = new TableColumn<>("GCode");
colGCode.setCellValueFactory(new PropertyValueFactory<>("gcode"));
TableColumn<GCodeItem, String> colStatus = new TableColumn<>("Status");
colStatus.setCellValueFactory(new PropertyValueFactory<>("validationResponse"));
// Set first column to be editable
tblGCode.setEditable(true);
colGCode.setEditable(true);
colGCode.setCellFactory(TextFieldTableCell.forTableColumn());
colGCode.setOnEditCommit((TableColumn.CellEditEvent<GCodeItem, String> t) -> {
((GCodeItem) t.getTableView().getItems().get(t.getTablePosition().getRow())).setGcode(t.getNewValue());
});
// Set row factory
tblGCode.setRowFactory(tbl -> new TableRow<GCodeItem>() {
private final Tooltip tip = new Tooltip();
{
tip.setShowDelay(new Duration(250));
}
#Override
protected void updateItem(GCodeItem item, boolean empty) {
super.updateItem(item, empty);
if(item == null || empty) {
setStyle("");
setTooltip(null);
} else {
if(item.isValidated()) {
if(item.hasError()) {
setStyle("-fx-background-color: #ffcccc"); // red
tip.setText(item.getErrorDescription());
setTooltip(tip);
} else {
setStyle("-fx-background-color: #ccffdd"); // green
setTooltip(null);
}
} else {
setStyle("");
setTooltip(null);
}
}
//tblGCode.refresh(); // this works to give desired styling, but breaks editing
}
});
tblGCode.getColumns().setAll(colGCode, colStatus);
tblGCode.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
// buttons to simulate issue
Button btnPopulate = new Button("1. Populate Table");
btnPopulate.setOnAction(eh -> populateTable());
Button btnValidate = new Button("2. Validate Table");
btnValidate.setOnAction(eh -> simulateValidation());
var scene = new Scene(new VBox(tblGCode, btnPopulate, btnValidate), 640, 320);
stage.setScene(scene);
stage.show();
}
public static void main(String[] args) {
launch();
}
private void populateTable() {
// simulates updating of ObservableList with first couple of dozen lines of a file
gcodeItems.add(new GCodeItem("(1001)"));
gcodeItems.add(new GCodeItem("(T4 D=0.25 CR=0 - ZMIN=-0.4824 - flat end mill)"));
gcodeItems.add(new GCodeItem("G90 G94"));
gcodeItems.add(new GCodeItem("G17"));
gcodeItems.add(new GCodeItem("G20"));
gcodeItems.add(new GCodeItem("G28 G91 Z0"));
gcodeItems.add(new GCodeItem("G90"));
gcodeItems.add(new GCodeItem(""));
gcodeItems.add(new GCodeItem("(Face1)"));
gcodeItems.add(new GCodeItem("T4 M6"));
gcodeItems.add(new GCodeItem("S5000 M3"));
gcodeItems.add(new GCodeItem("G54"));
gcodeItems.add(new GCodeItem("M8"));
gcodeItems.add(new GCodeItem("G0 X1.3842 Y-1.1452"));
gcodeItems.add(new GCodeItem("Z0.6"));
gcodeItems.add(new GCodeItem("Z0.2"));
gcodeItems.add(new GCodeItem("G1 Z0.015 F20"));
gcodeItems.add(new GCodeItem("G18 G3 X1.3592 Z-0.01 I-0.025 K0"));
gcodeItems.add(new GCodeItem("G1 X1.2492"));
gcodeItems.add(new GCodeItem("X-1.2492 F40"));
gcodeItems.add(new GCodeItem("X-1.25"));
gcodeItems.add(new GCodeItem("G17 G2 X-1.25 Y-0.9178 I0 J0.1137"));
gcodeItems.add(new GCodeItem("G1 X1.25"));
gcodeItems.add(new GCodeItem("G3 X1.25 Y-0.6904 I0 J0.1137"));
// Add list to table
tblGCode.setItems(gcodeItems);
}
private void simulateValidation() {
// sets validationResponse on certain rows (not every row is validated)
gcodeItems.get(2).setValidationResponse("ok");
gcodeItems.get(3).setValidationResponse("ok");
gcodeItems.get(4).setValidationResponse("ok");
gcodeItems.get(5).setValidationResponse("ok");
gcodeItems.get(6).setValidationResponse("ok");
gcodeItems.get(9).setValidationResponse("error:20");
gcodeItems.get(10).setValidationResponse("ok");
gcodeItems.get(11).setValidationResponse("ok");
gcodeItems.get(12).setValidationResponse("ok");
gcodeItems.get(13).setValidationResponse("ok");
gcodeItems.get(14).setValidationResponse("ok");
gcodeItems.get(15).setValidationResponse("ok");
gcodeItems.get(16).setValidationResponse("ok");
gcodeItems.get(17).setValidationResponse("ok");
gcodeItems.get(18).setValidationResponse("ok");
gcodeItems.get(19).setValidationResponse("ok");
gcodeItems.get(20).setValidationResponse("ok");
gcodeItems.get(21).setValidationResponse("ok");
gcodeItems.get(22).setValidationResponse("ok");
gcodeItems.get(23).setValidationResponse("ok");
}
}
GCodeItem model:
public class GCodeItem {
private final SimpleStringProperty gcode;
private final SimpleStringProperty validationResponse;
private ReadOnlyBooleanWrapper validated;
private ReadOnlyBooleanWrapper hasError;
private ReadOnlyIntegerWrapper errorNumber;
private ReadOnlyStringWrapper errorDescription;
public GCodeItem(String gcode) {
this.gcode = new SimpleStringProperty(gcode);
this.validationResponse = new SimpleStringProperty("");
this.validated = new ReadOnlyBooleanWrapper();
this.hasError = new ReadOnlyBooleanWrapper();
this.errorNumber = new ReadOnlyIntegerWrapper();
this.errorDescription = new ReadOnlyStringWrapper();
validated.bind(Bindings.createBooleanBinding(
() -> ! "".equals(getValidationResponse()),
validationResponse
));
hasError.bind(Bindings.createBooleanBinding(
() -> ! ("ok".equals(getValidationResponse()) ||
"".equals(getValidationResponse())),
validationResponse
));
errorNumber.bind(Bindings.createIntegerBinding(
() -> {
String vResp = getValidationResponse();
if ("ok".equals(vResp)) {
return 0;
} else {
// should handle potential exceptions here...
if(vResp.contains(":")) {
int en = Integer.parseInt(vResp.split(":")[1]);
return en ;
} else {
return 0;
}
}
}, validationResponse
));
errorDescription.bind(Bindings.createStringBinding(
() -> {
int en = getErrorNumber() ;
return GrblDictionary.getErrorDescription(en);
}, errorNumber
));
}
public final String getGcode() {
return gcode.get();
}
public final void setGcode(String value) {
gcode.set(value);
}
public SimpleStringProperty gcodeProperty() {
return this.gcode;
}
public final String getValidationResponse() {
return validationResponse.get();
}
public final void setValidationResponse(String value) {
validationResponse.set(value);
}
public SimpleStringProperty validationResponseProperty() {
return this.validationResponse;
}
public Boolean isValidated() {
return validatedProperty().get();
}
public ReadOnlyBooleanProperty validatedProperty() {
return validated.getReadOnlyProperty();
}
// ugly method name to conform to method naming pattern:
public final boolean isHasError() {
return hasErrorProperty().get();
}
// better method name:
public final boolean hasError() {
return isHasError();
}
public ReadOnlyBooleanProperty hasErrorProperty() {
return hasError.getReadOnlyProperty();
}
public final int getErrorNumber() {
return errorNumberProperty().get();
}
public ReadOnlyIntegerProperty errorNumberProperty() {
return errorNumber.getReadOnlyProperty() ;
}
public final String getErrorDescription() {
return errorDescriptionProperty().get();
}
public ReadOnlyStringProperty errorDescriptionProperty() {
return errorDescription.getReadOnlyProperty();
}
}
Supporting dictionary class (abridged):
public class GrblDictionary {
private static final Map<Integer, String> ERRORS = Map.ofEntries(
entry(1, "G-code words consist of a letter and a value. Letter was not found."),
entry(2, "Numeric value format is not valid or missing an expected value."),
entry(17, "Laser mode requires PWM outentry."),
entry(20, "Unsupported or invalid g-code command found in block."),
entry(21, "More than one g-code command from same modal group found in block."),
entry(22, "Feed rate has not yet been set or is undefined.")
);
public static String getErrorDescription(int errorNumber) {
return ERRORS.containsKey(errorNumber) ? ERRORS.get(errorNumber) : "Unrecognized error number.";
}
}
Edit #2:
If I replace the TableView.setRowFactory code with TableColumn.setCellFactory as shown below I get the desired effect and editing still works. Is this a sensible solution, or should I really be using setRowFactory and getting the list changes recognised correctly by setRowFactory? In my testing it only ever seemed like the overriden updateItem method was being called when rows scrolled in to view.
colStatus.setCellFactory(tc -> new TableCell<GCodeItem, String>() {
private final Tooltip tip = new Tooltip();
{
tip.setShowDelay(new Duration(250));
}
#Override
protected void updateItem(String item, boolean empty) {
super.updateItem(item, empty);
TableRow<GCodeItem> row = this.getTableRow();
GCodeItem rowItem = row.getItem();
if(item == null || empty) {
row.setStyle("");
row.setTooltip(null);
} else {
if(rowItem.isValidated()) {
if(rowItem.hasError()) {
row.setStyle("-fx-background-color: #ffcccc"); // red
tip.setText(rowItem.getErrorDescription());
row.setTooltip(tip);
} else {
row.setStyle("-fx-background-color: #ccffdd"); // green
row.setTooltip(null);
}
} else {
row.setStyle("");
row.setTooltip(null);
}
setText(item);
}
}
});
Edit #3:
Many thanks to kleopatra and James_D I now have a solution. Overriding isItemChanged() in the row factory has solved my issue.
The place to install conditional row styling is a custom TableRow - nowhere else. As always, contained nodes - like tableCells here - must not interfere with their parent's state, never-ever!.
The base problem with such styling in a tableRow is that row.updateItem(...) is not called when we might expect it, in particular, not after an update of a property. There are two options to solve (apart from making sure that the table is notified at all on updates of properties not shown in columns by using an extractor as already suggested by James)
A quick option is to unconditionally force an update always, by overriding isItemChanged:
#Override
protected boolean isItemChanged(GCodeItem oldItem,
GCodeItem newItem) {
return true;
}
Another option is to update the styling in both updateItem(...) and updateIndex(...) (the latter is called always when anything chances in the data)
#Override
protected void updateIndex(int i) {
super.updateIndex(i);
doUpdateItem(getItem());
}
#Override
protected void updateItem(CustomItem item, boolean empty) {
super.updateItem(item, empty);
doUpdateItem(item);
}
protected void doUpdateItem(CustomItem item) {
// actually do the update and styling
}
Choosing between both depends on context and requirements. Have seen contexts where the one or other didn't work properly, without a clean indication when/why that happened (too lazy to really dig ;)
Aside - a couple of comments to the question which did improve considerably over time but still is not quite a [MCVE]:
the data item is both too complex (for basic styling, there's no need for several direct/indirect intertwined conditions) and not complete enough to really demonstrate the requirements (like update after editing the value that drives the error condition)
the data item exposes properties (good thing!) - so use those (vs. PropertyValueFactory, bad thing!)
with a writable property a custom edit commit handler is not needed
TableColumn is editable by default, making col.setEditable(true) a no-op. If only some columns should editable, the others must be set to false
The basic issue is that the table is not forcing updates on the table row when the relevant properties change. Using the "extractor" as you do with
private final ObservableList<GCodeItem> gcodeItems = FXCollections.observableArrayList(
item -> new Observable[]{item.validatedProperty(), item.errorDescriptionProperty()});
should work, but it seems the table does not force row updates when the underlying data list fires updated type changes. (I'd consider this a bug; it's possible the JavaFX team simply doesn't consider this a supported feature.)
One approach here is to have the TableRow register a listener with the current item's validationResponseProperty() (or any other desired property), and update the row when it changes. A little care is needed here, because the current item that the row displays can change (e.g. when scrolling or when the data in the list change), so you need to observe the itemProperty() and ensure the listener is registered with the property in the correct item. This looks like:
// Set row factory
tblGCode.setRowFactory(tbl -> new TableRow<GCodeItem>() {
private final Tooltip tip = new Tooltip();
private final ChangeListener<String> listener = (obs, oldValidationResponse, newValidationResponse) ->
updateStyleAndTooltip();
{
tip.setShowDelay(new Duration(250));
itemProperty().addListener((obs, oldItem, newItem) -> {
if (oldItem != null) {
oldItem.validationResponseProperty().removeListener(listener);
}
if (newItem != null) {
newItem.validationResponseProperty().addListener(listener);
}
updateStyleAndTooltip();
});
}
#Override
protected void updateItem(GCodeItem item, boolean empty) {
super.updateItem(item, empty);
updateStyleAndTooltip();
}
private void updateStyleAndTooltip() {
GCodeItem item = getItem();
if(item == null || isEmpty()) {
setStyle("");
setTooltip(null);
} else {
if(item.isValidated()) {
if(item.hasError()) {
setStyle("-fx-background-color: #ffcccc"); // red
tip.setText(item.getErrorDescription());
setTooltip(tip);
} else {
setStyle("-fx-background-color: #ccffdd"); // green
setTooltip(null);
}
} else {
setStyle("");
setTooltip(null);
}
}
}
});
Note now you no longer need the list created with the extractor:
private final ObservableList<GCodeItem> gcodeItems = FXCollections.observableArrayList();
and indeed this would work without the dependent properties being implemented as JavaFX (bound) properties (as long as they are kept consistent with the other data); though I still consider the version you currently have to be the better implementation.
BTW, as a brief aside, your style will work better if you use -fx-background instead of -fx-background-color. By default, the background color (-fx-background-color) of a row is set equal to -fx-background. However, the color of the text is made dependent on -fx-background: if -fx-background is light, then a dark text is used, and vice-versa. By default, selecting a row changes -fx-background, which results in a change in text color, so in your implementation you'll notice the text is hard to read in a selected (validated or error) row. In short, modifying -fx-background will play better with selection than modifying -fx-background-color.

JavaFX - using setRowFactory to highlight new rows

I am writing a JavaFX app where a series of messages appear in a TableView. When a new message appears, its row in the table should be highlighted, meaning its background color should be orange or something. Once the user clicks it, the background color should clear, acknowledging the message was read. Should be simple.
I've done enough research to realize that I need to use a rowFactory to set or clear a row's background. But I'm struggling with the mechanics of setRowFactory(). The documentation on Oracle is over my head, and every example I pull up online seems radically different than the last one.
Here's what I have:
public class Message {
private boolean readOnce;
private int date;
private String msg;
public Message(int date, String msg, String msg2){
this.readOnce = false;
this.date = date;
this.msg = msg;
}
public boolean isReadOnce() {
return readOnce;
}
public void setReadOnce(){
readOnce = true;
}
// ...and more standard getters & setters here...
}
The TableView is set up in the main controller:
#FXML TableView<Message> messageTable;
#FXML TableColumn<Message, Integer> Col1;
#FXML TableColumn<Message, String> Col2;
ObservableList<Message> tableItems;
// ...
// Setting up the Table:
PropertyValueFactory<Message, Integer> dateProperty = new PropertyValueFactory<Message, Integer>("date");
PropertyValueFactory<Message, String> msgProperty = new PropertyValueFactory<Message, String>("msg");
Col1.setCellValueFactory( dateProperty );
Col2.setCellValueFactory( msgProperty );
messageTable.setItems( tableItems );
// If we click an item in the table: messageTable.getSelectionModel().selectedItemProperty().addListener((obs, oldSelection, newSelection) -> {
if (newSelection != null) {
System.out.println("Troubleshoot: You clicked: "+newSelection.getMsg());
newSelection.setReadOnce(true);
}
});
And if I want to add a new message to the table, I just add it into the observable list:
public void addMsg(int num, String msg){
tableItems.add(new Message(num, msg));
}
So far, pretty easy. But I'm all thumbs when it comes to the rowFactory:
messageTable.setRowFactory(messageTable -> {
TableRow<Message> row = new TableRow<>();
ObjectProperty<Message> opMsg = row.itemProperty();
Message tmpMsg = opMsg.get();
if(!tmpMsg.isReadOnce()){
row.getStyleClass().add("highlight-message"); // defined in CSS
} else {
row.getStyleClass().add("clear-message"); // defined in CSS
}
return row;
});
To be very honest, I have no idea what I'm doing here. I understand that the rowFactory takes in the entire table and regenerates each row one-by-one. What I don't understand is how does the RowFactory code examine each Message in the table and how can I access them? Originally I thought these line might allow me to see the Message within the row:
TableRow<Message> row = new TableRow<>();
ObjectProperty<Message> opMsg = row.itemProperty();
Message tmpMsg = opMsg.get();
But when I debug the code, tmpMsg == NULL. So that's a big fat dead end.
Anyone see what I'm doing wrong? I've been researching this for about a week, getting absolutely no-where. Any help anyone can offer is wildly appreciated.
Many thanks,
-RAO
TableRows are created by TableView to fill it's viewport and contain TableCells. At the time they are created the item property still contains the default value null. You could register a listener to that property but usually I prefer overriding the updateItem method of a cell.
Also using PseudoClass is simpler than using style classes. New items can be assigned to a row; this could result in the same style class being added multiple times and even both style classes could be added to the same cell. PseudoClasses however can be switched on/of without the need to take care of removing other classes.
final PseudoClass highlightMessage = PseudoClass.getPseudoClass("highlight-message");
messageTable.setRowFactory(messageTable -> new TableRow<Message>() {
{
selectedProperty().addListener((o, oldVal, newVal) -> {
if (newVal) {
Message item = getItem();
if (item != null) {
item.setReadOnce();
pseudoClassStateChanged(highlightMessage, false);
}
}
});
}
#Override
protected void updateItem(Message item, boolean empty) {
super.updateItem(item, empty);
pseudoClassStateChanged(highlightMessage, item != null && !item.isReadOnce());
}
});
In a CSS stylesheet you could use rules like this:
.table-row-cell:filled {
/* style for non-highlighted rows */
}
.table-row-cell:filled:highlight-message {
/* style for highlighted rows */
}
Note that this does not allow you to programmatically alter the read state. It updates the state on selecting a cell. You could add a BooleanProperty to Message or use a ObservableSet to store the highlighted messages and update the state of cells from a listener if you need to programmatically update the readOnce property. In the latter case you do not need to store a readOnce property in the Message itself...

javafx CheckBoxTreeItem update parents programmatically

I have to retrieve some data from my database to dynamically create a TreeView and select some CheckBoxTreeItems from this TreeView. This TreeView represents permissions to a menu structure.
My doubt is when I create the TreeView and select specific items from the Tree according to the user's permissions programmatically, the parents items don't have any status change (selected or indeterminate). But when I select any item directly from the interface, the parents get updated.
For example, here I have my screen when I select the items programmatically:
You can see that I have two menu items selected, but the parents aren't.
On this image, I have selected the same menu items using the screen, and the parents were updated with indeterminate status or selected if I select all children inside the submenu.
I have gone through the documentation, google and here on Stack Overflow, but only found examples to update the children.
Is there a way to update the parents programmatically or to call the event executed from the screen when an item is selected?
EDIT:
All items from the Tree have the independent property set to false.
I came with a workaround for this problem.
I had to first create all the TreeView structure, and change the selected property after using this code snippet:
Platform.runLater(new Runnable() {
#Override
public void run() {
selectItems();
}
});
Here is the code to verify the TreeItems:
private void selectItems(){
TreeItem root = tree.getRoot();
if (root != null) {
selectChildren(root);
}
}
private void selectChildren(TreeItem<TesteVO> root){
for(TreeItem<TesteVO> child: root.getChildren()){
// HERE I CHECK IF THE USER HAS PERMISSION FOR THE MENU ITEM
// IF SO, I CHANGE THE SELECTED PROPERTY TO TRUE
if (child.getValue().id == 4) {
((CheckBoxTreeItem) child).setSelected(true);
}
// IF THERE ARE CHILD NODES, KEEP DIGGING RECURSIVELY
if(!child.getChildren().isEmpty()) {
selectChildren(child);
}
}
}
If there is a simpler way, please let me know!
This is not the case. Parent items do get automatically get set to the indeterminate state when you select a child item. I'm not sure if this is something that got corrected from the time that this question was posted, probably not.
My guess is that there's a programming bug in how the node was selected or how the TableView was constructed and initialized.
Here's some code that shows what I'm doing, and it works! In my case, I'm using a CheckBoxTreeItem<File> for the TreeItem.
How the treeview was created
treeView = new TreeView(root);
treeView.getSelectionModel().selectedItemProperty().addListener(new ChangeListener() {
#Override
public void changed(ObservableValue observableValue, Object o, Object t1) {
CheckBoxTreeItem<File> node = (CheckBoxTreeItem<File>)t1;
if (node.getValue() != currentFile) {
setFileDetail(node);
showChildren(node);
}
}
});
treeView.setCellFactory(new CallBackWrapper());
treeView.setShowRoot(false);
Below show the CallBackWrapper class.
private class CallBackWrapper implements Callback<TreeView<File>, TreeCell<File>> {
Callback<TreeView<File>, TreeCell<File>> theCallback;
private CallBackWrapper() {
theCallback = CheckBoxTreeCell.<File>forTreeView(getSelectedProperty, converter);
}
#Override
public TreeCell<File> call(TreeView<File> fileTreeView) {
return theCallback.call(fileTreeView);
}
final Callback<TreeItem<File>, ObservableValue<Boolean>> getSelectedProperty = (TreeItem<File> item) -> {
if (item instanceof CheckBoxTreeItem<?>) {
return ((CheckBoxTreeItem<?>) item).selectedProperty();
}
return null;
};
final StringConverter<TreeItem<File>> converter = new StringConverter<TreeItem<File>>() {
#Override
public String toString(TreeItem<File> object) {
File item = object.getValue();
return fileSystemView.getSystemDisplayName(item);
}
#Override
public TreeItem<File> fromString(String string) {
return new TreeItem<File>(new File(string));
}
};
}
And lastly here some code that the selection was made in:
boolean selectNode(CheckBoxTreeItem<File> parentNode, String name) {
Object[] children = parentNode.getChildren().toArray();
for (Object child : children) {
CheckBoxTreeItem<File> childItem = (CheckBoxTreeItem<File>) child;
if (name.equals(childItem.getValue().getName())) {
childItem.setSelected(true);
//treeView.getSelectionModel().select(child); <-- this does not work!
return true;
}
}
return false;
}

javafx have an eventfilter remove itself

A snippet of my code is as follows:
//button clicked method
#FXML
public void newHeatExchanger2ButtonClicked(ActionEvent event) throws Exception {
//new pane created
Pane pane = new Pane();
//method call everytime the button is clicked
create2DExchanger(pane);
}
//method declaration
private void create2DExchanger(Pane pane) {
EventHandler<MouseEvent> panePressed = (e -> {
if (e.getButton() == MouseButton.SECONDARY){
do stuff
}
if (e.getButton() == MouseButton.PRIMARY){
do stuff
}
});
EventHandler<MouseEvent> paneDragged = (e -> {
if (e.getButton() == MouseButton.PRIMARY){
do stuff
}
});
EventHandler<MouseEvent> paneReleased = (e -> {
if (e.getButton() == MouseButton.PRIMARY){
do stuff;
}
});
EventHandler<MouseEvent> paneMoved = (t -> {
do stuff;
});
EventHandler<MouseEvent> paneClicked = (t -> {
//I need this filter to remove itself right here
t.consume();
pane.removeEventFilter(MouseEvent.MOUSE_MOVED, paneMoved);
pane.addEventHandler(MouseEvent.MOUSE_PRESSED, panePressed);
pane.addEventHandler(MouseEvent.MOUSE_DRAGGED, paneDragged);
pane.addEventHandler(MouseEvent.MOUSE_RELEASED, paneReleased);
});
pane.removeEventHandler(MouseEvent.MOUSE_PRESSED, panePressed);
pane.removeEventHandler(MouseEvent.MOUSE_DRAGGED, paneDragged);
pane.removeEventHandler(MouseEvent.MOUSE_RELEASED, paneReleased);
pane.addEventFilter(MouseEvent.MOUSE_MOVED, paneMoved);
pane.addEventFilter(MouseEvent.MOUSE_PRESSED, paneClicked);
}
Initially I set the pane to have only the event filters of mouse_moved, and mouse_pressed. As soon as the mouse is clicked I need the mouse filter for mouse_pressed and mouse_moved to go away and add the eventHandlers as I do in the paneClicked filter llamda. I need the first set of events to be filters because there are children nodes I do not want to receive the event (i.e. an event filter on an arc that is a child of the pane). The second set need to be handlers because the arc event filter needs to consume the event before the pane eventHandlers receive it.
Convenience events like:
pane.setOnMousePressed()
can remove themselves by calling
pane.setOnMousePressed(null);
but I need this initial event filter to remove itself. I will need the functionality of an event removing itself later as well in the code, but if I try to add
pane.removeEventFilter(MouseEvent.MOUSE_PRESSED, paneClicked);
to
EventHandler<MouseEvent> paneClicked = (t -> {
//I need this filter to remove itself right here
t.consume();
pane.removeEventFilter(MouseEvent.MOUSE_MOVED, paneMoved);
pane.addEventHandler(MouseEvent.MOUSE_PRESSED, panePressed);
pane.addEventHandler(MouseEvent.MOUSE_DRAGGED, paneDragged);
pane.addEventHandler(MouseEvent.MOUSE_RELEASED, paneReleased);
});
It will not compile. I have been researching for a couple of days on how to get the functionality of an eventFilter or eventHandler to remove itself but I am coming up short. I have not found anything online or on stackexchange in my Google searches either. I would really appreciate being able to figure this thing out. Thanks.
I believe the problem stems from the fact that you try to access paneClicked before it was fully declared.
You can overcome this using an anonymous class with the this keyword:
EventHandler<MouseEvent> paneClicked = new EventHandler<MouseEvent>() {
#Override
public void handle(MouseEvent event) {
event.consume();
pane.removeEventFilter(MouseEvent.MOUSE_PRESSED, this);
pane.removeEventFilter(MouseEvent.MOUSE_MOVED, paneMoved);
pane.addEventHandler(MouseEvent.MOUSE_PRESSED, panePressed);
pane.addEventHandler(MouseEvent.MOUSE_DRAGGED, paneDragged);
pane.addEventHandler(MouseEvent.MOUSE_RELEASED, paneReleased);
}
};
Or by referencing a fully qualified static function:
public class ContainingClass {
...
private static EventHandler<MouseEvent> paneClicked = (t -> {
t.consume();
pane.removeEventFilter(
MouseEvent.MOUSE_PRESSED, ContainingClass.paneClicked
);
});
}
See also:
Why do lambdas in Java 8 disallow forward reference to member variables where anonymous classes don't?
Java8 Lambdas vs Anonymous classes

Resources