Merge branch 'development' into sample-roasting

config/Windows/navigation.xml

             if(typeof(window.loggingWindow) == "undefined")
             {
                 window.loggingWindow = createWindow("basicWindow");
-                window.loggingWindow.windowTitle = "Typica";
+                window.loggingWindow.windowTitle = "Typica [*]";
 				window.loggingWindow.navigationWindow = window;
             }
             else

config/Windows/newbatch.xml

     <menu name="Batch">
         <item id="new" shortcut="Ctrl+N">New Batch…</item>
     </menu>
+	<layout type="horizontal">
     <layout type="vertical">
         <layout type="horizontal">
 			<label>Machine:</label>
             <button name="Save log as target profile" type="check" id="target" />
         </layout>
     </layout>
+	<layout type="vertical">
+		<label>Connected Scales</label>
+		<layout type="vertical" id="scales" />
+		<stretch />
+	</layout>
+	</layout>
     <program>
         <![CDATA[
 			var unitBox = findChildObject(this, 'unit');
             var roasted = findChildObject(this, 'roasted');
             var roastwt = findChildObject(this, 'roast');
             roastwt.maximumWidth = 80;
+			var scalesLayout = findChildObject(this, 'scales');
+			scalesLayout.spacing = 10;
+			if(navigationwindow.loggingWindow.scales.length > 0) {
+				for(var i = 0; i < navigationwindow.loggingWindow.scales.length; i++) {
+					var scale = navigationwindow.loggingWindow.scales[i];
+					var label = new DragLabel();
+					var weighButton = new QPushButton();
+					weighButton.text = "Weigh";
+					weighButton.clicked.connect(scale.weigh);
+					label.updateMeasurement = function(m, u) {
+						switch(unitBox.currentIndex) {
+							case 0:
+								this.text = Units.convertWeight(m, u, Units.Gram).toFixed(1);
+								break;
+							case 1:
+								this.text = Units.convertWeight(m, u, Units.Kilogram).toFixed(4);
+								break;
+							case 2:
+								this.text = Units.convertWeight(m, u, Units.Ounce).toFixed(3);
+								break;
+							case 3:
+								this.text = Units.convertWeight(m, u, Units.Pound).toFixed(4);
+								break;
+						}
+					};
+					scalesLayout.addWidget(label);
+					scalesLayout.addWidget(weighButton);
+					scale.newMeasurement.connect(function(m, u) {
+						label.updateMeasurement(m, u);
+					});
+					scale.weigh();
+					unitBox['currentIndexChanged(int)'].connect(scale.weigh);
+				}
+			}
 			model.dataChanged.connect(function() {
 				green.text = table.columnSum(1, 0);
 				table.resizeColumnToContents(0);

config/Windows/productionroaster.xml

 		var rateoffsets = new Array();
 		var ratezeros = new Array();
 		var channelType = new Array();
+		window.scales = new Array();
+		var channelVisibility = new Array();
 		var indicatorPanel = findChildObject(this, 'indicators');
 		var annotationPanel = findChildObject(this, 'controlpanel');
 		var log = findChildObject(this, 'log');
 											channelType.push("T");
 											columnNames.push(channelReference.columnname);
 											DAQChannels++;
-											var indicator = new TemperatureDisplay;
-											temperatureDisplays.push(indicator);
-											var decorator = new WidgetDecorator(indicator, configModel.data(channelIndex, 0), 2);
-											channel.newData.connect(indicator.setValue);
-											indicatorPanel.addWidget(decorator);
+											if(channelReference.hidden == "true") {
+												channelVisibility.push(false);
+											} else {
+												channelVisibility.push(true);
+												var indicator = new TemperatureDisplay;
+												temperatureDisplays.push(indicator);
+												var decorator = new WidgetDecorator(indicator, configModel.data(channelIndex, 0), 2);
+												channel.newData.connect(indicator.setValue);
+												indicatorPanel.addWidget(decorator);
+											}
 										}
 									}
 									switch(DAQChannels) {
 								channels.push(channel);
 								channelType.push("T");
 								columnNames.push(deviceReference.columnname);
-								var indicator = new TemperatureDisplay;
-								temperatureDisplays.push(indicator);
-								var decorator = new WidgetDecorator(indicator, configModel.data(deviceIndex, 0), 2);
-								channel.newData.connect(indicator.setValue);
-								indicatorPanel.addWidget(decorator);
+								if(deviceReference.hidden == "true") {
+									channelVisibility.push(false);
+								} else {
+									channelVisibility.push(true);
+									var indicator = new TemperatureDisplay;
+									temperatureDisplays.push(indicator);
+									var decorator = new WidgetDecorator(indicator, configModel.data(deviceIndex, 0), 2);
+									channel.newData.connect(indicator.setValue);
+									indicatorPanel.addWidget(decorator);
+								}
 								device.start();
 								nidevices.push(device);
 							}
 							channel.newData.connect(calibrator.newMeasurement)
 							channels.push(calibrator);
 							columnNames.push(channelReference.column);
-							var decorator = new WidgetDecorator(indicator, configModel.data(channelIndex, 0), 2);
-							calibrator.newData.connect(indicator.setValue);
-							indicatorPanel.addWidget(decorator);
+							if(channelReference.hidden == "true") {
+								channelVisibility.push(false);
+							} else {
+								channelVisibility.push(true);
+								var decorator = new WidgetDecorator(indicator, configModel.data(channelIndex, 0), 2);
+								calibrator.newData.connect(indicator.setValue);
+								indicatorPanel.addWidget(decorator);
+							}
 						}
 						sampleRate /= configModel.rowCount(driverIndex);
 					}
 					channels.push(pvchannel);
 					channelType.push("T");
 					columnNames.push(driverReference.pvcolname);
-					var indicator = new TemperatureDisplay;
-					temperatureDisplays.push(indicator);
-					var decorator = new WidgetDecorator(indicator, configModel.data(driverIndex, 0) + " PV", 2);
-					pvchannel.newData.connect(indicator.setValue);
-					indicatorPanel.addWidget(decorator);
+					if(driverReference.pvhidden == "true") {
+						channelVisibility.push(false);
+					} else {
+						channelVisibility.push(true);
+						var indicator = new TemperatureDisplay;
+						temperatureDisplays.push(indicator);
+						var decorator = new WidgetDecorator(indicator, configModel.data(driverIndex, 0) + " PV", 2);
+						pvchannel.newData.connect(indicator.setValue);
+						indicatorPanel.addWidget(decorator);
+					}
 					if(driverReference.sVEnabled == "true")
 					{
 						var svchannel = device.sVChannel();
 						channels.push(svchannel);
 						channelType.push("C");
 						columnNames.push(driverReference.svcolname);
-						var indicator = new TemperatureDisplay;
-						temperatureDisplays.push(indicator);
-						var decorator = new WidgetDecorator(indicator, configModel.data(driverIndex, 0) + " SV", 2);
-						svchannel.newData.connect(indicator.setValue);
-						indicatorPanel.addWidget(decorator);
+						if(driverReference.svhidden == "true") {
+							channelVisibility.push(false);
+						} else {
+							channelVisibility.push(true);
+							var indicator = new TemperatureDisplay;
+							temperatureDisplays.push(indicator);
+							var decorator = new WidgetDecorator(indicator, configModel.data(driverIndex, 0) + " SV", 2);
+							svchannel.newData.connect(indicator.setValue);
+							indicatorPanel.addWidget(decorator);
+						}
 					}
 					if(driverReference.sVWritable == "true")
 					{
 					annotationPanel.addWidget(button);
 					tabControls.push(button);
 				}
+				else if(driverReference.driver == "valueannotation")
+				{
+					var checker = new ValueAnnotation;
+					var valuesSetting = driverReference.measuredValues;
+					var notesSetting = driverReference.annotations;
+					var valuesList = valuesSetting.slice(2, valuesSetting.length-2).split(",");
+					var notesList = notesSetting.slice(2, notesSetting.length-2).split(",");
+					if(valuesList.length > 1 && notesList.length == valuesList.length) {
+						for(var j = 0; j < valuesList.length; j++) {
+							checker.setAnnotation(Number(valuesList[j]), notesList[j]);
+						}
+					}
+					if(driverReference.emitOnStart == "true") {
+						start.clicked.connect(checker.annotate);
+					}
+					var colname = driverReference.source;
+					for(var j = 0; j < columnNames.length; j++) {
+						if(columnNames[j] == colname) {
+							channels[j].newData.connect(checker.newMeasurement);
+							break;
+						}
+					}
+					annotationButtons.push(checker);
+				}
 				else if(driverReference.driver == "reconfigurablebutton")
 				{
 					var button = new AnnotationButton(driverReference.buttontext);
 								channels[j].newData.connect(calibrator.newMeasurement);
 								calibrator.newData.connect(indicator.setValue);
 								channels.push(calibrator);
+								// Channel hiding is not yet configurable for this.
+								// I'm not sure if there's any need to allow this
+								// to be hidden at present.
+								channelVisibility.push(true);
 								channelType.push(channelType[j]);
 								columnNames.push(driverReference.destination);
 								indicatorPanel.addWidget(decorator);
 							rate.newData.connect(indicator.setValue);
 							temperatureDisplays.push(indicator);
 							channels.push(rate);
+							// This cannot at present be configured to be
+							// hidden.
+							channelVisibility.push(true);
 							channelType.push("T");
 							columnNames.push(configModel.data(driverIndex, 0));
 						}
 					}
 				}
+				else if(driverReference.driver == "scale")
+				{
+					var scale = new SerialScale(driverReference.port);
+					scale.setDataBits(8);
+					scale.setBaudRate(driverReference.baudrate);
+					scale.setParity(driverReference.parity);
+					scale.setStopBits(driverReference.stopbits);
+					scale.setFlowControl(driverReference.flowcontrol);
+					scale.open(3);
+					window.scales.push(scale);
+				}
 			}
 		}
 		for(var i = 1; i < tabControls.length; i++)
 			setTabOrder(tabControls[i-1], tabControls[i]);
 		}
 		log.setHeaderData(0, "Time");
