Merge branch 'phidgets1048' into release-1.6.3

Conflicts:
	src/typica.w

config/Windows/productionroaster.xml

 		var nidevices = new Array();
 		var dataqsdkdevices = new Array();
 		var jsdevices = new Array();
+		var pdevices = new Array();
 		var temperatureDisplays = new Array();
 		var columnNames = new Array();
 		var modbusdevices = new Array();
 					device.start();
 					jsdevices.push(device);
 				}
+				else if(driverReference.driver == "phidgets1048")
+				{
+					var device = new PhidgetsTemperatureSensor(driverIndex);
+					for(var j = 0; j < device.channelCount(); j++) {
+						channels.push(device.getChannel(j));
+						columnNames.push(device.channelColumnName(j));
+						channelType.push("T");
+						if(device.isChannelHidden(j)) {
+							channelVisibility.push(false);
+						} else {
+							channelVisibility.push(true);
+							var indicator = new TemperatureDisplay;
+							temperatureDisplays.push(indicator);
+							var decorator = new WidgetDecorator(indicator, device.channelIndicatorText(j), 2);
+							device.getChannel(j).newData.connect(indicator.setValue);
+							indicatorPanel.addWidget(decorator);
+						}
+					}
+					device.start();
+					pdevices.push(device);
+				}
 				else if(driverReference.driver == "annotationbutton")
 				{
 					var button = new AnnotationButton(driverReference.buttontext);
 				jsdevices[i].stop();
 				jsdevices[i].deleteLater();
 			}
+			for(var i = 0; i < pdevices.length; i++)
+			{
+				pdevices[i].stop();
+				pdevices[i].deleteLater();
+			}
 			delete nidevices;
 			delete modbusdevices;
 			delete dataqsdkdevices;
 			delete jsdevices;
+			delete pdevices;
             window.saveSizeAndPosition("window");
             vsplit.saveState("script/loggingView/" + roasterIndex + "/mainSplitter");
 			QSettings.setValue("script/loggingView/" + roasterIndex + "/instrumentCount", isplit.count());

src/abouttypica.cpp

-/*222:*/
+/*249:*/
 #line 33 "./abouttypica.w"
 
 #include "abouttypica.h"
 
-/*223:*/
+/*250:*/
 #line 42 "./abouttypica.w"
 
 AboutTypica::AboutTypica():QMainWindow(NULL)
 setCentralWidget(banner);
 }
 
-#line 5641 "./typica.w"
+#line 5992 "./typica.w"
 
-/*:223*/
+/*:250*/
 #line 36 "./abouttypica.w"
 
 
-/*:222*/
+/*:249*/

src/abouttypica.h

-/*221:*/
+/*248:*/
 #line 14 "./abouttypica.w"
 
 #include <QMainWindow> 
 
 #endif
 
-/*:221*/
+/*:248*/

src/daterangeselector.cpp

-/*603:*/
-#line 66 "./daterangeselector.w"
+/*639:*/
+#line 68 "./daterangeselector.w"
 
 #include <QCalendarWidget> 
 #include <QPushButton> 
 
 #include "daterangeselector.h"
 
-/*604:*/
-#line 86 "./daterangeselector.w"
-
-class CustomDateRangePopup:public QWidget
-{
-Q_OBJECT
-public:
-CustomDateRangePopup(QWidget*parent= NULL);
-public slots:
-void applyRange();
-signals:
-void hidingPopup();
-protected:
-virtual void hideEvent(QHideEvent*event);
-private slots:
-void validateRange();
-private:
-QCalendarWidget*startDateSelector;
-QCalendarWidget*endDateSelector;
-QPushButton*applyButton;
-};
-
-/*:604*/
-#line 77 "./daterangeselector.w"
-
-/*605:*/
-#line 110 "./daterangeselector.w"
+/*641:*/
+#line 111 "./daterangeselector.w"
 
 CustomDateRangePopup::CustomDateRangePopup(QWidget*parent):
 QWidget(parent,Qt::Popup),startDateSelector(new QCalendarWidget),
 setLayout(outerLayout);
 }
 
-/*:605*//*606:*/
-#line 158 "./daterangeselector.w"
+/*:641*//*642:*/
+#line 159 "./daterangeselector.w"
 
 void CustomDateRangePopup::hideEvent(QHideEvent*)
 {
 emit hidingPopup();
 }
 
-/*:606*//*607:*/
-#line 167 "./daterangeselector.w"
+/*:642*//*643:*/
+#line 168 "./daterangeselector.w"
 
 void CustomDateRangePopup::applyRange()
 {
 hide();
 }
 
-/*:607*//*608:*/
-#line 184 "./daterangeselector.w"
+/*:643*//*644:*/
+#line 185 "./daterangeselector.w"
 
 void CustomDateRangePopup::validateRange()
 {
 }
 }
 
-/*:608*/
-#line 78 "./daterangeselector.w"
+/*:644*/
+#line 79 "./daterangeselector.w"
 
-/*609:*/
-#line 202 "./daterangeselector.w"
+/*645:*/
+#line 203 "./daterangeselector.w"
 
 DateRangeSelector::DateRangeSelector(QWidget*parent):
 QWidget(parent),quickSelector(new QComboBox(this)),
 QDate currentDate= QDate::currentDate();
 
 QHBoxLayout*layout= new QHBoxLayout;
-/*610:*/
-#line 231 "./daterangeselector.w"
+/*646:*/
+#line 232 "./daterangeselector.w"
 
 quickSelector->addItem("Yesterday",QVariant(QStringList()<<
 currentDate.addDays(-1).toString(Qt::ISODate)));
 quickSelector->addItem("Lifetime");
 quickSelector->addItem("Custom");
 
-/*:610*/
-#line 212 "./daterangeselector.w"
+/*:646*/
+#line 213 "./daterangeselector.w"
 
 QToolButton*customButton= new QToolButton;
 customButton->setIcon(QIcon::fromTheme("office-calendar",
 connect(customButton,SIGNAL(clicked()),this,SLOT(toggleCustom()));
 }
 
-/*:609*//*611:*/
-#line 314 "./daterangeselector.w"
+/*:645*//*647:*/
+#line 315 "./daterangeselector.w"
 
 void DateRangeSelector::updateRange(int index)
 {
 }
 }
 
