Phidget22 current channel support

Includes configuring current channels, reading current channel data, and allows some additional flexibility in numeric displays.

src/phidget22.w

 
 API differences are significant enough that it makes more sense to write new
 code for interacting with phidget22 than attempting to retrofit existing
-phidget21 code. By leaving both in, there is no configuration disription for
+phidget21 code. By leaving both in, there is no configuration disruption for
 people already using hardware previously supported and it is possible to use
 both libraries simultaneously to communicate with different hardware.
 
 	PhidgetConfWidget::staticMetaObject);
 app.registerDeviceConfigurationWidget("phidgetchannel",
 	PhidgetChannelConfWidget::staticMetaObject);
+app.registerDeviceConfigurationWidget("phidgetcurrentchannel",
+	PhidgetCurrentChannelConfWidget::staticMetaObject);
 
 @ The first configuration widget just serves as a parent to all channels using
 this library. There does not seem to be a need for the configuration to mirror
 	public:
 		Q_INVOKABLE PhidgetConfWidget(DeviceTreeModel *model,
 		                              const QModelIndex &index);
-	private slots:
-		void addChannel();
 };
 
 @ The only thing this configuration widget provides is a way to create child
 nodes.
 
+Originally, this only supported channels that use the TemperatureInput API.
+With the addition of support for other input types, the decision was made to
+give each channel type its own node type and configuration widget rather than
+attempt to cram every configuration option for all supported types into the
+same configuration control.
+
 @<Phidget implementation@>=
 PhidgetConfWidget::PhidgetConfWidget(DeviceTreeModel *model,
                                      const QModelIndex &index)
 {
 	QHBoxLayout *layout = new QHBoxLayout;
 	QPushButton *addChannelButton = new QPushButton(tr("Add Channel"));
-	connect(addChannelButton, SIGNAL(clicked()), this, SLOT(addChannel()));
+	QMenu *channelTypeMenu = new QMenu;
+	NodeInserter *temperatureChannel =
+		new NodeInserter(tr("Temperature Channel"),
+		tr("Temperature Channel"), "phidgetchannel");
+	connect(temperatureChannel, SIGNAL(triggered(QString, QString)),
+	        this, SLOT(insertChildNode(QString, QString)));
+	channelTypeMenu->addAction(temperatureChannel);
+	NodeInserter *currentChannel =
+		new NodeInserter(tr("Current Channel"),
+		tr("Current Channel"), "phidgetcurrentchannel");
+	connect(currentChannel, SIGNAL(triggered(QString, QString)),
+	        this, SLOT(insertChildNode(QString, QString)));
+	channelTypeMenu->addAction(currentChannel);
+	addChannelButton->setMenu(channelTypeMenu);	
 	layout->addWidget(addChannelButton);
 	setLayout(layout);
 }
 
-void PhidgetConfWidget::addChannel()
-{
-	insertChildNode(tr("Channel"), "phidgetchannel");
-}
-
 @ For this library, \pn{} supports a broader range of hardware. This requires
 slightly more involved hardware configuration to ensure that a given channel
 configuration consistently refers to the same sensor.
 built in ambient temperature sensors on some devices do not require additional
 configuration.
 
-At present, only temperature sensors are supported, however this code could be
-extended to support other options.
-
 To simplify configuration, a combo box is provided which displays all of the
 currently connected channels that \pn{} supports and allows a configuration
 widget to obtain relevant channel information when the desired channel is
 selected.
 
+By passing an optional channel type into the constructor, this will only
+display channels matching the specified type. Some potentially interesting
+channel types incude:
+
+\medskip
+
+\settabs 4 \columns
+
+\+&2&Current Input\cr
+\+&5&Digital Input\cr
+\+&6&Digital Output\cr
+\+&28&Temperature Input\cr
+\+&29&Voltage Input\cr
+\+&30&Voltage Output\cr
+\+&38&Current Output\cr
+\smallskip
+
+\centerline{Table \secno: A Selection of Phidget Channel Types}
+
+\medskip
+
 @<Class declarations@>=
 class PhidgetChannelSelector : public QComboBox
 {
 	Q_OBJECT
-	public:
-		PhidgetChannelSelector();
+	public:@/
+		PhidgetChannelSelector(int channeltype = 0);
 		~PhidgetChannelSelector();
 		void addChannel(void *device);
 		void removeChannel(void *device);
-	private:
+	private:@/
+		int typefilter;
 		QLibrary driver;
 		void *manager;
 		@<Phidget22 function pointers@>@;
 typedef int (CCONV *PhidgetPointerIntOut)(void *, int *);
 typedef void (CCONV *PhidgetManagerCallback)(void *, void *, void *);
 typedef void (CCONV *PhidgetValueCallback)(void *, void *, double);
+typedef void (CCONV *PhidgetErrorCallback)(void *, void *, int, const char *);
 typedef int (CCONV *PhidgetPointerCallbackPointer)(void *,
                                                    PhidgetManagerCallback,
                                                    void *);
                                              PhidgetValueCallback,
                                              void *);
 typedef int (CCONV *PhidgetPointerIntIn)(void *, int);
+typedef int (CCONV *PhidgetPointerECPointer)(void *, PhidgetErrorCallback,
+                                              void *);
 
 @ These are used to define function pointers that will be used to
 communicate with the library.
 the combo box.
 
 @<Phidget implementation@>=