+		var channelSkip = 0;
 		for(var i = 0; i < columnNames.length; i++) {
-			log.setHeaderData(i + 1, columnNames[i]);
-		}
-		log.setHeaderData(columnNames.length + 1, "Note");
-		for(var i = 0; i < channels.length; i++) {
-			log.addToCurrentColumnSet(i + 1);
+			if(channelVisibility[i]) {
+				log.setHeaderData(i + 1 - channelSkip, columnNames[i]);
+				log.addToCurrentColumnSet(i + 1 - channelSkip);
+			}
+			else {
+				channelSkip++;
+			}
 		}
+		log.setHeaderData(columnNames.length + 1 - channelSkip, "Note");
 		var timer = new TimerDisplay;
 		timer.displayFormat = "mm:ss";
 		timer.autoReset = true;
 		var offsets = new Array();
 		var zeroemitters = new Array();
 		var adapters = new Array();
+		channelSkip = 0;
 		for(var i = 0; i < channels.length; i++) {
-			var offset = new MeasurementTimeOffset(epoch);
-			offsets.push(offset);
-			channels[i].newData.connect(offset.newMeasurement);
-			var adapter = new MeasurementAdapter(i + 1);
-			adapters.push(adapter);
-			offset.measurement.connect(adapter.newMeasurement);
-			var emitter = new ZeroEmitter(i + 1);
-			zeroemitters.push(emitter);
-			channels[i].newData.connect(emitter.newMeasurement);
-			emitter.measurement.connect(log.newMeasurement);
-			emitter.measurement.connect(graph.newMeasurement);
+			if(channelVisibility[i]) {
+				var offset = new MeasurementTimeOffset(epoch);
+				offsets.push(offset);
+				channels[i].newData.connect(offset.newMeasurement);
+				var adapter = new MeasurementAdapter(i + 1 - channelSkip);
+				adapters.push(adapter);
+				offset.measurement.connect(adapter.newMeasurement);
+				var emitter = new ZeroEmitter(i + 1);
+				zeroemitters.push(emitter);
+				channels[i].newData.connect(emitter.newMeasurement);
+				emitter.measurement.connect(log.newMeasurement);
+				emitter.measurement.connect(graph.newMeasurement);
+			} else {
+				channelSkip++;
+			}
 		}
