Merge branch 'issue75' into development

config/Windows/offline.xml

 					QSettings.setValue("script/lastDir", dir(filename));
 				}
 			});
-			var printMenu = findChildObject(this, 'print');			
+			var printMenu = findChildObject(this, 'print');
 			printMenu.triggered.connect(function() {
 				var exportWindow = createWindow("print");
 				exportWindow.windowTitle = "Typica - Print";
 			});
 			var showC = findChildObject(this, 'showC');
 			showC.triggered.connect(function() {
-				log.setDisplayUnits(TemperatureDisplay.Celsius);
+				log.setDisplayUnits(Units.Celsius);
 				graph.showC();
 			});
 			var showF = findChildObject(this, 'showF');
 			showF.triggered.connect(function() {
-				log.setDisplayUnits(TemperatureDisplay.Fahrenheit);
+				log.setDisplayUnits(Units.Fahrenheit);
 				graph.showF();
 			});
 			var v1 = findChildObject(this, 'ms');

config/Windows/productionroaster.xml

         showC.triggered.connect(function() {
 			for(var i = 0; i < temperatureDisplays.length; i++)
 			{
-				temperatureDisplays[i].setDisplayUnits(TemperatureDisplay.Celsius);
+				temperatureDisplays[i].setDisplayUnits(Units.Celsius);
 			}
-            log.setDisplayUnits(TemperatureDisplay.Celsius);
+            log.setDisplayUnits(Units.Celsius);
             graph.showC();
         });
         var showF = findChildObject(this, 'showF');
         showF.triggered.connect(function() {
 			for(var i = 0; i < temperatureDisplays.length; i++)
 			{
-				temperatureDisplays[i].setDisplayUnits(TemperatureDisplay.Fahrenheit);
+				temperatureDisplays[i].setDisplayUnits(Units.Fahrenheit);
 			}
-            log.setDisplayUnits(TemperatureDisplay.Fahrenheit);
+            log.setDisplayUnits(Units.Fahrenheit);
             graph.showF();
         });
 		var clear = findChildObject(this, 'clear');

config/Windows/profilehistory.xml

         v7.triggered.connect(log.LOD_1m);
 		var showC = findChildObject(this, 'showC');
 		showC.triggered.connect(function() {
-			log.setDisplayUnits(TemperatureDisplay.Celsius);
+			log.setDisplayUnits(Units.Celsius);
 			graph.showC();
 		});
 		var showF = findChildObject(this, 'showF');
 		showF.triggered.connect(function() {
-			log.setDisplayUnits(TemperatureDisplay.Fahrenheit);
+			log.setDisplayUnits(Units.Fahrenheit);
 			graph.showF();
 		});
 	]]>

src/Typica.pro

-######################################################################
-# Automatically generated by qmake (2.01a) Sat May 23 23:41:13 2009
-######################################################################
-
-QT += script
-QT += xml
-QT += sql
-QT += xmlpatterns
-QT += scripttools
-QT += webkit
-
-include(3rdparty/qextserialport/src/qextserialport.pri)
-
-TEMPLATE = app
-TARGET =
-DEPENDPATH += .
-
-# Input
-HEADERS += moc_typica.cpp \
-    helpmenu.h \
-    abouttypica.h
-SOURCES += typica.cpp \
-    helpmenu.cpp \
-    abouttypica.cpp
-
-RESOURCES += \
-    resources.qrc
-
-RC_FILE = typica.rc
-ICON = resources/icons/appicons/logo.icns
-QMAKE_INFO_PLIST = resources/Info.plist
+######################################################################
+# Automatically generated by qmake (2.01a) Sat May 23 23:41:13 2009
+######################################################################
+
+QT += script
+QT += xml
+QT += sql
+QT += xmlpatterns
+QT += scripttools
+QT += webkit
+
+include(3rdparty/qextserialport/src/qextserialport.pri)
+
+TEMPLATE = app
+TARGET =
+DEPENDPATH += .
+
+# Input
+HEADERS += moc_typica.cpp \
+    helpmenu.h \
+    abouttypica.h \
+    units.h
+SOURCES += typica.cpp \
+    helpmenu.cpp \
+    abouttypica.cpp \
+    units.cpp
+
+RESOURCES += \
+    resources.qrc
+
+RC_FILE = typica.rc
+ICON = resources/icons/appicons/logo.icns
+QMAKE_INFO_PLIST = resources/Info.plist

