Add multi-range timers

config/Windows/productionroaster.xml

 		var roasterIndex = roasterlist.currentIndex;
 		var channels = new Array();
 		var annotationButtons = new Array();
+                var rangetimers = new Array();
 		var nidevices = new Array();
 		var dataqsdkdevices = new Array();
 		var jsdevices = new Array();
 				}
                                 else if(driverReference.driver == "coolingtimer")
                                 {
-                                    var coolingTimer = new TimerDisplay;
+                                    var coolingTimer = new TimerDisplay();
                                     coolingTimer.setDisplayFormat("mm:ss");
                                     var decorator = new WidgetDecorator(coolingTimer, configModel.data(driverIndex, 0), 2);
                                     indicatorPanel.addWidget(decorator);
                                     coolingTimer.setResetValue(timeValue);
                                     stop.clicked.connect(coolingTimer.startTimer);
                                 }
+                                else if(driverReference.driver == "rangetimer")
+                                {
+                                    rangetimers.push(new TimerDisplay());
+                                    var rangeTimer = rangetimers[rangetimers.length - 1];
+                                    rangeTimer.setDisplayFormat("mm:ss");
+                                    var decorator = new WidgetDecorator(rangeTimer, configModel.data(driverIndex, 0), 2);
+                                    indicatorPanel.addWidget(decorator);
+                                    stop.clicked.connect(rangeTimer.stopTimer);
+                                    start.clicked.connect(rangeTimer.reset);
+                                    if(driverReference.starttrigger == "batch")
+                                    {
+                                        start.clicked.connect(rangeTimer.startTimer);
+                                    }
+                                    else if(driverReference.starttrigger == "manual")
+                                    {
+                                        var startButton = new AnnotationButton(driverReference.startbuttontext);
+                                        startButton.clicked.connect(rangeTimer.startTimer);
+                                        annotationPanel.addWidget(startButton);
+                                        tabControls.push(button);
+                                    }
+                                    else if(driverReference.starttrigger == "value")
+                                    {
+                                        var startTrigger = new ThresholdDetector();
+                                        startTrigger.setThreshold(Number(driverReference.startvalue));
+                                        var scope = new Object;
+                                        scope.invoke = function() {
+                                            if(timer.running && !(arguments.callee.rangeTimer.running))
+                                            {
+                                                arguments.callee.rangeTimer.startTimer();
+                                            }
+                                        };
+                                        scope.invoke.rangeTimer = rangeTimer;
+                                        startTrigger.timeForValue.connect(scope.invoke);
+                                        for(var j = 0; j < columnNames.length; j++)
+                                        {
+                                            if(columnNames[j] == driverReference.startcolumnname)
+                                            {
+                                                channels[j].newData.connect(startTrigger.newMeasurement);
+                                            }
+                                        }
+                                    }
+                                    stop.clicked.connect(rangeTimer.stopTimer)
+                                    if(driverReference.stoptrigger == "manual")
+                                    {
+                                        var stopButton = new AnnotationButton(driverReference.stopbuttontext);
+                                        stopButton.clicked.connect(rangeTimer.stopTimer);
+                                        annotationPanel.addWidget(stopButton);
+                                        tabControls.push(button);
+                                    }
+                                    else if(driverReference.stoptrigger == "value")
+                                    {
+                                        var stopTrigger = new ThresholdDetector();
+                                        stopTrigger.setThreshold(Number(driverReference.stopvalue));
+                                        stopTrigger.timeForValue.connect(rangeTimer.stopTimer);
+                                        for(var j = 0; j < columnNames.length; j++)
+                                        {
+                                            if(columnNames[j] == driverReference.stopcolumnname)
+                                            {
+                                                channels[j].newData.connect(stopTrigger.newMeasurement);
+                                            }
+                                        }
+                                    }
+                                    rangeTimer.reportingName = configModel.data(driverIndex, 0);
+                                    rangeTimer.report = function() {
+                                        return "" + this.reportingName + ": " + this.value;
+                                    };
+                                }
+                                else if(driverReference.driver = "multirangetimer")
+                                {
+                                    var rangeTimer = new TimerDisplay();
+                                    rangeTimer.setDisplayFormat("mm:ss");
+                                    var decorator = new WidgetDecorator(rangeTimer, configModel.data(driverIndex, 0), 2);
+                                    indicatorPanel.addWidget(decorator);
+                                    var rangenames = driverReference.rangenames;
+                                    var endtemps = driverReference.endtemps;
+                                    var names = rangenames.slice(2, rangenames.length - 2).split(", ");
+                                    rangeTimer.rangeNames = new Array();
+                                    for(var j = 0; j < names.length; j++)
+                                    {
+                                        var name = names[j].slice(1, names[j].length - 1);
+                                        rangeTimer.rangeNames.push(name);
+                                    }
+                                    rangeTimer.rangeEnds = new Array();
+                                    var ends = endtemps.slice(2, endtemps.length - 2).split(", ");
+                                    for(var j = 0; j < ends.length; j++)
+                                    {
+                                        rangeTimer.rangeEnds.push(Number(ends[j]));
+                                    }
+                                    rangeTimer.currentRange = 0;
+                                    rangeTimer.results = new Array();
+                                    rangeTimer.trigger = new ThresholdDetector();
+                                    for(var j = 0; j < columnNames.length; j++)
+                                    {
+                                        if(columnNames[j] == driverReference.trigger)
+                                        {
+                                            channels[j].newData.connect(rangeTimer.trigger.newMeasurement);
+                                        }
+                                    }
+                                    rangeTimer.startRanges = function() {
+                                        arguments.callee.timer.currentRange = 0;
+                                        arguments.callee.timer.results.splice(0, arguments.callee.timer.results.length);
+                                        arguments.callee.timer.trigger.setThreshold(arguments.callee.timer.rangeEnds[0]);
+                                    };
+                                    rangeTimer.startRanges.timer = rangeTimer;
+                                    start.clicked.connect(rangeTimer.startTimer);
+                                    start.clicked.connect(rangeTimer.startRanges);
+                                    rangeTimer.transition = function() {
+                                        arguments.callee.timer.stopTimer();
+                                        arguments.callee.timer.results.push(arguments.callee.timer.value);
+                                        arguments.callee.timer.reset();
+                                        arguments.callee.timer.startTimer();
+                                        arguments.callee.timer.currentRange++;
+                                        if(arguments.callee.timer.currentRange <= arguments.callee.timer.rangeEnds.length)
+                                        {
+                                            arguments.callee.timer.trigger.setThreshold(arguments.callee.timer.rangeEnds[arguments.callee.timer.currentRange]);
+                                        }
+                                    };
+                                    rangeTimer.transition.timer = rangeTimer;
+                                    rangeTimer.trigger.timeForValue.connect(rangeTimer.transition);
+                                    stop.clicked.connect(rangeTimer.transition);
+                                    stop.clicked.connect(rangeTimer.stopTimer);
+                                    rangeTimer.report = function() {
+                                        var retval = "";
+                                        for(var j = 0; j < arguments.callee.timer.results.length; j++)
+                                        {
+                                            retval += arguments.callee.timer.rangeNames[j] + ": " + arguments.callee.timer.results[j] + "\n";
+                                        }
+                                        return retval;
+                                    };
+                                    rangeTimer.report.timer = rangeTimer;
+                                    rangetimers.push(rangeTimer);
+                                }
 			}
 		}
 		for(var i = 1; i < tabControls.length; i++)
 				log.addOutputAnnotationColumn(lc + channels.length - channelSkip);
                 var filename = log.saveTemporary();
                 currentBatchInfo.tempData = filename;