+		var offsetForChannel = function(c) {
+			var retval = -1;
+			for(var i = 0; i <= c; i++) {
+				if(channelVisibility[i]) {
+					retval++;
+				}
+			}
+			return retval;
+		};
         start.clicked.connect(function() {
 			start.enabled = false;
 			hasTranslated = false;
             }
 			if(translationChannel >= 0)
 			{
-				offsets[translationChannel].measurement.connect(currentDetector.newMeasurement);
+				offsets[offsetForChannel(translationChannel)].measurement.connect(currentDetector.newMeasurement);
 			}
 			if(typeof(externtrans) != 'undefined') {
 				externtrans.display(0);
 			{
 				annotationButtons[i].annotation.connect(log.newAnnotation);
 				annotationButtons[i].setTemperatureColumn(1);
-				annotationButtons[i].setAnnotationColumn(channels.length + 1);
+				annotationButtons[i].setAnnotationColumn(channels.length - channelSkip + 1);
 				annotationButtons[i].annotation.connect(function(note, tcol, ncol) {
 					for(var i = tcol; i < ncol; i++) {
 						log.newAnnotation(note, i, ncol);
         stop.annotation.connect(log.newAnnotation);
         stop.clicked.connect(timer.stopTimer);
 		stop.setTemperatureColumn(1);
-		stop.setAnnotationColumn(channels.length + 1);
+		stop.setAnnotationColumn(channels.length - channelSkip + 1);
 		QSettings.setValue("liveColumn", 1);
         var lc = 1;
         stop.clicked.connect(function() {
             }
 			if(translationChannel >= 0)
 			{
-				offsets[translationChannel].measurement.disconnect(currentDetector.newMeasurement);
+				offsets[offsetForChannel(translationChannel)].measurement.disconnect(currentDetector.newMeasurement);
 			}
 			start.enabled = true;
 			window.windowModified = false;
 				log.newAnnotation("End", 1, lc);
             }
         });
+		var columnName = function(c) {
+			var visibleColumns = 0;
+			for(var i = 0; i < channels.length; i++) {
+				if(channelVisibility[i]) {
+					visibleColumns++;
+				}
+				if(c == visibleColumns - 1) {
+					return columnNames[i];
+				}
+			}
+			return "";
+		};
 		window.postLoadColumnSetup = function(c) {
 			for(var i = 0; i < adapters.length; i++)
 			{
 				adapters[i].setColumn(c + i + 1);
 				zeroemitters[i].setColumn(c + i + 1);
-				log.setHeaderData(c + i + 1, columnNames[i]);
+				log.setHeaderData(c + i + 1, columnName(i));
 			}
-			log.setHeaderData(c + columnNames.length + 1, "Note");
+			log.setHeaderData(c + columnNames.length + 1 - channelSkip, "Note");
             stop.setTemperatureColumn(c + 1);
-			stop.setAnnotationColumn(c + columnNames.length + 1);
+			stop.setAnnotationColumn(c + columnNames.length + 1 - channelSkip);
 			for(var i = 0; i < annotationButtons.length; i++)
 			{
 				annotationButtons[i].setTemperatureColumn(c + 1);
-				annotationButtons[i].setAnnotationColumn(c + columnNames.length + 1);
+				annotationButtons[i].setAnnotationColumn(c + columnNames.length + 1 - channelSkip);
 			}
 			log.clearCurrentColumnSet();
-			for(var i = 0; i < channels.length; i++) {
+			for(var i = 0; i < channels.length - channelSkip; i++) {
 				log.addToCurrentColumnSet(c + i + 1);
 			}
 			window.firstTempColumn = c + 1;
-			window.annotationColumn = c + columnNames.length + 1;
+			window.annotationColumn = c + columnNames.length - channelSkip + 1;
 		}
 		var saveMenu = findChildObject(this, 'save');
         saveMenu.triggered.connect(function() {
                 var lc = Number(QSettings.value("liveColumn"));
                 var file = new QFile(filename);
                 log.clearOutputColumns();
-				for(var i = 0; i < columnNames.length; i++)
+				for(var i = 0; i < columnNames.length - channelSkip; i++)
 				{
 					if(channelType[i] == "T") {
 						log.addOutputTemperatureColumn(lc + i);
 						log.addOutputControlColumn(lc + i);
 					}
 				}
-				log.addOutputAnnotationColumn(lc + columnNames.length);
+				log.addOutputAnnotationColumn(lc + columnNames.length - channelSkip);
                 log.saveXML(file);
                 QSettings.setValue("script/lastDir", dir(filename));
             }
                 var lc = Number(QSettings.value("liveColumn"));
                 var file = new QFile(filename);
                 log.clearOutputColumns();
-				for(var i = 0; i < columnNames.length; i++)
+				for(var i = 0; i < columnNames.length - channelSkip; i++)
 				{
 					log.addOutputTemperatureColumn(lc + i);
 				}
-				log.addOutputAnnotationColumn(lc + columnNames.length);
+				log.addOutputAnnotationColumn(lc + columnNames.length - channelSkip);
                 log.saveCSV(file);
                 QSettings.setValue("script/lastDir", dir(filename));
             }

src/Typica.pro

     abouttypica.h \
     units.h \
     webview.h \
-    webelement.h
+    webelement.h \
+    scale.h \
+    draglabel.h
 SOURCES += typica.cpp \
     helpmenu.cpp \
     abouttypica.cpp \
     units.cpp \
     webview.cpp \
-    webelement.cpp
+    webelement.cpp \
+    scale.cpp \
+    draglabel.cpp
 
 RESOURCES += \
     resources.qrc

src/dataqsdk.w

 		void startCalibration();
 		void stopCalibration();
 		void resetCalibration();
+		void updateInput(Measurement measure);
+		void updateOutput(Measurement measure);
+		void updateHidden(bool hidden);
+	private:
+		QPushButton *startButton;
+		QPushButton *resetButton;
+		QPushButton *stopButton;
+		@<DATAQ SDK device settings@>@;
+		DataqSdkDevice *calibrationDevice;
+		LinearCalibrator *calibrator;
+		QLineEdit *currentMeasurement;
+		QLineEdit *minimumMeasurement;
+		QLineEdit *maximumMeasurement;
+		QLineEdit *averageMeasurement;
+		QLineEdit *currentMapped;
+		QLineEdit *minimumMapped;
+		QLineEdit *maximumMapped;
+		QLineEdit *averageMapped;
+		int rmCount;
+		int cmCount;
+		double rmin;
+		double rmax;
+		double rmean;
+		double cmin;
+		double cmax;
+		double cmean;
 };
 
+@ Private members that hold minimum and maximum aggregate data for channel
+calibration will be initialized to the maximum and minimum values available for
+the |double| type respectively. This guarantees that the first measurement will
+overwrite these values. This is done with |std::numeric_limits| so we require a
+header to be included to gain access to this.
+
+@<Header files to include@>=
+#include <limits>
+
 @ The constructor sets up the interface. Calibration settings line edits need
 to have numeric validators added.
 
 @<DataqSdkDeviceConfWidget implementation@>=
 DataqSdkChannelConfWidget::DataqSdkChannelConfWidget(DeviceTreeModel *model,
                                                      const QModelIndex &index)
-	: BasicDeviceConfigurationWidget(model, index)
+	: BasicDeviceConfigurationWidget(model, index),
+	startButton(new QPushButton(tr("Start"))),
+	resetButton(new QPushButton(tr("Reset"))),
+	stopButton(new QPushButton(tr("Stop"))),
+	calibrator(new LinearCalibrator),
+	currentMeasurement(new QLineEdit), minimumMeasurement(new QLineEdit),
+	maximumMeasurement(new QLineEdit), averageMeasurement(new QLineEdit),
+	currentMapped(new QLineEdit), minimumMapped(new QLineEdit),
+	maximumMapped(new QLineEdit), averageMapped(new QLineEdit),
+	rmCount(0), cmCount(0),
+	rmin(std::numeric_limits<double>::max()),
+	rmax(std::numeric_limits<double>::min()), rmean(0),
+	cmin(std::numeric_limits<double>::max()),
+	cmax(std::numeric_limits<double>::min()), cmean(0)
 {
+	@<Find DATAQ SDK device settings from parent node@>@;
+	resetButton->setEnabled(false);
+	stopButton->setEnabled(false);
+	connect(startButton, SIGNAL(clicked()), this, SLOT(startCalibration()));
+	connect(resetButton, SIGNAL(clicked()), this, SLOT(resetCalibration()));
+	connect(stopButton, SIGNAL(clicked()), this, SLOT(stopCalibration()));
 	QVBoxLayout *layout = new QVBoxLayout;
 	QFormLayout *topLayout = new QFormLayout;
 	QLineEdit *columnEdit = new QLineEdit;
 	QCheckBox *smoothingBox = new QCheckBox(tr("Enable smoothing"));
 	topLayout->addRow(smoothingBox);
 	layout->addLayout(topLayout);
+	QCheckBox *hideSeries = new QCheckBox(tr("Hide this channel"));
+	topLayout->addRow(hideSeries);
 	QLabel *calibrationLabel = new QLabel(tr("Calibration settings"));
 	layout->addWidget(calibrationLabel);
+	QHBoxLayout *calibrationLayout = new QHBoxLayout;
 	QFormLayout *calibrationControlsLayout = new QFormLayout;
 	QLineEdit *measuredLowerEdit = new QLineEdit;
 	measuredLowerEdit->setText("0");
 	QLineEdit *sensitivityEdit = new QLineEdit;
 	sensitivityEdit->setText("0");
 	calibrationControlsLayout->addRow(tr("Discrete interval skip"), sensitivityEdit);
-	layout->addLayout(calibrationControlsLayout);
-	
-	// Insert another panel to assist in determining proper calibration values.
-	
+	QVBoxLayout *calibrationTestLayout = new QVBoxLayout;
+	QHBoxLayout *deviceControlLayout = new QHBoxLayout;
+	deviceControlLayout->addWidget(startButton);
+	deviceControlLayout->addWidget(resetButton);
+	deviceControlLayout->addWidget(stopButton);
+	QFormLayout *indicatorLayout = new QFormLayout;	
+	currentMeasurement->setReadOnly(true);
+	minimumMeasurement->setReadOnly(true);
+	maximumMeasurement->setReadOnly(true);
+	averageMeasurement->setReadOnly(true);
+	currentMapped->setReadOnly(true);
+	minimumMapped->setReadOnly(true);
+	maximumMapped->setReadOnly(true);
+	averageMapped->setReadOnly(true);
+	indicatorLayout->addRow(tr("Measured Values"), new QWidget);
+	indicatorLayout->addRow(tr("Current"), currentMeasurement);
+	indicatorLayout->addRow(tr("Minimum"), minimumMeasurement);
+	indicatorLayout->addRow(tr("Maximum"), maximumMeasurement);
+	indicatorLayout->addRow(tr("Mean"), averageMeasurement);
+	indicatorLayout->addRow(tr("Mapped Values"), new QWidget);
+	indicatorLayout->addRow(tr("Current Mapped"), currentMapped);
+	indicatorLayout->addRow(tr("Minimum Mapped"), minimumMapped);
+	indicatorLayout->addRow(tr("Maximum Mapped"), maximumMapped);
+	indicatorLayout->addRow(tr("Mean Mapped"), averageMapped);
+	calibrationTestLayout->addLayout(deviceControlLayout);
+	calibrationTestLayout->addLayout(indicatorLayout);
+	calibrationLayout->addLayout(calibrationControlsLayout);
+	calibrationLayout->addLayout(calibrationTestLayout);
+	layout->addLayout(calibrationLayout);
 	@<Get device configuration data for current node@>@;
 	for(int i = 0; i < configData.size(); i++)
 	{
 		{
 			sensitivityEdit->setText(node.attribute("value"));
 		}
+		else if(node.attribute("name") == "hidden")
+		{
+			hideSeries->setChecked(node.attribute("value") == "true");
+		}
 	}
 	updateColumnName(columnEdit->text());
 	updateUnits(unitSelector->currentText());
 	updateMappedUpper(mappedUpperEdit->text());
 	updateClosedInterval(closedBox->isChecked());
 	updateSensitivity(sensitivityEdit->text());
+	updateHidden(hideSeries->isChecked());
 	connect(columnEdit, SIGNAL(textChanged(QString)),
 	        this, SLOT(updateColumnName(QString)));
 	connect(unitSelector, SIGNAL(currentIndexChanged(QString)),
 	        this, SLOT(updateClosedInterval(bool)));
 	connect(sensitivityEdit, SIGNAL(textChanged(QString)),
 	        this, SLOT(updateSensitivity(QString)));
+	connect(hideSeries, SIGNAL(toggled(bool)), this, SLOT(updateHidden(bool)));
 	setLayout(layout);
 }
 
 void DataqSdkChannelConfWidget::updateMeasuredLower(const QString &value)
 {
 	updateAttribute("calibrationMeasuredLower", value);
+	calibrator->setMeasuredLower(value.toDouble());
 }
 
 void DataqSdkChannelConfWidget::updateMeasuredUpper(const QString &value)
 {
 	updateAttribute("calibrationMeasuredUpper", value);
+	calibrator->setMeasuredUpper(value.toDouble());
 }
 
 void DataqSdkChannelConfWidget::updateMappedLower(const QString &value)
 {
 	updateAttribute("calibrationMappedLower", value);
+	calibrator->setMappedLower(value.toDouble());
 }
 
 void DataqSdkChannelConfWidget::updateMappedUpper(const QString &value)
 {
 	updateAttribute("calibrationMappedUpper", value);
+	calibrator->setMappedUpper(value.toDouble());
 }
 
 void DataqSdkChannelConfWidget::updateClosedInterval(bool closed)
 {
 	updateAttribute("calibrationClosedInterval", closed ? "true" : "false");
+	calibrator->setClosedRange(closed);
 }
 
 void DataqSdkChannelConfWidget::updateSmoothingEnabled(bool enabled)
 void DataqSdkChannelConfWidget::updateSensitivity(const QString &value)
 {
 	updateAttribute("calibrationSensitivity", value);
+	calibrator->setSensitivity(value.toDouble());
+}
+
+void DataqSdkChannelConfWidget::updateHidden(bool hidden)
+{
+	updateAttribute("hidden", hidden ? "true" : "false");
+}
+
+@ When calibrating a device, we must know certain information to open a
+connection to the appropriate hardware and know which channel we are interested
+in.
+
+@<DATAQ SDK device settings@>=
+bool autoSelect;
+QString deviceID;
+int channelOfInterest;
+
+@ This information is accessed through the reference element associated with
+the parent node of the current configuration and from the row number of the
+current node.
+
+@<Find DATAQ SDK device settings from parent node@>=
+QDomElement parentReference = model->referenceElement(model->data(index.parent(), Qt::UserRole).toString());
+QDomNodeList deviceConfigData = parentReference.elementsByTagName("attribute");
+QDomElement deviceNode;
+QString configPort;
+QString configAuto;
+for(int i = 0; i < deviceConfigData.size(); i++)
+{
+	deviceNode = deviceConfigData.at(i).toElement();
+	if(deviceNode.attribute("name") == "autoSelect")
+	{
+		autoSelect = (deviceNode.attribute("value") == "true");
+	}
+	else if(deviceNode.attribute("name") == "deviceNumber")
+	{
+		configAuto = deviceNode.attribute("value");
+	}
+	else if(deviceNode.attribute("name") == "port")
+	{
+		configPort = deviceNode.attribute("value");
+	}
 }
+deviceID = autoSelect ? configAuto : configPort;
+channelOfInterest = index.row();
 
 @ It must be possible to perform calibration operations with the hardware not
 connected. As such, the device should only be opened on request. Methods for
 @<DataqSdkDeviceConfWidget implementation@>=
 void DataqSdkChannelConfWidget::startCalibration()
 {
-
+	startButton->setEnabled(false);
+	stopButton->setEnabled(true);
+	resetButton->setEnabled(true);
+	calibrationDevice = new DataqSdkDevice(deviceID);
+	Channel *channel;
+	for(int i = 0; i <= channelOfInterest; i++)
+	{
+		channel = calibrationDevice->newChannel(Units::Unitless);
+	}
+	connect(channel, SIGNAL(newData(Measurement)), this, SLOT(updateInput(Measurement)));
+	connect(channel, SIGNAL(newData(Measurement)), calibrator, SLOT(newMeasurement(Measurement)));
+	connect(calibrator, SIGNAL(newData(Measurement)), this, SLOT(updateOutput(Measurement)));
+	calibrationDevice->setClockRate(6.0 / (1.0 + channelOfInterest));
+	calibrationDevice->start();
 }
 
 void DataqSdkChannelConfWidget::stopCalibration()
 {
-
+	startButton->setEnabled(true);
+	stopButton->setEnabled(false);
+	resetButton->setEnabled(false);
+	calibrationDevice->deleteLater();
+	@<Reset DATAQ SDK channel calibration aggregates@>@;
 }
 
 @ When collecting calibration data it is useful to have a few types of
 @<DataqSdkDeviceConfWidget implementation@>=
 void DataqSdkChannelConfWidget::resetCalibration()
 {
+	@<Reset DATAQ SDK channel calibration aggregates@>@;
+}
+
+@ When calibration is stopped or reset, aggregate statistics are set to
+their initial values;
+
+@<Reset DATAQ SDK channel calibration aggregates@>=
+rmCount = 0;
+cmCount = 0;
+rmin = std::numeric_limits<double>::max();
+rmax = std::numeric_limits<double>::min();
+rmean = 0;
+cmin = std::numeric_limits<double>::max();
+cmax = std::numeric_limits<double>::min();
+cmean = 0;
+
+@ Two methods are responsible for updating line edits with current and
+aggregate data when calibrating a channel. One handles raw measurements from
+the channel and the other handles output from the |LinearCalibrator|.
+
+@<DataqSdkDeviceConfWidget implementation@>=
+void DataqSdkChannelConfWidget::updateInput(Measurement measure)
+{
+	double nv = measure.temperature();
+	currentMeasurement->setText(QString("%1").arg(nv));
+	rmin = qMin(nv, rmin);
+	minimumMeasurement->setText(QString("%1").arg(rmin));
+	rmax = qMax(nv, rmax);
+	maximumMeasurement->setText(QString("%1").arg(rmax));
+	rmean = ((rmean * rmCount) + nv) / (rmCount + 1);
+	rmCount++;
+	averageMeasurement->setText(QString("%1").arg(rmean));
+}
 
+void DataqSdkChannelConfWidget::updateOutput(Measurement measure)
+{
+	double nv = measure.temperature();
+	currentMapped->setText(QString("%1").arg(nv));
+	cmin = qMin(nv, cmin);
+	minimumMapped->setText(QString("%1").arg(cmin));
+	cmax = qMax(nv, cmax);
+	maximumMapped->setText(QString("%1").arg(cmax));
+	cmean = ((cmean * cmCount) + nv) / (cmCount + 1);
+	cmCount++;
+	averageMapped->setText(QString("%1").arg(cmean));
 }
 
 @ Column name is handled as usual.

src/scales.w

+@** Collecting Measurements from Scales.
+
+\noindent When a computer connected scale is available, it can be useful to
+eliminate manual transcription from the data entry for batches. In general it
+is difficult to determine where a measurement should go automatically, but
+there are a number of situations where the ability to drag a measurement from a
+label and drop it to whatever input widget is appropriate would be a useful
+operation to support.
+
+To support this, we need to subclass |QLabel| to allow it to initiate a drag
+and drop operation.
+
+@(draglabel.h@>=
+#ifndef TypicaDragLabelInclude
+#define TypicaDragLabelInclude
+
+#include <QLabel>
+
+class DragLabel : public QLabel
+{
+	Q_OBJECT
+	public:
+		explicit DragLabel(const QString &labelText, QWidget *parent = NULL);
+	protected:
+		void mousePressEvent(QMouseEvent *event);
+};
+
+#endif
+
+@ The font size of the label is increased by default to make it easier to
+manipulate on a touch screen. Otherwise, there is little to do in this class.
+
+@(draglabel.cpp@>=
+#include "draglabel.h"
+
+#include <QDrag>
+#include <QMouseEvent>
+
+DragLabel::DragLabel(const QString &labelText, QWidget *parent) :
+	QLabel(labelText, parent)
+{
+	QFont labelFont = font();
+	labelFont.setPointSize(14);
+	setFont(labelFont);
+}
+
+void DragLabel::mousePressEvent(QMouseEvent *event)
+{
+	if(event->button() == Qt::LeftButton)
+	{
+		QDrag *drag = new QDrag(this);
+		QMimeData *mimeData = new QMimeData;
+		mimeData->setText(text());
+		drag->setMimeData(mimeData);
+		drag->exec();
+	}
+}
+
+@ We require the ability to create these labels from the host environment.
+First we include the appropriate header.
+
+@<Header files to include@>=
+#include "draglabel.h"
+
+@ Next, a pair of function prototypes.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructDragLabel(QScriptContext *context, QScriptEngine *engine);
+void setDragLabelProperties(QScriptValue value, QScriptEngine *engine);
+
+@ These are made known to the host environment as usual.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructDragLabel);
+value = engine->newQMetaObject(&DragLabel::staticMetaObject, constructor);
+engine->globalObject().setProperty("DragLabel", value);
+
+@ The implementation is trivial.
+
+@<Functions for scripting@>=
+QScriptValue constructDragLabel(QScriptContext *context, QScriptEngine *engine)
+{
+	QScriptValue object;
+	QString labelText = "";
+	if(context->argumentCount() == 1)
+	{
+		labelText = argument<QString>(0, context);
+	}
+	object = engine->newQObject(new DragLabel(labelText));
+	setDragLabelProperties(object, engine);
+	return object;
+}
+
+void setDragLabelProperties(QScriptValue value, QScriptEngine *engine)
+{
+	setQLabelProperties(value, engine);
+}
+
+@ An object is also required to communicate with a scale. This is responsible
+for setting up a connection over a serial port, sending commands out to the
+scale, buffering and interpreting the response, and signaling new measurements.
+
+@(scale.h@>=
+#ifndef TypicaScaleInclude
+#define TypicaScaleInclude
+
+#include "3rdparty/qextserialport/src/qextserialport.h"
+#include "units.h"
+
+class SerialScale : public QextSerialPort
+{
+	Q_OBJECT
+	public:
+		SerialScale(const QString &port);
+	public slots:
+		void tare();
+		void weigh();
+	signals:
+		void newMeasurement(double weight, Units::Unit unit);
+	private slots:
+		void dataAvailable();
+	private:
+		QByteArray responseBuffer;
+};
+
+#endif
+
+@ The constructor tells the port that this should be event driven and connects
+a signal to buffer data..
+
+@(scale.cpp@>=
+#include "scale.h"
+#include <QStringList>
+
+SerialScale::SerialScale(const QString &port) :
+	QextSerialPort(port, QextSerialPort::EventDriven)
+{
+	connect(this, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
+}
+
+@ The |dataAvailable| method handles buffering incoming data and processing
+responses when they have come in. Serial port communications are likely to be
+very slow in comparison to everything else so it is likely that only one
+character will come in at a time.
+
+Note that this currently only understands single line output and a limited
+selection of units.
+
+@(scale.cpp@>=
+void SerialScale::dataAvailable()
+{
+	responseBuffer.append(readAll());
+	if(responseBuffer.contains("\x0D"))
+	{
+		if(responseBuffer.contains("!"))
+		{
+			responseBuffer.clear();
+		}
+		else
+		{
+			@<Process weight measurement@>@;
+			responseBuffer.clear();
+		}
+	}
+}
+
+@ Each line of data consists of an optional sign character possibly followed
+by a space followed by characters representing a number followed by a
+space followed by characters indicating a unit. This may be preceeded and
+followed by a variable amount of white space. To process a new measurement, we
+must remove the excess white space, split the number from the unit, prepend the
+sign to the number if it is present, convert the string representing the number
+to a numeric type, and determine which unit the measurement is in.
+
+\medskip
+
+\settabs 8 \columns
+\+&&&{\tt |"lb"|}&|Units::Pound|\cr
+\+&&&{\tt |"kg"|}&|Units::Kilogram|\cr
+\+&&&{\tt |"g"|}&|Units::Gram|\cr
+\+&&&{\tt |"oz"|}&|Units::Ounce|\cr
+
+\smallskip
+
+\centerline{Table \secno: Unit Strings and Representative Unit Enumeration}
+
+\medskip
+
+@<Process weight measurement@>=
+QStringList responseParts = QString(responseBuffer.simplified()).split(' ');
+if(responseParts.size() > 2)
+{
+	responseParts.removeFirst();
+	responseParts.replace(0, QString("-%1").arg(responseParts[0]));
+}
+double weight = responseParts[0].toDouble();
+Units::Unit unit = Units::Unitless;
+if(responseParts[1] == "lb")
+{
+	unit = Units::Pound;
+}
+else if(responseParts[1] == "kg")
+{
+	unit = Units::Kilogram;
+}
+else if(responseParts[1] == "g")
+{
+	unit = Units::Gram;
+}
+else if(responseParts[1] == "oz")
+{
+	unit = Units::Ounce;
+}
+emit newMeasurement(weight, unit);
+
+@ Two methods are used to send commands to the scale. I am unsure of how well
+standardized remote key operation of scales are. The class may need to be
+extended to support more devices.
+
+@(scale.cpp@>=
+void SerialScale::tare()
+{
+	write("!KT\x0D");
+}
+
+void SerialScale::weigh()
+{
+	write("!KP\x0D");
+}
+
+@ This must be available to the host environment.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructSerialScale(QScriptContext *context, QScriptEngine *engine);
+void setSerialScaleProperties(QScriptValue value, QScriptEngine *engine);
+
+@ These functions are made known to the scripting engine in the usual way.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructSerialScale);
+value = engine->newQMetaObject(&SerialScale::staticMetaObject, constructor);
+engine->globalObject().setProperty("SerialScale", value);
+
+@ If we are to set up the serial ports from the host environment, a few
+enumerated types must be made known to the meta-object system.
+
+@<Class declarations@>=
+Q_DECLARE_METATYPE(BaudRateType)
+Q_DECLARE_METATYPE(DataBitsType)
+Q_DECLARE_METATYPE(ParityType)
+Q_DECLARE_METATYPE(StopBitsType)
+Q_DECLARE_METATYPE(FlowType)
+
+@ For each of these, a pair of functions converts values to script values and
+back. This is a very annoying aspect of the version of QextSerialPort currently
+used by \pn{}.
+
+@<Function prototypes for scripting@>=
+QScriptValue BaudRateType_toScriptValue(QScriptEngine *engine, const BaudRateType &value);
+void BaudRateType_fromScriptValue(const QScriptValue &sv, BaudRateType &value);
+QScriptValue DataBitsType_toScriptValue(QScriptEngine *engine, const DataBitsType &value);
+void DataBitsType_fromScriptValue(const QScriptValue &sv, DataBitsType &value);
+QScriptValue ParityType_toScriptValue(QScriptEngine *engine, const ParityType &value);
+void ParityType_fromScriptValue(const QScriptValue &sv, ParityType &value);
+QScriptValue StopBitsType_toScriptValue(QScriptEngine *engine, const StopBitsType &value);
+void StopBitsType_fromScriptValue(const QScriptValue &sv, StopBitsType &value);
+QScriptValue FlowType_toScriptValue(QScriptEngine *engine, const FlowType &value);
+void FlowType_fromScriptValue(const QScriptValue &sv, FlowType &value);
+
+@ These are implemented thusly.
+
+@<Functions for scripting@>=
+QScriptValue BaudRateType_toScriptValue(QScriptEngine *engine, const BaudRateType &value)
+{
+	return engine->newVariant(QVariant((int)(value)));
+}
+
+void BaudRateType_fromScriptValue(const QScriptValue &sv, BaudRateType &value)
+{
+	value = (BaudRateType)(sv.toVariant().toInt());
+}
+
+QScriptValue DataBitsType_toScriptValue(QScriptEngine *engine, const DataBitsType &value)
+{
+	return engine->newVariant(QVariant((int)(value)));
+}
+
+void DataBitsType_fromScriptValue(const QScriptValue &sv, DataBitsType &value)
+{
+	value = (DataBitsType)(sv.toVariant().toInt());
+}
+
+QScriptValue ParityType_toScriptValue(QScriptEngine *engine, const ParityType &value)
+{
+	return engine->newVariant(QVariant((int)(value)));
+}
+
+void ParityType_fromScriptValue(const QScriptValue &sv, ParityType &value)
+{
+	value = (ParityType)(sv.toVariant().toInt());
+}
+
+QScriptValue StopBitsType_toScriptValue(QScriptEngine *engine, const StopBitsType &value)
+{
+	return engine->newVariant(QVariant((int)(value)));
+}
+
+void StopBitsType_fromScriptValue(const QScriptValue &sv, StopBitsType &value)
+{
+	value = (StopBitsType)(sv.toVariant().toInt());
+}
+
+QScriptValue FlowType_toScriptValue(QScriptEngine *engine, const FlowType &value)
+{
+	return engine->newVariant(QVariant((int)(value)));
+}
+
+void FlowType_fromScriptValue(const QScriptValue &sv, FlowType &value)
+{
+	value = (FlowType)(sv.toVariant().toInt());
+}
+
+@ These conversion functions are then registered.
+
+@<Set up the scripting engine@>=
+qScriptRegisterMetaType(engine, BaudRateType_toScriptValue, BaudRateType_fromScriptValue);
+qScriptRegisterMetaType(engine, DataBitsType_toScriptValue, DataBitsType_fromScriptValue);
+qScriptRegisterMetaType(engine, ParityType_toScriptValue, ParityType_fromScriptValue);
+qScriptRegisterMetaType(engine, StopBitsType_toScriptValue, StopBitsType_fromScriptValue);
+qScriptRegisterMetaType(engine, FlowType_toScriptValue, FlowType_fromScriptValue);
+
+@ In order to make this class available to the host environment, we must also
+include the appropriate header file.
+
+@<Header files to include@>=
+#include "scale.h"
+
+@ Most of the properties of interest should be added automatically, however
+there are non-slot methods in |QIODevice| that we require.
+
+@<Functions for scripting@>=
+void setSerialScaleProperties(QScriptValue value, QScriptEngine *engine)
+{
+	setQIODeviceProperties(value, engine);
+}
+
+@ The script constructor should seem familiar.
+
+@<Functions for scripting@>=
+QScriptValue constructSerialScale(QScriptContext *context, QScriptEngine *engine)
+{
+	QScriptValue object;
+	if(context->argumentCount() == 1)
+	{
+		object = engine->newQObject(new SerialScale(argument<QString>(0, context)));
+		setSerialScaleProperties(object, engine);
+	}
+	else
+	{
+		context->throwError("Incorrect number of arguments passed to "
+		                    "SerialScale. The constructor takes one string "
+		                    "as an argument specifying a port name.");
+	}
+	return object;
+}
+
+@ In order to allow configuration of scales from within \pn{}, a configuration
+widget must be provided.
+
+@<Class declarations@>=
+class SerialScaleConfWidget : public BasicDeviceConfigurationWidget
+{
+	Q_OBJECT
+	public:
+		Q_INVOKABLE SerialScaleConfWidget(DeviceTreeModel *model,
+		                                  const QModelIndex &index);
+	private slots:
+		void updatePort(const QString &newPort);
+		void updateBaudRate(const QString &rate);
+		void updateParity(int index);
+		void updateFlowControl(int index);
+		void updateStopBits(int index);
+	private:
+		PortSelector *port;
+		BaudSelector *baud;
+		ParitySelector *parity;
+		FlowSelector *flow;
+		StopSelector *stop;
+};
+
+@ This is very similar to other configuration widgets.
+
+@<SerialScaleConfWidget implementation@>=
+SerialScaleConfWidget::SerialScaleConfWidget(DeviceTreeModel *model,
+                                             const QModelIndex &index)
+: BasicDeviceConfigurationWidget(model, index),
+  port(new PortSelector), baud(new BaudSelector), parity(new ParitySelector),
+  flow(new FlowSelector), stop(new StopSelector)
+{
+	QFormLayout *layout = new QFormLayout;
+	layout->addRow(tr("Port:"), port);
+	connect(port, SIGNAL(currentIndexChanged(QString)),
+	        this, SLOT(updatePort(QString)));
+	connect(port, SIGNAL(editTextChanged(QString)),
+	        this, SLOT(updatePort(QString)));
+	layout->addRow(tr("Baud:"), baud);
+	connect(baud, SIGNAL(currentIndexChanged(QString)),
+	        this, SLOT(updateBaudRate(QString)));
+	layout->addRow(tr("Parity:"), parity);
+	connect(parity, SIGNAL(currentIndexChanged(int)),
+	        this, SLOT(updateParity(int)));
+	layout->addRow(tr("Flow Control:"), flow);
+	connect(flow, SIGNAL(currentIndexChanged(int)),
+	        this, SLOT(updateFlowControl(int)));
+	layout->addRow(tr("Stop Bits:"), stop);
+	connect(stop, SIGNAL(currentIndexChanged(int)),
+	        this, SLOT(updateStopBits(int)));
+	@<Get device configuration data for current node@>@;
+	for(int i = 0; i < configData.size(); i++)
+	{
+		node = configData.at(i).toElement();
+		if(node.attribute("name") == "port")
+		{
+			int j = port->findText(node.attribute("value"));
+			if(j >= 0)
+			{
+				port->setCurrentIndex(j);
+			}
+			else
+			{
+				port->insertItem(0, node.attribute("value"));
+				port->setCurrentIndex(0);
+			}
+		}
+		else if(node.attribute("name") == "baudrate")
+		{
+			baud->setCurrentIndex(baud->findText(node.attribute("value")));
+		}
+		else if(node.attribute("name") == "parity")
+		{
+			parity->setCurrentIndex(parity->findData(node.attribute("value")));
+		}
+		else if(node.attribute("name") == "flowcontrol")
+		{
+			flow->setCurrentIndex(flow->findData(node.attribute("value")));
+		}
+		else if(node.attribute("name") == "stopbits")
+		{
+			stop->setCurrentIndex(stop->findData(node.attribute("value")));
+		}
+	}
+	updatePort(port->currentText());
+	updateBaudRate(baud->currentText());
+	updateParity(parity->currentIndex());
+	updateFlowControl(flow->currentIndex());
+	updateStopBits(stop->currentIndex());
+	setLayout(layout);
+}
+
+@ Update methods are the same as were used in |ModbusRtuPortConfWidget|.
+
+@<SerialScaleConfWidget implementation@>=
+void SerialScaleConfWidget::updatePort(const QString &newPort)
+{
+	updateAttribute("port", newPort);
+}
+
+void SerialScaleConfWidget::updateBaudRate(const QString &rate)
+{
+	updateAttribute("baudrate", rate);
+}
+
+void SerialScaleConfWidget::updateParity(int index)
+{
+	updateAttribute("parity", parity->itemData(index).toString());
+}
+
+void SerialScaleConfWidget::updateFlowControl(int index)
+{
+	updateAttribute("flowcontrol", flow->itemData(index).toString());
+}
+
+void SerialScaleConfWidget::updateStopBits(int index)
+{
+	updateAttribute("stopbits", stop->itemData(index).toString());
+}
+
+@ The configuration widget is registered with the configuration system.
+
+@<Register device configuration widgets@>=
+app.registerDeviceConfigurationWidget("scale", SerialScaleConfWidget::staticMetaObject);
+
+@ A |NodeInserter| is also added.
+
+@<Register top level device configuration nodes@>=
+inserter = new NodeInserter(tr("Serial Scale"), tr("Scale"), "scale", NULL);
+topLevelNodeInserters.append(inserter);
+

src/typica.w

 @<SettingsWindow implementation@>@/
 @<GraphSettingsWidget implementation@>@/
 @<DataqSdkDeviceConfWidget implementation@>@/
+@<SerialScaleConfWidget implementation@>@/
+@<ValueAnnotation implementation@>@/
+@<ValueAnnotationConfWidget implementation@>@/
 
 @ A few headers are required for various parts of \pn{}. These allow the use of
 various Qt modules.
 	return qscriptvalue_cast<QModelIndex>(context->argument(arg));
 }
 
+template<> double argument(int arg, QScriptContext *context)
+{
+	return (double)(context->argument(arg).toNumber());
+}
+
+template<> Units::Unit argument(int arg, QScriptContext *context)
+{
+	return (Units::Unit)(context->argument(arg).toInt32());
+}
+
 @ The scripting engine is informed of a number of classes defined elsewhere in
 the program. Code related to scripting these classes is grouped with the code
 implementing the classes. Additionally, there are several classes from Qt which
 r = cseconds - oseconds;
 
 @ The logic for a count down timer is very similar to the logic for a count up
-timer. A key difference is that we don't want to continue counting down if the
+timer. A key difference is that we don'@q'@>t want to continue counting down if the
 timer has already reached 0.
 
 @<Check for Timer Decrement@>=
 }
 
 @ Stopping the timer is a little simpler. Remember to stop the clock so we
-aren't updating senselessly.
+aren'@q'@>t updating senselessly.
 
 @<TimerDisplay Implementation@>=
 void TimerDisplay::stopTimer()@t\2\2@>@/
 
 The end of this function may seem a little strange. Why not simply look up the
 map and insert information directly into the model data? Well, as of this
-writing, that doesn't work. There are two ways around that problem. One is to
+writing, that doesn'@q'@>t work. There are two ways around that problem. One is to
 have the lists store references and dereference the real data. The other option
 is to obtain a copy of the row, then a copy of the cell, update the cell, then
 replace the old value of the cell in the copy of the row, then replace the old
 	@<Expand the SaltModel@>@;
 }
 
-@ The destructor doesn't need to do anything.
+@ The destructor doesn'@q'@>t need to do anything.
 
 @<SaltModel Implementation@>=
 SaltModel::~SaltModel()
 	@<Check that the SaltModel index is valid@>@;
 	if(valid)
 	{
-		return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
+		return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsDropEnabled;
 	}
 	return 0;
 }
 @ In order to connect to the database, we need five pieces of information: the
 name of a database driver (PostgreSQL is recommended for now), the host name of
 the computer running the database, the name of the database, the name of the
-user connecting to the database, and that user's password. This information will
+user connecting to the database, and that user'@q'@>s password. This information will
 be stored in the user settings for the application so that the database
 connection can be established without prompting the user next time. A class is
 provided to gather this information.
 				  QVariant(newsize));
 
 @ To determine which window a given table is in, we just follow
-|parentWidget()| until there isn't one. It is possible that the table view
+|parentWidget()| until there isn'@q'@>t one. It is possible that the table view
 will also be the window, however this is not advised as it is easier for the
 settings key to be non-unique in such a case.
 
 in Qt. This brings several benefits, including making it easy to print reports
 or save reports as plain text or HTML.
 
-Reports are specified in the \pn{}'s configuration document and can include both
+Reports are specified in the \pn{}'@q'@>s configuration document and can include both
 static elements and elements that are populated by external data such as the
 result of a SQL query.
 
 @ It is sometimes desirable to add fixed data such as column headers to a table.
 This is done with the {\tt <row>} element.
 
-Technically, this isn't needed. The same results can be produced by using a
+Technically, this isn'@q'@>t needed. The same results can be produced by using a
 {\tt <query>} element to select constant data, but this approach saves a trip to
 the database.
 
 	saveDeviceConfiguration();
 }
 
-@ There isn't really anything that can be done if the device configuration data
+@ There isn'@q'@>t really anything that can be done if the device configuration data
 is corrupt, but an error message can be produced if the program happens to have
 access to a debugging console.
 
 	return QDomElement();
 }
 
-@ We don't want any headers, so |headerData()| is very simple.
+@ We don'@q'@>t want any headers, so |headerData()| is very simple.
 
 @<DeviceTreeModel implementation@>=
 QVariant DeviceTreeModel::headerData(int, Qt::Orientation, int) const
 	        this, SLOT(insertChildNode(QString, QString)));
 	connect(freeAnnotationInserter, SIGNAL(triggered(QString, QString)),
 	        this, SLOT(insertChildNode(QString, QString)));
+	@<Add annotation control node inserters@>@;
 	addAnnotationControlButton->setMenu(annotationMenu);
 	layout->addWidget(addAnnotationControlButton);
 	QPushButton *advancedButton = new QPushButton(tr("Advanced Features"));
 	@[private slots@]:@/
 		void updateThermocoupleType(const QString &type);
 		void updateColumnName(const QString &name);
+		void updateHidden(bool hidden);
 };
 
 @ This follows the same pattern of previous device configuration widgets. The
 	typeSelector->addItem("R");
 	typeSelector->addItem("S");
 	layout->addRow(tr("Thermocouple Type:"), typeSelector);
