ValueAnnotation integration with example configuration

config/Windows/productionroaster.xml

 					annotationPanel.addWidget(button);
 					tabControls.push(button);
 				}
+				else if(driverReference.driver == "valueannotation")
+				{
+					var checker = new ValueAnnotation;
+					var valuesSetting = driverReference.measuredValues;
+					var notesSetting = driverReference.annotations;
+					var valuesList = valuesSetting.slice(2, valuesSetting.length-2).split(",");
+					var notesList = notesSetting.slice(2, notesSetting.length-2).split(",");
+					if(valuesList.length > 1 && notesList.length == valuesList.length) {
+						for(var j = 0; j < valuesList.length; j++) {
+							checker.setAnnotation(Number(valueList[j]), notesList[j]);
+						}
+					}
+					if(driverReference.emitOnStart == "true") {
+						start.clicked.connect(checker.annotate);
+					}
+					var colname = driverReference.source;
+					for(var j = 0; j < columnNames.length; j++) {
+						if(columnNames[j] == colname) {
+							channels[j].newData.connect(checker.newMeasurement);
+							break;
+						}
+					}
+					annotationButtons.push(checker);
+				}
 				else if(driverReference.driver == "reconfigurablebutton")
 				{
 					var button = new AnnotationButton(driverReference.buttontext);

src/typica.w

 @<GraphSettingsWidget implementation@>@/
 @<DataqSdkDeviceConfWidget implementation@>@/
 @<SerialScaleConfWidget implementation@>@/
+@<ValueAnnotation implementation@>@/
+@<ValueAnnotationConfWidget implementation@>@/
 
 @ A few headers are required for various parts of \pn{}. These allow the use of
 various Qt modules.
 r = cseconds - oseconds;
 
 @ The logic for a count down timer is very similar to the logic for a count up
-timer. A key difference is that we don't want to continue counting down if the
+timer. A key difference is that we don'@q'@>t want to continue counting down if the
 timer has already reached 0.
 
 @<Check for Timer Decrement@>=
 }
 
 @ Stopping the timer is a little simpler. Remember to stop the clock so we
-aren't updating senselessly.
+aren'@q'@>t updating senselessly.
 
 @<TimerDisplay Implementation@>=
 void TimerDisplay::stopTimer()@t\2\2@>@/
 
 The end of this function may seem a little strange. Why not simply look up the
 map and insert information directly into the model data? Well, as of this
-writing, that doesn't work. There are two ways around that problem. One is to
+writing, that doesn'@q'@>t work. There are two ways around that problem. One is to
 have the lists store references and dereference the real data. The other option
 is to obtain a copy of the row, then a copy of the cell, update the cell, then
 replace the old value of the cell in the copy of the row, then replace the old
 	@<Expand the SaltModel@>@;
 }
 
-@ The destructor doesn't need to do anything.
+@ The destructor doesn'@q'@>t need to do anything.
 
 @<SaltModel Implementation@>=
 SaltModel::~SaltModel()
 @ In order to connect to the database, we need five pieces of information: the
 name of a database driver (PostgreSQL is recommended for now), the host name of
 the computer running the database, the name of the database, the name of the
-user connecting to the database, and that user's password. This information will
+user connecting to the database, and that user'@q'@>s password. This information will
 be stored in the user settings for the application so that the database
 connection can be established without prompting the user next time. A class is
 provided to gather this information.
 				  QVariant(newsize));
 
 @ To determine which window a given table is in, we just follow
-|parentWidget()| until there isn't one. It is possible that the table view
+|parentWidget()| until there isn'@q'@>t one. It is possible that the table view
 will also be the window, however this is not advised as it is easier for the
 settings key to be non-unique in such a case.
 
 in Qt. This brings several benefits, including making it easy to print reports
 or save reports as plain text or HTML.
 
-Reports are specified in the \pn{}'s configuration document and can include both
+Reports are specified in the \pn{}'@q'@>s configuration document and can include both
 static elements and elements that are populated by external data such as the
 result of a SQL query.
 
 @ It is sometimes desirable to add fixed data such as column headers to a table.
 This is done with the {\tt <row>} element.
 
