1195 lines
41 KiB
C++
1195 lines
41 KiB
C++
/*
|
|
* Copyright 2017 Jos van den Oever <jos@vandenoever.info>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License or (at your option) version 3 or any later version
|
|
* accepted by the membership of KDE e.V. (or its successor approved
|
|
* by the membership of KDE e.V.), which shall act as a proxy
|
|
* defined in Section 14 of version 3 of the license.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "structs.h"
|
|
#include "cpp.h"
|
|
#include "helper.h"
|
|
#include <QMetaEnum>
|
|
#include <QDebug>
|
|
|
|
template <typename T>
|
|
QString cppSetType(const T& p)
|
|
{
|
|
if (p.optional) {
|
|
return "option_" + p.type.cppSetType;
|
|
}
|
|
return p.type.cppSetType;
|
|
}
|
|
|
|
template <typename T>
|
|
QString propertyType(const T& p)
|
|
{
|
|
return (p.optional && !p.type.isComplex()) ?"QVariant" :p.type.name;
|
|
}
|
|
|
|
QString upperInitial(const QString& name) {
|
|
return name.left(1).toUpper() + name.mid(1);
|
|
}
|
|
|
|
QString lowerInitial(const QString& name) {
|
|
return name.left(1).toLower() + name.mid(1);
|
|
}
|
|
|
|
QString writeProperty(const QString& name) {
|
|
return "WRITE set" + upperInitial(name) + " ";
|
|
}
|
|
|
|
QString baseType(const Object& o) {
|
|
if (o.type != ObjectType::Object) {
|
|
return "QAbstractItemModel";
|
|
}
|
|
return "QObject";
|
|
}
|
|
|
|
QString cGetType(const BindingTypeProperties& type) {
|
|
return type.name + "*, " + type.name.toLower() + "_set";
|
|
}
|
|
|
|
bool modelIsWritable(const Object& o) {
|
|
bool write = false;
|
|
for (auto ip: o.itemProperties) {
|
|
write |= ip.write;
|
|
}
|
|
return write;
|
|
}
|
|
|
|
void writeHeaderItemModel(QTextStream& h, const Object& o) {
|
|
h << QString(R"(
|
|
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
|
|
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
|
|
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
|
|
QModelIndex parent(const QModelIndex &index) const override;
|
|
bool hasChildren(const QModelIndex &parent = QModelIndex()) const override;
|
|
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
|
|
bool canFetchMore(const QModelIndex &parent) const override;
|
|
void fetchMore(const QModelIndex &parent) override;
|
|
Qt::ItemFlags flags(const QModelIndex &index) const override;
|
|
void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
|
|
int role(const char* name) const;
|
|
QHash<int, QByteArray> roleNames() const override;
|
|
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
|
|
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole) override;
|
|
Q_INVOKABLE bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
|
|
Q_INVOKABLE bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
|
|
)");
|
|
if (modelIsWritable(o)) {
|
|
h << " bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;\n";
|
|
}
|
|
for (auto ip: o.itemProperties) {
|
|
auto r = propertyType(ip);
|
|
auto rw = r;
|
|
if (r == "QVariant" || ip.type.isComplex()) {
|
|
rw = "const " + r + "&";
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
h << QString(" Q_INVOKABLE %2 %1(int row) const;\n").arg(ip.name, r);
|
|
if (ip.write) {
|
|
h << QString(" Q_INVOKABLE bool set%1(int row, %2 value);\n").arg(upperInitial(ip.name), rw);
|
|
}
|
|
} else {
|
|
h << QString(" Q_INVOKABLE %2 %1(const QModelIndex& index) const;\n").arg(ip.name, r);
|
|
if (ip.write) {
|
|
h << QString(" Q_INVOKABLE bool set%1(const QModelIndex& index, %2 value);\n").arg(upperInitial(ip.name), rw);
|
|
}
|
|
}
|
|
}
|
|
h << R"(
|
|
Q_SIGNALS:
|
|
// new data is ready to be made available to the model with fetchMore()
|
|
void newDataReady(const QModelIndex &parent) const;
|
|
private:
|
|
QHash<QPair<int,Qt::ItemDataRole>, QVariant> m_headerData;
|
|
void initHeaderData();
|
|
void updatePersistentIndexes();
|
|
)";
|
|
}
|
|
|
|
bool isColumnWrite(const Object& o, int col) {
|
|
for (auto ip: o.itemProperties) {
|
|
if (ip.write && (col == 0 || (ip.roles.size() > col && ip.roles[col].size() > 0))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void writeModelGetterSetter(QTextStream& cpp, const QString& index,
|
|
const ItemProperty& ip, const Object& o) {
|
|
const QString lcname(snakeCase(o.name));
|
|
QString idx = index;
|
|
|
|
// getter
|
|
auto r = propertyType(ip);
|
|
if (o.type == ObjectType::List) {
|
|
idx = ", row";
|
|
cpp << QString("%3 %1::%2(int row) const\n{\n")
|
|
.arg(o.name, ip.name, r);
|
|
} else {
|
|
cpp << QString("%3 %1::%2(const QModelIndex& index) const\n{\n")
|
|
.arg(o.name, ip.name, r);
|
|
}
|
|
if (ip.type.name == "QString") {
|
|
cpp << " QString s;\n";
|
|
cpp << QString(" %1_data_%2(m_d%4, &s, set_%3);\n")
|
|
.arg(lcname, snakeCase(ip.name), ip.type.name.toLower(), idx);
|
|
cpp << " return s;\n";
|
|
} else if (ip.type.name == "QByteArray") {
|
|
cpp << " QByteArray b;\n";
|
|
cpp << QString(" %1_data_%2(m_d%4, &b, set_%3);\n")
|
|
.arg(lcname, snakeCase(ip.name), ip.type.name.toLower(), idx);
|
|
cpp << " return b;\n";
|
|
} else if (ip.optional) {
|
|
cpp << " QVariant v;\n";
|
|
cpp << QString(" v = %1_data_%2(m_d%3);\n")
|
|
.arg(lcname, snakeCase(ip.name), idx);
|
|
cpp << " return v;\n";
|
|
} else {
|
|
cpp << QString(" return %1_data_%2(m_d%3);\n")
|
|
.arg(lcname, snakeCase(ip.name), idx);
|
|
}
|
|
cpp << "}\n\n";
|
|
|
|
if (!ip.write) {
|
|
return;
|
|
}
|
|
|
|
// setter
|
|
if (r == "QVariant" || ip.type.isComplex()) {
|
|
r = "const " + r + "&";
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
idx = ", row";
|
|
cpp << QString("bool %1::set%2(int row, %3 value)\n{\n")
|
|
.arg(o.name, upperInitial(ip.name), r);
|
|
} else {
|
|
cpp << QString("bool %1::set%2(const QModelIndex& index, %3 value)\n{\n")
|
|
.arg(o.name, upperInitial(ip.name), r);
|
|
}
|
|
cpp << " bool set = false;\n";
|
|
if (ip.optional) {
|
|
QString test = "value.isNull()";
|
|
if (!ip.type.isComplex()) {
|
|
test += " || !value.isValid()";
|
|
}
|
|
cpp << " if (" << test << ") {\n";
|
|
cpp << QString(" set = %1_set_data_%2_none(m_d%3);")
|
|
.arg(lcname, snakeCase(ip.name), idx) << endl;
|
|
cpp << " } else {\n";
|
|
}
|
|
if (ip.optional && !ip.type.isComplex()) {
|
|
cpp << QString(" if (!value.canConvert(qMetaTypeId<%1>())) {\n return false;\n }\n").arg(ip.type.name);
|
|
cpp << QString(" set = %1_set_data_%2(m_d%3, value.value<%4>());")
|
|
.arg(lcname, snakeCase(ip.name), idx, ip.type.name) << endl;
|
|
} else {
|
|
QString val = "value";
|
|
if (ip.type.isComplex()) {
|
|
if (ip.type.name == "QString") {
|
|
val = "value.utf16(), value.length()";
|
|
} else {
|
|
val = "value.data(), value.length()";
|
|
}
|
|
}
|
|
cpp << QString(" set = %1_set_data_%2(m_d%3, %4);")
|
|
.arg(lcname, snakeCase(ip.name), idx, val) << endl;
|
|
}
|
|
if (ip.optional) {
|
|
cpp << " }\n";
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
cpp << R"( if (set) {
|
|
QModelIndex index = createIndex(row, 0, row);
|
|
Q_EMIT dataChanged(index, index);
|
|
}
|
|
return set;
|
|
}
|
|
|
|
)";
|
|
} else {
|
|
cpp << R"( if (set) {
|
|
Q_EMIT dataChanged(index, index);
|
|
}
|
|
return set;
|
|
}
|
|
|
|
)";
|
|
}
|
|
}
|
|
|
|
void writeCppModel(QTextStream& cpp, const Object& o) {
|
|
const QString lcname(snakeCase(o.name));
|
|
QString indexDecl = ", int";
|
|
QString index = ", index.row()";
|
|
if (o.type == ObjectType::Tree) {
|
|
indexDecl = ", quintptr";
|
|
index = ", index.internalId()";
|
|
}
|
|
|
|
cpp << "extern \"C\" {\n";
|
|
for (auto ip: o.itemProperties) {
|
|
if (ip.type.isComplex()) {
|
|
cpp << QString(" void %2_data_%3(const %1::Private*%5, %4);\n")
|
|
.arg(o.name, lcname, snakeCase(ip.name), cGetType(ip.type), indexDecl);
|
|
} else {
|
|
cpp << QString(" %4 %2_data_%3(const %1::Private*%5);\n")
|
|
.arg(o.name, lcname, snakeCase(ip.name), cppSetType(ip), indexDecl);
|
|
}
|
|
if (ip.write) {
|
|
if (ip.type.name == "QString") {
|
|
cpp << QString(" bool %2_set_data_%3(%1::Private*%4, const ushort* s, int len);")
|
|
.arg(o.name, lcname, snakeCase(ip.name), indexDecl) << endl;
|
|
} else if (ip.type.name == "QByteArray") {
|
|
cpp << QString(" bool %2_set_data_%3(%1::Private*%4, const char* s, int len);")
|
|
.arg(o.name, lcname, snakeCase(ip.name), indexDecl) << endl;
|
|
} else {
|
|
cpp << QString(" bool %2_set_data_%3(%1::Private*%5, %4);")
|
|
.arg(o.name, lcname, snakeCase(ip.name), ip.type.cSetType, indexDecl) << endl;
|
|
}
|
|
if (ip.optional) {
|
|
cpp << QString(" bool %2_set_data_%3_none(%1::Private*%4);")
|
|
.arg(o.name, lcname, snakeCase(ip.name), indexDecl) << endl;
|
|
}
|
|
}
|
|
}
|
|
cpp << QString(" void %2_sort(%1::Private*, unsigned char column, Qt::SortOrder order = Qt::AscendingOrder);\n").arg(o.name, lcname);
|
|
if (o.type == ObjectType::List) {
|
|
cpp << QString(R"(
|
|
int %2_row_count(const %1::Private*);
|
|
bool %2_insert_rows(%1::Private*, int, int);
|
|
bool %2_remove_rows(%1::Private*, int, int);
|
|
bool %2_can_fetch_more(const %1::Private*);
|
|
void %2_fetch_more(%1::Private*);
|
|
}
|
|
int %1::columnCount(const QModelIndex &parent) const
|
|
{
|
|
return (parent.isValid()) ? 0 : %3;
|
|
}
|
|
|
|
bool %1::hasChildren(const QModelIndex &parent) const
|
|
{
|
|
return rowCount(parent) > 0;
|
|
}
|
|
|
|
int %1::rowCount(const QModelIndex &parent) const
|
|
{
|
|
return (parent.isValid()) ? 0 : %2_row_count(m_d);
|
|
}
|
|
|
|
bool %1::insertRows(int row, int count, const QModelIndex &)
|
|
{
|
|
return %2_insert_rows(m_d, row, count);
|
|
}
|
|
|
|
bool %1::removeRows(int row, int count, const QModelIndex &)
|
|
{
|
|
return %2_remove_rows(m_d, row, count);
|
|
}
|
|
|
|
QModelIndex %1::index(int row, int column, const QModelIndex &parent) const
|
|
{
|
|
if (!parent.isValid() && row >= 0 && row < rowCount(parent) && column >= 0 && column < %3) {
|
|
return createIndex(row, column, (quintptr)row);
|
|
}
|
|
return QModelIndex();
|
|
}
|
|
|
|
QModelIndex %1::parent(const QModelIndex &) const
|
|
{
|
|
return QModelIndex();
|
|
}
|
|
|
|
bool %1::canFetchMore(const QModelIndex &parent) const
|
|
{
|
|
return (parent.isValid()) ? 0 : %2_can_fetch_more(m_d);
|
|
}
|
|
|
|
void %1::fetchMore(const QModelIndex &parent)
|
|
{
|
|
if (!parent.isValid()) {
|
|
%2_fetch_more(m_d);
|
|
}
|
|
}
|
|
void %1::updatePersistentIndexes() {}
|
|
)").arg(o.name, lcname, QString::number(o.columnCount));
|
|
} else {
|
|
cpp << QString(R"(
|
|
int %2_row_count(const %1::Private*, option_quintptr);
|
|
bool %2_can_fetch_more(const %1::Private*, option_quintptr);
|
|
void %2_fetch_more(%1::Private*, option_quintptr);
|
|
quintptr %2_index(const %1::Private*, option_quintptr, int);
|
|
qmodelindex_t %2_parent(const %1::Private*, quintptr);
|
|
int %2_row(const %1::Private*, quintptr);
|
|
option_quintptr %2_check_row(const %1::Private*, quintptr, int);
|
|
}
|
|
int %1::columnCount(const QModelIndex &) const
|
|
{
|
|
return %3;
|
|
}
|
|
|
|
bool %1::hasChildren(const QModelIndex &parent) const
|
|
{
|
|
return rowCount(parent) > 0;
|
|
}
|
|
|
|
int %1::rowCount(const QModelIndex &parent) const
|
|
{
|
|
if (parent.isValid() && parent.column() != 0) {
|
|
return 0;
|
|
}
|
|
const option_quintptr rust_parent = {
|
|
parent.internalId(),
|
|
parent.isValid()
|
|
};
|
|
return %2_row_count(m_d, rust_parent);
|
|
}
|
|
|
|
bool %1::insertRows(int, int, const QModelIndex &)
|
|
{
|
|
return false; // not supported yet
|
|
}
|
|
|
|
bool %1::removeRows(int, int, const QModelIndex &)
|
|
{
|
|
return false; // not supported yet
|
|
}
|
|
|
|
QModelIndex %1::index(int row, int column, const QModelIndex &parent) const
|
|
{
|
|
if (row < 0 || column < 0 || column >= %3) {
|
|
return QModelIndex();
|
|
}
|
|
if (parent.isValid() && parent.column() != 0) {
|
|
return QModelIndex();
|
|
}
|
|
if (row >= rowCount(parent)) {
|
|
return QModelIndex();
|
|
}
|
|
const option_quintptr rust_parent = {
|
|
parent.internalId(),
|
|
parent.isValid()
|
|
};
|
|
const quintptr id = %2_index(m_d, rust_parent, row);
|
|
return createIndex(row, column, id);
|
|
}
|
|
|
|
QModelIndex %1::parent(const QModelIndex &index) const
|
|
{
|
|
if (!index.isValid()) {
|
|
return QModelIndex();
|
|
}
|
|
const qmodelindex_t parent = %2_parent(m_d, index.internalId());
|
|
return parent.row >= 0 ?createIndex(parent.row, 0, parent.id) :QModelIndex();
|
|
}
|
|
|
|
bool %1::canFetchMore(const QModelIndex &parent) const
|
|
{
|
|
if (parent.isValid() && parent.column() != 0) {
|
|
return false;
|
|
}
|
|
const option_quintptr rust_parent = {
|
|
parent.internalId(),
|
|
parent.isValid()
|
|
};
|
|
return %2_can_fetch_more(m_d, rust_parent);
|
|
}
|
|
|
|
void %1::fetchMore(const QModelIndex &parent)
|
|
{
|
|
const option_quintptr rust_parent = {
|
|
parent.internalId(),
|
|
parent.isValid()
|
|
};
|
|
%2_fetch_more(m_d, rust_parent);
|
|
}
|
|
void %1::updatePersistentIndexes() {
|
|
const auto from = persistentIndexList();
|
|
auto to = from;
|
|
auto len = to.size();
|
|
for (int i = 0; i < len; ++i) {
|
|
auto index = to.at(i);
|
|
auto row = %2_check_row(m_d, index.internalId(), index.row());
|
|
if (row.some) {
|
|
to[i] = createIndex(row.value, index.column(), index.internalId());
|
|
} else {
|
|
to[i] = QModelIndex();
|
|
}
|
|
}
|
|
changePersistentIndexList(from, to);
|
|
}
|
|
)").arg(o.name, lcname, QString::number(o.columnCount));
|
|
}
|
|
|
|
cpp << QString(R"(
|
|
void %1::sort(int column, Qt::SortOrder order)
|
|
{
|
|
%2_sort(m_d, column, order);
|
|
}
|
|
Qt::ItemFlags %1::flags(const QModelIndex &i) const
|
|
{
|
|
auto flags = QAbstractItemModel::flags(i);
|
|
)").arg(o.name, lcname);
|
|
for (int col = 0; col < o.columnCount; ++col) {
|
|
if (isColumnWrite(o, col)) {
|
|
cpp << " if (i.column() == " << col << ") {\n";
|
|
cpp << " flags |= Qt::ItemIsEditable;\n }\n";
|
|
}
|
|
}
|
|
cpp << " return flags;\n}\n\n";
|
|
for (auto ip: o.itemProperties) {
|
|
writeModelGetterSetter(cpp, index, ip, o);
|
|
}
|
|
cpp << QString(R"(QVariant %1::data(const QModelIndex &index, int role) const
|
|
{
|
|
Q_ASSERT(rowCount(index.parent()) > index.row());
|
|
switch (index.column()) {
|
|
)").arg(o.name);
|
|
|
|
auto metaRoles = QMetaEnum::fromType<Qt::ItemDataRole>();
|
|
for (int col = 0; col < o.columnCount; ++col) {
|
|
cpp << QString(" case %1:\n").arg(col);
|
|
cpp << QString(" switch (role) {\n");
|
|
for (int i = 0; i < o.itemProperties.size(); ++i) {
|
|
auto ip = o.itemProperties[i];
|
|
auto roles = ip.roles.value(col);
|
|
if (col > 0 && roles.size() == 0) {
|
|
continue;
|
|
}
|
|
for (auto role: roles) {
|
|
cpp << QString(" case Qt::%1:\n").arg(metaRoles.valueToKey(role));
|
|
}
|
|
cpp << QString(" case Qt::UserRole + %1:\n").arg(i);
|
|
auto ii = (o.type == ObjectType::List) ?".row()" :"";
|
|
if (ip.optional && !ip.type.isComplex()) {
|
|
cpp << QString(" return %1(index%2);\n").arg(ip.name, ii);
|
|
} else if (ip.optional) {
|
|
cpp << QString(" return cleanNullQVariant(QVariant::fromValue(%1(index%2)));\n").arg(ip.name, ii);
|
|
} else {
|
|
cpp << QString(" return QVariant::fromValue(%1(index%2));\n").arg(ip.name, ii);
|
|
}
|
|
}
|
|
cpp << " }\n break;\n";
|
|
}
|
|
cpp << " }\n return QVariant();\n}\n\n";
|
|
cpp << "int " << o.name << "::role(const char* name) const {\n";
|
|
cpp << " auto names = roleNames();\n";
|
|
cpp << " auto i = names.constBegin();\n";
|
|
cpp << " while (i != names.constEnd()) {\n";
|
|
cpp << " if (i.value() == name) {\n";
|
|
cpp << " return i.key();\n";
|
|
cpp << " }\n";
|
|
cpp << " ++i;\n";
|
|
cpp << " }\n";
|
|
cpp << " return -1;\n";
|
|
cpp << "}\n";
|
|
cpp << "QHash<int, QByteArray> " << o.name << "::roleNames() const {\n";
|
|
cpp << " QHash<int, QByteArray> names = QAbstractItemModel::roleNames();\n";
|
|
for (int i = 0; i < o.itemProperties.size(); ++i) {
|
|
auto ip = o.itemProperties[i];
|
|
cpp << " names.insert(Qt::UserRole + " << i << ", \"" << ip.name << "\");\n";
|
|
}
|
|
cpp << " return names;\n";
|
|
cpp << QString(R"(}
|
|
QVariant %1::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if (orientation != Qt::Horizontal) {
|
|
return QVariant();
|
|
}
|
|
return m_headerData.value(qMakePair(section, (Qt::ItemDataRole)role), role == Qt::DisplayRole ?QString::number(section + 1) :QVariant());
|
|
}
|
|
|
|
bool %1::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
|
|
{
|
|
if (orientation != Qt::Horizontal) {
|
|
return false;
|
|
}
|
|
m_headerData.insert(qMakePair(section, (Qt::ItemDataRole)role), value);
|
|
return true;
|
|
}
|
|
|
|
)").arg(o.name);
|
|
if (modelIsWritable(o)) {
|
|
cpp << QString("bool %1::setData(const QModelIndex &index, const QVariant &value, int role)\n{\n").arg(o.name);
|
|
for (int col = 0; col < o.columnCount; ++col) {
|
|
if (!isColumnWrite(o, col)) {
|
|
continue;
|
|
}
|
|
cpp << " if (index.column() == " << col << ") {\n";
|
|
for (int i = 0; i < o.itemProperties.size(); ++i) {
|
|
auto ip = o.itemProperties[i];
|
|
if (!ip.write) {
|
|
continue;
|
|
}
|
|
auto roles = ip.roles.value(col);
|
|
if (col > 0 && roles.size() == 0) {
|
|
continue;
|
|
}
|
|
cpp << " if (";
|
|
for (auto role: roles) {
|
|
cpp << QString("role == Qt::%1 || ").arg(metaRoles.valueToKey(role));
|
|
}
|
|
cpp << "role == Qt::UserRole + " << i << ") {\n";
|
|
auto ii = (o.type == ObjectType::List) ?".row()" :"";
|
|
if (ip.optional && !ip.type.isComplex()) {
|
|
cpp << QString(" return set%1(index%2, value);\n")
|
|
.arg(upperInitial(ip.name), ii);
|
|
} else {
|
|
QString pre = "";
|
|
if (ip.optional) {
|
|
pre = "!value.isValid() || value.isNull() ||";
|
|
}
|
|
cpp << QString(" if (%2value.canConvert(qMetaTypeId<%1>())) {\n").arg(ip.type.name, pre);
|
|
cpp << QString(" return set%1(index%2, value.value<%3>());\n").arg(upperInitial(ip.name), ii, ip.type.name);
|
|
cpp << QString(" }\n");
|
|
}
|
|
cpp << " }\n";
|
|
}
|
|
cpp << " }\n";
|
|
}
|
|
cpp << " return false;\n}\n\n";
|
|
}
|
|
}
|
|
|
|
void writeHeaderObject(QTextStream& h, const Object& o, const Configuration& conf) {
|
|
h << QString(R"(
|
|
class %1 : public %3
|
|
{
|
|
Q_OBJEC%2
|
|
)").arg(o.name, "T", baseType(o));
|
|
for (auto object: conf.objects) {
|
|
if (object.containsObject() && o.name != object.name) {
|
|
h << " friend class " << object.name << ";\n";
|
|
}
|
|
}
|
|
h << R"(public:
|
|
class Private;
|
|
private:
|
|
)";
|
|
for (auto p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
h << " " << p.type.name << "* const m_" << p.name << ";\n";
|
|
}
|
|
}
|
|
h << R"( Private * m_d;
|
|
bool m_ownsPrivate;
|
|
)";
|
|
for (auto p: o.properties) {
|
|
bool obj = p.type.type == BindingType::Object;
|
|
auto t = p.type.name;
|
|
if (p.optional && !p.type.isComplex()) {
|
|
t = "QVariant";
|
|
}
|
|
h << QString(" Q_PROPERTY(%1 %2 READ %2 %3NOTIFY %2Changed FINAL)")
|
|
.arg(t + (obj ?"*" :""),
|
|
p.name,
|
|
p.write ? writeProperty(p.name) :"")
|
|
<< endl;
|
|
}
|
|
h << QString(R"( explicit %1(bool owned, QObject *parent);
|
|
public:
|
|
explicit %1(QObject *parent = nullptr);
|
|
~%1();
|
|
)").arg(o.name);
|
|
for (auto p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
h << " const " << p.type.name << "* " << p.name << "() const;" << endl;
|
|
h << " " << p.type.name << "* " << p.name << "();" << endl;
|
|
} else {
|
|
auto t = p.type.name;
|
|
auto t2 = p.type.cppSetType;
|
|
if (p.optional && !p.type.isComplex()) {
|
|
t = "QVariant";
|
|
t2 = "const QVariant&";
|
|
}
|
|
h << " " << t << " " << p.name << "() const;" << endl;
|
|
if (p.write) {
|
|
h << " void set" << upperInitial(p.name) << "(" << t2 << " v);" << endl;
|
|
}
|
|
}
|
|
}
|
|
for (auto f: o.functions) {
|
|
h << " Q_INVOKABLE " << f.type.name << " " << f.name << "(";
|
|
for (auto a = f.args.begin(); a < f.args.end(); a++) {
|
|
if (a != f.args.begin()) {
|
|
h << ", ";
|
|
}
|
|
h << QString("%1 %2").arg(a->type.cppSetType, a->name);
|
|
}
|
|
h << QString(")%1;").arg(f.mut ? "" : " const");
|
|
h << endl;
|
|
}
|
|
if (baseType(o) == "QAbstractItemModel") {
|
|
writeHeaderItemModel(h, o);
|
|
}
|
|
h << "Q_SIGNALS:" << endl;
|
|
for (auto p: o.properties) {
|
|
h << " void " << p.name << "Changed();" << endl;
|
|
}
|
|
h << "};" << endl;
|
|
}
|
|
|
|
void constructorArgsDecl(QTextStream& cpp, const Object& o, const Configuration& conf) {
|
|
cpp << o.name << "*";
|
|
for (auto p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << QString(", ");
|
|
constructorArgsDecl(cpp, conf.findObject(p.type.name), conf);
|
|
} else {
|
|
cpp << QString(", void (*)(%1*)").arg(o.name);
|
|
}
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
cpp << QString(R"(,
|
|
void (*)(const %1*),
|
|
void (*)(%1*),
|
|
void (*)(%1*),
|
|
void (*)(%1*, quintptr, quintptr),
|
|
void (*)(%1*),
|
|
void (*)(%1*),
|
|
void (*)(%1*, int, int),
|
|
void (*)(%1*),
|
|
void (*)(%1*, int, int, int),
|
|
void (*)(%1*),
|
|
void (*)(%1*, int, int),
|
|
void (*)(%1*))").arg(o.name);
|
|
}
|
|
if (o.type == ObjectType::Tree) {
|
|
cpp << QString(R"(,
|
|
void (*)(const %1*, option_quintptr),
|
|
void (*)(%1*),
|
|
void (*)(%1*),
|
|
void (*)(%1*, quintptr, quintptr),
|
|
void (*)(%1*),
|
|
void (*)(%1*),
|
|
void (*)(%1*, option_quintptr, int, int),
|
|
void (*)(%1*),
|
|
void (*)(%1*, option_quintptr, int, int, option_quintptr, int),
|
|
void (*)(%1*),
|
|
void (*)(%1*, option_quintptr, int, int),
|
|
void (*)(%1*))").arg(o.name);
|
|
}
|
|
}
|
|
|
|
QString changedF(const Object& o, const Property& p) {
|
|
return lowerInitial(o.name) + upperInitial(p.name) + "Changed";
|
|
}
|
|
|
|
void constructorArgs(QTextStream& cpp, const QString& prefix, const Object& o, const Configuration& conf) {
|
|
const QString lcname(snakeCase(o.name));
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << ", " << prefix << "m_" << p.name;
|
|
constructorArgs(cpp, "m_" + p.name + "->",
|
|
conf.findObject(p.type.name), conf);
|
|
} else {
|
|
cpp << ",\n " << changedF(o, p);
|
|
}
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
cpp << QString(R"(,
|
|
[](const %1* o) {
|
|
Q_EMIT o->newDataReady(QModelIndex());
|
|
},
|
|
[](%1* o) {
|
|
Q_EMIT o->layoutAboutToBeChanged();
|
|
},
|
|
[](%1* o) {
|
|
o->updatePersistentIndexes();
|
|
Q_EMIT o->layoutChanged();
|
|
},
|
|
[](%1* o, quintptr first, quintptr last) {
|
|
o->dataChanged(o->createIndex(first, 0, first),
|
|
o->createIndex(last, %2, last));
|
|
},
|
|
[](%1* o) {
|
|
o->beginResetModel();
|
|
},
|
|
[](%1* o) {
|
|
o->endResetModel();
|
|
},
|
|
[](%1* o, int first, int last) {
|
|
o->beginInsertRows(QModelIndex(), first, last);
|
|
},
|
|
[](%1* o) {
|
|
o->endInsertRows();
|
|
},
|
|
[](%1* o, int first, int last, int destination) {
|
|
o->beginMoveRows(QModelIndex(), first, last, QModelIndex(), destination);
|
|
},
|
|
[](%1* o) {
|
|
o->endMoveRows();
|
|
},
|
|
[](%1* o, int first, int last) {
|
|
o->beginRemoveRows(QModelIndex(), first, last);
|
|
},
|
|
[](%1* o) {
|
|
o->endRemoveRows();
|
|
}
|
|
)").arg(o.name, QString::number(o.columnCount - 1));
|
|
}
|
|
if (o.type == ObjectType::Tree) {
|
|
cpp << QString(R"(,
|
|
[](const %1* o, option_quintptr id) {
|
|
if (id.some) {
|
|
int row = %2_row(o->m_d, id.value);
|
|
Q_EMIT o->newDataReady(o->createIndex(row, 0, id.value));
|
|
} else {
|
|
Q_EMIT o->newDataReady(QModelIndex());
|
|
}
|
|
},
|
|
[](%1* o) {
|
|
Q_EMIT o->layoutAboutToBeChanged();
|
|
},
|
|
[](%1* o) {
|
|
o->updatePersistentIndexes();
|
|
Q_EMIT o->layoutChanged();
|
|
},
|
|
[](%1* o, quintptr first, quintptr last) {
|
|
quintptr frow = %2_row(o->m_d, first);
|
|
quintptr lrow = %2_row(o->m_d, first);
|
|
o->dataChanged(o->createIndex(frow, 0, first),
|
|
o->createIndex(lrow, %3, last));
|
|
},
|
|
[](%1* o) {
|
|
o->beginResetModel();
|
|
},
|
|
[](%1* o) {
|
|
o->endResetModel();
|
|
},
|
|
[](%1* o, option_quintptr id, int first, int last) {
|
|
if (id.some) {
|
|
int row = %2_row(o->m_d, id.value);
|
|
o->beginInsertRows(o->createIndex(row, 0, id.value), first, last);
|
|
} else {
|
|
o->beginInsertRows(QModelIndex(), first, last);
|
|
}
|
|
},
|
|
[](%1* o) {
|
|
o->endInsertRows();
|
|
},
|
|
[](%1* o, option_quintptr sourceParent, int first, int last, option_quintptr destinationParent, int destination) {
|
|
QModelIndex s;
|
|
if (sourceParent.some) {
|
|
int row = %2_row(o->m_d, sourceParent.value);
|
|
s = o->createIndex(row, 0, sourceParent.value);
|
|
}
|
|
QModelIndex d;
|
|
if (destinationParent.some) {
|
|
int row = %2_row(o->m_d, destinationParent.value);
|
|
d = o->createIndex(row, 0, destinationParent.value);
|
|
}
|
|
o->beginMoveRows(s, first, last, d, destination);
|
|
},
|
|
[](%1* o) {
|
|
o->endMoveRows();
|
|
},
|
|
[](%1* o, option_quintptr id, int first, int last) {
|
|
if (id.some) {
|
|
int row = %2_row(o->m_d, id.value);
|
|
o->beginRemoveRows(o->createIndex(row, 0, id.value), first, last);
|
|
} else {
|
|
o->beginRemoveRows(QModelIndex(), first, last);
|
|
}
|
|
},
|
|
[](%1* o) {
|
|
o->endRemoveRows();
|
|
}
|
|
)").arg(o.name, lcname, QString::number(o.columnCount - 1));
|
|
}
|
|
}
|
|
|
|
void writeFunctionCDecl(QTextStream& cpp, const Function& f, const QString& lcname, const Object& o) {
|
|
const QString lc(snakeCase(f.name));
|
|
cpp << " ";
|
|
if (f.type.isComplex()) {
|
|
cpp << "void";
|
|
} else {
|
|
cpp << f.type.name;
|
|
}
|
|
const QString name = QString("%1_%2").arg(lcname, lc);
|
|
cpp << QString(" %1(%3%2::Private*").arg(name, o.name, f.mut ? "" : "const ");
|
|
// write all the input arguments, for QString and QByteArray, write
|
|
// pointers to their content and the length
|
|
for (auto a = f.args.begin(); a < f.args.end(); a++) {
|
|
if (a->type.name == "QString") {
|
|
cpp << ", const ushort*, int";
|
|
} else if (a->type.name == "QByteArray") {
|
|
cpp << ", const char*, int";
|
|
} else {
|
|
cpp << ", " << a->type.name;
|
|
}
|
|
}
|
|
// If the return type is QString or QByteArray, append a pointer to the
|
|
// variable that will be set to the argument list. Also add a setter
|
|
// function.
|
|
if (f.type.name == "QString") {
|
|
cpp << ", QString*, qstring_set";
|
|
} else if (f.type.name == "QByteArray") {
|
|
cpp << ", QByteArray*, qbytearray_set";
|
|
}
|
|
cpp << ");\n";
|
|
}
|
|
|
|
void writeObjectCDecl(QTextStream& cpp, const Object& o, const Configuration& conf) {
|
|
const QString lcname(snakeCase(o.name));
|
|
cpp << QString(" %1::Private* %2_new(").arg(o.name, lcname);
|
|
constructorArgsDecl(cpp, o, conf);
|
|
cpp << ");" << endl;
|
|
cpp << QString(" void %2_free(%1::Private*);").arg(o.name, lcname)
|
|
<< endl;
|
|
for (const Property& p: o.properties) {
|
|
const QString base = QString("%1_%2").arg(lcname, snakeCase(p.name));
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << QString(" %3::Private* %2_get(const %1::Private*);")
|
|
.arg(o.name, base, p.type.name) << endl;
|
|
} else if (p.type.isComplex()) {
|
|
cpp << QString(" void %2_get(const %1::Private*, %3);")
|
|
.arg(o.name, base, cGetType(p.type)) << endl;
|
|
} else if (p.optional) {
|
|
cpp << QString(" option_%3 %2_get(const %1::Private*);")
|
|
.arg(o.name, base, p.type.name) << endl;
|
|
} else {
|
|
cpp << QString(" %3 %2_get(const %1::Private*);")
|
|
.arg(o.name, base, p.type.name) << endl;
|
|
}
|
|
if (p.write) {
|
|
QString t = p.type.cSetType;
|
|
if (t == "qstring_t") {
|
|
t = "const ushort *str, int len";
|
|
} else if (t == "qbytearray_t") {
|
|
t = "const char* bytes, int len";
|
|
}
|
|
cpp << QString(" void %2_set(%1::Private*, %3);")
|
|
.arg(o.name, base, t) << endl;
|
|
if (p.optional) {
|
|
cpp << QString(" void %2_set_none(%1::Private*);")
|
|
.arg(o.name, base) << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const Function& f: o.functions) {
|
|
writeFunctionCDecl(cpp, f, lcname, o);
|
|
}
|
|
}
|
|
|
|
void initializeMembersEmpty(QTextStream& cpp, const Object& o, const Configuration& conf)
|
|
{
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
initializeMembersEmpty(cpp, conf.findObject(p.type.name), conf);
|
|
cpp << QString(" %1m_%2(new %3(false, this)),\n")
|
|
.arg(p.name, p.type.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void initializeMembersZero(QTextStream& cpp, const Object& o)
|
|
{
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << QString(" m_%1(new %2(false, this)),\n")
|
|
.arg(p.name, p.type.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void initializeMembers(QTextStream& cpp, const QString& prefix, const Object& o, const Configuration& conf)
|
|
{
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << QString(" %1m_%2->m_d = %3_%4_get(%1m_d);\n")
|
|
.arg(prefix, p.name, snakeCase(o.name), snakeCase(p.name));
|
|
initializeMembers(cpp, "m_" + p.name + "->",
|
|
conf.findObject(p.type.name), conf);
|
|
}
|
|
}
|
|
}
|
|
|
|
void connect(QTextStream& cpp, const QString& d, const Object& o, const Configuration& conf) {
|
|
for (auto p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
connect(cpp, d + "->m_" + p.name, conf.findObject(p.type.name), conf);
|
|
}
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
cpp << QString(R"( connect(%2, &%1::newDataReady, %2, [this](const QModelIndex& i) {
|
|
%2->fetchMore(i);
|
|
}, Qt::QueuedConnection);
|
|
)").arg(o.name, d);
|
|
}
|
|
}
|
|
|
|
void writeCppObject(QTextStream& cpp, const Object& o, const Configuration& conf) {
|
|
const QString lcname(snakeCase(o.name));
|
|
cpp << QString("%1::%1(bool /*owned*/, QObject *parent):\n %2(parent),")
|
|
.arg(o.name, baseType(o)) << endl;
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << QString(" m_%1(new %2(false, this)),\n")
|
|
.arg(p.name, p.type.name);
|
|
}
|
|
}
|
|
cpp << " m_d(nullptr),\n m_ownsPrivate(false)\n{\n";
|
|
if (o.type != ObjectType::Object) {
|
|
cpp << " initHeaderData();\n";
|
|
}
|
|
cpp << QString("}\n\n%1::%1(QObject *parent):\n %2(parent),")
|
|
.arg(o.name, baseType(o)) << endl;
|
|
initializeMembersZero(cpp, o);
|
|
cpp << QString(" m_d(%1_new(this").arg(lcname);
|
|
constructorArgs(cpp, "", o, conf);
|
|
cpp << ")),\n m_ownsPrivate(true)\n{\n";
|
|
initializeMembers(cpp, "", o, conf);
|
|
connect(cpp, "this", o, conf);
|
|
if (o.type != ObjectType::Object) {
|
|
cpp << " initHeaderData();\n";
|
|
}
|
|
cpp << QString(R"(}
|
|
|
|
%1::~%1() {
|
|
if (m_ownsPrivate) {
|
|
%2_free(m_d);
|
|
}
|
|
}
|
|
)").arg(o.name, lcname);
|
|
|
|
if (o.type != ObjectType::Object) {
|
|
cpp << QString("void %1::initHeaderData() {\n").arg(o.name);
|
|
|
|
for (int col = 0; col < o.columnCount; ++col) {
|
|
for (auto ip: o.itemProperties) {
|
|
auto roles = ip.roles.value(col);
|
|
if (roles.contains(Qt::DisplayRole)) {
|
|
cpp << QString(" m_headerData.insert(qMakePair(%1, Qt::DisplayRole), QVariant(\"%2\"));\n").arg(QString::number(col), ip.name);
|
|
}
|
|
}
|
|
}
|
|
cpp << "}\n";
|
|
}
|
|
|
|
for (const Property& p: o.properties) {
|
|
const QString base = QString("%1_%2").arg(lcname, snakeCase(p.name));
|
|
if (p.type.type == BindingType::Object) {
|
|
cpp << QString(R"(const %3* %1::%2() const
|
|
{
|
|
return m_%2;
|
|
}
|
|
%3* %1::%2()
|
|
{
|
|
return m_%2;
|
|
}
|
|
)").arg(o.name, p.name, p.type.name);
|
|
} else if (p.type.isComplex()) {
|
|
cpp << QString("%3 %1::%2() const\n{\n").arg(o.name, p.name, p.type.name);
|
|
cpp << " " << p.type.name << " v;\n";
|
|
cpp << " " << base << "_get(m_d, &v, set_" << p.type.name.toLower()
|
|
<< ");\n";
|
|
cpp << " return v;\n}\n";
|
|
} else if (p.optional) {
|
|
cpp << QString("QVariant %1::%2() const\n{\n").arg(o.name, p.name);
|
|
cpp << " QVariant v;\n";
|
|
cpp << QString(" auto r = %1_get(m_d);\n").arg(base);
|
|
cpp << " if (r.some) {\n";
|
|
cpp << " v.setValue(r.value);\n";
|
|
cpp << " }\n";
|
|
cpp << " return r;\n";
|
|
cpp << "}\n";
|
|
} else {
|
|
cpp << QString("%3 %1::%2() const\n{\n").arg(o.name, p.name, p.type.name);
|
|
cpp << QString(" return %1_get(m_d);\n}\n").arg(base);
|
|
}
|
|
if (p.write) {
|
|
auto t = p.type.cppSetType;
|
|
if (p.optional && !p.type.isComplex()) {
|
|
t = "const QVariant&";
|
|
}
|
|
cpp << "void " << o.name << "::set" << upperInitial(p.name) << "(" << t << " v) {" << endl;
|
|
if (p.optional) {
|
|
if (p.type.isComplex()) {
|
|
cpp << " if (v.isNull()) {" << endl;
|
|
} else {
|
|
cpp << QString(" if (v.isNull() || !v.canConvert<%1>()) {").arg(p.type.name) << endl;
|
|
}
|
|
cpp << QString(" %1_set_none(m_d);").arg(base) << endl;
|
|
cpp << QString(" } else {") << endl;
|
|
if (p.type.name == "QString") {
|
|
cpp << QString(" %1_set(m_d, reinterpret_cast<const ushort*>(v.data()), v.size());").arg(base) << endl;
|
|
} else if (p.type.name == "QByteArray") {
|
|
cpp << QString(" %1_set(m_d, v.data(), v.size());").arg(base) << endl;
|
|
} else if (p.optional) {
|
|
cpp << QString(" %1_set(m_d, v.value<%2>());").arg(base, p.type.name) << endl;
|
|
} else {
|
|
cpp << QString(" %1_set(m_d, v);").arg(base) << endl;
|
|
}
|
|
cpp << QString(" }") << endl;
|
|
} else if (p.type.name == "QString") {
|
|
cpp << QString(" %1_set(m_d, reinterpret_cast<const ushort*>(v.data()), v.size());").arg(base) << endl;
|
|
} else if (p.type.name == "QByteArray") {
|
|
cpp << QString(" %1_set(m_d, v.data(), v.size());").arg(base) << endl;
|
|
} else {
|
|
cpp << QString(" %1_set(m_d, v);").arg(base) << endl;
|
|
}
|
|
cpp << "}" << endl;
|
|
}
|
|
}
|
|
|
|
for (const Function& f: o.functions) {
|
|
const QString base = QString("%1_%2")
|
|
.arg(lcname, snakeCase(f.name));
|
|
cpp << QString("%1 %2::%3(").arg(f.type.name, o.name, f.name);
|
|
for (auto a = f.args.begin(); a < f.args.end(); a++) {
|
|
cpp << QString("%1 %2%3").arg(a->type.cppSetType, a->name, a + 1 < f.args.end() ? ", " : "");
|
|
}
|
|
cpp << QString(")%1\n{\n").arg(f.mut ? "" : " const");
|
|
QString argList;
|
|
for (auto a = f.args.begin(); a < f.args.end(); a++) {
|
|
if (a->type.name == "QString") {
|
|
argList.append(QString(", %1.utf16(), %1.size()").arg(a->name));
|
|
} else if (a->type.name == "QByteArray") {
|
|
argList.append(QString(", %1.data(), %1.size()").arg(a->name));
|
|
} else {
|
|
argList.append(QString(", %1").arg(a->name));
|
|
}
|
|
}
|
|
if (f.type.name == "QString") {
|
|
cpp << QString(" %1 s;").arg(f.type.name) << endl;
|
|
cpp << QString(" %1(m_d%2, &s, set_qstring);")
|
|
.arg(base, argList) << endl;
|
|
cpp << " return s;" << endl;
|
|
} else if (f.type.name == "QByteArray") {
|
|
cpp << QString(" %1 s;").arg(f.type.name) << endl;
|
|
cpp << QString(" %1(m_d%2, &s, set_qbytearray);")
|
|
.arg(base, argList) << endl;
|
|
cpp << " return s;" << endl;
|
|
} else {
|
|
cpp << QString(" return %1(m_d%2);")
|
|
.arg(base, argList) << endl;
|
|
}
|
|
cpp << "}" << endl;
|
|
}
|
|
}
|
|
|
|
void writeHeader(const Configuration& conf) {
|
|
DifferentFileWriter w(conf.hFile.absoluteFilePath());
|
|
QTextStream h(&w.buffer);
|
|
const QString guard(conf.hFile.fileName().replace('.', '_').toUpper());
|
|
h << QString(R"(/* generated by rust_qt_binding_generator */
|
|
#ifndef %1
|
|
#define %1
|
|
|
|
#include <QObject>
|
|
#include <QAbstractItemModel>
|
|
|
|
)").arg(guard);
|
|
|
|
for (auto object: conf.objects) {
|
|
h << "class " << object.name << ";\n";
|
|
}
|
|
for (auto object: conf.objects) {
|
|
writeHeaderObject(h, object, conf);
|
|
}
|
|
|
|
h << QString("#endif // %1\n").arg(guard);
|
|
}
|
|
|
|
void writeCpp(const Configuration& conf) {
|
|
DifferentFileWriter w(conf.cppFile.absoluteFilePath());
|
|
QTextStream cpp(&w.buffer);
|
|
cpp << QString(R"(/* generated by rust_qt_binding_generator */
|
|
#include "%1"
|
|
|
|
namespace {
|
|
)").arg(conf.hFile.fileName());
|
|
for (auto option: conf.optionalTypes()) {
|
|
if (option != "QString" && option != "QByteArray") {
|
|
cpp << QString(R"(
|
|
struct option_%1 {
|
|
public:
|
|
%1 value;
|
|
bool some;
|
|
operator QVariant() const {
|
|
if (some) {
|
|
return QVariant::fromValue(value);
|
|
}
|
|
return QVariant();
|
|
}
|
|
};
|
|
static_assert(std::is_pod<option_%1>::value, "option_%1 must be a POD type.");
|
|
)").arg(option);
|
|
}
|
|
}
|
|
if (conf.types().contains("QString")) {
|
|
cpp << R"(
|
|
typedef void (*qstring_set)(QString* val, const char* utf8, int nbytes);
|
|
void set_qstring(QString* val, const char* utf8, int nbytes) {
|
|
*val = QString::fromUtf8(utf8, nbytes);
|
|
}
|
|
)";
|
|
}
|
|
if (conf.types().contains("QByteArray")) {
|
|
cpp << R"(
|
|
typedef void (*qbytearray_set)(QByteArray* val, const char* bytes, int nbytes);
|
|
void set_qbytearray(QByteArray* v, const char* bytes, int nbytes) {
|
|
if (v->isNull() && nbytes == 0) {
|
|
*v = QByteArray(bytes, nbytes);
|
|
} else {
|
|
v->truncate(0);
|
|
v->append(bytes, nbytes);
|
|
}
|
|
}
|
|
)";
|
|
}
|
|
if (conf.hasListOrTree()) {
|
|
cpp << R"(
|
|
struct qmodelindex_t {
|
|
int row;
|
|
quintptr id;
|
|
};
|
|
inline QVariant cleanNullQVariant(const QVariant& v) {
|
|
return (v.isNull()) ?QVariant() :v;
|
|
}
|
|
)";
|
|
}
|
|
|
|
for (auto o: conf.objects) {
|
|
for (auto p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
continue;
|
|
}
|
|
cpp << " inline void " << changedF(o, p) << "(" << o.name << "* o)\n";
|
|
cpp << " {\n Q_EMIT o->" << p.name << "Changed();\n }\n";
|
|
}
|
|
}
|
|
cpp << "}\n";
|
|
|
|
for (auto object: conf.objects) {
|
|
if (object.type != ObjectType::Object) {
|
|
writeCppModel(cpp, object);
|
|
}
|
|
|
|
cpp << "extern \"C\" {\n";
|
|
writeObjectCDecl(cpp, object, conf);
|
|
cpp << "};\n" << endl;
|
|
}
|
|
|
|
for (auto object: conf.objects) {
|
|
writeCppObject(cpp, object, conf);
|
|
}
|
|
}
|