DATAQ SDK device configuration widget. Still requires channel configuration widget.

src/dataqsdk.w

 	value.setProperty("newChannel", engine->newFunction(DataqSdkDevice_newChannel));
 }
 
-@ The |newChannel()| wrapper requires two arguments.
+@ The |newChannel()| wrapper requires one argument to specify the measurement
+unit that will eventually be produced from that channel.
 
 @<Functions for scripting@>=
 QScriptValue DataqSdkDevice_newChannel(QScriptContext *context, QScriptEngine *engine)
 		setChannelProperties(object, engine);
 	}
 	return object;
-}
+}
+
+@ In order to configure supported devices within Typica, a set of configuration
+controls is required. First there is the base device configuration widget.
+
+@<Class declarations@>=
+class DataqSdkDeviceConfWidget : public BasicDeviceConfigurationWidget
+{
+	Q_OBJECT
+	public:
+		Q_INVOKABLE DataqSdkDeviceConfWidget(DeviceTreeModel *model,
+		                                     const QModelIndex &index);
+	private slots:
+		void updateAutoSelect(bool automatic);
+		void updateDeviceNumber(int deviceNumber);
+		void updatePort(QString portId);
+		void addChannel();
+	private:
+		QStackedWidget *deviceIdStack;
+};
+
+@ The constructor sets up the interface for updating device configuration
+settings.
+
+@<DataqSdkDeviceConfWidget implementation@>=
+DataqSdkDeviceConfWidget::DataqSdkDeviceConfWidget(DeviceTreeModel *model,
+                                                   const QModelIndex &index)
+	: BasicDeviceConfigurationWidget(model, index),
+	deviceIdStack(new QStackedWidget)
+{
+	QVBoxLayout *layout = new QVBoxLayout;
+	QCheckBox *autoDetect = new QCheckBox("Automatically select device");
+	layout->addWidget(autoDetect);
+	QWidget *autoLayerWidget = new QWidget;
+	QHBoxLayout *autoLayerLayout = new QHBoxLayout;
+	QLabel *autoLabel = new QLabel(tr("Device number"));
+	QSpinBox *autoNumber = new QSpinBox;
+	autoNumber->setMinimum(1);
+	autoNumber->setMaximum(99);
+	autoLayerLayout->addWidget(autoLabel);
+	autoLayerLayout->addWidget(autoNumber);
+	autoLayerWidget->setLayout(autoLayerLayout);
+	QWidget *fixedLayerWidget = new QWidget;
+	QHBoxLayout *fixedLayerLayout = new QHBoxLayout;
+	QLabel *fixedLabel = new QLabel(tr("Device port"));
+	QComboBox *portSelection = new QComboBox;
+	portSelection->setEditable(true);
+	portSelection->addItems(DataqSdkDevice::detectHardware());
+	fixedLayerLayout->addWidget(fixedLabel);
+	fixedLayerLayout->addWidget(portSelection);
+	fixedLayerWidget->setLayout(fixedLayerLayout);
+	deviceIdStack->addWidget(autoLayerWidget);
+	deviceIdStack->addWidget(fixedLayerWidget);
+	layout->addWidget(deviceIdStack);
+	QPushButton *addChannelButton = new QPushButton(tr("Add Channel"));
+	layout->addWidget(addChannelButton);
+	@<Get device configuration data for current node@>@;
+	for(int i = 0; i < configData.size(); i++)
+	{
+		node = configData.at(i).toElement();
+		if(node.attribute("name") == "autoSelect")
+		{
+			autoDetect->setChecked(node.attribute("value") == "true" ? true : false);
+		}
+		else if(node.attribute("name") == "deviceNumber")
+		{
+			autoNumber->setValue(node.attribute("value").toInt());
+		}
+		else if(node.attribute("name") == "port")
+		{
+			int index = portSelection->findText(node.attribute("value"));
+			if(index > -1)
+			{
+				portSelection->setCurrentIndex(index);
+			}
+			else
+			{
+				portSelection->setEditText(node.attribute("value"));
+			}
+		}
+	}
+	updateAutoSelect(autoDetect->isChecked());
+	updateDeviceNumber(autoNumber->value());
+	updatePort(portSelection->currentText());
+	connect(autoDetect, SIGNAL(toggled(bool)), this, SLOT(updateAutoSelect(bool)));
+	connect(autoNumber, SIGNAL(valueChanged(int)), this, SLOT(updateDeviceNumber(int)));
+	connect(portSelection, SIGNAL(currentIndexChanged(QString)), this, SLOT(updatePort(QString)));
+	connect(addChannelButton, SIGNAL(clicked()), this, SLOT(addChannel()));
+	setLayout(layout);
+}
+
+@ In addition to setting a value in the device configuration, the choice to
+automatically select devices also requires changing which controls in the
+configuration widget are presently available. It is recommended that automatic
+device selection is only used in cases where there is a single device supported
+by the DATAQ SDK present and it will always be the first detected device
+regardless of the current virtual COM port number. In cases where multiple
+devices must be connected, it is recommended to always plug devices into the
+same port and specify the port for each device explicitly.
+
+@<DataqSdkDeviceConfWidget implementation@>=
+void DataqSdkDeviceConfWidget::updateAutoSelect(bool automatic)
+{
+	if(automatic)
+	{
+		updateAttribute("autoSelect", "true");
+		deviceIdStack->setCurrentIndex(0);
+	}
+	else
+	{
+		updateAttribute("autoSelect", "false");
+		deviceIdStack->setCurrentIndex(1);
+	}
+}
+
+@ Other update methods only need to set a new current value.
+
+@<DataqSdkDeviceConfWidget implementation@>=
+void DataqSdkDeviceConfWidget::updateDeviceNumber(int deviceNumber)
+{
+	updateAttribute("deviceNumber", QString("%1").arg(deviceNumber));
+}
+
+void DataqSdkDeviceConfWidget::updatePort(QString portId)
+{
+	updateAttribute("port", portId);
+}
+
+@ The Add Channel button creates a new configuration node.
+
+@<DataqSdkDeviceConfWidget implementation@>=
+void DataqSdkDeviceConfWidget::addChannel()
+{
+	insertChildNode(tr("Channel"), "dataqsdkchannel");
+}
+
+@ These configuration widgets are registered with the configuration system.
+
+@<Register device configuration widgets@>=
+app.registerDeviceConfigurationWidget("dataqsdk", DataqSdkDeviceConfWidget::staticMetaObject);
+
+@ A |NodeInserter| is also added to provide access to
+|DataqSdkDeviceConfWidget|, but only on Windows.
+
+@<Register top level device configuration nodes@>=
+#ifdef Q_OS_WIN32
+inserter = new NodeInserter(tr("DATAQ SDK Device"), tr("DATAQ Device"),
+                            "dataqsdk", NULL);
+topLevelNodeInserters.append(inserter);
+#endif
+

