static methods in Units now invokable

src/typica.w

 	return qscriptvalue_cast<QModelIndex>(context->argument(arg));
 }
 
+template<> double argument(int arg, QScriptContext *context)
+{
+	return (double)(context->argument(arg).toNumber());
+}
+
+template<> Units::Unit argument(int arg, QScriptContext *context)
+{
+	return (Units::Unit)(context->argument(arg).toInt32());
+}
+
 @ The scripting engine is informed of a number of classes defined elsewhere in
 the program. Code related to scripting these classes is grouped with the code
 implementing the classes. Additionally, there are several classes from Qt which

src/units.w

 
 @ This class is exposed to the host environment. Note the lack of constructor.
 We do not wish to create any instances, just have access to the |Unit|
-enumeration.
+enumeration and conversion methods.
+
+Unfortunately, marking a static method |Q_INVOKABLE| will not work as per Qt
+bug #18840. There seems to be no intention to correct this deficiency so
+instead of having something that just works, we must resort to the following
+hackery.
+
+@<Function prototypes for scripting@>=
+QScriptValue Units_convertTemperature(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Units_convertRelativeTemperature(QScriptContext *context,
+                                              QScriptEngine *engine);
+QScriptValue Units_isTemperatureUnit(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Units_convertWeight(QScriptContext *context, QScriptEngine *engine);
+QScriptValue Units_isWeightUnit(QScriptContext *context, QScriptEngine *engine);
+
+@ These functions are added as properties for the host environment.
 
 @<Set up the scripting engine@>=
 value = engine->newQMetaObject(&Units::staticMetaObject);
+value.setProperty("convertTemperature", engine->newFunction(Units_convertTemperature));
+value.setProperty("convertRelativeTemperature",
+                  engine->newFunction(Units_convertRelativeTemperature));
+value.setProperty("isTemperatureUnit", engine->newFunction(Units_isTemperatureUnit));
+value.setProperty("convertWeight", engine->newFunction(Units_convertWeight));
+value.setProperty("isWeightUnit", engine->newFunction(Units_isWeightUnit));
 engine->globalObject().setProperty("Units", value);
 
-@ While the above is sufficient for some uses, others require some additional
-work.
+@ The implementation of these functions is trivial.
+
+@<Functions for scripting@>=
+QScriptValue Units_convertTemperature(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::convertTemperature(argument<double>(0, context),
+	                                              argument<Units::Unit>(1, context),
+	                                              argument<Units::Unit>(2, context)));
+}
+
+QScriptValue Units_convertRelativeTemperature(QScriptContext *context,
+                                              QScriptEngine *engine)
+{
+	return QScriptValue(Units::convertRelativeTemperature(
+	                         argument<double>(0, context),
+	                         argument<Units::Unit>(1, context),
+	                         argument<Units::Unit>(2, context)));
+}
+
+QScriptValue Units_isTemperatureUnit(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::isTemperatureUnit(argument<Units::Unit>(0, context)));
+}
+
+QScriptValue Units_convertWeight(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::convertWeight(argument<double>(0, context),
+	                                         argument<Units::Unit>(1, context),
+	                                         argument<Units::Unit>(2, context)));
+}
+
+QScriptValue Units_isWeightUnit(QScriptContext *context, QScriptEngine *engine)
+{
+	return QScriptValue(Units::isWeightUnit(argument<Units::Unit>(0, context)));
+}
+
+@ To pass unit data in some circumstances, the inner enumeration must be
+registered as a meta-type with script conversions.
 
 @<Class declarations@>=
 Q_DECLARE_METATYPE(Units::Unit)
 
 @<Set up the scripting engine@>=
 qScriptRegisterMetaType(engine, Unit_toScriptValue, Unit_fromScriptValue);
+