src/typica.w

 
 Measurement times are represented as instances of |QTime|.
 
-The declaration of |Measurement| is reasonably straightforward. Measurements
+@i units.w
+
+@ We will require the |units.h| header.
+
+@<Header files to include@>=
+#include "units.h"
+
+@ The declaration of |Measurement| is reasonably straightforward. Measurements
 will often be passed around to a number of different objects through the signals
 and slots mechanism of Qt. The simplest way to make this work is to provide a
 copy constructor and an assignment operator.
 @<Class declarations@>=
 class Measurement@/
 {
-	public:@/
-		enum TemperatureUnits
-		{
-			Fahrenheit = 10144,
-			Celsius = 10143,
-			Kelvin = 10325,
-			Rankine = 10145
-		};
-	private:@/
-		double theTemperature;
-		QTime theTime;
-		TemperatureUnits unit;
 	public:@;
 		Measurement(double temperature = 0, QTime time = QTime(),@|
-		            TemperatureUnits sc = Fahrenheit);
+		            Units::Unit sc = Units::Fahrenheit);
 		Measurement(double temperature);
 		Measurement(const Measurement &x);
 		Measurement& operator=(Measurement &x);
 		QTime time() const;
 		void setTemperature(double temperature);
 		void setTime(QTime time);
-		void setUnit(TemperatureUnits scale);
-		TemperatureUnits scale();
+		void setUnit(Units::Unit scale);
+		Units::Unit scale();
 		Measurement toFahrenheit();
 		Measurement toCelsius();
 		Measurement toKelvin();
 		Measurement toRankine();
+	private:@/
+		double theTemperature;
+		QTime theTime;
+		Units::Unit unit;
 };
 
 @ There are two constructors that can create |Measurement| objects. The
 
 @<Measurement implementation@>=
 Measurement::Measurement(double temperature, QTime time,
-                         TemperatureUnits sc) :@;
+                         Units::Unit sc) :@;
 	@t\kern2em@>theTemperature(temperature), theTime(time), unit(sc)@;
 {
 	/* Nothing has to be done here. */
 
 Measurement::Measurement(double temperature) :@;
 	@t\kern2em@>theTemperature(temperature), theTime(QTime::currentTime()),
-	unit(Fahrenheit)@;
+	unit(Units::Fahrenheit)@;
 {
 	/* Nothing has to be done here. */
 }@;
 method.
 
 @<Measurement implementation@>=
-void Measurement::setUnit(TemperatureUnits scale)
+void Measurement::setUnit(Units::Unit scale)
 {
 	unit = scale;
 }
 
-Measurement::TemperatureUnits Measurement::scale()
+Units::Unit Measurement::scale()
 {
 	return unit;
 }
 
 @ Four methods create a new |Measurement| from the object the method is called
-on representing the same measurement expressed in different units. The
-conversion formul\ae{} come from Wikipedia.\nfnote{%
-\pdfURL{Temperature Conversion}{%
-http://en.wikipedia.org/%
-w/index.php?title=Temperature_conversion&oldid=226047163}}
-
-The |toFahrenheit()| method converts a measurement to Fahrenheit.
+on representing the same measurement expressed in different units. The value
+conversions are handled in the |Units| class.
 
 @<Measurement implementation@>=
 Measurement Measurement::toFahrenheit()
 {
-	switch(unit)
-	{
-		case Celsius:
-			return Measurement(this->temperature() * 9 / 5 + 32, this->time(),
-			                   Fahrenheit);
-			break;
-		case Kelvin:
-			return Measurement(this->temperature() * 5 / 9 - 459.67,
-			                   this->time(), Fahrenheit);
-			break;
-		case Rankine:
-			return Measurement(this->temperature() - 459.67, this->time(),
-			                   Fahrenheit);
-			break;
-		default:
-			return Measurement(this->temperature(), this->time(), Fahrenheit);
-			break;
-	}
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->unit, Units::Fahrenheit),
+	                   this->time(), Units::Fahrenheit);
 }
 
