diff --git a/config/gui_default.cfg b/config/gui_default.cfg
index c4f5f3ca..32570f71 100644
--- a/config/gui_default.cfg
+++ b/config/gui_default.cfg
@@ -19,7 +19,7 @@
 		"VisualizerPanel": {
 			"Width": 1500,
 			"Height": 800,
-			"InnerWidth": 1600,
+			"InnerWidth": 2000,
 			"InnerHeight": 1000
 		},
 		"Buttons": {
@@ -36,7 +36,7 @@
 			"Name": "Control & Statistics",
 			"Width": 330,
 			"Height": 550,
-			"DateFormat": "hh:mm:ss:SS",
+			"DateFormat": "HH:mm:ss",
 
 			"ShowTimePanel": true,
 			"TimeSliderButtons": {
@@ -146,12 +146,12 @@
 					"LinesPointSize": 5,
 					"PaintFill": false,
 					"VerticalBarSize": 5,
-					"xAxisTitle": "Timestamp",
+					"xAxisTitle": "",
 					"xAxisType": "date",
-					"xAxisFormat": "hh:mm:ss:SS",
+					"xAxisFormat": "HH:mm:ss",
 					"xAxisOffset": 0.2,
-					"y1AxisTitle": "y1",
-					"y2AxisTitle": "y2"
+					"y1AxisTitle": "",
+					"y2AxisTitle": ""
 				},
 				"Legend": {
 					"Width": 190,
@@ -179,7 +179,9 @@
 				"MenuBar": {
 					"Width": 635,
 					"Height": 50,
+					"visible": true,
 					"showIntervalPanel": true,
+					"connected": true,
 					"showXOptionsPanel": true,
 					"showYOptionsPanel": true,
 					"showCoordsPanel": true,
@@ -221,10 +223,10 @@
 					"PaintFill": false,
 					"VerticalBarSize": 5,
 					"xAxisOffset": 0.2,
-					"x1AxisTitle": "x1",
-					"x2AxisTitle": "x2",
-					"y1AxisTitle": "y1",
-					"y2AxisTitle": "y2"
+					"x1AxisTitle": "",
+					"x2AxisTitle": "",
+					"y1AxisTitle": "",
+					"y2AxisTitle": ""
 				},
 				"Legend": {
 					"Width": 190,
@@ -252,6 +254,7 @@
 				"MenuBar": {
 					"Width": 635,
 					"Height": 50,
+					"visible": true,
 					"showIntervalPanel": true,
 					"showXOptionsPanel": true,
 					"showYOptionsPanel": true,
@@ -286,6 +289,71 @@
 					}
 				}
 			}
-		}
+		},
+		"LabelVisualizerConfigs": {
+			"LabelVisualizer1": {
+				"Name": "Label Visualizer 1",
+				"TraceLength": 1000,
+				"TraceModeLtd": true,	
+				
+				"AdditionPolicy": "all",
+				"AdditionList": ["labeler0.type0", "labeler0.type1"],
+				
+				"position": {
+					"x": 2,
+					"y": 0,
+					"rowspan": 1,
+					"colspan": 1
+				},
+				"Chart": {
+					"Width": 450,
+					"Height": 140,
+					"BarThickness": 0.7,
+					"xAxisTitle": "Timestamp",
+					"xAxisType": "date",
+					"xAxisFormat": "HH:mm:ss",
+					"y1AxisTitle": "Labels",
+				},
+				"Legend": {
+					"Width": 190,
+					"Height": 150,
+
+					"LegendItem": {
+						"Width": 165,
+						"Height": 40,
+						"Button_Width": 20,
+						"Button_Height": 20,
+						"ButtonPanel_Width": 100,
+						"ButtonPanel_Height": 20,
+						"NameLabel_Width": 160,
+						"NameLabel_Height": 16,
+						"ValueLabel_Width": 60,
+						"ValueLabel_Height": 20,
+						"ValueFont": {
+							"Name": "Dialog",
+							"Style": "PLAIN",
+							"Size": 9,
+							"Color": "BLACK"
+						}
+					}
+				},
+				"MenuBar": {
+					"Width": 635,
+					"Height": 50,
+					"visible": false,
+					"showIntervalPanel": true,
+					"connected": true,
+					"showXOptionsPanel": true,
+					"showYOptionsPanel": false,
+					"showCoordsPanel": true,
+					"CoordsFont": {
+						"Name": "Dialog",
+						"Style": "PLAIN",
+						"Size": 11,
+						"Color": "BLACK"
+					}
+				},
+			}
+		},
 	}
 }
\ No newline at end of file
diff --git a/config/gui_min_lab.cfg b/config/gui_min_lab.cfg
new file mode 100644
index 00000000..bc90c2e0
--- /dev/null
+++ b/config/gui_min_lab.cfg
@@ -0,0 +1,61 @@
+{
+    "MainDisplayConfig": {
+        "Name": "DNA - Dynamic Network Analyzer",
+        "LiveDisplayMode": false,
+        "DefaultDir": "data/test123/run.0/", 
+
+		"Width": 1680,
+		"Height": 800,
+		
+		"VisualizerPanel": {
+			"Width": 1000,
+			"Height": 800,
+			"InnerWidth": 900,
+			"InnerHeight": 1600
+		},
+
+		
+        "StatsDisplayConfig": {
+        },
+
+        "MetricVisualizerConfigs": {
+            "MetricVisualizer1": {
+                "Name": "Metric Visualizer 1",
+                "position": {
+                    "x": 0,
+                    "y": 0,
+                },
+                
+                "VisualizerConfig": {
+					"SingleConfigs": {
+						"inDegreeHosts": {
+							"Type": "MetricVisualizerItem",
+							"Name": "DegreeDistributionR-HOST.InDegreeDistribution_95p",
+							"DisplayMode": "linespoint",
+							"yAxis": "y1",
+							"visible": true,
+						}
+					}
+				}
+            }
+        },
+        "MultiScalarVisualizerConfigs": {
+            "MultiScalarVisualizer1": {
+                "Name": "MultiScalar Visualizer 1",
+                "position": {
+                    "x": 0,
+                    "y": 2,
+                }
+            }
+        },
+        "LabelVisualizerConfigs": {
+        	"LabelVisualizer1": {
+        		"Name": "Label Visualizer 2",
+        		"position": {
+        			"x": 0,
+        			"y": 1,
+        		}
+        	}
+        }
+    }
+}
diff --git a/config/gvis/gids.cfg b/config/gvis/gids.cfg
new file mode 100644
index 00000000..2ba7001f
--- /dev/null
+++ b/config/gvis/gids.cfg
@@ -0,0 +1,25 @@
+{
+	"GraphPanelConfig": {
+		"Width": 1024, 
+		"Height": 768,
+	
+		"TimestampFormat": "HH:mm:ss",
+		"TimestampOffset": -7200,
+		"TimestampInSeconds": true,
+
+		"StatPanelEnabled": true,
+		"TextPanelEnabled": true,
+	
+		"RulesConfig": {
+			"dna.visualization.graph.rules.nodes.NetworkNodeStyles": {},
+			"dna.visualization.graph.rules.nodes.NodeSizeByDegree": {
+				"Name": "defaultNodeSizeByDegree",
+				"Growth": 0.3,
+				"Enabled": true,
+			},
+			"dna.visualization.graph.rules.edges.EdgeWeightLabel": {
+				"label": "w=$weight$",
+			},
+		}
+	}
+}
\ No newline at end of file
diff --git a/config/vis/util.properties b/config/vis/util.properties
index 1550a978..39964dfb 100644
--- a/config/vis/util.properties
+++ b/config/vis/util.properties
@@ -2,6 +2,13 @@
 ## VISUALIZATION UTILITY OPTIONS
 ########################################
 
+
+## TIMESTAMP INTERPRETATION SETTINGS ###
+
+## todo: put these in actual vis config
+VISUALIZATION_TIMESTAMP_AS_SECOND = true
+VISUALIZATION_TIMESTAMP_OFFSET = -7200
+
 ## SCREENSHOT SETTINGS #################
 VIS_SCREENSHOT_DIR = images/
 VIS_SCREENSHOT_FORMAT = png
diff --git a/src/dna/graph/generators/network/NetflowBatch.java b/src/dna/graph/generators/network/NetflowBatch.java
index e97de852..dada2337 100644
--- a/src/dna/graph/generators/network/NetflowBatch.java
+++ b/src/dna/graph/generators/network/NetflowBatch.java
@@ -726,4 +726,12 @@ public String getKey(Integer mapping) {
 
 		return "unknown";
 	}
+	
+	public void setMap(HashMap<String, Integer> map) {
+		this.map = map;
+	}
+	
+	public HashMap<String, Integer> getMap() {
+		return this.map;
+	}
 }
diff --git a/src/dna/graph/generators/network/NetflowGraph.java b/src/dna/graph/generators/network/NetflowGraph.java
new file mode 100644
index 00000000..f9b9c9e7
--- /dev/null
+++ b/src/dna/graph/generators/network/NetflowGraph.java
@@ -0,0 +1,122 @@
+package dna.graph.generators.network;
+
+import java.io.IOException;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+import org.joda.time.DateTime;
+
+import dna.graph.Graph;
+import dna.graph.datastructures.GraphDataStructure;
+import dna.graph.edges.network.UpdateEvent;
+import dna.io.network.NetworkEvent;
+import dna.io.network.netflow.NetflowEvent.NetflowDirection;
+import dna.io.network.netflow.NetflowEvent.NetflowEventField;
+import dna.io.network.netflow.NetflowEventReader;
+import dna.io.network.netflow.darpa.DarpaNetflowReader;
+import dna.updates.batch.Batch;
+import dna.util.network.NetflowAnalysis.EdgeWeightValue;
+import dna.util.network.NetflowAnalysis.NodeWeightValue;
+import dna.visualization.graph.rules.nodes.NetworkNodeStyles;
+
+public class NetflowGraph extends NetworkGraph {
+
+	private NetflowEventReader reader;
+	private NetflowBatch batchGenerator;
+
+	private int batchLengthSeconds;
+	private int edgeLifeTimeSeconds;
+
+	private NetflowEventField[][] edges;
+	private NetflowDirection[] edgeDirections;
+	private EdgeWeightValue[] edgeWeights;
+	private NodeWeightValue[] nodeWeights;
+
+	private DateTime initDateTime;
+	private DateTime firstDateTime;
+
+	private Graph graph;
+
+	public NetflowGraph(GraphDataStructure gds, long timestampInit, long maximumTimestamp, String dir, String filename,
+			int batchLengthSeconds, int edgeLifeTimeSeconds, NetflowEventField[][] edges,
+			NetflowDirection[] edgeDirections, EdgeWeightValue[] edgeWeights, NodeWeightValue[] nodeWeights)
+			throws IOException, ParseException {
+		this(gds, timestampInit, maximumTimestamp, dir, filename, batchLengthSeconds, edgeLifeTimeSeconds, true, true,
+				0, edges, edgeDirections, edgeWeights, nodeWeights);
+	}
+
+	public NetflowGraph(GraphDataStructure gds, long timestampInit, long maximumTimestamp, String dir, String filename,
+			int batchLengthSeconds, int edgeLifeTimeSeconds, boolean removeZeroDegreeNodes,
+			boolean removeZeroWeightEdges, int dataOffsetSeconds, NetflowEventField[][] edges,
+			NetflowDirection[] edgeDirections, EdgeWeightValue[] edgeWeights, NodeWeightValue[] nodeWeights)
+			throws IOException, ParseException {
+		super("NetflowGraph", gds, timestampInit);
+
+		this.batchLengthSeconds = batchLengthSeconds;
+		this.edgeLifeTimeSeconds = edgeLifeTimeSeconds;
+		this.edges = edges;
+		this.edgeDirections = edgeDirections;
+		this.edgeWeights = edgeWeights;
+		this.nodeWeights = nodeWeights;
+
+		this.initDateTime = new DateTime(TimeUnit.SECONDS.toMillis(this.timestampInit));
+		this.firstDateTime = new DateTime(TimeUnit.SECONDS.toMillis(this.timestampInit - edgeLifeTimeSeconds));
+
+		this.reader = new DarpaNetflowReader(dir, filename);
+		this.reader.setBatchIntervalSeconds(batchLengthSeconds);
+		this.reader.setEdgeLifeTimeSeconds(edgeLifeTimeSeconds);
+		this.reader.setRemoveZeroDegreeNodes(removeZeroDegreeNodes);
+		this.reader.setRemoveZeroWeightEdges(removeZeroWeightEdges);
+		this.reader.setDataOffset(this.reader.getDataOffset() + dataOffsetSeconds);
+		this.reader.setMinimumTimestamp(this.firstDateTime);
+		this.reader.setMaximumTimestamp(new DateTime(TimeUnit.SECONDS.toMillis(maximumTimestamp)));
+
+		this.batchGenerator = new NetflowBatch("temp", reader, edges, edgeDirections, edgeWeights, nodeWeights);
+
+		// set batch-generator for mapping retrieval
+		NetworkNodeStyles.netflowBatchGenerator = (NetflowBatch) this.batchGenerator;
+
+		this.graph = generateGraph();
+	}
+
+	private Graph generateGraph() {
+		Graph g = this.newGraphInstance();
+		g.setTimestamp(TimeUnit.MILLISECONDS.toSeconds(this.firstDateTime.getMillis()));
+
+		DateTime simTime = this.firstDateTime;
+
+		while (simTime.isBefore(this.initDateTime)) {
+			ArrayList<NetworkEvent> events = this.reader.getEventsUntil(simTime);
+			if (events.size() > 0) {
+				Batch b = this.batchGenerator.craftBatch(g, simTime, events, new ArrayList<UpdateEvent>(0), null);
+				b.apply(g);
+			}
+			simTime = simTime.plusSeconds(this.batchLengthSeconds);
+		}
+
+		ArrayList<NetworkEvent> events = this.reader.getEventsUntil(this.initDateTime);
+		if (events.size() > 0) {
+			Batch b = this.batchGenerator.craftBatch(g, this.initDateTime, events, new ArrayList<UpdateEvent>(0), null);
+			b.apply(g);
+		}
+
+		g.setTimestamp(TimeUnit.MILLISECONDS.toSeconds(this.initDateTime.getMillis()));
+
+		// return graph
+		return g;
+	}
+
+	@Override
+	public Graph generate() {
+		return this.graph;
+	}
+
+	public NetflowEventReader getReader() {
+		return this.reader;
+	}
+
+	public NetflowBatch getBatchGenerator() {
+		return this.batchGenerator;
+	}
+}
diff --git a/src/dna/graph/weights/network/NetworkNodeWeight.java b/src/dna/graph/weights/network/NetworkNodeWeight.java
index 280be762..6c6c24c2 100644
--- a/src/dna/graph/weights/network/NetworkNodeWeight.java
+++ b/src/dna/graph/weights/network/NetworkNodeWeight.java
@@ -35,6 +35,11 @@ public String toString() {
 		return buff;
 	}
 
+	@Override
+	public String asString() {
+		return toString();
+	}
+
 	public NetworkNodeWeight(WeightSelection ws) {
 		this("unknown", new double[0]);
 	}
