Merge branch 'scale' into development

config/Windows/newbatch.xml

@@ -2,6 +2,7 @@
     <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>
@@ -53,6 +54,12 @@
             <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');
@@ -77,6 +84,40 @@
             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

@@ -75,6 +75,7 @@
 		var rateoffsets = new Array();
 		var ratezeros = new Array();
 		var channelType = new Array();
+		window.scales = new Array();
 		var indicatorPanel = findChildObject(this, 'indicators');
 		var annotationPanel = findChildObject(this, 'controlpanel');
 		var log = findChildObject(this, 'log');
@@ -488,6 +489,17 @@
 						}
 					}
 				}
+				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++)

src/Typica.pro

@@ -21,13 +21,17 @@ HEADERS += moc_typica.cpp \
     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/scales.w

@@ -0,0 +1,498 @@
+@** 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

@@ -839,6 +839,7 @@ generated file empty.
 @<SettingsWindow implementation@>@/
 @<GraphSettingsWidget implementation@>@/
 @<DataqSdkDeviceConfWidget implementation@>@/
+@<SerialScaleConfWidget implementation@>@/
 
 @ A few headers are required for various parts of \pn{}. These allow the use of
 various Qt modules.
@@ -976,6 +977,16 @@ template<> QModelIndex argument(int arg, QScriptContext *context)
 	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
@@ -12119,7 +12130,7 @@ Qt::ItemFlags SaltModel::flags(const QModelIndex &index) const
 	@<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;
 }
@@ -15782,7 +15793,11 @@ PortSelector::PortSelector(QWidget *parent) : QComboBox(parent),
 	QextPortInfo port;
 	foreach(port, ports)
 	{
+#ifdef Q_OS_WIN32
 		addItem(port.portName);
+#else
+		addItem(port.physName);
+#endif
 	}
 	lister->setUpNotifications();
 	connect(lister, SIGNAL(deviceDiscovered(QextPortInfo)),
@@ -18368,6 +18383,8 @@ app.registerDeviceConfigurationWidget("translation", TranslationConfWidget::stat
 
 @i dataqsdk.w
 
+@i scales.w
+
 @** Local changes.
 
 \noindent This is the end of \pn{} as distributed by its author. It is expected

src/units.w

@@ -22,11 +22,17 @@ class Units: public QObject
 			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
@@ -175,6 +181,9 @@ double Units::convertRelativeTemperature(double value, Unit fromUnit, Unit toUni
 				case Rankine:
 					return value;
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		case Celsius:
@@ -192,6 +201,9 @@ double Units::convertRelativeTemperature(double value, Unit fromUnit, Unit toUni
 				case Rankine:
 					return value * (9.0 / 5.0);
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		case Kelvin:
@@ -209,6 +221,9 @@ double Units::convertRelativeTemperature(double value, Unit fromUnit, Unit toUni
 				case Rankine:
 					return value * (9.0 / 5.0);
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		case Rankine:
@@ -226,6 +241,9 @@ double Units::convertRelativeTemperature(double value, Unit fromUnit, Unit toUni
 				case Rankine:
 					return value;
 					break;
+				default:
+					return 0;
+					break;
 			}
 			break;
 		default:
@@ -235,11 +253,207 @@ double Units::convertRelativeTemperature(double value, Unit fromUnit, Unit toUni
 	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);
+