Added existing source code

29 files changed, 3605 insertions, 0 deletions

diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..ec6d463
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="jcgp/src"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ae3c172
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/.project b/.project
new file mode 100644
index 0000000..58079f1
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>JCGP-GUI</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/jcgp b/jcgp
-Subproject 7c4eea4912bd4b5d8d42eb5209ee0b04e591c7c
+Subproject ff5248437491f1829c0168b271e85cb35851657
diff --git a/src/jcgp/gui/GUI.java b/src/jcgp/gui/GUI.java
new file mode 100644
index 0000000..79678bc
--- /dev/null
+++ b/src/jcgp/gui/GUI.java
@@ -0,0 +1,477 @@
+package jcgp.gui;
+
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.concurrent.Service;
+import javafx.concurrent.Task;
+import javafx.event.EventHandler;
+import javafx.scene.Scene;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.Pane;
+import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+import jcgp.JCGP;
+import jcgp.backend.modules.problem.TestCaseProblem.TestCase;
+import jcgp.backend.resources.Resources;
+import jcgp.gui.console.ConsolePane;
+import jcgp.gui.dragresize.HorizontalDragResize;
+import jcgp.gui.dragresize.VerticalDragResize;
+import jcgp.gui.population.FunctionSelector;
+import jcgp.gui.population.GUINode;
+import jcgp.gui.population.PopulationPane;
+import jcgp.gui.settings.SettingsPane;
+
+/**
+ * Main class for the graphical user interface (GUI).
+ * <br><br>
+ * This class declares the main method used when running the GUI.
+ * In addition, all main GUI panes are declared and instantiated here.
+ * <br><br>
+ * The user interface is divided into 3 main components: the node grid
+ * ({@link PopulationPane}), the control pane ({@link SettingsPane}) and
+ * the console ({@link ConsolePane}). Click on any of the links in
+ * brackets to see more information about each interface component.
+ * <br><br>
+ * This class also contains the instance of JCGP responsible for
+ * running the experiments in GUI mode. JCGP's execution must be delegated
+ * to a separate thread so that the GUI remains unblocked. This is done using
+ * a JavaFX {@code Service} which calls {@code nextGeneration()} in a loop
+ * until it is interrupted by the main JavaFX thread.
+ * <br>
+ * This service also handles flushing the console in a thread safe way. This
+ * is done by synchronising the {@code nextGeneration()} and {@code flush()}
+ * method calls on a lock object.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public class GUI extends Application {
+    
+	/*
+	 * Actual GUI elements
+	 */
+	private Stage stage;
+	private PopulationPane populationPane;
+	private ConsolePane console;
+	private SettingsPane settingsPane;
+	private final FunctionSelector functionSelector;
+	
+	/*
+	 * Flow control objects
+	 */
+	private boolean running = false;
+	private final Object printLock = new Object();
+	private Service<Void> jcgpService;
+	private Runnable consoleFlush;
+	
+	/*
+	 * The experiment itself
+	 */
+	private final JCGP jcgp;
+	
+	public static Resources resources;
+	
+	
+	/**
+	 * Start JCGP with the user interface.
+	 * 
+	 * @param args no arguments are used.
+	 */
+	public static void main(String[] args) {
+		// not much to do, simply launch the JavaFX application
+		launch();
+	}
+	
+	/**
+	 * Makes a new instance of GUI. This initialises the JCGP experiment and 
+	 * instantiates the function selector. It also creates the console flush task
+	 * and the service responsible for running the JCGP experiment.
+	 */
+	public GUI() {
+		jcgp = new JCGP();
+		resources = jcgp.getResources();
+		functionSelector = new FunctionSelector(jcgp.getResources().getFunctionSet());
+		
+		/*
+		 * This task flushes the console in a thread-safe way.
+		 * The problem is that this task is executed using Platform.runLater()
+		 * to ensure that the flush itself happens on the JavaFX thread. However,
+		 * runLater() is not guaranteed to run anytime soon. If the time taken for
+		 * jcgp to perform a single generation is shorter than the time taken for
+		 * this task to be executed by the platform, consoleFlush tasks will be 
+		 * scheduled faster than they can be executed and the console will eventually 
+		 * freeze. 
+		 * 
+		 * This is addressed by synchronizing the flushes with each nextGeneration() call.
+		 */
+		consoleFlush = new Runnable() {
+			@Override
+			public void run() {
+				/* 
+				 * Try to acquire printlock - wait here until jcgpService relinquishes it
+				 * by calling wait(). This means that it is finished with the current generation
+				 * and will wait for the console to be flushed to move on.
+				 * It might be the case that the service has already released the lock by waiting
+				 * on it; it makes no difference. In that case this will acquire the lock
+				 * immediately and proceed to flush the console.
+				 */
+				synchronized(printLock) {
+					/*
+					 * The lock is acquired, at this point we are certain that jcgpService
+					 * cannot execute; it is currently waiting to be notified about the lock.
+					 * No additional consoleFlush tasks can be scheduled with runLater() because
+					 * the service is waiting. We can now take our time to flush the console.
+					 */
+					console.flush();
+					/*
+					 * Once the console finishes flushing, we notify jcgpService to perform the
+					 * next generation.
+					 */
+					printLock.notifyAll();
+				}
+			}
+		};
+		
+		/* 
+		 * This service runs on a separate thread and performs
+		 * the experiment, including console prints, in a thread-safe
+		 * way. It is synchronized with consoleFlush.
+		 */
+		jcgpService = new Service<Void> () {
+			@Override
+			protected Task<Void> createTask() {
+				Task<Void> t = new Task<Void>() {
+					@Override
+					protected Void call() throws Exception {
+						/*
+						 * Only execute if the experiment isn't finished
+						 * and the service hasn't been cancelled.
+						 */
+						while (!isCancelled() && !jcgp.isFinished()) {
+							/*
+							 * Attempt to acquire the printlock.
+							 * Successfully doing so means no printing
+							 * is currently taking place and we are free
+							 * to schedule a print task.
+							 * This lock acquisition should never block. It should
+							 * not be possible to execute this statement without
+							 * having been notified by consoleFlush.
+							 */
+							synchronized (printLock) {
+								/*
+								 * Lock has been acquired, schedule a print
+								 * task ahead of time. The actual print messages
+								 * haven't been send to the console yet, that happens
+								 * during nextGeneration(), but since we have the lock
+								 * consoleFlush() will sit and wait for us to release it
+								 * whenever we are finished queueing prints.
+								 */
+								Platform.runLater(consoleFlush);
+								/*
+								 * Perform the actual generation. Here zero or more
+								 * strings might be sent to the console buffer.
+								 */
+								jcgp.nextGeneration();
+								/*
+								 * The generation is complete, relinquish the lock.
+								 * By this point chances are the platform is already trying
+								 * to execute the consoleFlush task that we scheduled. If it
+								 * hasn't already started though, it doesn't matter; we will
+								 * wait for a notification on the lock, which will only come
+								 * when printing is complete.
+								 */
+								printLock.wait();
+								/*
+								 * We have been notified. This means all buffered messages have
+								 * been successfully flushed to the actual console control and
+								 * we are now ready to perform another generation (or break out
+								 * of the loop if the loop conditions are no longer met).
+								 */
+							}
+							/*
+							 * We no longer own the lock, but neither does consoleFlush. 
+							 * The synchrony cycle has returned to its initial state, and we
+							 * are free to acquire the lock again.
+							 */
+						}
+						/*
+						 * Something happened to break the while loop -
+						 * either the experiment finished or the user pressed
+						 * pause.
+						 */
+						if (jcgp.isFinished()) {
+							// the experiment has finished, switch to pause mode
+							Platform.runLater(new Runnable() {
+								@Override
+								public void run() {
+									runningMode(false);
+								}
+							});
+						}
+						return null;
+					}
+				};
+				return t;
+			}
+		};
+	}
+	
+	@Override
+	public void start(Stage primaryStage) throws Exception {
+		/*
+		 * This method gets called when the application launches. Once it
+		 * returns, the application falls into the main loop which handles 
+		 * events, so all elements must be constructed here.
+		 */
+		
+		// make the console and set it so it is used for JCGP prints
+		console = new ConsolePane();
+		jcgp.setConsole(console);
+		
+		// store reference to the stage
+		stage = primaryStage;
+
+		/*
+		 * The experiment layer contains all of the experiment-related panes. 
+		 * The only element that sits higher than this is the function selector.
+		 */
+		BorderPane experimentLayer = new BorderPane();
+		/*
+		 * The left frame encapsulates the population pane and the console.
+		 * It goes into the center position of the experiment layer, next to the settings pane.
+		 */
+		BorderPane leftFrame = new BorderPane();
+		
+		/*
+		 * The population pane is a TabPane containing a tab for each chromosome. 
+		 */
+		populationPane = new PopulationPane(this);
+		
+		/*
+		 * The settings pane is a big class containing the entire control pane
+		 */
+		settingsPane = new SettingsPane(this);
+		
+		// make control pane and console resizable
+		HorizontalDragResize.makeDragResizable(settingsPane);
+		VerticalDragResize.makeDragResizable(console);
+		// prevent resizables from growing larger than the experiment layer
+		settingsPane.maxWidthProperty().bind(experimentLayer.widthProperty());
+		console.maxHeightProperty().bind(experimentLayer.heightProperty());
+
+		// put console and population pane in the main frame
+		leftFrame.setCenter(populationPane);
+		leftFrame.setBottom(console);
+		
+		// set the main frame and the control pane in the experiment layer
+		experimentLayer.setCenter(leftFrame);
+		experimentLayer.setRight(settingsPane);
+		
+		/*
+		 * Now we deal with the stage.
+		 */
+		primaryStage.setTitle("JCGP");
+		
+		// this pane holds the entire scene, that is its sole job.
+		Pane sceneParent = new Pane();
+		// the experiment layer should fill the entire scene parent
+		experimentLayer.prefHeightProperty().bind(sceneParent.heightProperty());
+		experimentLayer.prefWidthProperty().bind(sceneParent.widthProperty());
+		// the function selector goes over the experiment layer so it doesn't get covered by other panes
+		sceneParent.getChildren().addAll(experimentLayer, functionSelector);
+		
+		// set the scene, minimum sizes, show
+		primaryStage.setScene(new Scene(sceneParent));
+		primaryStage.setMinWidth(800);
+		primaryStage.setMinHeight(600);
+		primaryStage.show();
+		
+		// when the main stage closes, close the test case table as well
+		primaryStage.setOnCloseRequest(new EventHandler<WindowEvent>() {
+			@Override
+			public void handle(WindowEvent event) {
+				if (settingsPane.getTestCaseTable() != null) {
+					settingsPane.getTestCaseTable().close();
+				}
+			}
+		});
+	}
+
+	/**
+	 * Run/pause method.
+	 * Run the experiment if it is paused, or pause it if it is running.
+	 * <br>
+	 * This method is the callback used by the run/pause button. It
+	 * controls the jcgp service.
+	 */
+	public void runPause() {
+		// do nothing if experiment is finished or parameters aren't valid
+		if (!jcgp.isFinished() && settingsPane.areParametersValid()) {
+			if (!running) {
+				runningMode(true);
+				jcgpService.restart();
+			} else {
+				jcgpService.cancel();
+				runningMode(false);
+			}
+		}
+	}
+	
+	/**
+	 * Perform a single generation using {@code nextGeneration()}. 
+	 * <br>
+	 * On top of that, this method performs all of the housekeeping 
+	 * that is normally done before and after running, such as 
+	 * refreshing the chromosome panes.
+	 */
+	public void step() {
+		// do nothing if experiment is finished, running or parameters aren't valid
+		if (!running && !jcgp.isFinished() && settingsPane.areParametersValid()) {
+			if (settingsPane.isResetRequired()) {
+				reset();
+			}
+			jcgp.nextGeneration();
+			console.flush();
+			
+			populationPane.updateGenes();
+			settingsPane.revalidateParameters();
+			settingsPane.updateControls(false, jcgp.isFinished());
+		}
+	}
+	
+	/**
+	 * Reset button callback. If the parameters are valid, 
+	 * this resets the entire experiment by calling {@code reset()}
+	 * on jcgp.
+	 */
+	public void reset() {
+		if (!running && settingsPane.areParametersValid()) {
+			setEvaluating(false);
+			jcgp.reset();
+			settingsPane.applyParameters();
+			reDraw();
+		}
+	}
+	
+	/**
+	 * Does a complete GUI refresh. 
+	 * This is potentially lengthy, so use with care.
+	 */
+	public void reDraw() {
+		populationPane.remakeTabs();
+		settingsPane.revalidateParameters();
+		settingsPane.updateControls(false, jcgp.isFinished());
+		console.flush();
+	}
+	
+	/**
+	 * Toggles the entire GUI between run and pause
+	 * mode. 
+	 * <br><br>
+	 * A lot of the GUI must be enabled or disabled
+	 * depending on what the experiment is doing. This
+	 * method provides a one-line way to make
+	 * all required adjustments.
+	 * 
+	 * @param value true if experiment is running, false otherwise.
+	 */
+	private void runningMode(boolean value) {		
+		if (value) {
+			if (settingsPane.isResetRequired()) {
+				reset();
+			}
+		} else {
+			populationPane.updateGenes();
+			settingsPane.revalidateParameters();
+		}
+		populationPane.setDisable(value);
+		settingsPane.updateControls(value, jcgp.isFinished());
+		
+		running = value;
+	}
+	
+	/**
+	 * Refresh the function selector, used when functions are enabled or disabled.
+	 */
+	public void updateFunctionSelector() {
+		functionSelector.remakeFunctions(jcgp.getResources().getFunctionSet());
+	}
+	
+	/**
+	 * @return true if jcgp is evolving.
+	 */
+	public boolean isWorking() {
+		return running;
+	}
+
+	/**
+	 * Relocate the function selector to the right position
+	 * relative to the specified node and set it visible.
+	 * 
+	 * @param event the mouse event containing cursor coordinates.
+	 * @param node the node whose function should be changed.
+	 */
+	public void bringFunctionSelector(MouseEvent event, GUINode node) {
+		functionSelector.relocateAndShow(event, node);
+	}
+
+	/**
+	 * @return a reference to the {@code JCGP} experiment.
+	 */
+	public JCGP getExperiment() {
+		return jcgp;
+	}
+	
+	/**
+	 * Starts the evaluation process with the given test case.
+	 * It does so by calling {@code evaluateTestCase()} on
+	 * the population pane.
+	 * 
+	 * @param testCase the test case to evaluate.
+	 */
+	public void evaluateTestCase(TestCase<Object> testCase) {
+		populationPane.evaluateTestCase(testCase);
+	}
+
+	/**
+	 * Hide all evaluated values. This should be called when
+	 * evaluations are no longer being performed.
+	 */
+	public void hideGeneValues() {
+		populationPane.hideValues();
+	}
+
+	/**
+	 * Set the system into evaluation mode. 
+	 * When in evaluation mode, the population pane
+	 * refreshes the node values whenever connection
+	 * changes happen.
+	 * 
+	 * @param value true if evaluations are happening, false otherwise.
+	 */
+	public void setEvaluating(boolean value) {
+		populationPane.setEvaluating(value);
+	}
+
+	/**
+	 * @return a reference to the GUI stage.
+	 */
+	public Stage getStage() {
+		return stage;
+	}
+	
+	/**
+	 * Writes all buffered content out to the GUI console.
+	 */
+	public void flushConsole() {
+		console.flush();
+	}
+
+	/**
+	 * @return the index of the chromosome currently being looked at.
+	 */
+	public int getChromosomeIndex() {
+		return populationPane.getSelectionModel().getSelectedIndex();
+	}
+}
diff --git a/src/jcgp/gui/console/ConsolePane.java b/src/jcgp/gui/console/ConsolePane.java
new file mode 100644
index 0000000..de193a5
--- /dev/null
+++ b/src/jcgp/gui/console/ConsolePane.java
@@ -0,0 +1,122 @@
+package jcgp.gui.console;
+
+import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventDispatcher;
+import javafx.event.EventHandler;
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.SeparatorMenuItem;
+import javafx.scene.control.TextArea;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.AnchorPane;
+import jcgp.backend.resources.Console;
+import jcgp.gui.constants.Constants;
+
+/**
+ * Console pane used by the GUI to display CGP output messages.
+ * This class realises {@code Console}. It consists of a JavaFX
+ * {@code TextArea} and a {@code StringBuffer}. The buffer is filled
+ * as print messages are queued. Calling {@code flush()} writes the
+ * contents of the buffer to the {@code TextArea} and empties the buffer.
+ * 
+ * @see Console
+ * @author Eduardo Pedroni
+ *
+ */
+public class ConsolePane extends AnchorPane implements Console {
+	
+	private TextArea textArea = new TextArea("Welcome to JCGP!\n");
+	private StringBuffer printBuffer = new StringBuffer();
+		
+	/**
+	 * Creates a new instance of this class.
+	 */
+	public ConsolePane() {
+		super();
+		textArea.setEditable(false);
+		/*
+		 * This nasty hack is needed because the default TextArea ContextMenu is not
+		 * in the public API, making it impossible to override it with a custom one.
+		 * This has not been fixed as of 8/4/2014.
+		 * 
+		 * The following code modifies the EventDispatcher to consume the right mouse
+		 * button click, preventing the default menu from appearing. It propagates the mouse
+		 * click further so other elements will respond appropriately.
+		 * 
+		 * TODO this should be refactored once the API is updated.
+		 */
+		final EventDispatcher initial = textArea.getEventDispatcher();
+		textArea.setEventDispatcher(new EventDispatcher() {
+			@Override
+			public Event dispatchEvent(Event event, EventDispatchChain tail) {
+				if (event instanceof MouseEvent) {
+					MouseEvent mouseEvent = (MouseEvent)event;
+					if (mouseEvent.getButton() == MouseButton.SECONDARY || 
+							(mouseEvent.getButton() == MouseButton.PRIMARY && mouseEvent.isControlDown())) {
+						event.consume();
+					}
+				}
+				return initial.dispatchEvent(event, tail);
+			}
+		});
+		
+		// make the new context menu including the clear option		
+		MenuItem copySelected = new MenuItem("Copy");
+		copySelected.setOnAction(new EventHandler<ActionEvent>() {	
+			@Override
+			public void handle(ActionEvent event) {
+				textArea.copy();
+			}
+		});
+		MenuItem selectAll = new MenuItem("Select all");
+		selectAll.setOnAction(new EventHandler<ActionEvent>() {	
+			@Override
+			public void handle(ActionEvent event) {
+				textArea.selectAll();
+			}
+		});
+		MenuItem clearConsole = new MenuItem("Clear");
+		clearConsole.setOnAction(new EventHandler<ActionEvent>() {	
+			@Override
+			public void handle(ActionEvent event) {
+				textArea.setText("");
+			}
+		});
+				
+		textArea.setContextMenu(new ContextMenu(copySelected,
+												selectAll, 
+												new SeparatorMenuItem(),
+												clearConsole));
+		
+		// anchor the text area so it resizes automatically
+		AnchorPane.setTopAnchor(textArea, Constants.RESIZE_MARGIN);
+		AnchorPane.setBottomAnchor(textArea, 0.0);
+		AnchorPane.setRightAnchor(textArea, 0.0);
+		AnchorPane.setLeftAnchor(textArea, 0.0);
+		
+		setMinHeight(Constants.CONSOLE_MIN_HEIGHT);
+		setPrefHeight(Constants.CONSOLE_MIN_HEIGHT);
+		
+		getChildren().add(textArea);
+	}
+
+	@Override
+	public void println(String s) {
+		printBuffer.append(s + "\n");
+	}
+
+	@Override
+	public void print(String s) {
+		printBuffer.append(s);
+	}
+
+	@Override
+	public void flush() {
+		textArea.appendText(printBuffer.toString());
+		printBuffer = new StringBuffer();
+	}
+	
+}
diff --git a/src/jcgp/gui/constants/Constants.java b/src/jcgp/gui/constants/Constants.java
new file mode 100644
index 0000000..509d982
--- /dev/null
+++ b/src/jcgp/gui/constants/Constants.java
@@ -0,0 +1,170 @@
+package jcgp.gui.constants;
+
+import javafx.scene.paint.Paint;
+
+/**
+ * Holds the constants used in the GUI.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public final class Constants {
+
+	/**
+	 * Private constructor to prevent instantiation.
+	 */
+	private Constants(){}
+	
+	/*---------------------------------------------------------------------------------------------------
+	 * Colour Strings 
+	 *-------------------------------------------------------------------------------------------------*/
+	/**
+	 * A {@code String} containing the colour used for representing neutrality.
+	 */
+	public static final String NEUTRAL_COLOUR = "#FFFFFF";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for representing a hard highlight.
+	 * A "hard" select, for instance, happens when an output path is locked on the chromosome pane.
+	 */
+	public static final String HARD_HIGHLIGHT_COLOUR = "#5496FF";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for a medium highlight.
+	 * One example of such a selection is the colour applied to a node when it is hovered over.
+	 */
+	public static final String MEDIUM_HIGHLIGHT_COLOUR = "#75BAFF";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for a soft highlight.
+	 * When hovering over a node, its connections are soft-selected.
+	 */
+	public static final String SOFT_HIGHLIGHT_COLOUR = "#C7DFFF";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for representing a good selection.
+	 * Ideally a shade of green, used for instance when a manual connection is valid.
+	 */
+	public static final String GOOD_SELECTION_COLOUR = "#38C25B";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for representing a neutral selection.
+	 * Ideally a shade of yellow, used for instance when a manual connection is already the current connection.
+	 */
+	public static final String NEUTRAL_SELECTION_COLOUR = "#FFEF73";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for representing a bad selection.
+	 * Ideally a shade of red, use for instance when a manual connection is not valid.
+	 */
+	public static final String BAD_SELECTION_COLOUR = "#FF5C5C";
+	/**
+	 * A {@code String} containing the hexadecimal colour used for the gene sockets.
+	 */
+	public static final String SOCKET_COLOUR = "#FFFFFF";
+	
+	/*---------------------------------------------------------------------------------------------------
+	 * Colour Paints 
+	 *-------------------------------------------------------------------------------------------------*/
+	/**
+	 * A {@code Paint} containing the colour used for representing neutrality.
+	 */
+	public static final Paint NEUTRAL_PAINT = Paint.valueOf(NEUTRAL_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for representing a hard highlight.
+	 * A "hard" select, for instance, happens when an output path is locked on the chromosome pane.
+	 */
+	public static final Paint HARD_HIGHLIGHT_PAINT = Paint.valueOf(HARD_HIGHLIGHT_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for a medium highlight.
+	 * One example of such a selection is the colour applied to a node when it is hovered over.
+	 */
+	public static final Paint MEDIUM_HIGHLIGHT_PAINT = Paint.valueOf(MEDIUM_HIGHLIGHT_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for a soft highlight.
+	 * When hovering over a node, its connections are soft-selected.
+	 */
+	public static final Paint SOFT_HIGHLIGHT_PAINT = Paint.valueOf(SOFT_HIGHLIGHT_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for representing a good selection.
+	 * Ideally a shade of green, used for instance when a manual connection is valid.
+	 */
+	public static final Paint GOOD_SELECTION_PAINT = Paint.valueOf(GOOD_SELECTION_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for representing a neutral selection.
+	 * Ideally a shade of yellow, used for instance when a manual connection is already the current connection.
+	 */
+	public static final Paint NEUTRAL_SELECTION_PAINT = Paint.valueOf(NEUTRAL_SELECTION_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for representing a bad selection.
+	 * Ideally a shade of red, use for instance when a manual connection is not valid.
+	 */
+	public static final Paint BAD_SELECTION_PAINT = Paint.valueOf(BAD_SELECTION_COLOUR);
+	/**
+	 * A {@code Paint} containing the colour used for the gene sockets.
+	 */
+	public static final Paint SOCKET_PAINT = Paint.valueOf(SOCKET_COLOUR);
+	
+	/*---------------------------------------------------------------------------------------------------
+	 * Sizes and distances 
+	 *-------------------------------------------------------------------------------------------------*/
+	/**
+	 * The width or height of the area that can be clicked on
+	 * to drag-resize a pane.
+	 */
+    public static final double RESIZE_MARGIN = 5.0;
+    /**
+	 * The minimum width of the settings pane, to prevent it
+	 * from being resized beyond visibility.
+	 */
+    public static final double SETTINGS_MIN_WIDTH = 200;
+    /**
+	 * The minimum width of the console pane, to prevent it
+	 * from being resized beyond visibility.
+	 */
+    public static final double CONSOLE_MIN_HEIGHT = 100;
+    /**
+     * Radius used for the representation of nodes in the grid.
+     */
+    public static final double NODE_RADIUS = 35;
+	/**
+	 * Spacing between each node.
+	 */
+	public static final double SPACING = 15;
+	/**
+	 * The margin between the genes and the edge of the chromosome pane.
+	 */
+	public static final double CHROMOSOME_PANE_MARGIN = 10;
+	/**
+	 * The angle across which the node's sockets are evenly distributed.
+	 */
+	public static final double THETA = Math.PI / 1.4;
+	/**
+	 * The radius of the connection sockets, calculated as a function of NODE_RADIUS.
+	 */
+	public static final double SOCKET_RADIUS = Math.sqrt(NODE_RADIUS) / 1.8;
+	/**
+	 * Size of the text in each node.
+	 */
+	public static final double NODE_TEXT = NODE_RADIUS / 2.5;
+	
+	/*---------------------------------------------------------------------------------------------------
+	 * CSS Styles
+	 * TODO extract to stylesheet?
+	 *-------------------------------------------------------------------------------------------------*/
+	/**
+	 * The basic style of text boxes used in parameters.
+	 */
+	public static final String BASE_TEXT_STYLE = "-fx-border-color: #C9C9C9; -fx-border-radius: 2; -fx-padding: 0; ";
+	/**
+	 * The basic style of check boxes used in parameters.
+	 */
+	public static final String BASE_CHECKBOX_STYLE = "-fx-padding: 0; ";
+	/**
+	 * The style applied to invalid parameters, using BAD_SELECTION_COLOUR.
+	 */
+	public static final String INVALID_PARAMETER_STYLE = "-fx-background-color: " + BAD_SELECTION_COLOUR;
+	/**
+	 * The style applied to neutral parameters, using NEUTRAL_SELECTION_COLOUR.
+	 */
+	public static final String WARNING_PARAMETER_STYLE = "-fx-background-color: " + NEUTRAL_SELECTION_COLOUR;
+	/**
+	 * The style applied to valid parameters, using NEUTRAL_COLOUR.
+	 */
+	public static final String VALID_PARAMETER_STYLE = "-fx-background-color: " + NEUTRAL_COLOUR;	
+    
+}
diff --git a/src/jcgp/gui/constants/Position.java b/src/jcgp/gui/constants/Position.java
new file mode 100644
index 0000000..6d4e02b
--- /dev/null
+++ b/src/jcgp/gui/constants/Position.java
@@ -0,0 +1,103 @@
+package jcgp.gui.constants;
+
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import jcgp.gui.GUI;
+import jcgp.gui.population.GUIGene;
+import jcgp.gui.population.GUIInput;
+import jcgp.gui.population.GUINode;
+import jcgp.gui.population.GUIOutput;
+
+/**
+ * Abstracts the task of positioning GUI components.
+ * <br>
+ * Do not instantiate this class; instead, use the {@code public static} methods provided.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public final class Position {
+	
+	/**
+	 * Private constructor to prevent instantiation.
+	 */
+	private Position() {}
+	
+	/**
+	 * Sets the X and Y layouts of the specified input to the appropriate values, according to its index.
+	 * 
+	 * @param input the {@code GUIInput} instance to relocate.
+	 */
+	public static void place(GUIInput input) {
+		// inputs are the first column, so we only worry about the margin and their index
+		input.relocate(Constants.CHROMOSOME_PANE_MARGIN,
+				input.getInput().getIndex() * (2 * Constants.NODE_RADIUS + Constants.SPACING) + Constants.CHROMOSOME_PANE_MARGIN);
+	}
+	
+	/**
+	 * Sets the X and Y layouts of the specified node to the appropriate values, according to its row and column values.
+	 * This also connects the start of every line with its respective socket. Therefore, this method should be called at least
+	 * once when the {@code GUINode} is instantiated.
+	 * 
+	 * @param node the {@code GUINode} instance to relocate.
+	 */
+	public static void place(GUINode node) {
+		// calculate x and y offsets, in relation to the layout origin
+		double xOffset = (node.getNode().getColumn() + 1) * (2 * Constants.NODE_RADIUS + Constants.SPACING) + Constants.CHROMOSOME_PANE_MARGIN;
+		double yOffset = node.getNode().getRow() * (2 * Constants.NODE_RADIUS + Constants.SPACING) + Constants.CHROMOSOME_PANE_MARGIN;
+		
+		// move node
+		node.relocate(xOffset, yOffset);
+		
+		// use the offset and the socket positions to connect the lines
+		for (int i = 0; i < GUI.resources.arity(); i++) {
+			node.getLines()[i].setStartX(node.getSocket(i).getCenterX() + xOffset + Constants.NODE_RADIUS + Constants.SOCKET_RADIUS);
+			node.getLines()[i].setStartY(node.getSocket(i).getCenterY() + yOffset + Constants.NODE_RADIUS);
+		}
+	}
+	
+	/**
+	 * Sets the X and Y layouts of the specified output to the appropriate values, according to its index.
+	 * This also connects the start of the output's single line to its single input socket.Therefore,
+	 * this method should be called at least once when the {@code GUIOutput} is instantiated.
+	 * 
+	 * @param output the {@code GUIOutput} instance to relocate.
+	 */
+	public static void place(GUIOutput output) {
+		// the output's position is a function of the number of columns and its own index
+		output.relocate(((GUI.resources.columns() + 1) * (2 * Constants.NODE_RADIUS + Constants.SPACING)) + Constants.CHROMOSOME_PANE_MARGIN,
+				output.getOutput().getIndex() * (2 * Constants.NODE_RADIUS + Constants.SPACING) + Constants.CHROMOSOME_PANE_MARGIN);
+		output.getLines()[0].setStartX(output.getLayoutX() - Constants.NODE_RADIUS);
+		output.getLines()[0].setStartY(output.getLayoutY());
+	}
+	
+	/**
+	 * Connects the end of a specified line to the specified gene.
+	 * 
+	 * @param line the line to connect.
+	 * @param target the target gene to connect to.
+	 */
+	public static void connect(Line line, GUIGene target) {
+		// set line ends based on the layout position of the target
+		line.setEndX(target.getLayoutX() + Constants.NODE_RADIUS);
+		line.setEndY(target.getLayoutY());
+	}
+
+	/**
+	 * Relocates the given socket to the appropriate position given the 
+	 * socket's index.
+	 * 
+	 * @param index the socket index.
+	 * @param socket the {@code Circle} instance to relocate.
+	 */
+	public static void placeSocket(int index, Circle socket) {
+		// calculate the angle with respect to the x-axis
+		double angle = (((index + 1) / ((double) (GUI.resources.arity() + 1))) * Constants.THETA) - (Constants.THETA / 2);
+		// convert to cartesian form
+		double xPos = -Math.cos(angle) * Constants.NODE_RADIUS;
+		double yPos = Math.sin(angle) * Constants.NODE_RADIUS;
+		// set centre
+		socket.setCenterX(xPos);
+		socket.setCenterY(yPos);
+	}
+}
diff --git a/src/jcgp/gui/dragresize/HorizontalDragResize.java b/src/jcgp/gui/dragresize/HorizontalDragResize.java
new file mode 100644
index 0000000..e88eafd
--- /dev/null
+++ b/src/jcgp/gui/dragresize/HorizontalDragResize.java
@@ -0,0 +1,131 @@
+package jcgp.gui.dragresize;
+
+import javafx.event.EventHandler;
+import javafx.scene.Cursor;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Region;
+import jcgp.gui.constants.Constants;
+
+/**
+ * This class adds horizontal drag resize functionality to any 
+ * arbitrary region provided. This is done by using the static
+ * method {@code makeDragResizable()}.
+ * <br><br>
+ * This is based on a class by Andrew Till found on:
+ * http://andrewtill.blogspot.co.uk/2012/12/dragging-to-resize-javafx-region.html
+ * 
+ */
+public class HorizontalDragResize {
+	
+	private boolean dragging = false;
+	private final Region region;
+	
+	/**
+	 * For internal use only, creates an instance of the actual
+	 * resizer used.
+	 * 
+	 * @param region the region to make resizable.
+	 */
+	private HorizontalDragResize(Region region) {
+		this.region = region;
+	}
+	
+	/**
+	 * Makes the specified region drag resizable.
+	 * This particular implementation only creates a resize 
+	 * click-and-drag area on the left side of the region. 
+	 * The resize area is defined by {@code GUI.RESIZE_MARGIN}.
+	 * 
+	 * @param region the region to make resizable.
+	 */
+	public static void makeDragResizable(final Region region) {
+		// make the instance, this actually performs the resizing
+		final HorizontalDragResize dr = new HorizontalDragResize(region);
+
+		// set mouse listeners
+		region.setOnMousePressed(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+		        dr.mousePressed(event);
+			}
+		});
+		region.setOnMouseDragged(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dr.mouseDragged(event);
+			}
+		});
+		region.setOnMouseMoved(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dr.mouseMoved(event);
+			}
+		});
+		region.setOnMouseReleased(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dr.mouseReleased();
+			}
+		});
+		
+	}
+	
+	/**
+	 * If the press happened in the resize area, raise the drag flag.
+	 * 
+	 * @param event the associated mouse event.
+	 */
+	private void mousePressed(MouseEvent event) {
+		if(isInDraggableZone(event)) {
+	        dragging = true;
+        }
+	}
+
+	/**
+	 * If drag flag is high, resize the region to match the mouse position.
+	 * 
+	 * @param event the associated mouse event.
+	 */
+	private void mouseDragged(MouseEvent event) {
+		if(dragging) {
+			double newWidth = region.getWidth() - event.getX();
+			if (newWidth >= region.getMinWidth()) {
+				region.setPrefWidth(newWidth);
+			} else {
+				region.setPrefWidth(region.getMinWidth());
+			}
+		}
+	}
+	
+	/**
+	 * Change the cursor if the mouse position overlaps with the resize area.
+	 * 
+	 * @param event the associated mouse event.
+	 */
+	private void mouseMoved(MouseEvent event) {
+		if(isInDraggableZone(event) || dragging) {
+			region.setCursor(Cursor.H_RESIZE);
+		} else {
+			region.setCursor(Cursor.DEFAULT);
+		}
+	}
+
+	/**
+	 * Finish resizing.
+	 */
+	private void mouseReleased() {
+		dragging = false;
+		region.setCursor(Cursor.DEFAULT);
+	}
+
+	/**
+	 * Assert whether the mouse cursor is in the draggable area defined by {@code GUI.RESIZE_MARGIN}.
+	 * 
+	 * @param event the associated mouse event.
+	 * @return true if the mouse position is in the draggable area.
+	 */
+	private boolean isInDraggableZone(MouseEvent event) {
+		return event.getX() < (Constants.RESIZE_MARGIN);
+	}
+
+}
diff --git a/src/jcgp/gui/dragresize/VerticalDragResize.java b/src/jcgp/gui/dragresize/VerticalDragResize.java
new file mode 100644
index 0000000..4f784e5
--- /dev/null
+++ b/src/jcgp/gui/dragresize/VerticalDragResize.java
@@ -0,0 +1,132 @@
+package jcgp.gui.dragresize;
+
+import javafx.event.EventHandler;
+import javafx.scene.Cursor;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Region;
+import jcgp.gui.constants.Constants;
+
+/**
+ * This class adds vertical drag resize functionality to any 
+ * arbitrary region provided. This is done by using the static
+ * method {@code makeDragResizable()}.
+ * <br><br>
+ * This is based on a class by Andrew Till found on:
+ * http://andrewtill.blogspot.co.uk/2012/12/dragging-to-resize-javafx-region.html
+ * 
+ */
+public class VerticalDragResize {
+	
+	private boolean dragging = false;
+	private final Region region;
+	
+	/**
+	 * For internal use only, creates an instance of the actual
+	 * resizer used.
+	 * 
+	 * @param region the region to make resizable.
+	 */
+	private VerticalDragResize(Region region) {
+		this.region = region;
+	}
+	
+	/**
+	 * Makes the specified region drag resizable.
+	 * This particular implementation only creates a resize 
+	 * click-and-drag area on the top side of the region. 
+	 * The resize area is defined by {@code GUI.RESIZE_MARGIN}.
+	 * 
+	 * @param region the region to make resizable.
+	 */
+	public static void makeDragResizable(final Region region) {
+		// make the instance, this actually performs the resizing
+		final VerticalDragResize dr = new VerticalDragResize(region);
+
+		// set mouse listeners
+		region.setOnMousePressed(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+		        dr.mousePressed(event);
+			}
+		});
+		region.setOnMouseDragged(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dr.mouseDragged(event);
+			}
+		});
+		region.setOnMouseMoved(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dr.mouseMoved(event);
+			}
+		});
+		region.setOnMouseReleased(new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dr.mouseReleased();
+			}
+		});
+		
+	}
+	
+	/**
+	 * If the press happened in the resize area, raise the drag flag.
+	 * 
+	 * @param event the associated mouse event.
+	 */
+	private void mousePressed(MouseEvent event) {
+		if(isInDraggableZone(event)) {
+	        dragging = true;
+        }
+	}
+
+	/**
+	 * If drag flag is high, resize the region to match the mouse position.
+	 * 
+	 * @param event the associated mouse event.
+	 */
+	private void mouseDragged(MouseEvent event) {
+		if(dragging) {
+			double newHeight = region.getHeight() - event.getY();
+			if (newHeight >= region.getMinHeight()) {
+				region.setPrefHeight(newHeight);
+			} else {
+				region.setPrefHeight(region.getMinHeight());
+			}
+		}
+	}
+	
+	/**
+	 * Change the cursor if the mouse position overlaps with the resize area.
+	 * 
+	 * @param event the associated mouse event.
+	 */
+	private void mouseMoved(MouseEvent event) {
+		if(isInDraggableZone(event) || dragging) {
+			region.setCursor(Cursor.V_RESIZE);
+        }
+        else {
+        	region.setCursor(Cursor.DEFAULT);
+        }
+	}
+
+	/**
+	 * Finish resizing.
+	 */
+	private void mouseReleased() {
+		dragging = false;
+		region.setCursor(Cursor.DEFAULT);
+	}
+
+	/**
+	 * Assert whether the mouse cursor is in the draggable area defined by {@code GUI.RESIZE_MARGIN}.
+	 * 
+	 * @param event the associated mouse event.
+	 * @return true if the mouse position is in the draggable area.
+	 */
+	private boolean isInDraggableZone(MouseEvent event) {
+		return event.getY() < (Constants.RESIZE_MARGIN);
+	}
+
+}
diff --git a/src/jcgp/gui/handlers/InputHandlers.java b/src/jcgp/gui/handlers/InputHandlers.java
new file mode 100644
index 0000000..cc677eb
--- /dev/null
+++ b/src/jcgp/gui/handlers/InputHandlers.java
@@ -0,0 +1,56 @@
+package jcgp.gui.handlers;
+
+import javafx.event.EventHandler;
+import javafx.scene.input.MouseEvent;
+import jcgp.gui.population.GUIGene.GUIGeneState;
+import jcgp.gui.population.GUIInput;
+
+/**
+ * Holds the handlers that define the behaviour of {@code GUIInput}.
+ * <br><br>
+ * The handlers are instantiated here statically and added to {@code GUIInput}
+ * instances using {@code InputHandlers.addHandlers(...)}. This guarantees that
+ * all inputs behave the same way without instantiating a new set of handlers for
+ * each input instance.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public final class InputHandlers {
+	
+	/**
+	 * Private constructor to prevent instantiation.
+	 */
+	private InputHandlers() {}
+
+	/**
+	 * Inputs don't do much; set state to hover when mouse enters.
+	 */
+	private static EventHandler<MouseEvent> mouseEnteredHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			((GUIInput) event.getSource()).setState(GUIGeneState.HOVER);
+		}
+	};
+	
+	/**
+	 * Inputs don't do much; set state to neutral when mouse exits.
+	 */
+	private static EventHandler<MouseEvent> mouseExitedHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			((GUIInput) event.getSource()).setState(GUIGeneState.NEUTRAL);
+		}
+	};
+	
+	/**
+	 * Adds all handlers to the specified input.
+	 * 
+	 * @param input the {@code GUIInput} to which the handlers will be added.
+	 */
+	public static void addHandlers(GUIInput input) {
+		input.addEventHandler(MouseEvent.MOUSE_ENTERED, mouseEnteredHandler);
+		input.addEventHandler(MouseEvent.MOUSE_EXITED, mouseExitedHandler);
+	}
+	
+}
diff --git a/src/jcgp/gui/handlers/NodeHandlers.java b/src/jcgp/gui/handlers/NodeHandlers.java
new file mode 100644
index 0000000..b413a62
--- /dev/null
+++ b/src/jcgp/gui/handlers/NodeHandlers.java
@@ -0,0 +1,164 @@
+package jcgp.gui.handlers;
+
+import javafx.event.EventHandler;
+import javafx.scene.input.MouseDragEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import jcgp.backend.population.Gene;
+import jcgp.gui.GUI;
+import jcgp.gui.constants.Position;
+import jcgp.gui.population.ChromosomePane;
+import jcgp.gui.population.GUIConnection;
+import jcgp.gui.population.GUIGene;
+import jcgp.gui.population.GUIGene.GUIGeneState;
+import jcgp.gui.population.GUINode;
+
+/**
+ * Holds the handlers that define the behaviour of {@code GUINode}.
+ * <br><br>
+ * The handlers are instantiated here statically and added to {@code GUINode}
+ * instances using {@code NodeHandlers.addHandlers(...)}. This guarantees that
+ * all nodes behave the same way without instantiating a new set of handlers for
+ * each node instance.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public final class NodeHandlers {
+
+	/**
+	 * Private constructor to prevent instantiation.
+	 */
+	private NodeHandlers() {}
+
+	/**
+	 * Set the node to {@code GUIGeneState.HOVER} state, and set its immediate connections to {@code GUIGeneState.EXTENDED_HOVER}.
+	 */
+	private static EventHandler<MouseEvent> mouseEnteredHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// acquire the source, we can safely cast it to GUINode
+			GUINode source = (GUINode) event.getSource();
+
+			source.setState(GUIGeneState.HOVER);
+			for (int i = 0; i < GUI.resources.arity(); i++) {
+				((GUIGene) ((Gene) source.getNode().getConnection(i)).getGUIObject()).setState(GUIGeneState.EXTENDED_HOVER);
+			}
+		}
+	};
+
+	/**
+	 * Set the node and its immediate connections to {@code GUIGeneState.NEUTRAL} state.
+	 */
+	private static EventHandler<MouseEvent> mouseExitedHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// acquire the source, we can safely cast it to GUINode
+			GUINode source = (GUINode) event.getSource();
+
+			if (Target.getSourceMutable() != source) {
+				source.setState(GUIGeneState.NEUTRAL);
+				for (int i = 0; i < GUI.resources.arity(); i++) {
+					((GUIGene) ((Gene) source.getNode().getConnection(i)).getGUIObject()).setState(GUIGeneState.NEUTRAL);
+				}
+			}
+		}
+	};
+
+	private static EventHandler<MouseEvent> socketDragDetected = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// it's safe to assume that the source is the socket
+			((GUINode) ((Circle) event.getSource()).getParent()).startFullDrag();
+		}
+	};
+
+	private static EventHandler<MouseEvent> socketMousePressedHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// it's safe to assume that the source is the socket
+			Target.start((Circle) event.getSource());
+		}
+	};
+
+	private static EventHandler<MouseEvent> socketMouseDraggedHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// this can only happen after a press, so we know Target is up-to-date
+			if (!Target.isProspecting()) {
+				GUINode node = (GUINode) Target.getSourceMutable();
+				Line line = Target.getConnectionLine();
+				line.setEndX(event.getX() + node.getLayoutX());
+				line.setEndY(event.getY() + node.getLayoutY());
+			}
+
+		}
+	};
+
+	private static EventHandler<MouseEvent> socketMouseReleasedHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+
+			GUINode node = (GUINode) ((Circle) event.getSource()).getParent();
+			int connectionId = Integer.valueOf(((Circle) event.getSource()).getId());
+
+			Position.connect(node.getLines()[connectionId], (GUIGene) ((Gene) node.getNode().getConnection(connectionId)).getGUIObject());
+		}
+	};
+
+	private static EventHandler<MouseDragEvent> dragEnteredHandler = new EventHandler<MouseDragEvent>() {
+		@Override
+		public void handle(MouseDragEvent event) {
+			// acquire the source, we can safely cast it to GUINode
+			GUINode source = (GUINode) event.getSource();
+			if (Target.getCurrentConnection() == source) {
+				source.setState(GUIGeneState.NEUTRAL_TARGET);
+				// we are now prospecting
+				Target.setProspecting(true);
+				Position.connect(Target.getConnectionLine(), source);
+			} else if (ChromosomePane.isAllowed(Target.getSourceMutable(), (GUIConnection) source)) {
+				source.setState(GUIGeneState.GOOD_TARGET);
+				// we are now prospecting
+				Target.setProspecting(true);
+				Position.connect(Target.getConnectionLine(), source);
+			} else {
+				source.setState(GUIGeneState.BAD_TARGET);
+			}
+		}
+	};
+
+	private static EventHandler<MouseDragEvent> dragExitedHandler = new EventHandler<MouseDragEvent>() {
+		@Override
+		public void handle(MouseDragEvent event) {
+			// acquire the source, we can safely cast it to GUINode
+			GUINode source = (GUINode) event.getSource();
+			source.setState(GUIGeneState.NEUTRAL);
+			
+			// no longer prospecting
+			Target.setProspecting(false);
+		}
+	};
+
+	/**
+	 * Adds all handlers to the specified node.
+	 * 
+	 * @param node the {@code GUINode} to which the handlers will be added.
+	 */
+	public static void addHandlers(GUINode node) {
+		node.addEventHandler(MouseEvent.MOUSE_ENTERED, mouseEnteredHandler);
+		node.addEventHandler(MouseEvent.MOUSE_EXITED, mouseExitedHandler);
+
+		node.addEventHandler(MouseDragEvent.MOUSE_DRAG_ENTERED, dragEnteredHandler);
+		node.addEventHandler(MouseDragEvent.MOUSE_DRAG_EXITED, dragExitedHandler);
+
+		Circle[] sockets = node.getSockets();
+		for (int s = 0; s < sockets.length; s++) {
+
+			sockets[s].addEventFilter(MouseEvent.DRAG_DETECTED, socketDragDetected);
+			sockets[s].addEventHandler(MouseEvent.MOUSE_PRESSED, socketMousePressedHandler);
+			sockets[s].addEventHandler(MouseEvent.MOUSE_DRAGGED, socketMouseDraggedHandler);
+			sockets[s].addEventHandler(MouseEvent.MOUSE_RELEASED, socketMouseReleasedHandler);
+		}
+	}
+}
diff --git a/src/jcgp/gui/handlers/OutputHandlers.java b/src/jcgp/gui/handlers/OutputHandlers.java
new file mode 100644
index 0000000..b89d746
--- /dev/null
+++ b/src/jcgp/gui/handlers/OutputHandlers.java
@@ -0,0 +1,84 @@
+package jcgp.gui.handlers;
+
+import javafx.event.EventHandler;
+import javafx.scene.input.MouseEvent;
+import jcgp.backend.population.Gene;
+import jcgp.gui.population.GUIConnection;
+import jcgp.gui.population.GUIGene.GUIGeneState;
+import jcgp.gui.population.GUIOutput;
+
+/**
+ * Holds the handlers that define the behaviour of {@code GUIOutput}.
+ * <br><br>
+ * The handlers are instantiated here statically and added to {@code GUIOutput}
+ * instances using {@code OutputHandlers.addHandlers(...)}. This guarantees that
+ * all outputs behave the same way without instantiating a new set of handlers for
+ * each output instance.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public final class OutputHandlers {
+	
+	/**
+	 * Private constructor to prevent instantiation.
+	 */
+	private OutputHandlers() {}
+
+	/**
+	 * Set the output to {@code GUIGeneState.HOVER} state, and recursively set its active genes
+	 * to {@code GUIGeneState.ACTIVE_HOVER}.
+	 */
+	private static EventHandler<MouseEvent> mouseEnteredHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// acquire the source, we can safely cast it to GUIOutput
+			GUIOutput source = (GUIOutput) event.getSource();
+
+			source.setState(GUIGeneState.HOVER);
+			((GUIConnection) ((Gene) source.getOutput().getSource()).getGUIObject()).setStateRecursively(GUIGeneState.ACTIVE_HOVER);
+		}
+	};
+
+	/**
+	 * Set the output and all of its active genes to {@code GUIGeneState.NEUTRAL} state.
+	 */
+	private static EventHandler<MouseEvent> mouseExitedHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// acquire the source, we can safely cast it to GUIOutput
+			GUIOutput source = (GUIOutput) event.getSource();
+			
+			source.setState(GUIGeneState.NEUTRAL);
+			((GUIConnection) ((Gene) source.getOutput().getSource()).getGUIObject()).setStateRecursively(GUIGeneState.NEUTRAL);
+		}
+	};
+
+	/**
+	 * If the output is locked, unlock it and all of its associated genes recursively.
+	 * If it is unlocked, lock it and its active genes.
+	 */
+	private static EventHandler<MouseEvent> mouseClickHandler = new EventHandler<MouseEvent>() {
+		@Override
+		public void handle(MouseEvent event) {
+			// acquire the source, we can safely cast it to GUIOutput
+			GUIOutput source = (GUIOutput) event.getSource();
+
+			boolean lock = !source.isLocked();
+			source.setLock(lock);
+			((GUIConnection) ((Gene) source.getOutput().getSource()).getGUIObject()).setLockRecursively(lock);
+		}
+	};
+
+	/**
+	 * Adds all handlers to the specified output.
+	 * 
+	 * @param output the {@code GUIOutput} to which the handlers will be added.
+	 */
+	public static void addHandlers(GUIOutput output) {
+		output.addEventHandler(MouseEvent.MOUSE_ENTERED, mouseEnteredHandler);
+		output.addEventHandler(MouseEvent.MOUSE_EXITED, mouseExitedHandler);
+		output.addEventHandler(MouseEvent.MOUSE_CLICKED, mouseClickHandler);
+	}
+
+}
diff --git a/src/jcgp/gui/handlers/Target.java b/src/jcgp/gui/handlers/Target.java
new file mode 100644
index 0000000..b050663
--- /dev/null
+++ b/src/jcgp/gui/handlers/Target.java
@@ -0,0 +1,70 @@
+package jcgp.gui.handlers;
+
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import jcgp.gui.population.GUIConnection;
+import jcgp.gui.population.GUIMutable;
+
+/**
+ * @author Eduardo Pedroni
+ *
+ */
+public final class Target {
+
+	/**
+	 * Private constructor to prevent instantiation.
+	 */
+	private Target() {}
+	
+	private static GUIConnection targetConnection;
+	private static GUIMutable sourceMutable;
+	private static int connectionIndex;
+	private static Line connectionLine;
+	private static Circle sourceSocket;
+	private static boolean prospecting = false;
+	
+	public static void start(Circle newSocket) {
+		// store new socket
+		sourceSocket = newSocket;
+		// derive the rest of the information from it
+		connectionIndex = Integer.valueOf(newSocket.getId());
+		sourceMutable = (GUIMutable) newSocket.getParent();
+		connectionLine = sourceMutable.getLines()[connectionIndex];
+	}
+	
+	public static GUIMutable getSourceMutable() {
+		return sourceMutable;
+	}
+	
+	public static int getConnectionIndex() {
+		return connectionIndex;
+	}
+	
+	public static Line getConnectionLine() {
+		return connectionLine;
+	}
+	
+	public static Circle getSourceSocket() {
+		return sourceSocket;
+	}
+	
+	public static GUIConnection getTarget() {
+		return targetConnection;
+	}
+	
+	public static GUIConnection getCurrentConnection() {
+		return sourceMutable.getConnections()[connectionIndex];
+	}
+	
+	public static void setProspecting(boolean value) {
+		prospecting = value;
+	}
+	
+	public static boolean isProspecting() {
+		return prospecting;
+	}
+	
+	public static void setTarget(GUIConnection newTarget) {
+		targetConnection = newTarget;
+	}
+}
diff --git a/src/jcgp/gui/population/ChromosomePane.java b/src/jcgp/gui/population/ChromosomePane.java
new file mode 100644
index 0000000..a87a054
--- /dev/null
+++ b/src/jcgp/gui/population/ChromosomePane.java
@@ -0,0 +1,140 @@
+package jcgp.gui.population;
+
+import java.util.ArrayList;
+
+import javafx.scene.control.ScrollPane;
+import javafx.scene.layout.Pane;
+import javafx.scene.shape.Line;
+import jcgp.backend.population.Chromosome;
+import jcgp.backend.population.Node;
+import jcgp.gui.GUI;
+
+/**
+ * This extension of {@code ScrollPane} contains a series of
+ * nodes, inputs and outputs spread across a grid. It also contains
+ * all of the connection lines laid over the nodes, inputs and outputs.
+ * 
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public class ChromosomePane extends ScrollPane {
+
+	private GUIInput[] guiInputs;
+	private GUINode[][] guiNodes;
+	private GUIOutput[] guiOutputs;
+
+	private Pane content;
+
+	private boolean target = false;
+
+	public ChromosomePane(Chromosome chromosome) {
+		super();
+
+		ArrayList<Line> connectionLines = new ArrayList<Line>();
+
+		int rows = GUI.resources.rows();
+		int columns = GUI.resources.columns();
+
+		content = new Pane();
+		content.setId("content pane for genes");
+
+		/* 
+		 * inputs
+		 */
+		guiInputs = new GUIInput[GUI.resources.inputs()];
+		for (int i = 0; i < guiInputs.length; i++) {
+			guiInputs[i] = new GUIInput(chromosome.getInput(i));
+		}
+		// add inputs to content pane
+		content.getChildren().addAll(guiInputs);
+
+		/*
+		 * nodes
+		 */
+		guiNodes = new GUINode[rows][columns];
+		for (int c = 0; c < columns; c++) {
+			for (int r = 0; r < rows; r++) {
+				// make the connection lines
+				Line lines[] = new Line[GUI.resources.arity()];
+				for (int l = 0; l < lines.length; l++) {
+					lines[l] = new Line();
+					lines[l].setMouseTransparent(true);
+					lines[l].setVisible(false);
+					connectionLines.add(lines[l]);
+				}
+				// make the GUI element
+				guiNodes[r][c] = new GUINode(chromosome.getNode(r, c), lines);
+				// add node to content pane
+				content.getChildren().add(guiNodes[r][c]);
+			}
+		}
+
+		/* 
+		 * outputs
+		 */
+		guiOutputs = new GUIOutput[GUI.resources.outputs()];
+		for (int i = 0; i < guiOutputs.length; i++) {
+			// make the connection line
+			Line line = new Line();
+			line.setVisible(false);
+			line.setMouseTransparent(true);
+			connectionLines.add(line);
+			// make the GUI element
+			guiOutputs[i] = new GUIOutput(chromosome.getOutput(i), line);
+		}
+		// add outputs to content pane
+		content.getChildren().addAll(guiOutputs);
+
+		// add lines to the pane on top of genes
+		content.getChildren().addAll(connectionLines);
+
+		setPrefWidth(620);
+		setContent(content);
+	}
+
+	protected boolean isTarget() {
+		return target;
+	}
+
+	protected void setTarget(boolean newValue) {
+		target = newValue;
+	}
+
+	public void updateGenes(Chromosome chr) {
+		for (int r = 0; r < GUI.resources.rows(); r++) {
+			for (int c = 0; c < GUI.resources.columns(); c++) {
+				guiNodes[r][c].setNode(chr.getNode(r, c));
+			}
+		}
+		for (int i = 0; i < guiOutputs.length; i++) {
+			guiOutputs[i].setOutput(chr.getOutput(i));
+		}
+	}
+
+	public static boolean isAllowed(GUIMutable source, GUIConnection target) {
+		if (source instanceof GUINode) {
+			// if the source is a node, all inputs and some nodes are valid
+			if (target instanceof GUIInput) {
+				return true;
+			} else if (target instanceof GUINode) {
+				// target and source are nodes, let's look at levels back
+				Node t = ((GUINode) target).getNode(), s = ((GUINode) source).getNode();
+				if (s.getColumn() - t.getColumn() > 0 && s.getColumn() - t.getColumn() <= GUI.resources.levelsBack()) {
+					return true;
+				}
+			}
+			return false;
+		} else if (source instanceof GUIOutput) {
+			// if the source is an output, any node or input is valid
+			if (target instanceof GUINode || target instanceof GUIInput) {
+				return true;
+			} else {
+				// this should never happen...
+				return false;
+			}
+		}
+		// if the source was neither node nor output, something bad is happening
+		throw new ClassCastException("Source was neither GUINode nor GUIOutput.");
+	}
+}
diff --git a/src/jcgp/gui/population/FunctionSelector.java b/src/jcgp/gui/population/FunctionSelector.java
new file mode 100644
index 0000000..14614e5
--- /dev/null
+++ b/src/jcgp/gui/population/FunctionSelector.java
@@ -0,0 +1,80 @@
+package jcgp.gui.population;
+
+import javafx.event.EventHandler;
+import javafx.scene.control.Label;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.VBox;
+import jcgp.backend.function.FunctionSet;
+import jcgp.gui.constants.Constants;
+
+/**
+ * A menu class, exposes all of the allowed functions
+ * when called by a node, so that the node function can be changed.
+ * 
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public class FunctionSelector extends VBox {
+	
+	private GUINode target;
+		
+	public FunctionSelector(FunctionSet functionSet) {
+		setFillWidth(true);
+		setVisible(false);
+		setStyle("-fx-border-color: #A0A0A0; -fx-border-width: 1 1 0 1");
+		
+		remakeFunctions(functionSet);
+		
+		addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+			@Override
+			public void handle(MouseEvent event) {
+				dismiss();
+			}
+		});
+	}
+	
+	public void remakeFunctions(final FunctionSet fs) {
+		getChildren().clear();
+		
+		for (int i = 0; i < fs.getAllowedFunctionCount(); i++) {
+			final int index = i;
+			Label l = new Label(fs.getAllowedFunction(i).toString());
+			l.setMaxWidth(Double.MAX_VALUE);
+			l.setStyle("-fx-background-color: #FFFFFF; -fx-border-color: #A0A0A0; -fx-border-width: 0 0 1 0; -fx-padding: 2");
+			
+			l.addEventFilter(MouseEvent.MOUSE_ENTERED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					((Label) event.getSource()).setStyle("-fx-background-color: " + Constants.SOFT_HIGHLIGHT_PAINT + "; -fx-border-color: #B0B0B0; -fx-border-width: 0 0 1 0; -fx-padding: 2");
+				}
+			});
+			l.addEventFilter(MouseEvent.MOUSE_EXITED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					((Label) event.getSource()).setStyle("-fx-background-color: #FFFFFF; -fx-border-color: #A0A0A0; -fx-border-width: 0 0 1 0; -fx-padding: 2");
+				}
+			});
+			l.addEventFilter(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {
+				@Override
+				public void handle(MouseEvent event) {
+					//target.setFunction(fs.getAllowedFunction(index));
+					dismiss();
+				}
+			});
+			
+			getChildren().add(l);
+		}
+	}
+	
+	public void relocateAndShow(MouseEvent event, GUINode node) {
+		relocate(event.getSceneX() - 5, event.getSceneY() - 5);
+		target = node;
+		setVisible(true);
+	}
+	
+	private void dismiss() {
+		setVisible(false);
+	}
+	
+}
diff --git a/src/jcgp/gui/population/GUIConnection.java b/src/jcgp/gui/population/GUIConnection.java
new file mode 100644
index 0000000..dc7fcc8
--- /dev/null
+++ b/src/jcgp/gui/population/GUIConnection.java
@@ -0,0 +1,32 @@
+package jcgp.gui.population;
+
+import jcgp.gui.population.GUIGene.GUIGeneState;
+
+/**
+ * A loose equivalent to {@link jcgp.backend.population.Connection}.
+ * <br>
+ * This defines behaviour that all GUI representations of connections
+ * should be capable of.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public interface GUIConnection {
+
+	/**
+	 * Set the connection's state, but also recursively propagate that state
+	 * all the way back to the inputs.
+	 * 
+	 * @param state the state to set.
+	 */
+	public void setStateRecursively(GUIGeneState state);
+	
+	/**
+	 * Add or remove a lock, but also recursively propagate that change
+	 * all the way back to the inputs.
+	 * 
+	 * @param value true to lock, false to unlock.
+	 */
+	public void setLockRecursively(boolean value);
+	
+}
diff --git a/src/jcgp/gui/population/GUIGene.java b/src/jcgp/gui/population/GUIGene.java
new file mode 100644
index 0000000..5e6107f
--- /dev/null
+++ b/src/jcgp/gui/population/GUIGene.java
@@ -0,0 +1,187 @@
+package jcgp.gui.population;
+
+import javafx.geometry.VPos;
+import javafx.scene.Group;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+import jcgp.gui.constants.Constants;
+
+/**
+ * Defines the general behaviour of the visual representation of each chromosome gene.
+ * <br><br>
+ * In practice, this is subclass of {@code javafx.scene.Group} containing a {@code Circle}
+ * object and a {@code Text} object. Subclasses may add further elements to the group, for
+ * instance to display connection input and output sockets.
+ * <br><br>
+ * Genes also contain a locked property. When locked, some gene states behave slightly
+ * differently. This is used so genes remain highlighted even in the neutral state. The
+ * gene lock is in fact recursive; a gene can be locked multiple times and only unlocking
+ * it as many times will actually revert it back to its unlocked state. This allows multiple
+ * pathways to lock the same gene independently without affecting each other; the gene remains
+ * locked until no pathways are locking it.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public abstract class GUIGene extends Group {
+
+	/**
+	 * This {@code enum} type defines a finite list of all states
+	 * a gene can take. Each state represents a particular steady
+	 * situation, and has its own GUI appearance associated with it:
+	 * a combination of connection line visibility, gene background colour
+	 * and other visual characteristics.
+	 * 
+	 * @author Eduardo Pedroni
+	 *
+	 */
+	public enum GUIGeneState {
+		/**
+		 * No user interaction at all.
+		 */
+		NEUTRAL,
+		/**
+		 * User is simply hovering over the node.
+		 */
+		HOVER,
+		/**
+		 * User is hovering over a node connected to this one.
+		 */
+		EXTENDED_HOVER,
+		/**
+		 * User is hovering over an output connected to this gene.
+		 */
+		ACTIVE_HOVER,
+		
+		GOOD_TARGET,
+		
+		NEUTRAL_TARGET,
+		
+		BAD_TARGET
+	}
+
+	private GUIGeneState currentState = GUIGeneState.NEUTRAL;
+
+	private Text text;
+	private Circle mainCircle;
+	
+	/**
+	 * Recursive lock; lock == 0 means unlocked, lock > 0 means locked.
+	 * Accessing using {@code setLock(...)}.
+	 */
+	private int lock = 0;
+
+	/**
+	 * Initialises the {@code Text} and {@code Circle} objects so that all genes are standardised.
+	 */
+	protected GUIGene() {
+		text = new Text();
+		text.setFont(Font.font("Arial", 12));
+		text.setTextOrigin(VPos.CENTER);
+		text.setTextAlignment(TextAlignment.CENTER);
+		text.setWrappingWidth(Constants.NODE_RADIUS * 2);
+		text.setX(-Constants.NODE_RADIUS);
+
+		mainCircle = new Circle(Constants.NODE_RADIUS, Constants.NEUTRAL_PAINT);
+		mainCircle.setStroke(Paint.valueOf("black"));
+		
+		getChildren().addAll(mainCircle, text);
+	}
+
+	/**
+	 * Sets the gene's text field.
+	 * 
+	 * @param newText the text string to be displayed.
+	 */
+	public void setText(String newText) {
+		text.setText(newText);
+	}
+
+	/**
+	 * @return the gene's current state.
+	 */
+	public GUIGeneState getState() {
+		return currentState;
+	}
+
+	/**
+	 * Gene states are standardised: all gene subclasses behave the same way in each state.
+	 * <br>
+	 * This design choice was made for the sake of consistency. Rather than controlling the 
+	 * appearance of the genes with logic in the state transition method AND the mouse handlers, 
+	 * the states are now consistent across all types of gene. The mouse handlers implement
+	 * whatever logic is necessary to determine the gene's new state given a certain user input,
+	 * but the states themselves are the same for all genes.
+	 * <br>
+	 * The transition logic for each type of gene is defined in its respective handler class:
+	 * {@code InputHandlers}, {@code NodeHandlers} and {@code OutputHandlers}.   
+	 * 
+	 * @param newState the gene's new state.
+	 */
+	public final void setState(GUIGeneState newState) {
+		switch (newState) {
+		case NEUTRAL:
+			mainCircle.setFill(isLocked() ? Constants.HARD_HIGHLIGHT_PAINT : Constants.NEUTRAL_PAINT);
+			setLinesVisible(isLocked());
+			break;
+		case HOVER:
+			mainCircle.setFill(Constants.MEDIUM_HIGHLIGHT_PAINT);
+			setLinesVisible(true);
+			break;
+		case EXTENDED_HOVER:
+			mainCircle.setFill(Constants.SOFT_HIGHLIGHT_PAINT);
+			setLinesVisible(isLocked());
+			break;
+		case ACTIVE_HOVER:
+			mainCircle.setFill(Constants.SOFT_HIGHLIGHT_PAINT);
+			setLinesVisible(true);
+			break;
+		case GOOD_TARGET:
+			mainCircle.setFill(Constants.GOOD_SELECTION_PAINT);
+			break;
+		case NEUTRAL_TARGET:
+			mainCircle.setFill(Constants.NEUTRAL_SELECTION_PAINT);
+			break;
+		case BAD_TARGET:
+			mainCircle.setFill(Constants.BAD_SELECTION_PAINT);
+			break;
+		}
+		currentState = newState;
+	}
+	
+	/**
+	 * For the sake of practicality, all {@code GUIGene} instances must implement this
+	 * method. It sets the visibility of all of the gene's lines, if it has any.
+	 * 
+	 * @param value the visibility value.
+	 */
+	protected abstract void setLinesVisible(boolean value);
+	
+	/**
+	 * @return true if the gene is locked, false otherwise.
+	 */
+	public boolean isLocked() {
+		return lock > 0;
+	}
+	
+	/**
+	 * Locks or unlocks the gene once. Locked genes
+	 * behave slightly differently in some states. 
+	 * <br>
+	 * Unlocking an already unlocked gene does nothing.
+	 * 
+	 * @param value true to lock, false to unlock;
+	 */
+	public void setLock(boolean value) {
+		if (value) {
+			lock++;
+		} else if (lock > 0) {
+			lock--;
+		} else {
+			lock = 0;
+		}
+	}
+}
diff --git a/src/jcgp/gui/population/GUIInput.java b/src/jcgp/gui/population/GUIInput.java
new file mode 100644
index 0000000..3db7416
--- /dev/null
+++ b/src/jcgp/gui/population/GUIInput.java
@@ -0,0 +1,70 @@
+package jcgp.gui.population;
+
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import jcgp.backend.population.Input;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.constants.Position;
+import jcgp.gui.handlers.InputHandlers;
+
+/**
+ * The GUI counterpart of {@link jcgp.backend.population.Input}. This is a 
+ * subclass of {@code GUIGene} which represents a chromosome input.
+ * 
+ * @author Eduardo Pedroni
+ */
+public class GUIInput extends GUIGene implements GUIConnection {
+
+	private Input input;
+	
+	/**
+	 * Instantiate {@code GUIInput} given an {@code Input}.
+	 * 
+	 * @param input the associated backend input.
+	 */
+	public GUIInput(final Input input) {
+		super();
+		// store the input, associate itself with it
+		this.input = input;
+		input.setGUIObject(this);
+		
+		// inputs only have a single output socket
+		Circle outputSocket = new Circle(Constants.NODE_RADIUS, 0, Constants.SOCKET_RADIUS, Paint.valueOf("white"));
+		outputSocket.setStroke(Paint.valueOf("black"));
+		outputSocket.setId(String.valueOf(0));
+		getChildren().add(outputSocket);
+		
+		// relocate to the right position, add mouse handlers
+		Position.place(this);
+		InputHandlers.addHandlers(this);
+	}
+
+	/**
+	 * @return the {@code Input} instance associated with this object.
+	 */
+	public Input getInput() {
+		return input;
+	}
+	
+	/**
+	 * Associates this instance with a new input.
+	 * 
+	 * @param input the new input.
+	 */
+	void setInput(Input input) {
+		this.input = input;
+	}
+
+	@Override
+	public void setStateRecursively(GUIGeneState state) {
+		setState(state);
+	}
+
+	@Override
+	protected void setLinesVisible(boolean value) {}
+
+	@Override
+	public void setLockRecursively(boolean value) {
+		setLock(value);
+	}
+}
diff --git a/src/jcgp/gui/population/GUIMutable.java b/src/jcgp/gui/population/GUIMutable.java
new file mode 100644
index 0000000..fa996e2
--- /dev/null
+++ b/src/jcgp/gui/population/GUIMutable.java
@@ -0,0 +1,20 @@
+package jcgp.gui.population;
+
+import javafx.scene.shape.Line;
+
+/**
+ * A loose equivalent to {@link jcgp.backend.population.Mutable}.
+ * <br>
+ * This defines behaviour that all GUI representations of mutables
+ * should be capable of.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public interface GUIMutable {
+	
+	public Line[] getLines();
+	
+	public GUIConnection[] getConnections();
+	
+}
diff --git a/src/jcgp/gui/population/GUINode.java b/src/jcgp/gui/population/GUINode.java
new file mode 100644
index 0000000..1a32426
--- /dev/null
+++ b/src/jcgp/gui/population/GUINode.java
@@ -0,0 +1,134 @@
+package jcgp.gui.population;
+
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import jcgp.backend.population.Gene;
+import jcgp.backend.population.Node;
+import jcgp.gui.GUI;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.constants.Position;
+import jcgp.gui.handlers.NodeHandlers;
+
+/**
+ * The GUI counterpart of {@link jcgp.backend.population.Node}. This is a 
+ * subclass of {@code GUIGene} which represents a chromosome node.
+ * 
+ * @author Eduardo Pedroni
+ */
+public class GUINode extends GUIGene implements GUIMutable, GUIConnection {
+
+	private Node node;
+	private Line[] lines;
+	private Circle[] sockets;
+	
+	/**
+	 * Instantiate {@code GUINode} given a {@code Node} and the lines needed
+	 * to show its connections.
+	 * 
+	 * @param node the associated backend node.
+	 * @param lines the lines used to display connections.
+	 */
+	public GUINode(Node node, Line[] lines) {
+		super();
+		// store references, associate with node
+		this.node = node;
+		this.lines = lines;
+		node.setGUIObject(this);
+
+		// create the output socket
+		Circle output = new Circle(Constants.NODE_RADIUS, 0, Constants.SOCKET_RADIUS, Constants.SOCKET_PAINT);
+		output.setStroke(Paint.valueOf("black"));
+		
+		// create input sockets
+		sockets = new Circle[GUI.resources.arity()];
+		for (int l = 0; l < sockets.length; l++) {
+			sockets[l] = new Circle(Constants.SOCKET_RADIUS, Constants.SOCKET_PAINT);
+			sockets[l].setStroke(Paint.valueOf("black"));
+			sockets[l].setId(String.valueOf(l));
+			// relocate them
+			Position.placeSocket(l, sockets[l]);
+			Position.connect(lines[l], (GUIGene) ((Gene) node.getConnection(l)).getGUIObject());
+		}
+		
+		// add elements
+		getChildren().addAll(sockets);
+		getChildren().add(output);
+		
+		// relocate node, add handlers
+		Position.place(this);
+		NodeHandlers.addHandlers(this);
+	}
+	
+	/**
+	 * @return the {@code Node} instance associated with this object.
+	 */
+	public Node getNode() {
+		return node;
+	}
+
+	/**
+	 * Associates this instance with a new node.
+	 * 
+	 * @param node the new node.
+	 */
+	void setNode(Node node) {
+		this.node = node;
+	}
+	
+	@Override
+	public Line[] getLines() {
+		return lines;
+	}
+	
+	/**
+	 * Returns one of this object's connection sockets. They are 
+	 * indexed in the same order as lines and the connections
+	 * they represent.
+	 * 
+	 * @param index the socket to return.
+	 * @return the indexed socket object.
+	 */
+	public Circle getSocket(int index) {
+		return sockets[index];
+	}
+	
+	/**
+	 * @return the entire {@code Socket} array.
+	 */
+	public Circle[] getSockets() {
+		return sockets;
+	}
+
+	@Override
+	public void setStateRecursively(GUIGeneState state) {
+		setState(state);
+		for (int i = 0; i < GUI.resources.arity(); i++) {
+			((GUIConnection) ((Gene) node.getConnection(i)).getGUIObject()).setStateRecursively(state);
+		}
+	}
+
+	@Override
+	protected void setLinesVisible(boolean value) {
+		for (int i = 0; i < lines.length; i++) {
+			lines[i].setVisible(value);
+		}
+	}
+
+	@Override
+	public void setLockRecursively(boolean value) {
+		setLock(value);
+		for (int i = 0; i < GUI.resources.arity(); i++) {
+			((GUIConnection) ((Gene) node.getConnection(i)).getGUIObject()).setLockRecursively(value);
+		}
+	}
+
+	@Override
+	public GUIConnection[] getConnections() {
+		GUIConnection[] connections = new GUIConnection[GUI.resources.arity()];
+		for (int c = 0; c < connections.length; c++) {
+			connections[c] = (GUIConnection) ((Gene) node.getConnection(c)).getGUIObject();
+		}
+		return connections;
+	}
+}
diff --git a/src/jcgp/gui/population/GUIOutput.java b/src/jcgp/gui/population/GUIOutput.java
new file mode 100644
index 0000000..f023d00
--- /dev/null
+++ b/src/jcgp/gui/population/GUIOutput.java
@@ -0,0 +1,79 @@
+package jcgp.gui.population;
+
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import jcgp.backend.population.Gene;
+import jcgp.backend.population.Output;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.constants.Position;
+import jcgp.gui.handlers.OutputHandlers;
+
+/**
+ * The GUI counterpart of {@link jcgp.backend.population.Output}. This is a 
+ * subclass of {@code GUIGene} which represents a chromosome output.
+ * 
+ * @author Eduardo Pedroni
+ */
+public class GUIOutput extends GUIGene implements GUIMutable {
+
+	private Output output;
+	private Line line;
+
+	/**
+	 * Instantiate {@code GUIOutput} given an {@code Output} and the line needed
+	 * to show its connection.
+	 * 
+	 * @param output the associated backend output.
+	 * @param line the line used to display connection.
+	 */
+	public GUIOutput(final Output output, Line line) {
+		super();
+		// store references, associate with backend object
+		this.output = output;
+		this.line = line;
+		output.setGUIObject(this);
+
+		// create input socket
+		Circle socket = new Circle(-Constants.NODE_RADIUS, 0, Constants.SOCKET_RADIUS, Constants.SOCKET_PAINT);
+		socket.setStroke(Paint.valueOf("black"));
+		socket.setId(String.valueOf(0));
+		Position.connect(line, (GUIGene) ((Gene) output.getSource()).getGUIObject());
+		getChildren().add(socket);
+
+		// relocate output, add handlers
+		Position.place(this);
+		OutputHandlers.addHandlers(this);
+	}
+
+	/**
+	 * @return the {@code Output} instance associated with this object.
+	 */
+	public Output getOutput() {
+		return output;
+	}
+	
+	/**
+	 * Associates this instance with a new output.
+	 * 
+	 * @param output the new output.
+	 */
+	void setOutput(Output output) {
+		this.output = output;
+	}
+
+	@Override
+	public Line[] getLines() {
+		return new Line[] {line};
+	}
+
+	@Override
+	protected void setLinesVisible(boolean value) {
+		line.setVisible(value);
+	}
+
+	@Override
+	public GUIConnection[] getConnections() {
+		return new GUIConnection[] {(GUIConnection) output.getGUIObject()};
+	}
+}
diff --git a/src/jcgp/gui/population/PopulationPane.java b/src/jcgp/gui/population/PopulationPane.java
new file mode 100644
index 0000000..51b5ba4
--- /dev/null
+++ b/src/jcgp/gui/population/PopulationPane.java
@@ -0,0 +1,75 @@
+package jcgp.gui.population;
+
+import javafx.scene.control.Tab;
+import javafx.scene.control.TabPane;
+import jcgp.JCGP;
+import jcgp.backend.modules.problem.TestCaseProblem;
+import jcgp.backend.modules.problem.TestCaseProblem.TestCase;
+import jcgp.gui.GUI;
+
+public class PopulationPane extends TabPane {
+	
+	private GUI gui;
+	private TestCase<Object> currentTestCase;
+	private boolean evaluating = false;
+	
+	public PopulationPane(GUI gui) {
+		super();
+		this.gui = gui;
+		setTabClosingPolicy(TabClosingPolicy.UNAVAILABLE);
+		remakeTabs();
+	}
+	
+	public void remakeTabs() {
+		getTabs().clear();
+		JCGP jcgp = gui.getExperiment();
+		
+		Tab tab;
+		ChromosomePane cp;
+		for (int i = 0; i < jcgp.getResources().populationSize(); i++) {
+			cp = new ChromosomePane(jcgp.getPopulation().get(i));
+			tab = new Tab("Chr " + i);
+			tab.setContent(cp);
+			getTabs().add(tab);
+		}
+	}
+		
+	public void updateGenes() {
+		if (evaluating) {
+			evaluateTestCase(currentTestCase);
+		}
+		for (int i = 0; i < getTabs().size(); i++) {
+			((ChromosomePane) getTabs().get(i).getContent()).updateGenes(gui.getExperiment().getPopulation().get(i));
+		}
+	}
+	
+	public void evaluateTestCase(TestCase<Object> testCase) {
+		if (gui.getExperiment().getProblem() instanceof TestCaseProblem && testCase != null) {
+			currentTestCase = testCase;
+			if (testCase.getInputs().length == gui.getExperiment().getResources().inputs()) {
+				evaluating = true;
+				for (int i = 0; i < getTabs().size(); i++) {
+					//((ChromosomePane) getTabs().get(i).getContent()).setInputs(testCase.getInputs());
+				}
+			} else {
+				throw new IllegalArgumentException("Test case has " + testCase.getInputs().length
+						+ " inputs and chromosome has " + gui.getExperiment().getResources().inputs());
+			}
+		}
+	}
+	
+	public void hideValues() {
+		evaluating = false;
+		for (int i = 0; i < getTabs().size(); i++) {
+			//((ChromosomePane) getTabs().get(i).getContent()).updateValues();
+		}
+	}
+
+	public boolean isEvaluating() {
+		return evaluating;
+	}
+
+	public void setEvaluating(boolean value) {
+		evaluating = value;
+	}
+}
diff --git a/src/jcgp/gui/settings/SettingsPane.java b/src/jcgp/gui/settings/SettingsPane.java
new file mode 100644
index 0000000..bad42cd
--- /dev/null
+++ b/src/jcgp/gui/settings/SettingsPane.java
@@ -0,0 +1,595 @@
+package jcgp.gui.settings;
+
+import java.io.File;
+import java.util.ArrayList;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.VBox;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.stage.FileChooser;
+import javafx.stage.FileChooser.ExtensionFilter;
+import jcgp.JCGP;
+import jcgp.backend.function.FunctionSet;
+import jcgp.backend.modules.es.EvolutionaryStrategy;
+import jcgp.backend.modules.mutator.Mutator;
+import jcgp.backend.modules.problem.Problem;
+import jcgp.backend.modules.problem.TestCaseProblem;
+import jcgp.backend.parameters.Parameter;
+import jcgp.gui.GUI;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.settings.parameters.GUIParameter;
+import jcgp.gui.settings.testcase.TestCaseTable;
+
+/**
+ * This is a fairly hefty class which encapsulates the entire right-hand
+ * control pane. It contains base parameters, module selectors and their
+ * associated parameters, flow controls and file loading/saving buttons.
+ * <br><br>
+ * A single instance of this class is used in {@code GUI}.
+ * 
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public class SettingsPane extends AnchorPane {
+	
+	/*
+	 * The primary containers, these make up each section of the settings pane.
+	 */
+	private VBox mainContainer;
+	private VBox baseParameterPane, eaPane, mutatorPane, problemPane;
+	private VBox nodeFunctions;
+	
+	// all buttons
+	private Button runPause = new Button("Run"), step = new Button("Step"), reset = new Button("Reset");
+	private Button loadParameters = new Button("Load parameters"), loadChromosome = new Button("Load chromosome"), saveChromosome = new Button("Save chromosome");
+	
+	// this is a list of parameters used for parameter validity checks
+	private ArrayList<GUIParameter<?>> parameters = new ArrayList<GUIParameter<?>>();
+	
+	// the test case table stage
+	private TestCaseTable testCaseTable;
+	
+	// a reference to the parent GUI
+	private GUI gui;
+	
+	private int currentArity;
+		
+	/**
+	 * Create a new instance of {@code SettingsPane} associated
+	 * with the specified {@code GUI} object.
+	 * 
+	 * @param gui a reference to this object's parent.
+	 */
+	public SettingsPane(GUI gui) {
+		super();
+		this.gui = gui;
+		
+		// acquire a reference to jcgp, for convenience
+		final JCGP jcgp = gui.getExperiment();
+		
+		// make the overarching container
+		mainContainer = new VBox(8);
+		mainContainer.setPadding(new Insets(5, Constants.RESIZE_MARGIN, 0, 2));
+		
+		setMinWidth(Constants.SETTINGS_MIN_WIDTH);
+		setPrefWidth(Constants.SETTINGS_MIN_WIDTH);
+		
+		// initialise all sub-divisions
+		initialiseBaseParameters(jcgp);
+		
+		initialiseEAParameters(jcgp);
+		
+		initialiseMutatorParameters(jcgp);
+		
+		initialiseProblemTypeParameters(jcgp, gui);
+		
+		createControls(gui);
+		
+		// prepare the scroll pane
+		ScrollPane scroll = new ScrollPane();
+		scroll.setFitToWidth(true);
+		scroll.setContent(mainContainer);
+		scroll.setStyle("-fx-background-color: #FFFFFF");
+		
+		// anchor the scroll pane to itself, bearing in mind the resize margin
+		AnchorPane.setTopAnchor(scroll, 0.0);
+		AnchorPane.setBottomAnchor(scroll, 0.0);
+		AnchorPane.setRightAnchor(scroll, 0.0);
+		AnchorPane.setLeftAnchor(scroll, Constants.RESIZE_MARGIN);
+		
+		// add the scroll pane, all done!
+		getChildren().add(scroll);
+	}
+
+	/**
+	 * Creates the base parameters pane
+	 * 
+	 * @param jcgp
+	 */
+	private void initialiseBaseParameters(JCGP jcgp) {
+		baseParameterPane = new VBox(2);
+		
+		Text header = new Text("Base Parameters");
+		header.setFont(Font.font("Arial", 14));
+		header.setUnderline(true);
+		
+		baseParameterPane.getChildren().add(header);
+
+		parameters.add(GUIParameter.create(jcgp.getResources().getRowsParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getColumnsParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getInputsParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getOutputsParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getLevelsBackParameter(), this));
+		
+		GUIParameter<?> gp = GUIParameter.create(jcgp.getResources().getPopulationSizeParameter(), this);
+		gp.setPadding(new Insets(0, 0, 10, 0));
+		parameters.add(gp);
+		
+		parameters.add(GUIParameter.create(jcgp.getResources().getCurrentGenerationParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getGenerationsParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getCurrentRunParameter(), this));
+		
+		gp = GUIParameter.create(jcgp.getResources().getRunsParameter(), this);
+		gp.setPadding(new Insets(0, 0, 10, 0));
+		parameters.add(gp);
+		
+		parameters.add(GUIParameter.create(jcgp.getResources().getSeedParameter(), this));
+		parameters.add(GUIParameter.create(jcgp.getResources().getReportIntervalParameter(), this));
+		
+		baseParameterPane.getChildren().addAll(parameters);
+		mainContainer.getChildren().add(baseParameterPane);
+	}
+
+	private void initialiseEAParameters(final JCGP jcgp) {
+		eaPane = new VBox(2);
+		
+		Text header = new Text("Evolutionary Strategy");
+		header.setFont(Font.font("Arial", 14));
+		header.setUnderline(true);
+		
+		final ComboBox<EvolutionaryStrategy> esCBox = new ComboBox<EvolutionaryStrategy>();
+		esCBox.getItems().addAll(jcgp.getEvolutionaryStrategies());
+		esCBox.getSelectionModel().select(jcgp.getEvolutionaryStrategy());
+		esCBox.prefWidthProperty().bind(mainContainer.widthProperty());
+		
+		final VBox eaParameters = new VBox(2);
+		
+		refreshParameters(jcgp.getEvolutionaryStrategy().getLocalParameters(), eaParameters);
+		
+		esCBox.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				jcgp.setEvolutionaryStrategy(esCBox.getSelectionModel().getSelectedIndex());
+				refreshParameters(esCBox.getSelectionModel().getSelectedItem().getLocalParameters(), eaParameters);
+				gui.flushConsole();
+			}
+		});
+		
+		eaPane.getChildren().addAll(header, esCBox, eaParameters);	
+		mainContainer.getChildren().add(eaPane);
+	}
+
+	private void initialiseMutatorParameters(final JCGP jcgp) {
+		mutatorPane = new VBox(2);
+		
+		Text header = new Text("Mutator");
+		header.setFont(Font.font("Arial", 14));
+		header.setUnderline(true);
+		
+		final ComboBox<Mutator> mutatorCBox = new ComboBox<Mutator>();
+		mutatorCBox.getItems().addAll(jcgp.getMutators());
+		mutatorCBox.getSelectionModel().select(jcgp.getMutator());
+		mutatorCBox.prefWidthProperty().bind(mainContainer.widthProperty());
+		
+		final VBox mutatorParameters = new VBox(2);
+		refreshParameters(jcgp.getMutator().getLocalParameters(), mutatorParameters);
+		
+		mutatorCBox.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				jcgp.setMutator(mutatorCBox.getSelectionModel().getSelectedIndex());
+				refreshParameters(mutatorCBox.getSelectionModel().getSelectedItem().getLocalParameters(), mutatorParameters);
+				gui.flushConsole();
+			}
+		});
+		
+		mutatorPane.getChildren().addAll(header, mutatorCBox, mutatorParameters);
+		mainContainer.getChildren().add(mutatorPane); 
+	}
+	
+	private void initialiseProblemTypeParameters(final JCGP jcgp, final GUI gui) {
+		updateArity();
+		
+		problemPane= new VBox(2);
+		
+		Text header = new Text("Problem Type");
+		header.setFont(Font.font("Arial", 14));
+		header.setUnderline(true);
+		
+		final ComboBox<Problem> problemCBox = new ComboBox<Problem>();
+		problemCBox.getItems().addAll(jcgp.getProblems());
+		problemCBox.getSelectionModel().select(jcgp.getProblem());
+		problemCBox.prefWidthProperty().bind(mainContainer.widthProperty());
+		
+		final VBox problemParameters = new VBox(2);
+		problemParameters.setPadding(new Insets(0, 0, 4, 0));
+		refreshParameters(jcgp.getProblem().getLocalParameters(), problemParameters);
+		
+		final HBox testCaseControlContainer = new HBox(2);
+		
+		final Button showTestCaseButton = makeTestCaseButton();
+		final Button loadProblemDataButton = makeLoadTestCaseButton();
+		HBox.setHgrow(showTestCaseButton, Priority.ALWAYS);
+		showTestCaseButton.setMaxWidth(Double.MAX_VALUE);
+		HBox.setHgrow(loadProblemDataButton, Priority.ALWAYS);
+		loadProblemDataButton.setMaxWidth(Double.MAX_VALUE);
+		
+		if (jcgp.getProblem() instanceof TestCaseProblem<?>) {
+			testCaseControlContainer.getChildren().addAll(showTestCaseButton, loadProblemDataButton);
+			remakeTestCaseTable();
+		} else {
+			testCaseControlContainer.getChildren().add(loadProblemDataButton);
+		}
+		
+		nodeFunctions = new VBox(2);
+		nodeFunctions.setPadding(new Insets(0, 0, 4, 0));
+		refreshFunctions();
+		
+		problemCBox.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				jcgp.setProblem(problemCBox.getSelectionModel().getSelectedIndex());
+				updateArity();
+				refreshParameters(jcgp.getProblem().getLocalParameters(), problemParameters);
+				if (testCaseTable != null) {
+					testCaseTable.close();
+				}
+				gui.setEvaluating(false);
+				refreshFunctions();
+				testCaseControlContainer.getChildren().clear();
+				if (jcgp.getProblem() instanceof TestCaseProblem) {
+					testCaseControlContainer.getChildren().addAll(showTestCaseButton, loadProblemDataButton);
+					remakeTestCaseTable();
+				} else {
+					testCaseControlContainer.getChildren().add(loadProblemDataButton);
+				}
+				gui.reset();
+			}
+		});
+		
+		problemPane.getChildren().addAll(header, problemCBox, problemParameters, nodeFunctions, testCaseControlContainer); 
+		mainContainer.getChildren().add(problemPane);
+		
+	}
+	
+	private Button makeLoadTestCaseButton() {
+		Button b = new Button("Load data");
+		b.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				FileChooser fc = new FileChooser();
+				fc.setTitle("Open problem file...");
+				fc.getExtensionFilters().add(new ExtensionFilter("CGP " + gui.getExperiment().getProblem() + " files", "*" + ((TestCaseProblem<?>) gui.getExperiment().getProblem()).getFileExtension()));
+				fc.getExtensionFilters().add(new ExtensionFilter("All files", "*.*"));
+				File chrFile = fc.showOpenDialog(gui.getStage());
+				if (chrFile != null) {
+					gui.getExperiment().loadProblemData(chrFile);
+					remakeTestCaseTable();
+					gui.reDraw();
+				}
+			}
+		});
+		return b;
+	}
+
+	private Button makeTestCaseButton() {
+		Button b = new Button("Show data");
+		b.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				testCaseTable.show(); 
+			}
+		});
+		return b;
+	}
+
+	private void createControls(final GUI gui) {
+		Text header = new Text("Experiment controls");
+		header.setFont(Font.font("Arial", 14));
+		header.setUnderline(true);
+		
+		final VBox controls = new VBox(2);
+		controls.setFillWidth(true);
+		
+		final HBox flowButtons = new HBox(2);
+		runPause.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {				
+				gui.runPause();
+			}
+		});
+		
+		step.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				gui.step();
+			}
+		});
+		
+		reset.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				gui.reset();
+			}
+		});
+		
+		HBox.setHgrow(runPause, Priority.ALWAYS);
+		runPause.setMaxWidth(Double.MAX_VALUE);
+		HBox.setHgrow(step, Priority.ALWAYS);
+		step.setMaxWidth(Double.MAX_VALUE);
+		HBox.setHgrow(reset, Priority.ALWAYS);
+		reset.setMaxWidth(Double.MAX_VALUE);
+		
+		flowButtons.getChildren().addAll(runPause, step, reset);
+		flowButtons.setPadding(new Insets(0, 0, 10, 0));
+		
+		loadParameters.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {				
+				FileChooser fc = new FileChooser();
+				fc.setTitle("Open .par file...");
+				fc.getExtensionFilters().add(new ExtensionFilter("CGP parameter files", "*.par"));
+				fc.getExtensionFilters().add(new ExtensionFilter("All files", "*.*"));
+				File parFile = fc.showOpenDialog(gui.getStage());
+				if (parFile != null) {
+					gui.getExperiment().loadParameters(parFile);
+					gui.reDraw();
+					refreshFunctions();
+				}
+				gui.flushConsole();
+			}
+		});
+		
+		loadChromosome.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				FileChooser fc = new FileChooser();
+				fc.setTitle("Load .chr file...");
+				fc.getExtensionFilters().add(new ExtensionFilter("CGP chromosome files", "*.chr"));
+				fc.getExtensionFilters().add(new ExtensionFilter("All files", "*.*"));
+				File chrFile = fc.showOpenDialog(gui.getStage());
+				if (chrFile != null) {
+					gui.getExperiment().loadChromosome(chrFile, gui.getChromosomeIndex());
+					gui.reDraw();
+				}
+				gui.flushConsole();
+			}
+		});
+		saveChromosome.setOnAction(new EventHandler<ActionEvent>() {
+			@Override
+			public void handle(ActionEvent event) {
+				FileChooser fc = new FileChooser();
+				fc.setTitle("Save .chr file...");
+				fc.getExtensionFilters().add(new ExtensionFilter("CGP chromosome files", "*.chr"));
+				fc.getExtensionFilters().add(new ExtensionFilter("All files", "*.*"));
+				File chrFile = fc.showSaveDialog(gui.getStage());
+				if (chrFile != null) {
+					gui.getExperiment().saveChromosome(chrFile, gui.getChromosomeIndex());
+				}
+				gui.flushConsole();
+			}
+		});
+		
+		HBox.setHgrow(loadParameters, Priority.ALWAYS);
+		loadParameters.setMaxWidth(Double.MAX_VALUE);
+		HBox.setHgrow(loadChromosome, Priority.ALWAYS);
+		loadChromosome.setMaxWidth(Double.MAX_VALUE);
+		HBox.setHgrow(saveChromosome, Priority.ALWAYS);
+		saveChromosome.setMaxWidth(Double.MAX_VALUE);
+		
+		controls.getChildren().addAll(header, flowButtons, loadParameters, loadChromosome, saveChromosome);
+		
+		mainContainer.getChildren().add(controls);	
+	}
+	
+	/**
+	 * Builds {@code GUIParameter}s and adds them to the provided {@code VBox}. 
+	 * The parameters built are taken from the specified list.
+	 *
+	 * @param newParameters the list of parameters to add.
+	 * @param container the container to add the parameters to.
+	 */
+	private void refreshParameters(ArrayList<Parameter<?>> newParameters, VBox container) {
+		// remove what is currently in the container from the parameter list
+		parameters.removeAll(container.getChildren());
+		// remove everything in the container
+		container.getChildren().clear();
+		// if there are parameters to add, add them all
+		if (newParameters != null) {
+			for (int i = 0; i < newParameters.size(); i++) {
+				// factory method returns the right subtype of GUIParameter
+				GUIParameter<?> guiParameter = GUIParameter.create(newParameters.get(i), this);
+				// make sure to add it to the parameter list as well
+				parameters.add(guiParameter);
+				container.getChildren().add(guiParameter);
+			}
+		}
+		// do a quick refresh just in case something is invalid
+		revalidateParameters();
+	}
+	
+	/**
+	 * This method handles a problem type change by updating the list of allowed
+	 * node functions.
+	 * <br><br>
+	 * It does so by creating new checkboxes for each function in the function set.
+	 */
+	private void refreshFunctions() {
+		// remove all current functions
+		nodeFunctions.getChildren().clear();
+		CheckBox checkBox;
+		// get a reference to the function set
+		final FunctionSet functionSet = gui.getExperiment().getResources().getFunctionSet();
+		for (int i = 0; i < functionSet.getTotalFunctionCount(); i++) {
+			// add a checkbox for each function
+			checkBox = new CheckBox(functionSet.getFunction(i).toString());
+			checkBox.setId(String.valueOf(i));
+			// make sure the selection matches the function set
+			checkBox.setSelected(functionSet.isEnabled(functionSet.getFunction(i)));
+			final int index = i;
+			// set listener so function set gets updated if the checkboxes change
+			checkBox.setOnAction(new EventHandler<ActionEvent>() {
+				@Override
+				public void handle(ActionEvent event) {
+					if (((CheckBox) event.getSource()).isSelected()) {
+						functionSet.enableFunction(index);
+					} else {
+						functionSet.disableFunction(index);
+					}
+					gui.updateFunctionSelector();
+					revalidateParameters();
+				}
+			});
+			// add the new checkbox
+			nodeFunctions.getChildren().add(checkBox);
+		}
+		// make sure function selector has all functions
+		gui.updateFunctionSelector();
+	}
+	
+	/**
+	 * @return true if the experiment is currently evolving something, false otherwise.
+	 */
+	public boolean isExperimentRunning() {
+		return gui.isWorking();
+	}
+	
+	/**
+	 * 
+	 * @return true if the experiment needs to be reset, false if otherwise.
+	 */
+	public boolean isResetRequired() {
+		for (GUIParameter<?> parameter : parameters) {
+			if (parameter.requiresReset()) {
+				return true;
+			}
+		}
+		if (arityChanged()) {
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * @return true if no parameters have their status set to ParameterStatus.INVALID.
+	 */
+	public boolean areParametersValid() {
+		for (GUIParameter<?> parameter : parameters) {
+			if (!parameter.isValid()) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Calls validate() on every parameter. This is called whenever a parameter changes,
+	 * so that other parameters update their status in case they were dependent on the
+	 * changed parameter.
+	 * <br><br>
+	 * This also disables the controls if a reset is necessary, preventing the experiment
+	 * from running until it has happened.
+	 */
+	public void revalidateParameters() {
+		boolean disableControls = false;
+		for (GUIParameter<?> parameter : parameters) {
+			parameter.validate();
+			if (parameter.requiresReset()) {
+				disableControls = true;
+			}
+		}
+		if (arityChanged()) {
+			disableControls = true;
+		}
+		
+		runPause.setDisable(disableControls);
+		step.setDisable(disableControls);
+	}
+	
+	/**
+	 * Calls applyValue() on every parameter. This is called when a reset occurs, so that
+	 * the new value will be used as a reference instead of the old reference value.
+	 * <br><br>
+	 * It also closes the test case table, just in case.
+	 */
+	public void applyParameters() {
+		for (GUIParameter<?> parameter : parameters) {
+			parameter.applyValue();
+		}
+		updateArity();
+		if (testCaseTable != null) {
+			testCaseTable.close();
+		}
+	}
+
+	/**
+	 * Updates all of the controls to their appropriate state based on the status of the
+	 * experiment, in order to prevent inappropriate operations if the experiment is
+	 * running or finished.
+	 * 
+	 * @param running true if the experiment is running.
+	 * @param finished true if the experiment is finished.
+	 */
+	public void updateControls(boolean running, boolean finished) {
+		baseParameterPane.setDisable(running);
+		eaPane.setDisable(running);
+		mutatorPane.setDisable(running);
+		problemPane.setDisable(running);
+		
+		runPause.setText(running ? "Pause" : "Run");
+		runPause.setDisable(finished);
+		step.setDisable(running || finished);
+		reset.setDisable(running);
+		
+		loadParameters.setDisable(running);
+		loadChromosome.setDisable(running);
+		saveChromosome.setDisable(running);
+		
+		testCaseTable.getTable().setDisable(running);
+	}
+	
+	private void remakeTestCaseTable() {
+		boolean wasShowing = false;
+		if (testCaseTable != null) {
+			wasShowing = testCaseTable.isShowing();
+			testCaseTable.close();
+		}
+		testCaseTable = new TestCaseTable((TestCaseProblem<Object>) gui.getExperiment().getProblem(), gui);
+		if (wasShowing) {
+			testCaseTable.show();
+		}
+	}
+	
+	public TestCaseTable getTestCaseTable() {
+		return testCaseTable;
+	}
+	
+	private void updateArity() {
+		currentArity = gui.getExperiment().getProblem().getFunctionSet().getMaxArity();
+	}
+	
+	private boolean arityChanged() {
+		return currentArity != gui.getExperiment().getProblem().getFunctionSet().getMaxArity();
+	}
+}
diff --git a/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java b/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java
new file mode 100644
index 0000000..a1f03fe
--- /dev/null
+++ b/src/jcgp/gui/settings/parameters/GUIBooleanParameter.java
@@ -0,0 +1,82 @@
+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.parameters.BooleanParameter;
+import jcgp.backend.parameters.ParameterStatus;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.settings.SettingsPane;
+
+/**
+ * This extension of @code{GUIParameter} uses a @code{CheckBox} to display
+ * the value of a @code{BooleanParameter}. It cannot be constructed
+ * directly - instead, use @code{GUIParameter.create()}.
+ * <br><br>
+ * See {@link GUIParameter} for more information.
+ * 
+ * @author Eduardo Pedroni
+ */
+public class GUIBooleanParameter extends GUIParameter<Boolean> {
+
+	private CheckBox checkBox;
+	
+	/**
+	 * This protected constructor is intended for use
+	 * by the factory method only.
+	 * 
+	 */
+	protected GUIBooleanParameter(BooleanParameter parameter, SettingsPane sp) {
+		super(parameter, sp);
+	}
+	
+	@Override
+	protected Control makeControl() {
+		checkBox = new CheckBox();
+		checkBox.setSelected(parameter.get());
+		
+		return checkBox;
+	}
+	
+	@Override
+	protected void setControlListeners() {
+		/* pass the CheckBox value back to the parameter whenever it gets
+		 * modified, provided the experiment isn't running */
+		checkBox.selectedProperty().addListener(new ChangeListener<Boolean>() {
+			@Override
+			public void changed(
+					ObservableValue<? extends Boolean> observable,
+					Boolean oldValue, Boolean newValue) {
+				if (!settingsPane.isExperimentRunning()) {
+					parameter.set(newValue);
+					settingsPane.revalidateParameters();
+				}
+			}
+		});
+	}
+	
+	@Override
+	protected void setValidityStyle() {
+		// update the Control's style and tooltip based on the status of the parameter
+		if (parameter.getStatus() == ParameterStatus.INVALID) {
+			checkBox.setStyle(Constants.BASE_CHECKBOX_STYLE + Constants.INVALID_PARAMETER_STYLE);
+			checkBox.setTooltip(tooltip);
+			tooltip.setText(parameter.getStatus().getDetails());
+		} else if (parameter.getStatus() == ParameterStatus.WARNING 
+				|| parameter.getStatus() == ParameterStatus.WARNING_RESET) {
+			checkBox.setStyle(Constants.BASE_CHECKBOX_STYLE + Constants.WARNING_PARAMETER_STYLE);
+			checkBox.setTooltip(tooltip);
+			tooltip.setText(parameter.getStatus().getDetails());
+		} else {
+			checkBox.setStyle(Constants.BASE_CHECKBOX_STYLE + Constants.VALID_PARAMETER_STYLE);
+			checkBox.setTooltip(null);
+		}
+	}
+
+	@Override
+	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
new file mode 100644
index 0000000..feee34c
--- /dev/null
+++ b/src/jcgp/gui/settings/parameters/GUIDoubleParameter.java
@@ -0,0 +1,110 @@
+package jcgp.gui.settings.parameters;
+
+import java.text.DecimalFormat;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.Pos;
+import javafx.scene.control.Control;
+import javafx.scene.control.TextField;
+import jcgp.backend.parameters.DoubleParameter;
+import jcgp.backend.parameters.ParameterStatus;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.settings.SettingsPane;
+
+/**
+ * This extension of @code{GUIParameter} uses a @code{TextField} to display
+ * the value of a @code{DoubleParameter}. It cannot be constructed
+ * directly - instead, use @code{GUIParameter.create()}.
+ * <br><br>
+ * See {@link GUIParameter} for more information.
+ * 
+ * @author Eduardo Pedroni
+ */
+public class GUIDoubleParameter extends GUIParameter<Number> {
+
+	private TextField textField;
+	private DecimalFormat decimalFormat;
+	
+	/**
+	 * This protected constructor is intended for use
+	 * by the factory method only.
+	 * 
+	 */
+	protected GUIDoubleParameter(DoubleParameter parameter, SettingsPane sp) {
+		super(parameter, sp);
+	}
+	
+	@Override
+	protected Control makeControl() {
+		// we use a text field, and a formatting class to enforce decimals
+		decimalFormat = new DecimalFormat();
+		decimalFormat.setMaximumFractionDigits(10);
+		textField = new TextField(decimalFormat.format(parameter.get().doubleValue()));
+		textField.setStyle(Constants.VALID_PARAMETER_STYLE);
+		textField.setAlignment(Pos.CENTER_RIGHT);
+		textField.prefWidthProperty().bind(widthProperty().divide(2));
+		return textField;
+	}
+
+	@Override
+	protected void setControlListeners() {
+		/* pass the TextField value back to the parameter whenever it gets
+		 * modified, provided it is not empty, the experiment isn't running
+		 * and it matches the double-precision regex filter */
+		textField.textProperty().addListener(new ChangeListener<String>() {
+			@Override
+			public void changed(
+					ObservableValue<? extends String> observable,
+					String oldValue, String newValue) {
+				if (!settingsPane.isExperimentRunning()) {
+					if (newValue.matches("^[-+]?[0-9]*\\.?[0-9]+$")) {
+						if (!newValue.isEmpty()) {
+							double value = Double.parseDouble(newValue);
+							parameter.set(value);
+							settingsPane.revalidateParameters();
+						}
+					} else {
+						refreshValue();
+					}
+				}
+			}
+		});
+		/* if the TextField loses focus and is empty, set it to the current
+		 * value of the parameter */
+		textField.focusedProperty().addListener(new ChangeListener<Boolean>() {
+			@Override
+			public void changed(
+					ObservableValue<? extends Boolean> observable,
+					Boolean oldValue, Boolean newValue) {
+				if (!newValue) {
+					refreshValue();
+				}
+			}
+		});
+	}
+
+	@Override
+	protected void setValidityStyle() {
+		// update the Control's style and tooltip based on the status of the parameter
+		if (parameter.getStatus() == ParameterStatus.INVALID) {
+			textField.setStyle(Constants.BASE_TEXT_STYLE + Constants.INVALID_PARAMETER_STYLE);
+			textField.setTooltip(tooltip);
+			tooltip.setText(parameter.getStatus().getDetails());
+		} else if (parameter.getStatus() == ParameterStatus.WARNING || parameter.getStatus() ==  ParameterStatus.WARNING_RESET) {
+			textField.setStyle(Constants.BASE_TEXT_STYLE + Constants.WARNING_PARAMETER_STYLE);
+			textField.setTooltip(tooltip);
+			tooltip.setText(parameter.getStatus().getDetails());
+		} else {
+			textField.setStyle(Constants.BASE_TEXT_STYLE + Constants.VALID_PARAMETER_STYLE);
+			textField.setTooltip(null);
+		}
+	}
+	
+	@Override
+	public void refreshValue() {
+		if (!textField.isFocused()) {
+			textField.setText(decimalFormat.format(parameter.get().doubleValue()));
+		}
+	}
+}
diff --git a/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java b/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java
new file mode 100644
index 0000000..bcfbe50
--- /dev/null
+++ b/src/jcgp/gui/settings/parameters/GUIIntegerParameter.java
@@ -0,0 +1,107 @@
+package jcgp.gui.settings.parameters;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.Pos;
+import javafx.scene.control.Control;
+import javafx.scene.control.TextField;
+import jcgp.backend.parameters.IntegerParameter;
+import jcgp.backend.parameters.ParameterStatus;
+import jcgp.gui.constants.Constants;
+import jcgp.gui.settings.SettingsPane;
+
+/**
+ * This extension of @code{GUIParameter} uses a @code{TextField} to display
+ * the value of a @code{IntegerParameter}. It cannot be constructed
+ * directly - instead, use @code{GUIParameter.create()}.
+ * <br><br>
+ * See {@link GUIParameter} for more information.
+ * 
+ * @author Eduardo Pedroni
+ */
+public class GUIIntegerParameter extends GUIParameter<Number> {
+	
+	private TextField textField;
+	
+	/**
+	 * This protected constructor is intended for use
+	 * by the factory method only.
+	 * 
+	 */
+	protected GUIIntegerParameter(IntegerParameter parameter, SettingsPane sp) {
+		super(parameter, sp);
+	}
+
+	@Override
+	protected Control makeControl() {
+		// this uses a text field
+		textField = new TextField(String.valueOf(parameter.get()));
+		textField.setStyle(Constants.VALID_PARAMETER_STYLE);
+		textField.setAlignment(Pos.CENTER_RIGHT);
+		textField.prefWidthProperty().bind(widthProperty().divide(2));
+		
+		return textField;
+	}
+
+	@Override
+	protected void setControlListeners() {
+		/* pass the TextField value back to the parameter whenever it gets
+		 * modified, provided it is not empty, the experiment isn't running
+		 * and it matches the integer regex pattern */
+		textField.textProperty().addListener(new ChangeListener<String>() {
+			@Override
+			public void changed(
+					ObservableValue<? extends String> observable,
+					String oldValue, String newValue) {
+				if (!settingsPane.isExperimentRunning()) {
+					if (newValue.matches("[0-9]*")) {
+						if (!newValue.isEmpty()) {
+							int value = Integer.parseInt(newValue);
+							parameter.set(value);
+							settingsPane.revalidateParameters();
+						}
+					} else {
+						refreshValue();
+					}
+				}
+			}
+		});
+		/* if the TextField loses focus and is empty, set it to the current
+		 * value of the parameter */
+		textField.focusedProperty().addListener(new ChangeListener<Boolean>() {
+			@Override
+			public void changed(
+					ObservableValue<? extends Boolean> observable,
+					Boolean oldValue, Boolean newValue) {
+				if (!newValue) {
+					refreshValue();
+				}
+			}
+		});
+	}
+	
+	@Override
+	protected void setValidityStyle() {
+		// update the Control's style and tooltip based on the status of the parameter
+		if (parameter.getStatus() == ParameterStatus.INVALID) {
+			textField.setStyle(Constants.BASE_TEXT_STYLE + Constants.INVALID_PARAMETER_STYLE);
+			textField.setTooltip(tooltip);
+			tooltip.setText(parameter.getStatus().getDetails());
+		} else if (parameter.getStatus() == ParameterStatus.WARNING 
+				|| parameter.getStatus() ==  ParameterStatus.WARNING_RESET) {
+			textField.setStyle(Constants.BASE_TEXT_STYLE + Constants.WARNING_PARAMETER_STYLE);
+			textField.setTooltip(tooltip);
+			tooltip.setText(parameter.getStatus().getDetails());
+		} else {
+			textField.setStyle(Constants.BASE_TEXT_STYLE + Constants.VALID_PARAMETER_STYLE);
+			textField.setTooltip(null);
+		}
+	}
+
+	@Override
+	public void refreshValue() {
+		if (!textField.isFocused()) {
+			textField.setText(parameter.get().toString());
+		}
+	}
+}
diff --git a/src/jcgp/gui/settings/parameters/GUIParameter.java b/src/jcgp/gui/settings/parameters/GUIParameter.java
new file mode 100644
index 0000000..59aecf6
--- /dev/null
+++ b/src/jcgp/gui/settings/parameters/GUIParameter.java
@@ -0,0 +1,235 @@
+package jcgp.gui.settings.parameters;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javafx.application.Platform;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.Pos;
+import javafx.scene.control.Control;
+import javafx.scene.control.Label;
+import javafx.scene.control.Tooltip;
+import javafx.scene.layout.HBox;
+import jcgp.backend.parameters.BooleanParameter;
+import jcgp.backend.parameters.DoubleParameter;
+import jcgp.backend.parameters.IntegerParameter;
+import jcgp.backend.parameters.Parameter;
+import jcgp.backend.parameters.ParameterStatus;
+import jcgp.gui.settings.SettingsPane;
+
+/**
+ * 
+ * This is the base class for all @code{GUIParameter}s. Using the factory method @code{GUIParameter.create()}
+ * generates an appropriate instance of this class for the specified parameter.
+ * <br><br>
+ * A @code{GUIParameter} is an @code{HBox} containing a @code{Text} for the parameter name 
+ * and a @code{Control} for interaction.
+ * It stores an instance of its associated @code{Parameter} object and also contains a @code{Tooltip} for 
+ * displaying status information.
+ * <br><br>
+ * Monitor parameters are updated automatically and have their @code{Control} disabled so
+ * that no changes 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.
+ * 
+ * @see Parameter
+ * @author Eduardo Pedroni
+ * @param <T> the parameter data type
+ */
+public abstract class GUIParameter<T> extends HBox {
+	
+	private Label name;
+	private Control valueControl;
+	
+	protected SettingsPane settingsPane;
+	protected Tooltip tooltip;
+	protected Parameter<T> 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);
+	
+	/**
+	 * 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;
+	
+	/**
+	 * This protected template constructor contains the common elements to all
+	 * @code{GUIParameter}s and should be invoked by any subclasses using @code{super()}. It
+	 * defers the creation of the parameter {@code Control} object to the subclass
+	 * currently being built (which in turn is defined by the factory method).
+	 * 
+	 * @param parameter a @code{Parameter} for which to generate a @code{GUIParameter}.
+	 * @param sp a reference to the @code{SettingsPane}.
+	 */
+	protected GUIParameter(Parameter<T> parameter, final SettingsPane settingsPane) {
+		this.parameter = parameter;
+		this.referenceValue = parameter.get();
+		
+		this.settingsPane = settingsPane;
+		
+		setAlignment(Pos.CENTER_LEFT);
+		setSpacing(5);
+		
+		name = new Label(parameter.toString());
+		// set text width to half of the total width of the GUIParameter
+		name.prefWidthProperty().bind(widthProperty().divide(2));
+		
+		// the tooltip is the hover-over label containing status information, when appropriate
+		tooltip = new Tooltip();
+		tooltip.setSkin(null);
+		
+		valueControl = makeControl();
+		
+		// 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();
+		}
+		
+		getChildren().addAll(name, valueControl);
+	}
+	
+	/**
+	 * Factory method to create @code{GUIParameter}s from @code{Parameter}s. 
+	 * Use this to create an appropriate @code{GUIParameter} from any instance of @code{Parameter},
+	 * rather than manually downcasting the @code{Parameter} object every time.
+	 * 
+	 * @param parameter a parameter for which to generate a @code{GUIParameter}.
+	 * @param sp a reference to the @code{SettingsPane}.
+	 * @return an appropriate instance of @code{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.
+	 * <br><br>
+	 * 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<Object>() {
+			@Override
+			public void changed(
+					ObservableValue<? extends Object> observable,
+					Object oldValue, Object newValue) {
+				// only do this if the experiment is running
+				if (settingsPane.isExperimentRunning() || !isFocused()) {
+					/* 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);
+							}
+						});
+					}
+				}
+			}
+		});
+	}
+	
+	/**
+	 * @return true if the current value of the parameter does not prevent the 
+	 * experiment from running.
+	 */
+	public boolean isValid() {
+		return parameter.getStatus() != ParameterStatus.INVALID;
+	}
+	
+	/**
+	 * Force the parameter to validate its current value, and apply the associated
+	 * style to the @code{GUIParameter}.
+	 */
+	public void validate() {
+		parameter.validate(parameter.get());
+		setValidityStyle();
+	}
+	
+	/**
+	 * 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 @code{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 @code{Control} object used to control the parameter.
+	 * <br><br>
+	 * Implementations of @code{GUIParameter} must override this method and return 
+	 * a @code{Control} appropriate to the type of parameter. This will typically be
+	 * done by referencing the protected field @code{GUIParameter.parameter}.
+	 * 
+	 * @return the Control object to be added to the GUIParameter.
+	 */
+	protected abstract Control makeControl();
+	
+	/**
+	 * Adds the necessary handlers to the @code{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.
+	 */
+	protected abstract void setControlListeners();
+	
+	/**
+	 * This method is called to style the @code{GUIParameter} according to the status of
+	 * the parameter, which can be obtained with @code{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.
+	 * 
+	 * @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();
+}
diff --git a/src/jcgp/gui/settings/testcase/TestCaseTable.java b/src/jcgp/gui/settings/testcase/TestCaseTable.java
new file mode 100644
index 0000000..605b75e
--- /dev/null
+++ b/src/jcgp/gui/settings/testcase/TestCaseTable.java
@@ -0,0 +1,124 @@
+package jcgp.gui.settings.testcase;
+
+import java.util.ArrayList;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ObservableList;
+import javafx.event.EventHandler;
+import javafx.scene.Scene;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableColumn.CellDataFeatures;
+import javafx.scene.control.TableView;
+import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+import javafx.util.Callback;
+import jcgp.backend.modules.problem.TestCaseProblem;
+import jcgp.backend.modules.problem.TestCaseProblem.TestCase;
+import jcgp.backend.resources.Resources;
+import jcgp.gui.GUI;
+
+/**
+ * This is a test case table. For problems that have test cases, 
+ * this table shows the test case inputs and outputs. Clicking on 
+ * a test case (one is shown per row) applies the values to all 
+ * chromosome inputs shows the calculated values throughout the chromosome.
+ * 
+ * @author Eduardo Pedroni
+ *
+ */
+public class TestCaseTable extends Stage {
+
+	private TableView<TestCase<Object>> table;
+
+	/**
+	 * Make a new instance of {@code TestCaseTable}.
+	 * 
+	 * @param testCaseProblem the {@code TestCaseProblem} whose data must be displayed.
+	 * @param gui a reference to the GUI.
+	 */
+	public TestCaseTable(final TestCaseProblem<Object> testCaseProblem, final GUI gui) {
+		super();
+		
+		Resources resources = gui.getExperiment().getResources();
+		
+		// create the actual table view
+		table = new TableView<TestCase<Object>>();
+		// get test cases from problem
+		ObservableList<TestCase<Object>> testCaseList = testCaseProblem.getTestCases();
+		
+		// prepare input and output columns
+		ArrayList<TableColumn<TestCase<Object>, String>> inputs = new ArrayList<TableColumn<TestCase<Object>, String>>(resources.inputs());
+		ArrayList<TableColumn<TestCase<Object>, String>> outputs = new ArrayList<TableColumn<TestCase<Object>, String>>(resources.outputs());
+
+		// create input columns
+		TableColumn<TestCase<Object>, String> tc;
+		for (int i = 0; i < resources.inputs(); i++) {
+			tc = new TableColumn<TestCase<Object>, String>("I: " + i);
+			inputs.add(tc);
+			final int index = i;
+			tc.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<TestCase<Object>,String>, ObservableValue<String>>() {
+				@Override
+				public ObservableValue<String> call(CellDataFeatures<TestCase<Object>, String> param) {
+					// create a new string property and give it the test case value, no need for dynamic binding - this wont change often
+					return new SimpleStringProperty(param.getValue().getInputs()[index].toString());
+				}
+			});
+			tc.setSortable(false);
+			// set column width so all columns are distributed across the width of the stage
+			tc.prefWidthProperty().bind(table.widthProperty().divide(resources.inputs() + resources.outputs()));
+		}
+		
+		// create output columns
+		for (int o = 0; o < resources.outputs(); o++) {
+			tc = new TableColumn<TestCase<Object>, String>("O: " + o);
+			outputs.add(tc);
+			final int index = o;
+			tc.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<TestCase<Object>,String>, ObservableValue<String>>() {
+				@Override
+				public ObservableValue<String> call(CellDataFeatures<TestCase<Object>, String> param) {
+					// create a new string property and give it the test case value, no need for dynamic binding - this wont change often
+					return new SimpleStringProperty(param.getValue().getOutputs()[index].toString());
+				}
+			});
+			tc.setSortable(false);
+			// set column width so all columns are distributed across the width of the stage
+			tc.prefWidthProperty().bind(table.widthProperty().divide(resources.inputs() + resources.outputs()));
+		}
+		
+		// add created columns
+		table.getColumns().addAll(inputs);
+		table.getColumns().addAll(outputs);
+		
+		// populate table with actual data
+		table.setItems(testCaseList);
+		
+		// apply test case values when a new test case is selected
+		table.getSelectionModel().selectedItemProperty().addListener(new ChangeListener<TestCase<Object>>() {
+			@Override
+			public void changed(ObservableValue<? extends TestCase<Object>> observable,	TestCase<Object> oldValue, TestCase<Object> newValue) {
+				gui.evaluateTestCase(newValue);
+			}
+		});
+		
+		// when the stage is closed, clear the selection
+		// this doesn't work if the stage is closed by the program for some reason...
+		setOnCloseRequest(new EventHandler<WindowEvent>() {
+			@Override
+			public void handle(WindowEvent event) {
+				gui.hideGeneValues();
+				table.getSelectionModel().clearSelection();
+			}
+		});
+		
+		setScene(new Scene(table));
+	}
+
+	/**
+	 * @return a reference to the actual table of test cases.
+	 */
+	public TableView<TestCase<Object>> getTable() {
+		return table;
+	}
+}