diff --git a/src/dna/labels/labeler/attacks/GroundTruthLabelerAttacks.java b/src/dna/labels/labeler/attacks/GroundTruthLabelerAttacks.java
new file mode 100644
index 00000000..89a032f2
--- /dev/null
+++ b/src/dna/labels/labeler/attacks/GroundTruthLabelerAttacks.java
@@ -0,0 +1,37 @@
+package dna.labels.labeler.attacks;
+
+import java.io.IOException;
+
+import dna.labels.labeler.list.ListLabeler;
+import dna.labels.labeler.util.IntervalLabeler;
+
+public class GroundTruthLabelerAttacks extends ListLabeler {
+
+	protected int edgeLifeTimeSeconds;
+	protected boolean init = false;
+
+	public GroundTruthLabelerAttacks(String name, String dir, String filename, int edgeLifeTimeSeconds) {
+		super(name, dir, filename);
+		this.edgeLifeTimeSeconds = edgeLifeTimeSeconds;
+		this.init = true;
+
+		try {
+			this.labeler = parseLabelerFromList(name, dir, filename);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	protected IntervalLabeler parseLabelerFromString(String name, String line) {
+		if (this.init) {
+			String[] splits = line.split("\t");
+			long timestamp = Long.parseLong(splits[0]);
+			String value = splits[3];
+			return new IntervalLabeler(this.getName(), "0-1", value, timestamp, timestamp + this.edgeLifeTimeSeconds);
+		} else {
+			return new IntervalLabeler("", 0, 0);
+		}
+	}
+
+}
diff --git a/src/dna/labels/labeler/models/ModelLabeler.java b/src/dna/labels/labeler/models/ModelLabeler.java
new file mode 100644
index 00000000..27e5bb63
--- /dev/null
+++ b/src/dna/labels/labeler/models/ModelLabeler.java
@@ -0,0 +1,55 @@
+package dna.labels.labeler.models;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import dna.graph.Graph;
+import dna.graph.generators.GraphGenerator;
+import dna.labels.Label;
+import dna.labels.labeler.Labeler;
+import dna.metrics.IMetric;
+import dna.series.data.BatchData;
+import dna.updates.batch.Batch;
+import dna.updates.generators.BatchGenerator;
+import dna.util.machineLearning.ModelWrapper;
+
+/**
+ * The ModelLabeler labels a batch based on a trained machine-learning model.
+ * 
+ * @author Rwilmes
+ *
+ */
+public class ModelLabeler extends Labeler {
+
+	protected ModelWrapper model;
+
+	public ModelLabeler(String name, String scriptPath, String featureListPath, int numberOfFeatures,
+			String modelPath) {
+		super(name);
+
+		try {
+			this.model = new ModelWrapper(scriptPath, featureListPath, numberOfFeatures, modelPath);
+		} catch (IOException | InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	public boolean isApplicable(GraphGenerator gg, BatchGenerator bg, IMetric[] metrics) {
+		return true;
+	}
+
+	@Override
+	public ArrayList<Label> computeLabels(Graph g, Batch batch, BatchData batchData, IMetric[] metrics) {
+		ArrayList<Label> list = new ArrayList<Label>();
+		if (model != null) {
+			String prediction = model.predict(batchData);
+
+			// only add labels whenn prediction is not 0
+			if (!prediction.equals("0"))
+				list.add(new Label(this.getName(), "class", prediction));
+		}
+		return list;
+	}
+
+}
diff --git a/src/dna/test/ModelLabelingTest.java b/src/dna/test/ModelLabelingTest.java
new file mode 100644
index 00000000..66cd56b7
--- /dev/null
+++ b/src/dna/test/ModelLabelingTest.java
@@ -0,0 +1,193 @@
+package dna.test;
+
+import java.io.IOException;
+import java.text.ParseException;
+import java.util.concurrent.TimeUnit;
+
+import org.joda.time.DateTime;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+
+import dna.graph.datastructures.GDS;
+import dna.graph.generators.GraphGenerator;
+import dna.graph.generators.network.NetflowBatch;
+import dna.graph.generators.network.NetflowGraph;
+import dna.graph.weights.Weight.WeightSelection;
+import dna.graph.weights.multi.DoubleMultiWeight;
+import dna.graph.weights.network.NetworkNodeWeight;
+import dna.io.network.netflow.NetflowEvent.NetflowDirection;
+import dna.io.network.netflow.NetflowEvent.NetflowEventField;
+import dna.io.network.netflow.NetflowEventReader;
+import dna.labels.labeler.Labeler;
+import dna.labels.labeler.LabelerNotApplicableException;
+import dna.labels.labeler.attacks.GroundTruthLabelerAttacks;
+import dna.labels.labeler.models.ModelLabeler;
+import dna.metrics.Metric;
+import dna.metrics.MetricNotApplicableException;
+import dna.series.AggregationException;
+import dna.series.Series;
+import dna.series.data.SeriesData;
+import dna.test.graphModel.GraphModel;
+import dna.test.graphModel.GraphModelUtils;
+import dna.updates.generators.BatchGenerator;
+import dna.util.Config;
+import dna.util.Log;
+import dna.util.network.DatasetUtils;
+import dna.util.network.NetflowAnalysis.EdgeWeightValue;
+import dna.util.network.NetflowAnalysis.NodeWeightValue;
+import dna.visualization.BatchHandler.ZipMode;
+import dna.visualization.graph.GraphVisualization;
+import dna.visualization.graph.rules.nodes.NetworkNodeStyles;
+
+public class ModelLabelingTest {
+
+	// settings
+	public static final boolean writeDistributions = false;
+	public static final boolean writeNodeValueLists = false;
+	public static final boolean writeNodeNodeValueLists = false;
+	public static final boolean enableVis = true;
+	public static final int dataOffsetSeconds = 0;
+	public static final ZipMode zipMode = ZipMode.none;
+
+	public static void main(String[] args) throws IOException, ParseException, AggregationException,
+			MetricNotApplicableException, LabelerNotApplicableException {
+		GraphVisualization.setConfigPath("config/gvis/gids.cfg");
+
+		int week = 2;
+		int day = 1;
+
+		String homeDir = "/home/chibo/";
+
+		String srcDir = homeDir + "data/datasets/darpa1998/";
+		String srcFilename = week + "_" + day + ".netflow";
+
+		String dstDir = homeDir + "tests/data/blub/";
+		String name = "blub";
+
+		String attackListDir = homeDir + "data/lists/darpa1998/";
+		String attackListFile = week + "_" + day + ".labels";
+
+		// model settings
+		int batchLengthSeconds = 1;
+		int edgeLifeTimeSeconds = 300;
+		GraphModel model = GraphModelUtils.model1; // select model
+
+		DateTime from = getDateTime(week, day, "17:25:00");
+		DateTime to = getDateTime(week, day, "17:30:00");
+
+		String labelMode = "2";
+		int numberOfFeatures = 200;
+
+		String scriptPath = homeDir + "customscripts/wrapper/blackbox_java_wrapper.py";
+		String featureListPath = homeDir + "data/features/darpa1998/train/ranking/" + week + "_" + day + "/"
+				+ batchLengthSeconds + "_" + edgeLifeTimeSeconds + "_" + model.getName() + "_l" + labelMode + ".lasso";
+		String modelPath = homeDir + "q-data/models/darpa1998/train/" + week + "_" + day + "/" + batchLengthSeconds
+				+ "_" + edgeLifeTimeSeconds + "_" + model.getName() + "_f" + numberOfFeatures + "_l" + labelMode
+				+ ".svm";
+
+		Labeler[] labeler = new Labeler[] {
+				new ModelLabeler("ModelLabeler", scriptPath, featureListPath, numberOfFeatures, modelPath),
+				new GroundTruthLabelerAttacks("DarpaGroundTruth", attackListDir, attackListFile, edgeLifeTimeSeconds) };
+
+		// MainDisplayConfig visConfig =
+		// MainDisplayConfig.readConfig("config/gui_min_lab.cfg");
+		// visConfig.setDefaultDir(dstDir + "run.0/");
+		// visConfig.setLiveDisplayMode(true);
+		// MainDisplay display = new MainDisplay(visConfig);
+		// display.startLiveMonitoring();
+
+		SeriesData sd = generate(srcDir, srcFilename, dstDir, name, batchLengthSeconds, edgeLifeTimeSeconds, from, to,
+				model, enableVis, labeler);
+	}
+
+	public static SeriesData generate(String srcDir, String srcFilename, String dstDir, String name,
+			int batchLengthSeconds, int edgeLifeTimeSeconds, DateTime from, DateTime to, GraphModel model,
+			boolean enableVis, Labeler[] labeler) throws IOException, ParseException, AggregationException,
+			MetricNotApplicableException, LabelerNotApplicableException {
+		return generate(srcDir, srcFilename, dstDir, srcFilename, batchLengthSeconds, dataOffsetSeconds,
+				edgeLifeTimeSeconds, from, to, enableVis, model.getMetrics(), model.getEdges(),
+				model.getEdgeDirections(), model.getEdgeWeights(), model.getNodeWeights(), labeler);
+
+	}
+
+	public static SeriesData generate(String srcDir, String srcFilename, String dstDir, String name,
+			int batchLengthSeconds, int dataOffsetSeconds, int edgeLifeTimeSeconds, DateTime from, DateTime to,
+			boolean enableVis, Metric[] metrics, NetflowEventField[][] edges, NetflowDirection[] edgeDirections,
+			EdgeWeightValue[] edgeWeights, NodeWeightValue[] nodeWeights, Labeler[] labeler) throws IOException,
+			ParseException, AggregationException, MetricNotApplicableException, LabelerNotApplicableException {
+		// vis
+		Config.overwrite("GRAPH_VIS_SHOW_NODE_WEIGHTS", "true");
+		Config.overwrite("GRAPH_VIS_SHOW_NODE_INDEX", "true");
+		if (enableVis) {
+			DatasetUtils.setGraphVisSettings();
+			GraphVisualization.enable();
+		} else
+			GraphVisualization.disable();
+
+		// IO settings
+		Config.overwrite("GENERATION_WRITE_DISTRIBUTONS", String.valueOf(writeDistributions));
+		Config.overwrite("GENERATION_WRITE_NVL", String.valueOf(writeNodeValueLists));
+		Config.overwrite("GENERATION_WRITE_NNVL", String.valueOf(writeNodeNodeValueLists));
+		setZipMode();
+
+		// additional values
+		Config.overwrite("GENERATE_VALUES_FROM_DISTRIBUTION", "true");
+		Config.overwrite("GENERATE_DISTRIBUTION_PERCENT_VALUES", "true");
+
+		// configure extra value generation
+		Config.overwrite("EXTRA_VALUE_DISTRIBUTION_PERCENT", "99, 98, 97, 96, 95, 90, 85, 80, 70, 50");
+
+		// init graph generator
+		GraphGenerator gg = new NetflowGraph(
+				GDS.directedVE(NetworkNodeWeight.class, WeightSelection.None, DoubleMultiWeight.class,
+						WeightSelection.None),
+				TimeUnit.MILLISECONDS.toSeconds(from.getMillis()), TimeUnit.MILLISECONDS.toSeconds(to.getMillis()),
+				srcDir, srcFilename, batchLengthSeconds, edgeLifeTimeSeconds, edges, edgeDirections, edgeWeights,
+				nodeWeights);
+
+		// init batch generator with gg reader
+		NetflowEventReader reader = ((NetflowGraph) gg).getReader();
+		BatchGenerator bg = new NetflowBatch(name, reader, edges, edgeDirections, edgeWeights, nodeWeights);
+
+		// transfer mappings
+		((NetflowBatch) bg).setMap(((NetflowGraph) gg).getBatchGenerator().getMap());
+
+		// set new batch-generator for presentation
+		NetworkNodeStyles.netflowBatchGenerator = (NetflowBatch) bg;
+
+		// init series
+		Series s = new Series(gg, bg, metrics, labeler, dstDir, name);
+
+		// generate
+		SeriesData sd = s.generate(1, 500, false, false, true, 1);
+
+		GraphVisualization.setText("Finished");
+		Log.infoSep();
+
+		return sd;
+	}
+
+	/** Date time formatting **/
+	public static final DateTimeFormatter fmt = DateTimeFormat.forPattern("dd-MM-yyyy-HH:mm:ss");
+
+	public static DateTime getDateTime(int week, int day, String hhmmss) {
+		String dayString = DatasetUtils.getDarpaDate(week, day);
+		return fmt.parseDateTime(dayString + "-" + hhmmss).plusSeconds(7200);
+	}
+
+	/** Zip Mode **/
+	public static void setZipMode() {
+		switch (zipMode) {
+		case batches:
+			Config.zipBatches();
+			break;
+		case none:
+			Config.zipNone();
+			break;
+		case runs:
+			Config.zipRuns();
+			break;
+		}
+	}
+
+}
diff --git a/src/dna/test/graphModel/GraphModel.java b/src/dna/test/graphModel/GraphModel.java
new file mode 100644
index 00000000..cb03c980
--- /dev/null
+++ b/src/dna/test/graphModel/GraphModel.java
@@ -0,0 +1,52 @@
+package dna.test.graphModel;
+
+import dna.io.network.netflow.NetflowEvent.NetflowDirection;
+import dna.io.network.netflow.NetflowEvent.NetflowEventField;
+import dna.metrics.Metric;
+import dna.util.network.NetflowAnalysis.EdgeWeightValue;
+import dna.util.network.NetflowAnalysis.NodeWeightValue;
+
+public class GraphModel {
+
+	protected String name;
+	protected NetflowEventField[][] edges;
+	protected NetflowDirection[] edgeDirections;
+	protected EdgeWeightValue[] edgeWeights;
+	protected NodeWeightValue[] nodeWeights;
+	protected Metric[] metrics;
+
+	public GraphModel(String name, NetflowEventField[][] edges, NetflowDirection[] edgeDirections,
+			EdgeWeightValue[] edgeWeights, NodeWeightValue[] nodeWeights, Metric[] metrics) {
+		this.name = name;
+		this.edges = edges;
+		this.edgeDirections = edgeDirections;
+		this.edgeWeights = edgeWeights;
+		this.nodeWeights = nodeWeights;
+		this.metrics = metrics;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public NetflowEventField[][] getEdges() {
+		return edges;
+	}
+
+	public NetflowDirection[] getEdgeDirections() {
+		return edgeDirections;
+	}
+
+	public EdgeWeightValue[] getEdgeWeights() {
+		return edgeWeights;
+	}
+
+	public NodeWeightValue[] getNodeWeights() {
+		return nodeWeights;
+	}
+
+	public Metric[] getMetrics() {
+		return metrics;
+	}
+
+}
diff --git a/src/dna/test/graphModel/GraphModelUtils.java b/src/dna/test/graphModel/GraphModelUtils.java
new file mode 100644
index 00000000..d6f134e9
--- /dev/null
+++ b/src/dna/test/graphModel/GraphModelUtils.java
@@ -0,0 +1,177 @@
+package dna.test.graphModel;
+
+import dna.io.network.netflow.NetflowEvent.NetflowDirection;
+import dna.io.network.netflow.NetflowEvent.NetflowEventField;
+import dna.metrics.Metric;
+import dna.metrics.assortativity.AssortativityU;
+import dna.metrics.clustering.DirectedClusteringCoefficientU;
+import dna.metrics.connectivity.StrongConnectivityR;
+import dna.metrics.connectivity.WeakConnectivityR;
+import dna.metrics.degree.DegreeDistributionR;
+import dna.metrics.degree.WeightedDegreeDistributionMultiR;
+import dna.metrics.paths.unweighted.UnweightedMultiSourceShortestPathsR;
+import dna.metrics.richClub.RichClubConnectivityByDegreeU;
+import dna.metrics.weights.EdgeWeightsMultiU;
+import dna.metrics.weights.NodeWeightsMultiU;
+import dna.util.network.NetflowAnalysis.EdgeWeightValue;
+import dna.util.network.NetflowAnalysis.NodeWeightValue;
+
+public class GraphModelUtils {
+
+	protected static NetflowEventField[][] parseNetflowEventFields(String[] input) {
+		NetflowEventField[][] edges = new NetflowEventField[input.length][];
+		for (int i = 0; i < input.length; i++) {
+			String[] splits = input[i].split("-");
+			NetflowEventField[] fields = new NetflowEventField[splits.length];
+
+			for (int j = 0; j < splits.length; j++) {
+				if (splits[j] == null || splits[j].equals("null"))
+					fields[j] = NetflowEventField.None;
+				else
+					fields[j] = NetflowEventField.valueOf(splits[j]);
+			}
+
+			edges[i] = fields;
+		}
+
+		return edges;
+	}
+
+	protected static EdgeWeightValue[] parseEdgeWeightValues(String[] input) {
+		EdgeWeightValue[] edgeWeights = new EdgeWeightValue[input.length];
+		for (int i = 0; i < input.length; i++) {
+			edgeWeights[i] = EdgeWeightValue.valueOf(input[i]);
+		}
+		return edgeWeights;
+	}
+
+	protected static NodeWeightValue[] parseNodeWeightValues(String[] input) {
+		NodeWeightValue[] nodeWeights = new NodeWeightValue[input.length];
+		for (int i = 0; i < input.length; i++) {
+			nodeWeights[i] = NodeWeightValue.valueOf(input[i]);
+		}
+		return nodeWeights;
+	}
+
+	protected static NetflowDirection[] parseEdgeDirections(String[] inputDirections) {
+		NetflowDirection[] directions = new NetflowDirection[inputDirections.length];
+		for (int i = 0; i < inputDirections.length; i++) {
+			if (inputDirections[i].toLowerCase().equals("fw"))
+				directions[i] = NetflowDirection.forward;
+			if (inputDirections[i].toLowerCase().equals("bw"))
+				directions[i] = NetflowDirection.backward;
+		}
+		return directions;
+	}
+
+	/** NODE TYPES **/
+	public static final String[] hostType = new String[] { "HOST" };
+	public static final String[] portType = new String[] { "PORT" };
+	public static final String[] protType = new String[] { "PROT" };
+
+	/** WEIGHTS **/
+	public static final String edgeWeightString = "numberOfNetflows;Packets;Bytes";
+	public static final String nodeWeightString = "numberOfNetflowsIn;numberOfNetflowsOut;PacketsIn;PacketsOut;BytesIn;BytesOut";
+
+	/** M0 **/
+	protected static final String m0EdgesString = "SrcAddress-DstAddress;DstAddress-SrcAddress";
+	public static final NetflowEventField[][] m0Edges = parseNetflowEventFields(m0EdgesString.split(";"));
+
+	protected static final String m0DirectionsString = "fw;bw";
+	public static final NetflowDirection[] m0Directions = parseEdgeDirections(m0DirectionsString.split(";"));
+
+	protected static final String m0EdgeWeightString = edgeWeightString;
+	public static final EdgeWeightValue[] m0EdgeWeights = parseEdgeWeightValues(m0EdgeWeightString.split(";"));
+
+	protected static final String m0NodeWeightString = nodeWeightString;
+	public static final NodeWeightValue[] m0NodeWeights = parseNodeWeightValues(m0NodeWeightString.split(";"));
+
+	public static final Metric[] m0AllMetrics = new Metric[] { new DegreeDistributionR(), new AssortativityU(),
+			new DirectedClusteringCoefficientU(), new UnweightedMultiSourceShortestPathsR(100),
+			new RichClubConnectivityByDegreeU(), new WeakConnectivityR(), new StrongConnectivityR(),
+			new WeightedDegreeDistributionMultiR(0, 1.0), new WeightedDegreeDistributionMultiR(1, 1.0),
+			new WeightedDegreeDistributionMultiR(2, 1000.0), new NodeWeightsMultiU(0, 1.0),
+			new NodeWeightsMultiU(1, 1.0), new NodeWeightsMultiU(2, 1000.0), new NodeWeightsMultiU(3, 1.0),
+			new NodeWeightsMultiU(4, 1.0), new NodeWeightsMultiU(5, 1000.0), new EdgeWeightsMultiU(0, 1.0),
+			new EdgeWeightsMultiU(1, 1.0), new EdgeWeightsMultiU(2, 1000.0) };
+
+	/** M1 **/
+	protected static final String m1EdgesString = "SrcAddress-DstPort-DstAddress;DstAddress-SrcPort-SrcAddress";
+	public static final NetflowEventField[][] m1Edges = parseNetflowEventFields(m1EdgesString.split(";"));
+
+	protected static final String m1DirectionsString = "fw;bw";
+	public static final NetflowDirection[] m1Directions = parseEdgeDirections(m1DirectionsString.split(";"));
+
+	protected static final String m1EdgeWeightString = edgeWeightString;
+	public static final EdgeWeightValue[] m1EdgeWeights = parseEdgeWeightValues(m1EdgeWeightString.split(";"));
+
+	protected static final String m1NodeWeightString = nodeWeightString;
+	public static final NodeWeightValue[] m1NodeWeights = parseNodeWeightValues(m1NodeWeightString.split(";"));
+
+	public static final Metric[] m1allMetrics = new Metric[] { new DegreeDistributionR(),
+			new DegreeDistributionR(hostType), new DegreeDistributionR(portType), new AssortativityU(),
+			new DirectedClusteringCoefficientU(), new UnweightedMultiSourceShortestPathsR(100),
+			new RichClubConnectivityByDegreeU(), new WeakConnectivityR(), new StrongConnectivityR(),
+			new WeightedDegreeDistributionMultiR(0, 1.0), new WeightedDegreeDistributionMultiR(hostType, 0, 1.0),
+			new WeightedDegreeDistributionMultiR(portType, 0, 1.0), new WeightedDegreeDistributionMultiR(1, 1.0),
+			new WeightedDegreeDistributionMultiR(hostType, 1, 1.0),
+			new WeightedDegreeDistributionMultiR(portType, 1, 1.0), new WeightedDegreeDistributionMultiR(2, 1000.0),
+			new WeightedDegreeDistributionMultiR(hostType, 2, 1000.0),
+			new WeightedDegreeDistributionMultiR(portType, 2, 1000.0), new NodeWeightsMultiU(0, 1.0),
+			new NodeWeightsMultiU(1, 1.0), new NodeWeightsMultiU(2, 1000.0), new NodeWeightsMultiU(3, 1.0),
+			new NodeWeightsMultiU(4, 1.0), new NodeWeightsMultiU(5, 1000.0), new EdgeWeightsMultiU(0, 1.0),
+			new EdgeWeightsMultiU(1, 1.0), new EdgeWeightsMultiU(2, 1000.0) };
+
+	/** M2 **/
+	protected static final String m2EdgesString = "SrcAddress-DstPort-DstAddress;SrcAddress-DstAddress;DstAddress-SrcPort-SrcAddress;DstAddress-SrcAddress";
+	public static final NetflowEventField[][] m2Edges = parseNetflowEventFields(m2EdgesString.split(";"));
+
+	protected static final String m2DirectionsString = "fw;fw;bw;bw";
+	public static final NetflowDirection[] m2Directions = parseEdgeDirections(m2DirectionsString.split(";"));
+
+	protected static final String m2EdgeWeightString = edgeWeightString;
+	public static final EdgeWeightValue[] m2EdgeWeights = parseEdgeWeightValues(m2EdgeWeightString.split(";"));
+
+	protected static final String m2NodeWeightString = nodeWeightString;
+	public static final NodeWeightValue[] m2NodeWeights = parseNodeWeightValues(m2NodeWeightString.split(";"));
+
+	public static final Metric[] m2allMetrics = m1allMetrics;
+
+	/** M3 **/
+	protected static final String m3EdgesString = "SrcAddress-Protocol-DstAddress;DstAddress-Protocol-SrcAddress";
+	public static final NetflowEventField[][] m3Edges = parseNetflowEventFields(m3EdgesString.split(";"));
+
+	protected static final String m3DirectionsString = "fw;bw";
+	public static final NetflowDirection[] m3Directions = parseEdgeDirections(m3DirectionsString.split(";"));
+
+	protected static final String m3EdgeWeightString = edgeWeightString;
+	public static final EdgeWeightValue[] m3EdgeWeights = parseEdgeWeightValues(m3EdgeWeightString.split(";"));
+
+	protected static final String m3NodeWeightString = nodeWeightString;
+	public static final NodeWeightValue[] m3NodeWeights = parseNodeWeightValues(m3NodeWeightString.split(";"));
+
+	public static final Metric[] m3allMetrics = new Metric[] { new DegreeDistributionR(),
+			new DegreeDistributionR(hostType), new DegreeDistributionR(protType), new AssortativityU(),
+			new DirectedClusteringCoefficientU(), new UnweightedMultiSourceShortestPathsR(100),
+			new RichClubConnectivityByDegreeU(), new WeakConnectivityR(), new StrongConnectivityR(),
+			new WeightedDegreeDistributionMultiR(0, 1.0), new WeightedDegreeDistributionMultiR(hostType, 0, 1.0),
+			new WeightedDegreeDistributionMultiR(protType, 0, 1.0), new WeightedDegreeDistributionMultiR(1, 1.0),
+			new WeightedDegreeDistributionMultiR(hostType, 1, 1.0),
+			new WeightedDegreeDistributionMultiR(protType, 1, 1.0), new WeightedDegreeDistributionMultiR(2, 1000.0),
+			new WeightedDegreeDistributionMultiR(hostType, 2, 1000.0),
+			new WeightedDegreeDistributionMultiR(protType, 2, 1000.0), new NodeWeightsMultiU(0, 1.0),
+			new NodeWeightsMultiU(1, 1.0), new NodeWeightsMultiU(2, 1000.0), new NodeWeightsMultiU(3, 1.0),
+			new NodeWeightsMultiU(4, 1.0), new NodeWeightsMultiU(5, 1000.0), new EdgeWeightsMultiU(0, 1.0),
+			new EdgeWeightsMultiU(1, 1.0), new EdgeWeightsMultiU(2, 1000.0) };
+
+	/** GRAPH MODELS **/
+	public static final GraphModel model0 = new GraphModel("m0", m0Edges, m0Directions, m0EdgeWeights, m0NodeWeights,
+			m0AllMetrics);
+	public static final GraphModel model1 = new GraphModel("m1", m1Edges, m1Directions, m1EdgeWeights, m1NodeWeights,
+			m1allMetrics);
+	public static final GraphModel model2 = new GraphModel("m2", m2Edges, m2Directions, m2EdgeWeights, m2NodeWeights,
+			m2allMetrics);
+	public static final GraphModel model3 = new GraphModel("m3", m3Edges, m3Directions, m3EdgeWeights, m3NodeWeights,
+			m3allMetrics);
+
+}
diff --git a/src/dna/util/machineLearning/ModelWrapper.java b/src/dna/util/machineLearning/ModelWrapper.java
new file mode 100644
index 00000000..e82fb80d
--- /dev/null
+++ b/src/dna/util/machineLearning/ModelWrapper.java
@@ -0,0 +1,458 @@
+package dna.util.machineLearning;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+
+import dna.io.Reader;
+import dna.io.Writer;
+import dna.io.filesystem.Dir;
+import dna.series.aggdata.AggregatedBatch.BatchReadMode;
+import dna.series.data.BatchData;
+import dna.series.lists.BatchDataList;
+import dna.util.Log;
+
+public class ModelWrapper {
+
+	public enum LabelMode {
+		attackClasses, attacks, zeroOneMode
+	}
+
+	public class LabelEntry {
+		protected String attackClass;
+		protected long attackClassId;
+		protected String attack;
+		protected long attackId;
+
+		public LabelEntry(String attack, long attackId, String attackClass, long attackClassId) {
+			this.attack = attack;
+			this.attackId = attackId;
+			this.attackClass = attackClass;
+			this.attackClassId = attackClassId;
+		}
+
+		public String getAttackClass() {
+			return attackClass;
+		}
+
+		public long getAttackClassId() {
+			return attackClassId;
+		}
+
+		public String getAttack() {
+			return attack;
+		}
+
+		public long getAttackId() {
+			return attackId;
+		}
+	}
+
+	public class TruthLabeler {
+
+		protected String truthListPath;
+		protected ArrayList<Long> timestamps;
+		protected HashMap<Long, ArrayList<LabelEntry>> entries;
+
+		public TruthLabeler(String truthListPath) {
+			this.truthListPath = truthListPath;
+			this.timestamps = new ArrayList<Long>();
+
+			try {
+				this.entries = readListEntries(truthListPath);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+
+			for (long l : this.entries.keySet()) {
+				this.timestamps.add(l);
+			}
+
+			Collections.sort(this.timestamps);
+		}
+
+		protected HashMap<Long, ArrayList<LabelEntry>> readListEntries(String truthListPath) throws IOException {
+			HashMap<Long, ArrayList<LabelEntry>> entryMap = new HashMap<Long, ArrayList<LabelEntry>>();
+
+			Reader r = new Reader("", truthListPath);
+
+			String line = "";
+			while ((line = r.readString()) != null) {
+				String[] splits = line.split("\t");
+				long timestamp = Long.parseLong(splits[0]);
+				LabelEntry label = new LabelEntry(splits[1], Long.parseLong(splits[3]), splits[2],
+						Long.parseLong(splits[4]));
+				if (entryMap.containsKey(timestamp)) {
+					entryMap.get(timestamp).add(label);
+				} else {
+					ArrayList<LabelEntry> tempList = new ArrayList<LabelEntry>();
+					tempList.add(label);
+					entryMap.put(timestamp, tempList);
+				}
+			}
+
+			return entryMap;
+		}
+
+		public void print() {
+			for (Long l : this.timestamps) {
+				String line = "" + l;
+				ArrayList<LabelEntry> list = this.entries.get(l);
+				for (LabelEntry e : list) {
+					line += "\t" + e.getAttack() + "\t" + e.getAttackId();
+				}
+				System.out.println(line);
+			}
+		}
+
+		public String getAttacksAtTimestamp(long timestamp, int lifeTime, LabelMode labelMode) {
+			ArrayList<LabelEntry> foundEntries = new ArrayList<LabelEntry>();
+
+			for (long l : this.timestamps) {
+				if (l <= timestamp && ((l + lifeTime) >= timestamp)) {
+					ArrayList<LabelEntry> labels = this.entries.get(l);
+					for (LabelEntry e : labels) {
+						if (!foundEntries.contains(e))
+							foundEntries.add(e);
+					}
+				}
+			}
+
+			long attack = 0;
+			long attackId = 0;
+			long attackClassId = 0;
+
+			ArrayList<Long> attackIds = new ArrayList<Long>();
+			ArrayList<Long> attackClassIds = new ArrayList<Long>();
+			for (LabelEntry e : foundEntries) {
+				if (!attackIds.contains(e.getAttackId()))
+					attackIds.add(e.getAttackId());
+				if (!attackClassIds.contains(e.getAttackClassId()))
+					attackClassIds.add(e.getAttackClassId());
+			}
+
+			if (foundEntries.size() > 0)
+				attack = 1;
+			for (long l : attackIds)
+				attackId += l;
+			for (long l : attackClassIds)
+				attackClassId += l;
+
+			switch (labelMode) {
+			case attackClasses:
+				return "" + attackClassId;
+			case attacks:
+				return "" + attackId;
+			case zeroOneMode:
+				return "" + attack;
+			default:
+				return "unknown";
+			}
+
+			// return attack + "\t" + attackId + "\t" + attackClassId;
+		}
+	}
+
+	public class PredictionList {
+
+		protected ArrayList<Long> timestamps;
+		protected ArrayList<String> predictions;
+		protected ArrayList<String> truths;
+
+		public PredictionList() {
+			this.timestamps = new ArrayList<Long>();
+			this.predictions = new ArrayList<String>();
+			this.truths = new ArrayList<String>();
+		}
+
+		public PredictionList(int size) {
+			this.timestamps = new ArrayList<Long>(size);
+			this.predictions = new ArrayList<String>(size);
+			this.truths = new ArrayList<String>(size);
+		}
+
+		public void addPrediction(long timestamp, String prediction, String truth) {
+			this.timestamps.add(timestamp);
+			this.predictions.add(prediction);
+			this.truths.add(truth);
+		}
+
+		public ArrayList<Long> getTimestamps() {
+			return this.timestamps;
+		}
+
+		public ArrayList<String> getPredictions() {
+			return this.predictions;
+		}
+
+		public ArrayList<String> getTruths() {
+			return this.truths;
+		}
+
+		public String getPrediction(int index) {
+			return timestamps.get(index) + "\t" + predictions.get(index) + "\t" + truths.get(index);
+		}
+
+		public int size() {
+			return this.predictions.size();
+		}
+
+		public void write(String dir, String filename) throws IOException {
+			Writer w = new Writer(dir, filename);
+			for (int i = 0; i < size(); i++) {
+				w.writeln(getPrediction(i));
+			}
+			w.close();
+		}
+	}
+
+	public class FeatureListEntry {
+
+		protected String name;
+		protected double score;
+
+		protected String metric;
+		protected String value;
+
+		public FeatureListEntry(String name, double score) {
+			this.name = name;
+			this.score = score;
+
+			// parse metric and value
+			String[] splits = name.split(metricValueDelimiter);
+			this.metric = splits[0];
+			this.value = splits[1];
+
+			// fix edge-weights name
+			if (metric.startsWith("EdgeWeights")) {
+				String[] splits2 = metric.split("-");
+				metric = metric + "-" + splits2[splits2.length - 1];
+			}
+
+			// old feature lists may contain "_MED" as value definition
+			if (value.endsWith("_MED"))
+				value = value.replace("_MED", "_50p");
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public double getScore() {
+			return score;
+		}
+
+		public String getMetric() {
+			return metric;
+		}
+
+		public String getValue() {
+			return value;
+		}
+
+		public double obtainValueFromBatch(BatchData b) {
+			if (metric.equals("statistics")) {
+				return b.getValues().get(value).getValue();
+			} else {
+				return b.getMetrics().get(metric).getValues().get(value).getValue();
+			}
+		}
+	}
+
+	// statics
+	public static final long timeoutInterval = 10000;
+	public static final String initMessage = "init ok";
+	public static final String exitMessage = "exit";
+	public static final String featureListDelimiter = "\t";
+	public static final String metricValueDelimiter = "~";
+	public static final String featureVectorDelimiter = "\t";
+
+	// class fields
+	protected String scriptPath;
+	protected String featureListPath;
+	protected String blackboxPath;
+
+	protected ArrayList<FeatureListEntry> features;
+	protected int numberOfFeatures;
+
+	protected InputStream in;
+	protected OutputStream out;
+
+	protected BufferedReader r;
+
+	protected ProcessBuilder interpreter;
+	protected Process p;
+
+	protected TruthLabeler truthLabeler;
+
+	// constructor
+	public ModelWrapper(String scriptPath, String featureListPath, int numberOfFeatures, String blackboxPath)
+			throws IOException, InterruptedException {
+		this(scriptPath, featureListPath, numberOfFeatures, blackboxPath, null);
+	}
+
+	public ModelWrapper(String scriptPath, String featureListPath, int numberOfFeatures, String blackboxPath,
+			String truthListPath) throws IOException, InterruptedException {
+		Log.info("setting up blackbox wrapper");
+		Log.info("");
+		Log.info("script:\t" + scriptPath);
+		Log.info("");
+		Log.info("features:\t" + featureListPath);
+		Log.info("# features:\t" + numberOfFeatures);
+		Log.info("");
+		Log.info("blackbox:\t" + blackboxPath);
+		Log.info("");
+		Log.infoSep();
+		Log.info("");
+
+		this.scriptPath = scriptPath;
+		this.featureListPath = featureListPath;
+		this.features = readFeatureList(featureListPath);
+		this.numberOfFeatures = numberOfFeatures;
+		this.blackboxPath = blackboxPath;
+
+		if (truthListPath != null)
+			this.truthLabeler = new TruthLabeler(truthListPath);
+
+		this.interpreter = new ProcessBuilder("python", scriptPath);
+		this.p = interpreter.start();
+		this.out = p.getOutputStream();
+		this.in = p.getInputStream();
+
+		// init the blackbox
+		this.r = new BufferedReader(new InputStreamReader(this.in));
+		String line = "";
+		long start = System.currentTimeMillis();
+		long current = System.currentTimeMillis();
+		long timeout = start + timeoutInterval;
+		while (current < timeout) {
+			Thread.sleep(100);
+
+			current = System.currentTimeMillis();
+			line = r.readLine();
+
+			if (line.equals(initMessage))
+				break;
+		}
+
+		Log.info("init message received");
+
+		// Log.info(blackboxPath);
+		// send blackbox-path
+		Log.info(exec(blackboxPath));
+		Log.info("blackbox fully initialized");
+		Log.info("");
+	}
+
+	protected ArrayList<FeatureListEntry> readFeatureList(String path) throws IOException {
+		ArrayList<FeatureListEntry> list = new ArrayList<FeatureListEntry>();
+
+		// read and parse features line by line
+		BufferedReader reader = new BufferedReader(new FileReader(path));
+		String line = "";
+		while ((line = reader.readLine()) != null) {
+			String[] splits = line.split(featureListDelimiter);
+			list.add(new FeatureListEntry(splits[1], Double.parseDouble(splits[0])));
+		}
+
+		return list;
+	}
+
+	/** Executes a command and returns the response. **/
+	public String exec(String command) {
+		String str = null;
+
+		try {
+			out.write((command + "\n").getBytes());
+
+			// try {
+			out.flush();
+
+			// } catch (Exception e) {
+			//
+			// }
+			str = this.r.readLine();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return str;
+	}
+
+	/** Uses the blackbox to predict the given data. **/
+	public String predict(BatchData b) {
+		String prediction = null;
+
+		String featureVector = "";
+
+		for (int i = 0; i < this.numberOfFeatures; i++) {
+			FeatureListEntry e = this.features.get(i);
+			double v = e.obtainValueFromBatch(b);
+
+			if (Double.isNaN(v) || Double.isInfinite(v))
+				v = 0.0;
+
+			if (featureVector.equals(""))
+				featureVector += v;
+			else
+				featureVector += featureVectorDelimiter + v;
+		}
+
+		prediction = exec(featureVector);
+
+		prediction = prediction.replaceAll("predicting: ", "");
+		return prediction;
+	}
+
+	/** Predicts an entire run and returns a PredictionList. **/
+	public PredictionList predictRun(String runDir, int lifeTime, LabelMode labelMode) throws IOException {
+		Log.info("predicting run: '" + runDir + "'");
+		BatchDataList list = BatchDataList.readTimestamps(runDir);
+		PredictionList predictions = new PredictionList(list.size());
+
+		Log.infoSep();
+		Log.info("# batches\tpercent");
+
+		// iterate over batches
+		for (int i = 0; i < list.size(); i++) {
+			BatchData b = list.get(i);
+			long timestamp = b.getTimestamp();
+			BatchData tempBatch = BatchData.readIntelligent(Dir.getBatchDataDir(runDir, timestamp), timestamp,
+					BatchReadMode.readOnlySingleValues);
+
+			if (tempBatch.getValues().get("nodes").getValue() == 0.0) {
+				continue;
+			}
+
+			// predict batch
+			String prediction = this.predict(tempBatch);
+
+			// add prediction to list
+			predictions.addPrediction(timestamp, prediction,
+					"" + this.truthLabeler.getAttacksAtTimestamp(timestamp, lifeTime, labelMode));
+
+			if (i % 1000 == 0)
+				Log.info(i + "\t" + (Math.floor(10000.0 * i / list.size()) / 100.0));
+		}
+		Log.info((list.size() - 1) + "\t100.0");
+		Log.infoSep();
+		return predictions;
+	}
+
+	/** stops the blackbox **/
+	public void stop() {
+		try {
+			exec(exitMessage);
+			this.r.close();
+			this.out.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}
diff --git a/src/dna/visualization/MainDisplay.java b/src/dna/visualization/MainDisplay.java
index 042b803b..88cfb2a0 100644
--- a/src/dna/visualization/MainDisplay.java
+++ b/src/dna/visualization/MainDisplay.java
@@ -38,9 +38,11 @@
 import dna.visualization.BatchHandler.ZipMode;
 import dna.visualization.components.LogDisplay;
 import dna.visualization.components.statsdisplay.StatsDisplay;
+import dna.visualization.components.visualizer.LabelVisualizer;
 import dna.visualization.components.visualizer.MetricVisualizer;
 import dna.visualization.components.visualizer.MultiScalarVisualizer;
 import dna.visualization.components.visualizer.Visualizer;
+import dna.visualization.config.components.LabelVisualizerConfig;
 import dna.visualization.config.components.LogDisplayConfig;
 import dna.visualization.config.components.MainDisplayConfig;
 import dna.visualization.config.components.MetricVisualizerConfig;
@@ -50,8 +52,7 @@
 public class MainDisplay extends JFrame {
 
 	/** MAIN **/
-	public static void main(String[] args) throws URISyntaxException,
-			IOException {
+	public static void main(String[] args) throws URISyntaxException, IOException {
 		Log.infoSep();
 
 		// check cmd line parameters
@@ -116,42 +117,27 @@ public static void main(String[] args) throws URISyntaxException,
 
 		if (helpFlag) {
 			System.out.println("DNA - Dynamic Network Analyzer");
-			System.out
-					.println("Run the program with the following command line parameters to change the GUI's behaviour:");
+			System.out.println(
+					"Run the program with the following command line parameters to change the GUI's behaviour:");
 			System.out.println("Parameter" + "\t\t" + "Function");
-			System.out.println("-c <config-path>" + "\t"
-					+ "Uses the specified file as main display configuration");
-			System.out.println("-c <config-path>" + "\t"
-					+ "Uses the specified file as main display configuration");
-			System.out
-					.println("\t\t\t"
-							+ "Note: It will first check the path on the actual filesystem");
-			System.out
-					.println("\t\t\t"
-							+ "then inside the jar. If it is not present, it will use the default-cfg,");
-			System.out
-					.println("\t\t\t"
-							+ "again first the one from the filesystem, then from the jar.");
-			System.out.println("-d <data-dir>" + "\t\t"
-					+ "Specifies the data-dir as default dir");
+			System.out.println("-c <config-path>" + "\t" + "Uses the specified file as main display configuration");
+			System.out.println("-c <config-path>" + "\t" + "Uses the specified file as main display configuration");
+			System.out.println("\t\t\t" + "Note: It will first check the path on the actual filesystem");
+			System.out.println("\t\t\t" + "then inside the jar. If it is not present, it will use the default-cfg,");
+			System.out.println("\t\t\t" + "again first the one from the filesystem, then from the jar.");
+			System.out.println("-d <data-dir>" + "\t\t" + "Specifies the data-dir as default dir");
 			System.out.println("-h" + "\t\t\t" + "Displays this help message");
-			System.out.println("-l" + "\t\t\t"
-					+ "Runs the GUI in live display mode");
-			System.out.println("-p" + "\t\t\t"
-					+ "Runs the GUI in playback mode");
-			System.out.println("-z" + "\t\t\t"
-					+ "Enables zipped batches support");
-			System.out
-					.println("-zr" + "\t\t\t" + "Enables zipped runs support");
-
-			System.out.println("Example: run vis.jar -c " + '"'
-					+ "config/my_guy.cfg" + '"' + " -d " + '"'
+			System.out.println("-l" + "\t\t\t" + "Runs the GUI in live display mode");
+			System.out.println("-p" + "\t\t\t" + "Runs the GUI in playback mode");
+			System.out.println("-z" + "\t\t\t" + "Enables zipped batches support");
+			System.out.println("-zr" + "\t\t\t" + "Enables zipped runs support");
+
+			System.out.println("Example: run vis.jar -c " + '"' + "config/my_guy.cfg" + '"' + " -d " + '"'
 					+ "data/scenario1337/run.42/" + '"' + " -l -z");
 		} else {
 			MainDisplayConfig customConfig = MainDisplay.DefaultConfig;
 			if (configFlag) {
-				MainDisplayConfig tempConfig = MainDisplayConfig
-						.readConfig(configPath);
+				MainDisplayConfig tempConfig = MainDisplayConfig.readConfig(configPath);
 				if (tempConfig != null)
 					customConfig = tempConfig;
 			}
@@ -190,8 +176,7 @@ else if (zipRunFlag)
 			MainDisplay display = new MainDisplay(liveFlag, zipMode, config);
 
 			if (config.isFullscreen()) {
-				display.setExtendedState(display.getExtendedState()
-						| JFrame.MAXIMIZED_BOTH);
+				display.setExtendedState(display.getExtendedState() | JFrame.MAXIMIZED_BOTH);
 			}
 			display.setVisible(true);
 
@@ -231,8 +216,7 @@ else if (zipRunFlag)
 	// config
 	public static boolean runFromJar = IOUtils.isRunFromJar();
 	public static MainDisplayConfig config;
-	public static MainDisplayConfig DefaultConfig = MainDisplayConfig
-			.getDefaultConfig();
+	public static MainDisplayConfig DefaultConfig = MainDisplayConfig.getDefaultConfig();
 
 	// static paths
 	public static final String defaultConfigPath = "config/gui_default.cfg";
@@ -267,6 +251,9 @@ public MainDisplay(boolean liveDisplay, ZipMode zipMode, String configPath) {
 
 	public MainDisplay(boolean liveDisplay, ZipMode zipMode,
 			MainDisplayConfig config) {
+		// set config
+		MainDisplay.config = config;
+
 		// init
 		setTitle(config.getName());
 		setSize(config.getSize());
@@ -368,9 +355,7 @@ public void actionPerformed(ActionEvent event) {
 						batchHandler.start();
 						startLogDisplays();
 					} else {
-						Log.info("Dir '"
-								+ f.getPath()
-								+ "' not present, try again with existing directory.");
+						Log.info("Dir '" + f.getPath() + "' not present, try again with existing directory.");
 					}
 				}
 			}
@@ -401,10 +386,9 @@ public void actionPerformed(ActionEvent event) {
 
 		// create lock checkbox and add to buttons panel
 		this.mainLock = new JCheckBox("Lock");
-		this.mainLock
-				.setToolTipText("Locks all visualizers, which means their legends wont be altered during reset / directory change.");
-		this.mainLock.setFont(new Font(this.getDefaultFont().getName(),
-				Font.BOLD, this.getDefaultFont().getSize()));
+		this.mainLock.setToolTipText(
+				"Locks all visualizers, which means their legends wont be altered during reset / directory change.");
+		this.mainLock.setFont(new Font(this.getDefaultFont().getName(), Font.BOLD, this.getDefaultFont().getSize()));
 		this.mainLock.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent arg0) {
@@ -423,8 +407,7 @@ public void actionPerformed(ActionEvent arg0) {
 		/*
 		 * Create StatsDisplay
 		 */
-		this.statsDisplay = new StatsDisplay(this,
-				config.getStatsDisplayConfig(), liveDisplay);
+		this.statsDisplay = new StatsDisplay(this, config.getStatsDisplayConfig(), liveDisplay);
 		this.statsDisplay.setLocation(0, 0);
 		this.statsDisplay.setDirectory(config.getDefaultDir());
 
@@ -439,16 +422,14 @@ public void actionPerformed(ActionEvent arg0) {
 		 * Init LogoPanel, set position and add to leftSidePanel
 		 */
 		this.logoPanel = new JPanel();
-		this.logoPanel
-				.setLayout(new BoxLayout(this.logoPanel, BoxLayout.X_AXIS));
+		this.logoPanel.setLayout(new BoxLayout(this.logoPanel, BoxLayout.X_AXIS));
 
 		BufferedImage image = null;
 		JarFile x = null;
 		InputStream is = null;
 		try {
 			if (runFromJar) {
-				Path pPath = Paths.get(Config.class.getProtectionDomain()
-						.getCodeSource().getLocation().toURI());
+				Path pPath = Paths.get(Config.class.getProtectionDomain().getCodeSource().getLocation().toURI());
 				String[] splits = config.getLogoDir().split("/");
 				x = new JarFile(pPath.toFile(), false);
 				is = x.getInputStream(x.getEntry(splits[splits.length - 1]));
@@ -461,17 +442,14 @@ public void actionPerformed(ActionEvent arg0) {
 		}
 
 		// rescale image
-		Image newimg = image.getScaledInstance(
-				(int) Math.floor(config.getLogoSize().getWidth()),
-				(int) Math.floor(config.getLogoSize().getHeight()),
-				java.awt.Image.SCALE_SMOOTH);
+		Image newimg = image.getScaledInstance((int) Math.floor(config.getLogoSize().getWidth()),
+				(int) Math.floor(config.getLogoSize().getHeight()), java.awt.Image.SCALE_SMOOTH);
 
 		JLabel logoLabel = new JLabel(new ImageIcon(newimg));
 		this.logoPanel.setLayout(new GridBagLayout());
 		// this.logoPanel.setPreferredSize(config.getLogoSize());
 		this.logoPanel.add(logoLabel);
-		this.logoPanel.setBorder(BorderFactory
-				.createEtchedBorder((EtchedBorder.LOWERED)));
+		this.logoPanel.setBorder(BorderFactory.createEtchedBorder((EtchedBorder.LOWERED)));
 
 		// free resources
 		try {
@@ -503,13 +481,10 @@ public void actionPerformed(ActionEvent arg0) {
 		int maxYPosition = 0;
 		// FILL PANEL
 		// add metric visualizer
-		for (MetricVisualizerConfig metVisConfig : config
-				.getMetricVisualizerConfigs()) {
-			MetricVisualizer metricVisualizerTemp = new MetricVisualizer(this,
-					metVisConfig);
+		for (MetricVisualizerConfig metVisConfig : config.getMetricVisualizerConfigs()) {
+			MetricVisualizer metricVisualizerTemp = new MetricVisualizer(this, metVisConfig);
 
-			if (metVisConfig.getPositionX() >= 0
-					&& metVisConfig.getPositionY() >= 0) {
+			if (metVisConfig.getPositionX() >= 0 && metVisConfig.getPositionY() >= 0) {
 				visualizerPanelConstraints.gridx = metVisConfig.getPositionX();
 				visualizerPanelConstraints.gridy = metVisConfig.getPositionY();
 				if (visualizerPanelConstraints.gridy > maxYPosition)
@@ -517,58 +492,67 @@ public void actionPerformed(ActionEvent arg0) {
 			} else {
 				visualizerPanelConstraints.gridy = maxYPosition++;
 			}
-			if (metVisConfig.getColSpan() >= 1
-					&& metVisConfig.getRowSpan() >= 1) {
-				visualizerPanelConstraints.gridwidth = metVisConfig
-						.getColSpan();
-				visualizerPanelConstraints.gridheight = metVisConfig
-						.getRowSpan();
+			if (metVisConfig.getColSpan() >= 1 && metVisConfig.getRowSpan() >= 1) {
+				visualizerPanelConstraints.gridwidth = metVisConfig.getColSpan();
+				visualizerPanelConstraints.gridheight = metVisConfig.getRowSpan();
 			} else {
 				visualizerPanelConstraints.gridwidth = 1;
 				visualizerPanelConstraints.gridheight = 1;
 			}
-			this.visualizerPanel.add(metricVisualizerTemp,
-					visualizerPanelConstraints);
+			this.visualizerPanel.add(metricVisualizerTemp, visualizerPanelConstraints);
 			this.registerDataComponent(metricVisualizerTemp);
 		}
 		// add multi scalar visualizer
-		for (MultiScalarVisualizerConfig multiVisConfig : config
-				.getMultiScalarVisualizerConfigs()) {
-			MultiScalarVisualizer metricVisualizerTemp = new MultiScalarVisualizer(
-					this, multiVisConfig);
-
-			if (multiVisConfig.getPositionX() >= 0
-					&& multiVisConfig.getPositionY() >= 0) {
-				visualizerPanelConstraints.gridx = multiVisConfig
-						.getPositionX();
-				visualizerPanelConstraints.gridy = multiVisConfig
-						.getPositionY();
+		for (MultiScalarVisualizerConfig multiVisConfig : config.getMultiScalarVisualizerConfigs()) {
+			MultiScalarVisualizer metricVisualizerTemp = new MultiScalarVisualizer(this, multiVisConfig);
+
+			if (multiVisConfig.getPositionX() >= 0 && multiVisConfig.getPositionY() >= 0) {
+				visualizerPanelConstraints.gridx = multiVisConfig.getPositionX();
+				visualizerPanelConstraints.gridy = multiVisConfig.getPositionY();
 				if (visualizerPanelConstraints.gridy > maxYPosition)
 					maxYPosition = visualizerPanelConstraints.gridy;
 			} else {
 				visualizerPanelConstraints.gridy = maxYPosition++;
 			}
-			if (multiVisConfig.getColSpan() >= 1
-					&& multiVisConfig.getRowSpan() >= 1) {
-				visualizerPanelConstraints.gridwidth = multiVisConfig
-						.getColSpan();
-				visualizerPanelConstraints.gridheight = multiVisConfig
-						.getRowSpan();
+			if (multiVisConfig.getColSpan() >= 1 && multiVisConfig.getRowSpan() >= 1) {
+				visualizerPanelConstraints.gridwidth = multiVisConfig.getColSpan();
+				visualizerPanelConstraints.gridheight = multiVisConfig.getRowSpan();
 			} else {
 				visualizerPanelConstraints.gridwidth = 1;
 				visualizerPanelConstraints.gridheight = 1;
 			}
 
-			this.visualizerPanel.add(metricVisualizerTemp,
-					visualizerPanelConstraints);
+			this.visualizerPanel.add(metricVisualizerTemp, visualizerPanelConstraints);
 			this.registerDataComponent(metricVisualizerTemp);
 		}
+		// add label visualizers
+		for (LabelVisualizerConfig labelVisConfig : config.getLabelVisualizerConfigs()) {
+			LabelVisualizer labelVisualizerTemp = new LabelVisualizer(this, labelVisConfig);
+
+			if (labelVisConfig.getPositionX() >= 0 && labelVisConfig.getPositionY() >= 0) {
+				visualizerPanelConstraints.gridx = labelVisConfig.getPositionX();
+				visualizerPanelConstraints.gridy = labelVisConfig.getPositionY();
+				if (visualizerPanelConstraints.gridy > maxYPosition)
+					maxYPosition = visualizerPanelConstraints.gridy;
+			} else {
+				visualizerPanelConstraints.gridy = maxYPosition++;
+			}
+			if (labelVisConfig.getColSpan() >= 1 && labelVisConfig.getRowSpan() >= 1) {
+				visualizerPanelConstraints.gridwidth = labelVisConfig.getColSpan();
+				visualizerPanelConstraints.gridheight = labelVisConfig.getRowSpan();
+			} else {
+				visualizerPanelConstraints.gridwidth = 1;
+				visualizerPanelConstraints.gridheight = 1;
+			}
+
+			this.visualizerPanel.add(labelVisualizerTemp, visualizerPanelConstraints);
+			this.registerDataComponent(labelVisualizerTemp);
+		}
 		// add log display
 		for (LogDisplayConfig logDisConfig : config.getLogDisplayConfigs()) {
 			LogDisplay logDisplayTemp = new LogDisplay(this, logDisConfig);
 
-			if (logDisConfig.getPositionX() >= 0
-					&& logDisConfig.getPositionY() >= 0) {
+			if (logDisConfig.getPositionX() >= 0 && logDisConfig.getPositionY() >= 0) {
 				visualizerPanelConstraints.gridx = logDisConfig.getPositionX();
 				visualizerPanelConstraints.gridy = logDisConfig.getPositionY();
 				if (visualizerPanelConstraints.gridy > maxYPosition)
@@ -576,26 +560,21 @@ public void actionPerformed(ActionEvent arg0) {
 			} else {
 				visualizerPanelConstraints.gridy = maxYPosition++;
 			}
-			if (logDisConfig.getColSpan() >= 1
-					&& logDisConfig.getRowSpan() >= 1) {
-				visualizerPanelConstraints.gridwidth = logDisConfig
-						.getColSpan();
-				visualizerPanelConstraints.gridheight = logDisConfig
-						.getRowSpan();
+			if (logDisConfig.getColSpan() >= 1 && logDisConfig.getRowSpan() >= 1) {
+				visualizerPanelConstraints.gridwidth = logDisConfig.getColSpan();
+				visualizerPanelConstraints.gridheight = logDisConfig.getRowSpan();
 			} else {
 				visualizerPanelConstraints.gridwidth = 1;
 				visualizerPanelConstraints.gridheight = 1;
 			}
-			this.visualizerPanel
-					.add(logDisplayTemp, visualizerPanelConstraints);
+			this.visualizerPanel.add(logDisplayTemp, visualizerPanelConstraints);
 			this.dataComponents.add(logDisplayTemp);
 			logDisplayTemp.start();
 		}
 
 		JScrollPane dataScrollPanel = new JScrollPane(this.visualizerPanel);
 		dataScrollPanel.setPreferredSize(config.getVisualizerPanelSize());
-		this.visualizerPanel.setPreferredSize(config
-				.getInnerVisualizerPanelSize());
+		this.visualizerPanel.setPreferredSize(config.getInnerVisualizerPanelSize());
 
 		this.setLayout(new BoxLayout(this.getContentPane(), BoxLayout.X_AXIS));
 		this.getContentPane().add(this.leftSidePanel);
@@ -624,10 +603,8 @@ public void updateData(BatchData b) {
 		BatchData tempBatch = b;
 
 		// scaling
-		if (this.config.getScalingExpression() != null
-				&& !this.config.getScalingExpression().equals("none")) {
-			tempBatch = BatchHandler.scaleTimestamp(b,
-					this.config.getScalingExpression());
+		if (this.config.getScalingExpression() != null && !this.config.getScalingExpression().equals("none")) {
+			tempBatch = BatchHandler.scaleTimestamp(b, this.config.getScalingExpression());
 		}
 
 		for (Component c : this.dataComponents) {
@@ -640,6 +617,9 @@ public void updateData(BatchData b) {
 			if (c instanceof MultiScalarVisualizer) {
 				((MultiScalarVisualizer) c).updateData(tempBatch);
 			}
+			if (c instanceof LabelVisualizer) {
+				((LabelVisualizer) c).updateData(tempBatch);
+			}
 		}
 	}
 
@@ -656,19 +636,15 @@ public void initData(BatchData b) {
 		// scaling
 		if (MainDisplay.config.getScalingExpression() != null
 				&& !MainDisplay.config.getScalingExpression().equals("none")) {
-			tempBatch = BatchHandler.scaleTimestamp(b,
-					MainDisplay.config.getScalingExpression());
+			tempBatch = BatchHandler.scaleTimestamp(b, MainDisplay.config.getScalingExpression());
 		}
 
 		for (Component c : this.dataComponents) {
 			if (c instanceof StatsDisplay) {
 				if (this.liveDisplay)
-					((StatsDisplay) c).initData(tempBatch,
-							batchHandler.getDir());
+					((StatsDisplay) c).initData(tempBatch, batchHandler.getDir());
 				else
-					((StatsDisplay) c).initData(tempBatch,
-							batchHandler.getDir(),
-							batchHandler.getMinTimestamp(),
+					((StatsDisplay) c).initData(tempBatch, batchHandler.getDir(), batchHandler.getMinTimestamp(),
 							batchHandler.getMaxTimestamp());
 			}
 			if (c instanceof MetricVisualizer) {
@@ -677,7 +653,13 @@ public void initData(BatchData b) {
 			if (c instanceof MultiScalarVisualizer) {
 				((MultiScalarVisualizer) c).initData(tempBatch);
 			}
+			if (c instanceof LabelVisualizer) {
+				((LabelVisualizer) c).initData(tempBatch);
+			}
 		}
+
+		// sync x-axises of metric and label visualizers
+		setSync();
 	}
 
 	/** register components to recieve the batchdata objects **/
@@ -697,6 +679,9 @@ public void reset() {
 			if (c instanceof MultiScalarVisualizer) {
 				((MultiScalarVisualizer) c).reset();
 			}
+			if (c instanceof LabelVisualizer) {
+				((LabelVisualizer) c).reset();
+			}
 		}
 	}
 
@@ -738,16 +723,13 @@ public void initBatchHandler() throws IOException {
 		if (!this.liveDisplay) {
 			File f;
 			if (this.zipMode.equals(ZipMode.runs)) {
-				f = new File(this.batchHandler.getDir() + "run."
-						+ this.batchHandler.getRunId()
+				f = new File(this.batchHandler.getDir() + "run." + this.batchHandler.getRunId()
 						+ Config.get("SUFFIX_ZIP_FILE"));
 				if (f.exists() && !f.isDirectory()) {
 					this.batchHandler.updateBatches();
 					this.batchHandler.init();
 				} else {
-					Log.info("Zip '"
-							+ f.getPath()
-							+ "' not existing, BatchHandler could not be initialized.");
+					Log.info("Zip '" + f.getPath() + "' not existing, BatchHandler could not be initialized.");
 				}
 			} else {
 				f = new File(this.batchHandler.getDir());
@@ -755,25 +737,20 @@ public void initBatchHandler() throws IOException {
 					this.batchHandler.updateBatches();
 					this.batchHandler.init();
 				} else {
-					Log.info("Dir '"
-							+ f.getPath()
-							+ "' not existing, BatchHandler could not be initialized.");
+					Log.info("Dir '" + f.getPath() + "' not existing, BatchHandler could not be initialized.");
 				}
 			}
 		}
 	}
 
 	/** Creates and inits a new BatchHandler. **/
-	protected void createBatchHandler(MainDisplayConfig config)
-			throws IOException {
-		createBatchHandler(config.getDefaultDir(), this, liveDisplay,
-				this.zipMode);
+	protected void createBatchHandler(MainDisplayConfig config) throws IOException {
+		createBatchHandler(config.getDefaultDir(), this, liveDisplay, this.zipMode);
 	}
 
-	protected void createBatchHandler(String dataDir, MainDisplay display,
-			boolean liveFlag, ZipMode zipMode) throws IOException {
-		display.setBatchHandler(new BatchHandler(dataDir, display, liveFlag,
-				zipMode));
+	protected void createBatchHandler(String dataDir, MainDisplay display, boolean liveFlag, ZipMode zipMode)
+			throws IOException {
+		display.setBatchHandler(new BatchHandler(dataDir, display, liveFlag, zipMode));
 		display.initBatchHandler();
 	}
 
@@ -782,15 +759,14 @@ public void setBatchHandlerDir(String dir) {
 		if (this.zipMode.equals(ZipMode.runs)) {
 			try {
 				String[] splits = dir.split(Dir.delimiter);
-				this.batchHandler.setRunId(Dir.getRun(splits[splits.length - 1]
-						.replace(Config.get("SUFFIX_ZIP_FILE"), "")));
+				this.batchHandler
+						.setRunId(Dir.getRun(splits[splits.length - 1].replace(Config.get("SUFFIX_ZIP_FILE"), "")));
 				String tempDir = "";
 				for (int i = 0; i < splits.length - 1; i++)
 					tempDir += splits[i] + Dir.delimiter;
 				this.batchHandler.setDir(tempDir);
 			} catch (NumberFormatException e) {
-				Log.warn("NumberFormatException on dir '" + dir
-						+ "', no run-zip.");
+				Log.warn("NumberFormatException on dir '" + dir + "', no run-zip.");
 			}
 		} else {
 			this.batchHandler.setDir(dir);
@@ -863,7 +839,9 @@ public long getPreviousTimestamp(long timestamp) {
 		return this.batchHandler.getPreviousTimestamp(timestamp);
 	}
 
-	/** called from the statsdisplay to get the amount of previous timestamps **/
+	/**
+	 * called from the statsdisplay to get the amount of previous timestamps
+	 **/
 	public int getAmountOfPreviousTimestamps(long timestamp) {
 		return this.batchHandler.getAmountOfPreviousTimestamps(timestamp);
 	}
@@ -917,4 +895,67 @@ public void setLocked(boolean locked) {
 			}
 		}
 	}
+
+	/**
+	 * Broadcasts a x1 size slider change to all registered data components.
+	 **/
+	public void broadcastX1SizeSliderChange(Component source, int value) {
+		for (Component c : this.dataComponents) {
+			// dont broadcast to source
+			if (!c.equals(source)) {
+				if (c instanceof MetricVisualizer) {
+					((MetricVisualizer) c).setX1IntervalSizeSlider(value);
+				}
+				if (c instanceof LabelVisualizer) {
+					((LabelVisualizer) c).setX1IntervalSizeSlider(value);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Broadcasts a x1 interval scroll bar change to all registered data
+	 * components.
+	 **/
+	public void broadcastX1IntervalScrollBarChange(Component source, int value) {
+		for (Component c : this.dataComponents) {
+			// dont broadcast to source
+			if (!c.equals(source)) {
+				if (c instanceof MetricVisualizer) {
+					((MetricVisualizer) c).setX1IntervalScrollBar(value);
+				}
+				if (c instanceof LabelVisualizer) {
+					((LabelVisualizer) c).setX1IntervalScrollBar(value);
+				}
+			}
+		}
+	}
+
+	public void broadcastX1IntervalEnabled(Component source, boolean enabled) {
+		for (Component c : this.dataComponents) {
+			// dont broadcast to source
+			if (!c.equals(source)) {
+				if (c instanceof MetricVisualizer) {
+					((MetricVisualizer) c).setX1IntervalEnabled(enabled);
+				}
+				if (c instanceof LabelVisualizer) {
+					((LabelVisualizer) c).setX1IntervalEnabled(enabled);
+				}
+			}
+		}
+	}
+
+	public void setSync() {
+		Visualizer source = null;
+		for (Component c : this.dataComponents) {
+			if (c instanceof MetricVisualizer || c instanceof LabelVisualizer) {
+				if (source == null) {
+					source = (Visualizer) c;
+				} else {
+					((Visualizer) c).getChart().setSynchronizedXStartChart(source.getChart());
+				}
+			}
+		}
+	}
+
 }
diff --git a/src/dna/visualization/components/statsdisplay/StatsDisplay.java b/src/dna/visualization/components/statsdisplay/StatsDisplay.java
index 38109bc6..bacc803c 100644
--- a/src/dna/visualization/components/statsdisplay/StatsDisplay.java
+++ b/src/dna/visualization/components/statsdisplay/StatsDisplay.java
@@ -26,6 +26,7 @@
 import dna.series.data.BatchData;
 import dna.series.data.RunTime;
 import dna.series.data.Value;
+import dna.util.Config;
 import dna.util.Log;
 import dna.visualization.MainDisplay;
 import dna.visualization.config.components.StatsDisplayConfig;
@@ -681,8 +682,14 @@ public void updateMetricRuntimeValue(String name, double value) {
 	/** Sets the shown timestamp **/
 	public void setTimestamp(long timestamp) {
 		this.timestampLongValue.setText("" + timestamp);
+		
+		long tempTimestamp = timestamp;
+		if (Config.getBoolean("VISUALIZATION_TIMESTAMP_AS_SECOND")) {
+			tempTimestamp= (timestamp+ Config.getInt("VISUALIZATION_TIMESTAMP_OFFSET")) * 1000;
+		}
+		
 		this.timestampDateValue.setText(this.dateFormat.format(new Date(
-				timestamp)));
+				tempTimestamp)));
 		this.validate();
 	}
 
diff --git a/src/dna/visualization/components/visualizer/CircularArrayList.java b/src/dna/visualization/components/visualizer/CircularArrayList.java
new file mode 100644
index 00000000..f1187afe
--- /dev/null
+++ b/src/dna/visualization/components/visualizer/CircularArrayList.java
@@ -0,0 +1,136 @@
+package dna.visualization.components.visualizer;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.RandomAccess;
+
+/**
+ * Original Source:
+ * http://www.museful.net/2012/software-development/circulararraylist-for-java
+ * 
+ * If you use this code, please consider notifying isak at du-preez dot com with
+ * a brief description of your application.
+ *
+ * This is free and unencumbered software released into the public domain.
+ * Anyone is free to copy, modify, publish, use, compile, sell, or distribute
+ * this software, either in source code form or as a compiled binary, for any
+ * purpose, commercial or non-commercial, and by any means.
+ */
+
+public class CircularArrayList<E> extends AbstractList<E> implements RandomAccess {
+
+	private final int n; // buffer length
+	private final List<E> buf; // a List implementing RandomAccess
+	private int head = 0;
+	private int tail = 0;
+
+	public CircularArrayList(int capacity) {
+		n = capacity + 1;
+		buf = new ArrayList<E>(Collections.nCopies(n, (E) null));
+	}
+
+	public int capacity() {
+		return n - 1;
+	}
+
+	private int wrapIndex(int i) {
+		int m = i % n;
+		if (m < 0) { // java modulus can be negative
+			m += n;
+		}
+		return m;
+	}
+
+	// This method is O(n) but will never be called if the
+	// CircularArrayList is used in its typical/intended role.
+	private void shiftBlock(int startIndex, int endIndex) {
+		assert (endIndex > startIndex);
+		for (int i = endIndex - 1; i >= startIndex; i--) {
+			set(i + 1, get(i));
+		}
+	}
+
+	@Override
+	public int size() {
+		return tail - head + (tail < head ? n : 0);
+	}
+
+	@Override
+	public E get(int i) {
+		if (i < 0 || i >= size()) {
+			throw new IndexOutOfBoundsException();
+		}
+		return buf.get(wrapIndex(head + i));
+	}
+
+	@Override
+	public E set(int i, E e) {
+		if (i < 0 || i >= size()) {
+			throw new IndexOutOfBoundsException();
+		}
+		return buf.set(wrapIndex(head + i), e);
+	}
+
+	@Override
+	public void add(int i, E e) {
+		int s = size();
+		if (s == n - 1) {
+			throw new IllegalStateException("Cannot add element." + " CircularArrayList is filled to capacity.");
+		}
+		if (i < 0 || i > s) {
+			throw new IndexOutOfBoundsException();
+		}
+		tail = wrapIndex(tail + 1);
+		if (i < s) {
+			shiftBlock(i, s);
+		}
+		set(i, e);
+	}
+
+	@Override
+	public E remove(int i) {
+		int s = size();
+		if (i < 0 || i >= s) {
+			throw new IndexOutOfBoundsException();
+		}
+		E e = get(i);
+		if (i > 0) {
+			shiftBlock(0, i);
+		}
+		head = wrapIndex(head + 1);
+		return e;
+	}
+
+	/**
+	 * Added for convenience.
+	 * 
+	 * @author Rwilmes
+	 */
+	public E getHead() {
+		return this.get(0);
+	}
+
+	/**
+	 * Added for convenience.
+	 * 
+	 * @author Rwilmes
+	 */
+	public E getTail() {
+		return this.get(size() - 1);
+	}
+
+	/**
+	 * Added for convenience.
+	 * 
+	 * @author Rwilmes
+	 */
+	public void addSilent(E element) {
+		if (size() == capacity()) {
+			remove(0);
+		}
+		add(element);
+	}
+
+}
\ No newline at end of file
diff --git a/src/dna/visualization/components/visualizer/LabelVisualizer.java b/src/dna/visualization/components/visualizer/LabelVisualizer.java
new file mode 100644
index 00000000..42e3e546
--- /dev/null
+++ b/src/dna/visualization/components/visualizer/LabelVisualizer.java
@@ -0,0 +1,609 @@
+package dna.visualization.components.visualizer;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionListener;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import javax.swing.BorderFactory;
+import javax.swing.border.EtchedBorder;
+import javax.swing.border.TitledBorder;
+
+import dna.labels.Label;
+import dna.labels.LabelList;
+import dna.series.data.BatchData;
+import dna.util.Config;
+import dna.visualization.MainDisplay;
+import dna.visualization.components.visualizer.traces.LabelTrace;
+import dna.visualization.config.components.LabelVisualizerConfig;
+import dna.visualization.config.components.LabelVisualizerConfig.LabelAdditionPolicy;
+import info.monitorenter.gui.chart.IAxis.AxisTitle;
+import info.monitorenter.gui.chart.ITrace2D;
+import info.monitorenter.gui.chart.ITracePoint2D;
+import info.monitorenter.gui.chart.axis.scalepolicy.AxisScalePolicyAutomaticBestFit;
+import info.monitorenter.gui.chart.axis.scalepolicy.AxisScalePolicyManualTicks;
+import info.monitorenter.gui.chart.labelformatters.LabelFormatterDate;
+import info.monitorenter.gui.chart.rangepolicies.RangePolicyFixedViewport;
+import info.monitorenter.gui.chart.rangepolicies.RangePolicyUnbounded;
+import info.monitorenter.util.Range;
+
+public class LabelVisualizer extends Visualizer {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	protected HashMap<String, LabelTrace> labelTraces;
+
+	protected HashMap<String, Integer> mapping;
+	protected HashMap<String, Color> colorMap;
+	protected int mappingCounter;
+
+	protected ArrayList<String> availableValues;
+	private LinkedList<BatchData> batchBuffer;
+	private BatchData initBatch;
+	private int bufferSize;
+	private boolean reload;
+
+	private boolean xAxisTypeTimestamp;
+	private long currentTimestamp;
+
+	// config
+	protected MainDisplay mainDisplay;
+	protected LabelVisualizerConfig config;
+
+	protected boolean automaticAddition;
+
+	protected LabelAdditionPolicy labelAdditionPolicy;
+	protected String[] labelAdditionList;
+
+	public LabelVisualizer(MainDisplay mainDisplay, LabelVisualizerConfig config) {
+		super(config.getChartSize(), config.getLegendSize());
+
+		this.x1Connected = config.getMenuBarConfig().isX1AxisConnected();
+		this.mainDisplay = mainDisplay;
+		this.labelTraces = new HashMap<String, LabelTrace>();
+		this.mapping = new HashMap<String, Integer>();
+		this.colorMap = new HashMap<String, Color>();
+		this.mappingCounter = 0;
+		this.availableValues = new ArrayList<String>();
+
+		this.bufferSize = config.getTraceLength();
+		this.TRACE_LENGTH = config.getTraceLength();
+
+		this.labelAdditionPolicy = config.getAdditionPolicy();
+		this.labelAdditionList = config.getAdditionList();
+
+		this.config = config;
+		this.automaticAddition = true;
+
+		// batch buffer
+		this.batchBuffer = new LinkedList<BatchData>();
+		this.reload = false;
+
+		// set title and border of the metric visualizer
+		TitledBorder title = BorderFactory.createTitledBorder(config.getName());
+		title.setBorder(BorderFactory.createEtchedBorder((EtchedBorder.LOWERED)));
+		title.setTitleFont(new Font(this.mainDisplay.getDefaultFont().getName(), Font.BOLD,
+				this.mainDisplay.getDefaultFont().getSize()));
+		title.setTitleColor(this.mainDisplay.getDefaultFontColor());
+		this.setBorder(title);
+
+		// if x axis type is date
+		this.xAxisTypeTimestamp = true;
+		if (config.getxAxisType().equals("date")) {
+			this.xAxisTypeTimestamp = false;
+			this.xAxis1.setFormatter(new LabelFormatterDate(new SimpleDateFormat(config.getxAxisFormat())));
+			this.xAxis1.setMajorTickSpacing(5);
+			this.xAxis1.setMinorTickSpacing(1);
+			this.xAxis1.setAxisScalePolicy(new AxisScalePolicyAutomaticBestFit());
+		}
+
+		this.xAxis1.setRangePolicy(new RangePolicyFixedViewport(new Range(0, 1)));
+
+		this.yAxis1.setAxisScalePolicy(new AxisScalePolicyManualTicks());
+		this.yAxis1.setRangePolicy(new RangePolicyFixedViewport(new Range(0, 1)));
+		this.yAxis1.setPaintScale(false);
+
+		// add menu bar
+		super.addMenuBar(config.getMenuBarConfig());
+		this.menuBar.setYCoordsLabelText("v:");
+		this.menuBar.setVisible(config.getMenuBarConfig().isVisible());
+
+		// add coordinate parsing to mouseover on chart
+		this.chart.addMouseMotionListener(new MouseMotionListener() {
+			@Override
+			public void mouseMoved(MouseEvent e) {
+				if (chart.getPointFinder().getNearestPoint(e, chart) != null) {
+					ITracePoint2D tempPointFinder = chart.getPointFinder().getNearestPoint(e, chart);
+					if (tempPointFinder != null)
+						menuBar.updateCoordsPanel(tempPointFinder.getX(), tempPointFinder.getY());
+				}
+			}
+
+			public void mouseDragged(MouseEvent e) {
+			}
+		});
+
+		// apply config
+		this.chart.setPreferredSize(config.getChartSize());
+		this.legend.setLegendSize(config.getLegendSize());
+
+		this.xAxis1.setAxisTitle(new AxisTitle(config.getX1AxisTitle()));
+		this.yAxis1.setAxisTitle(new AxisTitle(config.getY1AxisTitle()));
+
+	}
+
+	/** initializes the data with the first batch **/
+	public void initData(BatchData b) {
+		long timestamp = b.getTimestamp();
+
+		if (Config.getBoolean("VISUALIZATION_TIMESTAMP_AS_SECOND")) {
+			timestamp = (timestamp + Config.getInt("VISUALIZATION_TIMESTAMP_OFFSET")) * 1000;
+		}
+
+		this.initBatch = b;
+		this.minTimestamp = timestamp;
+		this.maxTimestamp = timestamp;
+		this.minShownTimestamp = timestamp;
+		this.maxShownTimestamp = this.minShownTimestamp;
+
+		this.currentTimestamp = timestamp;
+
+		// clear chart
+		for (ITrace2D t : this.chart.getTraces()) {
+			t.removeAllPoints();
+		}
+
+		for (String name : this.labelTraces.keySet()) {
+			this.labelTraces.get(name).setLastTimestamp(timestamp - 1);
+		}
+
+		// gather all available values
+		for (Label label : b.getLabels().getList()) {
+			String key = getLabelKey(label.getName(), label.getType());
+			this.availableValues.add(key);
+
+			this.handleAutomaticAdditions(key);
+			// if (this.automaticAddition)
+			// this.legend.addLabelItemToList(key);
+		}
+
+		// init addbox
+		String[] tempValues = this.gatherValues(b);
+		this.legend.updateAddBox(tempValues);
+
+		// toggle visibility and validate
+		this.toggleYAxisVisibility();
+		this.validate();
+	}
+
+	/** gathers all plottable values from the batch **/
+	public String[] gatherValues(BatchData b) {
+		ArrayList<String> tempList = new ArrayList<String>();
+		tempList.add("labels");
+
+		ArrayList<String> labelers = new ArrayList<String>();
+		ArrayList<ArrayList<String>> types = new ArrayList<ArrayList<String>>();
+
+		for (Label l : b.getLabels().getList()) {
+			String name = l.getName();
+			String type = l.getType();
+
+			if (!labelers.contains(name)) {
+				labelers.add(name);
+				types.add(new ArrayList<String>());
+			}
+
+			int index = labelers.indexOf(name);
+			ArrayList<String> typesList = types.get(index);
+
+			if (!typesList.contains(type))
+				typesList.add(type);
+		}
+
+		// store original indices before sorting
+		HashMap<String, Integer> indexMap = new HashMap<String, Integer>();
+		for (int i = 0; i < labelers.size(); i++)
+			indexMap.put(labelers.get(i), i);
+
+		// sort labelers alphabetically
+		Collections.sort(labelers);
+
+		// fill templist
+		for (int i = 0; i < labelers.size(); i++) {
+			String name = labelers.get(i);
+			tempList.add("--- " + name);
+
+			ArrayList<String> ts = types.get(indexMap.get(name));
+			Collections.sort(ts);
+
+			for (String type : ts)
+				tempList.add("----- " + name + "." + type);
+		}
+
+		String[] tempValues = tempList.toArray(new String[tempList.size()]);
+		return tempValues;
+	}
+
+	/** adds trace to the visualizer with default trace length **/
+	public void addTrace(String name, Color color) {
+		if (!this.labelTraces.containsKey(name)) {
+			int yMapping = this.getLabelerTypeKeyMapping(name);
+			this.colorMap.put(name, color);
+			LabelTrace labelTrace = new LabelTrace(this, this.chart, name, yMapping, 10, color, this.currentTimestamp);
+			this.labelTraces.put(name, labelTrace);
+		}
+
+		this.updateTraceSizes();
+		this.updateYAxisRange();
+	}
+
+	/**
+	 * If the name is already being mapped it returns the mapping. Else a new
+	 * one is created and returned.
+	 **/
+	protected int getLabelerTypeKeyMapping(String labelerTypeKey) {
+		if (this.mapping.containsKey(labelerTypeKey))
+			return this.mapping.get(labelerTypeKey);
+
+		int newMapping = this.mappingCounter;
+		this.mapping.put(labelerTypeKey, newMapping);
+		this.mappingCounter--;
+
+		return newMapping;
+	}
+
+	/**
+	 * removes a trace from the chart and the traces-list and the current traces
+	 **/
+	public void removeTrace(String name) {
+		if (this.labelTraces.containsKey(name)) {
+			LabelTrace trace = this.labelTraces.get(name);
+			trace.clear();
+			this.labelTraces.remove(name);
+		}
+
+		this.toggleXAxisVisibility();
+		this.toggleYAxisVisibility();
+
+		this.updateTraceSizes();
+		this.updateYAxisRange();
+	}
+
+	/** Updates the trace sizes. **/
+	protected void updateTraceSizes() {
+		int traces = this.labelTraces.size();
+		for (String name : this.labelTraces.keySet()) {
+			LabelTrace trace = this.labelTraces.get(name);
+			trace.setSize(this.getTraceSize(traces));
+		}
+	}
+
+	/** Returns the trace size of a trace based on the number of traces. **/
+	protected int getTraceSize(int traces) {
+		int paddings = 50; // this will be substracted from the absolute height
+		int chartHeight = (int) Math.floor(this.config.getChartSize().getHeight()) - paddings;
+		int individualHeight = (int) Math.floor((this.config.getBarThickness() * chartHeight) / traces);
+
+		return individualHeight;
+	}
+
+	/** Updates the YAxisRange. **/
+	protected void updateYAxisRange() {
+		this.yAxis1.setRangePolicy(new RangePolicyFixedViewport(getYAxisRange()));
+	}
+
+	/** Returns the y-axis range based on the number of traces. **/
+	protected Range getYAxisRange() {
+		int max = 0;
+		int min = 0;
+		boolean first = true;
+		for (String name : this.labelTraces.keySet()) {
+			int y = this.labelTraces.get(name).getYMapping();
+			if (first) {
+				max = y;
+				min = y;
+				first = false;
+			} else {
+				max = Math.max(max, y);
+				min = Math.min(min, y);
+			}
+		}
+		return new Range(min - 1, max + 1);
+	}
+
+	/**
+	 * Updates the chart and the legend with a new batch.
+	 * 
+	 * @param b
+	 *            New batch
+	 */
+	public void updateData(BatchData b) {
+		long timestamp = b.getTimestamp();
+
+		if (Config.getBoolean("VISUALIZATION_TIMESTAMP_AS_SECOND")) {
+			timestamp = (timestamp + Config.getInt("VISUALIZATION_TIMESTAMP_OFFSET")) * 1000;
+		}
+
+		double timestampDouble = timestamp;
+
+		// check if new batch is before last one which means time slided
+		// backwards
+		if (timestamp < this.currentTimestamp) {
+			while (this.batchBuffer.size() > 0) {
+				if (this.batchBuffer.getLast().getTimestamp() <= b.getTimestamp()) {
+					break;
+				} else {
+					this.batchBuffer.removeLast();
+				}
+			}
+
+			// reload data
+			this.reloadData();
+			// this.updateData(b);
+		} else {
+			// if reload flag is set, dont add batch to buffer
+			if (!this.reload) {
+				// if buffer sizer is reached, remove batches until its
+				if (this.batchBuffer.size() >= this.bufferSize)
+					while (!(this.batchBuffer.size() < this.bufferSize))
+						this.batchBuffer.removeFirst();
+				// add new batch as last batch to list
+				this.batchBuffer.addLast(b);
+			}
+
+			this.currentTimestamp = timestamp;
+
+			if (timestamp < this.minTimestamp)
+				this.minTimestamp = timestamp;
+			if (timestamp > this.maxTimestamp)
+				this.maxTimestamp = timestamp;
+
+			// iterate over all added traces
+			LabelList labels = b.getLabels();
+
+			for (String name : this.labelTraces.keySet()) {
+				LabelTrace labelTrace = this.labelTraces.get(name);
+				boolean updated = false;
+				for (Label l : labels.getList()) {
+					String key = getLabelKey(l.getName(), l.getType());
+					if (key.equals(name)) {
+						labelTrace.update(timestampDouble, l);
+						updated = true;
+						break;
+					}
+				}
+
+				if (!updated)
+					labelTrace.update(timestampDouble, null);
+			}
+
+			if (this.FIXED_VIEWPORT) {
+				this.setXAxis1RangeByIntervalSelection();
+			} else {
+				this.xAxis1.setRange(new Range(minTimestamp, maxTimestamp));
+			}
+
+			// update chart axis ticks
+			this.updateTicks();
+
+			// check if new label contained in the batch
+			boolean newLabelFound = false;
+
+			for (Label l : labels.getList()) {
+				String name = l.getName();
+				String type = l.getType();
+
+				String key = getLabelKey(name, type);
+
+				if (!this.availableValues.contains(key)) {
+					newLabelFound = true;
+					this.availableValues.add(key);
+
+					this.handleAutomaticAdditions(key);
+					// if (this.automaticAddition)
+					// this.legend.addLabelItemToList(key);
+				}
+			}
+
+			if (newLabelFound)
+				this.legend.updateAddBox(this.gatherAddBoxChoicesFromAvailableValues());
+		}
+
+		this.validate();
+	}
+
+	/** Handles the automatic additions given the policy. **/
+	protected void handleAutomaticAdditions(String key) {
+		switch (this.labelAdditionPolicy) {
+		case AUTOMATIC_ADDITION_ALL:
+			this.addLabelItemToList(key);
+			break;
+		case AUTOMATIC_ADDITION_LIST:
+			for (String s : this.labelAdditionList) {
+				if (s.equals(key)) {
+					this.addLabelItemToList(key);
+					break;
+				}
+			}
+			break;
+		case MANUAL:
+			// do nothing
+			break;
+		}
+	}
+
+	/**
+	 * Adds a label item to the legend list (same as when selected from addbox.
+	 **/
+	protected void addLabelItemToList(String key) {
+		this.legend.addLabelItemToList(key);
+	}
+
+	/** Gathers all currently available addbox-choices. **/
+	protected String[] gatherAddBoxChoicesFromAvailableValues() {
+		ArrayList<String> addBoxList = new ArrayList<String>();
+		addBoxList.add("labels");
+
+		HashMap<String, ArrayList<String>> labelers = new HashMap<String, ArrayList<String>>();
+
+		// split available value-keys by .
+		for (String keys : this.availableValues) {
+			String[] splits = keys.split("\\.");
+			String name = splits[0];
+			String type = splits[1];
+
+			for (int i = 2; i < splits.length; i++)
+				type += "." + splits[i];
+
+			ArrayList<String> tempList;
+			if (labelers.containsKey(name)) {
+				tempList = labelers.get(name);
+			} else {
+				tempList = new ArrayList<String>();
+				labelers.put(name, tempList);
+			}
+
+			tempList.add(type);
+		}
+
+		for (String l : labelers.keySet()) {
+			addBoxList.add("--- " + l);
+			for (String t : labelers.get(l))
+				addBoxList.add("----- " + getLabelKey(l, t));
+		}
+
+		String[] tempValues = addBoxList.toArray(new String[addBoxList.size()]);
+		return tempValues;
+	}
+
+	/** Returns the key of a label based on its name and type. **/
+	protected String getLabelKey(String name, String type) {
+		return name + "." + type;
+	}
+
+	/** reloads all data included in the batchBuffer **/
+	private void reloadData() {
+		// set reload flag
+		this.reload = true;
+
+		// reset current timestamp
+		this.currentTimestamp = 0;
+
+		// clear chart
+		for (String name : this.labelTraces.keySet()) {
+			LabelTrace trace = this.labelTraces.get(name);
+			trace.clear();
+		}
+
+		// update with old batches
+		Iterator<BatchData> iterator = this.batchBuffer.iterator();
+		while (iterator.hasNext()) {
+			this.updateData(iterator.next());
+		}
+
+		// unset reload flag
+		this.reload = false;
+	}
+
+	/** resets the metric visualizer **/
+	public void reset() {
+		this.minShownTimestamp = 0;
+		this.maxShownTimestamp = 10;
+
+		// clear labels
+		for (String name : this.labelTraces.keySet()) {
+			LabelTrace trace = this.labelTraces.get(name);
+			trace.clear();
+		}
+		this.batchBuffer.clear();
+		this.availableValues.clear();
+		this.chart.updateUI();
+	}
+
+	/** handles the ticks that are shown on the x axis **/
+	@Override
+	protected void updateX1Ticks() {
+		if (this.xAxisTypeTimestamp) {
+			double minTemp = 0;
+			double maxTemp = 10;
+			if (this.xAxis1.getRangePolicy() instanceof RangePolicyUnbounded) {
+				minTemp = this.minTimestamp * 1.0;
+				maxTemp = this.maxTimestamp * 1.0;
+			} else {
+				if (this.xAxis1.getRangePolicy() instanceof RangePolicyFixedViewport) {
+					minTemp = this.minShownTimestamp;
+					maxTemp = this.maxShownTimestamp;
+				}
+			}
+			if (maxTemp > minTemp) {
+				double range = maxTemp - minTemp;
+				if (range > 0) {
+					double tickSpacingNew = Math.floor(range / 10);
+					if (tickSpacingNew < 1)
+						tickSpacingNew = 1.0;
+					this.xAxis1.setMajorTickSpacing(tickSpacingNew);
+					this.xAxis1.setMinorTickSpacing(tickSpacingNew);
+				}
+			}
+		}
+	}
+
+	/** shows/hides a trace from the chart without deleting it **/
+	public void toggleTraceVisibility(String name) {
+		if (this.labelTraces.containsKey(name)) {
+			LabelTrace trace = this.labelTraces.get(name);
+			if (trace.isVisible())
+				trace.setVisible(false);
+			else
+				trace.setVisible(true);
+		}
+		this.chart.setRequestedRepaint(true);
+	}
+
+	/** Returns the value at the given y-location. **/
+	public String getValue(double x, double y) {
+		String value = "unknown";
+		int yFloored = (int) Math.floor(y);
+		for (String key : this.labelTraces.keySet()) {
+			LabelTrace label = this.labelTraces.get(key);
+			if (yFloored == label.getYMapping()) {
+				value = label.getValue(x);
+				break;
+			}
+		}
+		return value;
+	}
+
+	/** Updates the according legend item. **/
+	public void updateItem(String name, String value) {
+		this.legend.updateItem(name, value);
+	}
+
+	@Override
+	public void broadcastX1IntervalSizeSliderChange(int value) {
+		if (this.isX1Connected())
+			this.mainDisplay.broadcastX1SizeSliderChange(this, value);
+	}
+
+	@Override
+	public void broadcastX1IntervalScrollBarChange(int value) {
+		if (this.isX1Connected())
+			this.mainDisplay.broadcastX1IntervalScrollBarChange(this, value);
+	}
+
+	@Override
+	public void broadcastX1IntervalEnabled(boolean enabled) {
+		if (this.isX1Connected())
+			this.mainDisplay.broadcastX1IntervalEnabled(this, enabled);
+	}
+
+}
diff --git a/src/dna/visualization/components/visualizer/Legend.java b/src/dna/visualization/components/visualizer/Legend.java
index 3321a081..12cd34f6 100644
--- a/src/dna/visualization/components/visualizer/Legend.java
+++ b/src/dna/visualization/components/visualizer/Legend.java
@@ -74,19 +74,15 @@ public Legend(Visualizer parent, Dimension size) {
 		c.gridy = 0;
 		this.add(list, c);
 		this.scrollPane = new JScrollPane(this.list);
-		this.scrollPane.setPreferredSize(new Dimension(size.width - 3,
-				size.height - 25));
-		this.scrollPane
-				.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
+		this.scrollPane.setPreferredSize(new Dimension(size.width - 3, size.height - 25));
+		this.scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
 		this.add(scrollPane);
 
 		// init addbutton panel and add it
 		this.addButtonPanel = new JPanel();
 		this.addButtonPanel.setPreferredSize(new Dimension(size.width - 3, 20));
-		this.addButtonPanel.setBorder(BorderFactory
-				.createEtchedBorder((EtchedBorder.LOWERED)));
-		this.addButtonPanel.setLayout(new BoxLayout(this.addButtonPanel,
-				BoxLayout.X_AXIS));
+		this.addButtonPanel.setBorder(BorderFactory.createEtchedBorder((EtchedBorder.LOWERED)));
+		this.addButtonPanel.setLayout(new BoxLayout(this.addButtonPanel, BoxLayout.X_AXIS));
 
 		c.gridx = 0;
 		c.gridy = 1;
@@ -96,13 +92,43 @@ public Legend(Visualizer parent, Dimension size) {
 	}
 
 	public void setLegendSize(Dimension size) {
-		this.scrollPane.setPreferredSize(new Dimension(size.width - 3,
-				size.height - 25));
+		this.scrollPane.setPreferredSize(new Dimension(size.width - 3, size.height - 25));
 		this.addButtonPanel.setPreferredSize(new Dimension(size.width - 3, 20));
 		this.validate();
 	}
 
-	/** adds a value item to the list, if its already added nothing will happen **/
+	/**
+	 * adds a label item to the list, if its already added nothing will happen
+	 **/
+	public void addLabelItemToList(String name) {
+		boolean alreadyAdded = false;
+		for (Component c : this.list.getComponents()) {
+			if (c instanceof LegendItem) {
+				if (c.getName().equals(name)) {
+					alreadyAdded = true;
+				}
+			}
+		}
+
+		if (!alreadyAdded) {
+			Color color = this.colorHandler.getNextColor();
+
+			LegendItem i = new LegendItemLabel(this.list, name, color);
+			i.setToolTipText(Legend.getToolTipText(name));
+			this.list.add(i);
+			if (this.parent instanceof LabelVisualizer)
+				((LabelVisualizer) this.parent).addTrace(name, color);
+
+			this.parent.updateTicks();
+		}
+		this.parent.toggleXAxisVisibility();
+		this.parent.toggleYAxisVisibility();
+		this.validate();
+	}
+
+	/**
+	 * adds a value item to the list, if its already added nothing will happen
+	 **/
 	public void addValueItemToList(String name) {
 		boolean alreadyAdded = false;
 		for (Component c : this.list.getComponents()) {
@@ -147,8 +173,7 @@ public void addValueItemToList(MetricVisualizerItem item) {
 			String name = item.getName();
 			Color color;
 
-			if ((item.getColor() != null)
-					&& this.colorHandler.containsColor(item.getColor())) {
+			if ((item.getColor() != null) && this.colorHandler.containsColor(item.getColor())) {
 				color = item.getColor();
 				this.colorHandler.addColor(color);
 			} else {
@@ -216,16 +241,13 @@ public void addDistributionItemToList(String name) {
 			if (this.parent instanceof MultiScalarVisualizer) {
 				MultiScalarVisualizerConfig config = ((MultiScalarVisualizer) this.parent).config;
 				if (config.getListConfig() != null) {
-					xAxis = config.getListConfig().getAllDistributionsConfig()
-							.getXAxis();
-					yAxis = config.getListConfig().getAllDistributionsConfig()
-							.getYAxis();
+					xAxis = config.getListConfig().getAllDistributionsConfig().getXAxis();
+					yAxis = config.getListConfig().getAllDistributionsConfig().getYAxis();
 				}
 			}
 
 			if (this.parent instanceof MultiScalarVisualizer)
-				((MultiScalarVisualizer) this.parent).addDistributionTrace(
-						name, color, xAxis, yAxis);
+				((MultiScalarVisualizer) this.parent).addDistributionTrace(name, color, xAxis, yAxis);
 			this.parent.updateTicks();
 		}
 		this.parent.toggleXAxisVisibility();
@@ -251,8 +273,7 @@ public void addDistributionItemToList(MultiScalarDistributionItem item) {
 			String name = item.getName();
 			Color color;
 
-			if ((item.getColor() != null)
-					&& this.colorHandler.containsColor(item.getColor())) {
+			if ((item.getColor() != null) && this.colorHandler.containsColor(item.getColor())) {
 				color = item.getColor();
 				this.colorHandler.addColor(color);
 			} else {
@@ -264,8 +285,8 @@ public void addDistributionItemToList(MultiScalarDistributionItem item) {
 
 			this.list.add(i);
 			if (this.parent instanceof MultiScalarVisualizer)
-				((MultiScalarVisualizer) this.parent).addDistributionTrace(
-						name, color, item.getXAxis(), item.getYAxis());
+				((MultiScalarVisualizer) this.parent).addDistributionTrace(name, color, item.getXAxis(),
+						item.getYAxis());
 
 			// usually added to x1/y1, check if config says otherways and toggle
 			// buttons accordingly
@@ -321,16 +342,13 @@ public void addNodeValueListItemToList(String name) {
 			if (this.parent instanceof MultiScalarVisualizer) {
 				MultiScalarVisualizerConfig config = ((MultiScalarVisualizer) this.parent).config;
 				if (config.getListConfig() != null) {
-					xAxis = config.getListConfig().getAllNodeValueListsConfig()
-							.getXAxis();
-					yAxis = config.getListConfig().getAllNodeValueListsConfig()
-							.getYAxis();
+					xAxis = config.getListConfig().getAllNodeValueListsConfig().getXAxis();
+					yAxis = config.getListConfig().getAllNodeValueListsConfig().getYAxis();
 				}
 			}
 
 			if (this.parent instanceof MultiScalarVisualizer)
-				((MultiScalarVisualizer) this.parent).addNodeValueListTrace(
-						name, color, xAxis, yAxis);
+				((MultiScalarVisualizer) this.parent).addNodeValueListTrace(name, color, xAxis, yAxis);
 
 			this.parent.updateTicks();
 		}
@@ -357,8 +375,7 @@ public void addNodeValueListItemToList(MultiScalarNodeValueListItem item) {
 			String name = item.getName();
 			Color color;
 
-			if ((item.getColor() != null)
-					&& this.colorHandler.containsColor(item.getColor())) {
+			if ((item.getColor() != null) && this.colorHandler.containsColor(item.getColor())) {
 				color = item.getColor();
 				this.colorHandler.addColor(color);
 			} else {
@@ -369,8 +386,8 @@ public void addNodeValueListItemToList(MultiScalarNodeValueListItem item) {
 			i.setToolTipText(Legend.getToolTipText(name));
 			this.list.add(i);
 			if (this.parent instanceof MultiScalarVisualizer)
-				((MultiScalarVisualizer) this.parent).addNodeValueListTrace(
-						name, color, item.getXAxis(), item.getYAxis());
+				((MultiScalarVisualizer) this.parent).addNodeValueListTrace(name, color, item.getXAxis(),
+						item.getYAxis());
 
 			// usually added to x1/y1, check if config says otherways and toggle
 			// buttons accordingly
@@ -410,6 +427,8 @@ public void removeItem(String name, Color color) {
 			((MetricVisualizer) this.parent).removeTrace(name);
 		if (this.parent instanceof MultiScalarVisualizer)
 			((MultiScalarVisualizer) this.parent).removeTrace(name);
+		if (this.parent instanceof LabelVisualizer)
+			((LabelVisualizer) this.parent).removeTrace(name);
 		this.colorHandler.removeColor(color);
 	}
 
@@ -422,15 +441,13 @@ public void updateAddBox(String[] addBoxChoices) {
 			@Override
 			public void actionPerformed(ActionEvent event) {
 				if (thisLegend.addBox.getSelectedItem() instanceof String) {
-					thisLegend.addSelection(thisLegend.addBox
-							.getSelectedIndex());
+					thisLegend.addSelection(thisLegend.addBox.getSelectedIndex());
 				}
 			}
 		});
 		this.addBox.setToolTipText("Add selected value to the list");
 		this.addBox.setFont(MainDisplay.config.getDefaultFont());
-		BoundsPopupMenuListener listener = new BoundsPopupMenuListener(true,
-				false);
+		BoundsPopupMenuListener listener = new BoundsPopupMenuListener(true, false);
 		this.addBox.addPopupMenuListener(listener);
 		this.addBox.setPrototypeDisplayValue("Test");
 		this.addButtonPanel.add(addBox);
@@ -448,21 +465,18 @@ private void initAddBox(String[] addBoxChoices) {
 			@Override
 			public void actionPerformed(ActionEvent event) {
 				if (thisLegend.addBox.getSelectedItem() instanceof String)
-					thisLegend.addSelection(thisLegend.addBox
-							.getSelectedIndex());
+					thisLegend.addSelection(thisLegend.addBox.getSelectedIndex());
 			}
 		});
 		this.addBox.setToolTipText("Add selected value to the list");
 		this.addBox.setFont(MainDisplay.config.getDefaultFont());
-		BoundsPopupMenuListener listener = new BoundsPopupMenuListener(true,
-				false);
+		BoundsPopupMenuListener listener = new BoundsPopupMenuListener(true, false);
 		this.addBox.addPopupMenuListener(listener);
 		this.addBox.setPrototypeDisplayValue("Test");
 
 		// create lock checkbox
 		this.lock = new JCheckBox("Lock");
-		this.lock
-				.setToolTipText("Locks the visualizer. Prevents any legend alteration on reset / directory change.");
+		this.lock.setToolTipText("Locks the visualizer. Prevents any legend alteration on reset / directory change.");
 		this.lock.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent arg0) {
@@ -498,21 +512,18 @@ public void addSelection(int selectionIndex) {
 				// each
 				if (this.addBoxMenu[selectionIndex].equals("metrics")) {
 					int x = selectionIndex + 1;
-					while (x != this.addBoxMenu.length
-							&& this.addBoxMenu[x].charAt(0) == '-') {
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].charAt(0) == '-') {
 						if (this.addBoxMenu[x].substring(0, 6).equals("----- ")) {
-							this.addValueItemToList(this.addBoxMenu[x]
-									.substring(6));
+							this.addValueItemToList(this.addBoxMenu[x].substring(6));
 						}
 						x++;
 					}
 				} else {
 					// if selected element is a category other than "metrics"
 					int x = selectionIndex + 1;
-					while (x != this.addBoxMenu.length
-							&& this.addBoxMenu[x].charAt(0) == '-') {
-						this.addValueItemToList(this.addBoxMenu[selectionIndex]
-								+ "." + this.addBoxMenu[x].substring(3));
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].charAt(0) == '-') {
+						this.addValueItemToList(
+								this.addBoxMenu[selectionIndex] + "." + this.addBoxMenu[x].substring(3));
 						x++;
 					}
 				}
@@ -521,12 +532,9 @@ public void addSelection(int selectionIndex) {
 			if (this.addBoxMenu[selectionIndex].substring(0, 3).equals("---")) {
 				// if selected element starts with "--- "
 				// means element is metric with different values
-				if (this.addBoxMenu[selectionIndex].substring(0, 4).equals(
-						"--- ")) {
+				if (this.addBoxMenu[selectionIndex].substring(0, 4).equals("--- ")) {
 					int x = selectionIndex + 1;
-					while (x != this.addBoxMenu.length
-							&& this.addBoxMenu[x].substring(0, 6).equals(
-									"----- ")) {
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].substring(0, 6).equals("----- ")) {
 						this.addValueItemToList(this.addBoxMenu[x].substring(6));
 						x++;
 					}
@@ -534,21 +542,17 @@ public void addSelection(int selectionIndex) {
 					// if selected element is single element starting with
 					// "----- "
 					// means it is a metric value without sub-elements
-					if (this.addBoxMenu[selectionIndex].substring(0, 6).equals(
-							"----- ")) {
-						this.addValueItemToList(this.addBoxMenu[selectionIndex]
-								.substring(6));
+					if (this.addBoxMenu[selectionIndex].substring(0, 6).equals("----- ")) {
+						this.addValueItemToList(this.addBoxMenu[selectionIndex].substring(6));
 					} else {
 						// if selected element starts with "---"
 						// means it is a value of runtimes or batch statistics
 						int x = selectionIndex - 1;
-						while (x > 0
-								&& (this.addBoxMenu[x].substring(0, 3)
-										.equals("---"))) {
+						while (x > 0 && (this.addBoxMenu[x].substring(0, 3).equals("---"))) {
 							x--;
 						}
-						this.addValueItemToList(this.addBoxMenu[x] + "."
-								+ this.addBoxMenu[selectionIndex].substring(3));
+						this.addValueItemToList(
+								this.addBoxMenu[x] + "." + this.addBoxMenu[selectionIndex].substring(3));
 					}
 				}
 			}
@@ -560,58 +564,101 @@ public void addSelection(int selectionIndex) {
 			if (this.addBoxMenu[selectionIndex].substring(0, 3).equals("---")) {
 				// if selected element starts with "--- "
 				// means element is metric with different values
-				if (this.addBoxMenu[selectionIndex].substring(0, 4).equals(
-						"--- ")) {
+				if (this.addBoxMenu[selectionIndex].substring(0, 4).equals("--- ")) {
 
 					// check if distributions or nodevaluelists should be added
 					boolean addDistribution;
-					if (this.addBoxMenu[selectionIndex].substring(0, 5).equals(
-							"--- D"))
+					if (this.addBoxMenu[selectionIndex].substring(0, 5).equals("--- D"))
 						addDistribution = true;
 					else
 						addDistribution = false;
 
 					int x = selectionIndex + 1;
-					while (x != this.addBoxMenu.length
-							&& this.addBoxMenu[x].substring(0, 6).equals(
-									"----- ")) {
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].substring(0, 6).equals("----- ")) {
 						if (addDistribution)
-							this.addDistributionItemToList(this.addBoxMenu[x]
-									.substring(6));
+							this.addDistributionItemToList(this.addBoxMenu[x].substring(6));
 						else
-							this.addNodeValueListItemToList(this.addBoxMenu[x]
-									.substring(6));
+							this.addNodeValueListItemToList(this.addBoxMenu[x].substring(6));
 						x++;
 					}
 				} else {
 					// if selected element is single element starting with
 					// "----- "
 					// means it is a single value without sub-elements
-					if (this.addBoxMenu[selectionIndex].substring(0, 6).equals(
-							"----- ")) {
+					if (this.addBoxMenu[selectionIndex].substring(0, 6).equals("----- ")) {
 
 						// check if a distribution or a nodevaluelist should be
 						// added
 						boolean addDistribution = true;
 						for (int i = 1; selectionIndex - i >= 0; i++) {
-							if (this.addBoxMenu[selectionIndex - i].substring(
-									0, 5).equals("--- N")) {
+							if (this.addBoxMenu[selectionIndex - i].substring(0, 5).equals("--- N")) {
 								addDistribution = false;
 								break;
 							}
-							if (this.addBoxMenu[selectionIndex - i].substring(
-									0, 5).equals("--- D")) {
+							if (this.addBoxMenu[selectionIndex - i].substring(0, 5).equals("--- D")) {
 								addDistribution = true;
 								break;
 							}
 						}
 
 						if (addDistribution)
-							this.addDistributionItemToList(this.addBoxMenu[selectionIndex]
-									.substring(6));
+							this.addDistributionItemToList(this.addBoxMenu[selectionIndex].substring(6));
 						else
-							this.addNodeValueListItemToList(this.addBoxMenu[selectionIndex]
-									.substring(6));
+							this.addNodeValueListItemToList(this.addBoxMenu[selectionIndex].substring(6));
+					}
+				}
+			}
+		}
+		// if its a label visualizer -> add label-legenditems
+		if (this.parent instanceof LabelVisualizer) {
+			// if selected element is a category
+			if (this.addBoxMenu[selectionIndex].charAt(0) != '-') {
+				// if selected element is "labels" category
+				// means it probably has different metrics with different values
+				// each
+				if (this.addBoxMenu[selectionIndex].equals("labels")) {
+					int x = selectionIndex + 1;
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].charAt(0) == '-') {
+						if (this.addBoxMenu[x].substring(0, 6).equals("----- ")) {
+							this.addLabelItemToList(this.addBoxMenu[x].substring(6));
+						}
+						x++;
+					}
+				} else {
+					// if selected element is a category other than "labels"
+					int x = selectionIndex + 1;
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].charAt(0) == '-') {
+						this.addLabelItemToList(
+								this.addBoxMenu[selectionIndex] + "." + this.addBoxMenu[x].substring(3));
+						x++;
+					}
+				}
+			}
+			// if selected element starts with "---"
+			if (this.addBoxMenu[selectionIndex].substring(0, 3).equals("---")) {
+				// if selected element starts with "--- "
+				// means element is labeler with different types
+				if (this.addBoxMenu[selectionIndex].substring(0, 4).equals("--- ")) {
+					int x = selectionIndex + 1;
+					while (x != this.addBoxMenu.length && this.addBoxMenu[x].substring(0, 6).equals("----- ")) {
+						this.addLabelItemToList(this.addBoxMenu[x].substring(6));
+						x++;
+					}
+				} else {
+					// if selected element is single element starting with
+					// "----- "
+					// means it is a labeler type pair without sub-elements
+					if (this.addBoxMenu[selectionIndex].substring(0, 6).equals("----- ")) {
+						this.addLabelItemToList(this.addBoxMenu[selectionIndex].substring(6));
+					} else {
+						// if selected element starts with "---"
+						// means it is a value of runtimes or batch statistics
+						int x = selectionIndex - 1;
+						while (x > 0 && (this.addBoxMenu[x].substring(0, 3).equals("---"))) {
+							x--;
+						}
+						this.addLabelItemToList(
+								this.addBoxMenu[x] + "." + this.addBoxMenu[selectionIndex].substring(3));
 					}
 				}
 			}
@@ -621,6 +668,11 @@ public void addSelection(int selectionIndex) {
 
 	/** updates the value of an item **/
 	public void updateItem(String name, double value) {
+		this.list.updateItem(name, "" + value);
+	}
+
+	/** updates the value of an item **/
+	public void updateItem(String name, String value) {
 		this.list.updateItem(name, value);
 	}
 
@@ -652,11 +704,12 @@ public void toggleXAxis(LegendItem item) {
 	/** toggles visiblity of a trace **/
 	public void toggleVisiblity(LegendItem item) {
 		if (this.parent instanceof MetricVisualizer)
-			((MetricVisualizer) this.parent).toggleTraceVisiblity(item
-					.getName());
+			((MetricVisualizer) this.parent).toggleTraceVisiblity(item.getName());
 		if (this.parent instanceof MultiScalarVisualizer)
-			((MultiScalarVisualizer) this.parent).toggleTraceVisiblity(item
-					.getName());
+			((MultiScalarVisualizer) this.parent).toggleTraceVisiblity(item.getName());
+		if (this.parent instanceof LabelVisualizer) {
+			((LabelVisualizer) this.parent).toggleTraceVisibility(item.getName());
+		}
 	}
 
 	/** toggles the display mode of a trace **/
@@ -664,8 +717,7 @@ public void toggleDisplayMode(LegendItem item) {
 		if (this.parent instanceof MetricVisualizer)
 			((MetricVisualizer) this.parent).toggleDisplayMode(item.getName());
 		if (this.parent instanceof MultiScalarVisualizer)
-			((MultiScalarVisualizer) this.parent).toggleDisplayMode(item
-					.getName());
+			((MultiScalarVisualizer) this.parent).toggleDisplayMode(item.getName());
 	}
 
 	/** called from an item to get resorted while paused **/
@@ -697,8 +749,7 @@ public static String getToolTipText(String name) {
 		String descr = Config.getPropertyDescription(splits[0], splits[1]);
 
 		if (descr != null) {
-			tooltip = Legend.HTML_Begin + descr + Legend.HTML_NewLine
-					+ Legend.HTML_NewLine + tooltip + Legend.HTML_End;
+			tooltip = Legend.HTML_Begin + descr + Legend.HTML_NewLine + Legend.HTML_NewLine + tooltip + Legend.HTML_End;
 		}
 
 		// return
diff --git a/src/dna/visualization/components/visualizer/LegendItem.java b/src/dna/visualization/components/visualizer/LegendItem.java
index 815869b4..3bf6fb10 100644
--- a/src/dna/visualization/components/visualizer/LegendItem.java
+++ b/src/dna/visualization/components/visualizer/LegendItem.java
@@ -19,6 +19,7 @@
 
 import dna.visualization.MainDisplay;
 import dna.visualization.config.VisualizerListConfig.yAxisSelection;
+import dna.visualization.config.components.LabelVisualizerConfig;
 import dna.visualization.config.components.MetricVisualizerConfig;
 import dna.visualization.config.components.MultiScalarVisualizerConfig;
 
@@ -76,7 +77,7 @@ public LegendItem(LegendList parent, String name, Color color) {
 			this.valueLabelSize = config.getLegendItemValueLabelSize();
 			this.valueFont = config.getLegendItemValueFont();
 			this.valueFontColor = config.getLegendItemValueFontColor();
-		} else {
+		} else if (parent.parent.parent instanceof MultiScalarVisualizer) {
 			MultiScalarVisualizerConfig config = ((MultiScalarVisualizer) parent.parent.parent).config;
 			this.buttonPanelSize = config.getLegendItemButtonPanelSize();
 			this.buttonSize = config.getLegendItemButtonSize();
@@ -85,6 +86,15 @@ public LegendItem(LegendList parent, String name, Color color) {
 			this.valueLabelSize = config.getLegendItemValueLabelSize();
 			this.valueFont = config.getLegendItemValueFont();
 			this.valueFontColor = config.getLegendItemValueFontColor();
+		} else if (parent.parent.parent instanceof LabelVisualizer) {
+			LabelVisualizerConfig config = ((LabelVisualizer) parent.parent.parent).config;
+			this.buttonPanelSize = config.getLegendItemButtonPanelSize();
+			this.buttonSize = config.getLegendItemButtonSize();
+			this.size = config.getLegendItemSize();
+			this.nameLabelSize = config.getLegendItemNameLabelSize();
+			this.valueLabelSize = config.getLegendItemValueLabelSize();
+			this.valueFont = config.getLegendItemValueFont();
+			this.valueFontColor = config.getLegendItemValueFontColor();
 		}
 		this.setPreferredSize(this.size);
 		this.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.LOWERED));
@@ -115,11 +125,9 @@ public LegendItem(LegendList parent, String name, Color color) {
 		// remove button
 		this.removeButton = new JButton("-");
 		this.removeButton.setFont(MainDisplay.config.getDefaultFont());
-		this.removeButton.setForeground(MainDisplay.config
-				.getDefaultFontColor());
+		this.removeButton.setForeground(MainDisplay.config.getDefaultFontColor());
 		this.removeButton.setPreferredSize(this.buttonSize);
-		this.removeButton
-				.setToolTipText("Removes this value from list and plot.");
+		this.removeButton.setToolTipText("Removes this value from list and plot.");
 		this.removeButton.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent event) {
@@ -127,18 +135,16 @@ public void actionPerformed(ActionEvent event) {
 			}
 		});
 		this.removeButton.setMargin(new Insets(0, 0, 0, 0));
-		this.removeButton.setFont(new Font(this.removeButton.getFont()
-				.getName(), this.removeButton.getFont().getStyle(), 17));
+		this.removeButton
+				.setFont(new Font(this.removeButton.getFont().getName(), this.removeButton.getFont().getStyle(), 17));
 
 		// toggle y axis button
 		this.toggleYAxisButton = new JButton("y1");
 		this.toggleYAxisButton.setFont(MainDisplay.config.getDefaultFont());
-		this.toggleYAxisButton.setForeground(MainDisplay.config
-				.getDefaultFontColor());
+		this.toggleYAxisButton.setForeground(MainDisplay.config.getDefaultFontColor());
 		this.toggleYAxisButton.setPreferredSize(this.buttonSize);
 		this.toggleYAxisButton.setMargin(new Insets(0, 0, 0, 0));
-		this.toggleYAxisButton
-				.setToolTipText("Currently plotted on left y-axis (y1). Click to change to right y-axis");
+		this.toggleYAxisButton.setToolTipText("Currently plotted on left y-axis (y1). Click to change to right y-axis");
 		this.toggleYAxisButton.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent event) {
@@ -158,8 +164,7 @@ public void actionPerformed(ActionEvent event) {
 		// show/hide button
 		this.showHideButton = new JButton("S");
 		this.showHideButton.setFont(MainDisplay.config.getDefaultFont());
-		this.showHideButton.setForeground(MainDisplay.config
-				.getDefaultFontColor());
+		this.showHideButton.setForeground(MainDisplay.config.getDefaultFontColor());
 		this.showHideButton.setPreferredSize(this.buttonSize);
 		this.showHideButton.setMargin(new Insets(0, 0, 0, 0));
 		this.showHideButton.setToolTipText("Hides this value in the chart");
@@ -168,15 +173,12 @@ public void actionPerformed(ActionEvent event) {
 			public void actionPerformed(ActionEvent event) {
 				if (thisItem.showHideButton.getText().equals("H")) {
 					thisItem.showHideButton.setText("S");
-					thisItem.showHideButton.setForeground(MainDisplay.config
-							.getDefaultFontColor());
-					thisItem.showHideButton
-							.setToolTipText("Hides this value in the chart");
+					thisItem.showHideButton.setForeground(MainDisplay.config.getDefaultFontColor());
+					thisItem.showHideButton.setToolTipText("Hides this value in the chart");
 				} else {
 					thisItem.showHideButton.setText("H");
 					thisItem.showHideButton.setForeground(Color.RED);
-					thisItem.showHideButton
-							.setToolTipText("Shows this value in the chart");
+					thisItem.showHideButton.setToolTipText("Shows this value in the chart");
 				}
 				thisItem.parent.toggleVisiblity(thisItem);
 			}
@@ -185,12 +187,10 @@ public void actionPerformed(ActionEvent event) {
 		// bar/linespoint button
 		this.displayModeButton = new JButton("L");
 		this.displayModeButton.setFont(MainDisplay.config.getDefaultFont());
-		this.displayModeButton.setForeground(MainDisplay.config
-				.getDefaultFontColor());
+		this.displayModeButton.setForeground(MainDisplay.config.getDefaultFontColor());
 		this.displayModeButton.setPreferredSize(this.buttonSize);
 		this.displayModeButton.setMargin(new Insets(0, 0, 0, 0));
-		this.displayModeButton
-				.setToolTipText("Currently shown as linespoint. Click to change to bars.");
+		this.displayModeButton.setToolTipText("Currently shown as linespoint. Click to change to bars.");
 		this.displayModeButton.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent event) {
@@ -210,8 +210,7 @@ public void actionPerformed(ActionEvent event) {
 		// button panel
 		this.buttonPanel = new JPanel();
 		this.buttonPanel.setLayout(new FlowLayout(FlowLayout.RIGHT, 0, 0));
-		this.buttonPanel
-				.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
+		this.buttonPanel.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
 		this.buttonPanel.setPreferredSize(this.buttonPanelSize);
 		this.buttonPanel.add(this.removeButton);
 		this.buttonPanel.add(this.showHideButton);
@@ -259,8 +258,7 @@ public Color getColor() {
 	public void setShowHideButton(boolean visible) {
 		if (visible) {
 			this.showHideButton.setText("S");
-			this.showHideButton.setForeground(MainDisplay.config
-					.getDefaultFontColor());
+			this.showHideButton.setForeground(MainDisplay.config.getDefaultFontColor());
 			this.showHideButton.setToolTipText("Hides this value in the chart");
 		} else {
 			this.showHideButton.setText("H");
@@ -273,12 +271,10 @@ public void setShowHideButton(boolean visible) {
 	public void setDisplayModeButton(boolean displayAsLinespoint) {
 		if (displayAsLinespoint) {
 			this.displayModeButton.setText("L");
-			this.displayModeButton
-					.setToolTipText("Currently shown as linespoint. Click to change to bars.");
+			this.displayModeButton.setToolTipText("Currently shown as linespoint. Click to change to bars.");
 		} else {
 			this.displayModeButton.setText("B");
-			this.displayModeButton
-					.setToolTipText("Currently shown as bars. Click to change to linespoint.");
+			this.displayModeButton.setToolTipText("Currently shown as bars. Click to change to linespoint.");
 		}
 	}
 
diff --git a/src/dna/visualization/components/visualizer/LegendItemLabel.java b/src/dna/visualization/components/visualizer/LegendItemLabel.java
new file mode 100644
index 00000000..0d7c7281
--- /dev/null
+++ b/src/dna/visualization/components/visualizer/LegendItemLabel.java
@@ -0,0 +1,31 @@
+package dna.visualization.components.visualizer;
+
+import java.awt.Color;
+
+/**
+ * A legenditem in the legendlist representing a labeler and type pair.
+ * 
+ * @author Rwilmes
+ * 
+ */
+@SuppressWarnings("serial")
+public class LegendItemLabel extends LegendItem {
+
+	// constructor
+	public LegendItemLabel(LegendList parent, String name, Color color) {
+		super(parent, name, color);
+
+		this.nameLabel.setText(name);
+		this.valueLabel.setText("V=0.0");
+
+		// remove displaymode and y-axis toggle button
+		this.buttonPanel.remove(this.displayModeButton);
+		this.buttonPanel.remove(this.toggleYAxisButton);
+	}
+
+	/** sets the value of an item **/
+	public void setValue(String value) {
+		this.valueLabel.setText("V=" + value);
+		this.valueLabel.setToolTipText("V=" + value);
+	}
+}
diff --git a/src/dna/visualization/components/visualizer/LegendItemValue.java b/src/dna/visualization/components/visualizer/LegendItemValue.java
index 34bf577f..51d51fac 100644
--- a/src/dna/visualization/components/visualizer/LegendItemValue.java
+++ b/src/dna/visualization/components/visualizer/LegendItemValue.java
@@ -19,7 +19,7 @@ public LegendItemValue(LegendList parent, String name, Color color) {
 	}
 
 	/** sets the value of an item **/
-	public void setValue(double value) {
+	public void setValue(String value) {
 		this.valueLabel.setText("V=" + value);
 		this.valueLabel.setToolTipText("V=" + value);
 	}
diff --git a/src/dna/visualization/components/visualizer/LegendList.java b/src/dna/visualization/components/visualizer/LegendList.java
index 2a2620d2..4b7e3f4b 100644
--- a/src/dna/visualization/components/visualizer/LegendList.java
+++ b/src/dna/visualization/components/visualizer/LegendList.java
@@ -70,13 +70,27 @@ public void removeItem(Component c) {
 	}
 
 	/** updates the value of an legend item contained in the list **/
-	public void updateItem(String name, double value) {
+	public void updateItem(String name, String value) {
 		for (Component c : this.getComponents()) {
-			if (c instanceof LegendItemValue) {
-				if (c.getName().equals(name)) {
+			if (c.getName().equals(name)) {
+				if (c instanceof LegendItemValue) {
 					((LegendItemValue) c).setValue(value);
 				}
+				if (c instanceof LegendItemLabel) {
+					((LegendItemLabel) c).setValue(value);
+				}
+
 			}
+			// if (c instanceof LegendItemValue) {
+			// if (c.getName().equals(name)) {
+			// ((LegendItemValue) c).setValue(value);
+			// }
+			// }
+			// if (c instanceof LegendItemLabel) {
+			// if (c.getName().equals(name)) {
+			// ((Legend))
+			// }
+			// }
 		}
 		this.validate();
 	}
diff --git a/src/dna/visualization/components/visualizer/MenuBar.java b/src/dna/visualization/components/visualizer/MenuBar.java
index d4124afe..57768224 100644
--- a/src/dna/visualization/components/visualizer/MenuBar.java
+++ b/src/dna/visualization/components/visualizer/MenuBar.java
@@ -1,11 +1,5 @@
 package dna.visualization.components.visualizer;
 
-import info.monitorenter.gui.chart.rangepolicies.RangePolicyFixedViewport;
-import info.monitorenter.gui.chart.rangepolicies.RangePolicyUnbounded;
-import info.monitorenter.gui.chart.traces.Trace2DLtd;
-import info.monitorenter.gui.chart.traces.Trace2DSimple;
-import info.monitorenter.util.Range;
-
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.FlowLayout;
@@ -34,6 +28,11 @@
 
 import dna.visualization.MainDisplay;
 import dna.visualization.config.components.MenuBarConfig;
+import info.monitorenter.gui.chart.rangepolicies.RangePolicyFixedViewport;
+import info.monitorenter.gui.chart.rangepolicies.RangePolicyUnbounded;
+import info.monitorenter.gui.chart.traces.Trace2DLtd;
+import info.monitorenter.gui.chart.traces.Trace2DSimple;
+import info.monitorenter.util.Range;
 
 /**
  * The menubar is a bar containing several options for a visualizer, for example
@@ -52,16 +51,12 @@ public class MenuBar extends JPanel implements ChangeListener {
 	private Color coordsFontColor = Color.BLACK;
 
 	// sizes
-	public static final Dimension menuBarCoordsPanelSize = new Dimension(145,
-			45);
-	public static final Dimension menuBarXOptionsPanelSize = new Dimension(65,
-			45);
-	public static final Dimension menuBarYOptionsPanelSize = new Dimension(65,
-			45);
-	public static final Dimension menuBarYRightOptionsPanelSize = new Dimension(
-			65, 45);
-	public static final Dimension menuBarIntervalPanelSize = new Dimension(210,
-			45);
+	public static final Dimension menuBarCoordsPanelSize = new Dimension(145, 45);
+	public static final Dimension menuBarXOptionsPanelSize = new Dimension(65, 45);
+	public static final Dimension menuBarYOptionsPanelSize = new Dimension(65, 45);
+	public static final Dimension menuBarYRightOptionsPanelSize = new Dimension(65, 45);
+	public static final Dimension menuBarIntervalPanelSize = new Dimension(225, 45);
+	public static final Dimension menuBarMultiScalarIntervalPanelSize = new Dimension(210, 45);
 
 	// creates the default menu with all panels
 	public MenuBar(Visualizer parent, Dimension d) {
@@ -70,17 +65,16 @@ public MenuBar(Visualizer parent, Dimension d) {
 
 	// creates the menu with a given config
 	public MenuBar(Visualizer parent, MenuBarConfig config) {
-		this(parent, config.getSize(), config.isAddCoordsPanel(), config
-				.isAddIntervalPanel(), config.isAddXOptionsPanel(), config
-				.isAddYOptionsPanel());
+		this(parent, config.getSize(), config.isAddCoordsPanel(), config.isAddIntervalPanel(),
+				config.isAddXOptionsPanel(), config.isAddYOptionsPanel());
 	}
 
 	// constructor
-	public MenuBar(Visualizer parent, Dimension size, boolean addCoordsPanel,
-			boolean addIntervalPanel, boolean addXOptionsPanel,
-			boolean addYOptionsPanel) {
+	public MenuBar(Visualizer parent, Dimension size, boolean addCoordsPanel, boolean addIntervalPanel,
+			boolean addXOptionsPanel, boolean addYOptionsPanel) {
 		this.parent = parent;
 		this.thisMenuBar = this;
+
 		this.setLayout(new GridBagLayout());
 		this.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
 
@@ -94,7 +88,10 @@ public MenuBar(Visualizer parent, Dimension size, boolean addCoordsPanel,
 
 		// add interval panel
 		if (addIntervalPanel) {
-			this.addIntervalPanel(menuBarIntervalPanelSize);
+			Dimension tempSize = menuBarIntervalPanelSize;
+			if (parent instanceof MultiScalarVisualizer)
+				tempSize = menuBarMultiScalarIntervalPanelSize;
+			this.addIntervalPanel(tempSize);
 		}
 
 		// add x axis options panel
@@ -110,7 +107,9 @@ public MenuBar(Visualizer parent, Dimension size, boolean addCoordsPanel,
 
 	// menu bar elements
 	private JPanel coordsPanel;
+	private JLabel xCoordsLabel;
 	private JLabel xCoordsValue;
+	private JLabel yCoordsLabel;
 	private JLabel yCoordsValue;
 	private JPanel xOptionsPanel;
 	private JPanel yLeftOptionsPanel;
@@ -122,6 +121,8 @@ public MenuBar(Visualizer parent, Dimension size, boolean addCoordsPanel,
 	private JScrollBar x1IntervalScrollBar;
 	private JCheckBox x1ShowAllCheckBox;
 	private JSlider x1SizeSlider;
+	private JCheckBox x1ConnectedCheckBox;
+
 	// for x2
 	private JScrollBar x2IntervalScrollBar;
 	private JCheckBox x2ShowAllCheckBox;
@@ -142,8 +143,8 @@ private void addIntervalPanel(Dimension size) {
 
 		/** upper panel **/
 		final JPanel upperPanel = new JPanel();
-		upperPanel.setPreferredSize(new Dimension((int) (size.getWidth() - 5),
-				(int) Math.floor((size.getHeight() - 5) / 2)));
+		upperPanel.setPreferredSize(
+				new Dimension((int) (size.getWidth() - 5), (int) Math.floor((size.getHeight() - 5) / 2)));
 		upperPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
 
 		// x1 label
@@ -162,54 +163,61 @@ public void actionPerformed(ActionEvent event) {
 				if (x1ShowAllCheckBox.isSelected()) {
 					// if selected: disable bar and slider and set x1 to
 					// unbounded policy
-					parent.xAxis1.setRangePolicy(new RangePolicyUnbounded());
+					// parent.xAxis1.setRangePolicy(new RangePolicyUnbounded());
 					parent.setFixedViewport(false);
+					parent.resetXAxis1Range();
 					x1IntervalScrollBar.setEnabled(false);
 					x1SizeSlider.setEnabled(false);
 				} else {
 					// if not selected: enable bar and slider and set x1 to
 					// fixedviewport policy
-					double minTemp = 0;
-					double maxTemp = 1;
-					parent.setFixedViewport(true);
-					parent.xAxis1
-							.setRangePolicy(new RangePolicyFixedViewport());
-					if (parent instanceof MultiScalarVisualizer) {
-						for (Object t : parent.xAxis1.getTraces()) {
-							if (t instanceof Trace2DSimple) {
-								double minX = ((Trace2DSimple) t).getMinX();
-								double maxX = ((Trace2DSimple) t).getMaxX();
-								if (minTemp > minX)
-									minTemp = minX;
-								if (maxTemp < maxX)
-									maxTemp = maxX;
-							}
-						}
-					} else if (parent instanceof MetricVisualizer) {
-						for (Object t : parent.xAxis1.getTraces()) {
-							if (t instanceof Trace2DLtd) {
-								minTemp = ((Trace2DLtd) t).getMinX();
-								maxTemp = ((Trace2DLtd) t).getMaxX();
-								if (((Trace2DLtd) t).getMinX() < minTemp)
-									minTemp = ((Trace2DLtd) t).getMinX();
-								if (((Trace2DLtd) t).getMaxX() < maxTemp)
-									maxTemp = ((Trace2DLtd) t).getMaxX();
-							}
-						}
-					}
-					double lowP = 1.0 * x1IntervalScrollBar.getValue() / 100;
-					double highP = 1.0 * (x1IntervalScrollBar.getValue() + x1IntervalScrollBar
-							.getModel().getExtent()) / 100;
-
-					int minTimestampNew = (int) Math.floor(minTemp)
-							+ (int) Math.floor(lowP * (maxTemp - minTemp));
-					int maxTimestampNew = (int) Math.floor(minTemp)
-							+ (int) Math.floor(highP * (maxTemp - minTemp));
-					parent.xAxis1.setRange(new Range(minTimestampNew,
-							maxTimestampNew));
+					// double minTemp = 0;
+					// double maxTemp = 1;
+					// parent.setFixedViewport(true);
+					// parent.xAxis1.setRangePolicy(new
+					// RangePolicyFixedViewport());
+					// if (parent instanceof MultiScalarVisualizer) {
+					// for (Object t : parent.xAxis1.getTraces()) {
+					// if (t instanceof Trace2DSimple) {
+					// double minX = ((Trace2DSimple) t).getMinX();
+					// double maxX = ((Trace2DSimple) t).getMaxX();
+					// if (minTemp > minX)
+					// minTemp = minX;
+					// if (maxTemp < maxX)
+					// maxTemp = maxX;
+					// }
+					// }
+					// } else if (parent instanceof MetricVisualizer) {
+					// for (Object t : parent.xAxis1.getTraces()) {
+					// if (t instanceof Trace2DLtd) {
+					// minTemp = ((Trace2DLtd) t).getMinX();
+					// maxTemp = ((Trace2DLtd) t).getMaxX();
+					// if (((Trace2DLtd) t).getMinX() < minTemp)
+					// minTemp = ((Trace2DLtd) t).getMinX();
+					// if (((Trace2DLtd) t).getMaxX() < maxTemp)
+					// maxTemp = ((Trace2DLtd) t).getMaxX();
+					// }
+					// }
+					// }
+					// double lowP = 1.0 * x1IntervalScrollBar.getValue() / 100;
+					// double highP = 1.0 * (x1IntervalScrollBar.getValue() +
+					// x1IntervalScrollBar.getModel().getExtent())
+					// / 100;
+					//
+					// int minTimestampNew = (int) Math.floor(minTemp) + (int)
+					// Math.floor(lowP * (maxTemp - minTemp));
+					// int maxTimestampNew = (int) Math.floor(minTemp) + (int)
+					// Math.floor(highP * (maxTemp - minTemp));
+					// parent.xAxis1.setRange(new Range(minTimestampNew,
+					// maxTimestampNew));
+
+					parent.setXAxis1RangePercent(getIntervalSliderSelectionLowPercent(),
+							getIntervalSliderSelectionHighPercent());
 					x1IntervalScrollBar.setEnabled(true);
 					x1SizeSlider.setEnabled(true);
 				}
+
+				parent.broadcastX1IntervalEnabled(x1ShowAllCheckBox.isSelected());
 			}
 		});
 
@@ -223,59 +231,87 @@ public void actionPerformed(ActionEvent event) {
 		this.x1SizeSlider.setToolTipText("Set size of shown interval");
 
 		// interval scroll bar
-		this.x1IntervalScrollBar = new JScrollBar(JScrollBar.HORIZONTAL, 0, 50,
-				0, 100);
+		this.x1IntervalScrollBar = new JScrollBar(JScrollBar.HORIZONTAL, 0, 50, 0, 100);
 		this.x1IntervalScrollBar.setPreferredSize(new Dimension(100, 20));
 		this.x1IntervalScrollBar.setEnabled(false);
-		this.x1IntervalScrollBar
-				.addAdjustmentListener(new AdjustmentListener() {
-					@Override
-					public void adjustmentValueChanged(AdjustmentEvent e) {
-						if (parent.chart.getAxisX().getRangePolicy() instanceof RangePolicyFixedViewport) {
-							double lowP = 1.0 * x1IntervalScrollBar.getValue() / 100;
-							double highP = 1.0 * (x1IntervalScrollBar
-									.getValue() + x1IntervalScrollBar
-									.getModel().getExtent()) / 100;
+		this.x1IntervalScrollBar.addAdjustmentListener(new AdjustmentListener() {
+			@Override
+			public void adjustmentValueChanged(AdjustmentEvent e) {
+				if (parent.chart.getAxisX().getRangePolicy() instanceof RangePolicyFixedViewport) {
+					// double lowP = 1.0 * x1IntervalScrollBar.getValue() / 100;
+					// double highP = 1.0 * (x1IntervalScrollBar.getValue() +
+					// x1IntervalScrollBar.getModel().getExtent())
+					// / 100;
+					//
+					// double minTemp = 0;
+					// double maxTemp = 1;
+					//
+					// // get range of plotted data
+					// for (Object t : parent.xAxis1.getTraces()) {
+					// if (t instanceof Trace2DSimple) {
+					// double minX = ((Trace2DSimple) t).getMinX();
+					// double maxX = ((Trace2DSimple) t).getMaxX();
+					// if (minTemp > minX)
+					// minTemp = minX;
+					// if (maxTemp < maxX)
+					// maxTemp = maxX;
+					// } else if (t instanceof Trace2DLtd) {
+					// minTemp = ((Trace2DLtd) t).getMinX();
+					// maxTemp = ((Trace2DLtd) t).getMaxX();
+					// }
+					// }
+					//
+					// if (parent instanceof LabelVisualizer) {
+					// minTemp = ((LabelVisualizer) parent).getMinTimestamp();
+					// maxTemp = ((LabelVisualizer) parent).getMaxTimestamp();
+					// }
+					//
+					// int minTimestampNew = (int) Math.floor(minTemp) + (int)
+					// Math.floor(lowP * (maxTemp - minTemp));
+					// int maxTimestampNew = (int) Math.floor(minTemp) + (int)
+					// Math.floor(highP * (maxTemp - minTemp));
+					// parent.setMinShownTimestamp((long) minTimestampNew);
+					// parent.setMaxShownTimestamp((long) maxTimestampNew);
+					// parent.xAxis1.setRange(new Range(minTimestampNew,
+					// maxTimestampNew));
+					// // update x ticks
+
+//					if (parent.isViewPortFixed()) {
+						parent.setXAxis1RangePercent(getIntervalSliderSelectionLowPercent(),
+								getIntervalSliderSelectionHighPercent());
+//					}
+					parent.updateX1Ticks();
+
+					parent.broadcastX1IntervalSizeSliderChange(x1SizeSlider.getValue());
+					parent.broadcastX1IntervalScrollBarChange(x1IntervalScrollBar.getValue());
+				}
+			}
 
-							double minTemp = 0;
-							double maxTemp = 1;
+		});
 
-							// get range of plotted data
-							for (Object t : parent.xAxis1.getTraces()) {
-								if (t instanceof Trace2DSimple) {
-									double minX = ((Trace2DSimple) t).getMinX();
-									double maxX = ((Trace2DSimple) t).getMaxX();
-									if (minTemp > minX)
-										minTemp = minX;
-									if (maxTemp < maxX)
-										maxTemp = maxX;
-								} else if (t instanceof Trace2DLtd) {
-									minTemp = ((Trace2DLtd) t).getMinX();
-									maxTemp = ((Trace2DLtd) t).getMaxX();
-								}
-							}
-							int minTimestampNew = (int) Math.floor(minTemp)
-									+ (int) Math.floor(lowP
-											* (maxTemp - minTemp));
-							int maxTimestampNew = (int) Math.floor(minTemp)
-									+ (int) Math.floor(highP
-											* (maxTemp - minTemp));
-							parent.setMinShownTimestamp((long) minTimestampNew);
-							parent.setMaxShownTimestamp((long) maxTimestampNew);
-							parent.xAxis1.setRange(new Range(minTimestampNew,
-									maxTimestampNew));
-							// update x ticks
-							parent.updateX1Ticks();
-						}
-					}
+		// x1 connected checkbox
+		this.x1ConnectedCheckBox = new JCheckBox("", this.parent.isX1Connected());
+		this.x1ConnectedCheckBox.setToolTipText("Check to connect x1 axis with other components");
+		this.x1ConnectedCheckBox.addActionListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent event) {
+				// check if checkbox is selected
+				if (x1ConnectedCheckBox.isSelected()) {
+					parent.setX1Connected(true);
 
-				});
+				} else {
+					parent.setX1Connected(false);
+				}
+			}
+		});
 
 		// add components
 		upperPanel.add(x1Label);
 		upperPanel.add(this.x1ShowAllCheckBox);
 		upperPanel.add(this.x1SizeSlider);
 		upperPanel.add(this.x1IntervalScrollBar);
+		if (!(parent instanceof MultiScalarVisualizer))
+			upperPanel.add(this.x1ConnectedCheckBox);
 
 		/** add uppper panel **/
 		c.gridx = 0;
@@ -287,9 +323,8 @@ public void adjustmentValueChanged(AdjustmentEvent e) {
 		if (parent instanceof MultiScalarVisualizer) {
 			// lower panel
 			final JPanel lowerPanel = new JPanel();
-			lowerPanel.setPreferredSize(new Dimension(
-					(int) (size.getWidth() - 5), (int) Math.floor((size
-							.getHeight() - 5) / 2)));
+			lowerPanel.setPreferredSize(
+					new Dimension((int) (size.getWidth() - 5), (int) Math.floor((size.getHeight() - 5) / 2)));
 			lowerPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
 
 			// x1 label
@@ -309,27 +344,24 @@ public void actionPerformed(ActionEvent event) {
 						// if selected: disable bar and slider and set x2 to
 						// unbounded policy
 						if (parent instanceof MultiScalarVisualizer)
-							((MultiScalarVisualizer) parent).xAxis2
-									.setRangePolicy(new RangePolicyUnbounded());
+							((MultiScalarVisualizer) parent).xAxis2.setRangePolicy(new RangePolicyUnbounded());
 						x2IntervalScrollBar.setEnabled(false);
 						x2SizeSlider.setEnabled(false);
 					} else {
 						// if not selected: enable bar and slider and set x2 to
 						// fixedviewport policy
 						if (parent instanceof MultiScalarVisualizer) {
-							((MultiScalarVisualizer) parent).xAxis2
-									.setRangePolicy(new RangePolicyFixedViewport());
+							((MultiScalarVisualizer) parent).xAxis2.setRangePolicy(new RangePolicyFixedViewport());
 							double lowP = 1.0 * x2IntervalScrollBar.getValue() / 100;
-							double highP = 1.0 * (x2IntervalScrollBar
-									.getValue() + x2IntervalScrollBar
-									.getModel().getExtent()) / 100;
+							double highP = 1.0
+									* (x2IntervalScrollBar.getValue() + x2IntervalScrollBar.getModel().getExtent())
+									/ 100;
 
 							double minTemp = 0;
 							double maxTemp = 10;
 
 							// get range of plotted data
-							for (Object t : ((MultiScalarVisualizer) parent).xAxis2
-									.getTraces()) {
+							for (Object t : ((MultiScalarVisualizer) parent).xAxis2.getTraces()) {
 								if (t instanceof Trace2DSimple) {
 									double minX = ((Trace2DSimple) t).getMinX();
 									double maxX = ((Trace2DSimple) t).getMaxX();
@@ -341,15 +373,12 @@ public void actionPerformed(ActionEvent event) {
 							}
 
 							int minTimestampNew = (int) Math.floor(minTemp)
-									+ (int) Math.floor(lowP
-											* (maxTemp - minTemp));
+									+ (int) Math.floor(lowP * (maxTemp - minTemp));
 							int maxTimestampNew = (int) Math.floor(minTemp)
-									+ (int) Math.floor(highP
-											* (maxTemp - minTemp));
+									+ (int) Math.floor(highP * (maxTemp - minTemp));
 
 							((MultiScalarVisualizer) parent).xAxis2
-									.setRange(new Range(minTimestampNew,
-											maxTimestampNew));
+									.setRange(new Range(minTimestampNew, maxTimestampNew));
 							// update x2 ticks
 							((MultiScalarVisualizer) parent).updateX2Ticks();
 						}
@@ -369,57 +398,46 @@ public void actionPerformed(ActionEvent event) {
 			this.x2SizeSlider.setToolTipText("Set size of shown interval");
 
 			// interval scroll bar
-			this.x2IntervalScrollBar = new JScrollBar(JScrollBar.HORIZONTAL, 0,
-					50, 0, 100);
+			this.x2IntervalScrollBar = new JScrollBar(JScrollBar.HORIZONTAL, 0, 50, 0, 100);
 			this.x2IntervalScrollBar.setPreferredSize(new Dimension(100, 20));
 			this.x2IntervalScrollBar.setEnabled(false);
-			this.x2IntervalScrollBar
-					.addAdjustmentListener(new AdjustmentListener() {
-						@Override
-						public void adjustmentValueChanged(AdjustmentEvent e) {
-							if (parent instanceof MultiScalarVisualizer) {
-								if (((MultiScalarVisualizer) parent).xAxis2
-										.getRangePolicy() instanceof RangePolicyFixedViewport) {
-									double lowP = 1.0 * x2IntervalScrollBar
-											.getValue() / 100;
-									double highP = 1.0 * (x2IntervalScrollBar
-											.getValue() + x2IntervalScrollBar
-											.getModel().getExtent()) / 100;
-
-									double minTemp = 0;
-									double maxTemp = 10;
-
-									// get range of plotted data
-									for (Object t : ((MultiScalarVisualizer) parent).xAxis2
-											.getTraces()) {
-										if (t instanceof Trace2DSimple) {
-											double minX = ((Trace2DSimple) t)
-													.getMinX();
-											double maxX = ((Trace2DSimple) t)
-													.getMaxX();
-											if (minTemp > minX)
-												minTemp = minX;
-											if (maxTemp < maxX)
-												maxTemp = maxX;
-										}
-									}
-
-									int minTimestampNew = (int) Math.floor(lowP
-											* (maxTemp - minTemp));
-									int maxTimestampNew = (int) Math
-											.floor(highP * (maxTemp - minTemp));
-
-									((MultiScalarVisualizer) parent).xAxis2
-											.setRange(new Range(
-													minTimestampNew,
-													maxTimestampNew));
-									// update x2 ticks
-									((MultiScalarVisualizer) parent)
-											.updateX2Ticks();
+			this.x2IntervalScrollBar.addAdjustmentListener(new AdjustmentListener() {
+				@Override
+				public void adjustmentValueChanged(AdjustmentEvent e) {
+					if (parent instanceof MultiScalarVisualizer) {
+						if (((MultiScalarVisualizer) parent).xAxis2
+								.getRangePolicy() instanceof RangePolicyFixedViewport) {
+							double lowP = 1.0 * x2IntervalScrollBar.getValue() / 100;
+							double highP = 1.0
+									* (x2IntervalScrollBar.getValue() + x2IntervalScrollBar.getModel().getExtent())
+									/ 100;
+
+							double minTemp = 0;
+							double maxTemp = 10;
+
+							// get range of plotted data
+							for (Object t : ((MultiScalarVisualizer) parent).xAxis2.getTraces()) {
+								if (t instanceof Trace2DSimple) {
+									double minX = ((Trace2DSimple) t).getMinX();
+									double maxX = ((Trace2DSimple) t).getMaxX();
+									if (minTemp > minX)
+										minTemp = minX;
+									if (maxTemp < maxX)
+										maxTemp = maxX;
 								}
 							}
+
+							int minTimestampNew = (int) Math.floor(lowP * (maxTemp - minTemp));
+							int maxTimestampNew = (int) Math.floor(highP * (maxTemp - minTemp));
+
+							((MultiScalarVisualizer) parent).xAxis2
+									.setRange(new Range(minTimestampNew, maxTimestampNew));
+							// update x2 ticks
+							((MultiScalarVisualizer) parent).updateX2Ticks();
 						}
-					});
+					}
+				}
+			});
 
 			// add components
 			lowerPanel.add(x2Label);
@@ -433,8 +451,7 @@ public void adjustmentValueChanged(AdjustmentEvent e) {
 		} else {
 			// if parent not multiscalarvisualizer -> add dummy panel
 			JPanel dummyPanel = new JPanel();
-			dummyPanel.setPreferredSize(new Dimension(size.width - 5,
-					(int) Math.floor((size.height - 5) / 2)));
+			dummyPanel.setPreferredSize(new Dimension(size.width - 5, (int) Math.floor((size.height - 5) / 2)));
 
 			/** add dummy panel **/
 			c.gridy = 1;
@@ -462,59 +479,61 @@ private void addYOptionsPanel(Dimension size) {
 		final JButton toggleGridYLeftButton = new JButton("y1");
 		toggleGridYLeftButton.setFont(MainDisplay.config.getDefaultFont());
 		toggleGridYLeftButton.setForeground(Color.GRAY);
-		toggleGridYLeftButton.setPreferredSize(new Dimension(size.width - 5,
-				(int) Math.floor((size.getHeight() - 5) / 2)));
+		toggleGridYLeftButton
+				.setPreferredSize(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2)));
 		toggleGridYLeftButton.setMargin(new Insets(0, 0, 0, 0));
 		toggleGridYLeftButton.setToolTipText("Show grid of left y-axis (y1).");
 		toggleGridYLeftButton.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent event) {
 				if (toggleGridYLeftButton.getForeground().equals(Color.GRAY)) {
-					toggleGridYLeftButton.setForeground(MainDisplay.config
-							.getDefaultFontColor());
-					toggleGridYLeftButton
-							.setToolTipText("Hide grid of left y-axis (y1).");
+					toggleGridYLeftButton.setForeground(MainDisplay.config.getDefaultFontColor());
+					toggleGridYLeftButton.setToolTipText("Hide grid of left y-axis (y1).");
 				} else {
 					toggleGridYLeftButton.setForeground(Color.GRAY);
-					toggleGridYLeftButton
-							.setToolTipText("Show grid of left y-axis (y1).");
+					toggleGridYLeftButton.setToolTipText("Show grid of left y-axis (y1).");
 				}
 				parent.toggleY1Grid();
 			}
 		});
 		yLeftOptionsPanelConstraints.gridx = 0;
 		yLeftOptionsPanelConstraints.gridy = 0;
-		this.yLeftOptionsPanel.add(toggleGridYLeftButton,
-				yLeftOptionsPanelConstraints);
+		this.yLeftOptionsPanel.add(toggleGridYLeftButton, yLeftOptionsPanelConstraints);
 
-		// toggle right y axis grid button
-		final JButton toggleGridYRightButton = new JButton("y2");
-		toggleGridYRightButton.setFont(MainDisplay.config.getDefaultFont());
-		toggleGridYRightButton.setForeground(Color.GRAY);
-		toggleGridYRightButton.setPreferredSize(new Dimension(new Dimension(
-				size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
-		toggleGridYRightButton.setMargin(new Insets(0, 0, 0, 0));
-		toggleGridYRightButton
-				.setToolTipText("Show grid of right y-axis (y2).");
-		toggleGridYRightButton.addActionListener(new ActionListener() {
-			@Override
-			public void actionPerformed(ActionEvent event) {
-				if (toggleGridYRightButton.getForeground().equals(Color.GRAY)) {
-					toggleGridYRightButton.setForeground(MainDisplay.config
-							.getDefaultFontColor());
-					toggleGridYRightButton
-							.setToolTipText("Hide grid of right y-axis (y2).");
-				} else {
-					toggleGridYRightButton.setForeground(Color.GRAY);
-					toggleGridYRightButton
-							.setToolTipText("Show grid of right y-axis (y2).");
+		if (this.parent instanceof LabelVisualizer) {
+			// add dummy panel
+			JPanel dummyP = new JPanel();
+			dummyP.setPreferredSize(
+					new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
+			yLeftOptionsPanelConstraints.gridx = 0;
+			yLeftOptionsPanelConstraints.gridy = 1;
+			this.yLeftOptionsPanel.add(dummyP, yLeftOptionsPanelConstraints);
+		} else {
+			// toggle right y axis grid button
+			final JButton toggleGridYRightButton = new JButton("y2");
+			toggleGridYRightButton.setFont(MainDisplay.config.getDefaultFont());
+			toggleGridYRightButton.setForeground(Color.GRAY);
+			toggleGridYRightButton.setPreferredSize(
+					new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
+			toggleGridYRightButton.setMargin(new Insets(0, 0, 0, 0));
+			toggleGridYRightButton.setToolTipText("Show grid of right y-axis (y2).");
+			toggleGridYRightButton.addActionListener(new ActionListener() {
+				@Override
+				public void actionPerformed(ActionEvent event) {
+					if (toggleGridYRightButton.getForeground().equals(Color.GRAY)) {
+						toggleGridYRightButton.setForeground(MainDisplay.config.getDefaultFontColor());
+						toggleGridYRightButton.setToolTipText("Hide grid of right y-axis (y2).");
+					} else {
+						toggleGridYRightButton.setForeground(Color.GRAY);
+						toggleGridYRightButton.setToolTipText("Show grid of right y-axis (y2).");
+					}
+					parent.toggleY2Grid();
 				}
-				parent.toggleY2Grid();
-			}
-		});
-		yLeftOptionsPanelConstraints.gridy = 1;
-		this.yLeftOptionsPanel.add(toggleGridYRightButton,
-				yLeftOptionsPanelConstraints);
+			});
+			yLeftOptionsPanelConstraints.gridy = 1;
+
+			this.yLeftOptionsPanel.add(toggleGridYRightButton, yLeftOptionsPanelConstraints);
+		}
 
 		// add to menu bar
 		this.add(this.yLeftOptionsPanel);
@@ -537,43 +556,37 @@ private void addYRightOptionsPanel(Dimension size) {
 		final JButton toggleGridYRightButton = new JButton("y2");
 		toggleGridYRightButton.setFont(MainDisplay.config.getDefaultFont());
 		toggleGridYRightButton.setForeground(Color.GRAY);
-		toggleGridYRightButton.setPreferredSize(new Dimension(new Dimension(
-				size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
+		toggleGridYRightButton.setPreferredSize(
+				new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
 		toggleGridYRightButton.setMargin(new Insets(0, 0, 0, 0));
-		toggleGridYRightButton
-				.setToolTipText("Show grid of right y-axis (y2).");
+		toggleGridYRightButton.setToolTipText("Show grid of right y-axis (y2).");
 		toggleGridYRightButton.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent event) {
 				if (toggleGridYRightButton.getForeground().equals(Color.GRAY)) {
-					toggleGridYRightButton.setForeground(MainDisplay.config
-							.getDefaultFontColor());
-					toggleGridYRightButton
-							.setToolTipText("Hide grid of right y-axis (y2).");
+					toggleGridYRightButton.setForeground(MainDisplay.config.getDefaultFontColor());
+					toggleGridYRightButton.setToolTipText("Hide grid of right y-axis (y2).");
 				} else {
 					toggleGridYRightButton.setForeground(Color.GRAY);
-					toggleGridYRightButton
-							.setToolTipText("Show grid of right y-axis (y2).");
+					toggleGridYRightButton.setToolTipText("Show grid of right y-axis (y2).");
 				}
 				parent.toggleY2Grid();
 			}
 		});
 		yRightOptionsPanelConstraints.gridx = 0;
 		yRightOptionsPanelConstraints.gridy = 0;
-		this.yRightOptionsPanel.add(toggleGridYRightButton,
-				yRightOptionsPanelConstraints);
+		this.yRightOptionsPanel.add(toggleGridYRightButton, yRightOptionsPanelConstraints);
 
 		// toggle right y axis log button
 		final JButton toggleLogYRightButton = new JButton("+log y1");
 		toggleLogYRightButton.setFont(MainDisplay.config.getDefaultFont());
 		toggleLogYRightButton.setForeground(Color.GRAY);
-		toggleLogYRightButton.setPreferredSize(new Dimension(new Dimension(
-				size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
+		toggleLogYRightButton.setPreferredSize(
+				new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
 		toggleLogYRightButton.setMargin(new Insets(0, 0, 0, 0));
 		yRightOptionsPanelConstraints.gridx = 0;
 		yRightOptionsPanelConstraints.gridy = 1;
-		this.yRightOptionsPanel.add(toggleLogYRightButton,
-				yRightOptionsPanelConstraints);
+		this.yRightOptionsPanel.add(toggleLogYRightButton, yRightOptionsPanelConstraints);
 
 		// add to menu bar
 		this.add(this.yRightOptionsPanel);
@@ -596,16 +609,15 @@ private void addXOptionsPanel(Dimension size) {
 		final JButton toggleGridX1Button = new JButton("x1");
 		toggleGridX1Button.setFont(MainDisplay.config.getDefaultFont());
 		toggleGridX1Button.setForeground(Color.GRAY);
-		toggleGridX1Button.setPreferredSize(new Dimension(new Dimension(
-				size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
+		toggleGridX1Button.setPreferredSize(
+				new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
 		toggleGridX1Button.setMargin(new Insets(0, 0, 0, 0));
 		toggleGridX1Button.setToolTipText("Show grid of x1.");
 		toggleGridX1Button.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent event) {
 				if (toggleGridX1Button.getForeground().equals(Color.GRAY)) {
-					toggleGridX1Button.setForeground(MainDisplay.config
-							.getDefaultFontColor());
+					toggleGridX1Button.setForeground(MainDisplay.config.getDefaultFontColor());
 					toggleGridX1Button.setToolTipText("Hide grid of x1.");
 				} else {
 					toggleGridX1Button.setForeground(Color.GRAY);
@@ -616,25 +628,22 @@ public void actionPerformed(ActionEvent event) {
 		});
 		xAxisOptionsPanelConstraints.gridx = 0;
 		xAxisOptionsPanelConstraints.gridy = 0;
-		this.xOptionsPanel
-				.add(toggleGridX1Button, xAxisOptionsPanelConstraints);
+		this.xOptionsPanel.add(toggleGridX1Button, xAxisOptionsPanelConstraints);
 
 		// if parent is multiscalarvisualizer -> add grid button for x2
 		if (parent instanceof MultiScalarVisualizer) {
 			final JButton toggleGridX2Button = new JButton("x2");
 			toggleGridX2Button.setFont(MainDisplay.config.getDefaultFont());
 			toggleGridX2Button.setForeground(Color.GRAY);
-			toggleGridX2Button.setPreferredSize(new Dimension(new Dimension(
-					size.width - 5,
-					(int) Math.floor((size.getHeight() - 5) / 2))));
+			toggleGridX2Button.setPreferredSize(
+					new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
 			toggleGridX2Button.setMargin(new Insets(0, 0, 0, 0));
 			toggleGridX2Button.setToolTipText("Show grid of x2.");
 			toggleGridX2Button.addActionListener(new ActionListener() {
 				@Override
 				public void actionPerformed(ActionEvent event) {
 					if (toggleGridX2Button.getForeground().equals(Color.GRAY)) {
-						toggleGridX2Button.setForeground(MainDisplay.config
-								.getDefaultFontColor());
+						toggleGridX2Button.setForeground(MainDisplay.config.getDefaultFontColor());
 						toggleGridX2Button.setToolTipText("Hide grid of x2.");
 					} else {
 						toggleGridX2Button.setForeground(Color.GRAY);
@@ -645,13 +654,12 @@ public void actionPerformed(ActionEvent event) {
 			});
 			xAxisOptionsPanelConstraints.gridx = 0;
 			xAxisOptionsPanelConstraints.gridy = 1;
-			this.xOptionsPanel.add(toggleGridX2Button,
-					xAxisOptionsPanelConstraints);
+			this.xOptionsPanel.add(toggleGridX2Button, xAxisOptionsPanelConstraints);
 		} else {
 			// else add dummy panel
 			JPanel dummyP = new JPanel();
-			dummyP.setPreferredSize(new Dimension(new Dimension(size.width - 5,
-					(int) Math.floor((size.getHeight() - 5) / 2))));
+			dummyP.setPreferredSize(
+					new Dimension(new Dimension(size.width - 5, (int) Math.floor((size.getHeight() - 5) / 2))));
 			xAxisOptionsPanelConstraints.gridx = 0;
 			xAxisOptionsPanelConstraints.gridy = 1;
 			this.xOptionsPanel.add(dummyP, xAxisOptionsPanelConstraints);
@@ -678,18 +686,17 @@ private void addCoordsPanel(Dimension size) {
 		coordsPanelConstraints.gridy = 0;
 
 		// x coords label
-		JLabel xCoordsLabel = new JLabel("x:");
+		xCoordsLabel = new JLabel("x:");
 		xCoordsLabel.setFont(this.coordsFont);
 		xCoordsLabel.setForeground(this.coordsFontColor);
 		xCoordsLabel.setPreferredSize(new Dimension(10, 20));
 		this.coordsPanel.add(xCoordsLabel, coordsPanelConstraints);
 		// x coords value
 		this.xCoordsValue = new JLabel();
-		if (MainDisplay.config.getMetricVisualizerConfigs()[0].getxAxisType()
-				.equals("date") && (this.parent instanceof MetricVisualizer)) {
+		if ((this.parent instanceof MetricVisualizer)
+				&& MainDisplay.config.getMetricVisualizerConfigs()[0].getxAxisType().equals("date")) {
 			SimpleDateFormat tempDateFormat = new SimpleDateFormat(
-					MainDisplay.config.getMetricVisualizerConfigs()[0]
-							.getxAxisFormat());
+					MainDisplay.config.getMetricVisualizerConfigs()[0].getxAxisFormat());
 			this.xCoordsValue.setText(tempDateFormat.format(new Date(0)));
 		} else {
 			this.xCoordsValue.setText("0");
@@ -702,7 +709,7 @@ private void addCoordsPanel(Dimension size) {
 		this.coordsPanel.add(this.xCoordsValue, coordsPanelConstraints);
 
 		// y coords label
-		JLabel yCoordsLabel = new JLabel("y:");
+		yCoordsLabel = new JLabel("y:");
 		yCoordsLabel.setFont(this.coordsFont);
 		yCoordsLabel.setForeground(this.coordsFontColor);
 		yCoordsLabel.setPreferredSize(new Dimension(10, 20));
@@ -742,19 +749,31 @@ private void addDummyPanel(Dimension size) {
 	 * @param y
 	 *            y-value
 	 */
-	public void updateCoordsPanel(int x, double y) {
+	public void updateCoordsPanel(double x, double y) {
 		if (this.coordsPanel != null) {
-			if (MainDisplay.config.getMetricVisualizerConfigs()[0]
-					.getxAxisType().equals("date")
-					&& (this.parent instanceof MetricVisualizer)) {
-				SimpleDateFormat tempDateFormat = new SimpleDateFormat(
-						MainDisplay.config.getMetricVisualizerConfigs()[0]
-								.getxAxisFormat());
-				this.xCoordsValue.setText(tempDateFormat.format(new Date(x)));
+			if (this.parent instanceof LabelVisualizer) {
+				if (MainDisplay.config.getLabelVisualizerConfigs()[0].getxAxisType().equals("date")) {
+					SimpleDateFormat tempDateFormat = new SimpleDateFormat(
+							MainDisplay.config.getLabelVisualizerConfigs()[0].getxAxisFormat());
+					this.xCoordsValue.setText(tempDateFormat.format(new Date((long) Math.floor(x))));
+				} else {
+					this.xCoordsValue.setText("" + x);
+				}
+
+				LabelVisualizer labelVisualizer = (LabelVisualizer) this.parent;
+				String yValueString = labelVisualizer.getValue(x, y);
+				this.yCoordsValue.setText("" + yValueString);
 			} else {
-				this.xCoordsValue.setText("" + x);
+				if ((this.parent instanceof MetricVisualizer)
+						&& MainDisplay.config.getMetricVisualizerConfigs()[0].getxAxisType().equals("date")) {
+					SimpleDateFormat tempDateFormat = new SimpleDateFormat(
+							MainDisplay.config.getMetricVisualizerConfigs()[0].getxAxisFormat());
+					this.xCoordsValue.setText(tempDateFormat.format(new Date((long) Math.floor(x))));
+				} else {
+					this.xCoordsValue.setText("" + x);
+				}
+				this.yCoordsValue.setText("" + y);
 			}
-			this.yCoordsValue.setText("" + y);
 		}
 	}
 
@@ -778,13 +797,18 @@ public void stateChanged(ChangeEvent e) {
 			source = (JSlider) e.getSource();
 			intervalScrollBar = this.x1IntervalScrollBar;
 			// check if event is coming from x2SizeSlider
-			if (e.getSource().equals(this.x2SizeSlider))
+			if (e.getSource().equals(this.x2SizeSlider)) {
 				intervalScrollBar = this.x2IntervalScrollBar;
+			} else {
+				// if its x1 and parent is not multiscalar vis --> broadcast new
+				// value
+				if (!(this.parent instanceof MultiScalarVisualizer))
+					this.parent.broadcastX1IntervalSizeSliderChange(source.getValue());
+			}
 
 			// check if slider is set on the right end
-			if (intervalScrollBar.getValue()
-					+ intervalScrollBar.getModel().getExtent() == intervalScrollBar
-						.getMaximum()) {
+			if (intervalScrollBar.getValue() + intervalScrollBar.getModel().getExtent() == intervalScrollBar
+					.getMaximum()) {
 				int oldValue = intervalScrollBar.getValue();
 				int oldExtent = intervalScrollBar.getModel().getExtent();
 
@@ -794,11 +818,10 @@ public void stateChanged(ChangeEvent e) {
 				intervalScrollBar.getModel().setExtent(source.getValue());
 
 				// if slider is not set on right end anymore, adjust value
-				if (intervalScrollBar.getValue()
-						+ intervalScrollBar.getModel().getExtent() != intervalScrollBar
-							.getMaximum()) {
-					intervalScrollBar.setValue(intervalScrollBar.getMaximum()
-							- intervalScrollBar.getModel().getExtent());
+				if (intervalScrollBar.getValue() + intervalScrollBar.getModel().getExtent() != intervalScrollBar
+						.getMaximum()) {
+					intervalScrollBar
+							.setValue(intervalScrollBar.getMaximum() - intervalScrollBar.getModel().getExtent());
 				}
 				// if slider is in between, just resize it
 			} else {
@@ -815,4 +838,47 @@ public JScrollBar getIntervalSlider() {
 		return this.x1IntervalScrollBar;
 	}
 
+	/** Sets the x-coords label text. **/
+	public void setXCoordsLabelText(String text) {
+		this.xCoordsLabel.setText(text);
+	}
+
+	/** Sets the y-coords label text. **/
+	public void setYCoordsLabelText(String text) {
+		this.yCoordsLabel.setText(text);
+	}
+
+	/** Sets the x1 interval size slider to a value. **/
+	public void setX1IntervalSizeSlider(int value) {
+		if (this.x1SizeSlider != null && this.x1SizeSlider.isEnabled())
+			this.x1SizeSlider.setValue(value);
+	}
+
+	/** Set x1 interval scroll bar. **/
+	public void setX1IntervalScrollBar(int value) {
+		if (this.x1IntervalScrollBar != null & this.x1IntervalScrollBar.isEnabled())
+			this.x1IntervalScrollBar.setValue(value);
+	}
+
+	/** Set x1 interval enabled. **/
+	public void setX1IntervalEnabled(boolean enabled) {
+		if (this.x1ShowAllCheckBox != null) {
+			if (this.x1ShowAllCheckBox.isSelected()) {
+				if (!enabled)
+					this.x1ShowAllCheckBox.doClick();
+			} else {
+				if (enabled)
+					this.x1ShowAllCheckBox.doClick();
+			}
+		}
+	}
+
+	public double getIntervalSliderSelectionLowPercent() {
+		return 1.0 * this.getIntervalSlider().getValue() / 100;
+	}
+
+	public double getIntervalSliderSelectionHighPercent() {
+		return 1.0 * (this.getIntervalSlider().getValue() + this.getIntervalSlider().getModel().getExtent()) / 100;
+	}
+
 }
diff --git a/src/dna/visualization/components/visualizer/MetricVisualizer.java b/src/dna/visualization/components/visualizer/MetricVisualizer.java
index ef22dd4e..cdc1f73c 100644
--- a/src/dna/visualization/components/visualizer/MetricVisualizer.java
+++ b/src/dna/visualization/components/visualizer/MetricVisualizer.java
@@ -1,23 +1,5 @@
 package dna.visualization.components.visualizer;
 
-import info.monitorenter.gui.chart.IAxis;
-import info.monitorenter.gui.chart.IAxis.AxisTitle;
-import info.monitorenter.gui.chart.ITrace2D;
-import info.monitorenter.gui.chart.ITracePainter;
-import info.monitorenter.gui.chart.ITracePoint2D;
-import info.monitorenter.gui.chart.axis.scalepolicy.AxisScalePolicyAutomaticBestFit;
-import info.monitorenter.gui.chart.labelformatters.LabelFormatterDate;
-import info.monitorenter.gui.chart.rangepolicies.RangePolicyFixedViewport;
-import info.monitorenter.gui.chart.rangepolicies.RangePolicyUnbounded;
-import info.monitorenter.gui.chart.traces.Trace2DLtd;
-import info.monitorenter.gui.chart.traces.Trace2DSimple;
-import info.monitorenter.gui.chart.traces.painters.TracePainterDisc;
-import info.monitorenter.gui.chart.traces.painters.TracePainterFill;
-import info.monitorenter.gui.chart.traces.painters.TracePainterLine;
-import info.monitorenter.gui.chart.traces.painters.TracePainterPolyline;
-import info.monitorenter.gui.chart.traces.painters.TracePainterVerticalBar;
-import info.monitorenter.util.Range;
-
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.event.MouseEvent;
@@ -36,11 +18,29 @@
 import dna.series.data.MetricData;
 import dna.series.data.RunTime;
 import dna.series.data.Value;
+import dna.util.Config;
 import dna.visualization.MainDisplay;
 import dna.visualization.config.ConfigItem;
 import dna.visualization.config.MetricVisualizerItem;
 import dna.visualization.config.VisualizerListConfig;
 import dna.visualization.config.components.MetricVisualizerConfig;
+import info.monitorenter.gui.chart.IAxis;
+import info.monitorenter.gui.chart.IAxis.AxisTitle;
+import info.monitorenter.gui.chart.ITrace2D;
+import info.monitorenter.gui.chart.ITracePainter;
+import info.monitorenter.gui.chart.ITracePoint2D;
+import info.monitorenter.gui.chart.axis.scalepolicy.AxisScalePolicyAutomaticBestFit;
+import info.monitorenter.gui.chart.labelformatters.LabelFormatterDate;
+import info.monitorenter.gui.chart.rangepolicies.RangePolicyFixedViewport;
+import info.monitorenter.gui.chart.rangepolicies.RangePolicyUnbounded;
+import info.monitorenter.gui.chart.traces.Trace2DLtd;
+import info.monitorenter.gui.chart.traces.Trace2DSimple;
+import info.monitorenter.gui.chart.traces.painters.TracePainterDisc;
+import info.monitorenter.gui.chart.traces.painters.TracePainterFill;
+import info.monitorenter.gui.chart.traces.painters.TracePainterLine;
+import info.monitorenter.gui.chart.traces.painters.TracePainterPolyline;
+import info.monitorenter.gui.chart.traces.painters.TracePainterVerticalBar;
+import info.monitorenter.util.Range;
 
 @SuppressWarnings("serial")
 public class MetricVisualizer extends Visualizer {
@@ -68,10 +68,11 @@ public class MetricVisualizer extends Visualizer {
 	private static String statisticsPrefix = "statistics.";
 
 	// constructor
-	public MetricVisualizer(MainDisplay mainDisplay,
-			MetricVisualizerConfig config) {
+	public MetricVisualizer(MainDisplay mainDisplay, MetricVisualizerConfig config) {
 		// initialization
 		super(config.getChartSize(), config.getLegendSize());
+
+		this.x1Connected = config.getMenuBarConfig().isX1AxisConnected();
 		this.mainDisplay = mainDisplay;
 		this.traces = new HashMap<String, ITrace2D>();
 		this.availableValues = new ArrayList<String>();
@@ -86,10 +87,8 @@ public MetricVisualizer(MainDisplay mainDisplay,
 
 		// set title and border of the metric visualizer
 		TitledBorder title = BorderFactory.createTitledBorder(config.getName());
-		title.setBorder(BorderFactory
-				.createEtchedBorder((EtchedBorder.LOWERED)));
-		title.setTitleFont(new Font(
-				this.mainDisplay.getDefaultFont().getName(), Font.BOLD,
+		title.setBorder(BorderFactory.createEtchedBorder((EtchedBorder.LOWERED)));
+		title.setTitleFont(new Font(this.mainDisplay.getDefaultFont().getName(), Font.BOLD,
 				this.mainDisplay.getDefaultFont().getSize()));
 		title.setTitleColor(this.mainDisplay.getDefaultFontColor());
 		this.setBorder(title);
@@ -98,14 +97,14 @@ public MetricVisualizer(MainDisplay mainDisplay,
 		this.xAxisTypeTimestamp = true;
 		if (config.getxAxisType().equals("date")) {
 			this.xAxisTypeTimestamp = false;
-			this.xAxis1.setFormatter(new LabelFormatterDate(
-					new SimpleDateFormat(config.getxAxisFormat())));
+			this.xAxis1.setFormatter(new LabelFormatterDate(new SimpleDateFormat(config.getxAxisFormat())));
 			this.xAxis1.setMajorTickSpacing(5);
 			this.xAxis1.setMinorTickSpacing(1);
-			this.xAxis1
-					.setAxisScalePolicy(new AxisScalePolicyAutomaticBestFit());
+			this.xAxis1.setAxisScalePolicy(new AxisScalePolicyAutomaticBestFit());
 		}
 
+		this.xAxis1.setRangePolicy(new RangePolicyFixedViewport(new Range(0, 1)));
+
 		// add menu bar
 		super.addMenuBar(config.getMenuBarConfig());
 
@@ -114,11 +113,8 @@ public MetricVisualizer(MainDisplay mainDisplay,
 			@Override
 			public void mouseMoved(MouseEvent e) {
 				if (chart.getPointFinder().getNearestPoint(e, chart) != null) {
-					ITracePoint2D tempPointFinder = chart.getPointFinder()
-							.getNearestPoint(e, chart);
-					menuBar.updateCoordsPanel(
-							(int) Math.floor(tempPointFinder.getX()),
-							tempPointFinder.getY());
+					ITracePoint2D tempPointFinder = chart.getPointFinder().getNearestPoint(e, chart);
+					menuBar.updateCoordsPanel(tempPointFinder.getX(), tempPointFinder.getY());
 				}
 			}
 
@@ -130,9 +126,11 @@ public void mouseDragged(MouseEvent e) {
 		this.chart.setPreferredSize(config.getChartSize());
 		this.legend.setLegendSize(config.getLegendSize());
 		this.xAxisOffset = config.getxAxisOffset();
-
+		this.xAxis1.setAxisTitle(new AxisTitle(config.getx1AxisTitle()));
 		this.yAxis1.setAxisTitle(new AxisTitle(config.getY1AxisTitle()));
 		this.yAxis2.setAxisTitle(new AxisTitle(config.getY2AxisTitle()));
+
+		this.menuBar.setVisible(config.getMenuBarConfig().isVisible());
 	}
 
 	/** handles the ticks that are shown on the x axis **/
@@ -171,14 +169,18 @@ protected void updateX1Ticks() {
 	 */
 	public void updateData(BatchData b) {
 		long timestamp = b.getTimestamp();
+
+		if (Config.getBoolean("VISUALIZATION_TIMESTAMP_AS_SECOND")) {
+			timestamp = (timestamp + Config.getInt("VISUALIZATION_TIMESTAMP_OFFSET")) * 1000;
+		}
+
 		double timestampDouble = timestamp;
 
 		// check if new batch is before last one which means time slided
 		// backwards
 		if (timestamp < this.currentTimestamp) {
 			while (this.batchBuffer.size() > 0) {
-				if (this.batchBuffer.getLast().getTimestamp() <= b
-						.getTimestamp()) {
+				if (this.batchBuffer.getLast().getTimestamp() <= b.getTimestamp()) {
 					break;
 				} else {
 					this.batchBuffer.removeLast();
@@ -209,14 +211,11 @@ public void updateData(BatchData b) {
 
 			// update values
 			for (String metric : b.getMetrics().getNames()) {
-				for (String value : b.getMetrics().get(metric).getValues()
-						.getNames()) {
+				for (String value : b.getMetrics().get(metric).getValues().getNames()) {
 					if (this.traces.containsKey(metric + "." + value)) {
 						String tempName = metric + "." + value;
-						double tempValue = b.getMetrics().get(metric)
-								.getValues().get(value).getValue();
-						this.traces.get(tempName).addPoint(
-								timestampDouble + offsetX, tempValue);
+						double tempValue = b.getMetrics().get(metric).getValues().get(value).getValue();
+						this.traces.get(tempName).addPoint(timestampDouble + offsetX, tempValue);
 						offsetX += this.xAxisOffset;
 						this.legend.updateItem(tempName, tempValue);
 					}
@@ -224,84 +223,43 @@ public void updateData(BatchData b) {
 			}
 			// update general runtimes
 			for (String runtime : b.getGeneralRuntimes().getNames()) {
-				if (this.traces
-						.containsKey(MetricVisualizer.generalRuntimesPrefix
-								+ runtime)) {
-					String tempName = MetricVisualizer.generalRuntimesPrefix
-							+ runtime;
-					double tempValue = b.getGeneralRuntimes().get(runtime)
-							.getRuntime();
-					this.traces.get(tempName).addPoint(
-							timestampDouble + offsetX, tempValue);
+				if (this.traces.containsKey(MetricVisualizer.generalRuntimesPrefix + runtime)) {
+					String tempName = MetricVisualizer.generalRuntimesPrefix + runtime;
+					double tempValue = b.getGeneralRuntimes().get(runtime).getRuntime();
+					this.traces.get(tempName).addPoint(timestampDouble + offsetX, tempValue);
 					offsetX += this.xAxisOffset;
 					this.legend.updateItem(tempName, tempValue);
 				}
 			}
 			// update metric runtimes
 			for (String runtime : b.getMetricRuntimes().getNames()) {
-				if (this.traces
-						.containsKey(MetricVisualizer.metricRuntimesPrefix
-								+ runtime)) {
-					String tempName = MetricVisualizer.metricRuntimesPrefix
-							+ runtime;
-					double tempValue = b.getMetricRuntimes().get(runtime)
-							.getRuntime();
-
-					this.traces.get(tempName).addPoint(
-							timestampDouble + offsetX, tempValue);
+				if (this.traces.containsKey(MetricVisualizer.metricRuntimesPrefix + runtime)) {
+					String tempName = MetricVisualizer.metricRuntimesPrefix + runtime;
+					double tempValue = b.getMetricRuntimes().get(runtime).getRuntime();
+
+					this.traces.get(tempName).addPoint(timestampDouble + offsetX, tempValue);
 					offsetX += this.xAxisOffset;
 					this.legend.updateItem(tempName, tempValue);
 				}
 			}
 			// update statistics
 			for (String value : b.getValues().getNames()) {
-				if (this.traces.containsKey(MetricVisualizer.statisticsPrefix
-						+ value)) {
+				if (this.traces.containsKey(MetricVisualizer.statisticsPrefix + value)) {
 					String tempName = MetricVisualizer.statisticsPrefix + value;
 					double tempValue = b.getValues().get(value).getValue();
 
-					this.traces.get(tempName).addPoint(
-							timestampDouble + offsetX, tempValue);
+					this.traces.get(tempName).addPoint(timestampDouble + offsetX, tempValue);
 					offsetX += this.xAxisOffset;
 					this.legend.updateItem(tempName, tempValue);
 				}
 			}
-			// timestamp adjustmens for x-axis tick calculation
-			if (config.isTraceModeLtd() && !this.FIXED_VIEWPORT) {
-				this.maxShownTimestamp = this.maxTimestamp;
-				if (this.maxShownTimestamp - this.TRACE_LENGTH > 0)
-					this.minShownTimestamp = this.maxShownTimestamp
-							- this.TRACE_LENGTH;
-				else
-					this.minShownTimestamp = 0;
-				this.xAxis1.setRange(new Range(this.minShownTimestamp,
-						this.maxShownTimestamp));
-			} else {
-				if (this.FIXED_VIEWPORT) {
-					double lowP = 1.0 * this.menuBar.getIntervalSlider()
-							.getValue() / 100;
-					double highP = 1.0 * (this.menuBar.getIntervalSlider()
-							.getValue() + this.menuBar.getIntervalSlider()
-							.getModel().getExtent()) / 100;
-					double minD = 0;
-					double maxD = 0;
-
-					for (String s : this.traces.keySet()) {
-						minD = this.traces.get(s).getMinX();
-						maxD = this.traces.get(s).getMaxX();
-						if (this.traces.get(s).getMinX() < this.minTimestamp)
-							minD = this.traces.get(s).getMinX();
-						if (this.traces.get(s).getMaxX() > this.maxTimestamp)
-							maxD = this.traces.get(s).getMaxX();
-					}
-					double tMinNew = minD + (lowP * (maxD - minD));
-					double tMaxNew = minD + (highP * (maxD - minD));
 
-					this.xAxis1.setRange(new Range(tMinNew, tMaxNew));
-					this.setMinShownTimestamp((long) tMinNew);
-					this.setMaxShownTimestamp((long) tMaxNew);
-				}
+			if (this.FIXED_VIEWPORT) {
+				this.setXAxis1RangeByIntervalSelection();
+			} else {
+				this.xAxis1.setRange(new Range(minTimestamp, maxTimestamp));
 			}
+
 			// update chart axis ticks
 			this.updateTicks();
 		}
@@ -347,20 +305,21 @@ private void reloadTrace(String name) {
 
 	/** updates only one specific trace **/
 	private void updateTrace(BatchData b, String name) {
-
 		long timestamp = b.getTimestamp();
 		double timestampDouble = timestamp;
+
+		if (Config.getBoolean("VISUALIZATION_TIMESTAMP_AS_SECOND")) {
+			timestampDouble = (timestampDouble + Config.getInt("VISUALIZATION_TIMESTAMP_OFFSET")) * 1000;
+		}
+
 		// update values
 		for (String metric : b.getMetrics().getNames()) {
-			for (String value : b.getMetrics().get(metric).getValues()
-					.getNames()) {
+			for (String value : b.getMetrics().get(metric).getValues().getNames()) {
 				if (this.traces.containsKey(metric + "." + value)) {
 					String tempName = metric + "." + value;
 					if (tempName.equals(name)) {
-						double tempValue = b.getMetrics().get(metric)
-								.getValues().get(value).getValue();
-						this.traces.get(tempName).addPoint(timestampDouble,
-								tempValue);
+						double tempValue = b.getMetrics().get(metric).getValues().get(value).getValue();
+						this.traces.get(tempName).addPoint(timestampDouble, tempValue);
 						this.legend.updateItem(tempName, tempValue);
 					}
 				}
@@ -368,43 +327,33 @@ private void updateTrace(BatchData b, String name) {
 		}
 		// update general runtimes
 		for (String runtime : b.getGeneralRuntimes().getNames()) {
-			if (this.traces.containsKey(MetricVisualizer.generalRuntimesPrefix
-					+ runtime)) {
-				String tempName = MetricVisualizer.generalRuntimesPrefix
-						+ runtime;
+			if (this.traces.containsKey(MetricVisualizer.generalRuntimesPrefix + runtime)) {
+				String tempName = MetricVisualizer.generalRuntimesPrefix + runtime;
 				if (tempName.equals(name)) {
-					double tempValue = b.getGeneralRuntimes().get(runtime)
-							.getRuntime();
-					this.traces.get(tempName).addPoint(timestampDouble,
-							tempValue);
+					double tempValue = b.getGeneralRuntimes().get(runtime).getRuntime();
+					this.traces.get(tempName).addPoint(timestampDouble, tempValue);
 					this.legend.updateItem(tempName, tempValue);
 				}
 			}
 		}
 		// update metric runtimes
 		for (String runtime : b.getMetricRuntimes().getNames()) {
-			if (this.traces.containsKey(MetricVisualizer.metricRuntimesPrefix
-					+ runtime)) {
-				String tempName = MetricVisualizer.metricRuntimesPrefix
-						+ runtime;
-				double tempValue = b.getMetricRuntimes().get(runtime)
-						.getRuntime();
+			if (this.traces.containsKey(MetricVisualizer.metricRuntimesPrefix + runtime)) {
+				String tempName = MetricVisualizer.metricRuntimesPrefix + runtime;
+				double tempValue = b.getMetricRuntimes().get(runtime).getRuntime();
 				if (tempName.equals(name)) {
-					this.traces.get(tempName).addPoint(timestampDouble,
-							tempValue);
+					this.traces.get(tempName).addPoint(timestampDouble, tempValue);
 					this.legend.updateItem(tempName, tempValue);
 				}
 			}
 		}
 		// update statistics
 		for (String value : b.getValues().getNames()) {
-			if (this.traces.containsKey(MetricVisualizer.statisticsPrefix
-					+ value)) {
+			if (this.traces.containsKey(MetricVisualizer.statisticsPrefix + value)) {
 				String tempName = MetricVisualizer.statisticsPrefix + value;
 				if (tempName.equals(name)) {
 					double tempValue = b.getValues().get(value).getValue();
-					this.traces.get(tempName).addPoint(timestampDouble,
-							tempValue);
+					this.traces.get(tempName).addPoint(timestampDouble, tempValue);
 					this.legend.updateItem(tempName, tempValue);
 				}
 			}
@@ -420,8 +369,7 @@ public void addTrace(String name, Color color) {
 				this.traces.put(name, newTrace);
 				this.chart.addTrace(newTrace);
 				if (config.isPaintLinesPoint())
-					newTrace.addTracePainter(new TracePainterDisc(config
-							.getLinesPointSize()));
+					newTrace.addTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 				if (config.isPaintFill())
 					newTrace.addTracePainter(new TracePainterFill(this.chart));
 			} else {
@@ -431,8 +379,7 @@ public void addTrace(String name, Color color) {
 				this.chart.addTrace(newTrace);
 
 				if (config.isPaintLinesPoint())
-					newTrace.addTracePainter(new TracePainterDisc(config
-							.getLinesPointSize()));
+					newTrace.addTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 				if (config.isPaintFill())
 					newTrace.addTracePainter(new TracePainterFill(this.chart));
 			}
@@ -453,16 +400,13 @@ public void addTrace(String name, Color color, boolean verticalBar) {
 						if (painter instanceof TracePainterPolyline)
 							newTrace.removeTracePainter(painter);
 					}
-					newTrace.addTracePainter(new TracePainterVerticalBar(config
-							.getVerticalBarSize(), this.chart));
+					newTrace.addTracePainter(new TracePainterVerticalBar(config.getVerticalBarSize(), this.chart));
 				} else {
 					if (config.isPaintLinesPoint())
-						newTrace.addTracePainter(new TracePainterDisc(config
-								.getLinesPointSize()));
+						newTrace.addTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 
 					if (config.isPaintFill())
-						newTrace.addTracePainter(new TracePainterFill(
-								this.chart));
+						newTrace.addTracePainter(new TracePainterFill(this.chart));
 				}
 			} else {
 				Trace2DSimple newTrace = new Trace2DSimple();
@@ -471,8 +415,7 @@ public void addTrace(String name, Color color, boolean verticalBar) {
 				this.chart.addTrace(newTrace);
 
 				if (config.isPaintLinesPoint())
-					newTrace.addTracePainter(new TracePainterDisc(config
-							.getLinesPointSize()));
+					newTrace.addTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 				if (config.isPaintFill())
 					newTrace.addTracePainter(new TracePainterFill(this.chart));
 			}
@@ -481,13 +424,19 @@ public void addTrace(String name, Color color, boolean verticalBar) {
 
 	/** initializes the data with the first batch **/
 	public void initData(BatchData b) {
+		long timestamp = b.getTimestamp();
+
+		if (Config.getBoolean("VISUALIZATION_TIMESTAMP_AS_SECOND")) {
+			timestamp = (timestamp + Config.getInt("VISUALIZATION_TIMESTAMP_OFFSET")) * 1000;
+		}
+
 		this.initBatch = b;
-		this.minTimestamp = b.getTimestamp();
-		this.maxTimestamp = b.getTimestamp();
-		this.minShownTimestamp = b.getTimestamp();
+		this.minTimestamp = timestamp;
+		this.maxTimestamp = timestamp;
+		this.minShownTimestamp = timestamp;
 		this.maxShownTimestamp = this.minShownTimestamp;
 
-		this.currentTimestamp = b.getTimestamp();
+		this.currentTimestamp = timestamp;
 
 		// clear chart
 		for (ITrace2D t : this.chart.getTraces()) {
@@ -496,8 +445,7 @@ public void initData(BatchData b) {
 
 		// gather all available values
 		for (String metric : b.getMetrics().getNames()) {
-			for (String value : b.getMetrics().get(metric).getValues()
-					.getNames()) {
+			for (String value : b.getMetrics().get(metric).getValues().getNames()) {
 				this.availableValues.add(metric + "." + value);
 			}
 		}
@@ -505,13 +453,11 @@ public void initData(BatchData b) {
 			// graphGeneration runtime will be ignored cause it is only present
 			// in the initial batch
 			if (!runtime.equals("graphGeneration")) {
-				this.availableValues.add(MetricVisualizer.generalRuntimesPrefix
-						+ runtime);
+				this.availableValues.add(MetricVisualizer.generalRuntimesPrefix + runtime);
 			}
 		}
 		for (String runtime : b.getMetricRuntimes().getNames()) {
-			this.availableValues.add(MetricVisualizer.metricRuntimesPrefix
-					+ runtime);
+			this.availableValues.add(MetricVisualizer.metricRuntimesPrefix + runtime);
 		}
 		for (String value : b.getValues().getNames()) {
 			this.availableValues.add(MetricVisualizer.statisticsPrefix + value);
@@ -563,12 +509,10 @@ public void toggleDisplayMode(String name) {
 					verticalBar = true;
 			}
 			if (verticalBar) {
-				trace.setTracePainter(new TracePainterDisc(config
-						.getLinesPointSize()));
+				trace.setTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 				trace.addTracePainter(new TracePainterLine());
 			} else {
-				trace.setTracePainter(new TracePainterVerticalBar(config
-						.getVerticalBarSize(), this.chart));
+				trace.setTracePainter(new TracePainterVerticalBar(config.getVerticalBarSize(), this.chart));
 			}
 		}
 	}
@@ -678,8 +622,7 @@ public void loadConfig(VisualizerListConfig config) {
 		// add single configs to lists
 		for (ConfigItem c : config.getEntries()) {
 			if (c instanceof MetricVisualizerItem) {
-				if (this.availableValues.contains(c.getName())
-						&& c.getOrderId() >= -1) {
+				if (this.availableValues.contains(c.getName()) && c.getOrderId() >= -1) {
 					configsList.add((MetricVisualizerItem) c);
 				}
 			}
@@ -689,21 +632,18 @@ public void loadConfig(VisualizerListConfig config) {
 		MetricVisualizer.addGeneralConfigs(configsList, config);
 
 		// craft names list to use as a blacklist for general configs later
-		ArrayList<String> configsNamesList = new ArrayList<String>(
-				configsList.size());
+		ArrayList<String> configsNamesList = new ArrayList<String>(configsList.size());
 		for (MetricVisualizerItem c : configsList)
 			configsNamesList.add(c.getName());
 
 		// convert list to array
-		MetricVisualizerItem[] configsArray = configsList
-				.toArray(new MetricVisualizerItem[configsList.size()]);
+		MetricVisualizerItem[] configsArray = configsList.toArray(new MetricVisualizerItem[configsList.size()]);
 
 		// sort array with insertion sort
 		for (int i = 1; i < configsArray.length; i++) {
 			MetricVisualizerItem single = configsArray[i];
 			int j = i;
-			while (j > 0
-					&& configsArray[j - 1].getOrderId() > single.getOrderId()) {
+			while (j > 0 && configsArray[j - 1].getOrderId() > single.getOrderId()) {
 				configsArray[j] = configsArray[j - 1];
 				j--;
 			}
@@ -715,20 +655,16 @@ public void loadConfig(VisualizerListConfig config) {
 
 		// calculate "breakpoint" in sorted list: where does -1 end?
 		int breakpoint = 0;
-		for (int i = 0; i < configsArray.length
-				&& configsArray[i].getOrderId() < 0; i++)
+		for (int i = 0; i < configsArray.length && configsArray[i].getOrderId() < 0; i++)
 			breakpoint = i + 1;
 
 		// first insert items with id > -1, then those with -1
-		this.insertForId(breakpoint, configsArray.length, b, configsNamesList,
-				configsArray, config);
-		this.insertForId(0, breakpoint, b, configsNamesList, configsArray,
-				config);
+		this.insertForId(breakpoint, configsArray.length, b, configsNamesList, configsArray, config);
+		this.insertForId(0, breakpoint, b, configsNamesList, configsArray, config);
 	}
 
 	/** Inserts items from the configs array to the legend. **/
-	private void insertForId(int from, int to, BatchData b,
-			ArrayList<String> configsNamesList,
+	private void insertForId(int from, int to, BatchData b, ArrayList<String> configsNamesList,
 			MetricVisualizerItem[] configsArray, VisualizerListConfig config) {
 		for (int i = from; i < to; i++) {
 			MetricVisualizerItem item = configsArray[i];
@@ -760,90 +696,89 @@ private void insertForId(int from, int to, BatchData b,
 	}
 
 	/** Adds all set general configs to the list. **/
-	private static void addGeneralConfigs(
-			ArrayList<MetricVisualizerItem> configs, VisualizerListConfig config) {
+	private static void addGeneralConfigs(ArrayList<MetricVisualizerItem> configs, VisualizerListConfig config) {
 		if (config.isAnyGeneralConfigSet()) {
-			if (config.getAllGeneralRuntimesConfig() != null
-					&& config.getAllGeneralRuntimesConfig().getOrderId() >= -1)
+			if (config.getAllGeneralRuntimesConfig() != null && config.getAllGeneralRuntimesConfig().getOrderId() >= -1)
 				configs.add(config.getAllGeneralRuntimesConfig());
 
-			if (config.getAllMetricRuntimesConfig() != null
-					&& config.getAllMetricRuntimesConfig().getOrderId() >= -1)
+			if (config.getAllMetricRuntimesConfig() != null && config.getAllMetricRuntimesConfig().getOrderId() >= -1)
 				configs.add(config.getAllMetricRuntimesConfig());
 
-			if (config.getAllStatisticsConfig() != null
-					&& config.getAllStatisticsConfig().getOrderId() >= -1)
+			if (config.getAllStatisticsConfig() != null && config.getAllStatisticsConfig().getOrderId() >= -1)
 				configs.add(config.getAllStatisticsConfig());
 
-			if (config.getAllMetricsConfig() != null
-					&& config.getAllMetricsConfig().getOrderId() >= -1)
+			if (config.getAllMetricsConfig() != null && config.getAllMetricsConfig().getOrderId() >= -1)
 				configs.add(config.getAllMetricsConfig());
 		}
 	}
 
 	/** Insert all available metric runtimes. **/
-	private void insertMetricRuntimes(BatchData b, VisualizerListConfig config,
-			ArrayList<String> blackList) {
+	private void insertMetricRuntimes(BatchData b, VisualizerListConfig config, ArrayList<String> blackList) {
 		// insert all available metric runtimes
 		for (String runtime : b.getMetricRuntimes().getNames()) {
-			if (!blackList.contains(MetricVisualizer.metricRuntimesPrefix
-					+ runtime)) {
+			if (!blackList.contains(MetricVisualizer.metricRuntimesPrefix + runtime)) {
 				MetricVisualizerItem c = config.getAllMetricRuntimesConfig();
-				this.legend.addValueItemToList(new MetricVisualizerItem(
-						MetricVisualizer.metricRuntimesPrefix + runtime, c
-								.getDisplayMode(), c.getYAxis(), c
-								.getVisibility()));
+				this.legend.addValueItemToList(new MetricVisualizerItem(MetricVisualizer.metricRuntimesPrefix + runtime,
+						c.getDisplayMode(), c.getYAxis(), c.getVisibility()));
 			}
 		}
 	}
 
 	/** Insert all available general runtimes. **/
-	private void insertGeneralRuntimes(BatchData b,
-			VisualizerListConfig config, ArrayList<String> blackList) {
+	private void insertGeneralRuntimes(BatchData b, VisualizerListConfig config, ArrayList<String> blackList) {
 		for (String runtime : b.getGeneralRuntimes().getNames()) {
 			// graphGeneration runtime will be ignored cause it is only present
 			// in the initial batch
 			if (!runtime.equals("graphGeneration")
-					&& !blackList
-							.contains(MetricVisualizer.generalRuntimesPrefix
-									+ runtime)) {
+					&& !blackList.contains(MetricVisualizer.generalRuntimesPrefix + runtime)) {
 				MetricVisualizerItem c = config.getAllGeneralRuntimesConfig();
-				this.legend.addValueItemToList(new MetricVisualizerItem(
-						MetricVisualizer.generalRuntimesPrefix + runtime, c
-								.getDisplayMode(), c.getYAxis(), c
-								.getVisibility()));
+				this.legend
+						.addValueItemToList(new MetricVisualizerItem(MetricVisualizer.generalRuntimesPrefix + runtime,
+								c.getDisplayMode(), c.getYAxis(), c.getVisibility()));
 			}
 		}
 	}
 
 	/** Insert all available statistics. **/
-	private void insertStatistics(BatchData b, VisualizerListConfig config,
-			ArrayList<String> blackList) {
+	private void insertStatistics(BatchData b, VisualizerListConfig config, ArrayList<String> blackList) {
 		for (String value : b.getValues().getNames()) {
 			if (!blackList.contains(MetricVisualizer.statisticsPrefix + value)) {
 				MetricVisualizerItem c = config.getAllStatisticsConfig();
-				this.legend.addValueItemToList(new MetricVisualizerItem(
-						MetricVisualizer.statisticsPrefix + value, c
-								.getDisplayMode(), c.getYAxis(), c
-								.getVisibility()));
+				this.legend.addValueItemToList(new MetricVisualizerItem(MetricVisualizer.statisticsPrefix + value,
+						c.getDisplayMode(), c.getYAxis(), c.getVisibility()));
 			}
 		}
 	}
 
 	/** Insert all available metrics. **/
-	private void insertMetrics(BatchData b, VisualizerListConfig config,
-			ArrayList<String> blackList) {
+	private void insertMetrics(BatchData b, VisualizerListConfig config, ArrayList<String> blackList) {
 		for (String metric : b.getMetrics().getNames()) {
-			for (String value : b.getMetrics().get(metric).getValues()
-					.getNames()) {
+			for (String value : b.getMetrics().get(metric).getValues().getNames()) {
 				if (!blackList.contains(metric + "." + value)) {
 					MetricVisualizerItem c = config.getAllMetricsConfig();
-					this.legend.addValueItemToList(new MetricVisualizerItem(
-							metric + "." + value, c.getDisplayMode(), c
-									.getYAxis(), c.getVisibility()));
+					this.legend.addValueItemToList(new MetricVisualizerItem(metric + "." + value, c.getDisplayMode(),
+							c.getYAxis(), c.getVisibility()));
 				}
 			}
 		}
 	}
 
+	@Override
+	public void broadcastX1IntervalSizeSliderChange(int value) {
+		if (this.isX1Connected())
+			this.mainDisplay.broadcastX1SizeSliderChange(this, value);
+	}
+
+	@Override
+	public void broadcastX1IntervalScrollBarChange(int value) {
+		if (this.isX1Connected())
+			this.mainDisplay.broadcastX1IntervalScrollBarChange(this, value);
+	}
+
+	@Override
+	public void broadcastX1IntervalEnabled(boolean enabled) {
+		if (this.isX1Connected())
+			this.mainDisplay.broadcastX1IntervalEnabled(this, enabled);
+	}
+
 }
diff --git a/src/dna/visualization/components/visualizer/MultiScalarVisualizer.java b/src/dna/visualization/components/visualizer/MultiScalarVisualizer.java
index e32bb24e..4ea0f4c3 100644
--- a/src/dna/visualization/components/visualizer/MultiScalarVisualizer.java
+++ b/src/dna/visualization/components/visualizer/MultiScalarVisualizer.java
@@ -1,16 +1,5 @@
 package dna.visualization.components.visualizer;
 
-import info.monitorenter.gui.chart.IAxis;
-import info.monitorenter.gui.chart.IAxis.AxisTitle;
-import info.monitorenter.gui.chart.ITrace2D;
-import info.monitorenter.gui.chart.ITracePainter;
-import info.monitorenter.gui.chart.ITracePoint2D;
-import info.monitorenter.gui.chart.traces.Trace2DSimple;
-import info.monitorenter.gui.chart.traces.painters.TracePainterDisc;
-import info.monitorenter.gui.chart.traces.painters.TracePainterFill;
-import info.monitorenter.gui.chart.traces.painters.TracePainterLine;
-import info.monitorenter.gui.chart.traces.painters.TracePainterVerticalBar;
-
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.event.MouseEvent;
@@ -47,6 +36,16 @@
 import dna.visualization.config.VisualizerListConfig.xAxisSelection;
 import dna.visualization.config.VisualizerListConfig.yAxisSelection;
 import dna.visualization.config.components.MultiScalarVisualizerConfig;
+import info.monitorenter.gui.chart.IAxis;
+import info.monitorenter.gui.chart.IAxis.AxisTitle;
+import info.monitorenter.gui.chart.ITrace2D;
+import info.monitorenter.gui.chart.ITracePainter;
+import info.monitorenter.gui.chart.ITracePoint2D;
+import info.monitorenter.gui.chart.traces.Trace2DSimple;
+import info.monitorenter.gui.chart.traces.painters.TracePainterDisc;
+import info.monitorenter.gui.chart.traces.painters.TracePainterFill;
+import info.monitorenter.gui.chart.traces.painters.TracePainterLine;
+import info.monitorenter.gui.chart.traces.painters.TracePainterVerticalBar;
 
 @SuppressWarnings("serial")
 public class MultiScalarVisualizer extends Visualizer {
@@ -73,8 +72,7 @@ public class MultiScalarVisualizer extends Visualizer {
 	private BatchData currentBatch;
 
 	// constructor
-	public MultiScalarVisualizer(MainDisplay mainDisplay,
-			MultiScalarVisualizerConfig config) {
+	public MultiScalarVisualizer(MainDisplay mainDisplay, MultiScalarVisualizerConfig config) {
 		// initialization
 		super(config.getChartSize(), config.getLegendSize());
 		this.config = config;
@@ -99,10 +97,8 @@ public MultiScalarVisualizer(MainDisplay mainDisplay,
 
 		// set title and border of the visualizer
 		TitledBorder title = BorderFactory.createTitledBorder(config.getName());
-		title.setBorder(BorderFactory
-				.createEtchedBorder((EtchedBorder.LOWERED)));
-		title.setTitleFont(new Font(
-				this.mainDisplay.getDefaultFont().getName(), Font.BOLD,
+		title.setBorder(BorderFactory.createEtchedBorder((EtchedBorder.LOWERED)));
+		title.setTitleFont(new Font(this.mainDisplay.getDefaultFont().getName(), Font.BOLD,
 				this.mainDisplay.getDefaultFont().getSize()));
 		title.setTitleColor(this.mainDisplay.getDefaultFontColor());
 		this.setBorder(title);
@@ -115,11 +111,8 @@ public MultiScalarVisualizer(MainDisplay mainDisplay,
 			@Override
 			public void mouseMoved(MouseEvent e) {
 				if (chart.getPointFinder().getNearestPoint(e, chart) != null) {
-					ITracePoint2D tempPointFinder = chart.getPointFinder()
-							.getNearestPoint(e, chart);
-					menuBar.updateCoordsPanel(
-							(int) Math.floor(tempPointFinder.getX()),
-							tempPointFinder.getY());
+					ITracePoint2D tempPointFinder = chart.getPointFinder().getNearestPoint(e, chart);
+					menuBar.updateCoordsPanel((int) Math.floor(tempPointFinder.getX()), tempPointFinder.getY());
 				}
 			}
 
@@ -131,6 +124,7 @@ public void mouseDragged(MouseEvent e) {
 		// apply config
 		this.chart.setPreferredSize(config.getChartSize());
 		this.legend.setLegendSize(config.getLegendSize());
+		this.menuBar.setVisible(config.getMenuBarConfig().isVisible());
 		this.xAxisOffset = config.getxAxisOffset();
 
 		this.xAxis1.setAxisTitle(new AxisTitle(config.getx1AxisTitle()));
@@ -158,12 +152,10 @@ public void initData(BatchData b) {
 
 		// gather all available values
 		for (String metric : b.getMetrics().getNames()) {
-			for (String dist : b.getMetrics().get(metric).getDistributions()
-					.getNames()) {
+			for (String dist : b.getMetrics().get(metric).getDistributions().getNames()) {
 				this.availableDistributions.add(metric + "." + dist);
 			}
-			for (String nvl : b.getMetrics().get(metric).getNodeValues()
-					.getNames()) {
+			for (String nvl : b.getMetrics().get(metric).getNodeValues().getNames()) {
 				this.availableNodeValueLists.add(metric + "." + nvl);
 			}
 		}
@@ -199,74 +191,58 @@ public void updateData(BatchData b) {
 
 		// add points
 		for (String metric : b.getMetrics().getNames()) {
-			for (String dist : b.getMetrics().get(metric).getDistributions()
-					.getNames()) {
+			for (String dist : b.getMetrics().get(metric).getDistributions().getNames()) {
 				if (this.traces.containsKey(metric + "." + dist)) {
-					Distr<?, ?> tempDist = b.getMetrics().get(metric)
-							.getDistributions().get(dist);
+					Distr<?, ?> tempDist = b.getMetrics().get(metric).getDistributions().get(dist);
 					String tempName = metric + "." + dist;
 
 					DistrType tempType = tempDist.getDistrType();
 
-					SortModeDist tempSortMode = ((LegendItemDistribution) this.legend
-							.getLegendList().getLegendItem(tempName))
-							.getSortMode();
+					SortModeDist tempSortMode = ((LegendItemDistribution) this.legend.getLegendList()
+							.getLegendItem(tempName)).getSortMode();
 
 					switch (tempType) {
 					case BINNED_DOUBLE:
 						BinnedDoubleDistr bdd = (BinnedDoubleDistr) tempDist;
-						this.addLongDistributionTrace(tempName,
-								bdd.getValues(), bdd.getDenominator(),
-								bdd.getBinSize(), tempSortMode,
-								this.getTraceOffsetX(tempName));
+						this.addLongDistributionTrace(tempName, bdd.getValues(), bdd.getDenominator(), bdd.getBinSize(),
+								tempSortMode, this.getTraceOffsetX(tempName));
 						break;
 					case BINNED_INT:
 						BinnedIntDistr bid = (BinnedIntDistr) tempDist;
-						this.addLongDistributionTrace(tempName,
-								bid.getValues(), bid.getDenominator(),
-								bid.getBinSize(), tempSortMode,
-								this.getTraceOffsetX(tempName));
+						this.addLongDistributionTrace(tempName, bid.getValues(), bid.getDenominator(), bid.getBinSize(),
+								tempSortMode, this.getTraceOffsetX(tempName));
 						break;
 					case BINNED_LONG:
 						BinnedLongDistr bld = (BinnedLongDistr) tempDist;
-						this.addLongDistributionTrace(tempName,
-								bld.getValues(), bld.getDenominator(),
-								bld.getBinSize(), tempSortMode,
-								this.getTraceOffsetX(tempName));
+						this.addLongDistributionTrace(tempName, bld.getValues(), bld.getDenominator(), bld.getBinSize(),
+								tempSortMode, this.getTraceOffsetX(tempName));
 						break;
 					case QUALITY_DOUBLE:
 						QualityDoubleDistr qdd = (QualityDoubleDistr) tempDist;
-						this.addDoubleDistributionTrace(tempName,
-								qdd.getValues(), qdd.getBinSize(),
-								tempSortMode, this.getTraceOffsetX(tempName));
+						this.addDoubleDistributionTrace(tempName, qdd.getValues(), qdd.getBinSize(), tempSortMode,
+								this.getTraceOffsetX(tempName));
 						break;
 					case QUALITY_INT:
 						QualityIntDistr qid = (QualityIntDistr) tempDist;
-						this.addDoubleDistributionTrace(tempName,
-								qid.getValues(), qid.getBinSize(),
-								tempSortMode, this.getTraceOffsetX(tempName));
+						this.addDoubleDistributionTrace(tempName, qid.getValues(), qid.getBinSize(), tempSortMode,
+								this.getTraceOffsetX(tempName));
 						break;
 					case QUALITY_LONG:
 						QualityLongDistr qld = (QualityLongDistr) tempDist;
-						this.addDoubleDistributionTrace(tempName,
-								qld.getValues(), qld.getBinSize(),
-								tempSortMode, this.getTraceOffsetX(tempName));
+						this.addDoubleDistributionTrace(tempName, qld.getValues(), qld.getBinSize(), tempSortMode,
+								this.getTraceOffsetX(tempName));
 						break;
 					}
 				}
 			}
-			for (String nvl : b.getMetrics().get(metric).getNodeValues()
-					.getNames()) {
+			for (String nvl : b.getMetrics().get(metric).getNodeValues().getNames()) {
 				String tempName = metric + "." + nvl;
 				if (this.traces.containsKey(tempName)) {
-					SortModeNVL tempSortMode = ((LegendItemNodeValueList) this.legend
-							.getLegendList().getLegendItem(tempName))
-							.getSortMode();
-					double[] tempValues = b.getMetrics().get(metric)
-							.getNodeValues().get(nvl).getValues();
+					SortModeNVL tempSortMode = ((LegendItemNodeValueList) this.legend.getLegendList()
+							.getLegendItem(tempName)).getSortMode();
+					double[] tempValues = b.getMetrics().get(metric).getNodeValues().get(nvl).getValues();
 					this.doubleValues.put(tempName, tempValues);
-					this.addPoints(metric + "." + nvl, tempValues,
-							tempSortMode, this.getTraceOffsetX(tempName));
+					this.addPoints(metric + "." + nvl, tempValues, tempSortMode, this.getTraceOffsetX(tempName));
 				}
 			}
 		}
@@ -275,8 +251,8 @@ public void updateData(BatchData b) {
 	}
 
 	/** adds points sorted and normalized by dividing through denominator **/
-	private void addDistributionPoints(String name, long[] values,
-			long denominator, double binsize, SortModeDist sort, double offsetX) {
+	private void addDistributionPoints(String name, long[] values, long denominator, double binsize, SortModeDist sort,
+			double offsetX) {
 		ITrace2D tempTrace = this.traces.get(name);
 		long[] tempValues = new long[values.length];
 
@@ -291,8 +267,7 @@ private void addDistributionPoints(String name, long[] values,
 			break;
 		case distribution:
 			for (int i = 0; i < values.length; i++) {
-				tempTrace.addPoint(i * binsize + offsetX, (1.0 * values[i])
-						/ denominator);
+				tempTrace.addPoint(i * binsize + offsetX, (1.0 * values[i]) / denominator);
 			}
 			break;
 		}
@@ -304,8 +279,8 @@ private void addDistributionPoints(String name, long[] values,
 	}
 
 	/** adds points sorted and normalized by dividing through denominator **/
-	private void addDistributionPoints(String name, double[] values,
-			double binsize, SortModeDist sort, double offsetX) {
+	private void addDistributionPoints(String name, double[] values, double binsize, SortModeDist sort,
+			double offsetX) {
 		ITrace2D tempTrace = this.traces.get(name);
 		double[] tempValues = new double[values.length];
 
@@ -332,8 +307,7 @@ private void addDistributionPoints(String name, double[] values,
 	}
 
 	/** adds points sorted **/
-	private void addPoints(String name, double[] values, SortModeNVL sort,
-			double offsetX) {
+	private void addPoints(String name, double[] values, SortModeNVL sort, double offsetX) {
 		ITrace2D tempTrace = this.traces.get(name);
 		double[] tempValues = new double[values.length];
 		int tempIndex = 0;
@@ -365,8 +339,7 @@ private void addPoints(String name, double[] values, SortModeNVL sort,
 				else
 					break;
 			}
-			for (int i = 0, j = tempValues.length - 1; i < tempValues.length
-					- tempIndex; i++) {
+			for (int i = 0, j = tempValues.length - 1; i < tempValues.length - tempIndex; i++) {
 				tempTrace.addPoint(j - (i + tempIndex), tempValues[i]);
 			}
 			break;
@@ -394,8 +367,7 @@ public void clearPoints() {
 	}
 
 	/** adds trace to the visualizer **/
-	public void addTrace(String name, Color color, xAxisSelection xAxis,
-			yAxisSelection yAxis) {
+	public void addTrace(String name, Color color, xAxisSelection xAxis, yAxisSelection yAxis) {
 		Trace2DSimple newTrace = new Trace2DSimple();
 		newTrace.setColor(color);
 		this.traces.put(name, newTrace);
@@ -410,15 +382,13 @@ public void addTrace(String name, Color color, xAxisSelection xAxis,
 			this.yAxis2.addTrace(newTrace);
 
 		if (config.isPaintLinesPoint())
-			newTrace.addTracePainter(new TracePainterDisc(config
-					.getLinesPointSize()));
+			newTrace.addTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 		if (config.isPaintFill())
 			newTrace.addTracePainter(new TracePainterFill(this.chart));
 	}
 
 	/** adds trace of a distribution and its points to the visualizer **/
-	public void addDistributionTrace(String name, Color color,
-			xAxisSelection xAxis, yAxisSelection yAxis) {
+	public void addDistributionTrace(String name, Color color, xAxisSelection xAxis, yAxisSelection yAxis) {
 		// calculate offset
 		double offsetX = this.calculateOffsetX(name, xAxis);
 
@@ -431,55 +401,46 @@ public void addDistributionTrace(String name, Color color,
 		// get sort mode
 		SortModeDist tempSortMode = SortModeDist.distribution;
 		if (config.getListConfig() != null) {
-			tempSortMode = config.getListConfig().getAllDistributionsConfig()
-					.getSortMode();
+			tempSortMode = config.getListConfig().getAllDistributionsConfig().getSortMode();
 		}
 
 		// add points to chart
 		for (String metric : this.currentBatch.getMetrics().getNames()) {
-			for (String dist : this.currentBatch.getMetrics().get(metric)
-					.getDistributions().getNames()) {
+			for (String dist : this.currentBatch.getMetrics().get(metric).getDistributions().getNames()) {
 				if ((metric + "." + dist).equals(name)) {
-					Distr<?, ?> tempDist = this.currentBatch.getMetrics()
-							.get(metric).getDistributions().get(dist);
+					Distr<?, ?> tempDist = this.currentBatch.getMetrics().get(metric).getDistributions().get(dist);
 					String tempName = metric + "." + dist;
 
 					switch (tempDist.getDistrType()) {
 					case BINNED_DOUBLE:
 						BinnedDoubleDistr bdd = (BinnedDoubleDistr) tempDist;
-						this.addLongDistributionTrace(tempName,
-								bdd.getValues(), bdd.getDenominator(),
-								bdd.getBinSize(), tempSortMode, offsetX);
+						this.addLongDistributionTrace(tempName, bdd.getValues(), bdd.getDenominator(), bdd.getBinSize(),
+								tempSortMode, offsetX);
 						break;
 					case BINNED_INT:
 						BinnedIntDistr bid = (BinnedIntDistr) tempDist;
-						this.addLongDistributionTrace(tempName,
-								bid.getValues(), bid.getDenominator(),
-								bid.getBinSize(), tempSortMode, offsetX);
+						this.addLongDistributionTrace(tempName, bid.getValues(), bid.getDenominator(), bid.getBinSize(),
+								tempSortMode, offsetX);
 						break;
 					case BINNED_LONG:
 						BinnedLongDistr bld = (BinnedLongDistr) tempDist;
-						this.addLongDistributionTrace(tempName,
-								bld.getValues(), bld.getDenominator(),
-								bld.getBinSize(), tempSortMode, offsetX);
+						this.addLongDistributionTrace(tempName, bld.getValues(), bld.getDenominator(), bld.getBinSize(),
+								tempSortMode, offsetX);
 						break;
 					case QUALITY_DOUBLE:
 						QualityDoubleDistr qdd = (QualityDoubleDistr) tempDist;
-						this.addDoubleDistributionTrace(tempName,
-								qdd.getValues(), qdd.getBinSize(),
-								tempSortMode, offsetX);
+						this.addDoubleDistributionTrace(tempName, qdd.getValues(), qdd.getBinSize(), tempSortMode,
+								offsetX);
 						break;
 					case QUALITY_INT:
 						QualityIntDistr qid = (QualityIntDistr) tempDist;
-						this.addDoubleDistributionTrace(tempName,
-								qid.getValues(), qid.getBinSize(),
-								tempSortMode, offsetX);
+						this.addDoubleDistributionTrace(tempName, qid.getValues(), qid.getBinSize(), tempSortMode,
+								offsetX);
 						break;
 					case QUALITY_LONG:
 						QualityLongDistr qld = (QualityLongDistr) tempDist;
-						this.addDoubleDistributionTrace(tempName,
-								qld.getValues(), qld.getBinSize(),
-								tempSortMode, offsetX);
+						this.addDoubleDistributionTrace(tempName, qld.getValues(), qld.getBinSize(), tempSortMode,
+								offsetX);
 						break;
 					}
 				}
@@ -490,28 +451,25 @@ public void addDistributionTrace(String name, Color color,
 	}
 
 	/** adds trace of a double distribution and its points to the visualizer **/
-	private void addDoubleDistributionTrace(String name, double[] values,
-			double binsize, SortModeDist tempSortMode, double offsetX) {
+	private void addDoubleDistributionTrace(String name, double[] values, double binsize, SortModeDist tempSortMode,
+			double offsetX) {
 		this.doubleValues.put(name, values);
 		this.binSizes.put(name, binsize);
 		this.addDistributionPoints(name, values, binsize, tempSortMode, offsetX);
 	}
 
 	/** adds trace of a long distribution and its points to the visualizer **/
-	private void addLongDistributionTrace(String name, long[] values,
-			long denominator, double binsize, SortModeDist tempSortMode,
-			double offsetX) {
+	private void addLongDistributionTrace(String name, long[] values, long denominator, double binsize,
+			SortModeDist tempSortMode, double offsetX) {
 		this.longValues.put(name, values);
 		this.longDenominators.put(name, denominator);
 		this.binSizes.put(name, binsize);
-		this.addDistributionPoints(name, values, denominator, binsize,
-				tempSortMode, offsetX);
+		this.addDistributionPoints(name, values, denominator, binsize, tempSortMode, offsetX);
 		this.legend.updateItem(name, denominator);
 	}
 
 	/** adds trace of a nodevaluelist and its points to the visualizer **/
-	public void addNodeValueListTrace(String name, Color color,
-			xAxisSelection xAxis, yAxisSelection yAxis) {
+	public void addNodeValueListTrace(String name, Color color, xAxisSelection xAxis, yAxisSelection yAxis) {
 		// calculate offset
 		double offsetX = this.calculateOffsetX(name, xAxis);
 
@@ -523,19 +481,16 @@ public void addNodeValueListTrace(String name, Color color,
 
 		// add points to chart
 		for (String metric : this.currentBatch.getMetrics().getNames()) {
-			for (String nvl : this.currentBatch.getMetrics().get(metric)
-					.getNodeValues().getNames()) {
+			for (String nvl : this.currentBatch.getMetrics().get(metric).getNodeValues().getNames()) {
 				String tempName = metric + "." + nvl;
 				if (this.traces.containsKey(tempName)) {
-					SortModeNVL tempSortMode = ((LegendItemNodeValueList) this.legend
-							.getLegendList().getLegendItem(tempName))
-							.getSortMode();
-					double[] tempValues = this.currentBatch.getMetrics()
-							.get(metric).getNodeValues().get(nvl).getValues();
+					SortModeNVL tempSortMode = ((LegendItemNodeValueList) this.legend.getLegendList()
+							.getLegendItem(tempName)).getSortMode();
+					double[] tempValues = this.currentBatch.getMetrics().get(metric).getNodeValues().get(nvl)
+							.getValues();
 
 					this.doubleValues.put(tempName, tempValues);
-					this.addPoints(metric + "." + nvl, tempValues,
-							tempSortMode, offsetX);
+					this.addPoints(metric + "." + nvl, tempValues, tempSortMode, offsetX);
 				}
 			}
 		}
@@ -723,17 +678,12 @@ public void toggleYAxis(String name) {
 	/** toggles the x axis for a trace identified by its name **/
 	public void toggleXAxis(String name) {
 		if (this.traces.containsKey(name)) {
-			if (this.chart.getAxesXBottom().get(0).getTraces()
-					.contains(this.traces.get(name))) {
-				this.chart.getAxesXBottom().get(0)
-						.removeTrace(this.traces.get(name));
-				this.chart.getAxesXBottom().get(1)
-						.addTrace(this.traces.get(name));
+			if (this.chart.getAxesXBottom().get(0).getTraces().contains(this.traces.get(name))) {
+				this.chart.getAxesXBottom().get(0).removeTrace(this.traces.get(name));
+				this.chart.getAxesXBottom().get(1).addTrace(this.traces.get(name));
 			} else {
-				this.chart.getAxesXBottom().get(1)
-						.removeTrace(this.traces.get(name));
-				this.chart.getAxesXBottom().get(0)
-						.addTrace(this.traces.get(name));
+				this.chart.getAxesXBottom().get(1).removeTrace(this.traces.get(name));
+				this.chart.getAxesXBottom().get(0).addTrace(this.traces.get(name));
 			}
 			this.toggleXAxisVisibility();
 			this.updateTicks();
@@ -761,13 +711,11 @@ public void toggleDisplayMode(String name) {
 					verticalBar = true;
 			}
 			if (verticalBar) {
-				trace.setTracePainter(new TracePainterDisc(config
-						.getLinesPointSize()));
+				trace.setTracePainter(new TracePainterDisc(config.getLinesPointSize()));
 				trace.addTracePainter(new TracePainterLine());
 			} else {
 
-				trace.setTracePainter(new TracePainterVerticalBar(config
-						.getVerticalBarSize(), this.chart));
+				trace.setTracePainter(new TracePainterVerticalBar(config.getVerticalBarSize(), this.chart));
 			}
 		}
 	}
@@ -810,11 +758,9 @@ public void sortItem(String name, SortModeDist s) {
 			double offsetX = 0;
 
 			if (this.doubleValues.containsKey(name)) {
-				this.addDistributionPoints(name, this.doubleValues.get(name),
-						this.binSizes.get(name), s, offsetX);
+				this.addDistributionPoints(name, this.doubleValues.get(name), this.binSizes.get(name), s, offsetX);
 			} else if (this.longValues.containsKey(name)) {
-				this.addDistributionPoints(name, this.longValues.get(name),
-						this.longDenominators.get(name),
+				this.addDistributionPoints(name, this.longValues.get(name), this.longDenominators.get(name),
 						this.binSizes.get(name), s, offsetX);
 			}
 		}
@@ -828,14 +774,12 @@ public void loadConfig(VisualizerListConfig config) {
 		// add single configs to lists
 		for (ConfigItem c : config.getEntries()) {
 			if (c instanceof MultiScalarDistributionItem) {
-				if (this.availableDistributions.contains(c.getName())
-						&& c.getOrderId() >= -1) {
+				if (this.availableDistributions.contains(c.getName()) && c.getOrderId() >= -1) {
 					configsList.add(c);
 				}
 			}
 			if (c instanceof MultiScalarNodeValueListItem) {
-				if (this.availableNodeValueLists.contains(c.getName())
-						&& c.getOrderId() >= -1) {
+				if (this.availableNodeValueLists.contains(c.getName()) && c.getOrderId() >= -1) {
 					configsList.add(c);
 				}
 			}
@@ -845,21 +789,18 @@ public void loadConfig(VisualizerListConfig config) {
 		MultiScalarVisualizer.addGeneralConfigs(configsList, config);
 
 		// craft names list to use as a blacklist for general configs later
-		ArrayList<String> configsNamesList = new ArrayList<String>(
-				configsList.size());
+		ArrayList<String> configsNamesList = new ArrayList<String>(configsList.size());
 		for (ConfigItem c : configsList)
 			configsNamesList.add(c.getName());
 
 		// convert list to array
-		ConfigItem[] configsArray = configsList
-				.toArray(new ConfigItem[configsList.size()]);
+		ConfigItem[] configsArray = configsList.toArray(new ConfigItem[configsList.size()]);
 
 		// sort array with insertion sort
 		for (int i = 1; i < configsArray.length; i++) {
 			ConfigItem single = configsArray[i];
 			int j = i;
-			while (j > 0
-					&& configsArray[j - 1].getOrderId() > single.getOrderId()) {
+			while (j > 0 && configsArray[j - 1].getOrderId() > single.getOrderId()) {
 				configsArray[j] = configsArray[j - 1];
 				j--;
 			}
@@ -869,19 +810,16 @@ public void loadConfig(VisualizerListConfig config) {
 
 		// calculate "breakpoint" in sorted list: where does -1 end?
 		int breakpoint = 0;
-		for (int i = 0; i < configsArray.length
-				&& configsArray[i].getOrderId() < 0; i++)
+		for (int i = 0; i < configsArray.length && configsArray[i].getOrderId() < 0; i++)
 			breakpoint = i + 1;
 
 		// first insert items with id > -1, then those with -1
-		this.insertForId(breakpoint, configsArray.length, configsNamesList,
-				configsArray, config);
+		this.insertForId(breakpoint, configsArray.length, configsNamesList, configsArray, config);
 		this.insertForId(0, breakpoint, configsNamesList, configsArray, config);
 	}
 
 	/** Inserts items from the configs array to the legend. **/
-	private void insertForId(int from, int to,
-			ArrayList<String> configsNamesList, ConfigItem[] configsArray,
+	private void insertForId(int from, int to, ArrayList<String> configsNamesList, ConfigItem[] configsArray,
 			VisualizerListConfig config) {
 		for (int i = from; i < to; i++) {
 			ConfigItem item = configsArray[i];
@@ -901,13 +839,11 @@ private void insertForId(int from, int to,
 			default:
 				if (item instanceof MultiScalarDistributionItem) {
 					if (this.availableDistributions.contains(item.getName()))
-						this.legend
-								.addDistributionItemToList((MultiScalarDistributionItem) item);
+						this.legend.addDistributionItemToList((MultiScalarDistributionItem) item);
 				}
 				if (item instanceof MultiScalarNodeValueListItem) {
 					if (this.availableNodeValueLists.contains(item.getName()))
-						this.legend
-								.addNodeValueListItemToList((MultiScalarNodeValueListItem) item);
+						this.legend.addNodeValueListItemToList((MultiScalarNodeValueListItem) item);
 				}
 				break;
 			}
@@ -915,45 +851,34 @@ private void insertForId(int from, int to,
 	}
 
 	/** Adds all set general configs to the list. **/
-	private static void addGeneralConfigs(ArrayList<ConfigItem> configs,
-			VisualizerListConfig config) {
+	private static void addGeneralConfigs(ArrayList<ConfigItem> configs, VisualizerListConfig config) {
 		if (config.isAnyGeneralConfigSet()) {
-			if (config.getAllDistributionsConfig() != null
-					&& config.getAllDistributionsConfig().getOrderId() >= -1)
+			if (config.getAllDistributionsConfig() != null && config.getAllDistributionsConfig().getOrderId() >= -1)
 				configs.add(config.getAllDistributionsConfig());
 
-			if (config.getAllNodeValueListsConfig() != null
-					&& config.getAllNodeValueListsConfig().getOrderId() >= -1)
+			if (config.getAllNodeValueListsConfig() != null && config.getAllNodeValueListsConfig().getOrderId() >= -1)
 				configs.add(config.getAllNodeValueListsConfig());
 		}
 	}
 
 	/** Insert all available distributions. **/
-	private void insertDistributions(VisualizerListConfig config,
-			ArrayList<String> blackList) {
+	private void insertDistributions(VisualizerListConfig config, ArrayList<String> blackList) {
 		MultiScalarDistributionItem c = config.getAllDistributionsConfig();
 		for (String dist : this.availableDistributions) {
 			if (!blackList.contains(dist)) {
-				this.legend
-						.addDistributionItemToList(new MultiScalarDistributionItem(
-								dist, c.getSortMode(), c.getXAxis(), c
-										.getYAxis(), c.getDisplayMode(), c
-										.getVisibility()));
+				this.legend.addDistributionItemToList(new MultiScalarDistributionItem(dist, c.getSortMode(),
+						c.getXAxis(), c.getYAxis(), c.getDisplayMode(), c.getVisibility()));
 			}
 		}
 	}
 
 	/** Insert all available nodevaluelists. **/
-	private void insertNodeValueLists(VisualizerListConfig config,
-			ArrayList<String> blackList) {
+	private void insertNodeValueLists(VisualizerListConfig config, ArrayList<String> blackList) {
 		MultiScalarNodeValueListItem c = config.getAllNodeValueListsConfig();
 		for (String nvl : this.availableNodeValueLists) {
 			if (!blackList.contains(nvl)) {
-				this.legend
-						.addNodeValueListItemToList(new MultiScalarNodeValueListItem(
-								nvl, c.getSortMode(), c.getXAxis(), c
-										.getYAxis(), c.getDisplayMode(), c
-										.getVisibility()));
+				this.legend.addNodeValueListItemToList(new MultiScalarNodeValueListItem(nvl, c.getSortMode(),
+						c.getXAxis(), c.getYAxis(), c.getDisplayMode(), c.getVisibility()));
 			}
 		}
 	}
@@ -977,12 +902,10 @@ public double calculateOffsetX(String name, xAxisSelection axis) {
 		// gather used offsets
 		List<Double> usedOffsets = new ArrayList<Double>();
 		for (ITrace2D trace : this.offsets.keySet()) {
-			if (this.xAxis1.containsTrace(trace)
-					&& axis.equals(xAxisSelection.x1)) {
+			if (this.xAxis1.containsTrace(trace) && axis.equals(xAxisSelection.x1)) {
 				usedOffsets.add(this.offsets.get(trace));
 			}
-			if (this.xAxis2.containsTrace(trace)
-					&& axis.equals(xAxisSelection.x2)) {
+			if (this.xAxis2.containsTrace(trace) && axis.equals(xAxisSelection.x2)) {
 				usedOffsets.add(this.offsets.get(trace));
 			}
 		}
@@ -1009,8 +932,7 @@ public void decrementOffsetsX1() {
 		for (ITrace2D trace : this.offsets.keySet()) {
 			if (this.xAxis1.containsTrace(trace))
 				if (this.offsets.get(trace) != 0)
-					this.offsets.put(trace, this.offsets.get(trace)
-							- this.xAxisOffset);
+					this.offsets.put(trace, this.offsets.get(trace) - this.xAxisOffset);
 		}
 	}
 
@@ -1019,8 +941,7 @@ public void decrementOffsetsX2() {
 		for (ITrace2D trace : this.offsets.keySet()) {
 			if (this.xAxis2.containsTrace(trace))
 				if (this.offsets.get(trace) != 0)
-					this.offsets.put(trace, this.offsets.get(trace)
-							- this.xAxisOffset);
+					this.offsets.put(trace, this.offsets.get(trace) - this.xAxisOffset);
 		}
 	}
 }
diff --git a/src/dna/visualization/components/visualizer/Visualizer.java b/src/dna/visualization/components/visualizer/Visualizer.java
index 78e9237c..e3cca373 100644
--- a/src/dna/visualization/components/visualizer/Visualizer.java
+++ b/src/dna/visualization/components/visualizer/Visualizer.java
@@ -1,5 +1,15 @@
 package dna.visualization.components.visualizer;
 
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+
+import javax.swing.JPanel;
+
+import dna.visualization.MainDisplay;
+import dna.visualization.config.components.MenuBarConfig;
 import info.monitorenter.gui.chart.Chart2D;
 import info.monitorenter.gui.chart.IAxis;
 import info.monitorenter.gui.chart.IAxis.AxisTitle;
@@ -11,17 +21,7 @@
 import info.monitorenter.gui.chart.rangepolicies.RangePolicyUnbounded;
 import info.monitorenter.gui.chart.traces.Trace2DLtd;
 import info.monitorenter.gui.chart.traces.Trace2DSimple;
-
-import java.awt.Dimension;
-import java.awt.GridBagConstraints;
-import java.awt.GridBagLayout;
-import java.text.DecimalFormat;
-import java.text.NumberFormat;
-
-import javax.swing.JPanel;
-
-import dna.visualization.MainDisplay;
-import dna.visualization.config.components.MenuBarConfig;
+import info.monitorenter.util.Range;
 
 @SuppressWarnings("serial")
 public class Visualizer extends JPanel {
@@ -58,6 +58,9 @@ public class Visualizer extends JPanel {
 	// shows if the visualizer is locked or not
 	protected boolean locked;
 
+	// if true the x1 axis interval selections are shared with other components
+	protected boolean x1Connected;
+
 	// constructor
 	@SuppressWarnings("rawtypes")
 	public Visualizer(Dimension chartSize, Dimension legendSize) {
@@ -65,8 +68,7 @@ public Visualizer(Dimension chartSize, Dimension legendSize) {
 		// this.setPreferredSize(GuiOptions.visualizerDefaultSize);
 		this.paused = true;
 
-		this.TRACE_LENGTH = MainDisplay.DefaultConfig
-				.getMetricVisualizerConfigs()[0].getTraceLength();
+		this.TRACE_LENGTH = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getTraceLength();
 		this.FIXED_VIEWPORT = false;
 		this.minTimestamp = 0;
 		this.maxTimestamp = 0;
@@ -82,6 +84,8 @@ public Visualizer(Dimension chartSize, Dimension legendSize) {
 		// init chart
 		this.chart = new Chart2D();
 		this.chart.setPreferredSize(chartSize);
+		// TODO: add anti alias to config
+		// this.chart.setUseAntialiasing(true);
 
 		/*
 		 * axis configuration
@@ -93,8 +97,7 @@ public Visualizer(Dimension chartSize, Dimension legendSize) {
 		// y1
 		this.yAxis1 = this.chart.getAxisY();
 		this.yAxis1.setAxisTitle(new AxisTitle("y1"));
-		this.yAxis1.setFormatter(new LabelFormatterNumber(new DecimalFormat(
-				"0.0")));
+		this.yAxis1.setFormatter(new LabelFormatterNumber(new DecimalFormat("0.0")));
 
 		// x2
 		this.xAxis2 = new AxisLinear();
@@ -102,8 +105,7 @@ public Visualizer(Dimension chartSize, Dimension legendSize) {
 		this.chart.addAxisXBottom((AAxis) this.xAxis2);
 
 		// y2
-		this.yAxis2 = new AxisLinear(new LabelFormatterNumber(
-				new DecimalFormat("0.0")));
+		this.yAxis2 = new AxisLinear(new LabelFormatterNumber(new DecimalFormat("0.0")));
 		this.yAxis2 = new AxisLinear();
 		this.yAxis2.setVisible(false);
 		this.yAxis2.setAxisTitle(new AxisTitle("y2"));
@@ -133,14 +135,13 @@ public Visualizer(Dimension chartSize, Dimension legendSize) {
 		this.xAxis2.setAxisScalePolicy(manualTickScalePolicy);
 	}
 
-	protected void addMenuBar(Dimension size, boolean addCoordsPanel,
-			boolean addIntervalPanel, boolean addXOptionsPanel,
-			boolean addYLeftOptionsPanel) {
+	protected void addMenuBar(Dimension size, boolean addCoordsPanel, boolean addIntervalPanel,
+			boolean addXOptionsPanel, boolean addYLeftOptionsPanel) {
 		this.mainConstraints.gridx = 0;
 		this.mainConstraints.gridy = 1;
 		this.mainConstraints.gridwidth = 2;
-		this.menuBar = new MenuBar(this, size, addCoordsPanel,
-				addIntervalPanel, addXOptionsPanel, addYLeftOptionsPanel);
+		this.menuBar = new MenuBar(this, size, addCoordsPanel, addIntervalPanel, addXOptionsPanel,
+				addYLeftOptionsPanel);
 		this.add(this.menuBar, this.mainConstraints);
 	}
 
@@ -387,6 +388,27 @@ public void setFixedViewport(boolean isViewportFixed) {
 		this.FIXED_VIEWPORT = isViewportFixed;
 	}
 
+	public void resetXAxis1Range() {
+		this.setXAxis1Range(this.minTimestamp, this.maxTimestamp);
+	}
+
+	public void setXAxis1Range(long min, long max) {
+		this.xAxis1.setRange(new Range(min, max));
+	}
+
+	public void setXAxis1RangeByIntervalSelection() {
+		this.setXAxis1RangePercent(this.menuBar.getIntervalSliderSelectionLowPercent(),
+				this.menuBar.getIntervalSliderSelectionHighPercent());
+	}
+
+	public void setXAxis1RangePercent(double lowPercent, double highPercent) {
+		long coveredArea = maxTimestamp - minTimestamp;
+		long tMinNew = minTimestamp + (long) Math.floor(lowPercent * (coveredArea));
+		long tMaxNew = minTimestamp + (long) Math.floor(highPercent * (coveredArea));
+
+		this.xAxis1.setRange(new Range(tMinNew, tMaxNew));
+	}
+
 	public boolean isViewPortFixed() {
 		return this.FIXED_VIEWPORT;
 	}
@@ -463,7 +485,9 @@ protected void setLocked(boolean locked) {
 		this.locked = locked;
 	}
 
-	/** Called when the visualizer gets locked by the main lock in maindisplay. **/
+	/**
+	 * Called when the visualizer gets locked by the main lock in maindisplay.
+	 **/
 	public void setLockedByMainDisplay(boolean locked) {
 		this.legend.setLocked(locked);
 		this.locked = locked;
@@ -474,4 +498,67 @@ public boolean isLocked() {
 		return this.locked;
 	}
 
+	/**
+	 * Broadcasts the x1 interval size slider changes. The visualizer method
+	 * does nothing as the visualizer does not know the main display and cant
+	 * forward the broadcast. Shall be overridden by visualizer implementations.
+	 **/
+	public void broadcastX1IntervalSizeSliderChange(int value) {
+		// do nothing here
+	}
+
+	/**
+	 * Broadcasts the x1 interval scroll bar changes. The visualizer method does
+	 * nothing as the visualizer does not know the main display and cant forward
+	 * the broadcast. Shall be overridden by visualizer implementations.
+	 **/
+	public void broadcastX1IntervalScrollBarChange(int value) {
+		// do nothing here
+	}
+
+	/**
+	 * Broadcasts the x1 interval checkbox changes. The visualizer method does
+	 * nothing as the visualizer does not know the main display and cant forward
+	 * the broadcast. Shall be overridden by visualizer implementations.
+	 **/
+	public void broadcastX1IntervalEnabled(boolean enabled) {
+		// do nothing here
+	}
+
+	/** Sets the x1 interval size slider. **/
+	public void setX1IntervalSizeSlider(int value) {
+		if (this.isX1Connected())
+			this.menuBar.setX1IntervalSizeSlider(value);
+	}
+
+	/** Sets the x1 interval scrollbar. **/
+	public void setX1IntervalScrollBar(int value) {
+		if (this.isX1Connected())
+			this.menuBar.setX1IntervalScrollBar(value);
+	}
+
+	/** Sets if the interval checkbox is set and if alterations are enabled. **/
+	public void setX1IntervalEnabled(boolean enabled) {
+		if (this.isX1Connected())
+			this.menuBar.setX1IntervalEnabled(enabled);
+	}
+
+	/** Returns if this component is currently connected to shared x1 axis. **/
+	public boolean isX1Connected() {
+		return this.x1Connected;
+	}
+
+	/**
+	 * Sets if the component is connected or not. Called by menu-bar, dont call
+	 * manually! Changes will not be reflected by the menu-bar checkbox.
+	 **/
+	public void setX1Connected(boolean connected) {
+		this.x1Connected = connected;
+	}
+
+	/** Returns the chart. **/
+	public Chart2D getChart() {
+		return this.chart;
+	}
+
 }
diff --git a/src/dna/visualization/components/visualizer/traces/LabelTrace.java b/src/dna/visualization/components/visualizer/traces/LabelTrace.java
new file mode 100644
index 00000000..17a89c86
--- /dev/null
+++ b/src/dna/visualization/components/visualizer/traces/LabelTrace.java
@@ -0,0 +1,254 @@
+package dna.visualization.components.visualizer.traces;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import dna.labels.Label;
+import dna.visualization.components.visualizer.CircularArrayList;
+import dna.visualization.components.visualizer.LabelVisualizer;
+import info.monitorenter.gui.chart.Chart2D;
+import info.monitorenter.gui.chart.ITrace2D;
+import info.monitorenter.gui.chart.traces.Trace2DLtd;
+import info.monitorenter.gui.chart.traces.painters.TracePainterLine;
+
+/**
+ * The LabelTrace represents one entire trace of a single labeler-type pair in a
+ * label-visualizer. It encapsulates and handles all logical traces that are
+ * actually being used.
+ * 
+ * @author Rwilmes
+ *
+ */
+public class LabelTrace {
+
+	protected LabelVisualizer parent;
+	protected Chart2D chart;
+	protected String key;
+
+	protected int y;
+
+	protected double minX;
+	protected double maxX;
+
+	protected boolean visible;
+	protected int size;
+	protected Color color;
+
+	protected double initTimestamp;
+	protected double lastTimestamp;
+
+	protected boolean active;
+	protected HashMap<Double, ITrace2D> currentTraces;
+	protected ArrayList<ITrace2D> removedTraces;
+	protected HashMap<Double, String> values;
+
+	protected CircularArrayList<Double> timestampBuffer;
+
+	public LabelTrace(LabelVisualizer parent, Chart2D chart, String key, int y, int size, Color color,
+			double initTimestamp) {
+		this.parent = parent;
+		this.chart = chart;
+		this.key = key;
+		this.y = y;
+		this.size = size;
+		this.color = color;
+		this.visible = true;
+
+		this.initTimestamp = initTimestamp;
+		this.lastTimestamp = initTimestamp;
+
+		this.minX = initTimestamp;
+		this.maxX = initTimestamp;
+
+		this.active = false;
+		this.currentTraces = new HashMap<Double, ITrace2D>();
+		this.removedTraces = new ArrayList<ITrace2D>();
+		this.values = new HashMap<Double, String>();
+		this.timestampBuffer = new CircularArrayList<Double>(this.parent.getTraceLength());
+	}
+
+	/**
+	 * Called for each batch to update the trace. If label was not present in
+	 * the batch the handed over Label-object should be null.
+	 **/
+	public void update(double timestamp, Label label) {
+		this.timestampBuffer.addSilent(timestamp);
+
+		// maybe remove old traces
+		handleRemovedTraces();
+
+		if (label != null) {
+			String value = label.getValue();
+			if (active) {
+				// add points to all traces
+				for (double y : this.currentTraces.keySet()) {
+					this.currentTraces.get(y).addPoint(timestamp, y);
+					this.addValue(timestamp, value);
+				}
+			} else {
+				double y = this.y;
+
+				Trace2DLtd newTrace = new Trace2DLtd(this.parent.getTraceLength());
+				newTrace.setColor(this.color);
+				newTrace.setStroke(new BasicStroke(this.size, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
+				this.chart.addTrace(newTrace);
+				newTrace.addTracePainter(new TracePainterLine());
+
+				// add point t-1
+				if (this.lastTimestamp == timestamp) {
+					newTrace.addPoint(timestamp - 1, y);
+					this.addValue(timestamp - 1, value);
+				} else {
+					newTrace.addPoint(lastTimestamp, y);
+					this.addValue(lastTimestamp, value);
+				}
+
+				// add point t
+				newTrace.addPoint(timestamp, y);
+				this.addValue(timestamp, value);
+
+				// add trace to current traces
+				this.currentTraces.put(y, newTrace);
+
+				// mark as active
+				this.active = true;
+			}
+		} else {
+
+			// label is null
+			if (active) {
+				// move all current traces to removed traces
+				this.removeCurrentTraces();
+
+				// mark as inactive
+				this.active = false;
+			}
+
+			this.parent.updateItem(this.key, " -");
+		}
+
+		// update last timestamp to this one
+		this.lastTimestamp = timestamp;
+	}
+
+	/** Handles removed traces. **/
+	protected void handleRemovedTraces() {
+		double minX = this.getMinX();
+
+		ArrayList<ITrace2D> toBeTrashed = new ArrayList<ITrace2D>();
+
+		for (ITrace2D trace : this.removedTraces) {
+			if (trace.getMaxX() >= minX)
+				break;
+			else
+				toBeTrashed.add(trace);
+		}
+
+		for (ITrace2D trace : toBeTrashed) {
+			this.removedTraces.remove(trace);
+			this.chart.removeTrace(trace);
+			trace.removeAllPoints();
+		}
+	}
+
+	/** Adds a label-value to the internal hashmap. **/
+	protected void addValue(double y, String value) {
+		this.values.put(y, value);
+		this.parent.updateItem(this.key, value);
+	}
+
+	/** Clears all traces associated with this object. **/
+	public void clear() {
+		this.removeCurrentTraces();
+		for (ITrace2D trace : this.removedTraces) {
+			trace.removeAllPoints();
+			trace.removeAllPointHighlighters();
+			this.chart.removeTrace(trace);
+		}
+		this.removedTraces.clear();
+		this.values.clear();
+		this.minX = this.initTimestamp;
+		this.maxX = this.initTimestamp;
+		this.lastTimestamp = this.initTimestamp;
+		this.active = false;
+	}
+
+	/** Moves all current traces to the removed traces. **/
+	protected void removeCurrentTraces() {
+		for (Double y : this.currentTraces.keySet())
+			this.removedTraces.add(this.currentTraces.get(y));
+
+		this.currentTraces.clear();
+	}
+
+	/** Sets the last-timestamp. **/
+	public void setLastTimestamp(double timestamp) {
+		this.lastTimestamp = timestamp;
+	}
+
+	/** Returns the traces y-mapping. **/
+	public int getYMapping() {
+		return this.y;
+	}
+
+	/** Sets a new size and updates all traces. **/
+	public void setSize(int size) {
+		this.size = size;
+		updateTraceSizes();
+	}
+
+	/** Updates the size of all traces. **/
+	protected void updateTraceSizes() {
+		for (Double y : this.currentTraces.keySet()) {
+			ITrace2D trace = this.currentTraces.get(y);
+			trace.setStroke(new BasicStroke(this.size, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
+		}
+		for (ITrace2D trace : this.removedTraces) {
+			trace.setStroke(new BasicStroke(this.size, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
+		}
+	}
+
+	/** Returns whether the traces are currently shown or not **/
+	public boolean isVisible() {
+		return this.visible;
+	}
+
+	/** Sets the visibility of the traces. **/
+	public void setVisible(boolean visible) {
+		for (Double y : this.currentTraces.keySet()) {
+			this.currentTraces.get(y).setVisible(visible);
+		}
+		for (ITrace2D trace : this.removedTraces) {
+			trace.setVisible(visible);
+		}
+		this.visible = visible;
+	}
+
+	/** Returns the value for the given timestamp (x-coordinate). **/
+	public String getValue(double timestamp) {
+		String value = this.values.get(timestamp);
+		if (value == null)
+			return "null";
+		else
+			return value;
+	}
+
+	// public double getMinX() {
+	// return this.minX;
+	// }
+	//
+	// public double getMaxX() {
+	// return this.maxX;
+	// }
+
+	public double getMinX() {
+		return this.timestampBuffer.getHead();
+	}
+
+	public double getMaxX() {
+		return this.timestampBuffer.getTail();
+	}
+
+}
diff --git a/src/dna/visualization/config/components/LabelVisualizerConfig.java b/src/dna/visualization/config/components/LabelVisualizerConfig.java
new file mode 100644
index 00000000..1abc6b29
--- /dev/null
+++ b/src/dna/visualization/config/components/LabelVisualizerConfig.java
@@ -0,0 +1,481 @@
+package dna.visualization.config.components;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.lang.reflect.Field;
+
+import dna.visualization.MainDisplay;
+import dna.visualization.config.JSON.JSONArray;
+import dna.visualization.config.JSON.JSONObject;
+
+/**
+ * A config object for label visualizers.
+ * 
+ * @author Rwilmes
+ *
+ */
+public class LabelVisualizerConfig {
+
+	/** Enumeration for addition policies. **/
+	public enum LabelAdditionPolicy {
+		AUTOMATIC_ADDITION_ALL, AUTOMATIC_ADDITION_LIST, MANUAL
+	}
+
+	public LabelVisualizerConfig(String name, int traceLength, boolean traceModeLtd, double barThickness,
+			LabelAdditionPolicy additionPolicy, String[] additionList, int positionX, int positionY, int rowSpan,
+			int colSpan, Dimension chartSize, String x1AxisTitle, String xAxisType, String xAxisFormat,
+			String y1AxisTitle, Dimension legendSize, Dimension legendItemSize, Dimension legendItemButtonSize,
+			Dimension legendItemButtonPanelSize, Dimension legendItemNameLabelSize, Dimension legendItemValueLabelSize,
+			Font legendItemValueFont, Color legendItemValueFontColor, MenuBarConfig menuBarConfig) {
+		this.name = name;
+		this.traceLength = traceLength;
+		this.traceModeLtd = traceModeLtd;
+		this.barThickness = barThickness;
+		this.additionPolicy = additionPolicy;
+		this.additionList = additionList;
+		this.positionX = positionX;
+		this.positionY = positionY;
+		this.rowSpan = rowSpan;
+		this.colSpan = colSpan;
+		this.chartSize = chartSize;
+		this.x1AxisTitle = x1AxisTitle;
+		this.xAxisType = xAxisType;
+		this.xAxisFormat = xAxisFormat;
+		this.y1AxisTitle = y1AxisTitle;
+		this.legendSize = legendSize;
+		this.legendItemSize = legendItemSize;
+		this.legendItemButtonSize = legendItemButtonSize;
+		this.legendItemButtonPanelSize = legendItemButtonPanelSize;
+		this.legendItemNameLabelSize = legendItemNameLabelSize;
+		this.legendItemValueLabelSize = legendItemValueLabelSize;
+		this.legendItemValueFont = legendItemValueFont;
+		this.legendItemValueFontColor = legendItemValueFontColor;
+		this.menuBarConfig = menuBarConfig;
+	}
+
+	// general options
+	private String name;
+	private int traceLength;
+	private boolean traceModeLtd;
+	private double barThickness;
+
+	private LabelAdditionPolicy additionPolicy;
+	private String[] additionList;
+
+	// position
+	private int positionX;
+	private int positionY;
+	private int rowSpan;
+	private int colSpan;
+
+	// chart options
+	private Dimension chartSize;
+
+	// x axis
+	private String x1AxisTitle;
+	private String xAxisType;
+	private String xAxisFormat;
+
+	// y axis
+	private String y1AxisTitle;
+
+	// legend options
+	private Dimension legendSize;
+	private Dimension legendItemSize;
+	private Dimension legendItemButtonSize;
+	private Dimension legendItemButtonPanelSize;
+	private Dimension legendItemNameLabelSize;
+	private Dimension legendItemValueLabelSize;
+	private Font legendItemValueFont;
+	private Color legendItemValueFontColor;
+
+	// menu bar options
+	private MenuBarConfig menuBarConfig;
+
+	// get methods
+	public String getName() {
+		return this.name;
+	}
+
+	public int getTraceLength() {
+		return this.traceLength;
+	}
+
+	public boolean isTraceModeLtd() {
+		return this.traceModeLtd;
+	}
+
+	public double getBarThickness() {
+		return this.barThickness;
+	}
+
+	public int getPositionX() {
+		return this.positionX;
+	}
+
+	public int getPositionY() {
+		return this.positionY;
+	}
+
+	public int getRowSpan() {
+		return this.rowSpan;
+	}
+
+	public int getColSpan() {
+		return this.colSpan;
+	}
+
+	public Dimension getChartSize() {
+		return this.chartSize;
+	}
+
+	public String getX1AxisTitle() {
+		return this.x1AxisTitle;
+	}
+
+	public String getxAxisType() {
+		return this.xAxisType;
+	}
+
+	public String getxAxisFormat() {
+		return this.xAxisFormat;
+	}
+
+	public String getY1AxisTitle() {
+		return this.y1AxisTitle;
+	}
+
+	public Dimension getLegendSize() {
+		return this.legendSize;
+	}
+
+	public Dimension getLegendItemSize() {
+		return this.legendItemSize;
+	}
+
+	public Dimension getLegendItemButtonSize() {
+		return this.legendItemButtonSize;
+	}
+
+	public Dimension getLegendItemButtonPanelSize() {
+		return this.legendItemButtonPanelSize;
+	}
+
+	public Dimension getLegendItemNameLabelSize() {
+		return this.legendItemNameLabelSize;
+	}
+
+	public Dimension getLegendItemValueLabelSize() {
+		return this.legendItemValueLabelSize;
+	}
+
+	public Font getLegendItemValueFont() {
+		return this.legendItemValueFont;
+	}
+
+	public Color getLegendItemValueFontColor() {
+		return this.legendItemValueFontColor;
+	}
+
+	public MenuBarConfig getMenuBarConfig() {
+		return this.menuBarConfig;
+	}
+
+	public LabelAdditionPolicy getAdditionPolicy() {
+		return additionPolicy;
+	}
+
+	public String[] getAdditionList() {
+		return additionList;
+	}
+
+	/** Creates a Label visualizer config object from a given json object. **/
+	public static LabelVisualizerConfig createLabelVisualizerConfigFromJSONObject(JSONObject o) {
+		// init
+		String name;
+		int traceLength;
+		boolean traceModeLtd;
+		double barThickness = 0.5;
+		LabelAdditionPolicy additionPolicy;
+		String[] additionList;
+
+		int positionX = -1;
+		int positionY = -1;
+		int rowSpan = 1;
+		int colSpan = 1;
+		Dimension chartSize;
+		String x1AxisTitle;
+		String xAxisType;
+		String xAxisFormat;
+		String y1AxisTitle;
+		Dimension legendSize;
+		Dimension legendItemSize;
+		Dimension legendItemButtonSize;
+		Dimension legendItemButtonPanelSize;
+		Dimension legendItemNameLabelSize;
+		Dimension legendItemValueLabelSize;
+		Font legendItemValueFont;
+		Color legendItemValueFontColor;
+		MenuBarConfig menuBarConfig;
+
+		// set default values
+		if (MainDisplay.DefaultConfig == null) {
+			// if the defaultconfig is not set, use this default values
+			name = o.getString("Name");
+			traceLength = o.getInt("TraceLength");
+			traceModeLtd = o.getBoolean("TraceModeLtd");
+			JSONObject chart = o.getJSONObject("Chart");
+			chartSize = new Dimension(chart.getInt("Width"), chart.getInt("Height"));
+			x1AxisTitle = chart.getString("xAxisTitle");
+			xAxisType = chart.getString("xAxisType");
+			xAxisFormat = chart.getString("xAxisFormat");
+			y1AxisTitle = chart.getString("y1AxisTitle");
+			barThickness = chart.getDouble("BarThickness");
+
+			String policyString = o.getString("AdditionPolicy");
+			switch (policyString) {
+			case "all":
+				additionPolicy = LabelAdditionPolicy.AUTOMATIC_ADDITION_ALL;
+				break;
+			case "list":
+				additionPolicy = LabelAdditionPolicy.AUTOMATIC_ADDITION_LIST;
+				break;
+			default:
+				additionPolicy = LabelAdditionPolicy.MANUAL;
+				break;
+			}
+
+			JSONArray additionListArray = o.getJSONArray("AdditionList");
+			additionList = new String[additionListArray.length()];
+			for (int i = 0; i < additionListArray.length(); i++) {
+				additionList[i] = additionListArray.getString(i);
+			}
+
+			JSONObject legend = o.getJSONObject("Legend");
+			legendSize = new Dimension(legend.getInt("Width"), legend.getInt("Height"));
+			JSONObject legendItem = legend.getJSONObject("LegendItem");
+			legendItemSize = new Dimension(legendItem.getInt("Width"), legendItem.getInt("Height"));
+			legendItemButtonSize = new Dimension(legendItem.getInt("Button_Width"), legendItem.getInt("Button_Height"));
+			legendItemButtonPanelSize = new Dimension(legendItem.getInt("ButtonPanel_Width"),
+					legendItem.getInt("ButtonPanel_Height"));
+			legendItemNameLabelSize = new Dimension(legendItem.getInt("NameLabel_Width"),
+					legendItem.getInt("NameLabel_Height"));
+			legendItemValueLabelSize = new Dimension(legendItem.getInt("ValueLabel_Width"),
+					legendItem.getInt("ValueLabel_Height"));
+			JSONObject fontObject = legendItem.getJSONObject("ValueFont");
+			String tempName = fontObject.getString("Name");
+			String tempStyle = fontObject.getString("Style");
+			int tempSize = fontObject.getInt("Size");
+			int style;
+			switch (tempStyle) {
+			case "PLAIN":
+				style = Font.PLAIN;
+				break;
+			case "BOLD":
+				style = Font.BOLD;
+				break;
+			case "ITALIC":
+				style = Font.ITALIC;
+				break;
+			default:
+				style = Font.PLAIN;
+				break;
+			}
+			legendItemValueFont = new Font(tempName, style, tempSize);
+			legendItemValueFontColor = Color.BLACK;
+			try {
+				Field field = Color.class.getField(fontObject.getString("Color"));
+				legendItemValueFontColor = (Color) field.get(null);
+			} catch (Exception e) {
+			}
+			menuBarConfig = MenuBarConfig.createMenuBarConfigFromJSONObject(o.getJSONObject("MenuBar"));
+		} else {
+			// use default config values as defaults
+			LabelVisualizerConfig defaultConfig = MainDisplay.DefaultConfig.getLabelVisualizerConfigs()[0];
+			name = defaultConfig.getName();
+			traceLength = defaultConfig.getTraceLength();
+			traceModeLtd = defaultConfig.isTraceModeLtd();
+			barThickness = defaultConfig.getBarThickness();
+			additionPolicy = defaultConfig.getAdditionPolicy();
+			additionList = defaultConfig.getAdditionList();
+			chartSize = defaultConfig.getChartSize();
+			x1AxisTitle = defaultConfig.getX1AxisTitle();
+			xAxisType = defaultConfig.getxAxisType();
+			xAxisFormat = defaultConfig.getxAxisFormat();
+			y1AxisTitle = defaultConfig.getY1AxisTitle();
+			legendSize = defaultConfig.getLegendSize();
+			legendItemSize = defaultConfig.getLegendItemSize();
+			legendItemButtonSize = defaultConfig.getLegendItemButtonSize();
+			legendItemButtonPanelSize = defaultConfig.getLegendItemButtonPanelSize();
+			legendItemNameLabelSize = defaultConfig.getLegendItemNameLabelSize();
+			legendItemValueLabelSize = defaultConfig.getLegendItemValueLabelSize();
+			legendItemValueFont = defaultConfig.getLegendItemValueFont();
+			legendItemValueFontColor = defaultConfig.getLegendItemValueFontColor();
+			menuBarConfig = defaultConfig.getMenuBarConfig();
+		}
+
+		// overwrite default values with parsed values
+		try {
+			name = o.getString("Name");
+		} catch (Exception e) {
+		}
+
+		try {
+			traceLength = o.getInt("TraceLength");
+		} catch (Exception e) {
+		}
+
+		try {
+			traceModeLtd = o.getBoolean("TraceModeLtd");
+		} catch (Exception e) {
+		}
+
+		try {
+			String policyString = o.getString("AdditionPolicy");
+
+			switch (policyString) {
+			case "all":
+				additionPolicy = LabelAdditionPolicy.AUTOMATIC_ADDITION_ALL;
+				break;
+			case "list":
+				additionPolicy = LabelAdditionPolicy.AUTOMATIC_ADDITION_LIST;
+				break;
+			default:
+				additionPolicy = LabelAdditionPolicy.MANUAL;
+				break;
+			}
+		} catch (Exception e) {
+		}
+
+		try {
+			JSONArray additionListArray = o.getJSONArray("AdditionList");
+			additionList = new String[additionListArray.length()];
+			for (int i = 0; i < additionListArray.length(); i++) {
+				additionList[i] = additionListArray.getString(i);
+			}
+		} catch (Exception e) {
+		}
+
+		try {
+			JSONObject positionObject = o.getJSONObject("position");
+			try {
+				positionX = positionObject.getInt("x");
+				positionY = positionObject.getInt("y");
+			} catch (Exception e) {
+			}
+			try {
+				rowSpan = positionObject.getInt("rowspan");
+				colSpan = positionObject.getInt("colspan");
+			} catch (Exception e) {
+			}
+		} catch (Exception e) {
+		}
+
+		try {
+			JSONObject chart = o.getJSONObject("Chart");
+			try {
+				chartSize = new Dimension(chart.getInt("Width"), chart.getInt("Height"));
+			} catch (Exception e) {
+			}
+
+			for (String s : JSONObject.getNames(chart)) {
+				switch (s) {
+				case "BarThickness":
+					barThickness = chart.getDouble(s);
+					break;
+				case "xAxisTitle":
+					x1AxisTitle = chart.getString(s);
+					break;
+				case "xAxisType":
+					xAxisType = chart.getString(s);
+					break;
+				case "xAxisFormat":
+					xAxisFormat = chart.getString(s);
+					break;
+				case "y1AxisTitle":
+					y1AxisTitle = chart.getString(s);
+					break;
+				}
+			}
+		} catch (Exception e) {
+		}
+
+		// legend
+		try {
+			JSONObject legend = o.getJSONObject("Legend");
+			legendSize = new Dimension(legend.getInt("Width"), legend.getInt("Height"));
+			try {
+				JSONObject legendItem = legend.getJSONObject("LegendItem");
+				try {
+					legendItemSize = new Dimension(legendItem.getInt("Width"), legendItem.getInt("Height"));
+				} catch (Exception e) {
+				}
+				try {
+					legendItemButtonSize = new Dimension(legendItem.getInt("Button_Width"),
+							legendItem.getInt("Button_Height"));
+				} catch (Exception e) {
+				}
+				try {
+					legendItemButtonPanelSize = new Dimension(legendItem.getInt("ButtonPanel_Width"),
+							legendItem.getInt("ButtonPanel_Height"));
+				} catch (Exception e) {
+				}
+				try {
+					legendItemNameLabelSize = new Dimension(legendItem.getInt("NameLabel_Width"),
+							legendItem.getInt("NameLabel_Height"));
+				} catch (Exception e) {
+				}
+				try {
+					legendItemValueLabelSize = new Dimension(legendItem.getInt("ValueLabel_Width"),
+							legendItem.getInt("ValueLabel_Height"));
+				} catch (Exception e) {
+				}
+				try {
+					JSONObject fontObject = legendItem.getJSONObject("ValueFont");
+
+					String tempName = fontObject.getString("Name");
+					String tempStyle = fontObject.getString("Style");
+					int tempSize = fontObject.getInt("Size");
+					int style;
+					switch (tempStyle) {
+					case "PLAIN":
+						style = Font.PLAIN;
+						break;
+					case "BOLD":
+						style = Font.BOLD;
+						break;
+					case "ITALIC":
+						style = Font.ITALIC;
+						break;
+					default:
+						style = Font.PLAIN;
+						break;
+					}
+					legendItemValueFont = new Font(tempName, style, tempSize);
+					legendItemValueFontColor = Color.BLACK;
+					try {
+						Field field = Color.class.getField(fontObject.getString("Color"));
+						legendItemValueFontColor = (Color) field.get(null);
+					} catch (Exception e) {
+					}
+				} catch (Exception e) {
+				}
+			} catch (Exception e) {
+			}
+		} catch (Exception e) {
+		}
+
+		// parse menu bar config
+		try {
+			menuBarConfig = MenuBarConfig.createMenuBarConfigFromJSONObject(o.getJSONObject("MenuBar"));
+		} catch (Exception e) {
+		}
+
+		// craft metric visualizer config
+		return new LabelVisualizerConfig(name, traceLength, traceModeLtd, barThickness, additionPolicy, additionList,
+				positionX, positionY, rowSpan, colSpan, chartSize, x1AxisTitle, xAxisType, xAxisFormat, y1AxisTitle,
+				legendSize, legendItemSize, legendItemButtonSize, legendItemButtonPanelSize, legendItemNameLabelSize,
+				legendItemValueLabelSize, legendItemValueFont, legendItemValueFontColor, menuBarConfig);
+	}
+}
diff --git a/src/dna/visualization/config/components/MainDisplayConfig.java b/src/dna/visualization/config/components/MainDisplayConfig.java
index d112f76c..1b48e04f 100644
--- a/src/dna/visualization/config/components/MainDisplayConfig.java
+++ b/src/dna/visualization/config/components/MainDisplayConfig.java
@@ -23,16 +23,13 @@
 public class MainDisplayConfig {
 
 	// constructor
-	public MainDisplayConfig(String name, Dimension size,
-			boolean liveDisplayMode, boolean fullscreen, ZipMode zipMode,
-			String defaultDir, Font defaultFont, Color defaultFontColor,
-			Dimension buttonSize, String logoDir, Dimension logoSize,
-			String scalingExpression, Dimension visualizerPanelSize,
-			Dimension innerVisualizerPanelSize,
-			StatsDisplayConfig statsDisplayConfig,
-			LogDisplayConfig[] logDisplayConfigs,
-			MetricVisualizerConfig[] metricVisualizerConfigs,
-			MultiScalarVisualizerConfig[] multiScalarVisualizerConfigs) {
+	public MainDisplayConfig(String name, Dimension size, boolean liveDisplayMode, boolean fullscreen, ZipMode zipMode,
+			String defaultDir, Font defaultFont, Color defaultFontColor, Dimension buttonSize, String logoDir,
+			Dimension logoSize, String scalingExpression, Dimension visualizerPanelSize,
+			Dimension innerVisualizerPanelSize, StatsDisplayConfig statsDisplayConfig,
+			LogDisplayConfig[] logDisplayConfigs, MetricVisualizerConfig[] metricVisualizerConfigs,
+			MultiScalarVisualizerConfig[] multiScalarVisualizerConfigs,
+			LabelVisualizerConfig[] labelVisualizerConfigs) {
 		this.name = name;
 		this.size = size;
 		this.liveDisplayMode = liveDisplayMode;
@@ -51,6 +48,7 @@ public MainDisplayConfig(String name, Dimension size,
 		this.logDisplayConfigs = logDisplayConfigs;
 		this.metricVisualizerConfigs = metricVisualizerConfigs;
 		this.multiScalarVisualizerConfigs = multiScalarVisualizerConfigs;
+		this.labelVisualizerConfigs = labelVisualizerConfigs;
 	}
 
 	private String name;
@@ -73,6 +71,7 @@ public MainDisplayConfig(String name, Dimension size,
 	private LogDisplayConfig[] logDisplayConfigs;
 	private MetricVisualizerConfig[] metricVisualizerConfigs;
 	private MultiScalarVisualizerConfig[] multiScalarVisualizerConfigs;
+	private LabelVisualizerConfig[] labelVisualizerConfigs;
 
 	// get methods
 	public String getName() {
@@ -169,6 +168,10 @@ public MultiScalarVisualizerConfig[] getMultiScalarVisualizerConfigs() {
 		return this.multiScalarVisualizerConfigs;
 	}
 
+	public LabelVisualizerConfig[] getLabelVisualizerConfigs() {
+		return this.labelVisualizerConfigs;
+	}
+
 	/*
 	 * STATIC METHODS
 	 */
@@ -189,8 +192,7 @@ public static MainDisplayConfig getDisplayConfig() {
 	}
 
 	/** Creates a main display config object from a given json object. **/
-	public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
-			JSONObject o) {
+	public static MainDisplayConfig createMainDisplayConfigFromJSONObject(JSONObject o) {
 		// init
 		String name;
 		Dimension size;
@@ -212,6 +214,7 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 		LogDisplayConfig[] logDisplayConfigs = new LogDisplayConfig[0];
 		MetricVisualizerConfig[] metricVisualizerConfigs = new MetricVisualizerConfig[0];
 		MultiScalarVisualizerConfig[] multiScalarVisualizerConfigs = new MultiScalarVisualizerConfig[0];
+		LabelVisualizerConfig[] labelVisualizerConfigs = new LabelVisualizerConfig[0];
 
 		// set default values
 		if (MainDisplay.DefaultConfig == null) {
@@ -257,24 +260,19 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 			defaultFont = new Font(tempName, style, tempSize);
 			defaultFontColor = Color.BLACK;
 			try {
-				Field field = Color.class.getField(fontObject
-						.getString("Color"));
+				Field field = Color.class.getField(fontObject.getString("Color"));
 				defaultFontColor = (Color) field.get(null);
 			} catch (Exception e) {
 			}
 			JSONObject buttonObject = o.getJSONObject("Buttons");
-			buttonSize = new Dimension(buttonObject.getInt("Width"),
-					buttonObject.getInt("Height"));
+			buttonSize = new Dimension(buttonObject.getInt("Width"), buttonObject.getInt("Height"));
 			JSONObject logoObject = o.getJSONObject("Logo");
 			logoDir = logoObject.getString("Dir");
-			logoSize = new Dimension(logoObject.getInt("Width"),
-					logoObject.getInt("Height"));
+			logoSize = new Dimension(logoObject.getInt("Width"), logoObject.getInt("Height"));
 			scalingExpression = o.getString("Scaling");
 			JSONObject visPanelObject = o.getJSONObject("VisualizerPanel");
-			visualizerPanelSize = new Dimension(visPanelObject.getInt("Width"),
-					visPanelObject.getInt("Height"));
-			innerVisualizerPanelSize = new Dimension(
-					visPanelObject.getInt("InnerWidth"),
+			visualizerPanelSize = new Dimension(visPanelObject.getInt("Width"), visPanelObject.getInt("Height"));
+			innerVisualizerPanelSize = new Dimension(visPanelObject.getInt("InnerWidth"),
 					visPanelObject.getInt("InnerHeight"));
 		} else {
 			// use default config values as defaults
@@ -289,12 +287,9 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 			buttonSize = MainDisplay.DefaultConfig.getButtonSize();
 			logoDir = MainDisplay.DefaultConfig.getLogoDir();
 			logoSize = MainDisplay.DefaultConfig.getLogoSize();
-			scalingExpression = MainDisplay.DefaultConfig
-					.getScalingExpression();
-			visualizerPanelSize = MainDisplay.DefaultConfig
-					.getVisualizerPanelSize();
-			innerVisualizerPanelSize = MainDisplay.DefaultConfig
-					.getInnerVisualizerPanelSize();
+			scalingExpression = MainDisplay.DefaultConfig.getScalingExpression();
+			visualizerPanelSize = MainDisplay.DefaultConfig.getVisualizerPanelSize();
+			innerVisualizerPanelSize = MainDisplay.DefaultConfig.getInnerVisualizerPanelSize();
 		}
 
 		// overwrite default values with parsed values
@@ -374,8 +369,7 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 			} catch (Exception e) {
 			}
 			try {
-				Field field = Color.class.getField(fontObject
-						.getString("Color"));
+				Field field = Color.class.getField(fontObject.getString("Color"));
 				defaultFontColor = (Color) field.get(null);
 			} catch (Exception e) {
 			}
@@ -389,8 +383,7 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 
 		try {
 			JSONObject buttonObject = o.getJSONObject("Buttons");
-			buttonSize = new Dimension(buttonObject.getInt("Width"),
-					buttonObject.getInt("Height"));
+			buttonSize = new Dimension(buttonObject.getInt("Width"), buttonObject.getInt("Height"));
 		} catch (Exception e) {
 		}
 
@@ -401,8 +394,7 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 			} catch (Exception e) {
 			}
 			try {
-				logoSize = new Dimension(logoObject.getInt("Width"),
-						logoObject.getInt("Height"));
+				logoSize = new Dimension(logoObject.getInt("Width"), logoObject.getInt("Height"));
 			} catch (Exception e) {
 			}
 		} catch (Exception e) {
@@ -411,14 +403,11 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 		try {
 			JSONObject visPanelObject = o.getJSONObject("VisualizerPanel");
 			try {
-				visualizerPanelSize = new Dimension(
-						visPanelObject.getInt("Width"),
-						visPanelObject.getInt("Height"));
+				visualizerPanelSize = new Dimension(visPanelObject.getInt("Width"), visPanelObject.getInt("Height"));
 			} catch (Exception e) {
 			}
 			try {
-				innerVisualizerPanelSize = new Dimension(
-						visPanelObject.getInt("InnerWidth"),
+				innerVisualizerPanelSize = new Dimension(visPanelObject.getInt("InnerWidth"),
 						visPanelObject.getInt("InnerHeight"));
 			} catch (Exception e) {
 			}
@@ -427,8 +416,7 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 
 		try {
 			statsDisplayConfig = StatsDisplayConfig
-					.creatStatsDisplayConfigFromJSONObject(o
-							.getJSONObject("StatsDisplayConfig"));
+					.creatStatsDisplayConfigFromJSONObject(o.getJSONObject("StatsDisplayConfig"));
 		} catch (Exception e) {
 		}
 
@@ -439,9 +427,8 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 
 			for (String logDis : JSONObject.getNames(mvo)) {
 				try {
-					logDisplayConfigsArray.add(LogDisplayConfig
-							.createLogDisplayConfigFromJSONObject(mvo
-									.getJSONObject(logDis)));
+					logDisplayConfigsArray
+							.add(LogDisplayConfig.createLogDisplayConfigFromJSONObject(mvo.getJSONObject(logDis)));
 				} catch (Exception e) {
 				}
 			}
@@ -459,15 +446,14 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 			for (String metricVis : JSONObject.getNames(mvo)) {
 				try {
 					metricVisualizerConfigsArray.add(MetricVisualizerConfig
-							.createMetricVisualizerConfigFromJSONObject(mvo
-									.getJSONObject(metricVis)));
+							.createMetricVisualizerConfigFromJSONObject(mvo.getJSONObject(metricVis)));
 				} catch (Exception e) {
+					e.printStackTrace();
 				}
 			}
 		} catch (Exception e) {
 		}
-		metricVisualizerConfigs = new MetricVisualizerConfig[metricVisualizerConfigsArray
-				.size()];
+		metricVisualizerConfigs = new MetricVisualizerConfig[metricVisualizerConfigsArray.size()];
 		for (int i = 0; i < metricVisualizerConfigsArray.size(); i++) {
 			metricVisualizerConfigs[i] = metricVisualizerConfigsArray.get(i);
 		}
@@ -478,28 +464,42 @@ public static MainDisplayConfig createMainDisplayConfigFromJSONObject(
 			JSONObject mvo = o.getJSONObject("MultiScalarVisualizerConfigs");
 			for (String multiScalarVis : JSONObject.getNames(mvo)) {
 				try {
-					multiScalarVisualizerConfigsArray
-							.add(MultiScalarVisualizerConfig
-									.createMultiScalarVisualizerConfigFromJSONObject(mvo
-											.getJSONObject(multiScalarVis)));
+					multiScalarVisualizerConfigsArray.add(MultiScalarVisualizerConfig
+							.createMultiScalarVisualizerConfigFromJSONObject(mvo.getJSONObject(multiScalarVis)));
 				} catch (Exception e) {
+					e.printStackTrace();
 				}
 			}
 		} catch (Exception e) {
 		}
-		multiScalarVisualizerConfigs = new MultiScalarVisualizerConfig[multiScalarVisualizerConfigsArray
-				.size()];
+		multiScalarVisualizerConfigs = new MultiScalarVisualizerConfig[multiScalarVisualizerConfigsArray.size()];
 		for (int i = 0; i < multiScalarVisualizerConfigsArray.size(); i++) {
-			multiScalarVisualizerConfigs[i] = multiScalarVisualizerConfigsArray
-					.get(i);
+			multiScalarVisualizerConfigs[i] = multiScalarVisualizerConfigsArray.get(i);
+		}
+
+		// gather label visualizer configs
+		ArrayList<LabelVisualizerConfig> labelVisualizerConfigsArray = new ArrayList<LabelVisualizerConfig>();
+		try {
+			JSONObject mvo = o.getJSONObject("LabelVisualizerConfigs");
+			for (String labelVis : JSONObject.getNames(mvo)) {
+				try {
+					labelVisualizerConfigsArray.add(LabelVisualizerConfig
+							.createLabelVisualizerConfigFromJSONObject(mvo.getJSONObject(labelVis)));
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		} catch (Exception e) {
+		}
+		labelVisualizerConfigs = new LabelVisualizerConfig[labelVisualizerConfigsArray.size()];
+		for (int i = 0; i < labelVisualizerConfigsArray.size(); i++) {
+			labelVisualizerConfigs[i] = labelVisualizerConfigsArray.get(i);
 		}
 
-		return new MainDisplayConfig(name, size, liveDisplayMode, fullscreen,
-				zipMode, defaultDir, defaultFont, defaultFontColor, buttonSize,
-				logoDir, logoSize, scalingExpression, visualizerPanelSize,
-				innerVisualizerPanelSize, statsDisplayConfig,
-				logDisplayConfigs, metricVisualizerConfigs,
-				multiScalarVisualizerConfigs);
+		return new MainDisplayConfig(name, size, liveDisplayMode, fullscreen, zipMode, defaultDir, defaultFont,
+				defaultFontColor, buttonSize, logoDir, logoSize, scalingExpression, visualizerPanelSize,
+				innerVisualizerPanelSize, statsDisplayConfig, logDisplayConfigs, metricVisualizerConfigs,
+				multiScalarVisualizerConfigs, labelVisualizerConfigs);
 	}
 
 	/**
@@ -524,8 +524,7 @@ public static MainDisplayConfig readConfig(String path) {
 			}
 		} else {
 			if (IOUtils.isRunFromJar()) {
-				Log.info("'" + path
-						+ "-> ' not found. Attempting to read from .jar");
+				Log.info("'" + path + "-> ' not found. Attempting to read from .jar");
 				try {
 					jar = IOUtils.getExecutionJarFile();
 					is = IOUtils.getInputStreamFromJar(jar, path, true);
@@ -541,8 +540,7 @@ public static MainDisplayConfig readConfig(String path) {
 			JSONTokener tk = new JSONTokener(is);
 			JSONObject jsonConfig = new JSONObject(tk);
 			config = MainDisplayConfig
-					.createMainDisplayConfigFromJSONObject(jsonConfig
-							.getJSONObject("MainDisplayConfig"));
+					.createMainDisplayConfigFromJSONObject(jsonConfig.getJSONObject("MainDisplayConfig"));
 
 			try {
 				is.close();
diff --git a/src/dna/visualization/config/components/MenuBarConfig.java b/src/dna/visualization/config/components/MenuBarConfig.java
index d12b7dda..a34b7118 100644
--- a/src/dna/visualization/config/components/MenuBarConfig.java
+++ b/src/dna/visualization/config/components/MenuBarConfig.java
@@ -11,29 +11,36 @@
 public class MenuBarConfig {
 
 	// constructor
-	public MenuBarConfig(Dimension size, Font coordsFont,
-			Color coordsFontColor, boolean addCoordsPanel,
-			boolean addIntervalPanel, boolean addXOptionsPanel,
+	public MenuBarConfig(boolean visible, Dimension size, Font coordsFont, Color coordsFontColor,
+			boolean addCoordsPanel, boolean addIntervalPanel, boolean x1AxisConnected, boolean addXOptionsPanel,
 			boolean addYOptionsPanel) {
+		this.visible = visible;
 		this.size = size;
 		this.coordsFont = coordsFont;
 		this.coordsFontColor = coordsFontColor;
 		this.addCoordsPanel = addCoordsPanel;
 		this.addIntervalPanel = addIntervalPanel;
+		this.x1AxisConnected = x1AxisConnected;
 		this.addXOptionsPanel = addXOptionsPanel;
 		this.addYOptionsPanel = addYOptionsPanel;
 	}
 
 	// variables
+	private boolean visible;
 	private Dimension size;
 	private Font coordsFont;
 	private Color coordsFontColor;
 	private boolean addCoordsPanel;
 	private boolean addIntervalPanel;
+	private boolean x1AxisConnected;
 	private boolean addXOptionsPanel;
 	private boolean addYOptionsPanel;
 
 	// get methods
+	public boolean isVisible() {
+		return this.visible;
+	}
+
 	public Dimension getSize() {
 		return this.size;
 	}
@@ -54,6 +61,10 @@ public boolean isAddIntervalPanel() {
 		return this.addIntervalPanel;
 	}
 
+	public boolean isX1AxisConnected() {
+		return this.x1AxisConnected;
+	}
+
 	public boolean isAddXOptionsPanel() {
 		return this.addXOptionsPanel;
 	}
@@ -69,20 +80,24 @@ public void setSize(Dimension size) {
 	/** creates a menubar config object from a given json object **/
 	public static MenuBarConfig createMenuBarConfigFromJSONObject(JSONObject o) {
 		// init
+		boolean visible;
 		Dimension size;
 		Font coordsFont;
 		Color coordsFontColor;
 		boolean addCoordsPanel;
 		boolean addIntervalPanel;
+		boolean x1AxisConnected;
 		boolean addXOptionsPanel;
 		boolean addYOptionsPanel;
 
 		// set default values
 		if (MainDisplay.DefaultConfig == null) {
 			// if the defaultconfig is not set, read default values
+			visible = o.getBoolean("visible");
 			size = new Dimension(o.getInt("Width"), o.getInt("Height"));
 			addCoordsPanel = o.getBoolean("showCoordsPanel");
 			addIntervalPanel = o.getBoolean("showIntervalPanel");
+			x1AxisConnected = true;
 			addXOptionsPanel = o.getBoolean("showXOptionsPanel");
 			addYOptionsPanel = o.getBoolean("showYOptionsPanel");
 			JSONObject fontObject = o.getJSONObject("CoordsFont");
@@ -107,38 +122,37 @@ public static MenuBarConfig createMenuBarConfigFromJSONObject(JSONObject o) {
 			coordsFont = new Font(tempName, style, tempSize);
 			coordsFontColor = Color.BLACK;
 			try {
-				Field field = Color.class.getField(fontObject
-						.getString("Color"));
+				Field field = Color.class.getField(fontObject.getString("Color"));
 				coordsFontColor = (Color) field.get(null);
 			} catch (Exception e) {
 			}
-			return new MenuBarConfig(size, coordsFont, coordsFontColor,
-					addCoordsPanel, addIntervalPanel, addXOptionsPanel,
-					addYOptionsPanel);
+			return new MenuBarConfig(visible, size, coordsFont, coordsFontColor, addCoordsPanel, addIntervalPanel,
+					x1AxisConnected, addXOptionsPanel, addYOptionsPanel);
 		} else {
 			// use default config values as defaults
-			size = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0]
-					.getMenuBarConfig().getSize();
-			addCoordsPanel = MainDisplay.DefaultConfig
-					.getMetricVisualizerConfigs()[0].getMenuBarConfig()
+			size = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig().getSize();
+			visible = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig().isVisible();
+			addCoordsPanel = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig()
 					.isAddCoordsPanel();
-			addIntervalPanel = MainDisplay.DefaultConfig
-					.getMetricVisualizerConfigs()[0].getMenuBarConfig()
+			addIntervalPanel = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig()
 					.isAddIntervalPanel();
-			addXOptionsPanel = MainDisplay.DefaultConfig
-					.getMetricVisualizerConfigs()[0].getMenuBarConfig()
+			x1AxisConnected = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig()
+					.isX1AxisConnected();
+			addXOptionsPanel = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig()
 					.isAddXOptionsPanel();
-			addYOptionsPanel = MainDisplay.DefaultConfig
-					.getMetricVisualizerConfigs()[0].getMenuBarConfig()
+			addYOptionsPanel = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig()
 					.isAddYOptionsPanel();
-			coordsFont = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0]
-					.getMenuBarConfig().getCoordsFont();
-			coordsFontColor = MainDisplay.DefaultConfig
-					.getMetricVisualizerConfigs()[0].getMenuBarConfig()
+			coordsFont = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig().getCoordsFont();
+			coordsFontColor = MainDisplay.DefaultConfig.getMetricVisualizerConfigs()[0].getMenuBarConfig()
 					.getCoordsFontColor();
 		}
 
 		// overwrite default values with parsed values
+		try {
+			visible = o.getBoolean("visible");
+		} catch (Exception e) {
+		}
+
 		try {
 			size = new Dimension(o.getInt("Width"), o.getInt("Height"));
 		} catch (Exception e) {
@@ -187,16 +201,14 @@ public static MenuBarConfig createMenuBarConfigFromJSONObject(JSONObject o) {
 			coordsFont = new Font(tempName, style, tempSize);
 			coordsFontColor = Color.BLACK;
 			try {
-				Field field = Color.class.getField(fontObject
-						.getString("Color"));
+				Field field = Color.class.getField(fontObject.getString("Color"));
 				coordsFontColor = (Color) field.get(null);
 			} catch (Exception e) {
 			}
 		} catch (Exception e) {
 		}
 
-		return new MenuBarConfig(size, coordsFont, coordsFontColor,
-				addCoordsPanel, addIntervalPanel, addXOptionsPanel,
-				addYOptionsPanel);
+		return new MenuBarConfig(visible, size, coordsFont, coordsFontColor, addCoordsPanel, addIntervalPanel,
+				x1AxisConnected, addXOptionsPanel, addYOptionsPanel);
 	}
 }
diff --git a/src/dna/visualization/graph/GraphPanel.java b/src/dna/visualization/graph/GraphPanel.java
index 1eabb6ae..6f0d9ad9 100644
--- a/src/dna/visualization/graph/GraphPanel.java
+++ b/src/dna/visualization/graph/GraphPanel.java
@@ -1121,8 +1121,8 @@ public void removeEdge(dna.graph.edges.Edge e) {
 		int n2 = e.getN2Index();
 
 		// remove edge
-		Edge edge = this.graph.removeEdge(this.graph.getNode("" + n1)
-				.getEdgeBetween("" + n2));
+		Edge edge = this.graph.getNode("" + n1).getEdgeBetween("" + n2);
+		this.graph.removeEdge(edge);
 
 		// apply style rules
 		Node node1 = this.graph.getNode("" + n1);
diff --git a/src/dna/visualization/graph/GraphVisualization.java b/src/dna/visualization/graph/GraphVisualization.java
index 35b12f57..0aefd381 100644
--- a/src/dna/visualization/graph/GraphVisualization.java
+++ b/src/dna/visualization/graph/GraphVisualization.java
@@ -26,7 +26,9 @@
 import dna.visualization.config.graph.GraphPanelConfig;
 import dna.visualization.graph.GraphPanel.PositionMode;
 
-/** The GraphVisualization class offers methods to visualize graphs used in DNA. **/
+/**
+ * The GraphVisualization class offers methods to visualize graphs used in DNA.
+ **/
 public class GraphVisualization {
 	// statics
 	public static final String positionKey = "xyz";
@@ -39,6 +41,7 @@ public class GraphVisualization {
 	public static final String colorKey = "dna.color";
 	public static final String sizeKey = "dna.size";
 	public static final String shapeKey = "dna.shape";
+	public static final String styleLockKey = "dna.style.lock";
 	public static final String styleKey = "ui.style";
 	public static final String updateKey = "dna.update";
 	public static final String zKey = "dna.z";
@@ -58,8 +61,7 @@ public class GraphVisualization {
 	public static void init(Graph g) {
 		if (!init) {
 			// init sophisticated renderer
-			System.setProperty("org.graphstream.ui.renderer",
-					"org.graphstream.ui.j2dviewer.J2DGraphRenderer");
+			System.setProperty("org.graphstream.ui.renderer", "org.graphstream.ui.j2dviewer.J2DGraphRenderer");
 			init = true;
 		}
 
@@ -78,17 +80,12 @@ public static void init(Graph g) {
 
 		// check nodeweighttypes for position modes
 		PositionMode mode = PositionMode.auto;
-		Class<? extends Weight> nwt = g.getGraphDatastructures()
-				.getNodeWeightType();
-		if (nwt != null
-				&& (nwt.equals(Int2dWeight.class)
-						|| nwt.equals(Long2dWeight.class) || nwt
-							.equals(Double2dWeight.class)))
+		Class<? extends Weight> nwt = g.getGraphDatastructures().getNodeWeightType();
+		if (nwt != null && (nwt.equals(Int2dWeight.class) || nwt.equals(Long2dWeight.class)
+				|| nwt.equals(Double2dWeight.class)))
 			mode = PositionMode.twoDimension;
-		if (nwt != null
-				&& (nwt.equals(Int3dWeight.class)
-						|| nwt.equals(Long3dWeight.class) || nwt
-							.equals(Double3dWeight.class)))
+		if (nwt != null && (nwt.equals(Int3dWeight.class) || nwt.equals(Long3dWeight.class)
+				|| nwt.equals(Double3dWeight.class)))
 			mode = PositionMode.threeDimension;
 
 		// main frame
@@ -105,8 +102,7 @@ public static void init(Graph g) {
 			cfg = GraphPanelConfig.defaultGraphPanelConfig;
 
 		// init graph panel
-		GraphPanel panel = new GraphPanel(mainFrame, graph, name, name, mode,
-				cfg);
+		GraphPanel panel = new GraphPanel(mainFrame, graph, name, name, mode, cfg);
 
 		// rendering options
 		if (cfg.isRenderHQ())
@@ -123,8 +119,7 @@ public static void init(Graph g) {
 		mainFrame.setLocationRelativeTo(null);
 
 		if (cfg.isFullscreen()) {
-			mainFrame.setExtendedState(mainFrame.getExtendedState()
-					| JFrame.MAXIMIZED_BOTH);
+			mainFrame.setExtendedState(mainFrame.getExtendedState() | JFrame.MAXIMIZED_BOTH);
 		}
 
 		// set visible
diff --git a/src/dna/visualization/graph/rules/GraphStyleUtils.java b/src/dna/visualization/graph/rules/GraphStyleUtils.java
index 66d6b1d2..1a9ba162 100644
--- a/src/dna/visualization/graph/rules/GraphStyleUtils.java
+++ b/src/dna/visualization/graph/rules/GraphStyleUtils.java
@@ -60,8 +60,7 @@ public enum ElementShape {
 
 	/** Sets a shape to an element. **/
 	public static void setShape(Element e, ElementShape shape) {
-		e.setAttribute(GraphVisualization.shapeKey,
-				GraphStyleUtils.getStringFromShape(shape));
+		e.setAttribute(GraphVisualization.shapeKey, GraphStyleUtils.getStringFromShape(shape));
 	}
 
 	/** Returns the shape of an element. **/
@@ -97,27 +96,30 @@ public static String getStringFromShape(ElementShape shape) {
 
 	/** Updates the elements style. **/
 	public static void updateStyle(Element e) {
-		String style = "";
-		// add shape
-		if (e.hasAttribute(GraphVisualization.shapeKey))
-			style += "shape: " + e.getAttribute(GraphVisualization.shapeKey)
-					+ ";";
-
-		// add color
-		if (e.hasAttribute(GraphVisualization.colorKey)) {
-			Color c = e.getAttribute(GraphVisualization.colorKey);
-			style += "fill-color: rgb(" + c.getRed() + "," + c.getGreen() + ","
-					+ c.getBlue() + ");";
-		}
+		if (GraphStyleUtils.isStyleLocked(e)) {
+			// do nothing: style locked
+		} else {
+
+			String style = "";
+			// add shape
+			if (e.hasAttribute(GraphVisualization.shapeKey))
+				style += "shape: " + e.getAttribute(GraphVisualization.shapeKey) + ";";
+
+			// add color
+			if (e.hasAttribute(GraphVisualization.colorKey)) {
+				Color c = e.getAttribute(GraphVisualization.colorKey);
+				style += "fill-color: rgb(" + c.getRed() + "," + c.getGreen() + "," + c.getBlue() + ");";
+			}
 
-		// calc size
-		double size = (double) e.getAttribute(GraphVisualization.sizeKey);
-		size = size < 0 ? 0 : size;
+			// calc size
+			double size = (double) e.getAttribute(GraphVisualization.sizeKey);
+			size = size < 0 ? 0 : size;
 
-		style += "size: " + size + "px;";
+			style += "size: " + size + "px;";
 
-		// set style
-		e.setAttribute(GraphVisualization.styleKey, style);
+			// set style
+			e.setAttribute(GraphVisualization.styleKey, style);
+		}
 	}
 
 	/** Sets the label of the element. **/
@@ -137,4 +139,31 @@ public static void appendToLabel(Element e, String text) {
 		else
 			setLabel(e, text);
 	}
+
+	/**
+	 * Locks or unlocks the style-lock of an element, preventing automated
+	 * style-generation. Note: Element counts as locked when the styleLockKey is
+	 * present. The value assigned to the key is not regarded.
+	 **/
+	public static void setStyleLock(Element e, boolean locked) {
+		if (locked) {
+			e.setAttribute(GraphVisualization.styleLockKey, locked);
+		} else {
+			if (e.hasAttribute(GraphVisualization.styleLockKey))
+				e.removeAttribute(GraphVisualization.styleLockKey);
+		}
+	}
+
+	/**
+	 * Returns whether the element is locked or not. Note: Element counts as
+	 * locked when the styleLockKey is present. The value assigned to the key is
+	 * not regarded.
+	 **/
+	public static boolean isStyleLocked(Element e) {
+		if (e.hasAttribute(GraphVisualization.styleLockKey))
+			return true;
+		else
+			return false;
+
+	}
 }
diff --git a/src/dna/visualization/graph/rules/nodes/NetworkNodeStyles.java b/src/dna/visualization/graph/rules/nodes/NetworkNodeStyles.java
new file mode 100644
index 00000000..70d2f9fd
--- /dev/null
+++ b/src/dna/visualization/graph/rules/nodes/NetworkNodeStyles.java
@@ -0,0 +1,106 @@
+package dna.visualization.graph.rules.nodes;
+
+import java.awt.Color;
+
+import org.graphstream.graph.Node;
+
+import dna.graph.generators.network.NetflowBatch;
+import dna.graph.weights.TypedWeight;
+import dna.graph.weights.Weight;
+import dna.util.parameters.Parameter;
+import dna.visualization.graph.GraphVisualization;
+import dna.visualization.graph.rules.GraphStyleRule;
+import dna.visualization.graph.rules.GraphStyleUtils;
+import dna.visualization.graph.rules.GraphStyleUtils.ElementShape;
+
+/**
+ * This rule shape and colors nodes according to their NetworkNodeWeight.
+ * 
+ * @author Rwilmes
+ * 
+ */
+public class NetworkNodeStyles extends GraphStyleRule {
+
+	protected String name;
+
+	protected ElementShape defaultShape;
+	protected ElementShape hostShape;
+	protected ElementShape portShape;
+
+	protected Color hostColor;
+	protected Color portColor;
+
+	public NetworkNodeStyles(String name, Parameter[] params) {
+		this(name, ElementShape.circle, ElementShape.rounded_box, ElementShape.circle, new Color(0, 255, 0),
+				new Color(255, 0, 0));
+	}
+
+	public NetworkNodeStyles(String name, ElementShape defaultShape, ElementShape hostShape, ElementShape portShape,
+			Color hostColor, Color portColor) {
+		System.out.println("INIT!");
+		this.name = name;
+		this.defaultShape = defaultShape;
+		this.hostShape = hostShape;
+		this.portShape = portShape;
+		this.hostColor = hostColor;
+		this.portColor = portColor;
+	}
+
+	@Override
+	public void onNodeAddition(Node n, Weight weight) {
+		GraphStyleUtils.setStyleLock(n, true);
+
+		// check type and handle accordingly
+		if (weight instanceof TypedWeight) {
+			TypedWeight w = (TypedWeight) weight;
+			if (w.getType().equals("HOST"))
+				handleHostNode(n);
+			else if (w.getType().equals("PORT"))
+				handlePortNode(n);
+			else
+				GraphStyleUtils.setShape(n, defaultShape);
+		}
+	}
+
+	public void handleHostNode(Node n) {
+		GraphStyleUtils.setLabel(n, getCurrentNetflowMapping(n));
+		n.setAttribute(GraphVisualization.styleKey, host_default_style);
+	}
+
+	public void handlePortNode(Node n) {
+		GraphStyleUtils.setLabel(n, getCurrentNetflowMapping(n));
+		n.setAttribute(GraphVisualization.styleKey, port_style);
+	}
+
+	// STATIC STYLE DEFINITIONS
+	public static final String test = "fill-color: rgb(0, 100, 255);";
+
+	public static final String default_style = "" + "shape:rounded-box; " + "size:100px,30px; " + "fill-mode:plain; "
+			+ "fill-color: rgba(220,220,220, 150); " + "stroke-mode:dots; " + "stroke-color: rgb(40, 40, 40); "
+			+ "text-alignment:center;";
+
+	public static final String host_default_style = "" + "shape:rounded-box; " + "size:100px,30px; "
+			+ "fill-mode:plain; " + "fill-color: rgb(220,220,220); " + "stroke-mode:dots; "
+			+ "stroke-color: rgb(40, 40, 40); " + "text-alignment:center;" + "text-size:12;";
+
+	public static final String port_style = "" + "shape:circle; " + "size:30px; " + "fill-mode:plain; "
+			+ "fill-color: rgb(255, 220, 220); " + "stroke-mode:dots; " + "stroke-color: rgb(40, 40, 40); "
+			+ "text-alignment:center;" + "text-size:12;";
+
+	// STATIC NETFLOW BATCH GENERATOR TO RETRIEVE MAPPING
+	public static NetflowBatch netflowBatchGenerator;
+
+	public static String getCurrentNetflowMapping(Node n) {
+		if (netflowBatchGenerator != null) {
+			return netflowBatchGenerator.getKey(Integer.parseInt(n.getId()));
+		} else {
+			return "no netflowbatch";
+		}
+	}
+
+	@Override
+	public String toString() {
+		return "NetworkPresentation-Rule: '" + this.name + "'";
+	}
+
+}
\ No newline at end of file