-Technically, this isn't needed. The same results can be produced by using a
+Technically, this isn'@q'@>t needed. The same results can be produced by using a
 {\tt <query>} element to select constant data, but this approach saves a trip to
 the database.
 
 	saveDeviceConfiguration();
 }
 
-@ There isn't really anything that can be done if the device configuration data
+@ There isn'@q'@>t really anything that can be done if the device configuration data
 is corrupt, but an error message can be produced if the program happens to have
 access to a debugging console.
 
 	return QDomElement();
 }
 
-@ We don't want any headers, so |headerData()| is very simple.
+@ We don'@q'@>t want any headers, so |headerData()| is very simple.
 
 @<DeviceTreeModel implementation@>=
 QVariant DeviceTreeModel::headerData(int, Qt::Orientation, int) const
 	        this, SLOT(insertChildNode(QString, QString)));
 	connect(freeAnnotationInserter, SIGNAL(triggered(QString, QString)),
 	        this, SLOT(insertChildNode(QString, QString)));
+	@<Add annotation control node inserters@>@;
 	addAnnotationControlButton->setMenu(annotationMenu);
 	layout->addWidget(addAnnotationControlButton);
 	QPushButton *advancedButton = new QPushButton(tr("Advanced Features"));
 A later version of QextSerialPort than is used by \pn{} provides a helper
 class which can be used more conveniently to create this sort of control. As
 this is not yet available to \pn{}, we instead copy the |enum| specifying
-the appropriate values into the class and use Qt's meta-object system to
+the appropriate values into the class and use Qt'@q'@>s meta-object system to
 populate the combo box based on the values in that |enum|.
 
 @<Class declarations@>=
 }
 
 @ There are two ways that we might request measurement data. All of the
-devices I've seen documented provide function 0x4 addresses for PV and SV
+devices I'@q'@>ve seen documented provide function 0x4 addresses for PV and SV
 such that SV can be obtained from the address immediately after the address
 from which we obtain PV. In this case we request both values at the same time.
 
 this buffer will have incomplete data. This means that we must determine when
 the full response is available before passing the complete response along to
 the appropriate method. If the response has not been received in full, nothing
-is done. We'll be notified of more data shortly.
+is done. We'@q'@>ll be notified of more data shortly.
 
 When the message we see the response for was queued, a callback was also
 registered to handle the response. Once we have the complete message, we pass
 	queueMessage(message, this, "ignore(QByteArray)");
 }
 
-@ We don't care about the response when sending a new SV.
+@ We don'@q'@>t care about the response when sending a new SV.
 
 @<ModbusRTUDevice implementation@>=
 void ModbusRTUDevice::ignore(QByteArray)
 		void updateDestinationColumn(const QString &dest);
 		void updateKnots();
 	private:@/
-		SaltModel *model;
+		SaltModel *tablemodel;
 };
 
 @ This is configured by specifying a source column name, a destination column
 
 @<LinearSplineInterpolationConfWidget implementation@>=
 LinearSplineInterpolationConfWidget::LinearSplineInterpolationConfWidget(DeviceTreeModel *model, const QModelIndex &index)