-PhidgetChannelSelector::PhidgetChannelSelector() : QComboBox(), manager(NULL)
+PhidgetChannelSelector::PhidgetChannelSelector(int channeltype) :
+	QComboBox(), typefilter(channeltype), manager(NULL)
 {
 #if __APPLE__
 	driver.setFileName("Phidget22.framework/Phidget22");
 	
 	QMap<QString,QVariant> itemData;
 	
-	if(channelClass == 28) // Temperature sensor
+	if(typefilter != 0 && channelClass == typefilter)
 	{
 		itemData.insert("serialNumber", QString("%1").arg(deviceSerialNumber));
 		itemData.insert("channel", QString("%1").arg(channel));
 		itemData.insert("class", QString("%1").arg(channelClass));
-		itemData.insert("subclass", QString("%1").arg(channelSubclass));
+		itemData.insert("subclass", 
+		                QString("%1").arg(channelSubclass));
 		itemData.insert("hubport", QString("%1").arg(hubPort));
-		addItem(QString("%1: %2").arg(deviceName).arg(channel), QVariant(itemData));
+		addItem(QString("%1: %2").arg(deviceName).arg(channel),
+		        QVariant(itemData));
 	}
 }
 
                                                    
 @ Channel configuration provides a |PhidgetChannelSelector| for choosing
 among connected devices but also displays the relevant configuration data.
+
+This class only deals with temperature channels as that was the only channel
+type originally supported. Other configuration classes should be used for
+other channel types to allow type specific configuration options to be
+presented sensibly.
                                                    
 @<Class declarations@>=
 class PhidgetChannelConfWidget : public BasicDeviceConfigurationWidget
 PhidgetChannelConfWidget::PhidgetChannelConfWidget(DeviceTreeModel *model,
                                                    const QModelIndex &index)
 	: BasicDeviceConfigurationWidget(model, index),
-	channelSelector(new PhidgetChannelSelector),
+	channelSelector(new PhidgetChannelSelector(28)),
 	serialNumber(new QLineEdit),
 	channel(new QLineEdit),
 	hubPort(new QLineEdit),
 	updateAttribute("hidden", value == 0 ? "false" : "true");
 }
 