+	QCheckBox *hideSeries = new QCheckBox("Hide this channel");
+	layout->addRow(hideSeries);
 	setLayout(layout);
 	@<Get device configuration data for current node@>@;
 	for(int i = 0; i < configData.size(); i++)
 		{
 			columnName->setText(node.attribute("value"));
 		}
+		else if(node.attribute("name") == "hidden")
+		{
+			hideSeries->setChecked(node.attribute("value") == "true");
+		}
 	}
 	updateThermocoupleType(typeSelector->currentText());
 	updateColumnName(columnName->text());
+	updateHidden(hideSeries->isChecked());
 	connect(typeSelector, SIGNAL(currentIndexChanged(QString)),
 	        this, SLOT(updateThermocoupleType(QString)));
 	connect(columnName, SIGNAL(textEdited(QString)), this, SLOT(updateColumnName(QString)));
+	connect(hideSeries, SIGNAL(toggled(bool)), this, SLOT(updateHidden(bool)));
 }
 
 @ Two slots are used to pass configuration changes back to the underlying XML
 	updateAttribute("columnname", name);
 }
 
+void Ni9211TcConfWidget::updateHidden(bool hidden)
+{
+	updateAttribute("hidden", hidden ? "true" : "false");
+}
+
 @ These three widgets need to be registered so the configuration widget can
 instantiate them when the nodes are selected.
 
 		void updateDeviceId(const QString &newId);
 		void updateThermocoupleType(const QString &type);
 		void updateColumnName(const QString &name);