-: BasicDeviceConfigurationWidget(model, index), model(new SaltModel(2))
+: BasicDeviceConfigurationWidget(model, index), tablemodel(new SaltModel(2))
 {
 	QFormLayout *layout = new QFormLayout;
 	QLineEdit *source = new QLineEdit;
 	layout->addRow(tr("Source column name:"), source);
 	QLineEdit *destination = new QLineEdit;
 	layout->addRow(tr("Destination column name:"), destination);
-	model->setHeaderData(0, Qt::Horizontal, "Input");
-	model->setHeaderData(1, Qt::Horizontal, "Output");
+	tablemodel->setHeaderData(0, Qt::Horizontal, "Input");
+	tablemodel->setHeaderData(1, Qt::Horizontal, "Output");
 	QTableView *mappingTable = new QTableView;
-	mappingTable->setModel(model);
+	mappingTable->setModel(tablemodel);
 	NumericDelegate *delegate = new NumericDelegate;
 	mappingTable->setItemDelegate(delegate);
 	layout->addRow(tr("Mapping data:"), mappingTable);
 	updateKnots();
 	connect(source, SIGNAL(textEdited(QString)), this, SLOT(updateSourceColumn(QString)));
 	connect(destination, SIGNAL(textEdited(QString)), this, SLOT(updateDestinationColumn(QString)));
-	connect(model, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateKnots()));
+	connect(tablemodel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateKnots()));
 	setLayout(layout);
 }
 
 @<Populate model column from list@>=
 for(int i = 0; i < itemList.size(); i++)
 {
-	model->setData(model->index(i, column),
+	tablemodel->setData(tablemodel->index(i, column),
 	               QVariant(itemList.at(i).toDouble()),
                    Qt::DisplayRole);
 }
 @<LinearSplineInterpolationConfWidget implementation@>=
 void LinearSplineInterpolationConfWidget::updateKnots()
 {
-	updateAttribute("sourcevalues", model->arrayLiteral(0, Qt::DisplayRole));
-	updateAttribute("destinationvalues", model->arrayLiteral(1, Qt::DisplayRole));
+	updateAttribute("sourcevalues", tablemodel->arrayLiteral(0, Qt::DisplayRole));
+	updateAttribute("destinationvalues", tablemodel->arrayLiteral(1, Qt::DisplayRole));
 }
 
 void LinearSplineInterpolationConfWidget::updateSourceColumn(const QString &source)

src/valueannotation.w

 to identify which data series should be monitored and what annotations should
 be produced for what values.
 
-@<Class declrations@>=
+@<Class declarations@>=
 class ValueAnnotationConfWidget : public BasicDeviceConfigurationWidget
 {
 	Q_OBJECT
 		void updateAnnotations();
 		void updateStart(bool noteOnStart);
 	private:
-		SaltModel *model;
+		SaltModel *tablemodel;
 };
 
 @ The constructor sets up the configuration interface requesting a source
 ValueAnnotationConfWidget::ValueAnnotationConfWidget(DeviceTreeModel *model,
                                                      const QModelIndex &index)
 : BasicDeviceConfigurationWidget(model, index),
-  model(new SaltModel(2))
+  tablemodel(new SaltModel(2))
 {
 	QFormLayout *layout = new QFormLayout;
 	QLineEdit *source = new QLineEdit;
 	QCheckBox *noteOnStart = new QCheckBox(tr("Produce Start State Annotation"));
 	noteOnStart->setChecked(true);
 	layout->addRow(noteOnStart);
-	model->setHeaderData(0, Qt::Horizontal, "Value");
-	model->setHeaderData(1, Qt::Horizontal, "Annotation");
+	tablemodel->setHeaderData(0, Qt::Horizontal, "Value");
+	tablemodel->setHeaderData(1, Qt::Horizontal, "Annotation");
 	QTableView *annotationTable = new QTableView;
-	annotationTable->setModel(model);
+	annotationTable->setModel(tablemodel);
 	NumericDelegate *delegate = new NumericDelegate;
 	annotationTable->setItemDelegateForColumn(0, delegate);
 	layout->addRow(tr("Annotations for values:"), annotationTable);
-	@<Get device configuration data for current node@>=
+	@<Get device configuration data for current node@>@;
 	for(int i = 0; i < configData.size(); i++)
 	{
 		node = configData.at(i).toElement();
 		}
 		else if(node.attribute("name") == "annotations")
 		{
-			@<Convert numeric array literal to list@>@;
+			@<Convert string array literal to list@>@;
 			int column = 1;
-			@<Populate model column from list@>@;
+			@<Populate model column from string list@>@;
 		}
 	}
 	updateSourceColumn(source->text());
 	updateAnnotations();
 	connect(source, SIGNAL(textEdited(QString)), this, SLOT(updateSourceColumn(QString)));
 	connect(noteOnStart, SIGNAL(toggled(bool)), this, SLOT(updateStart(bool)));
-	connect(model, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateAnnotations()));
+	connect(tablemodel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(updateAnnotations()));
 	setLayout(layout);
 }
 