+@ The current input channel is intended for devices that can measure 4-20mA
+current signals. The output from such a channel is likely to be hidden and
+redirected to something that bring those measurements into whatever scale the
+signal represents. For example, the motivating hardware for this feature was a
+device that used 4-20mA to represent an approximation of the Agtron Gourmet
+Scale in the range of 25-95. Another potential use is measuring gas pressure,
+in which case it would be desirable to present this in terms of an appropriate
+pressure unit. Longer term it would be nice to add support for custom units and
+allow different graphing configurations for different units.
+
+@<Class declarations@>=
+class PhidgetCurrentChannelConfWidget : BasicDeviceConfigurationWidget
+{
+	Q_OBJECT@;
+	public:@/
+		Q_INVOKABLE PhidgetCurrentChannelConfWidget(DeviceTreeModel *model,
+		                                            const QModelIndex &index);
+	public slots:@/
+		void changeSelectedChannel(int index);
+		void updateSerialNumber(const QString &value);
+		void updateChannel(const QString &value);
+		void updateHubPort(const QString &value);
+		void updateColumnName(const QString &value);
+		void updatePowerSupply(int value);
+		void updateDataInterval(int value);
+		void updateHidden(int value);
+	private:@/
+		PhidgetChannelSelector *channelSelector;
+		QLineEdit *serialNumber;
+		QLineEdit *channel;
+		QLineEdit *hubPort;
+		QComboBox *powerSupply;
+};
+
+@ The constructor is responsible for setting up the interface. This is
+slightly simpler than the configuration for temperature inputs as instead of
+requiring information about RTD types and wiring or thermocouple types, a
+current input only requires selecting the power supply and data interval.
+
+It might be a good idea to go back to the temperature channels and allow the
+data interval to be set there as well instead of relying on the default
+sample rate.
+
+@<Phidget implementation@>=
+PhidgetCurrentChannelConfWidget::PhidgetCurrentChannelConfWidget(
+	DeviceTreeModel *model, const QModelIndex &index
+) :
+	BasicDeviceConfigurationWidget(model, index),
+	channelSelector(new PhidgetChannelSelector(2)),
+	serialNumber(new QLineEdit),
+	channel(new QLineEdit),
+	hubPort(new QLineEdit),
+	powerSupply(new QComboBox)
+{
+	QFormLayout *layout = new QFormLayout;
+	layout->addRow(tr("Channel:"), channelSelector);
+	QLineEdit *columnName = new QLineEdit;
+	layout->addRow(tr("Column Name:"), columnName);
+	powerSupply->addItem(tr("12V"), QVariant(2));
+	powerSupply->addItem(tr("24V"), QVariant(3));
+	layout->addRow(tr("Power Supply:"), powerSupply);
+	QSpinBox *dataInterval = new QSpinBox;
+	dataInterval->setMinimum(20);
+	dataInterval->setMaximum(1000);
+	dataInterval->setValue(250);
+	layout->addRow(tr("Data Interval:"), dataInterval);
+	QCheckBox *hidden = new QCheckBox(tr("Hide channel"));
+	layout->addRow(hidden);
+	serialNumber->setEnabled(false);
+	channel->setEnabled(false);
+	hubPort->setEnabled(false);
+	layout->addRow(tr("Serial Number:"), serialNumber);
+	layout->addRow(tr("Channel Number:"), channel);
+	layout->addRow(tr("Hub Port:"), hubPort);
+	@<Get device configuration data for current node@>@;
+	for(int i = 0; i < configData.size(); i++)
+	{
+		node = configData.at(i).toElement();
+		if(node.attribute("name") == "serialnumber")
+		{
+			serialNumber->setText(node.attribute("value"));
+		}
+		else if(node.attribute("name") == "channel")
+		{
+			channel->setText(node.attribute("value"));
+		}
+		else if(node.attribute("name") == "columnname")
+		{
+			columnName->setText(node.attribute("value"));
+		}
+		else if(node.attribute("name") == "hidden")
+		{
+			hidden->setCheckState(node.attribute("value") == "true" ?
+				Qt::Checked : Qt::Unchecked);
+		}
+		else if(node.attribute("name") == "powersupply")
+		{
+			powerSupply->setCurrentIndex(
+				powerSupply->findData(
+					QVariant(node.attribute("value").toInt())));
+		}
+		else if(node.attribute("name") == "datainterval")
+		{
+			dataInterval->setValue(node.attribute("value").toInt());
+		}
+	}
+	setLayout(layout);
+	updateSerialNumber(serialNumber->text());
+	updateChannel(channel->text());
+	updateColumnName(columnName->text());
+	updateHubPort(hubPort->text());
+	updateHidden(hidden->checkState());
+	updatePowerSupply(powerSupply->currentIndex());
+	updateDataInterval(dataInterval->value());
+	connect(channelSelector, SIGNAL(currentIndexChanged(int)),
+	        this, SLOT(changeSelectedChannel(int)));
+	connect(serialNumber, SIGNAL(textChanged(QString)),
+	        this, SLOT(updateSerialNumber(QString)));
+	connect(channel, SIGNAL(textChanged(QString)),
+	        this, SLOT(updateChannel(QString)));
+	connect(columnName, SIGNAL(textChanged(QString)),
+	        this, SLOT(updateColumnName(QString)));
+	connect(hubPort, SIGNAL(textChanged(QString)),
+	        this, SLOT(updateHubPort(QString)));
+	connect(hidden, SIGNAL(stateChanged(int)),
+	        this, SLOT(updateHidden(int)));
+	connect(powerSupply, SIGNAL(currentIndexChanged(int)),
+	        this, SLOT(updatePowerSupply(int)));
+	connect(dataInterval, SIGNAL(valueChanged(int)),
+	        this, SLOT(updateDataInterval(int)));
+}
+
+@ The combo box is responsible for setting a variety of required configuration
+fields with values the user has no reasonable expectation of knowing.
+
+@<Phidget implementation@>=
+void PhidgetCurrentChannelConfWidget::changeSelectedChannel(int index)
+{
+	QMap<QString, QVariant> data = channelSelector->itemData(index).toMap();
+	serialNumber->setText(data.value("serialNumber").toString());
+	channel->setText(data.value("channel").toString());
+	hubPort->setText(data.value("hubport").toString());
+}
+
+@ Channel configuration settings are persisted as they are updated as usual.
+
+@<Phidget implementation@>=
+void PhidgetCurrentChannelConfWidget::updateSerialNumber(const QString &value)
+{
+	updateAttribute("serialnumber", value);
+}
+
+void PhidgetCurrentChannelConfWidget::updateChannel(const QString &value)
+{
+	updateAttribute("channel", value);
+}
+
+void PhidgetCurrentChannelConfWidget::updateColumnName(const QString &value)
+{
+	updateAttribute("columnname", value);
+}
+
+void PhidgetCurrentChannelConfWidget::updateHubPort(const QString &value)
+{
+	updateAttribute("hubport", value);
+}
+
+void PhidgetCurrentChannelConfWidget::updateHidden(int value)
+{
+	updateAttribute("hidden", value == 0 ? "false" : "true");
+}
+
+void PhidgetCurrentChannelConfWidget::updatePowerSupply(int value)
+{
+	updateAttribute("powersupply", powerSupply->itemData(value).toString());
+}
+
+void PhidgetCurrentChannelConfWidget::updateDataInterval(int value)
+{
+	updateAttribute("datainterval", QString("%1").arg(value));
+}
+
 @ The hardware communnications code provides a single class that reads the
 saved configuration data, creates |Channel| objects for the logging view to
 connect various things to, and pushes data out on those channels. Internally,
 	QString indicatorLabel;
 	int serialNumber;
 	int channelNumber;
+	int majorType;
 	int channelType;
 	int hubPort;
+	int dataInterval;
+	// Set for temperature channels
 	int tcType;
 	int rtdType;
 	int wiring;
+	// Set for current channels
+	int powerSupply;
+	// Non-specialized
 	bool hidden;
 	void *device;
 };
 		Q_INVOKABLE bool isChannelHidden(int channel);
 		Q_INVOKABLE QString channelColumnName(int channel);
 		Q_INVOKABLE QString channelIndicatorText(int channel);
+		Q_INVOKABLE QString channelType(int channel);
 	public slots:
 		void start();
 		void stop();
 		QList<PhidgetChannelData *> channelConfiguration;
 		QLibrary driver;
 		PhidgetPointer p_createTemperatureSensor;