-/*:611*//*612:*/
-#line 331 "./daterangeselector.w"
+/*:647*//*648:*/
+#line 332 "./daterangeselector.w"
 
 void DateRangeSelector::popupHidden()
 {
 quickSelector->setCurrentIndex(lastIndex);
 }
 
-/*:612*//*613:*/
-#line 342 "./daterangeselector.w"
+/*:648*//*649:*/
+#line 343 "./daterangeselector.w"
 
 void DateRangeSelector::setCustomRange(QVariant range)
 {
 quickSelector->setCurrentIndex(lastIndex);
 }
 
-/*:613*//*614:*/
-#line 357 "./daterangeselector.w"
+/*:649*//*650:*/
+#line 358 "./daterangeselector.w"
 
 void DateRangeSelector::toggleCustom()
 {
 }
 }
 
-/*:614*//*615:*/
-#line 399 "./daterangeselector.w"
+/*:650*//*651:*/
+#line 400 "./daterangeselector.w"
 
 QVariant DateRangeSelector::currentRange()
 {
 return quickSelector->itemData(lastIndex);
 }
 
-/*:615*//*616:*/
-#line 407 "./daterangeselector.w"
+/*:651*//*652:*/
+#line 408 "./daterangeselector.w"
 
 void DateRangeSelector::setCurrentIndex(int index)
 {
 quickSelector->setCurrentIndex(index);
 }
 
-/*:616*//*617:*/
-#line 422 "./daterangeselector.w"
+/*:652*//*653:*/
+#line 423 "./daterangeselector.w"
 
 void DateRangeSelector::setLifetimeRange(QString startDate,QString endDate)
 {
 QVariant(QStringList()<<startDate<<endDate));
 }
 
-/*:617*//*618:*/
-#line 432 "./daterangeselector.w"
+/*:653*//*654:*/
+#line 433 "./daterangeselector.w"
 
 void DateRangeSelector::removeIndex(int index)
 {
 quickSelector->removeItem(index);
 }
 
-/*:618*/
-#line 79 "./daterangeselector.w"
+/*:654*/
+#line 80 "./daterangeselector.w"
 
 
 #include "moc_daterangeselector.cpp"
 
-/*:603*/
+/*:639*/

src/daterangeselector.h

-/*602:*/
+/*638:*/
 #line 30 "./daterangeselector.w"
 
 
 #include <QComboBox> 
+#include <QPushButton> 
+#include <QCalendarWidget> 
 
 #ifndef TypicaDateRangeSelectorHeader
 #define TypicaDateRangeSelectorHeader
 
-class CustomDateRangePopup;
+/*640:*/
+#line 87 "./daterangeselector.w"
+
+class CustomDateRangePopup:public QWidget
+{
+Q_OBJECT
+public:
+CustomDateRangePopup(QWidget*parent= NULL);
+public slots:
+void applyRange();
+signals:
+void hidingPopup();
+protected:
+virtual void hideEvent(QHideEvent*event);
+private slots:
+void validateRange();
+private:
+QCalendarWidget*startDateSelector;
+QCalendarWidget*endDateSelector;
+QPushButton*applyButton;
+};
+
+/*:640*/
+#line 39 "./daterangeselector.w"
+
 
 class DateRangeSelector:public QWidget
 {
 
 #endif
 
-/*:602*/
+/*:638*/

src/draglabel.cpp

-/*863:*/
+/*958:*/
 #line 33 "./scales.w"
 
 #include "draglabel.h"
 }
 }
 
-/*:863*/
+/*:958*/

src/draglabel.h

-/*862:*/
+/*957:*/
 #line 13 "./scales.w"
 
 #ifndef TypicaDragLabelInclude
 
 #endif
 
-/*:862*/
+/*:957*/

src/helpmenu.cpp

-/*163:*/
-#line 35 "./helpmenu.w"
+/*182:*/
+#line 36 "./helpmenu.w"
 
 #include "helpmenu.h"
 #include "abouttypica.h"
+#include "feedback.h"
 
-/*164:*/
-#line 47 "./helpmenu.w"
+/*183:*/
+#line 49 "./helpmenu.w"
 
 HelpMenu::HelpMenu():QMenu()
 {
 aboutTypicaAction->setObjectName("aboutTypicaAction");
 addAction(aboutTypicaAction);
 connect(aboutTypicaAction,SIGNAL(triggered()),this,SLOT(displayAboutTypica()));
+QAction*sendFeedbackAction= new QAction(tr("Send Feedback"),this);
+sendFeedbackAction->setObjectName("sendFeedback");
+addAction(sendFeedbackAction);
+connect(sendFeedbackAction,SIGNAL(triggered()),this,SLOT(displayFeedbackWizard()));
 }
 
-/*:164*//*165:*/
-#line 61 "./helpmenu.w"
+/*:183*//*184:*/
+#line 67 "./helpmenu.w"
 
 void HelpMenu::displayAboutTypica()
 {
 aboutBox->show();
 }
 
-#line 3946 "./typica.w"
+/*:184*//*185:*/
+#line 76 "./helpmenu.w"
 
-/*:165*/
-#line 39 "./helpmenu.w"
+void HelpMenu::displayFeedbackWizard()
+{
+FeedbackWizard*window= new FeedbackWizard;
+window->show();
+}
+
+#line 4266 "./typica.w"
+
+#line 1 "./feedback.w"
+/*:185*/
+#line 41 "./helpmenu.w"
 
 
-/*:163*/
+/*:182*/

src/helpmenu.h

-/*162:*/
+/*181:*/
 #line 16 "./helpmenu.w"
 
 #include <QMenu> 
 HelpMenu();
 public slots:
 void displayAboutTypica();
+void displayFeedbackWizard();
 };
 
 #endif
 
-/*:162*/
+/*:181*/

src/moc_feedback.cpp

        6,       // revision
        0,       // classname
        0,    0, // classinfo
-       5,   14, // methods
+       1,   14, // methods
        0,    0, // properties
        0,    0, // enums/sets
        0,    0, // constructors
 
  // slots: signature, parameters, type, tag, flags
       22,   16,   15,   15, 0x08,
