Add threshold annotations

config/Windows/productionroaster.xml

@@ -457,6 +457,25 @@
 				annotationPanel.addWidget(button);
 				tabControls.push(button);
 			}
+                        else if(driverReference.driver == "thresholdannotation")
+                        {
+                            var noteDetector = new ThresholdDetector();
+                            var noteEmitter = new Annotator(driverReference.annotation);
+                            noteDetector.setThreshold(Number(driverReference.value));
+                            for(var j = 0; j < columnNames.length; j++) {
+                                if(columnNames[j] == driverReference.source) {
+                                    channels[j].newData.connect(noteDetector.newMeasurement);
+                                    break;
+                                }
+                            }
+                            if(Number(driverReference.direction) == 1) {
+                                noteDetector.setEdgeDirection(ThresholdDetector.Descending);
+                            } else {
+                                noteDetector.setEdgeDirection(ThresholdDetector.Ascending);
+                            }
+                            noteDetector.timeForValue.connect(noteEmitter.annotate);
+                            annotationButtons.push(noteEmitter);
+                        }
 			else if(driverReference.driver == "valueannotation")
 			{
 				var checker = new ValueAnnotation;

src/moc_typica.cpp

@@ -1,7 +1,7 @@
 /****************************************************************************
 ** Meta object code from reading C++ file 'typica.cpp'
 **
-** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.6)
+** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.7)
 **
 ** WARNING! All changes made in this file will be lost!
 *****************************************************************************/
@@ -9,7 +9,7 @@
 #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.6. It"
+#error "This file was generated using the moc from 4.8.7. It"
 #error "cannot be used with the include files from this version of Qt."
 #error "(The moc has changed too much.)"
 #endif
@@ -6081,6 +6081,297 @@ int ModbusConfigurator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
     }
     return _id;
 }