src/typica.w

 @<RateOfChange implementation@>@/
 @<SettingsWindow implementation@>@/
 @<GraphSettingsWidget implementation@>@/
+@<DataqSdkDeviceConfWidget implementation@>@/
 
 @ A few headers are required for various parts of \pn{}. These allow the use of
 various Qt modules.
 	return object;
 }
 
-@i dataqsdk.w
-
 @ Sometimes it can be useful to test other parts of the program (for example,
 when developing new scripts) when the DAQ hardware is not available. In these
 cases, it is possible to temporarily use the |FakeDAQ| class. This class mimics
 window that may vary from one machine to the next.
 
 All of the configuration widgets follow a similar pattern. One important detail
-to note is that these configuration widgets are instantiated through Qt's
+to note is that these configuration widgets are instantiated through Qt'@q'@>s
 meta-object system. All of these constructors take a |DeviceTreeModel *| and a
 |QModelIndex &| as arguments and they are marked as |Q_INVOKABLE|.
 
 \noindent The primary concern in supporting hardware that communicates through
 NI-DAQmx Base is in configurations using a single NI USB 9211 (for NI-DAQmx
 Base 2.x) or NI USB 9211A (for NI-DAQmx Base 3.x), but if it is reasonable to
-do so I'd like to later add support for multiple device configurations and
+do so I'@q'@>d like to later add support for multiple device configurations and
 limited support for other devices including the ability to use devices with
 voltage inputs for non-temperature measurement data. The top priority, however,
 is in continuing to support hardware that people are already using with Typica.
 		                                        const QModelIndex &index);
 };
 
-@ There is very little to configure here so there isn't much for the
+@ There is very little to configure here so there isn'@q'@>t much for the
 constructor to do. We do need to keep a reference to the node we are
 configuring so that child nodes can later be added. At present, no real
 configuration data other than the existence of the node is required so
 device. Next is the thermocouple type. Many options are supported, but I would
 like to ensure that the most commonly used choices are listed first. The other
 piece of information that DAQmx or DAQmx Base require is the measurement unit.
-As all of Typica's internal operations are in Fahrenheit there is no need to
+As all of Typica'@q'@>s internal operations are in Fahrenheit there is no need to
 make this configurable so long as everything else that can display temperature
 measurements can perform the appropriate conversions.
 
 
 @ Set values are slightly more complicated as we may want either a fixed range
 or the ability to query the device for its current allowed range, but nothing
-is here that hasn't been seen elsewhere.
+is here that hasn'@q'@>t been seen elsewhere.
 
 @<Class declarations@>=
 class ModbusRtuDeviceTSvConfWidget : public BasicDeviceConfigurationWidget
 }
 
 @ To update the temperature at which to match we save both the values of the
-two widgets which control this and the value in Fahrenheit so we don't need to
+two widgets which control this and the value in Fahrenheit so we don'@q@'@>t need to
 run unit conversions during view initialization.
 
 @<TranslationConfWidget implementation@>=
 
 @i rate.w
 
+@i dataqsdk.w
+
 @** Local changes.
 
 \noindent This is the end of \pn{} as distributed by its author. It is expected

src/units.w

 
 @(units.cpp@>=
 #include "units.h"
-#ifndef Q_OS_WIN32
-#include "moc_units.cpp"
-#endif
 
 @ The |isTemperatureUnit()| method may seem counter-intuitive while the enum
 only contains represenations of temperature measurements, but there are plans