-@ Similarly, the following converts to Celsius.
-
-@<Measurement implementation@>=
 Measurement Measurement::toCelsius()
 {
-	switch(unit)
-	{
-		case Fahrenheit:
-			return Measurement((this->temperature() - 32) * 5 / 9, this->time(),
-			                   Celsius);
-			break;
-		case Kelvin:
-			return Measurement(this->temperature() - 273.15, this->time(),
-			                   Celsius);
-			break;
-		case Rankine:
-			return Measurement((this->temperature() - 491.67) * 5 / 9,
-			                   this->time(), Celsius);
-			break;
-		default:
-			return Measurement(this->temperature(), this->time(), Celsius);
-			break;
-	}
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->unit, Units::Celsius),
+	                   this->time(), Units::Celsius);
 }
 
-@ For those who prefer absolute scales, a method is provided to convert to
-Kelvin.
-
-@<Measurement implementation@>=
 Measurement Measurement::toKelvin()
 {
-	switch(unit)
-	{
-		case Fahrenheit:
-			return Measurement((this->temperature() + 459.67) * 5 / 9,
-			                   this->time(), Kelvin);
-			break;
-		case Celsius:
-			return Measurement(this->temperature() + 273.15, this->time(),
-			                   Kelvin);
-			break;
-		case Rankine:
-			return Measurement(this->temperature() * 5 / 9, this->time(),
-			                   Kelvin);
-			break;
-		default:
-			return Measurement(this->temperature(), this->time(), Kelvin);
-			break;
-	}
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->unit, Units::Kelvin),
+	                   this->time(), Units::Kelvin);
 }
 