+                var notes = findChildObject(currentBatchInfo, 'annotation');
+                for(var i = 0; i < rangetimers.length; i++)
+                {
+                    notes.append(rangetimers[i].report());
+                }
                 currentBatchInfo.raise();
                 currentBatchInfo.activateWindow();
             }

src/typica.w

     return QScriptValue();
 }
 
+
 @** Application Configuration.
 
 \noindent While \pn{} is intended as a data logging application, the diversity
 model.
 
 @<Populate model column from list@>=
-for(int i = 0; i < itemList.size(); i++)
+for(int j = 0; j < itemList.size(); j++)
 {
-    tablemodel->setData(tablemodel->index(i, column),
-                   QVariant(itemList.at(i).toDouble()),
+    tablemodel->setData(tablemodel->index(j, column),
+                   QVariant(itemList.at(j).toDouble()),
                    Qt::DisplayRole);
 }
 
     }
 }
 
-
-
 @ The widget is registered with the configuration system.
 @<Register device configuration widgets@>=
 app.registerDeviceConfigurationWidget("rangetimer",
 @<Class implementations@>=
 @<RangeTimerConfWidget implementation@>
 
+@ The multirange timer is a little different. To keep configuration tractible,
+this is slightly less general purpose than the range timer and only supports
+automatic triggering on a single data series.
+
+@<Class declarations@>=
+class MultiRangeTimerConfWidget : public BasicDeviceConfigurationWidget
+{
+    @[Q_OBJECT@]@/
+    public:@/
+        @[Q_INVOKABLE@]@, MultiRangeTimerConfWidget(DeviceTreeModel *model,
+                                                    const QModelIndex &index);
+    @[private slots@]:@/
+        void updateColumnName(const QString &text);
+        void updateRangeData();
+    private:@/
+        SaltModel *tablemodel;
+};
+
+@ These limitations allow a rather small set of controls for configuration. A
+line edit to specify the data series used for automatic triggering and a table
+which specifies the name of the timed range and an ending temperature.
+
+@<MultiRangeTimerConfWidget implementation@>=
+MultiRangeTimerConfWidget::MultiRangeTimerConfWidget(DeviceTreeModel *model,
+                                                     const QModelIndex &index)
+: BasicDeviceConfigurationWidget(model, index), tablemodel(new SaltModel(2))
+{
+    QFormLayout *layout = new QFormLayout;
+    QLineEdit *trigger = new QLineEdit;
+    layout->addRow(tr("Trigger column name:"), trigger);
+    tablemodel->setHeaderData(0, Qt::Horizontal, "Range Name");
+    tablemodel->setHeaderData(1, Qt::Horizontal, "End Temperature");
+    QTableView *rangeTable = new QTableView;
+    rangeTable->setModel(tablemodel);
+    layout->addRow(tr("Range data:"), rangeTable);
+    @<Get device configuration data for current node@>@;
+    for(int i = 0; i < configData.size(); i++)
+    {
+        node = configData.at(i).toElement();
+        if(node.attribute("name") == "trigger")
+        {
+            trigger->setText(node.attribute("value"));
+        }
+        else if(node.attribute("name") == "rangenames")
+        {
+            QString data = node.attribute("value");
+            if(data.length() > 3)
+            {
+                data.chop(2);
+                data = data.remove(0, 2);
+            }
+            QStringList itemList = data.split(", ");
+            for(int j = 0; j < itemList.size(); j++)
+            {
+                QString item = itemList.at(j);
+                item.chop(1);
+                item = item.remove(0, 1);
+                tablemodel->setData(tablemodel->index(j, 0),
+                                    QVariant(item), Qt::DisplayRole);
+            }
+        }
+        else if(node.attribute("name") == "endtemps")
+        {
+            @<Convert numeric array literal to list@>@;
+            int column = 1;
+            @<Populate model column from list@>@;
+        }
+    }
+    updateColumnName(trigger->text());
+    updateRangeData();
+    connect(trigger, SIGNAL(textEdited(QString)), this, SLOT(updateColumnName(QString)));
+    connect(tablemodel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateRangeData()));
+    setLayout(layout);
+}
+
+@ The update mechanisms are reasonably straightforward. Table updates just
+refresh the entire table instead of attempting to be clever about updating only
+the element that changed.
+
+@<MultiRangeTimerConfWidget implementation@>=
+void MultiRangeTimerConfWidget::updateRangeData()
+{
+    updateAttribute("rangenames", tablemodel->quotedArrayLiteral(0, Qt::DisplayRole));
+    updateAttribute("endtemps", tablemodel->arrayLiteral(1, Qt::DisplayRole));
+}
+
+void MultiRangeTimerConfWidget::updateColumnName(const QString &text)
+{
+    updateAttribute("trigger", text);
+}
+
+@ The widget is registered with the configuration system.
+@<Register device configuration widgets@>=
+app.registerDeviceConfigurationWidget("multirangetimer",
+MultiRangeTimerConfWidget::staticMetaObject);
+
+@ The implementation is in the main source file.
+
+@<Class implementations@>=
+@<MultiRangeTimerConfWidget implementation@>
+
 @* Profile Translation Configuration Widget.
 
 \noindent Configuring profile translation requires knowing which column to use