-      50,   15,   15,   15, 0x08,
-      70,   15,   15,   15, 0x08,
-      91,   15,   15,   15, 0x08,
-     107,   15,   15,   15, 0x08,
 
        0        // eod
 };
 
 static const char qt_meta_stringdata_FeedbackWizard[] = {
     "FeedbackWizard\0\0index\0setCommentInstructions(int)\0"
-    "updateMessageText()\0printButtonPressed()\0"
-    "printAccepted()\0copyButtonPressed()\0"
 };
 
 void FeedbackWizard::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
         FeedbackWizard *_t = static_cast<FeedbackWizard *>(_o);
         switch (_id) {
         case 0: _t->setCommentInstructions((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 1: _t->updateMessageText(); break;
-        case 2: _t->printButtonPressed(); break;
-        case 3: _t->printAccepted(); break;
-        case 4: _t->copyButtonPressed(); break;
         default: ;
         }
     }
     if (_id < 0)
         return _id;
     if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 5)
+        if (_id < 1)
             qt_static_metacall(this, _c, _id, _a);
-        _id -= 5;
+        _id -= 1;
     }
     return _id;
 }

src/moc_typica.cpp

 /****************************************************************************
 ** Meta object code from reading C++ file 'typica.cpp'
 **
-** Created: Thu Jul 3 12:34:58 2014
-**      by: The Qt Meta Object Compiler version 63 (Qt 4.8.4)
+** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.6)
 **
 ** WARNING! All changes made in this file will be lost!
 *****************************************************************************/
 #if !defined(Q_MOC_OUTPUT_REVISION)
 #error "The header file 'typica.cpp' doesn't include <QObject>."
 #elif Q_MOC_OUTPUT_REVISION != 63
-#error "This file was generated using the moc from 4.8.4. It"
+#error "This file was generated using the moc from 4.8.6. It"
 #error "cannot be used with the include files from this version of Qt."
 #error "(The moc has changed too much.)"
 #endif
     }
     return _id;
 }
+static const uint qt_meta_data_AdvancedSettingsWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       1,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      32,   24,   23,   23, 0x0a,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_AdvancedSettingsWidget[] = {
+    "AdvancedSettingsWidget\0\0enabled\0"
+    "enableDiagnosticLogging(bool)\0"
+};
+
+void AdvancedSettingsWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        AdvancedSettingsWidget *_t = static_cast<AdvancedSettingsWidget *>(_o);
+        switch (_id) {
+        case 0: _t->enableDiagnosticLogging((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData AdvancedSettingsWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject AdvancedSettingsWidget::staticMetaObject = {
+    { &QWidget::staticMetaObject, qt_meta_stringdata_AdvancedSettingsWidget,
+      qt_meta_data_AdvancedSettingsWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &AdvancedSettingsWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *AdvancedSettingsWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *AdvancedSettingsWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_AdvancedSettingsWidget))
+        return static_cast<void*>(const_cast< AdvancedSettingsWidget*>(this));
+    return QWidget::qt_metacast(_clname);
+}
+
+int AdvancedSettingsWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 1)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 1;
+    }
+    return _id;
+}
 static const uint qt_meta_data_ModbusRTUDevice[] = {
 
  // content:
        6,       // revision
        0,       // classname
        0,    0, // classinfo
-      17,   14, // methods
+      18,   14, // methods
        0,    0, // properties
        0,    0, // enums/sets
        0,    0, // constructors
      262,   16,   16,   16, 0x08,
      283,  152,   16,   16, 0x08,
      305,  152,   16,   16, 0x08,
+     324,   16,   16,   16, 0x08,
 
  // methods: signature, parameters, type, tag, flags
-     331,   16,  324,   16, 0x02,
-     341,   16,  324,   16, 0x02,
-     355,   16,  351,   16, 0x02,
+     341,   16,  334,   16, 0x02,
+     351,   16,  334,   16, 0x02,
+     365,   16,  361,   16, 0x02,
 
        0        // eod
 };
     "unitResponse(QByteArray)\0"
     "svlResponse(QByteArray)\0svuResponse(QByteArray)\0"
     "requestMeasurement()\0mResponse(QByteArray)\0"
-    "ignore(QByteArray)\0double\0SVLower()\0"
-    "SVUpper()\0int\0decimals()\0"
+    "ignore(QByteArray)\0timeout()\0double\0"
+    "SVLower()\0SVUpper()\0int\0decimals()\0"
 };
 
 void ModbusRTUDevice::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
         case 11: _t->requestMeasurement(); break;
         case 12: _t->mResponse((*reinterpret_cast< QByteArray(*)>(_a[1]))); break;
         case 13: _t->ignore((*reinterpret_cast< QByteArray(*)>(_a[1]))); break;
-        case 14: { double _r = _t->SVLower();
+        case 14: _t->timeout(); break;
+        case 15: { double _r = _t->SVLower();
             if (_a[0]) *reinterpret_cast< double*>(_a[0]) = _r; }  break;
-        case 15: { double _r = _t->SVUpper();
+        case 16: { double _r = _t->SVUpper();
             if (_a[0]) *reinterpret_cast< double*>(_a[0]) = _r; }  break;
-        case 16: { int _r = _t->decimals();
+        case 17: { int _r = _t->decimals();
             if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; }  break;
         default: ;
         }
     if (_id < 0)
         return _id;
     if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 17)
+        if (_id < 18)
             qt_static_metacall(this, _c, _id, _a);
-        _id -= 17;
+        _id -= 18;
     }
     return _id;
 }
 {
     QMetaObject::activate(this, &staticMetaObject, 3, 0);
 }