+		PhidgetPointer p_createCurrentSensor;
 		PhidgetPointerIntIn p_setSerialNumber;
 		PhidgetPointerIntIn p_setChannelNumber;
 		PhidgetPointerIntIn p_setHubPort;
 		PhidgetPointerIntIn p_setTCType;
 		PhidgetPointerIntIn p_setRTDType;
 		PhidgetPointerIntIn p_setRTDWiring;
+		PhidgetPointerIntIn p_setCurrentPowerSupply;
+		PhidgetPointerIntIn p_setCurrentDataInterval;
 		PhidgetPointerVCPointer p_setNewDataCallback;
+		PhidgetPointerVCPointer p_setCurrentNewDataCallback;
 		PhidgetPointerIntIn p_open;
 		PhidgetPointer p_close;
 		PhidgetPointer p_delete;
+		PhidgetPointerECPointer p_setOnErrorCallback;
 };
 
 @ The constructor reads the previously saved hardware configuration data and
 				model->data(channelIndex, Qt::DisplayRole).toString();
 			c->device = NULL;
 			c->hubPort = -1;
+			c->dataInterval = -1;
+			c->powerSupply = -1;
+			if(channelReferenceElement.attribute("driver") == "phidgetchannel")
+			{
+				c->majorType = 28; // Temperature Input
+			}
+			else if(channelReferenceElement.attribute("driver") ==
+			        "phidgetcurrentchannel")
+			{
+				c->majorType = 2; // Current Input
+			}
 			for(int j = 0; j < channelConfigData.size(); j++)
 			{
 				QDomElement node = channelConfigData.at(j).toElement();
 				{
 					c->wiring = node.attribute("value").toInt();
 				}
+				else if(node.attribute("name") == "powersupply")
+				{
+					c->powerSupply = node.attribute("value").toInt();
+				}
+				else if(node.attribute("name") == "datainterval")
+				{
+					c->dataInterval = node.attribute("value").toInt();
+				}
 				else if(node.attribute("name") == "hidden")
 				{
 					c->hidden = (node.attribute("value") == "true");
 	return channelConfiguration.at(channel)->indicatorLabel;
 }
 
+QString Phidget22::channelType(int channel)
+{
+	return (channelConfiguration.at(channel)->majorType == 28 ? "T" : "C");
+}
+
 @ Once the hardware configuration has been read and the UI has been set up, we
 can start talking to the hardware and start getting measurements.
 
+Now that multiple channel types are supported which each require slightly
+different initialization procedures, it would be nice to see if channel
+initialization can be reordered to avoid repeatedly checking the channel type
+without duplicating code. Alternately, shared features could be separated into
+their own chunks.
+
 @<Phidget implementation@>=
 void Phidget22::start()
 {
-#if __APPLE__
-	driver.setFileName("Phidget22.framework/Phidget22");
-#else
-	driver.setFileName("phidget22");
-#endif
-	if(!driver.load())
-	{
-		QMessageBox::critical(NULL, tr("Typica: Driver not found"),
-		                      tr("Failed to find phidget22. Please install it."));
-		return;
-	}
-	if((p_createTemperatureSensor = (PhidgetPointer)driver.resolve("PhidgetTemperatureSensor_create")) == 0 ||
-		(p_setSerialNumber = (PhidgetPointerIntIn)driver.resolve("Phidget_setDeviceSerialNumber")) == 0 ||
-		(p_setChannelNumber = (PhidgetPointerIntIn)driver.resolve("Phidget_setChannel")) == 0 ||
-		(p_setTCType = (PhidgetPointerIntIn)driver.resolve("PhidgetTemperatureSensor_setThermocoupleType")) == 0 ||
-		(p_setRTDType = (PhidgetPointerIntIn)driver.resolve("PhidgetTemperatureSensor_setRTDType")) == 0 ||
-		(p_setRTDWiring = (PhidgetPointerIntIn)driver.resolve("PhidgetTemperatureSensor_setRTDWireSetup")) == 0 ||
-		(p_setNewDataCallback = (PhidgetPointerVCPointer)driver.resolve("PhidgetTemperatureSensor_setOnTemperatureChangeHandler")) == 0 ||
-		(p_open = (PhidgetPointerIntIn)driver.resolve("Phidget_openWaitForAttachment")) == 0 ||
-		(p_close = (PhidgetPointer)driver.resolve("Phidget_close")) == 0 ||
-		(p_delete = (PhidgetPointer)driver.resolve("PhidgetTemperatureSensor_delete")) == 0 ||
-		(p_setHubPort = (PhidgetPointerIntIn)driver.resolve("Phidget_setHubPort")) == 0)
-	{
-		QMessageBox::critical(NULL, tr("Typica: Link error"),
-		                      tr("Failed to link a required symbol in phidget22."));
-		return;
-	}
+	@<Load Phidget22 library@>@;
+	@<Resolve Phidget22 function pointers@>@;
+	
 	for(int i = 0; i < channelConfiguration.length(); i++)
 	{
 		PhidgetChannelData *c = channelConfiguration.at(i);
-		p_createTemperatureSensor(&(c->device));
-		p_setSerialNumber(c->device, c->serialNumber);
-		p_setChannelNumber(c->device, c->channelNumber);
-		switch(c->channelType)
+		switch(c->majorType)
 		{
-			case 32:
-				p_setRTDType(c->device, c->rtdType);
-				p_setRTDWiring(c->device, c->wiring);
+			case 2:
+				p_createCurrentSensor(&(c->device));
+				p_setOnErrorCallback(c->device,
+				                     Phidget22CurrentErrorCallback,
+									 c->channel);
 				break;
-			case 33:
-				p_setTCType(c->device, c->tcType);
+			case 28:
+				p_createTemperatureSensor(&(c->device));
 				break;
 			default:
 				break;
 		}
+		p_setSerialNumber(c->device, c->serialNumber);
+		p_setChannelNumber(c->device, c->channelNumber);
+		if(c->majorType == 28) //Set up temperature channel
+		{
+			switch(c->channelType)
+			{
+				case 32:
+					p_setRTDType(c->device, c->rtdType);
+					p_setRTDWiring(c->device, c->wiring);
+					break;
+				case 33:
+					p_setTCType(c->device, c->tcType);
+					break;
+				default:
+					break;
+			}
+		}
 		if(c->hubPort >= 0)
 		{
 			p_setHubPort(c->device, c->hubPort);
 		}
-		p_setNewDataCallback(c->device, Phidget22ValueCallback, c->channel);
+		switch(c->majorType)
+		{
+			case 2:
+				p_setCurrentNewDataCallback(c->device,
+				                            Phidget22CurrentValueCallback,
+				                            c->channel);
+				break;
+			case 28:
+				p_setNewDataCallback(c->device, Phidget22ValueCallback, c->channel);
+				break;
+			default:
+				break;
+		}
 		p_open(c->device, 5000);
+		/* The data interval must be set after opening the channel, otherwise
+		   the change has no effect. */
+		if(c->majorType == 2)
+		{
+			p_setCurrentPowerSupply(c->device, c->powerSupply);
+			p_setCurrentDataInterval(c->device, c->dataInterval);
+		}
 	}
 }
 
+@ The library we need is slightly different depending on the current platform.
+If the library is not installed, an error is displayed.
+
+@<Load Phidget22 library@>=
+#if __APPLE__
+	driver.setFileName("Phidget22.framework/Phidget22");
+#else
+	driver.setFileName("phidget22");
+#endif
+if(!driver.load())
+{
+	QMessageBox::critical(NULL, tr("Typica: Driver not found"),
+	                      tr("Failed to find phidget22. Please install it."));
+	return;
+}
+
+@ Several function pointers are required to call into the library. If any of
+these fail to resolve, the most likely cause is that an incompatible library
+with the same name has been installed.
+
+@<Resolve Phidget22 function pointers@>=
+if((p_createTemperatureSensor = (PhidgetPointer)driver.resolve("PhidgetTemperatureSensor_create")) == 0 ||
+	(p_createCurrentSensor = (PhidgetPointer)driver.resolve("PhidgetCurrentInput_create")) == 0 ||
+	(p_setSerialNumber = (PhidgetPointerIntIn)driver.resolve("Phidget_setDeviceSerialNumber")) == 0 ||
+	(p_setChannelNumber = (PhidgetPointerIntIn)driver.resolve("Phidget_setChannel")) == 0 ||
+	(p_setTCType = (PhidgetPointerIntIn)driver.resolve("PhidgetTemperatureSensor_setThermocoupleType")) == 0 ||
+	(p_setRTDType = (PhidgetPointerIntIn)driver.resolve("PhidgetTemperatureSensor_setRTDType")) == 0 ||
+	(p_setRTDWiring = (PhidgetPointerIntIn)driver.resolve("PhidgetTemperatureSensor_setRTDWireSetup")) == 0 ||
+	(p_setCurrentPowerSupply = (PhidgetPointerIntIn)driver.resolve("PhidgetCurrentInput_setPowerSupply")) == 0 ||
+	(p_setCurrentDataInterval = (PhidgetPointerIntIn)driver.resolve("PhidgetCurrentInput_setDataInterval")) == 0 ||
+	(p_setNewDataCallback = (PhidgetPointerVCPointer)driver.resolve("PhidgetTemperatureSensor_setOnTemperatureChangeHandler")) == 0 ||
+	(p_setCurrentNewDataCallback = (PhidgetPointerVCPointer)driver.resolve("PhidgetCurrentInput_setOnCurrentChangeHandler")) == 0 ||
+	(p_open = (PhidgetPointerIntIn)driver.resolve("Phidget_openWaitForAttachment")) == 0 ||
+	(p_close = (PhidgetPointer)driver.resolve("Phidget_close")) == 0 ||
+	(p_delete = (PhidgetPointer)driver.resolve("PhidgetTemperatureSensor_delete")) == 0 ||
+	(p_setHubPort = (PhidgetPointerIntIn)driver.resolve("Phidget_setHubPort")) == 0 ||
+	(p_setOnErrorCallback = (PhidgetPointerECPointer)driver.resolve("Phidget_setOnErrorHandler")) == 0)
+{
+	QMessageBox::critical(NULL, tr("Typica: Link error"),
+	                      tr("Failed to link a required symbol in phidget22."));
+	return;
+}
+
 @ New values are delivered to a callback function outside of the class, but
 with a pointer to the relevant |Channel| object. This means that all the
 callback needs to do is perform the unit conversion, assemble the |Measurement|
 available on all channels simultaneously. Hopefully this will not be too
 problematic.
 
+Temperature values and current values are handled separately with the
+former requiring a conversion into Fahrenheit and the latter providing a
+conversion into mA as the most common use is expected to be reading from
+4-20mA sensors. Additional input types might require their own callbacks. For
+example, a voltage input callback might not perform any conversion.
+
+For current channels, the initial use case potentially uses the entire 0-20mA
+range, which can result in errors being generated instead of measurements. Out
+of range and saturation errors should be converted to 0 and 20 respectively.
+This may be the wrong call if someone wants to use a larger range current
+sensor such as 30A, but until someone provides a concrete use case I'm not
+going to worry about that.
+
 @<Additional functions@>=
 void CCONV Phidget22ValueCallback(void *, void *context, double value)
 {
 	channel->input(measure);
 }
 
-@ A function prototype is provided.
+void CCONV Phidget22CurrentValueCallback(void *, void *context, double value)
+{
+	Channel *channel = (Channel*)context;
+	QTime time = QTime::currentTime();
+	Measurement measure(value * 1000.0, time, Units::Unitless);
+	channel->input(measure);
+}
+
+void CCONV Phidget22CurrentErrorCallback(void *, void *context, int error,
+                                         const char *)
+{
+	Channel *channel = (Channel*)context;
+	QTime time = QTime::currentTime();
+	switch(error)
+	{
+		case 4103: // Measurement below valid range
+			{
+				Measurement measure(0.0, time, Units::Unitless);
+				channel->input(measure);
+			}
+			break;
+		case 4105: // Measurement above valid range
+			{
+				Measurement measure(20.0, time, Units::Unitless);
+				channel->input(measure);
+			}
+			break;
+		default:
+			break;
+	}
+}
+
+@ Function prototypes are provided.
 
 @<Additional function prototypes@>=
 void CCONV Phidget22ValueCallback(void *device, void *context, double value);
+void CCONV Phidget22CurrentValueCallback(void *device, void *context,
+                                         double value);
+void CCONV Phidget22CurrentErrorCallback(void *device, void *context,
+                                         int error, const char *description);
 
 @ When the logging window is closed, it is important to close all open channels
 and delete their handles.

src/typica.w

     return self;
 }
 