+		void updateHidden(bool hidden);
 };
 
 @ The implementation is similar to the other configuration widgets.
 	typeSelector->addItem("R");
 	typeSelector->addItem("S");
 	layout->addRow(tr("Thermocouple Type:"), typeSelector);
+	QCheckBox *hideSeries = new QCheckBox(tr("Hide this channel"));
+	layout->addRow(hideSeries);
 	@<Get device configuration data for current node@>@;
 	for(int i = 0; i < configData.size(); i++)
 	{
 		{
 			columnName->setText(node.attribute("value"));
 		}
+		else if(node.attribute("name") == "hidden")
+		{
+			hideSeries->setChecked(node.attribute("value") == "true");
+		}
 	}
 	updateDeviceId(deviceId->text());
 	updateThermocoupleType(typeSelector->currentText());
 	updateColumnName(columnName->text());
+	updateHidden(hideSeries->isChecked());
 	connect(deviceId, SIGNAL(textEdited(QString)), this, SLOT(updateDeviceId(QString)));
 	connect(typeSelector, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateThermocoupleType(QString)));
 	connect(columnName, SIGNAL(textEdited(QString)), this, SLOT(updateColumnName(QString)));
 	setLayout(layout);
+	connect(hideSeries, SIGNAL(toggled(bool)), this, SLOT(updateHidden(bool)));
 }
 
 void NiDaqMxTc01ConfWidget::updateDeviceId(const QString &newId)
 	updateAttribute("columnname", name);
 }
 