+static const uint qt_meta_data_ModbusNGConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       6,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   44, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      26,   20,   19,   19, 0x08,
+      46,   20,   19,   19, 0x08,
+      70,   20,   19,   19, 0x08,
+      88,   20,   19,   19, 0x08,
+     111,   20,   19,   19, 0x08,
+     131,   19,   19,   19, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+     154,  142,   19,   19, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ModbusNGConfWidget[] = {
+    "ModbusNGConfWidget\0\0value\0updatePort(QString)\0"
+    "updateBaudRate(QString)\0updateParity(int)\0"
+    "updateFlowControl(int)\0updateStopBits(int)\0"
+    "addInput()\0model,index\0"
+    "ModbusNGConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void ModbusNGConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { ModbusNGConfWidget *_r = new ModbusNGConfWidget((*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));
+        ModbusNGConfWidget *_t = static_cast<ModbusNGConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updatePort((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 1: _t->updateBaudRate((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 2: _t->updateParity((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 3: _t->updateFlowControl((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 4: _t->updateStopBits((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 5: _t->addInput(); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData ModbusNGConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ModbusNGConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_ModbusNGConfWidget,
+      qt_meta_data_ModbusNGConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ModbusNGConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ModbusNGConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ModbusNGConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ModbusNGConfWidget))
+        return static_cast<void*>(const_cast< ModbusNGConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int ModbusNGConfWidget::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 < 6)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 6;
+    }
+    return _id;
+}
+static const uint qt_meta_data_ModbusNGInputConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       8,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   54, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      31,   25,   24,   24, 0x08,
+      50,   25,   24,   24, 0x08,
+      69,   25,   24,   24, 0x08,
+      89,   25,   24,   24, 0x08,
+     107,   25,   24,   24, 0x08,
+     127,   25,   24,   24, 0x08,
+     143,   25,   24,   24, 0x08,
+     169,   25,   24,   24, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+     200,  188,   24,   24, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ModbusNGInputConfWidget[] = {
+    "ModbusNGInputConfWidget\0\0value\0"
+    "updateStation(int)\0updateAddress(int)\0"
+    "updateFunction(int)\0updateFormat(int)\0"
+    "updateDecimals(int)\0updateUnit(int)\0"
+    "updateColumnName(QString)\0updateHidden(bool)\0"
+    "model,index\0"
+    "ModbusNGInputConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void ModbusNGInputConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { ModbusNGInputConfWidget *_r = new ModbusNGInputConfWidget((*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));
+        ModbusNGInputConfWidget *_t = static_cast<ModbusNGInputConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updateStation((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 1: _t->updateAddress((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 2: _t->updateFunction((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 3: _t->updateFormat((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 4: _t->updateDecimals((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 5: _t->updateUnit((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 6: _t->updateColumnName((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 7: _t->updateHidden((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData ModbusNGInputConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ModbusNGInputConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_ModbusNGInputConfWidget,
+      qt_meta_data_ModbusNGInputConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ModbusNGInputConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ModbusNGInputConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ModbusNGInputConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ModbusNGInputConfWidget))
+        return static_cast<void*>(const_cast< ModbusNGInputConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int ModbusNGInputConfWidget::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 < 8)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 8;
+    }
+    return _id;
+}
+static const uint qt_meta_data_ModbusNG[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       7,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      10,    9,    9,    9, 0x08,
+      28,    9,    9,    9, 0x08,
+      38,    9,    9,    9, 0x08,
+
+ // methods: signature, parameters, type, tag, flags
+      58,    9,   54,    9, 0x02,
+      81,    9,   73,    9, 0x02,
+     104,    9,   73,    9, 0x02,
+     135,    9,  130,    9, 0x02,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ModbusNG[] = {
+    "ModbusNG\0\0sendNextMessage()\0timeout()\0"
+    "dataAvailable()\0int\0channelCount()\0"
+    "QString\0channelColumnName(int)\0"
+    "channelIndicatorText(int)\0bool\0"
+    "isChannelHidden(int)\0"
+};
+
+void ModbusNG::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        ModbusNG *_t = static_cast<ModbusNG *>(_o);
+        switch (_id) {
+        case 0: _t->sendNextMessage(); break;
+        case 1: _t->timeout(); break;
+        case 2: _t->dataAvailable(); break;
+        case 3: { int _r = _t->channelCount();
+            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; }  break;
+        case 4: { QString _r = _t->channelColumnName((*reinterpret_cast< int(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
+        case 5: { QString _r = _t->channelIndicatorText((*reinterpret_cast< int(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
+        case 6: { bool _r = _t->isChannelHidden((*reinterpret_cast< int(*)>(_a[1])));
+            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData ModbusNG::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ModbusNG::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_ModbusNG,
+      qt_meta_data_ModbusNG, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ModbusNG::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ModbusNG::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ModbusNG::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ModbusNG))
+        return static_cast<void*>(const_cast< ModbusNG*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int ModbusNG::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_UnsupportedSerialDeviceConfWidget[] = {
 
  // content:
@@ -7980,4 +8271,193 @@ void ValueAnnotation::annotation(QString _t1, int _t2, int _t3)
     void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
     QMetaObject::activate(this, &staticMetaObject, 0, _a);
 }
+static const uint qt_meta_data_ThresholdAnnotationConfWidget[] = {
+
+ // 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
+      38,   31,   30,   30, 0x08,
+      72,   66,   30,   30, 0x08,
+     102,   96,   30,   30, 0x08,
+     128,  123,   30,   30, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+     166,  154,   30,   30, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ThresholdAnnotationConfWidget[] = {
+    "ThresholdAnnotationConfWidget\0\0source\0"
+    "updateSourceColumn(QString)\0value\0"
+    "updateThreshold(double)\0index\0"
+    "updateDirection(int)\0note\0"
+    "updateAnnotation(QString)\0model,index\0"
+    "ThresholdAnnotationConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void ThresholdAnnotationConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { ThresholdAnnotationConfWidget *_r = new ThresholdAnnotationConfWidget((*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));
+        ThresholdAnnotationConfWidget *_t = static_cast<ThresholdAnnotationConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updateSourceColumn((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 1: _t->updateThreshold((*reinterpret_cast< double(*)>(_a[1]))); break;
+        case 2: _t->updateDirection((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 3: _t->updateAnnotation((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData ThresholdAnnotationConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ThresholdAnnotationConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_ThresholdAnnotationConfWidget,
+      qt_meta_data_ThresholdAnnotationConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ThresholdAnnotationConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ThresholdAnnotationConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ThresholdAnnotationConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ThresholdAnnotationConfWidget))
+        return static_cast<void*>(const_cast< ThresholdAnnotationConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int ThresholdAnnotationConfWidget::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_Annotator[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       6,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       1,       // signalCount
+
+ // signals: signature, parameters, type, tag, flags
+      44,   11,   10,   10, 0x05,
+
+ // slots: signature, parameters, type, tag, flags
+      83,   72,   10,   10, 0x0a,
+     117,  106,   10,   10, 0x0a,
+     160,  143,   10,   10, 0x0a,
+     185,   10,   10,   10, 0x0a,
+     196,   10,   10,   10, 0x08,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_Annotator[] = {
+    "Annotator\0\0annotation,tempcolumn,notecolumn\0"
+    "annotation(QString,int,int)\0annotation\0"
+    "setAnnotation(QString)\0tempcolumn\0"
+    "setTemperatureColumn(int)\0annotationcolumn\0"
+    "setAnnotationColumn(int)\0annotate()\0"
+    "catchTimer()\0"
+};
+
+void Annotator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        Annotator *_t = static_cast<Annotator *>(_o);
+        switch (_id) {
+        case 0: _t->annotation((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
+        case 1: _t->setAnnotation((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 2: _t->setTemperatureColumn((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 3: _t->setAnnotationColumn((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 4: _t->annotate(); break;
+        case 5: _t->catchTimer(); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData Annotator::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject Annotator::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_Annotator,
+      qt_meta_data_Annotator, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &Annotator::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *Annotator::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *Annotator::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_Annotator))
+        return static_cast<void*>(const_cast< Annotator*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int Annotator::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 < 6)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 6;
+    }
+    return _id;
+}
+
+// SIGNAL 0
+void Annotator::annotation(QString _t1, int _t2, int _t3)
+{
+    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
+    QMetaObject::activate(this, &staticMetaObject, 0, _a);
+}
 QT_END_MOC_NAMESPACE

src/thresholdannotation.w

@@ -0,0 +1,235 @@
+@** Threshold Annotations.
+
+\noindent Value annotations are fine for cases where we want to capture the
+fact that a control series has changed to some specific value, but there are
+times when it is more useful to know when a data series has passed through some
+value in a particular direction even if the exact value of interest is never
+directly recorded. For example, it would be possible to automatically mark a
+point near turnaround by watching for a rate of temperature change ascending
+through 0. This could also be set up to match range timers and mark events of
+interest that begin at consistent temperatures.
+
+As usual, this is a feature that must be configured on a per roaster basis.
+
+@<Class declarations@>=
+class ThresholdAnnotationConfWidget : public BasicDeviceConfigurationWidget
+{
+    Q_OBJECT
+    public:
+        Q_INVOKABLE ThresholdAnnotationConfWidget(DeviceTreeModel *model,
+                                                  const QModelIndex &index);
+    private slots:
+        void updateSourceColumn(const QString &source);
+        void updateThreshold(double value);
+        void updateDirection(int index);
+        void updateAnnotation(const QString &note);
+};
+
+@ The configuration widget needs to provide fields for determining which data
+series should be used to generate the annotation, the value that the
+|ThresholdDetector| should use as its trigger, the direction this should fire
+on, and the text of the annotation.
+
+@<ThresholdAnnotationConfWidget implementation@>=
+ThresholdAnnotationConfWidget::ThresholdAnnotationConfWidget(DeviceTreeModel *model,
+                                                             const QModelIndex &index)
+: BasicDeviceConfigurationWidget(model, index)
+{
+    QFormLayout *layout = new QFormLayout;
+    QLineEdit *source = new QLineEdit;
+    layout->addRow(tr("Source column name:"), source);
+    QDoubleSpinBox *value = new QDoubleSpinBox;
+
+@ A |QDoubleSpinBox| is used for entering the value. By default this allows for
+entering data in a range from 0 to 99.99, however this range is inadequate for
+many coffee roasting applications. Instead, we allow the full range of the
+underlying data type, but as this might be different on different platforms,
+another header is required.
+
+@<Header files to include@>=
+#include <limits>
+
+@ The number of decimal places is limited to 2, however this is an arbitrary
+decision which can be raised later if needed.
+
+@<ThresholdAnnotationConfWidget implementation@>=
+
+    value->setMinimum(std::numeric_limits<double>::min());
+    value->setMaximum(std::numeric_limits<double>::max());
+    value->setDecimals(2);
+    layout->addRow(tr("Threshold value:"), value);
+    QComboBox *direction = new QComboBox;
+    direction->addItem(tr("Ascending"));
+    direction->addItem(tr("Descending"));
+    layout->addRow(tr("Direction:"), direction);
+    QLineEdit *annotation = new QLineEdit;
+    layout->addRow(tr("Annotation:"), annotation);
+    @<Get device configuration data for current node@>@;
+    for(int i = 0; i < configData.size(); i++)
+    {
+        node = configData.at(i).toElement();
+        if(node.attribute("name") == "source")
+        {
+            source->setText(node.attribute("value"));
+        }
+        else if(node.attribute("name") == "value")
+        {
+            value->setValue(node.attribute("value").toDouble());
+        }
+        else if(node.attribute("name") == "direction")
+        {
+            direction->setCurrentIndex(node.attribute("value").toInt());
+        }
+        else if(node.attribute("name") == "annotation")
+        {
+            annotation->setText(node.attribute("value"));
+        }
+    }
+    updateSourceColumn(source->text());
+    updateThreshold(value->value());
+    updateDirection(direction->currentIndex());
+    updateAnnotation(annotation->text());
+    connect(source, SIGNAL(textEdited(QString)), this, SLOT(updateSourceColumn(QString)));
+    connect(value, SIGNAL(valueChanged(double)), this, SLOT(updateThreshold(double)));
+    connect(direction, SIGNAL(currentIndexChanged(int)), this, SLOT(updateDirection(int)));
+    connect(annotation, SIGNAL(textEdited(QString)), this, SLOT(updateAnnotation(QString)));
+    setLayout(layout);
+}
+
+@ Configuration of the model is done as usual.
+
+@<ThresholdAnnotationConfWidget implementation@>=
+void ThresholdAnnotationConfWidget::updateSourceColumn(const QString &source)
+{
+    updateAttribute("source", source);
+}
+
+void ThresholdAnnotationConfWidget::updateThreshold(double value)
+{
+    updateAttribute("value", QString("%1").arg(value));
+}
+
+void ThresholdAnnotationConfWidget::updateDirection(int direction)
+{
+    updateAttribute("direction", QString("%1").arg(direction));
+}
+
+void ThresholdAnnotationConfWidget::updateAnnotation(const QString &annotation)
+{
+    updateAttribute("annotation", annotation);
+}
+
+@ The configurationwidget is registered with the configuration system as usual.
+
+@<Register device configuration widgets@>=
+app.registerDeviceConfigurationWidget("thresholdannotation",
+                                      ThresholdAnnotationConfWidget::staticMetaObject);
+
+@ A NodeInserter makes the configuration available.
+
+@<Add annotation control node inserters@>=
+NodeInserter *thresholdAnnotationInserter = new NodeInserter(tr("Threshold Annotation"),
+                                                             tr("Threshold Annotation"),
+                                                             "thresholdannotation");
+annotationMenu->addAction(thresholdAnnotationInserter);
+connect(thresholdAnnotationInserter, SIGNAL(triggered(QString, QString)),
+        this, SLOT(insertChildNode(QString, QString)));
+
+@ While we could use |ThresholdDetector| in the configuration directly, it is
+easier to provide another class with the same interface as |AnnotationButton|
+to leverage existing code for handling these.
+
+@<Class declarations@>=
+class Annotator : public QObject
+{@t\1@>@/
+    Q_OBJECT@;
+    QString note;
+    int tc;
+    int ac;
+    QTimer t;
+    public:
+        Annotator(const QString &text);@/
+    @t\4@>public slots@t\kern-3pt@>:@/
+        void setAnnotation(const QString &annotation);
+        void setTemperatureColumn(int tempcolumn);
+        void setAnnotationColumn(int annotationcolumn);
+        void annotate();
+    private slots:
+        void catchTimer();
+    signals:@/
+        void annotation(QString annotation, int tempcolumn, int notecolumn);@t\2@>@/
+}@t\kern-3pt@>;
+
+@ To use this class with a |ThresholdDetector|, simply connect the
+|timeForValue()| signal to the |annotate()| slot and use the existing
+|AnnotationButton| code to keep the columns up to date.
+
+@<Annotator implementation@>=
+Annotator::Annotator(const QString &text) : QObject(NULL), note(text)
+{
+    t.setInterval(0);
+    t.setSingleShot(true);
+    connect(&t, SIGNAL(timeout()), this, SLOT(catchTimer()));
+}
+
+void Annotator::setAnnotation(const QString &annotation)
+{
+    note = annotation;
+}
+
+void Annotator::setTemperatureColumn(int tempcolumn)
+{
+    tc = tempcolumn;
+}
+
+void Annotator::setAnnotationColumn(int annotationcolumn)
+{
+    ac = annotationcolumn;
+}
+
+@ When connecting a |ThresholdDetector| to an |Annotator| directly, the
+annotation can be recorded before the measurement reaches the log. The result
+of this is that the annotation appears with the measurement immediately before
+the one it should appear next to. To solve this, the annotation is delayed
+until the next iteration of the event loop.
+
+@<Annotator implementation@>=
+void Annotator::catchTimer()
+{
+    emit annotation(note, tc, ac);
+}
+
+void Annotator::annotate()
+{
+    t.start();
+}
+
+@ It must be possible to create these from a script.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructAnnotator(QScriptContext *context,
+                                QScriptEngine *engine);
+void setAnnotatorProperties(QScriptValue value, QScriptEngine *engine);
+
+@ The engine is informed of the constructor.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructAnnotator);
+value = engine->newQMetaObject(&Annotator::staticMetaObject, constructor);
+engine->globalObject().setProperty("Annotator", value);
+
+@ The implementation is trivial.
+
+@<Functions for scripting@>=
+QScriptValue constructAnnotator(QScriptContext *context, QScriptEngine *engine)
+{
+    QScriptValue object = engine->newQObject(new Annotator(argument<QString>(0, context)));
+    setAnnotatorProperties(object, engine);
+    return object;
+}
+
+void setAnnotatorProperties(QScriptValue value, QScriptEngine *engine)
+{
+    setQObjectProperties(value, engine);
+}
+

src/typica.w

@@ -610,6 +610,8 @@ generated file empty.
 @<ValueAnnotation implementation@>@/
 @<ValueAnnotationConfWidget implementation@>@/
 @<ModbusNG implementation@>@/
+@<ThresholdAnnotationConfWidget implementation@>@/
+@<Annotator implementation@>@/
 
 @ A few headers are required for various parts of \pn{}. These allow the use of
 various Qt modules.
@@ -19988,6 +19990,8 @@ app.registerDeviceConfigurationWidget("translation", TranslationConfWidget::stat
 
 @i valueannotation.w
 
+@i thresholdannotation.w
+
 @** Local changes.
 
 \noindent This is the end of \pn{} as distributed by its author. It is expected