-template<> QModelIndex getself(QScriptContext *context)
-{
-    QModelIndex self = context->thisObject().toVariant().value<QModelIndex>();
-    return self;
-}
-
 template<> QByteArray getself(QScriptContext *context)
 {
     QByteArray self = context->thisObject().toVariant().toByteArray();
         {@t\1@>@/
             case 4:@/
                 arg4 = argument<int>(3, context);
-                arg3 = argument<int>(2, context);
-                arg2 = argument<int>(1, context);
-                arg1 = argument<int>(0, context);
-                break;
             case 3:@/
                 arg3 = argument<int>(2, context);
-                arg2 = argument<int>(1, context);
-                arg1 = argument<int>(0, context);
-                break;
             case 2:@/
                 arg2 = argument<int>(1, context);
                 arg1 = argument<int>(0, context);
-                break;
             default:@/
                 break;@t\2@>@/
         }
         {@t\1@>@/
             case 4:@/
                 arg4 = argument<int>(3, context);
-                arg3 = argument<int>(2, context);
-                arg2 = argument<int>(1, context);
-                arg1 = argument<int>(0, context);
-                break;
             case 3:@/
                 arg3 = argument<int>(2, context);
                 arg2 = argument<int>(1, context);
                 arg1 = argument<int>(0, context);
-                break;
             default:@/
                 break;@t\2@>@/
         }
                     QStack<QLayout *> *layoutStack);
 void populateStackedLayout(QDomElement element, QStack<QWidget *> *widgetStack,
                            QStack<QLayout *> *layoutStack);