+void NiDaqMxTc01ConfWidget::updateHidden(bool hidden)
+{
+	updateAttribute("hidden", hidden ? "true" : "false");
+}
+
 @ These configuration widgets need to be registered so they can be instantiated
 in response to node selections.
 
 	QextPortInfo port;
 	foreach(port, ports)
 	{
+#ifdef Q_OS_WIN32
 		addItem(port.portName);
+#else
+		addItem(port.physName);
+#endif
 	}
 	lister->setUpNotifications();
 	connect(lister, SIGNAL(deviceDiscovered(QextPortInfo)),
 A later version of QextSerialPort than is used by \pn{} provides a helper
 class which can be used more conveniently to create this sort of control. As
 this is not yet available to \pn{}, we instead copy the |enum| specifying
-the appropriate values into the class and use Qt's meta-object system to
+the appropriate values into the class and use Qt'@q'@>s meta-object system to
 populate the combo box based on the values in that |enum|.
 
 @<Class declarations@>=
 }
 
 @ There are two ways that we might request measurement data. All of the
-devices I've seen documented provide function 0x4 addresses for PV and SV
+devices I'@q'@>ve seen documented provide function 0x4 addresses for PV and SV
 such that SV can be obtained from the address immediately after the address
 from which we obtain PV. In this case we request both values at the same time.
 
 this buffer will have incomplete data. This means that we must determine when
 the full response is available before passing the complete response along to
 the appropriate method. If the response has not been received in full, nothing
-is done. We'll be notified of more data shortly.
+is done. We'@q'@>ll be notified of more data shortly.
 
 When the message we see the response for was queued, a callback was also
 registered to handle the response. Once we have the complete message, we pass
 	queueMessage(message, this, "ignore(QByteArray)");
 }
 
-@ We don't care about the response when sending a new SV.
+@ We don'@q'@>t care about the response when sending a new SV.
 
 @<ModbusRTUDevice implementation@>=
 void ModbusRTUDevice::ignore(QByteArray)
 		void updateSVWriteAddress(int address);
 		void updatePVColumnName(const QString &name);
 		void updateSVColumnName(const QString &name);
+		void updatePVHidden(bool hidden);
+		void updateSVHidden(bool hidden);
 	private:@/
 		PortSelector *port;
 		BaudSelector *baud;
 	QFormLayout *pVSection = new QFormLayout;
 	pVSection->addRow(tr("Value relative address:"), pVAddress);
 	pVSection->addRow(tr("PV column name:"), pVColumnName);
+	QCheckBox *pVHideBox = new QCheckBox(tr("Hide this channel"));
+	pVSection->addRow(pVHideBox);
 	QGroupBox *processValueBox = new QGroupBox(tr("Process Value"));
 	processValueBox->setLayout(pVSection);
 	seriesLayout->addWidget(processValueBox);
 	sVSection->addRow(tr("Upper limit:"), sVUpper);
 	sVSection->addRow(tr("Output set value:"), sVWritable);
 	sVSection->addRow(tr("Output relative address:"), sVOutputAddr);
+	QCheckBox *sVHideBox = new QCheckBox(tr("Hide this channel"));
+	sVSection->addRow(sVHideBox);
 	QGroupBox *setValueBox = new QGroupBox(tr("Set Value"));
 	setValueBox->setLayout(sVSection);
 	seriesLayout->addWidget(setValueBox);
 		{
 			sVColumnName->setText(node.attribute("value"));
 		}
+		else if(node.attribute("name") == "pvhidden")
+		{
+			pVHideBox->setChecked(node.attribute("value") == "true");
+		}
+		else if(node.attribute("name") == "svhidden")
+		{
+			sVHideBox->setChecked(node.attribute("value") == "true");
+		}
 	}
 	updatePort(port->currentText());
 	updateBaudRate(baud->currentText());
 	updateSVWriteAddress(sVOutputAddr->value());
 	updatePVColumnName(pVColumnName->text());
 	updateSVColumnName(sVColumnName->text());
+	updatePVHidden(pVHideBox->isChecked());
+	updateSVHidden(sVHideBox->isChecked());
 	connect(port, SIGNAL(currentIndexChanged(QString)), this, SLOT(updatePort(QString)));
 	connect(port, SIGNAL(editTextChanged(QString)), this, SLOT(updatePort(QString)));
 	connect(baud, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateBaudRate(QString)));
 	connect(sVOutputAddr, SIGNAL(valueChanged(int)), this, SLOT(updateSVWriteAddress(int)));
 	connect(pVColumnName, SIGNAL(textEdited(QString)), this, SLOT(updatePVColumnName(QString)));
 	connect(sVColumnName, SIGNAL(textEdited(QString)), this, SLOT(updateSVColumnName(QString)));
+	connect(pVHideBox, SIGNAL(toggled(bool)), this, SLOT(updatePVHidden(bool)));
+	connect(sVHideBox, SIGNAL(toggled(bool)), this, SLOT(updateSVHidden(bool)));
 	layout->addWidget(form);
 	setLayout(layout);
 }
 	updateAttribute("svcolname", name);
 }
 