-@ Finally, conversion to Rankine is also allowed.
-
-@<Measurement implementation@>=
 Measurement Measurement::toRankine()
 {
-	switch(unit)
-	{
-		case Fahrenheit:
-			return Measurement(this->temperature() + 459.67, this->time(),
-			                   Rankine);
-			break;
-		case Celsius:
-			return Measurement((this->temperature() + 273.15) * 9 / 5,
-			                   this->time(), Rankine);
-			break;
-		case Kelvin:
-			return Measurement(this->temperature() * 9 / 5, this->time(),
-			                   Rankine);
-			break;
-		default:
-			return Measurement(this->temperature(), this->time(), Rankine);
-			break;
-	}
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->unit, Units::Rankine),
+	                   this->time(), Units::Rankine);
 }
 
 @** The Main Measurement Pipeline.
 class DAQ : public QObject@;@/
 {@t\1@>@/
 	Q_OBJECT@/
-	Q_ENUMS(TemperatureUnits)@/
 	Q_ENUMS(ThermocoupleType)@;@/
 	DAQImplementation *imp;@/
 	@t\4@>private slots@t\kern-3pt@>:@/
 		@[Q_INVOKABLE@,@, void@]@, setClockRate(double Hz);@t\2\2@>@/
 		@[Q_INVOKABLE@,@, void@]@, start();@t\2\2@>@/
 		@[Q_INVOKABLE@]@, void stop();
-		enum TemperatureUnits@/
-		{
-			@!Fahrenheit = 10144,
-			@!Celsius = 10143,
-			@!Kelvin = 10325,
-			@!Rankine = 10145
-		};
 		enum ThermocoupleType@/
 		{
 			@!TypeJ = 10072,
 int channels;
 bool ready;
 QLibrary driver;
-QVector<Measurement::TemperatureUnits> unitMap;
+QVector<Units::Unit> unitMap;
 
 @ Most of the interesting work associated with the |DAQ| class is handled in
 the |measure()| method of |DAQImplementation|. This function will block until a
 {
 	Channel *retval = new Channel();
 	imp->channelMap[imp->channels] = retval;
-	imp->unitMap[imp->channels] = (Measurement::TemperatureUnits)units;
+	imp->unitMap[imp->channels] = (Units::Unit)units;
 	imp->channels++;
 	if(imp->ready)
 	{
 QScriptValue DAQ_newChannel(QScriptContext *context, QScriptEngine *engine);
 void setDAQProperties(QScriptValue value, QScriptEngine *engine);
 
-@ First we make these functions known to the scripting engine.
+@ First we make these functions known to the scripting engine. We also add
+the values from |Units::Unit| as this was widely used in configurations
+before this enumeration was removed from the |DAQ| class. As these properties
+must be available without an instance, the properties must be added here.
 
 @<Set up the scripting engine@>=
 constructor = engine->newFunction(constructDAQ);
 value = engine->newQMetaObject(&DAQ::staticMetaObject, constructor);
+value.setProperty("Fahrenheit", Units::Fahrenheit);
+value.setProperty("Celsius", Units::Celsius);
+value.setProperty("Kelvin", Units::Kelvin);
+value.setProperty("Rankine", Units::Rankine);
 engine->globalObject().setProperty("DAQ", value);
 
 @ When creating a new |DAQ|, we make sure that it is owned by the script engine.
 class TemperatureDisplay : public QLCDNumber@/
 {@t\1@>@/
 	Q_OBJECT@;
-	Q_ENUMS(DisplayUnits)
 	int unit;
 	public:@/
-		enum DisplayUnits
-		{
-			Auto = -1,
-			Fahrenheit = 10144,
-			Celsius = 10143,
-			Kelvin = 10325,
-			Rankine = 10145
-		};
 		TemperatureDisplay(QWidget *parent = NULL);
 		~TemperatureDisplay();@/
 	@t\4@>public slots@t\kern-3pt@>:@/
 		void setValue(Measurement temperature);
 		void invalidate();
-		void setDisplayUnits(DisplayUnits scale);@t\2@>@/
+		void setDisplayUnits(Units::Unit scale);@t\2@>@/
 };
 
 @ Displaying a temperature is a simple matter of taking the temperature
 	QString number;
 	switch(unit)
 	{
-		case Auto:
-			switch(temperature.scale())
-			{
-				case Fahrenheit:
-					display(QString("%1'F").
-						arg(number.setNum(temperature.temperature(), 'f', 2)));
-					break;
-				case Celsius:
-					display(QString("%1'C").
-						arg(number.setNum(temperature.temperature(), 'f', 2)));
-					break;
-				case Kelvin:
-					display(QString("%1").
-						arg(number.setNum(temperature.temperature(), 'f', 2)));
-					break;
-				case Rankine:
-					display(QString("%1'r").
-						arg(number.setNum(temperature.temperature(), 'f', 2)));
-					break;
-			}
-			break;
-		case Fahrenheit:
+		case Units::Fahrenheit:
 			display(QString("%1'F").
 				arg(number.setNum(temperature.toFahrenheit().temperature(), 'f',
 				                  2)));
 			break;
-		case Celsius:
+		case Units::Celsius:
 			display(QString("%1'C").
 				arg(number.setNum(temperature.toCelsius().temperature(), 'f',
 				                  2)));
 			break;
-		case Kelvin:
+		case Units::Kelvin:
 			display(QString("%1").
 				arg(number.setNum(temperature.toKelvin().temperature(), 'f',
 				                  2)));
 			break;
-		case Rankine:
+		case Units::Rankine:
 			display(QString("%1'r").
 				arg(number.setNum(temperature.toRankine().temperature(), 'f',
 				                  2)));
 			break;
+		default:
+			switch(temperature.scale())
+			{
+				case Units::Fahrenheit:
+					display(QString("%1'F").
+						arg(number.setNum(temperature.temperature(), 'f', 2)));
+					break;
+				case Units::Celsius:
+					display(QString("%1'C").
+						arg(number.setNum(temperature.temperature(), 'f', 2)));
+					break;
+				case Units::Kelvin:
+					display(QString("%1").
+						arg(number.setNum(temperature.temperature(), 'f', 2)));
+					break;
+				case Units::Rankine:
+					display(QString("%1'r").
+						arg(number.setNum(temperature.temperature(), 'f', 2)));
+					break;
+			}
+			break;
 	}
 }
 
 
 @<TemperatureDisplay Implementation@>=
 TemperatureDisplay::TemperatureDisplay(QWidget *parent) :
-	QLCDNumber(8, parent), unit(Auto)@/
+	QLCDNumber(8, parent), unit(Units::Fahrenheit)@/
 {
 	setSegmentStyle(Filled);
 	display("---.--'F");
 prior to display.
 
 @<TemperatureDisplay Implementation@>=
-void TemperatureDisplay::setDisplayUnits(DisplayUnits scale)
+void TemperatureDisplay::setDisplayUnits(Units::Unit scale)
 {
 	unit = scale;
 }
 QScriptValue constructTemperatureDisplay(QScriptContext *context,
                                          QScriptEngine *engine);
 void setTemperatureDisplayProperties(QScriptValue value, QScriptEngine *engine);
+QScriptValue TemperatureDisplay_setDisplayUnits(QScriptContext *context,
+                                                QScriptEngine *engine);
 
 @ The scripting engine must be informed of this function.
 
 void setTemperatureDisplayProperties(QScriptValue value, QScriptEngine *engine)
 {
 	setQLCDNumberProperties(value, engine);
+	value.setProperty("setDisplayUnits",
+	                  engine->newFunction(TemperatureDisplay_setDisplayUnits));
+}
+
+@ There seems to be a bad interaction when enumerated value types as used as
+the argument to slot methods called through QtScript. Script code that attempts
+to make use of the enumeration appears to get the value without any type
+information. When attempting to use that value as an argument the meta-object
+system cannot find an appropriate match and the script just hangs silently.
+The solution is to wrap such methods in the script bindings and explicitly cast
+the argument value to the enumerated type. This looks stupid but it works.
+
+@<Functions for scripting@>=
+QScriptValue TemperatureDisplay_setDisplayUnits(QScriptContext *context, QScriptEngine *)
+{
+	TemperatureDisplay *self = getself<@[TemperatureDisplay *@]>(context);
+	self->setDisplayUnits((Units::Unit)argument<int>(0, context));
+	return QScriptValue();
 }
 
 @* The MeasurementTimeOffset class.
 		bool saveXML(QIODevice *device);
 		bool saveCSV(QIODevice *device);
 		QString lastTime(int series);
-		@[Q_INVOKABLE@,@, int displayUnits()@];@t\2\2@>@/
+		@[Q_INVOKABLE@,@, Units::Unit displayUnits()@];@t\2\2@>@/
 	@[public slots@]:@/
 		void setVisible(bool visibility);
 		void setHeaderData(int section, QString text);
 		void addOutputTemperatureColumn(int column);
 		void addOutputAnnotationColumn(int column);
 		void clearOutputColumns();
-		void setDisplayUnits(int scale);
+		void setDisplayUnits(Units::Unit scale);
 		void addToCurrentColumnSet(int column);
 		void clearCurrentColumnSet();@/
 	protected:@/
 @<ZoomLog Implementation@>=
 bool ZoomLog::saveXML(QIODevice *device)
 {
-	int prevUnits = model_ms->displayUnits();
-	if(prevUnits != 10144)
+	Units::Unit prevUnits = model_ms->displayUnits();
+	if(prevUnits != Units::Fahrenheit)
 	{
-		model_ms->setDisplayUnits(10144);
+		model_ms->setDisplayUnits(Units::Fahrenheit);
 	}
 	XMLOutput writer(model_ms, device, 0);
 	int c;
 		                                     toString(), c);
 	}
 	bool retval = writer.output();
-	if(prevUnits != 10144)
+	if(prevUnits != Units::Fahrenheit)
 	{
 		model_ms->setDisplayUnits(prevUnits);
 	}
 possible to obtain the currently selected unit.
 
 @<ZoomLog Implementation@>=
-void ZoomLog::setDisplayUnits(int scale)
+void ZoomLog::setDisplayUnits(Units::Unit scale)
 {
 	model_ms->setDisplayUnits(scale);
 	model_1s->setDisplayUnits(scale);
 	model_1m->setDisplayUnits(scale);
 }
 
-int ZoomLog::displayUnits()
+Units::Unit ZoomLog::displayUnits()
 {
 	return model_ms->displayUnits();
 }
 QScriptValue ZoomLog_lastTime(QScriptContext *context, QScriptEngine *engine);
 QScriptValue ZoomLog_saveTemporary(QScriptContext *context,
                                    QScriptEngine *engnie);
+QScriptValue ZoomLog_setDisplayUnits(QScriptContext *context,
+                                     QScriptEngine *engine);
 
 @ Of these, the global object only needs to know about the constructor.
 
 	value.setProperty("lastTime", engine->newFunction(ZoomLog_lastTime));
 	value.setProperty("saveTemporary",
 	                  engine->newFunction(ZoomLog_saveTemporary));
+	value.setProperty("setDisplayUnits", engine->newFunction(ZoomLog_setDisplayUnits));
 }
 
 @ The functions for saving data are simple wrappers around the corresponding
 	return QScriptValue(engine, self->lastTime(argument<int>(0, context)));
 }
 
+@ There seems to be a bad interaction when enumerated value types as used as
+the argument to slot methods called through QtScript. Script code that attempts
+to make use of the enumeration appears to get the value without any type
+information. When attempting to use that value as an argument the meta-object
+system cannot find an appropriate match and the script just hangs silently.
+The solution is to wrap such methods in the script bindings and explicitly cast
+the argument value to the enumerated type. This looks stupid but it works.
+
+@<Functions for scripting@>=
+QScriptValue ZoomLog_setDisplayUnits(QScriptContext *context, QScriptEngine *)
+{
+	ZoomLog *self = getself<@[ZoomLog *@]>(context);
+	self->setDisplayUnits((Units::Unit)argument<int>(0, context));
+	return QScriptValue();
+}
+
 @* A model for roasting data.
 
 \noindent Qt provides a tool called the model view architecture. This provides a
 class MeasurementModel : public QAbstractItemModel@/
 {@t\1@>@/
 	Q_OBJECT@;
-	Q_ENUMS(DisplayUnits);
-	int unit;
+	Units::Unit unit;
 	QList<MeasurementList *> *entries;
 	QStringList *hData;
 	int colcount;
 	QHash<int, int> *lastTemperature;
 	QList<MeasurementList *>::iterator@, lastInsertion;
 	public:@/
-		enum DisplayUnits
-		{
-			Auto = -1,
-			Fahrenheit = 10144,
-			Celsius = 10143,
-			Kelvin = 10325,
-			Rankine = 10145
-		};
 		MeasurementModel(QObject *parent = NULL);
 		~MeasurementModel();
 		int rowCount(const QModelIndex &parent = QModelIndex()) const;
 		QModelIndex index(int row, int column,
 							const QModelIndex &parent = QModelIndex()) const;
 		QModelIndex parent(const QModelIndex &index) const;
-		int displayUnits();@/
+		Units::Unit displayUnits();@/
 	@t\4@>public slots@t\kern-3pt@>:@/
 		void newMeasurement(Measurement measure, int tempcolumn);
 		void newAnnotation(QString annotation, int tempcolumn,
 							int annotationColumn);
 		void clear();
-		void setDisplayUnits(int scale);
+		void setDisplayUnits(Units::Unit scale);
 	signals:@/
 		void rowChanged(int);@t\2@>@/
 }@t\kern-3pt@>;
 
 @<MeasurementModel Implementation@>=
 MeasurementModel::MeasurementModel(QObject *parent) : QAbstractItemModel(parent),
-	unit(Fahrenheit), hData(new QStringList),
+	unit(Units::Fahrenheit), hData(new QStringList),
 	lastTemperature(new QHash<int, int>)@/
 {
 	colcount = 1;
 available to request a number identifyin the currently displayed units.
 
 @<MeasurementModel Implementation@>=
-void MeasurementModel::setDisplayUnits(int scale)
+void MeasurementModel::setDisplayUnits(Units::Unit scale)
 {
 	beginResetModel();
 	unit = scale;
 	endResetModel();
 }
 
-int MeasurementModel::displayUnits()
+Units::Unit MeasurementModel::displayUnits()
 {
 	return unit;
 }
 				}
 				switch(unit)
 				{
-					case Auto:
-					case Fahrenheit:
+					case Units::Fahrenheit:
 						return QVariant(row->at(index.column()).toString());
 						break;
-					case Celsius:
+					case Units::Celsius:
 						return QVariant((row->at(index.column()).toDouble() -
 						                32) * 5 / 9);
 						break;
-					case Kelvin:
+					case Units::Kelvin:
 						return QVariant((row->at(index.column()).toDouble() +
 						                459.67) * 5 / 9);
 						break;
-					case Rankine:
+					case Units::Rankine:
 						return QVariant(row->at(index.column()).toDouble() +
 						                459.67);
 						break;
 					default:
+						return QVariant(row->at(index.column()).toString());
 						break;
 				}
 			}
 	pvOut = pvOut * 9 / 5 + 32;
 	svOut = svOut * 9 / 5 + 32;
 }