-void populateFormLayout(QDomElement element, QStack<QWidget *> *widgetStack,@|
-                        QStack<QLayout *> *layoutStack);
 void addTemperatureDisplayToSplitter(QDomElement element,@|
                                      QStack<QWidget *> *widgetStack,
                                      QStack<QLayout *> *layoutStack);
     layoutStack->push(layout);
     populateStackedLayout(element, widgetStack, layoutStack);
 }
-else if(layoutType == "form")
-{
-    layout = new QFormLayout;
-    layoutStack->push(layout);
-    populateFormLayout(element, widgetStack, layoutStack);
-}
 if(element.hasAttribute("id"))
 {
     layout->setObjectName(element.attribute("id"));
     layout->setContentsMargins(m, m, m, m);
 }
 
-@ Any direct child of a form layout must be a {\tt <row>} element to specify
-the label for the given row. The field for the given row will always be a
-|QVBoxLayout| containing whatever is specified by children of the {\tt <row>}.
-
-@<Functions for scripting@>=
-void populateFormLayout(QDomElement element, QStack<QWidget *> *widgetStack,
-                        QStack<QLayout *> *layoutStack)
-{
-    QDomNodeList children = element.childNodes();
-    QFormLayout *layout = qobject_cast<QFormLayout *>(layoutStack->top());
-    for(int i = 0; i < children.count(); i++)
-    {
-        QDomNode current;
-        QDomElement currentElement;
-        current = children.at(i);
-        if(current.isElement())
-        {
-            currentElement = current.toElement();
-            if(currentElement.tagName() == "row")
-            {
-                QString label = QString();
-                if(currentElement.hasAttribute("label"))
-                {
-                    label = currentElement.attribute("label");
-                }
-                QVBoxLayout *childLayout = new QVBoxLayout;
-                layoutStack->push(childLayout);
-                populateBoxLayout(currentElement, widgetStack, layoutStack);
-                if(label.isEmpty())
-                {
-                    layout->addRow(childLayout);
-                }
-                else
-                {
-                    layout->addRow(label, childLayout);
-                }
-            }
-        }
-    }
-}
-
 @ Stacked layouts are a bit different from the other types. A stacked layout has
 an arbitrary number of {\tt <page>} children which are just a |QWidget| which
 can have the same child elements as {\tt <widget>} elements elsewhere. Only the
 
 When splitters are used as a way to hide optional features it sometimes has the
 effect of forcing a window to stay larger than should be required. To fix this,