+void ModbusConfigurator::updatePVHidden(bool hidden)
+{
+	updateAttribute("pvhidden", hidden ? "true" : "false");
+}
+
+void ModbusConfigurator::updateSVHidden(bool hidden)
+{
+	updateAttribute("svhidden", hidden ? "true" : "false");
+}
+
 @ This is registered with the configuration system.
 
 @<Register device configuration widgets@>=
 		void updateDestinationColumn(const QString &dest);
 		void updateKnots();
 	private:@/
-		SaltModel *knotmodel;
+		SaltModel *tablemodel;
 };
 
 @ This is configured by specifying a source column name, a destination column
 
 @<LinearSplineInterpolationConfWidget implementation@>=
 LinearSplineInterpolationConfWidget::LinearSplineInterpolationConfWidget(DeviceTreeModel *model, const QModelIndex &index)
-: BasicDeviceConfigurationWidget(model, index), knotmodel(new SaltModel(2))
+: BasicDeviceConfigurationWidget(model, index), tablemodel(new SaltModel(2))
 {
 	QFormLayout *layout = new QFormLayout;
 	QLineEdit *source = new QLineEdit;
 	layout->addRow(tr("Source column name:"), source);
 	QLineEdit *destination = new QLineEdit;
 	layout->addRow(tr("Destination column name:"), destination);
-	knotmodel->setHeaderData(0, Qt::Horizontal, "Input");
-	knotmodel->setHeaderData(1, Qt::Horizontal, "Output");
+	tablemodel->setHeaderData(0, Qt::Horizontal, "Input");
+	tablemodel->setHeaderData(1, Qt::Horizontal, "Output");
 	QTableView *mappingTable = new QTableView;
-	mappingTable->setModel(knotmodel);
+	mappingTable->setModel(tablemodel);
 	NumericDelegate *delegate = new NumericDelegate;
 	mappingTable->setItemDelegate(delegate);
 	layout->addRow(tr("Mapping data:"), mappingTable);
 	updateKnots();
 	connect(source, SIGNAL(textEdited(QString)), this, SLOT(updateSourceColumn(QString)));
 	connect(destination, SIGNAL(textEdited(QString)), this, SLOT(updateDestinationColumn(QString)));
-	connect(knotmodel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateKnots()));
+	connect(tablemodel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateKnots()));
 	setLayout(layout);
 }
 
 @<Populate model column from list@>=
 for(int i = 0; i < itemList.size(); i++)
 {
-	knotmodel->setData(knotmodel->index(i, column),
-	                   QVariant(itemList.at(i).toDouble()),
-                       Qt::DisplayRole);
+	tablemodel->setData(tablemodel->index(i, column),
+	               QVariant(itemList.at(i).toDouble()),
+                   Qt::DisplayRole);
 }
 
 @ When data in the table is changed we simply overwrite any previously saved
 @<LinearSplineInterpolationConfWidget implementation@>=
 void LinearSplineInterpolationConfWidget::updateKnots()
 {
-	updateAttribute("sourcevalues", knotmodel->arrayLiteral(0, Qt::DisplayRole));
-	updateAttribute("destinationvalues", knotmodel->arrayLiteral(1, Qt::DisplayRole));
+	updateAttribute("sourcevalues", tablemodel->arrayLiteral(0, Qt::DisplayRole));
+	updateAttribute("destinationvalues", tablemodel->arrayLiteral(1, Qt::DisplayRole));
 }
 
 void LinearSplineInterpolationConfWidget::updateSourceColumn(const QString &source)
 
 @i dataqsdk.w
 
+@i scales.w
+
+@i valueannotation.w
+
 @** Local changes.
 
 \noindent This is the end of \pn{} as distributed by its author. It is expected

src/units.w

 			Fahrenheit = 10144,
 			Celsius = 10143,
 			Kelvin = 10325,
-			Rankine = 10145
+			Rankine = 10145,
+			Pound = 15876,
+			Kilogram = 15877,
+			Ounce = 1,
+			Gram = 2
 		};
 		static double convertTemperature(double value, Unit fromUnit, Unit toUnit);
 		static double convertRelativeTemperature(double value, Unit fromUnit, Unit toUnit);
 		static bool isTemperatureUnit(Unit unit);
+		static double convertWeight(double value, Unit fromUnit, Unit toUnit);
+		static bool isWeightUnit(Unit unit);
 };
 
 #endif
 				case Rankine:
 					return value;
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		case Celsius:
 				case Rankine:
 					return value * (9.0 / 5.0);
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		case Kelvin:
 				case Rankine:
 					return value * (9.0 / 5.0);
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		case Rankine:
 				case Rankine:
 					return value;
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		default:
 	return 0;
 }
 
+@ Units of force are handled similarly to units of temperature.
+
+@(units.cpp@>=
+double Units::convertWeight(double value, Unit fromUnit, Unit toUnit)
+{
+	if(isWeightUnit(fromUnit) && isWeightUnit(toUnit))
+	{
+		switch(fromUnit)
+		{
+			case Pound:
+				switch(toUnit)
+				{
+					case Pound:
+						return value;
+						break;
+					case Kilogram:
+						return value / 2.2;
+						break;
+					case Ounce:
+						return value * 16.0;
+						break;
+					case Gram:
+						return value / 0.0022;
+						break;
+					default:
+						return 0;
+						break;
+				}
+				break;
+			case Kilogram:
+				switch(toUnit)
+				{
+					case Pound:
+						return value * 2.2;
+						break;
+					case Kilogram:
+						return value;
+						break;
+					case Ounce:
+						return value * 35.2;
+						break;
+					case Gram:
+						return value * 1000.0;
+						break;
+					default:
+						return 0;
+						break;
+				}
+				break;
+			case Ounce:
+				switch(toUnit)
+				{
+					case Pound:
+						return value / 16.0;
+						break;
+					case Kilogram:
+						return value / 35.2;
+						break;
+					case Ounce:
+						return value;
+						break;
+					case Gram:
+						return value / 0.0352;
+						break;
+					default:
+						return 0;
+						break;
+				}
+				break;
+			case Gram:
+				switch(toUnit)
+				{
+					case Pound:
+						return value * 0.0022;
+						break;
+					case Kilogram:
+						return value / 1000.0;
+						break;
+					case Ounce:
+						return value * 0.0352;
+						break;
+					case Gram:
+						return value;
+						break;
+					default:
+						return 0;
+						break;
+				}
+				break;
+			default:
+				return 0;
+				break;
+		}
+	}
+	return 0;
+}
+
+bool Units::isWeightUnit(Unit unit)
+{
+	if(unit == Pound ||
+	   unit == Kilogram ||
+	   unit == Ounce ||
+	   unit == Gram)
+	{
+		return true;
+	}
+	return false;
+}
+
 @ This class is exposed to the host environment. Note the lack of constructor.
 We do not wish to create any instances, just have access to the |Unit|
-enumeration.
+enumeration and conversion methods.
+
+Unfortunately, marking a static method |Q_INVOKABLE| will not work as per Qt
+bug #18840. There seems to be no intention to correct this deficiency so
+instead of having something that just works, we must resort to the following
+hackery.
+
+@<Function prototypes for scripting@>=
+QScriptValue Units_convertTemperature(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Units_convertRelativeTemperature(QScriptContext *context,
+                                              QScriptEngine *engine);
+QScriptValue Units_isTemperatureUnit(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Units_convertWeight(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Units_isWeightUnit(QScriptContext *context, QScriptEngine *engine);
+
+@ These functions are added as properties for the host environment.
 
 @<Set up the scripting engine@>=
 value = engine->newQMetaObject(&Units::staticMetaObject);
+value.setProperty("convertTemperature", engine->newFunction(Units_convertTemperature));
+value.setProperty("convertRelativeTemperature",
+                  engine->newFunction(Units_convertRelativeTemperature));
+value.setProperty("isTemperatureUnit", engine->newFunction(Units_isTemperatureUnit));
+value.setProperty("convertWeight", engine->newFunction(Units_convertWeight));
+value.setProperty("isWeightUnit", engine->newFunction(Units_isWeightUnit));
 engine->globalObject().setProperty("Units", value);
 
+@ The implementation of these functions is trivial.
+
+@<Functions for scripting@>=
+QScriptValue Units_convertTemperature(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::convertTemperature(argument<double>(0, context),
+	                                              argument<Units::Unit>(1, context),
+	                                              argument<Units::Unit>(2, context)));
+}
+
+QScriptValue Units_convertRelativeTemperature(QScriptContext *context,
+                                              QScriptEngine *engine)
+{
+	return QScriptValue(Units::convertRelativeTemperature(
+	                         argument<double>(0, context),
+	                         argument<Units::Unit>(1, context),
+	                         argument<Units::Unit>(2, context)));
+}
+
+QScriptValue Units_isTemperatureUnit(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::isTemperatureUnit(argument<Units::Unit>(0, context)));
+}
+
+QScriptValue Units_convertWeight(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::convertWeight(argument<double>(0, context),
+	                                         argument<Units::Unit>(1, context),
+	                                         argument<Units::Unit>(2, context)));
+}
+
+QScriptValue Units_isWeightUnit(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::isWeightUnit(argument<Units::Unit>(0, context)));
+}
+
+@ To pass unit data in some circumstances, the inner enumeration must be
+registered as a meta-type with script conversions.
+
+@<Class declarations@>=
+Q_DECLARE_METATYPE(Units::Unit)
+
+@ A pair of conversion methods is required.
+
+@<Function prototypes for scripting@>=
+QScriptValue Unit_toScriptValue(QScriptEngine *engine, const Units::Unit &value);
+void Unit_fromScriptValue(const QScriptValue &sv, Units::Unit &value);
+
+@ These are implemented thusly.
+
+@<Functions for scripting@>=
+QScriptValue Unit_toScriptValue(QScriptEngine *engine, const Units::Unit &value)
+{
+	return engine->newVariant(QVariant(value));
+}
+
+void Unit_fromScriptValue(const QScriptValue &sv, Units::Unit &value)
+{
+	value = sv.toVariant().value<Units::Unit>();
+}
+
+@ These conversion functions are registered.
+
+@<Set up the scripting engine@>=
+qScriptRegisterMetaType(engine, Unit_toScriptValue, Unit_fromScriptValue);
+

