Skip to content

Commit 1032c75

Browse files
jcelerierjcelerier
committed
js: add support for more ossia <-> Qt conversion
1 parent 08aab44 commit 1032c75

4 files changed

Lines changed: 332 additions & 1 deletion

File tree

‎src/ossia-qt/js_utilities.cpp‎

Lines changed: 328 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -795,6 +795,24 @@ QVariant ossia_to_qvariant::operator()(QMetaType::Type type, const value& ossia_
795795
}
796796
return QVariant::fromValue(std::move(vars));
797797
}
798+
case QMetaType::QVariantMap: {
799+
auto val = convert<ossia::value_map_type>(ossia_val);
800+
QVariantMap vars;
801+
for(auto& [k, v] : val)
802+
{
803+
vars.insert(QString::fromStdString(k), v.apply(ossia_to_qvariant{}));
804+
}
805+
return QVariant::fromValue(std::move(vars));
806+
}
807+
case QMetaType::QVariantHash: {
808+
auto val = convert<ossia::value_map_type>(ossia_val);
809+
QVariantHash vars;
810+
for(auto& [k, v] : val)
811+
{
812+
vars.insert(QString::fromStdString(k), v.apply(ossia_to_qvariant{}));
813+
}
814+
return QVariant::fromValue(std::move(vars));
815+
}
798816
case QMetaType::QDate:
799817
// TODO double ?
800818
default: {
@@ -922,6 +940,316 @@ value qt_to_ossia::operator()(const QVariant& v)
922940
}
923941
}
924942
}
943+
944+
void registerQVariantConverters()
945+
{
946+
// ossia -> qvariant
947+
QMetaType::registerConverter<ossia::value, bool>([](const ossia::value& ossia_val) -> bool {
948+
return ossia::convert<bool>(ossia_val);
949+
});
950+
QMetaType::registerConverter<ossia::value, QTime>([](const ossia::value& ossia_val) -> QTime {
951+
return QTime().addMSecs(convert<int>(ossia_val));
952+
});
953+
QMetaType::registerConverter<ossia::value, int>([](const ossia::value& ossia_val) -> int {
954+
return ossia::convert<int>(ossia_val);
955+
});
956+
QMetaType::registerConverter<ossia::value, qint16>([](const ossia::value& ossia_val) -> qint16 {
957+
return (qint16)ossia::convert<int>(ossia_val);
958+
});
959+
QMetaType::registerConverter<ossia::value, quint16>([](const ossia::value& ossia_val) -> quint16 {
960+
return (quint16)ossia::convert<int>(ossia_val);
961+
});
962+
QMetaType::registerConverter<ossia::value, quint32>([](const ossia::value& ossia_val) -> quint32 {
963+
return (quint32)ossia::convert<int>(ossia_val);
964+
});
965+
QMetaType::registerConverter<ossia::value, qlonglong>([](const ossia::value& ossia_val) -> qlonglong {
966+
return (qlonglong)ossia::convert<int>(ossia_val);
967+
});
968+
QMetaType::registerConverter<ossia::value, qulonglong>([](const ossia::value& ossia_val) -> qulonglong {
969+
return (qulonglong)ossia::convert<int>(ossia_val);
970+
});
971+
QMetaType::registerConverter<ossia::value, QChar>([](const ossia::value& ossia_val) -> QChar {
972+
return QChar::fromLatin1(ossia::convert<int>(ossia_val));
973+
});
974+
QMetaType::registerConverter<ossia::value, char>([](const ossia::value& ossia_val) -> char {
975+
return char(ossia::convert<int>(ossia_val));
976+
});
977+
QMetaType::registerConverter<ossia::value, unsigned char>([](const ossia::value& ossia_val) -> unsigned char {
978+
return (unsigned char)ossia::convert<int>(ossia_val);
979+
});
980+
QMetaType::registerConverter<ossia::value, signed char>([](const ossia::value& ossia_val) -> signed char {
981+
return (signed char)ossia::convert<int>(ossia_val);
982+
});
983+
QMetaType::registerConverter<ossia::value, QString>([](const ossia::value& ossia_val) -> QString {
984+
return QString::fromStdString(ossia::convert<std::string>(ossia_val));
985+
});
986+
QMetaType::registerConverter<ossia::value, QUrl>([](const ossia::value& ossia_val) -> QUrl {
987+
return QUrl{QString::fromStdString(ossia::convert<std::string>(ossia_val))};
988+
});
989+
QMetaType::registerConverter<ossia::value, QByteArray>([](const ossia::value& ossia_val) -> QByteArray {
990+
return QByteArray::fromStdString(ossia::convert<std::string>(ossia_val));
991+
});
992+
QMetaType::registerConverter<ossia::value, float>([](const ossia::value& ossia_val) -> float {
993+
return ossia::convert<float>(ossia_val);
994+
});
995+
QMetaType::registerConverter<ossia::value, double>([](const ossia::value& ossia_val) -> double {
996+
return ossia::convert<double>(ossia_val);
997+
});
998+
QMetaType::registerConverter<ossia::value, QColor>([](const ossia::value& ossia_val) -> QColor {
999+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1000+
return QColor::fromRgbF(val[1], val[2], val[3], val[0]);
1001+
});
1002+
QMetaType::registerConverter<ossia::value, QPoint>([](const ossia::value& ossia_val) -> QPoint {
1003+
auto val = ossia::convert<ossia::vec2f>(ossia_val);
1004+
return QPoint(val[0], val[1]);
1005+
});
1006+
QMetaType::registerConverter<ossia::value, QPointF>([](const ossia::value& ossia_val) -> QPointF {
1007+
auto val = ossia::convert<ossia::vec2f>(ossia_val);
1008+
return QPointF(val[0], val[1]);
1009+
});
1010+
QMetaType::registerConverter<ossia::value, QVector2D>([](const ossia::value& ossia_val) -> QVector2D {
1011+
auto val = ossia::convert<ossia::vec2f>(ossia_val);
1012+
return QVector2D(val[0], val[1]);
1013+
});
1014+
QMetaType::registerConverter<ossia::value, QVector3D>([](const ossia::value& ossia_val) -> QVector3D {
1015+
auto val = ossia::convert<ossia::vec3f>(ossia_val);
1016+
return QVector3D(val[0], val[1], val[2]);
1017+
});
1018+
QMetaType::registerConverter<ossia::value, QVector4D>([](const ossia::value& ossia_val) -> QVector4D {
1019+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1020+
return QVector4D(val[0], val[1], val[2], val[3]);
1021+
});
1022+
QMetaType::registerConverter<ossia::value, QQuaternion>([](const ossia::value& ossia_val) -> QQuaternion {
1023+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1024+
return QQuaternion(val[0], val[1], val[2], val[3]);
1025+
});
1026+
QMetaType::registerConverter<ossia::value, QLine>([](const ossia::value& ossia_val) -> QLine {
1027+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1028+
return QLine(val[0], val[1], val[2], val[3]);
1029+
});
1030+
QMetaType::registerConverter<ossia::value, QLineF>([](const ossia::value& ossia_val) -> QLineF {
1031+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1032+
return QLineF(val[0], val[1], val[2], val[3]);
1033+
});
1034+
QMetaType::registerConverter<ossia::value, QRect>([](const ossia::value& ossia_val) -> QRect {
1035+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1036+
return QRect(val[0], val[1], val[2], val[3]);
1037+
});
1038+
QMetaType::registerConverter<ossia::value, QRectF>([](const ossia::value& ossia_val) -> QRectF {
1039+
auto val = ossia::convert<ossia::vec4f>(ossia_val);
1040+
return QRectF(val[0], val[1], val[2], val[3]);
1041+
});
1042+
QMetaType::registerConverter<ossia::value, QSize>([](const ossia::value& ossia_val) -> QSize {
1043+
auto val = ossia::convert<ossia::vec2f>(ossia_val);
1044+
return QSize(val[0], val[1]);
1045+
});
1046+
QMetaType::registerConverter<ossia::value, QSizeF>([](const ossia::value& ossia_val) -> QSizeF {
1047+
auto val = ossia::convert<ossia::vec2f>(ossia_val);
1048+
return QSizeF(val[0], val[1]);
1049+
});
1050+
QMetaType::registerConverter<ossia::value, QVariantList>([](const ossia::value& ossia_val) -> QVariantList {
1051+
auto val = ossia::convert<std::vector<ossia::value>>(ossia_val);
1052+
QVariantList vars;
1053+
vars.reserve(val.size());
1054+
for(auto& v : val)
1055+
{
1056+
vars.push_back(v.apply(ossia_to_qvariant{}));
1057+
}
1058+
return vars;
1059+
});
1060+
QMetaType::registerConverter<ossia::value, QStringList>([](const ossia::value& ossia_val) -> QStringList {
1061+
auto val = ossia::convert<std::vector<ossia::value>>(ossia_val);
1062+
QStringList vars;
1063+
vars.reserve(val.size());
1064+
for(auto& v : val)
1065+
{
1066+
vars.push_back(QString::fromStdString(ossia::convert<std::string>(v)));
1067+
}
1068+
return vars;
1069+
});
1070+
QMetaType::registerConverter<ossia::value, QByteArrayList>([](const ossia::value& ossia_val) -> QByteArrayList {
1071+
auto val = ossia::convert<std::vector<ossia::value>>(ossia_val);
1072+
QByteArrayList vars;
1073+
vars.reserve(val.size());
1074+
for(auto& v : val)
1075+
{
1076+
vars.push_back(QByteArray::fromStdString(ossia::convert<std::string>(v)));
1077+
}
1078+
return vars;
1079+
});
1080+
QMetaType::registerConverter<ossia::value, QVariantMap>([](const ossia::value& ossia_val) -> QVariantMap {
1081+
auto val = ossia::convert<ossia::value_map_type>(ossia_val);
1082+
QVariantMap vars;
1083+
for(auto& [k, v] : val)
1084+
{
1085+
vars.insert(QString::fromStdString(k), v.apply(ossia_to_qvariant{}));
1086+
}
1087+
return vars;
1088+
});
1089+
QMetaType::registerConverter<ossia::value, QVariantHash>([](const ossia::value& ossia_val) -> QVariantHash {
1090+
auto val = ossia::convert<ossia::value_map_type>(ossia_val);
1091+
QVariantHash vars;
1092+
for(auto& [k, v] : val)
1093+
{
1094+
vars.insert(QString::fromStdString(k), v.apply(ossia_to_qvariant{}));
1095+
}
1096+
return vars;
1097+
});
1098+
1099+
1100+
// Qt -> ossia
1101+
// qvariant -> ossia
1102+
QMetaType::registerConverter<QTime, ossia::value>([](const QTime& v) -> ossia::value {
1103+
return qt_to_ossia{}(v);
1104+
});
1105+
QMetaType::registerConverter<bool, ossia::value>([](const bool& v) -> ossia::value {
1106+
return qt_to_ossia{}(v);
1107+
});
1108+
QMetaType::registerConverter<int, ossia::value>([](const int& v) -> ossia::value {
1109+
return qt_to_ossia{}(v);
1110+
});
1111+
QMetaType::registerConverter<uint, ossia::value>([](const uint& v) -> ossia::value {
1112+
return qt_to_ossia{}(v);
1113+
});
1114+
QMetaType::registerConverter<qlonglong, ossia::value>([](const qlonglong& v) -> ossia::value {
1115+
return qt_to_ossia{}(v);
1116+
});
1117+
QMetaType::registerConverter<qulonglong, ossia::value>([](const qulonglong& v) -> ossia::value {
1118+
return qt_to_ossia{}(v);
1119+
});
1120+
QMetaType::registerConverter<double, ossia::value>([](const double& v) -> ossia::value {
1121+
return qt_to_ossia{}(v);
1122+
});
1123+
QMetaType::registerConverter<long, ossia::value>([](const long& v) -> ossia::value {
1124+
return qt_to_ossia{}((qlonglong)v);
1125+
});
1126+
QMetaType::registerConverter<short, ossia::value>([](const short& v) -> ossia::value {
1127+
return qt_to_ossia{}((int)v);
1128+
});
1129+
QMetaType::registerConverter<ulong, ossia::value>([](const ulong& v) -> ossia::value {
1130+
return qt_to_ossia{}((qlonglong)v);
1131+
});
1132+
QMetaType::registerConverter<ushort, ossia::value>([](const ushort& v) -> ossia::value {
1133+
return qt_to_ossia{}((int)v);
1134+
});
1135+
QMetaType::registerConverter<char, ossia::value>([](const char& v) -> ossia::value {
1136+
return qt_to_ossia{}(v);
1137+
});
1138+
QMetaType::registerConverter<uchar, ossia::value>([](const uchar& v) -> ossia::value {
1139+
return qt_to_ossia{}((char)v);
1140+
});
1141+
QMetaType::registerConverter<signed char, ossia::value>([](const signed char& v) -> ossia::value {
1142+
return qt_to_ossia{}((char)v);
1143+
});
1144+
QMetaType::registerConverter<std::nullptr_t, ossia::value>([](const std::nullptr_t&) -> ossia::value {
1145+
return ossia::value{};
1146+
});
1147+
QMetaType::registerConverter<QChar, ossia::value>([](const QChar& v) -> ossia::value {
1148+
return qt_to_ossia{}(v);
1149+
});
1150+
QMetaType::registerConverter<QUrl, ossia::value>([](const QUrl& v) -> ossia::value {
1151+
return qt_to_ossia{}(v.toString());
1152+
});
1153+
QMetaType::registerConverter<QString, ossia::value>([](const QString& v) -> ossia::value {
1154+
return qt_to_ossia{}(v);
1155+
});
1156+
QMetaType::registerConverter<QByteArray, ossia::value>([](const QByteArray& v) -> ossia::value {
1157+
return qt_to_ossia{}(v);
1158+
});
1159+
QMetaType::registerConverter<float, ossia::value>([](const float& v) -> ossia::value {
1160+
return qt_to_ossia{}(v);
1161+
});
1162+
QMetaType::registerConverter<QColor, ossia::value>([](const QColor& v) -> ossia::value {
1163+
return qt_to_ossia{}(v);
1164+
});
1165+
QMetaType::registerConverter<QPoint, ossia::value>([](const QPoint& v) -> ossia::value {
1166+
return qt_to_ossia{}(v);
1167+
});
1168+
QMetaType::registerConverter<QPointF, ossia::value>([](const QPointF& v) -> ossia::value {
1169+
return qt_to_ossia{}(v);
1170+
});
1171+
QMetaType::registerConverter<QVector2D, ossia::value>([](const QVector2D& v) -> ossia::value {
1172+
return qt_to_ossia{}(v);
1173+
});
1174+
QMetaType::registerConverter<QSize, ossia::value>([](const QSize& v) -> ossia::value {
1175+
return qt_to_ossia{}(v);
1176+
});
1177+
QMetaType::registerConverter<QSizeF, ossia::value>([](const QSizeF& v) -> ossia::value {
1178+
return qt_to_ossia{}(v);
1179+
});
1180+
QMetaType::registerConverter<QVector3D, ossia::value>([](const QVector3D& v) -> ossia::value {
1181+
return qt_to_ossia{}(v);
1182+
});
1183+
QMetaType::registerConverter<QVector4D, ossia::value>([](const QVector4D& v) -> ossia::value {
1184+
return qt_to_ossia{}(v);
1185+
});
1186+
QMetaType::registerConverter<QQuaternion, ossia::value>([](const QQuaternion& v) -> ossia::value {
1187+
return qt_to_ossia{}(v);
1188+
});
1189+
QMetaType::registerConverter<QLine, ossia::value>([](const QLine& v) -> ossia::value {
1190+
return qt_to_ossia{}(v);
1191+
});
1192+
QMetaType::registerConverter<QLineF, ossia::value>([](const QLineF& v) -> ossia::value {
1193+
return qt_to_ossia{}(v);
1194+
});
1195+
QMetaType::registerConverter<QRect, ossia::value>([](const QRect& v) -> ossia::value {
1196+
return qt_to_ossia{}(v);
1197+
});
1198+
QMetaType::registerConverter<QRectF, ossia::value>([](const QRectF& v) -> ossia::value {
1199+
return qt_to_ossia{}(v);
1200+
});
1201+
QMetaType::registerConverter<QVariantList, ossia::value>([](const QVariantList& v) -> ossia::value {
1202+
return qt_to_ossia{}(v);
1203+
});
1204+
QMetaType::registerConverter<QVariantMap, ossia::value>([](const QVariantMap& v) -> ossia::value {
1205+
return qt_to_ossia{}(v);
1206+
});
1207+
QMetaType::registerConverter<QVariantHash, ossia::value>([](const QVariantHash& v) -> ossia::value {
1208+
return qt_to_ossia{}(v);
1209+
});
1210+
QMetaType::registerConverter<QJsonArray, ossia::value>([](const QJsonArray& v) -> ossia::value {
1211+
return qt_to_ossia{}(v.toVariantList());
1212+
});
1213+
QMetaType::registerConverter<QJsonObject, ossia::value>([](const QJsonObject& v) -> ossia::value {
1214+
return qt_to_ossia{}(v.toVariantMap());
1215+
});
1216+
QMetaType::registerConverter<QJsonValue, ossia::value>([](const QJsonValue& v) -> ossia::value {
1217+
return qt_to_ossia{}(v.toVariant());
1218+
});
1219+
QMetaType::registerConverter<QStringList, ossia::value>([](const QStringList& v) -> ossia::value {
1220+
return qt_to_ossia{}(v);
1221+
});
1222+
QMetaType::registerConverter<QByteArrayList, ossia::value>([](const QByteArrayList& v) -> ossia::value {
1223+
return qt_to_ossia{}(v);
1224+
});
1225+
QMetaType::registerConverter<QDate, ossia::value>([](const QDate& v) -> ossia::value {
1226+
return qt_to_ossia{}(v);
1227+
});
1228+
1229+
#if __has_include(<QJSValue>)
1230+
QMetaType::registerConverter<QJSValue, ossia::value>([](const QJSValue& v) -> ossia::value {
1231+
return value_from_js(v);
1232+
});
1233+
QMetaType::registerConverter<QJSValueList, ossia::value>([](const QJSValueList& in_values) -> ossia::value {
1234+
std::vector<ossia::value> out_values;
1235+
out_values.reserve(in_values.size());
1236+
for(const auto& in_val : in_values)
1237+
out_values.push_back(value_from_js(in_val));
1238+
return out_values;
1239+
});
1240+
#endif
1241+
1242+
1243+
// Generic cases
1244+
QMetaType::registerConverter<ossia::value, QVariant>([](const ossia::value& ossia_val) -> QVariant {
1245+
return ossia_val.apply(ossia_to_qvariant{});
1246+
});
1247+
QMetaType::registerConverter<QVariant, ossia::value>([](const QVariant& qval) -> ossia::value {
1248+
return qt_to_ossia{}(qval);
1249+
});
1250+
1251+
}
1252+
9251253
}
9261254
#endif
9271255

‎src/ossia-qt/js_utilities.hpp‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -304,6 +304,8 @@ struct ossia_to_qvariant
304304
}
305305
};
306306

307+
OSSIA_EXPORT void registerQVariantConverters();
308+
307309
#if defined(QT_QML_LIB)
308310
/**
309311
* @brief The js_value_outbound_visitor struct

‎src/ossia-qt/protocols/utils.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ namespace ossia::qt
2020
{
2121
struct protocols_sender
2222
{
23-
void send_osc(this auto&& self, QByteArray address, QJSValueList values)
23+
void send_osc(this auto&& self, QByteArray address, const QJSValueList& values)
2424
{
2525
using socket_type = std::remove_cvref_t<decltype(self.socket)>;
2626
using writer_type = ossia::net::socket_writer<socket_type>;

‎src/ossia/dataflow/graph_node.hpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -214,6 +214,7 @@ class OSSIA_EXPORT nonowning_graph_node : public graph_node
214214
};
215215

216216
template <typename T, typename... Args>
217+
requires std::is_constructible_v<T, Args...>
217218
auto make_node(const execution_state& st, Args&&... args)
218219
{
219220
auto n = std::make_shared<T>(std::forward<Args>(args)...);

0 commit comments

Comments
 (0)