-it is possible to set the \tt{ignoreSizePolicy} attribute to true. While this
+it is possible to set the {\tt ignoreSizePolicy} attribute to true. While this
 does solve the window size issue, this technique is inconsistent with generally
 expected behavior and its use should generally be discouraged.
 
     {
         view->setObjectName(element.attribute("id"));
     }
-    if(element.hasAttribute("editable"))
-    {
-        if(element.attribute("editable") == "false")
-        {
-            view->setEditTriggers(QAbstractItemView::NoEditTriggers);
-        }
-    }
-    if(element.hasAttribute("selectionBehavior"))
-    {
-        if(element.attribute("selectionBehavior") == "items")
-        {
-            view->setSelectionBehavior(QAbstractItemView::SelectItems);
-        }
-        else if(element.attribute("selectionBehavior") == "rows")
-        {
-            view->setSelectionBehavior(QAbstractItemView::SelectRows);
-        }
-        else if(element.attribute("selectionBehavior") == "columns")
-        {
-            view->setSelectionBehavior(QAbstractItemView::SelectColumns);
-        }
-    }
     if(element.hasChildNodes())
     {
         QDomNodeList children = element.childNodes();
 {
     widget->setDisplayColumn(currentElement.attribute("display").toInt());
 }
-if(currentElement.hasAttribute("editable"))
-{
-    if(currentElement.attribute("editable") == "true")
-    {
-        widget->setEditable(true);
-    }
-}
 widget->addSqlOptions(currentElement.text());
 delegate->setWidget(widget);
 view->setItemDelegateForColumn(currentColumn, delegate);
 
 This is a specialization of |QLCDNumber|.
 
+With the addition of 4-20mA current channels, it no longer makes sense to
+restrict non-temperature measurements to whole number values. The default
+behavior is kept the same to avoid breaking old configurations, however new
+uses should explicitly set a desired number of decimal places for each
+indicator.
+
 @<Class declarations@>=
 class TemperatureDisplay : public QLCDNumber@/
 {@t\1@>@/
     Q_OBJECT@;
     int unit;
     bool r;
+	int decimalPlaces;
     public:@/
         TemperatureDisplay(QWidget *parent = NULL);
         ~TemperatureDisplay();@/
         void setValue(Measurement temperature);
         void invalidate();
         void setDisplayUnits(Units::Unit scale);
-        void setRelativeMode(bool relative);@t\2@>@/
+        void setRelativeMode(bool relative);
+		void setDecimalPlaces(int value);@t\2@>@/
 };
 
 @ Starting in version 1.6 this widget is also used for displaying a relative
     r = relative;
 }
 
+@ Starting in version 1.10 it is possible to override the default number of
+decimal places for different units on a per indicator basis. This allows more
+sensible handling of raw non-temperature measurements.
+
+@<TemperatureDisplay Implementation@>=
+void TemperatureDisplay::setDecimalPlaces(int value)
+{
+	decimalPlaces = value;
+}
+
 @ Displaying a temperature is a simple matter of taking the temperature
 component from the measurement and converting it to a string. Presently, this
 code assumes that the measurements are in degrees Fahrenheit. If the code
         case Units::Fahrenheit:
             display(QString("%1'F").
                 arg(number.setNum(temperature.toFahrenheit().temperature(), 'f',
-                                  2)));
+                                  (decimalPlaces == -1 ? 2 : decimalPlaces))));
             break;
         case Units::Celsius:
             if(!r) {
                 display(QString("%1'C").
                     arg(number.setNum(temperature.toCelsius().temperature(), 'f',
-                                    2)));
+                                    (decimalPlaces == -1 ? 2 : decimalPlaces))));
             } else {
-                number.setNum(temperature.temperature() * (5.0/9.0), 'f', 2);
+                number.setNum(temperature.temperature() * (5.0/9.0), 'f', (decimalPlaces == -1 ? 2 : decimalPlaces));
                 display(QString("%1'C").arg(number));
             }
             break;
             if(!r) {
                 display(QString("%1").
                     arg(number.setNum(temperature.toKelvin().temperature(), 'f',
-                                    2)));
+                                    (decimalPlaces == -1 ? 2 : decimalPlaces))));
             } else {
-                number.setNum(temperature.temperature() * (5.0/9.0), 'f', 2);
+                number.setNum(temperature.temperature() * (5.0/9.0), 'f', (decimalPlaces == -1 ? 2 : decimalPlaces));
                 display(QString("%1").arg(number));
             }
             break;
         case Units::Rankine:
             display(QString("%1'r").
                 arg(number.setNum(temperature.toRankine().temperature(), 'f',
-                                  2)));
+                                  (decimalPlaces == -1 ? 2 : decimalPlaces))));
             break;
         case Units::Unitless:
