From 260f1baaab10ab9b1db67ab587bc36adcb34494e Mon Sep 17 00:00:00 2001 From: Eduardo Pedroni Date: Tue, 8 Apr 2014 20:04:12 +0100 Subject: GUIParameters all refactored and commented. --- .../settings/parameters/GUIBooleanParameter.java | 106 +++++----- .../settings/parameters/GUIDoubleParameter.java | 168 +++++++-------- .../settings/parameters/GUIIntegerParameter.java | 167 +++++++-------- src/jcgp/gui/settings/parameters/GUIParameter.java | 229 +++++++++++++++++---- 4 files changed, 401 insertions(+), 269 deletions(-) (limited to 'src/jcgp/gui/settings/parameters') diff --git a/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java b/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java index 4339562..bada5d4 100644 --- a/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java +++ b/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java @@ -3,83 +3,79 @@ package jcgp.gui.settings.parameters; import javafx.beans.value.ChangeListener; import javafx.beans.value.ObservableValue; import javafx.scene.control.CheckBox; +import javafx.scene.control.Control; import jcgp.backend.resources.parameters.BooleanParameter; import jcgp.backend.resources.parameters.ParameterStatus; +import jcgp.gui.GUI; import jcgp.gui.settings.SettingsPane; -public class GUIBooleanParameter extends GUIParameter { - - private boolean originalValue; +/** + * This extension of GUIParameter uses a CheckBox to display + * the value of a BooleanParameter. It cannot be constructed + * directly - instead, use GUIParameter.create(). + *

+ * See {@link GUIParameter} for more information. + * + * @author Eduardo Pedroni + */ +public class GUIBooleanParameter extends GUIParameter { + + private CheckBox checkBox; + /** + * This default-visibility constructor is intended for use + * by the factory method only. + * + */ GUIBooleanParameter(final BooleanParameter parameter, final SettingsPane sp) { - super(); - - this.parameter = parameter; - - originalValue = parameter.get(); - - valueControl = new CheckBox(parameter.getName()); - ((CheckBox) valueControl).setSelected(parameter.get()); - - valueControl.setDisable(parameter.isMonitor()); - - if (parameter.isMonitor()) { - makeLightBinding(); - } else { - ((CheckBox) valueControl).selectedProperty().addListener(new ChangeListener() { - @Override - public void changed( - ObservableValue observable, - Boolean oldValue, Boolean newValue) { - parameter.set(newValue); - setValidityStyle(); - sp.revalidateParameters(); - } - }); - } - - getChildren().add(valueControl); - } - - @Override - public void refreshValue() { - if (!((CheckBox) valueControl).selectedProperty().isBound()) { - ((CheckBox) valueControl).setSelected(((BooleanParameter) parameter).get()); - } + super(parameter, sp); } @Override - public boolean requiresReset() { - return (parameter.isCritical() && ((BooleanParameter) parameter).get() != originalValue) - || parameter.getStatus() == ParameterStatus.WARNING_RESET; + protected Control makeControl() { + checkBox = new CheckBox(); + checkBox.setSelected(parameter.get()); + + return checkBox; } @Override - public void applyValue() { - originalValue = ((BooleanParameter) parameter).get(); + protected void setControlListeners(final SettingsPane sp) { + /* pass the CheckBox value back to the parameter whenever it gets + * modified, provided the experiment isn't running */ + checkBox.selectedProperty().addListener(new ChangeListener() { + @Override + public void changed( + ObservableValue observable, + Boolean oldValue, Boolean newValue) { + if (!GUI.isWorking()) { + parameter.set(newValue); + sp.revalidateParameters(); + } + } + }); } - /** - * @param parameter - */ - private void setValidityStyle() { + @Override + protected void setValidityStyle() { + // update the Control's style and tooltip based on the status of the parameter if (parameter.getStatus() == ParameterStatus.INVALID) { - valueControl.setStyle(BASE_CHECKBOX_STYLE + INVALID_PARAMETER_STYLE); - valueControl.setTooltip(tooltip); + checkBox.setStyle(BASE_CHECKBOX_STYLE + INVALID_PARAMETER_STYLE); + checkBox.setTooltip(tooltip); tooltip.setText(parameter.getStatus().getDetails()); } else if (parameter.getStatus() == ParameterStatus.WARNING || parameter.getStatus() == ParameterStatus.WARNING_RESET) { - valueControl.setStyle(BASE_CHECKBOX_STYLE + WARNING_PARAMETER_STYLE); - valueControl.setTooltip(tooltip); + checkBox.setStyle(BASE_CHECKBOX_STYLE + WARNING_PARAMETER_STYLE); + checkBox.setTooltip(tooltip); tooltip.setText(parameter.getStatus().getDetails()); } else { - valueControl.setStyle(BASE_CHECKBOX_STYLE + VALID_PARAMETER_STYLE); - valueControl.setTooltip(null); + checkBox.setStyle(BASE_CHECKBOX_STYLE + VALID_PARAMETER_STYLE); + checkBox.setTooltip(null); } } @Override - public void validate() { - ((BooleanParameter) parameter).validate(((BooleanParameter) parameter).get()); - setValidityStyle(); + public void refreshValue() { + checkBox.setSelected(parameter.get()); } + } diff --git a/src/jcgp/gui/settings/parameters/GUIDoubleParameter.java b/src/jcgp/gui/settings/parameters/GUIDoubleParameter.java index 4a8e0e1..87e7b69 100644 --- a/src/jcgp/gui/settings/parameters/GUIDoubleParameter.java +++ b/src/jcgp/gui/settings/parameters/GUIDoubleParameter.java @@ -4,115 +4,105 @@ import javafx.beans.value.ChangeListener; import javafx.beans.value.ObservableValue; import javafx.event.EventHandler; import javafx.geometry.Pos; +import javafx.scene.control.Control; import javafx.scene.control.TextField; import javafx.scene.input.KeyEvent; -import javafx.scene.layout.Priority; -import javafx.scene.text.Text; -import jcgp.backend.resources.parameters.DoubleParameter; +import jcgp.backend.resources.parameters.Parameter; import jcgp.backend.resources.parameters.ParameterStatus; +import jcgp.gui.GUI; import jcgp.gui.settings.SettingsPane; -public class GUIDoubleParameter extends GUIParameter { +/** + * This extension of GUIParameter uses a TextField to display + * the value of a DoubleParameter. It cannot be constructed + * directly - instead, use GUIParameter.create(). + *

+ * See {@link GUIParameter} for more information. + * + * @author Eduardo Pedroni + */ +public class GUIDoubleParameter extends GUIParameter { + + private TextField textField; - private double originalValue; + /** + * This default-visibility constructor is intended for use + * by the factory method only. + * + */ + GUIDoubleParameter(Parameter parameter, SettingsPane sp) { + super(parameter, sp); + } - GUIDoubleParameter(final DoubleParameter parameter, final SettingsPane sp) { - super(); - - this.parameter = parameter; - - originalValue = parameter.get(); - - name = new Text(parameter.getName()); - valueControl = new TextField(String.valueOf(parameter.get())); - valueControl.setStyle(VALID_PARAMETER_STYLE); - - ((TextField) valueControl).setAlignment(Pos.CENTER_RIGHT); - - setHgrow(valueControl, Priority.ALWAYS); - setHgrow(name, Priority.ALWAYS); - - name.wrappingWidthProperty().bind(widthProperty().divide(2)); - - ((TextField) valueControl).setDisable(parameter.isMonitor()); + @Override + protected Control makeControl() { + textField = new TextField(String.valueOf(parameter.get())); + textField.setStyle(VALID_PARAMETER_STYLE); + textField.setAlignment(Pos.CENTER_RIGHT); - // bind if monitor, else set changelistener - if (parameter.isMonitor()) { - makeLightBinding(); - } else { - valueControl.addEventFilter(KeyEvent.KEY_TYPED, new EventHandler() { - @Override - public void handle( KeyEvent t ) { - char ch = t.getCharacter().toCharArray()[t.getCharacter().toCharArray().length - 1]; - if (!((ch >= '0' && ch <= '9') || (ch == '.' && !((TextField) valueControl).getText().contains(".")))) { - t.consume(); - } - } - }); - ((TextField) valueControl).textProperty().addListener(new ChangeListener() { - @Override - public void changed( - ObservableValue observable, - String oldValue, String newValue) { - if (!newValue.isEmpty()) { - parameter.set(Double.parseDouble(newValue)); - setValidityStyle(); - sp.revalidateParameters(); - } + return textField; + } + @Override + protected void setControlListeners(final SettingsPane sp) { + /* filter keypresses and ignore anything that is not a number + * and any decimal point beyond the first ones */ + textField.addEventFilter(KeyEvent.KEY_TYPED, new EventHandler() { + @Override + public void handle( KeyEvent t ) { + char ch = t.getCharacter().toCharArray()[t.getCharacter().toCharArray().length - 1]; + if (!((ch >= '0' && ch <= '9') || (ch == '.' && !textField.getText().contains(".")))) { + t.consume(); } - }); - valueControl.focusedProperty().addListener(new ChangeListener() { - @Override - public void changed( - ObservableValue observable, - Boolean oldValue, Boolean newValue) { - if (!newValue && ((TextField) valueControl).getText().isEmpty()) { - ((TextField) valueControl).setText(String.valueOf(parameter.get())); - } + } + }); + /* pass the TextField value back to the parameter whenever it gets + * modified, provided it is not empty and the experiment isn't running */ + textField.textProperty().addListener(new ChangeListener() { + @Override + public void changed( + ObservableValue observable, + String oldValue, String newValue) { + if (!newValue.isEmpty() && !GUI.isWorking()) { + parameter.set(Double.parseDouble(newValue)); + sp.revalidateParameters(); } - }); - } - - - getChildren().addAll(name, valueControl); - } - @Override - public void refreshValue() { - ((TextField) valueControl).setText(String.valueOf(((DoubleParameter) parameter).get())); - } - - @Override - public boolean requiresReset() { - return (parameter.isCritical() && ((DoubleParameter) parameter).get() != originalValue) - || parameter.getStatus() == ParameterStatus.WARNING_RESET; - } - - @Override - public void applyValue() { - originalValue = ((DoubleParameter) parameter).get(); + } + }); + /* if the TextField loses focus and is empty, set it to the current + * value of the parameter */ + textField.focusedProperty().addListener(new ChangeListener() { + @Override + public void changed( + ObservableValue observable, + Boolean oldValue, Boolean newValue) { + if (!newValue && textField.getText().isEmpty()) { + textField.setText(String.valueOf(parameter.get())); + } + } + }); } @Override - public void validate() { - ((DoubleParameter) parameter).validate(((DoubleParameter) parameter).get()); - setValidityStyle(); - } - - private void setValidityStyle() { + protected void setValidityStyle() { + // update the Control's style and tooltip based on the status of the parameter if (parameter.getStatus() == ParameterStatus.INVALID) { - valueControl.setStyle(BASE_TEXT_STYLE + INVALID_PARAMETER_STYLE); - valueControl.setTooltip(tooltip); + textField.setStyle(BASE_TEXT_STYLE + INVALID_PARAMETER_STYLE); + textField.setTooltip(tooltip); tooltip.setText(parameter.getStatus().getDetails()); } else if (parameter.getStatus() == ParameterStatus.WARNING || parameter.getStatus() == ParameterStatus.WARNING_RESET) { - valueControl.setStyle(BASE_TEXT_STYLE + WARNING_PARAMETER_STYLE); - valueControl.setTooltip(tooltip); + textField.setStyle(BASE_TEXT_STYLE + WARNING_PARAMETER_STYLE); + textField.setTooltip(tooltip); tooltip.setText(parameter.getStatus().getDetails()); } else { - valueControl.setStyle(BASE_TEXT_STYLE + VALID_PARAMETER_STYLE); - valueControl.setTooltip(null); + textField.setStyle(BASE_TEXT_STYLE + VALID_PARAMETER_STYLE); + textField.setTooltip(null); } } - + + @Override + public void refreshValue() { + textField.setText(String.valueOf((parameter).get())); + } } diff --git a/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java b/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java index 204e7a2..6927f26 100644 --- a/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java +++ b/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java @@ -4,115 +4,104 @@ import javafx.beans.value.ChangeListener; import javafx.beans.value.ObservableValue; import javafx.event.EventHandler; import javafx.geometry.Pos; +import javafx.scene.control.Control; import javafx.scene.control.TextField; import javafx.scene.input.KeyEvent; -import javafx.scene.layout.Priority; -import javafx.scene.text.Text; -import jcgp.backend.resources.parameters.IntegerParameter; +import jcgp.backend.resources.parameters.Parameter; import jcgp.backend.resources.parameters.ParameterStatus; +import jcgp.gui.GUI; import jcgp.gui.settings.SettingsPane; -public class GUIIntegerParameter extends GUIParameter { - - private int originalValue; +/** + * This extension of GUIParameter uses a TextField to display + * the value of a IntegerParameter. It cannot be constructed + * directly - instead, use GUIParameter.create(). + *

+ * See {@link GUIParameter} for more information. + * + * @author Eduardo Pedroni + */ +public class GUIIntegerParameter extends GUIParameter { - GUIIntegerParameter(final IntegerParameter parameter, final SettingsPane sp) { - super(); - - this.parameter = parameter; - - originalValue = parameter.get(); - - name = new Text(parameter.getName()); - valueControl = new TextField(String.valueOf(parameter.get())); - valueControl.setStyle(VALID_PARAMETER_STYLE); - - ((TextField) valueControl).setAlignment(Pos.CENTER_RIGHT); - - setHgrow(valueControl, Priority.ALWAYS); - setHgrow(name, Priority.ALWAYS); - - name.wrappingWidthProperty().bind(widthProperty().divide(2)); - - ((TextField) valueControl).setDisable(parameter.isMonitor()); - - // bind if monitor, else set listeners - if (parameter.isMonitor()) { - makeLightBinding(); - } else { - valueControl.addEventFilter(KeyEvent.KEY_TYPED, new EventHandler() { - @Override - public void handle( KeyEvent t ) { - char ch = t.getCharacter().toCharArray()[t.getCharacter().toCharArray().length - 1]; - if (!(ch >= '0' && ch <= '9')) { - t.consume(); - } - } - }); - ((TextField) valueControl).textProperty().addListener(new ChangeListener() { - @Override - public void changed( - ObservableValue observable, - String oldValue, String newValue) { - if (!newValue.isEmpty()) { - parameter.set(Integer.parseInt(newValue)); - setValidityStyle(); - sp.revalidateParameters(); - } - - } - }); - valueControl.focusedProperty().addListener(new ChangeListener() { - @Override - public void changed( - ObservableValue observable, - Boolean oldValue, Boolean newValue) { - if (!newValue && ((TextField) valueControl).getText().isEmpty()) { - ((TextField) valueControl).setText(String.valueOf(parameter.get())); - } - } - }); - } - - getChildren().addAll(name, valueControl); + private TextField textField; + + /** + * This default-visibility constructor is intended for use + * by the factory method only. + * + */ + GUIIntegerParameter(Parameter parameter, SettingsPane sp) { + super(parameter, sp); } @Override - public void refreshValue() { - ((TextField) valueControl).setText(String.valueOf(((IntegerParameter) parameter).get())); + protected Control makeControl() { + textField = new TextField(String.valueOf(parameter.get())); + textField.setStyle(VALID_PARAMETER_STYLE); + textField.setAlignment(Pos.CENTER_RIGHT); + + return textField; } @Override - public boolean requiresReset() { - // true if critical and the value has changed, or it requires a reset anyway - return (parameter.isCritical() && ((IntegerParameter) parameter).get() != originalValue) - || parameter.getStatus() == ParameterStatus.WARNING_RESET; + protected void setControlListeners(final SettingsPane settingsPane) { + /* filter keypresses and ignore anything that is not a number */ + textField.addEventFilter(KeyEvent.KEY_TYPED, new EventHandler() { + @Override + public void handle( KeyEvent t ) { + char ch = t.getCharacter().toCharArray()[t.getCharacter().toCharArray().length - 1]; + if (!(ch >= '0' && ch <= '9')) { + t.consume(); + } + } + }); + /* pass the TextField value back to the parameter whenever it gets + * modified, provided it is not empty and the experiment isn't running */ + textField.textProperty().addListener(new ChangeListener() { + @Override + public void changed( + ObservableValue observable, + String oldValue, String newValue) { + if (!newValue.isEmpty() && !GUI.isWorking()) { + parameter.set(Double.parseDouble(newValue)); + settingsPane.revalidateParameters(); + } + } + }); + /* if the TextField loses focus and is empty, set it to the current + * value of the parameter */ + textField.focusedProperty().addListener(new ChangeListener() { + @Override + public void changed( + ObservableValue observable, + Boolean oldValue, Boolean newValue) { + if (!newValue && textField.getText().isEmpty()) { + textField.setText(String.valueOf(parameter.get())); + } + } + }); } @Override - public void applyValue() { - originalValue = ((IntegerParameter) parameter).get(); - } - - @Override - public void validate() { - ((IntegerParameter) parameter).validate(((IntegerParameter) parameter).get()); - setValidityStyle(); - } - - private void setValidityStyle() { + protected void setValidityStyle() { + // update the Control's style and tooltip based on the status of the parameter if (parameter.getStatus() == ParameterStatus.INVALID) { - valueControl.setStyle(BASE_TEXT_STYLE + INVALID_PARAMETER_STYLE); - valueControl.setTooltip(tooltip); + textField.setStyle(BASE_TEXT_STYLE + INVALID_PARAMETER_STYLE); + textField.setTooltip(tooltip); tooltip.setText(parameter.getStatus().getDetails()); - } else if (parameter.getStatus() == ParameterStatus.WARNING || parameter.getStatus() == ParameterStatus.WARNING_RESET) { - valueControl.setStyle(BASE_TEXT_STYLE + WARNING_PARAMETER_STYLE); - valueControl.setTooltip(tooltip); + } else if (parameter.getStatus() == ParameterStatus.WARNING + || parameter.getStatus() == ParameterStatus.WARNING_RESET) { + textField.setStyle(BASE_TEXT_STYLE + WARNING_PARAMETER_STYLE); + textField.setTooltip(tooltip); tooltip.setText(parameter.getStatus().getDetails()); } else { - valueControl.setStyle(BASE_TEXT_STYLE + VALID_PARAMETER_STYLE); - valueControl.setTooltip(null); + textField.setStyle(BASE_TEXT_STYLE + VALID_PARAMETER_STYLE); + textField.setTooltip(null); } } + @Override + public void refreshValue() { + textField.setText(String.valueOf((parameter).get())); + } } diff --git a/src/jcgp/gui/settings/parameters/GUIParameter.java b/src/jcgp/gui/settings/parameters/GUIParameter.java index 6bfdf30..b7afb74 100644 --- a/src/jcgp/gui/settings/parameters/GUIParameter.java +++ b/src/jcgp/gui/settings/parameters/GUIParameter.java @@ -9,6 +9,7 @@ import javafx.geometry.Pos; import javafx.scene.control.Control; import javafx.scene.control.Tooltip; import javafx.scene.layout.HBox; +import javafx.scene.layout.Priority; import javafx.scene.text.Text; import jcgp.backend.resources.parameters.BooleanParameter; import jcgp.backend.resources.parameters.DoubleParameter; @@ -18,7 +19,25 @@ import jcgp.backend.resources.parameters.ParameterStatus; import jcgp.gui.GUI; import jcgp.gui.settings.SettingsPane; -public abstract class GUIParameter extends HBox { +/** + * + * This is the base class for all GUIParameters. Using the factory method GUIParameter.create() + * generates an appropriate instance of this class for the specified parameter. + *

+ * GUIParameter is an HBox containing a Text for the parameter name and a Control for interaction. + * It stores an instance of its associated Parameter object and also contains a Tooltip for + * displaying status information. + *

+ * Monitor parameters have their Control disabled so that no changed can be made via the GUI. + * Non-monitor parameters are updated automatically as well, but may be changed by the user + * if the program is not evolving. + *

+ * For more information on how parameters work in JCGP, see {@link Parameter}. + * + * @author Eduardo Pedroni + * @param the parameter data type + */ +public abstract class GUIParameter extends HBox { public static final String BASE_TEXT_STYLE = "-fx-border-color: #C9C9C9; -fx-border-radius: 2; -fx-padding: 0; "; public static final String BASE_CHECKBOX_STYLE = "-fx-padding: 0; "; @@ -26,66 +45,204 @@ public abstract class GUIParameter extends HBox { public static final String INVALID_PARAMETER_STYLE = "-fx-background-color: " + GUI.BAD_SELECTION_COLOUR; public static final String WARNING_PARAMETER_STYLE = "-fx-background-color: " + GUI.NEUTRAL_SELECTION_COLOUR; public static final String VALID_PARAMETER_STYLE = "-fx-background-color: " + GUI.NEUTRAL_COLOUR; - - protected Parameter parameter; - protected Text name; - protected Control valueControl; + + private Text name; + private Control valueControl; protected Tooltip tooltip; + protected Parameter parameter; + + /** This is the lock used to prevent more than one update task to be scheduled + * at the same time on the same GUIParameter. */ + private AtomicBoolean updateLock = new AtomicBoolean(false); - protected AtomicBoolean updateCheck = new AtomicBoolean(true); + /** + * This value is used to assert whether the control has changed values since + * the program last ran. Therefore, it is updated whenever a generation occurs + * or the experiment is reset. + */ + private T referenceValue; - protected GUIParameter() { + /** + * This protected constructor contains the common elements to all GUIParameters + * and should be invoked by any subclasses using super(). + * + * @param parameter a Parameter for which to generate a GUIParameter + * @param sp a reference to the SettingsPane + */ + protected GUIParameter(Parameter parameter, final SettingsPane sp) { + this.parameter = parameter; + this.referenceValue = parameter.get(); + setAlignment(Pos.CENTER_LEFT); setSpacing(5); + name = new Text(parameter.getName()); + // set text width to half of the total width of the GUIParameter + name.wrappingWidthProperty().bind(widthProperty().divide(2)); + // allow the text to grow to always fill half of the GUIParameter + + // the tooltip is the hover-over label containing status information, when appropriate tooltip = new Tooltip(); tooltip.setStyle("-fx-background-color: white; -fx-border-color: black; .page-corner {-fx-background-color: transparent;}"); tooltip.setSkin(null); + + + valueControl = makeControl(); + setHgrow(valueControl, Priority.ALWAYS); + + // if the parameter is a monitor, it should be permanently disabled + valueControl.setDisable(parameter.isMonitor()); + + // bind to parameter value property in a thread-safe way + makeThreadSafeBinding(); + + // if parameter is not a monitor, make sure the control is constrained appropriately + if (!parameter.isMonitor()) { + setControlListeners(sp); + } + + getChildren().addAll(name, valueControl); } - protected final void makeLightBinding() { + /** + * Factory method to create GUIParameters from Parameters. + * Use this to create an appropriate GUIParameter from any instance of Parameter, + * rather than manually downcasting the Parameter object every time. + * + * @param parameter a Parameter for which to generate a GUIParameter + * @param sp a reference to the SettingsPane + * @return an appropriate instance of GUIParameter + */ + public static GUIParameter create(Parameter parameter, SettingsPane sp) { + if (parameter instanceof IntegerParameter) { + return new GUIIntegerParameter((IntegerParameter) parameter, sp); + } else if (parameter instanceof DoubleParameter) { + return new GUIDoubleParameter((DoubleParameter) parameter, sp); + } else if (parameter instanceof BooleanParameter) { + return new GUIBooleanParameter((BooleanParameter) parameter, sp); + } else { + throw new ClassCastException("No GUIParameter subclass exists for argument of type " + parameter.getClass()); + } + } + + /** + * Parameters are intended to communicate information from the experiment + * to the GUI. Since the experiment runs on a separate threads and it is illegal + * to modify JavaFX objects from outside the JavaFX Application thread, this + * special ChangeListener updates the GUIParameter in a safe way. + *

+ * Note that this is applied to all parameters regardless of whether they are + * monitors or not; the only difference between monitor and non-monitor parameters + * is that monitor parameters cannot be modified from the GUI. + */ + private void makeThreadSafeBinding() { parameter.valueProperty().addListener(new ChangeListener() { @Override public void changed( ObservableValue observable, Object oldValue, Object newValue) { - if (updateCheck.getAndSet(false)) { - Platform.runLater(new Runnable() { - @Override - public void run() { - updateCheck.set(true); - refreshValue(); - } - }); + // only do this if the experiment is running + if (GUI.isWorking()) { + /* here's the catch - atomically get the lock state and set it to true + * the lock will only be false again when the runnable is finished executing, + * preventing multiple runnables to concurrently update the same GUIParameter + */ + if (!updateLock.getAndSet(true)) { + Platform.runLater(new Runnable() { + @Override + public void run() { + refreshValue(); + updateLock.set(false); + } + }); + } } } }); } - public abstract void refreshValue(); - - public abstract boolean requiresReset(); - - public abstract void applyValue(); - - public abstract void validate(); + /** + * @return true if the current value of the parameter does not prevent the + * experiment from running. + */ + public boolean isValid() { + return parameter.getStatus() != ParameterStatus.INVALID; + } - public static GUIParameter create(Parameter parameter, SettingsPane sp) { - if (parameter instanceof IntegerParameter) { - return new GUIIntegerParameter((IntegerParameter) parameter, sp); - } else if (parameter instanceof DoubleParameter) { - return new GUIDoubleParameter((DoubleParameter) parameter, sp); - } else if (parameter instanceof BooleanParameter) { - return new GUIBooleanParameter((BooleanParameter) parameter, sp); - } else { - throw new ClassCastException("No GUIParameter subclass exists for argument of type " + parameter.getClass()); - } + /** + * Force the parameter to validate its current value, and apply the associated + * style to the GUIParameter. + */ + public void validate() { + parameter.validate(parameter.get()); + refreshValue(); + setValidityStyle(); } - public boolean isValid() { - return parameter.getStatus() == ParameterStatus.VALID - || parameter.getStatus() == ParameterStatus.WARNING + /** + * Certain parameter changes might require the experiment to be reset, either + * because the parameter is critical or because its status requires a reset. + * + * @return true if an experiment reset is required due to this parameter changing. + */ + public boolean requiresReset() { + return (parameter.isCritical() && !parameter.get().equals(referenceValue)) || parameter.getStatus() == ParameterStatus.WARNING_RESET; } + + /** + * Set the current parameter value as the reference value of the GUIParameter. + * The new reference value will be used to determine the validity of the parameter, + * should its value change. + */ + public void applyValue() { + referenceValue = parameter.get(); + } + + /* + * The following prototypes are instance-dependent and are called from + * GUIParameter() as necessary. + */ + /** + * This method returns the Control object used to control the parameter. + *

+ * Implementations of GUIParameter must override this method and return + * a control appropriate to the type of parameter. This will typically be + * done by referencing the protected field GUIParameter.parameter. + * + * @return the Control object to be added to the GUIParameter. + */ + protected abstract Control makeControl(); + + /** + * Adds the necessary handlers to the Control object in order to modify + * the underlying parameter. This will typically consist of filtering key + * presses to ensure no invalid characters are inserted, applying the new + * value to the underlying parameter and revalidating the parameters to + * reflect the changes made. + * + * @param settingsPane the parent Pane on which revalidateParameters() should + * be called. + */ + protected abstract void setControlListeners(SettingsPane settingsPane); + + /** + * This method is called to style the GUIParameter according to the status of + * the parameter, which can be obtained with parameter.getStatus(). While the + * subclass is free to style itself in any way, the CSS strings defined here + * (INVALID_PARAMETER_STYLE, WARNING_PARAMETER_STYLE, VALID_PARAMETER_STYLE) + * provide a way to keep the GUI consistent. + * + * TODO update this if the strings are externalised + * + * @see ParameterStatus + */ + protected abstract void setValidityStyle(); + + /** + * Update the control so it shows the correct value of the parameter. This method + * is used exclusively by the thread-safe binding created if the module is a monitor. + */ + protected abstract void refreshValue(); } -- cgit v1.2.3