Initial work toward adding support for relative measurements to ZoomLog.

src/typica.w

 		if(measure.time().second() !=
 			lastMeasurement.value(tempcolumn).time().second())
 		{
-			Measurement adjusted(measure.temperature(),
-									QTime(0, measure.time().minute(),
-											measure.time().second(), 0),
-									measure.scale());
+			Measurement adjusted = measure;
+			adjusted.setTime(QTime(0, measure.time().minute(), measure.time().second(), 0));
 			model_1s->newMeasurement(adjusted, tempcolumn);
 			if(adjusted.time().second() % 5 == 0)
 			{
 	}
 	for(int i = 0; i < timelist.size(); i++)
 	{
-		newMeasurement(Measurement(measure.temperature(), timelist[i], measure.scale()), tempcolumn);
+		Measurement synthesized = measure;
+		synthesized.setTime(timelist[i]);
+		newMeasurement(synthesized, tempcolumn);
 	}
 }
 
 			{
 				if(measure.time() > lastMeasurement.value(replicationcolumn).time())
 				{
-					Measurement synthetic(lastMeasurement.value(replicationcolumn).temperature(),
-                                          measure.time());
+					Measurement synthetic = lastMeasurement.value(replicationcolumn);
+					synthetic.setTime(measure.time());
 					model_ms->newMeasurement(synthetic, replicationcolumn);
 					if(synthetic.time().second() != lastMeasurement.value(replicationcolumn).time().second())
 					{
-						Measurement adjusted(synthetic.temperature(), QTime(0, synthetic.time().minute(), synthetic.time().second(), 0));
+						Measurement adjusted = synthetic;
+						synthetic.setTime(QTime(0, synthetic.time().minute(), synthetic.time().second(), 0));
 						model_1s->newMeasurement(adjusted, replicationcolumn);
 						if(adjusted.time().second() % 5 == 0)
 						{
 		(*i)->append(QVariant());
 	}
 }
-(*i)->replace(tempcolumn, measure.temperature());
+(*i)->replace(tempcolumn, measure);
 lastInsertion = i;
 emit dataChanged(createIndex(insertion, tempcolumn),
 					createIndex(insertion, tempcolumn));
 {
 	newEntry->append(QVariant());
 }
-newEntry->replace(tempcolumn, measure.temperature());
+newEntry->replace(tempcolumn, measure);
 lastInsertion = entries->insert(i, newEntry);
 endInsertRows();
 lastTemperature->insert(tempcolumn, insertion);
 data, there are also cases where we'@q'@>d like to edit the data in the model
 directly from the table view. For this, we need to reimplement |setData()|.
 
+Note that editing from the |ZoomLog| has never been supported. While stream
+inserted data currently preserves all properties of inserted measurements,
+using |setData| it is possible to insert a numeric value as if it were a
+measurement. Such an entry will not have any additional information associated
+and cannot be expected to exhibit behavior implemented through the use of that
+extra information.
+
 Very little input checking is done here. Editable views may want to place
 delegates\nfnote{Qt 4.4: Delegate Classes\par\indent\hbox{%
 \pdfURL{http://doc.trolltech.com/4.4/model-view-delegate.html}{%
 				{
 					return QVariant();
 				}
-				if(controlColumns->contains(index.column()))
+				Measurement v = row->at(index.column());
+				if(v.scale() == Units::Unitless)
 				{
-					if(controlColumns->value(index.column()) == true)
-					{
-						return QVariant(QString("%1").arg(QVariant(row->at(index.column()).toInt()).toString()));
-					}
+					return QVariant(QString("%1").arg(v.temperature()));
 				}
-				switch(unit)
+				else
 				{
-					case Units::Fahrenheit:
-						return QVariant(row->at(index.column()).toString());
-						break;
-					case Units::Celsius:
-						return QVariant((row->at(index.column()).toDouble() -
-						                32) * 5 / 9);
-						break;
-					case Units::Kelvin:
-						return QVariant((row->at(index.column()).toDouble() +
-						                459.67) * 5 / 9);
-						break;
-					case Units::Rankine:
-						return QVariant(row->at(index.column()).toDouble() +
-						                459.67);
-						break;
-					default:
-						return QVariant(row->at(index.column()).toString());
-						break;
+					if(v.contains("relative"))
+					{
+						if(v.value("relative") == true)
+						{
+							return QVariant(QString("%1").arg(Units::convertRelativeTemperature(v.temperature(), v.scale, unit)));
+						}
+					}
+					return QVariant(QString("%1").arg(Units::convertTemperature(v.temperature(), v.scale(), unit)));
 				}
 			}
 			return QVariant(row->at(index.column()).toString());
 
 It may be a good idea to extend the model class to allow models that can be
 edited through the view such as the table view presented in the |LogEditWindow|
-and models that probably shouldn't be edited in the view, such as the models
+and models that probably shouldn'@q'@>t be edited in the view, such as the models
 managed by |ZoomLog|. This could be done by subclassing and only reimplementing
 this method. Otherwise, a new method to specify that the user should not edit
 the model could be provided and a flag would be checked here.
 	return 0;
 }
 
-@ Much of the way models are interacted with in Qt's model view architecture is
+@ Much of the way models are interacted with in Qt'@q'@>s model view architecture is
 through model indices. The model is responsible for creating these indices from
 row column pairs.
 

src/units.w

 			Rankine = 10145
 		};
 		static double convertTemperature(double value, Unit fromUnit, Unit toUnit);
+		static double convertRelativeTemperature(double value, Unit fromUnit, Unit toUnit);
 		static bool isTemperatureUnit(Unit unit);
 };
 
 					return value;
 					break;
 				case Celsius:
-					return (value - 32) * 5 / 9;
+					return (value - 32.0) * 5.0 / 9.0;
 					break;
 				case Kelvin:
-					return (value + 459.67) * 5 / 9;
+					return (value + 459.67) * 5.0 / 9.0;
 					break;
 				case Rankine:
 					return value + 459.67;
 			switch(toUnit)
 			{
 				case Fahrenheit:
-					return value * 9 / 5 + 32;
+					return value * 9.0 / 5.0 + 32.0;
 					break;
 				case Celsius:
 					return value;
 					return value + 273.15;
 					break;
 				case Rankine:
-					return (value + 273.15) * 9 / 5;
+					return (value + 273.15) * 9.0 / 5.0;
 					break;
 			}
 			break;
 			switch(toUnit)
 			{
 				case Fahrenheit:
-					return value * 5 / 9 - 459.67;
+					return value * 5.0 / 9.0 - 459.67;
 					break;
 				case Celsius:
 					return value - 273.15;
 					return value;
 					break;
 				case Rankine:
-					return value * 9 / 5;
+					return value * 9.0 / 5.0;
 					break;
 			}
 			break;
 					return value - 457.67;
 					break;
 				case Celsius:
-					return (value - 491.67) * 5 / 9;
+					return (value - 491.67) * 5.0 / 9.0;
 					break;
 				case Kelvin:
-					return value * 5 / 9;
+					return value * 5.0 / 9.0;
+					break;
+				case Rankine:
+					return value;
+					break;
+			}
+			break;
+		default:
+			return 0;
+			break;
+	}
+	return 0;
+}
+
+@ Conversions are also provided for relative temperature measurements.
+
+@(units.cpp@>=
+double Units::convertRelativeTemperature(double value, Unit fromUnit, Unit toUnit)
+{
+	if(isTemperatureUnit(fromUnit) && isTemperatureUnit(toUnit) == false)
+	{
+		return 0;
+	}
+	switch(fromUnit)
+	{
+		case Fahrenheit:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value;
+					break;
+				case Celsius:
+					return value * (5.0 / 9.0);
+					break;
+				case Kelvin:
+					return value * (5.0 / 9.0);
+					break;
+				case Rankine:
+					return value;
+					break;
+			}
+			break;
+		case Celsius:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value * (9.0 / 5.0);
+					break;
+				case Celsius:
+					return value;
+					break;
+				case Kelvin:
+					return value;
+					break;
+				case Rankine:
+					return value * (9.0 / 5.0);
+					break;
+			}
+			break;
+		case Kelvin:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value * (5.0 / 9.0);
+					break;
+				case Celsius:
+					return value;
+					break;
+				case Kelvin:
+					return value;
+					break;
+				case Rankine:
+					return value * (9.0 / 5.0);
+					break;
+			}
+			break;
+		case Rankine:
+			switch(toUnit)
+			{
+				case Fahrenheit:
+					return value;
+					break;
+				case Celsius:
+					return value * (5.0 / 9.0);
+					break;
+				case Kelvin:
+					return value * (5.0 / 9.0);
 					break;
 				case Rankine:
 					return value;