-            display(QString("%1").arg(number.setNum(temperature.temperature(), 'f', 0)));
+            display(QString("%1").arg(number.setNum(temperature.temperature(), 'f', (decimalPlaces == -1 ? 0 : decimalPlaces))));
             break;
         default:
             switch(temperature.scale())
             {
                 case Units::Fahrenheit:
                     display(QString("%1'F").
-                        arg(number.setNum(temperature.temperature(), 'f', 2)));
+                        arg(number.setNum(temperature.temperature(), 'f', (decimalPlaces == -1 ? 2 : decimalPlaces))));
                     break;
                 case Units::Celsius:
                     display(QString("%1'C").
-                        arg(number.setNum(temperature.temperature(), 'f', 2)));
+                        arg(number.setNum(temperature.temperature(), 'f', (decimalPlaces == -1 ? 2 : decimalPlaces))));
                     break;
                 case Units::Kelvin:
                     display(QString("%1").
-                        arg(number.setNum(temperature.temperature(), 'f', 2)));
+                        arg(number.setNum(temperature.temperature(), 'f', (decimalPlaces == -1 ? 2 : decimalPlaces))));
                     break;
                 case Units::Rankine:
                     display(QString("%1'r").
-                        arg(number.setNum(temperature.temperature(), 'f', 2)));
+                        arg(number.setNum(temperature.temperature(), 'f', (decimalPlaces == -1 ? 2 : decimalPlaces))));
                     break;
                 case Units::Unitless:
-                    display(QString("%1").arg(number.setNum(temperature.temperature(), 'f', 0)));
+                    display(QString("%1").arg(number.setNum(temperature.temperature(), 'f', (decimalPlaces == -1 ? 0 : decimalPlaces))));
                     break;
                 default:
 					qDebug() << "Warning: Attempting to convert a non-temperature unit to a temperature unit";
 \centerline{Figure \secno: Outline (Qt default) and Filled |QLCDNumber| Example}
 \medskip
 
+The default initialization of decimalPlaces to -1 is used to preserve unit
+specific defaults as seen above.
+
 @<TemperatureDisplay Implementation@>=
 TemperatureDisplay::TemperatureDisplay(QWidget *parent) :
-    QLCDNumber(8, parent), unit(Units::Fahrenheit), r(false)@/
+    QLCDNumber(8, parent), unit(Units::Fahrenheit), r(false),
+	decimalPlaces(-1)@/
 {
     setSegmentStyle(Filled);
     display("---.--'F");
     public:@/
         SaltModel(int columns);
         ~SaltModel();
-        Q_INVOKABLE int rowCount(const QModelIndex &parent = QModelIndex()) const;
+        int rowCount(const QModelIndex &parent = QModelIndex()) const;
         int columnCount(const QModelIndex &parent = QModelIndex()) const;
         bool setHeaderData(int section, Qt::Orientation@, orientation,
                            const QVariant &value, int role = Qt::DisplayRole);
     specialNullText(tr("Unknown")), specialNullData(QVariant::String)
 {
     view()->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
-    setMinimumContentsLength(20);
 }
 
 SqlComboBox::~SqlComboBox()
                                            const QStyleOptionViewItem &,
                                            const QModelIndex &) const
 {
-    SqlComboBox *retval = delegate->clone(parent);
-    if(delegate->isEditable())
-    {
-        retval->setEditable(true);
-    }
-    return retval;
+    return delegate->clone(parent);
 }
 
 @ To set the appropriate editor data, we check the value in the model and
                                        const QModelIndex &index) const
 {
     SqlComboBox *self = qobject_cast<SqlComboBox *>(editor);
-    model->setData(index, self->currentText(), Qt::DisplayRole);
     model->setData(index, self->itemData(self->currentIndex(), Qt::UserRole),
                    Qt::UserRole);
+    model->setData(index, self->currentText(), Qt::DisplayRole);
 }
 
 @ This is needed to play nicely with the model view architecture.
 Q_DECLARE_METATYPE(QModelIndex)
 
 @ Next we need a pair of functions to convert |QModelIndex| to and from script
-values. Some |QModelIndex| methods are also exposed to the host environment.
+values.
 
 @<Function prototypes for scripting@>=
 QScriptValue QModelIndex_toScriptValue(QScriptEngine *engine, const QModelIndex &index);
 void QModelIndex_fromScriptValue(const QScriptValue &value, QModelIndex &index);
-void setQModelIndexProperties(QScriptValue value, QScriptEngine *engine);
-QScriptValue QModelIndex_row(QScriptContext *context, QScriptEngine *engine);
 
 @ These are implemented thusly.
 
     QVariant var;
     var.setValue(index);
     QScriptValue object = engine->newVariant(var);
-    setQModelIndexProperties(object, engine);
     return object;
 }
 
     index = value.toVariant().value<QModelIndex>();
 }
 
-void setQModelIndexProperties(QScriptValue value, QScriptEngine *engine)
-{
-    value.setProperty("row", engine->newFunction(QModelIndex_row));
-}
-
-QScriptValue QModelIndex_row(QScriptContext *context, QScriptEngine *engine)
-{
-    QModelIndex self = getself<QModelIndex>(context);
-    return QScriptValue(engine, self.row());
-}
-
 @ Finally we register this with the engine.
 
 @<Set up the scripting engine@>=