+@ While we can re-use code for handling numeric array literals, string array
+literals need to be handled a little differently.
+
+@<Convert string array literal to list@>=
+QString data = node.attribute("value");
+if(data.length() > 3)
+{
+	data.chop(2);
+	data = data.remove(0, 2);
+}
+QStringList itemList = data.split(",");
+for(int i = 0; i < itemList.size(); i++)
+{
+	itemList[i] = itemList[i].simplified();
+}
+
+@ Populating the model must also be done a little differently.
+
+@<Populate model column from string list@>=
+for(int i = 0; i < itemList.size(); i++)
+{
+	tablemodel->setData(tablemodel->index(i, column),
+	                    QVariant(itemList.at(i)),
+	                    Qt::DisplayRole);
+}
+
 @ To update the table data, the measued values and annotations are saved in
 separate lists.
 
 @<ValueAnnotationConfWidget implementation@>=
 void ValueAnnotationConfWidget::updateAnnotations()
 {
-	updateAttribute("measuredValues", model->arrayLiteral(0, Qt::DisplayRole));
-	updateAttribute("annotations", model->arrayLiteral(1, Qt::DisplayRole));
+	updateAttribute("measuredValues", tablemodel->arrayLiteral(0, Qt::DisplayRole));
+	updateAttribute("annotations", tablemodel->arrayLiteral(1, Qt::DisplayRole));
 }
 
 @ The other settings are updated based on values passed through the parameter
 
 void ValueAnnotationConfWidget::updateStart(bool noteOnStart)
 {
-	updateAttribute("emitOnStart", noteOnStart);
+	updateAttribute("emitOnStart", noteOnStart ? "true" : "false");
 }
 
 @ The widget is registered with the configuration system.
 
 @<Register device configuration widgets@>=
 app.registerDeviceConfigurationWidget("valueannotation",
-	ValueAnnotationConfWidget::staticMetaObjet);
+	ValueAnnotationConfWidget::staticMetaObject);
+
+@ A NodeInserter is needed to make this widget available.
+
+@<Add annotation control node inserters@>=
+NodeInserter *valueAnnotationInserter = new NodeInserter(tr("Value Annotation"),
+                                                         tr("Value Annotation"),
+                                                         "valueannotation");
+annotationMenu->addAction(valueAnnotationInserter);
+connect(valueAnnotationInserter, SIGNAL(triggered(QString, QString)),
+        this, SLOT(insertChildNode(QString, QString)));
 
 @ While it is possible to implement this feature with |ThresholdDetector|
 objects, the code to handle these would be difficult to understand and there
 		QList<double> values;
 		QStringList annotations;
 		double tolerance;
-}
+};
 
 @ Most of the work of this class happens in the |newMeasurement| method. This
 compares the latest measurement with every value that has an associated
 	/* Nothing needs to be done here. */
 }
 
+@ This class is exposed to the host environment in the usual way. First with
+function prototypes.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructValueAnnotation(QScriptContext *context, QScriptEngine *engine);
+void setValueAnnotationProperties(QScriptValue value, QScriptEngine *engine);
+
+@ Then setting up a new property of the global object.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructValueAnnotation);
+value = engine->newQMetaObject(&ValueAnnotation::staticMetaObject, constructor);
+engine->globalObject().setProperty("ValueAnnotation", value);
+
+@ The implementation of the functions also proceeds as usual.
+
+@<Functions for scripting@>=
+QScriptValue constructValueAnnotation(QScriptContext *context, QScriptEngine *engine)
+{
+	QScriptValue object = engine->newQObject(new ValueAnnotation);
+	setValueAnnotationProperties(object, engine);
+	return object;
+}
+
+void setValueAnnotationProperties(QScriptValue value, QScriptEngine *engine)
+{
+	setQObjectProperties(value, engine);
+}