src/valueannotation.w

+@** Annotations for Values.
+
+\noindent In circumstances where a control setting is logged but this setting
+changes infrequently and has a small number of possible values, it is sometimes
+useful to not log the control values throughout the roast but rather simply add
+an annotation when the control value changes. It will commonly be desirable to
+also provide an annotation representing the current state at the start of every
+batch.
+
+To support this feature, there must be a configuration widget which can be used
+to identify which data series should be monitored and what annotations should
+be produced for what values.
+
+@<Class declarations@>=
+class ValueAnnotationConfWidget : public BasicDeviceConfigurationWidget
+{
+	Q_OBJECT
+	public:
+		Q_INVOKABLE ValueAnnotationConfWidget(DeviceTreeModel *model,
+                                              const QModelIndex &index);
+	private slots:
+		void updateSourceColumn(const QString &source);
+		void updateAnnotations();
+		void updateStart(bool noteOnStart);
+	private:
+		SaltModel *tablemodel;
+};
+
+@ The constructor sets up the configuration interface requesting a source
+column name, if an annotation should be emitted at the start of the batch, and
+what annotations should be produced for what values.
+
+@<ValueAnnotationConfWidget implementation@>=
+ValueAnnotationConfWidget::ValueAnnotationConfWidget(DeviceTreeModel *model,
+                                                     const QModelIndex &index)
+: BasicDeviceConfigurationWidget(model, index),
+  tablemodel(new SaltModel(2))
+{
+	QFormLayout *layout = new QFormLayout;
+	QLineEdit *source = new QLineEdit;
+	layout->addRow(tr("Source column name:"), source);
+	QCheckBox *noteOnStart = new QCheckBox(tr("Produce Start State Annotation"));
+	noteOnStart->setChecked(true);
+	layout->addRow(noteOnStart);
+	tablemodel->setHeaderData(0, Qt::Horizontal, "Value");
+	tablemodel->setHeaderData(1, Qt::Horizontal, "Annotation");
+	QTableView *annotationTable = new QTableView;
+	annotationTable->setModel(tablemodel);
+	NumericDelegate *delegate = new NumericDelegate;
+	annotationTable->setItemDelegateForColumn(0, delegate);
+	layout->addRow(tr("Annotations for values:"), annotationTable);
+	@<Get device configuration data for current node@>@;
+	for(int i = 0; i < configData.size(); i++)
+	{
+		node = configData.at(i).toElement();
+		if(node.attribute("name") == "source")
+		{
+			source->setText(node.attribute("value"));
+		}
+		else if(node.attribute("name") == "emitOnStart")
+		{
+			noteOnStart->setChecked(node.attribute("value") == "true" ? true : false);
+		}
+		else if(node.attribute("name") == "measuredValues")
+		{
+			@<Convert numeric array literal to list@>@;
+			int column = 0;
+			@<Populate model column from list@>@;
+		}
+		else if(node.attribute("name") == "annotations")
+		{
+			@<Convert string array literal to list@>@;
+			int column = 1;
+			@<Populate model column from string list@>@;
+		}
+	}
+	updateSourceColumn(source->text());
+	updateStart(noteOnStart->isChecked());
+	updateAnnotations();
+	connect(source, SIGNAL(textEdited(QString)), this, SLOT(updateSourceColumn(QString)));
+	connect(noteOnStart, SIGNAL(toggled(bool)), this, SLOT(updateStart(bool)));
+	connect(tablemodel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateAnnotations()));
+	setLayout(layout);
+}
+
+@ While we can re-use code for handling numeric array literals, string array
+literals need to be handled a little differently.
+
+@<Convert string array literal to list@>=
+QString data = node.attribute("value");
+if(data.length() > 3)
+{
+	data.chop(2);
+	data = data.remove(0, 2);
+}
+QStringList itemList = data.split(",");
+for(int i = 0; i < itemList.size(); i++)
+{
+	itemList[i] = itemList[i].simplified();
+}
+
+@ Populating the model must also be done a little differently.
+
+@<Populate model column from string list@>=
+for(int i = 0; i < itemList.size(); i++)
+{
+	tablemodel->setData(tablemodel->index(i, column),
+	                    QVariant(itemList.at(i)),
+	                    Qt::DisplayRole);
+}
+
+@ To update the table data, the measued values and annotations are saved in
+separate lists.
+
+@<ValueAnnotationConfWidget implementation@>=
+void ValueAnnotationConfWidget::updateAnnotations()
+{
+	updateAttribute("measuredValues", tablemodel->arrayLiteral(0, Qt::DisplayRole));
+	updateAttribute("annotations", tablemodel->arrayLiteral(1, Qt::DisplayRole));
+}
+
+@ The other settings are updated based on values passed through the parameter
+to the update method.
+
+@<ValueAnnotationConfWidget implementation@>=
+void ValueAnnotationConfWidget::updateSourceColumn(const QString &source)
+{
+	updateAttribute("source", source);
+}
+
+void ValueAnnotationConfWidget::updateStart(bool noteOnStart)
+{
+	updateAttribute("emitOnStart", noteOnStart ? "true" : "false");
+}
+
+@ The widget is registered with the configuration system.
+
+@<Register device configuration widgets@>=
+app.registerDeviceConfigurationWidget("valueannotation",
+	ValueAnnotationConfWidget::staticMetaObject);
+
+@ A NodeInserter is needed to make this widget available.
+
+@<Add annotation control node inserters@>=
+NodeInserter *valueAnnotationInserter = new NodeInserter(tr("Value Annotation"),
+                                                         tr("Value Annotation"),
+                                                         "valueannotation");
+annotationMenu->addAction(valueAnnotationInserter);
+connect(valueAnnotationInserter, SIGNAL(triggered(QString, QString)),
+        this, SLOT(insertChildNode(QString, QString)));
+
+@ While it is possible to implement this feature with |ThresholdDetector|
+objects, the code to handle these would be difficult to understand and there
+would be excessive overhead in moving measurements through all of these.
+Instead, we create a new class that watches for any sort of measurement
+change and produces the annotation signals directly.
+
+As measured values are represented as a |double|, a small value should be
+provided such that comparisons are not against the value directly but instead
+are against the value plus or minus this other small value.
+
+Method names have been chosen to be compatible with the |AnnotationButton|
+class.
+
+@<Class declarations@>=
+class ValueAnnotation : public QObject
+{
+	Q_OBJECT
+	public:
+		ValueAnnotation();
+		Q_INVOKABLE void setAnnotation(double value, const QString &annotation);
+	public slots:
+		void newMeasurement(Measurement measure);
+		void annotate();
+		void setAnnotationColumn(int column);
+		void setTemperatureColumn(int column);
+		void setTolerance(double epsilon);
+	signals:
+		void annotation(QString annotation, int tempcolumn, int notecolumn);
+	private:
+		int lastIndex;
+		int annotationColumn;
+		int measurementColumn;
+		QList<double> values;
+		QStringList annotations;
+		double tolerance;
+};
+
+@ Most of the work of this class happens in the |newMeasurement| method. This
+compares the latest measurement with every value that has an associated
+annotation. If the value is near enough to a value in the list, the index of
+that value is compared with the index of the previous annotation (if any) and
+if the indices are different, the appropriate annotation is emitted.
+
+@<ValueAnnotation implementation@>=
+void ValueAnnotation::newMeasurement(Measurement measure)
+{
+	for(int i = 0; i < values.size(); i++)
+	{
+		if(measure.temperature() > values.at(i) - tolerance &&
+		   measure.temperature() < values.at(i) + tolerance)
+		{
+			if(i != lastIndex)
+			{
+				lastIndex = i;
+				emit annotation(annotations.at(i), measurementColumn, annotationColumn);
+			}
+		}
+	}
+}
+
+@ Another method is used to emit an annotation matching the current state at
+the start of a batch if that is desired. This will not produce any output if
+no state has yet been matched.
+
+@<ValueAnnotation implementation@>=
+void ValueAnnotation::annotate()
+{
+	if(lastIndex > -1)
+	{
+		emit annotation(annotations.at(lastIndex), measurementColumn, annotationColumn);
+	}
+}
+
+@ Values and annotations are added to separate lists with new mappings always
+appended. Entries are never removed from these lists.
+
+@<ValueAnnotation implementation@>=
+void ValueAnnotation::setAnnotation(double value, const QString &annotation)
+{
+	values.append(value);
+	annotations.append(annotation);
+}
+
+@ The remaining setter methods are trivial similarly trivial.
+
+@<ValueAnnotation implementation@>=
+void ValueAnnotation::setAnnotationColumn(int column)
+{
+	annotationColumn = column;
+}
+
+void ValueAnnotation::setTemperatureColumn(int column)
+{
+	measurementColumn = column;
+}
+
+void ValueAnnotation::setTolerance(double epsilon)
+{
+	tolerance = epsilon;
+}
+
+@ This just leaves a trivial constructor.
+
+@<ValueAnnotation implementation@>=
+ValueAnnotation::ValueAnnotation() : QObject(),
+	lastIndex(-1), annotationColumn(2), measurementColumn(1), tolerance(0.05)
+{
+	/* Nothing needs to be done here. */
+}
+
+@ This class is exposed to the host environment in the usual way. First with
+function prototypes.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructValueAnnotation(QScriptContext *context, QScriptEngine *engine);
+void setValueAnnotationProperties(QScriptValue value, QScriptEngine *engine);
+
+@ Then setting up a new property of the global object.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructValueAnnotation);
+value = engine->newQMetaObject(&ValueAnnotation::staticMetaObject, constructor);
+engine->globalObject().setProperty("ValueAnnotation", value);
+
+@ The implementation of the functions also proceeds as usual.
+
+@<Functions for scripting@>=
+QScriptValue constructValueAnnotation(QScriptContext *context, QScriptEngine *engine)
+{
+	QScriptValue object = engine->newQObject(new ValueAnnotation);
+	setValueAnnotationProperties(object, engine);
+	return object;
+}
+
+void setValueAnnotationProperties(QScriptValue value, QScriptEngine *engine)
+{
+	setQObjectProperties(value, engine);
+}