-Measurement pvm(pvOut, time, Measurement::Fahrenheit);
-Measurement svm(svOut, time, Measurement::Fahrenheit);
+Measurement pvm(pvOut, time, Units::Fahrenheit);
+Measurement svm(svOut, time, Units::Fahrenheit);
 channels.at(0)->input(pvm);
 channels.at(1)->input(svm);
 
 }
 if(!svenabled)
 {
-	Measurement vm(valueOut, time, Measurement::Fahrenheit);
+	Measurement vm(valueOut, time, Units::Fahrenheit);
 	channels.at(0)->input(vm);
 }
 else
 {
 	if(readingsv)
 	{
-		Measurement pvm(savedpv, time, Measurement::Fahrenheit);
-		Measurement svm(valueOut, time, Measurement::Fahrenheit);
+		Measurement pvm(savedpv, time, Units::Fahrenheit);
+		Measurement svm(valueOut, time, Units::Fahrenheit);
 		channels.at(0)->input(pvm);
 		channels.at(1)->input(svm);
 		readingsv = false;

src/units.w

+@* Unit information.
+
+\noindent As unit information is required in several places, the enumeration
+listing these is moved to an external class. This derives from QObject only to
+take advantage of the meta-object system. There are no data members, however
+there are some convenience methods for working with unit data.
+
+@(units.h@>=
+#include <QObject>
+
+#ifndef TypicaUnitsIncluded
+#define TypicaUnitsIncluded
+
+class Units: public QObject
+{
+	Q_OBJECT
+	Q_ENUMS(Unit)
+	public:
+		enum Unit
+		{
+			Fahrenheit = 10144,
+			Celsius = 10143,
+			Kelvin = 10325,
+			Rankine = 10145
+		};
+		static double convertTemperature(double value, Unit fromUnit, Unit toUnit);
+		static bool isTemperatureUnit(Unit unit);
+};
+
+#endif
+
+@ Methods are implemented in a separate file.
+
+@(units.cpp@>=
+#include "units.h"
+#include "moc_units.cpp"
+
+@ The |isTemperatureUnit()| method may seem counter-intuitive while the enum
+only contains represenations of temperature measurements, but there are plans
+to extend this later to extend hardware support to devices that do not directly
+measure temperature values and also to support the measurement of properties
+that cannot sensibly be represented as temperatures such as fuel pressure and
+control settings.
+
+@(units.cpp@>=
+bool Units::isTemperatureUnit(Unit unit)
+{
+	if(unit == Fahrenheit ||
+	   unit == Celsius ||
+	   unit == Kelvin ||
+	   unit == Rankine)
+	{
+		return true;
+	}
+	return false;
+}
+
+@ Temperature conversions can be performed by the |Units| class and should
+eliminate the need to have conversion code in multiple places. This method
+takes the measurement value, the unit that value is in, and the unit that we
+would like to have the measurement converted into. It returns the value as it
+would be expressed after unit conversion. A value of 0 is presently returned
+if either or both of the units to convert are not temperature units, however
+that behavior may change in the future. Any code activating that branch should
+be considered flawed.
+
+@(units.cpp@>=
+double Units::convertTemperature(double value, Unit fromUnit, Unit toUnit)
+{
+	if(isTemperatureUnit(fromUnit) && isTemperatureUnit(toUnit) == false)
+	{
+		return 0;
+	}
+	switch(fromUnit)
+	{
+		case Fahrenheit:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value;
+					break;
+				case Celsius:
+					return (value - 32) * 5 / 9;
+					break;
+				case Kelvin:
+					return (value + 459.67) * 5 / 9;
+					break;
+				case Rankine:
+					return value + 459.67;
+					break;
+			}
+			break;
+		case Celsius:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value * 9 / 5 + 32;
+					break;
+				case Celsius:
+					return value;
+					break;
+				case Kelvin:
+					return value + 273.15;
+					break;
+				case Rankine:
+					return (value + 273.15) * 9 / 5;
+					break;
+			}
+			break;
+		case Kelvin:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value * 5 / 9 - 459.67;
+					break;
+				case Celsius:
+					return value - 273.15;
+					break;
+				case Kelvin:
+					return value;
+					break;
+				case Rankine:
+					return value * 9 / 5;
+					break;
+			}
+			break;
+		case Rankine:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value - 457.67;
+					break;
+				case Celsius:
+					return (value - 491.67) * 5 / 9;
+					break;
+				case Kelvin:
+					return value * 5 / 9;
+					break;
+				case Rankine:
+					return value;
+					break;
+			}
+			break;
+		default:
+			return 0;
+			break;
+	}
+	return 0;
+}
+
+@ 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.
+
+@<Set up the scripting engine@>=
+value = engine->newQMetaObject(&Units::staticMetaObject);
+engine->globalObject().setProperty("Units", value);
+