+static const uint qt_meta_data_PhidgetsTemperatureSensorConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       2,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   24, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      37,   36,   36,   36, 0x08,
+      53,   50,   36,   36, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+      81,   69,   36,   36, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_PhidgetsTemperatureSensorConfWidget[] = {
+    "PhidgetsTemperatureSensorConfWidget\0"
+    "\0addChannel()\0ms\0updateRate(int)\0"
+    "model,index\0"
+    "PhidgetsTemperatureSensorConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void PhidgetsTemperatureSensorConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { PhidgetsTemperatureSensorConfWidget *_r = new PhidgetsTemperatureSensorConfWidget((*reinterpret_cast< DeviceTreeModel*(*)>(_a[1])),(*reinterpret_cast< const QModelIndex(*)>(_a[2])));
+            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
+        }
+    } else if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        PhidgetsTemperatureSensorConfWidget *_t = static_cast<PhidgetsTemperatureSensorConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->addChannel(); break;
+        case 1: _t->updateRate((*reinterpret_cast< int(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData PhidgetsTemperatureSensorConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject PhidgetsTemperatureSensorConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_PhidgetsTemperatureSensorConfWidget,
+      qt_meta_data_PhidgetsTemperatureSensorConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &PhidgetsTemperatureSensorConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *PhidgetsTemperatureSensorConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *PhidgetsTemperatureSensorConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_PhidgetsTemperatureSensorConfWidget))
+        return static_cast<void*>(const_cast< PhidgetsTemperatureSensorConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int PhidgetsTemperatureSensorConfWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = BasicDeviceConfigurationWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 2)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 2;
+    }
+    return _id;
+}
+static const uint qt_meta_data_PhidgetTemperatureSensorChannelConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       4,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   34, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      49,   43,   42,   42, 0x08,
+      82,   75,   42,   42, 0x08,
+     107,  101,   42,   42, 0x08,
+     129,  121,   42,   42, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+     160,  148,   42,   42, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_PhidgetTemperatureSensorChannelConfWidget[] = {
+    "PhidgetTemperatureSensorChannelConfWidget\0"
+    "\0value\0updateColumnName(QString)\0"
+    "hidden\0updateHidden(bool)\0index\0"
+    "updateTC(int)\0channel\0updateChannel(int)\0"
+    "model,index\0"
+    "PhidgetTemperatureSensorChannelConfWidget(DeviceTreeModel*,QModelIndex"
+    ")\0"
+};
+
+void PhidgetTemperatureSensorChannelConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { PhidgetTemperatureSensorChannelConfWidget *_r = new PhidgetTemperatureSensorChannelConfWidget((*reinterpret_cast< DeviceTreeModel*(*)>(_a[1])),(*reinterpret_cast< const QModelIndex(*)>(_a[2])));
+            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
+        }
+    } else if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        PhidgetTemperatureSensorChannelConfWidget *_t = static_cast<PhidgetTemperatureSensorChannelConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updateColumnName((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 1: _t->updateHidden((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        case 2: _t->updateTC((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 3: _t->updateChannel((*reinterpret_cast< int(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData PhidgetTemperatureSensorChannelConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject PhidgetTemperatureSensorChannelConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_PhidgetTemperatureSensorChannelConfWidget,
+      qt_meta_data_PhidgetTemperatureSensorChannelConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &PhidgetTemperatureSensorChannelConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *PhidgetTemperatureSensorChannelConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *PhidgetTemperatureSensorChannelConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_PhidgetTemperatureSensorChannelConfWidget))
+        return static_cast<void*>(const_cast< PhidgetTemperatureSensorChannelConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int PhidgetTemperatureSensorChannelConfWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = BasicDeviceConfigurationWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 4)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 4;
+    }
+    return _id;
+}
+static const uint qt_meta_data_PhidgetsTemperatureSensor[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       7,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   49, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      27,   26,   26,   26, 0x0a,
+      35,   26,   26,   26, 0x0a,
+      42,   26,   26,   26, 0x08,
+
+ // methods: signature, parameters, type, tag, flags
+      64,   26,   60,   26, 0x02,
+      92,   84,   79,   26, 0x02,
+     121,   84,  113,   26, 0x02,
+     144,   84,  113,   26, 0x02,
+
+ // constructors: signature, parameters, type, tag, flags
+     182,  170,   26,   26, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_PhidgetsTemperatureSensor[] = {
+    "PhidgetsTemperatureSensor\0\0start()\0"
+    "stop()\0getMeasurements()\0int\0"
+    "channelCount()\0bool\0channel\0"
+    "isChannelHidden(int)\0QString\0"
+    "channelColumnName(int)\0channelIndicatorText(int)\0"
+    "deviceIndex\0PhidgetsTemperatureSensor(QModelIndex)\0"
+};
+
+void PhidgetsTemperatureSensor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { PhidgetsTemperatureSensor *_r = new PhidgetsTemperatureSensor((*reinterpret_cast< const QModelIndex(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
+        }
+    } else if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        PhidgetsTemperatureSensor *_t = static_cast<PhidgetsTemperatureSensor *>(_o);
+        switch (_id) {
+        case 0: _t->start(); break;
+        case 1: _t->stop(); break;
+        case 2: _t->getMeasurements(); break;
+        case 3: { int _r = _t->channelCount();
+            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; }  break;
+        case 4: { bool _r = _t->isChannelHidden((*reinterpret_cast< int(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
+        case 5: { QString _r = _t->channelColumnName((*reinterpret_cast< int(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
+        case 6: { QString _r = _t->channelIndicatorText((*reinterpret_cast< int(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData PhidgetsTemperatureSensor::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject PhidgetsTemperatureSensor::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_PhidgetsTemperatureSensor,
+      qt_meta_data_PhidgetsTemperatureSensor, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &PhidgetsTemperatureSensor::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *PhidgetsTemperatureSensor::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *PhidgetsTemperatureSensor::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_PhidgetsTemperatureSensor))
+        return static_cast<void*>(const_cast< PhidgetsTemperatureSensor*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int PhidgetsTemperatureSensor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 7)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 7;
+    }
+    return _id;
+}
 static const uint qt_meta_data_LinearSplineInterpolationConfWidget[] = {
 
  // content:

src/phidgets.w

+@** Phidgets 1048.
+
+\noindent Phidgets, Inc. has provided one of their four channel temperature
+sensor devices so that support could be added to \pn{}. This was originally
+planned for version 1.7, however early support was rushed in for the 1.6.3
+release. As a result, this support is not full featured, but it should still be
+adequate for the most common uses.
+
+Two configuration widgets are required. The first is for the device as a whole.
+
+@<Class declarations@>=
+class PhidgetsTemperatureSensorConfWidget : public BasicDeviceConfigurationWidget
+{
+	Q_OBJECT
+	public:
+		Q_INVOKABLE PhidgetsTemperatureSensorConfWidget(DeviceTreeModel *model,
+                                                        const QModelIndex &index);
+	private slots:
+		void addChannel();
+		void updateRate(int ms);
+};
+
+@ This widget allows specification of a device wide sample rate and allows
+adding channels for the device to monitor. The device specifications indicate
+temperature updates happen up to 25 times per second, but this is generally
+excessive for \pn{} so a default rate is set to a multiple of this close to
+3 updates per second. There are other options for collecting measurements from
+this device and I have not yet had time to experiment with all of the options
+to determine the best approach suitable for coffee roasting applications.
+
+@<Phidgets implementation@>=
+PhidgetsTemperatureSensorConfWidget::PhidgetsTemperatureSensorConfWidget(DeviceTreeModel *model,
+                                                                         const QModelIndex &index)
+	: BasicDeviceConfigurationWidget(model, index)
+{
+	QFormLayout *layout = new QFormLayout;
+	QPushButton *addChannelButton = new QPushButton(tr("Add Channel"));
+	QSpinBox *sampleRate = new QSpinBox;
+	sampleRate->setMinimum(40);
+	sampleRate->setMaximum(600);
+	sampleRate->setSingleStep(40);
+	sampleRate->setValue(360);
+
+	@<Get device configuration data for current node@>@;
+	for(int i = 0; i < configData.size(); i++)
+	{
+		node = configData.at(i).toElement();
+		if(node.attribute("name") == "sampleRate")
+		{
+			sampleRate->setValue(node.attribute("value").toInt());
+		}
+	}
+	updateRate(sampleRate->value());
+
+	connect(sampleRate, SIGNAL(valueChanged(int)), this, SLOT(updateRate(int)));
+	connect(addChannelButton, SIGNAL(clicked()), this, SLOT(addChannel()));
+
+	layout->addRow(addChannelButton);
+	layout->addRow(tr("Sample rate:"), sampleRate);
+	setLayout(layout);
+}
+
+@ Adding another channel is handled in the usual way, with the channel
+configured in a separate widget.
+
+@<Phidgets implementation@>=
+void PhidgetsTemperatureSensorConfWidget::addChannel()
+{
+	insertChildNode(tr("Channel"), "phidgets1048channel");
+}
+
+@ Changes to the sample rate are saved as an attribute of the node as usual.
+
+@<Phidgets implementation@>=
+void PhidgetsTemperatureSensorConfWidget::updateRate(int ms)
+{
+	updateAttribute("sampleRate", QString("%1").arg(ms));
+}
+
+@ The other required configuration widget is for a single channel.
+
+@<Class declarations@>=
+class PhidgetTemperatureSensorChannelConfWidget : public BasicDeviceConfigurationWidget
+{
+	Q_OBJECT
+	public:
+		Q_INVOKABLE PhidgetTemperatureSensorChannelConfWidget(DeviceTreeModel *model,
+                                                              const QModelIndex &index);
+	private slots:
+		void updateColumnName(const QString &value);
+		void updateHidden(bool hidden);
+		void updateTC(int index);
+		void updateChannel(int channel);
+	private:
+		QComboBox *tcType;
+};
+
+@ For each channel it is necessary to specify which channel of the device
+measurements will come in on. The thermocouple type should be set to match the
+type of the thermocouple attached to that channel. The column name and if the
+channel is hidden has the same meaning as in channels on other devices.
+
+@<Phidgets implementation@>=
+PhidgetTemperatureSensorChannelConfWidget::PhidgetTemperatureSensorChannelConfWidget(
+	DeviceTreeModel *model, const QModelIndex &index)
+	: BasicDeviceConfigurationWidget(model, index),
+	tcType(new QComboBox)
+{
+	QFormLayout *layout = new QFormLayout;
+	QLineEdit *columnName = new QLineEdit;
+	layout->addRow(tr("Column Name:"), columnName);
+	QCheckBox *hideSeries = new QCheckBox("Hide this channel");
+	layout->addRow(hideSeries);
+	layout->addRow(tr("Thermocouple Type:"), tcType);
+	tcType->addItem("Type K", "1");
+	tcType->addItem("Type J", "2");
+	tcType->addItem("Type E", "3");
+	tcType->addItem("Type T", "4");
+	QSpinBox *channel = new QSpinBox;
+	layout->addRow(tr("Channel:"), channel);
+	channel->setMinimum(0);
+	channel->setMaximum(3);
+	setLayout(layout);
+	@<Get device configuration data for current node@>@;
+	for(int i = 0; i < configData.size(); i++)
+	{
+		node = configData.at(i).toElement();
+		if(node.attribute("name") == "columnname")
+		{
+			columnName->setText(node.attribute("value"));
+		}
+		else if(node.attribute("name") == "hidden")
+		{
+			hideSeries->setChecked(node.attribute("value") == "true");
+		}
+		else if(node.attribute("name") == "tctype")
+		{
+			tcType->setCurrentIndex(tcType->findData(node.attribute("value")));
+		}
+		else if(node.attribute("name") == "channel")
+		{
+			channel->setValue(node.attribute("value").toInt());
+		}
+	}
+	updateColumnName(columnName->text());
+	updateHidden(hideSeries->isChecked());
+	updateTC(tcType->currentIndex());
+	updateChannel(channel->value());
+	connect(columnName, SIGNAL(textEdited(QString)), this, SLOT(updateColumnName(QString)));
+	connect(hideSeries, SIGNAL(toggled(bool)), this, SLOT(updateHidden(bool)));
+	connect(tcType, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTC(int)));
+	connect(channel, SIGNAL(valueChanged(int)), this, SLOT(updateChannel(int)));
+}
+
+@ Channel configuration settings are persisted as they are made.
+
+@<Phidgets implementation@>=
+void PhidgetTemperatureSensorChannelConfWidget::updateColumnName(const QString &value)
+{
+	updateAttribute("columnname", value);
+}
+
+void PhidgetTemperatureSensorChannelConfWidget::updateHidden(bool hidden)
+{
+	updateAttribute("hidden", hidden ? "true" : "false");
+}
+
+void PhidgetTemperatureSensorChannelConfWidget::updateTC(int index)
+{
+	updateAttribute("tctype", tcType->itemData(index).toString());
+}
+
+void PhidgetTemperatureSensorChannelConfWidget::updateChannel(int channel)
+{
+	updateAttribute("channel", QString("%1").arg(channel));
+}
+
+@ The configuration widgets need to be registered so they can be instantiated as
+appropriate.
+
+@<Register device configuration widgets@>=
+app.registerDeviceConfigurationWidget("phidgets1048",
+	PhidgetsTemperatureSensorConfWidget::staticMetaObject);
+app.registerDeviceConfigurationWidget("phidgets1048channel",
+	PhidgetTemperatureSensorChannelConfWidget::staticMetaObject);
+
+@ A |NodeInserter| for the device node is also required, but this should only
+be provided if the required library is installed.
+
+@<Register top level device configuration nodes@>=
+QLibrary phidgetsCheck("phidget21");
+if(phidgetsCheck.load())
+{
+	inserter = new NodeInserter(tr("Phidgets 1048"), tr("Phidgets 1048"),
+		"phidgets1048", NULL);
+	topLevelNodeInserters.append(inserter);
+	phidgetsCheck.unload();
+}
+else
+{
+	phidgetsCheck.setFileName("Phidget21.framework/Phidget21");
+	if(phidgetsCheck.load())
+	{
+		inserter = new NodeInserter(tr("Phidgets 1048"), tr("Phidgets 1048"),
+		"phidgets1048", NULL);
+		topLevelNodeInserters.append(inserter);
+		phidgetsCheck.unload();
+	}
+}
+
+@ As usual, a class representing the device is provided.
+
+@<Class declarations@>=
+class PhidgetsTemperatureSensor : public QObject
+{
+	Q_OBJECT
+	public:
+		Q_INVOKABLE PhidgetsTemperatureSensor(const QModelIndex &deviceIndex);
+		Q_INVOKABLE int channelCount();
+		Channel* getChannel(int channel);
+		Q_INVOKABLE bool isChannelHidden(int channel);
+		Q_INVOKABLE QString channelColumnName(int channel);
+		Q_INVOKABLE QString channelIndicatorText(int channel);
+	public slots:
+		void start();
+		void stop();
+	private slots:
+		void getMeasurements();
+	private:
+		QList<int> channelIndices;
+		QList<int> tctypes;
+		QList<Channel*> channelList;
+		QMap<int, Channel*> channelMap;
+		QList<bool> hiddenState;
+		QList<QString> columnNames;
+		QList<QString> indicatorTexts;
+		QLibrary driver;
+		QTimer sampleTimer;
+		void *device;
+		@<Phidgets 1048 function pointers@>@;
+};
+
+@ The constructor uses the configuration data to set up the interface used for
+integration with the logging view.
+
+@<Phidgets implementation@>=
+PhidgetsTemperatureSensor::PhidgetsTemperatureSensor(const QModelIndex &index)
+	: QObject(NULL), driver("phidget21"), device(NULL)
+{
+	DeviceTreeModel *model = (DeviceTreeModel *)(index.model());
+	QDomElement deviceReferenceElement =
+		model->referenceElement(model->data(index, Qt::UserRole).toString());
+	QDomNodeList deviceConfigData = deviceReferenceElement.elementsByTagName("attribute");
+	QDomElement node;
+	for(int i = 0; i < deviceConfigData.size(); i++)
+	{
+		node = deviceConfigData.at(i).toElement();
+		if(node.attribute("name") == "sampleRate")
+		{
+			sampleTimer.setInterval(node.attribute("value").toInt());
+		}
+	}
+	if(model->hasChildren(index))
+	{
+		for(int i = 0; i < model->rowCount(index); i++)
+		{
+			QModelIndex channelIndex = model->index(i, 0, index);
+			QDomElement channelReference = model->referenceElement(model->data(channelIndex, 32).toString());
+			QDomElement channelReferenceElement = model->referenceElement(model->data(channelIndex, Qt::UserRole).toString());
+			QDomNodeList channelConfigData = channelReferenceElement.elementsByTagName("attribute");
+			for(int j = 0; j < channelConfigData.size(); j++)
+			{
+				node = channelConfigData.at(j).toElement();
+				if(node.attribute("name") == "channel")
+				{
+					int channelID = node.attribute("value").toInt();
+					channelIndices.append(channelID);
+					Channel* channel = new Channel;
+					channelList.append(channel);
+					channelMap.insert(channelID, channel);
+				}
+				else if(node.attribute("name") == "hidden")
+				{
+					hiddenState.append(node.attribute("value") == "true");
+				}
+				else if(node.attribute("name") == "columnname")
+				{
+					columnNames.append(node.attribute("value"));
+				}
+				else if(node.attribute("name") == "tctype")
+				{
+					tctypes.append(node.attribute("value").toInt());
+				}
+			}
+			indicatorTexts.append(model->data(channelIndex, Qt::DisplayRole).toString());
+		}
+	}
+}
+
+@ There is a distinction between logical and physical channels. Physical
+channels are specified as a configuration attribute and are used for
+communication with hardware. Logical channels are determined by the order of
+nodes in the configuration and are used for integrating device support with the
+rest of the program.
+
+@<Phidgets implementation@>=
+int PhidgetsTemperatureSensor::channelCount()
+{
+	return channelList.length();
+}
+
+Channel* PhidgetsTemperatureSensor::getChannel(int channel)
+{
+	return channelList.at(channel);
+}
+
+@ Some information is available about each channel.
+
+@<Phidgets implementation@>=
+bool PhidgetsTemperatureSensor::isChannelHidden(int channel)
+{
+	return hiddenState.at(channel);
+}
+
+QString PhidgetsTemperatureSensor::channelColumnName(int channel)
+{
+	if(channel >= 0 && channel < columnNames.length())
+	{
+		return columnNames.at(channel);
+	}
+	return QString();
+}
+
+QString PhidgetsTemperatureSensor::channelIndicatorText(int channel)
+{
+	if(channel >= 0 && channel < indicatorTexts.length())
+	{
+		return indicatorTexts.at(channel);
+	}
+	return QString();
+}
+
+@ To avoid introducing dependencies on a library that is only needed for
+hardware that may not exist, the phidget21 library is only loaded at runtime
+if it is needed. Some function pointers and associated types are, therefore,
+required. This approach also means the associated header does not need to
+exist at compile time.
+
+@<Phidgets 1048 function pointers@>=
+#ifdef _WIN32
+typedef int (__stdcall *PhidgetHandleOnly)(void *);
+typedef int (__stdcall *PhidgetHandleInt)(void *, int);
+typedef int (__stdcall *PhidgetHandleIntInt)(void *, int, int);
+typedef int (__stdcall *PhidgetHandleIntDoubleOut)(void *, int, double*);
+#else
+typedef int (*PhidgetHandleOnly)(void *);
+typedef int (*PhidgetHandleInt)(void *, int);
+typedef int (*PhidgetHandleIntInt)(void *, int, int);
+typedef int (*PhidgetHandleIntDoubleOut)(void *, int, double*);
+#endif
+PhidgetHandleOnly createDevice;
+PhidgetHandleInt openDevice;
+PhidgetHandleInt waitForOpen;
+PhidgetHandleIntInt setTCType;
+PhidgetHandleIntDoubleOut getTemperature;
+PhidgetHandleOnly closeDevice;
+PhidgetHandleOnly deleteDevice;
+
+@ Library loading is deferred until we are ready to open a device.
+
+@<Phidgets implementation@>=
+void PhidgetsTemperatureSensor::start()
+{
+	if(!driver.load())
+	{
+		driver.setFileName("Phidget21.framework/Phidget21");
+		if(!driver.load())
+		{
+			QMessageBox::critical(NULL, tr("Typica: Driver not found"),
+				tr("Failed to find phidget21. Please install it."));
+			return;
+		}
+	}
+	if((createDevice = (PhidgetHandleOnly) driver.resolve("CPhidgetTemperatureSensor_create")) == 0 || @|
+       (openDevice = (PhidgetHandleInt) driver.resolve("CPhidget_open")) == 0 || @|
+       (waitForOpen = (PhidgetHandleInt) driver.resolve("CPhidget_waitForAttachment")) == 0 || @|
+       (setTCType = (PhidgetHandleIntInt) driver.resolve("CPhidgetTemperatureSensor_setThermocoupleType")) == 0 || @|
+       (getTemperature = (PhidgetHandleIntDoubleOut) driver.resolve("CPhidgetTemperatureSensor_getTemperature")) == 0 || @|
+       (closeDevice = (PhidgetHandleOnly) driver.resolve("CPhidget_close")) == 0 || @|
+       (deleteDevice = (PhidgetHandleOnly) driver.resolve("CPhidget_delete")) == 0)
+	{
+		QMessageBox::critical(NULL, tr("Typica: Link error"),
+			tr("Failed to link a required symbol in phidget21."));
+		return;
+	}
+	createDevice(&device);
+	openDevice(device, -1);
+	int error;
+	if(error = waitForOpen(device, 10000))
+	{
+		closeDevice(device);
+		deleteDevice(device);
+		QMessageBox::critical(NULL, tr("Typica: Failed to Open Device"),
+			tr("CPhidget_waitForAttachment returns error %n", 0, error));
+		return;
+	}
+	for(int i = 0; i < channelIndices.length(); i++)
+	{
+		setTCType(device, channelIndices.at(i), tctypes.at(i));
+	}
+	connect(&sampleTimer, SIGNAL(timeout()), this, SLOT(getMeasurements()));
+	sampleTimer.start();
+}
+
+@ Once the device is started, we periodically request measurements and pass
+them to the appropriate |Channel|.
+
+@<Phidgets implementation@>=
+void PhidgetsTemperatureSensor::getMeasurements()
+{
+	double value = 0.0;
+	QTime time = QTime::currentTime();
+	foreach(int i, channelIndices)
+	{
+		getTemperature(device, i, &value);
+		Measurement measure(value * 9.0 / 5.0 + 32.0, time);
+		channelMap[i]->input(measure);
+	}
+}
+
+@ Some clean up is needed in the |stop()| method.
+
+@<Phidgets implementation@>=
+void PhidgetsTemperatureSensor::stop()
+{
+	sampleTimer.stop();
+	closeDevice(device);
+	deleteDevice(device);
+	driver.unload();
+}
+
+@ The implementation currently goes into typica.cpp.
+
+@<Class implementations@>=
+@<Phidgets implementation@>@;
+
+@ The |PhidgetsTemperatureSensor| needs to be available from the host
+environment. This detail is likely to change in the future.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructPhidgetsTemperatureSensor);
+value = engine->newQMetaObject(&PhidgetsTemperatureSensor::staticMetaObject, constructor);
+engine->globalObject().setProperty("PhidgetsTemperatureSensor", value);
+
+@ Two function prototypes are needed.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructPhidgetsTemperatureSensor(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Phidgets_getChannel(QScriptContext *context, QScriptEngine *engine);
+
+@ The script constructor is trivial.
+
+@<Functions for scripting@>=
+QScriptValue constructPhidgetsTemperatureSensor(QScriptContext *context, QScriptEngine *engine)
+{
+	if(context->argumentCount() != 1)
+	{
+		context->throwError("Incorrect number of arguments passed to "@|
+                            "PhidgetsTemperatureSensor constructor. This takes "@|
+                            "a QModelIndex.");
+	}
+	QScriptValue object = engine->newQObject(new PhidgetsTemperatureSensor(argument<QModelIndex>(0, context)), QScriptEngine::ScriptOwnership);
+	setQObjectProperties(object, engine);
+	object.setProperty("getChannel", engine->newFunction(Phidgets_getChannel));
+	return object;
+}
+
+@ As usual, a wrapper is needed for getting channels.
+
+@<Functions for scripting@>=
+QScriptValue Phidgets_getChannel(QScriptContext *context, QScriptEngine *engine)
+{
+	PhidgetsTemperatureSensor *self = getself<PhidgetsTemperatureSensor *>(context);
+	QScriptValue object;
+	if(self)
+	{
+		object = engine->newQObject(self->getChannel(argument<int>(0, context)));
+		setChannelProperties(object, engine);
+	}
+	return object;
+}

src/scale.cpp

-/*869:*/
+/*964:*/
 #line 131 "./scales.w"
 
 #include "scale.h"
 connect(this,SIGNAL(readyRead()),this,SLOT(dataAvailable()));
 }
 
-/*:869*//*870:*/
+/*:964*//*965:*/
 #line 149 "./scales.w"
 
 void SerialScale::dataAvailable()
 }
 else
 {
-/*871:*/
+/*966:*/
 #line 189 "./scales.w"
 
 QStringList responseParts= QString(responseBuffer.simplified()).split(' ');
 }
 emit newMeasurement(weight,unit);
 
-/*:871*/
+/*:966*/
 #line 161 "./scales.w"
 
 responseBuffer.clear();
 }
 }
 
-/*:870*//*872:*/
+/*:965*//*967:*/
 #line 220 "./scales.w"
 
 void SerialScale::tare()
 write("!KP\x0D");
 }
 
-/*:872*/
+/*:967*/

src/scale.h

-/*868:*/
+/*963:*/
 #line 103 "./scales.w"
 
 #ifndef TypicaScaleInclude
 
 #endif
 
-/*:868*/
+/*:963*/

src/typica.w

 
 @i unsupportedserial.w
 
+@i phidgets.w
+
 @* Configuration widget for a calibrated data series.
 
 \noindent This control is used for adding a |LinearSplineInterpolator| to the

src/units.cpp

-/*226:*/
+/*253:*/
 #line 42 "./units.w"
 
 #include "units.h"
 
-/*:226*//*227:*/
+/*:253*//*254:*/
 #line 52 "./units.w"
 
 bool Units::isTemperatureUnit(Unit unit)
 unit==Rankine);
 }
 
-/*:227*//*228:*/
+/*:254*//*255:*/
 #line 70 "./units.w"
 
 double Units::convertTemperature(double value,Unit fromUnit,Unit toUnit)
 return 0;
 }
 
-/*:228*//*229:*/
+/*:255*//*256:*/
 #line 156 "./units.w"
 
 double Units::convertRelativeTemperature(double value,Unit fromUnit,Unit toUnit)
 return 0;
 }
 
-/*:229*//*230:*/
+/*:256*//*257:*/
 #line 254 "./units.w"
 
 double Units::convertWeight(double value,Unit fromUnit,Unit toUnit)
 unit==Gram);
 }
 
-/*:230*/
+/*:257*/

src/units.h

-/*225:*/
+/*252:*/
 #line 8 "./units.w"
 
 #include <QObject> 
 
 #endif
 
-/*:225*/
+/*:252*/

src/webelement.cpp

-/*513:*/
-#line 365 "./webview.w"
+/*546:*/
+#line 368 "./webview.w"
 
 #include "webelement.h"
 
-/*511:*/
-#line 308 "./webview.w"
+/*544:*/
+#line 311 "./webview.w"
 
 TypicaWebElement::TypicaWebElement(QWebElement element):e(element)
 {
 
 }
 
-/*:511*//*512:*/
-#line 317 "./webview.w"
+/*:544*//*545:*/
+#line 320 "./webview.w"
 
 void TypicaWebElement::appendInside(const QString&markup)
 {
 e.setPlainText(text);
 }
 
-/*:512*/
-#line 368 "./webview.w"
+/*:545*/
+#line 371 "./webview.w"
 
 
-/*:513*/
+/*:546*/

src/webelement.h

-/*506:*/
-#line 245 "./webview.w"
+/*539:*/
+#line 248 "./webview.w"
 
 #include <QWebElement> 
 #include <QObject> 
 
 #endif
 
-/*:506*/
+/*:539*/

src/webview.cpp

-/*491:*/
-#line 49 "./webview.w"
+/*524:*/
+#line 50 "./webview.w"
 
 #include "webview.h"
 
-/*492:*/
-#line 56 "./webview.w"
+/*525:*/
+#line 57 "./webview.w"
 
 TypicaWebView::TypicaWebView():QWebView()
 {
 connect(page(),SIGNAL(linkClicked(QUrl)),this,SLOT(linkDelegate(QUrl)));
 }
 
-/*:492*//*493:*/
-#line 72 "./webview.w"
+/*:525*//*526:*/
+#line 73 "./webview.w"
 
 void TypicaWebView::linkDelegate(const QUrl&url)
 {
 if(url.scheme()=="typica")
 {
 QString address(url.toEncoded());
-/*494:*/
-#line 90 "./webview.w"
+/*527:*/
+#line 91 "./webview.w"
 
 if(address=="typica://aboutqt")
 {
 return;
 }
 
-/*:494*/
-#line 78 "./webview.w"
+/*:527*/
+#line 79 "./webview.w"
 
-/*495:*/
-#line 99 "./webview.w"
+/*528:*/
+#line 100 "./webview.w"
 
 if(address.startsWith("typica://script/"))
 {
 return;
 }
 
-/*:495*/
-#line 79 "./webview.w"
+/*:528*/
+#line 80 "./webview.w"
 
 }
 else
 }
 }
 
-/*:493*//*496:*/
-#line 111 "./webview.w"
+/*:526*//*529:*/
+#line 112 "./webview.w"
 
 void TypicaWebView::load(const QString&url)
 {
 
 void TypicaWebView::setContent(QIODevice*device)
 {
+QSettings settings;
 device->reset();
 QByteArray content= device->readAll();
-QWebView::setContent(content,"application/xhtml+xml");
+QUrl baseDir= QUrl("file://"+settings.value("config").toString()+"/");
+QWebView::setContent(content,"application/xhtml+xml",baseDir);
 }
 
 QString TypicaWebView::saveXml()
 return page()->currentFrame()->documentElement().toOuterXml();
 }
 
-/*:496*//*502:*/
-#line 202 "./webview.w"
+/*:529*//*535:*/
+#line 205 "./webview.w"
 
 QWebElement TypicaWebView::documentElement()
 {
 return page()->mainFrame()->findFirstElement(selector);
 }
 
-/*:502*/
-#line 52 "./webview.w"
+/*:535*/
+#line 53 "./webview.w"
 
 
-/*:491*/
+/*:524*/

src/webview.h

-/*490:*/
+/*523:*/
 #line 14 "./webview.w"
 
 #include <QWebView> 
 #include <QPrintDialog> 
 #include <QWebFrame> 
 #include <QWebElement> 
+#include <QSettings> 
 
 #ifndef TypicaWebViewHeader
 #define TypicaWebViewHeader
 
 #endif
 
-/*:490*/
+/*:523*/