status-im/dotherside
2
0
Fork 0
mirror of https://github.com/status-im/dotherside.git synced 2025-02-12 04:26:43 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'qaim'

Browse Source
This commit is contained in:
Filippo Cucchetto 2017-04-09 12:06:12 +02:00
commit f5eba67bd3
24 changed files with 1206 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
CHANGELOG.md
View File

@ -1,3 +1,10 @@
# Version 0.6.0
* Fixed #48: Added support QAbstractItemModel and QAbstractTableModels
* Added missing canFetchMore, fetchMore, hasChildren callbacks
* Fixed #46: Added support for index, createIndex
* Fixed #45: Added support for setting the qml signal names (old behaviour was arg0, arg1..)
* Added support
# Version 0.5.2
* Added support qmlRegisterType
* Added support qmlRegisterSingletonType

7
lib/CMakeLists.txt
View File

@ -19,13 +19,14 @@ set(HEADERS_LIST
include/DOtherSide/DOtherSide.h
include/DOtherSide/DosQDeclarative.h
include/DOtherSide/DosQObjectWrapper.h
include/DOtherSide/DosQAbstractListModelWrapper.h
include/DOtherSide/DosQAbstractItemModelWrapper.h
include/DOtherSide/DosQObject.h
include/DOtherSide/DosQObjectImpl.h
include/DOtherSide/DosIQObjectImpl.h
include/DOtherSide/OnSlotExecutedHandler.h
include/DOtherSide/DosQMetaObject.h
include/DOtherSide/DosQAbstractListModel.h
include/DOtherSide/DosIQAbstractItemModelImpl.h
include/DOtherSide/DosQAbstractItemModel.h
include/DOtherSide/Utils.h
)
@ -37,7 +38,7 @@ set(SRC_LIST
src/DosQObject.cpp
src/DOtherSideTypesCpp.cpp
src/DosQObjectImpl.cpp
src/DosQAbstractListModel.cpp
src/DosQAbstractItemModel.cpp
)
include_directories(include include/Qt)

188
lib/include/DOtherSide/DOtherSide.h
View File

@ -372,7 +372,7 @@ DOS_API void DOS_CALL dos_qmetaobject_delete(DosQMetaObject *vptr);
/// @}
/// \defgroup QAbstractListModel QAbstractListModel
/// \defgroup QAbstractListModel QAbstractItemModel
/// \brief Functions related to the QAbstractListModel class
/// @{
@ -381,72 +381,188 @@ DOS_API void DOS_CALL dos_qmetaobject_delete(DosQMetaObject *vptr);
/// \note The returned QMetaObject should be freed using dos_qmetaobject_delete().
DOS_API DosQMetaObject *DOS_CALL dos_qabstractlistmodel_qmetaobject();
/// \brief Create a new QAbstractListModel
/// \param callbackObject The pointer of QAbstractListModel in the binded language
/// \param metaObject The QMetaObject for this QAbstractListModel
/// \param dObjectCallback The callback for handling the properties read/write and slots execution
/// \param rowCountCallback The callback for handling the QAbstractListModel::rowCount() execution
/// \param columnCountCallback The callback for handling the QAbstractListModel::columnCount() execution
/// \param dataCallback The callback for handling the QAbstractListModel::data() execution
/// \param setDataCallback The callback for handling the QAbstractListModel::setData() execution
/// \param roleNamesCallback The callback for handling the QAbstractListModel::roleNames() execution
/// \param flagsCallback The callback for handling the QAbstractListModel::flags() execution
/// \param headerDataCallback The callback for handling the QAbstractListModel::headerData() execution
/// \param callbacks The QAbstractItemModel callbacks
DOS_API DosQAbstractListModel *DOS_CALL dos_qabstractlistmodel_create(void *callbackObject,
DosQMetaObject *metaObject,
DObjectCallback dObjectCallback,
RowCountCallback rowCountCallback,
ColumnCountCallback columnCountCallback,
DataCallback dataCallback,
SetDataCallback setDataCallback,
RoleNamesCallback roleNamesCallback,
FlagsCallback flagsCallback,
HeaderDataCallback headerDataCallback);
DosQAbstractItemModelCallbacks* callbacks);
/// \brief Calls the QAbstractListModel::beginInsertRows() function
/// \param vptr The QAbstractListModel
/// \brief Calls the default QAbstractListModel::index() function
DOS_API DosQModelIndex* DOS_CALL dos_qabstractlistmodel_index(DosQAbstractListModel *vptr,
int row, int column, DosQModelIndex* parent);
/// \brief Calls the default QAbstractListModel::parent() function
DOS_API DosQModelIndex* DOS_CALL dos_qabstractlistmodel_parent(DosQAbstractListModel *vptr,
DosQModelIndex* child);
/// \brief Calls the default QAbstractListModel::columnCount() function
DOS_API int DOS_CALL dos_qabstractlistmodel_columnCount(DosQAbstractListModel *vptr,
DosQModelIndex* parent);
/// @}
/// \defgroup QAbstractTableModel QAbstractTableModel
/// \brief Functions related to the QAbstractTableModel class
/// @{
/// \brief Return QMetaObject associated to the QAbstractTableModel class
/// \return The QMetaObject of the QAbstractTableModel class
/// \note The returned QMetaObject should be freed using dos_qmetaobject_delete().
DOS_API DosQMetaObject *DOS_CALL dos_qabstracttablemodel_qmetaobject();
/// \brief Create a new QAbstractTableModel
/// \param callbackObject The pointer of QAbstractTableModel in the binded language
/// \param metaObject The QMetaObject for this QAbstractTableModel
/// \param dObjectCallback The callback for handling the properties read/write and slots execution
/// \param callbacks The QAbstractItemModel callbacks
DOS_API DosQAbstractTableModel *DOS_CALL dos_qabstracttablemodel_create(void *callbackObject,
DosQMetaObject *metaObject,
DObjectCallback dObjectCallback,
DosQAbstractItemModelCallbacks* callbacks);
/// \brief Calls the default QAbstractTableModel::index() function
DOS_API DosQModelIndex* DOS_CALL dos_qabstracttablemodel_index(DosQAbstractTableModel *vptr,
int row, int column, DosQModelIndex* parent);
/// \brief Calls the default QAbstractTableModel::parent() function
DOS_API DosQModelIndex* DOS_CALL dos_qabstracttablemodel_parent(DosQAbstractTableModel *vptr,
DosQModelIndex* child);
/// @}
/// \defgroup QAbstractItemModel QAbstractItemModel
/// \brief Functions related to the QAbstractItemModel class
/// @{
/// \brief Return QMetaObject associated to the QAbstractItemModel class
/// \return The QMetaObject of the QAbstractItemModel class
/// \note The returned QMetaObject should be freed using dos_qmetaobject_delete().
DOS_API DosQMetaObject *DOS_CALL dos_qabstractitemmodel_qmetaobject();
/// \brief Create a new QAbstractItemModel
/// \param callbackObject The pointer of QAbstractItemModel in the binded language
/// \param metaObject The QMetaObject for this QAbstractItemModel
/// \param dObjectCallback The callback for handling the properties read/write and slots execution
/// \param callbacks The QAbstractItemModel callbacks
/// \note The callbacks struct is copied so you can freely delete after calling this function
DOS_API DosQAbstractItemModel *DOS_CALL dos_qabstractitemmodel_create(void *callbackObject,
DosQMetaObject *metaObject,
DObjectCallback dObjectCallback,
DosQAbstractItemModelCallbacks* callbacks);
/// \brief Calls the QAbstractItemModel::setData function
bool dos_qabstractitemmodel_setData(DosQAbstractItemModel *vptr, DosQModelIndex* index, DosQVariant* data, int role);
/// \brief Calls the QAbstractItemModel::roleNames function
DosQHashIntQByteArray* dos_qabstractitemmodel_roleNames(DosQAbstractItemModel *vptr);
/// \brief Calls the QAbstractItemModel::flags function
int dos_qabstractitemmodel_flags(DosQAbstractItemModel *vptr, DosQModelIndex* index);
/// \brief Calls the QAbstractItemModel::headerData function
DosQVariant* dos_qabstractitemmodel_headerData(DosQAbstractItemModel *vptr, int section, int orientation, int role);
/// \brief Calls the QAbstractItemModel::hasChildren function
bool dos_qabstractitemmodel_hasChildren(DosQAbstractItemModel *vptr, DosQModelIndex* parentIndex);
/// \brief Calls the QAbstractItemModel::canFetchMore function
bool dos_qabstractitemmodel_canFetchMore(DosQAbstractItemModel *vptr, DosQModelIndex* parentIndex);
/// \brief Calls the QAbstractItemModel::fetchMore function
void dos_qabstractitemmodel_fetchMore(DosQAbstractItemModel *vptr, DosQModelIndex* parentIndex);
/// \brief Calls the QAbstractItemModel::beginInsertRows() function
/// \param vptr The QAbstractItemModel
/// \param parent The parent QModelIndex
/// \param first The first row in the range
/// \param last The last row in the range
/// \note The \p parent QModelIndex is owned by the caller thus it will not be deleted
DOS_API void DOS_CALL dos_qabstractlistmodel_beginInsertRows(DosQAbstractListModel *vptr, DosQModelIndex *parent, int first, int last);
DOS_API void DOS_CALL dos_qabstractitemmodel_beginInsertRows(DosQAbstractItemModel *vptr, DosQModelIndex *parent, int first, int last);
/// \brief Calls the QAbstractListModel::endInsertRows() function
/// \param vptr The QAbstractListModel
DOS_API void DOS_CALL dos_qabstractlistmodel_endInsertRows(DosQAbstractListModel *vptr);
/// \brief Calls the QAbstractItemModel::endInsertRows() function
/// \param vptr The QAbstractItemModel
DOS_API void DOS_CALL dos_qabstractitemmodel_endInsertRows(DosQAbstractItemModel *vptr);
/// \brief Calls the QAbstractListModel::beginRemovetRows() function
/// \param vptr The QAbstractListModel
/// \brief Calls the QAbstractItemModel::beginRemovetRows() function
/// \param vptr The QAbstractItemModel
/// \param parent The parent QModelIndex
/// \param first The first column in the range
/// \param last The last column in the range
/// \note The \p parent QModelIndex is owned by the caller thus it will not be deleted
DOS_API void DOS_CALL dos_qabstractlistmodel_beginRemoveRows(DosQAbstractListModel *vptr, DosQModelIndex *parent, int first, int last);
DOS_API void DOS_CALL dos_qabstractitemmodel_beginRemoveRows(DosQAbstractItemModel *vptr, DosQModelIndex *parent, int first, int last);
/// \brief Calls the QAbstractListModel::endRemoveRows() function
/// \param vptr The QAbstractListModel
DOS_API void DOS_CALL dos_qabstractlistmodel_endRemoveRows(DosQAbstractListModel *vptr);
/// \brief Calls the QAbstractItemModel::endRemoveRows() function
/// \param vptr The QAbstractItemModel
DOS_API void DOS_CALL dos_qabstractitemmodel_endRemoveRows(DosQAbstractItemModel *vptr);
/// \brief Calls the QAbstractListModel::beginResetModel() function
/// \param vptr The QAbstractListModel
DOS_API void DOS_CALL dos_qabstractlistmodel_beginResetModel(DosQAbstractListModel *vptr);
/// \brief Calls the QAbstractItemModel::beginInsertColumns() function
/// \param vptr The QAbstractItemModel
/// \param parent The parent QModelIndex
/// \param first The first column in the range
/// \param last The last column in the range
/// \note The \p parent QModelIndex is owned by the caller thus it will not be deleted
DOS_API void DOS_CALL dos_qabstractitemmodel_beginInsertColumns(DosQAbstractItemModel *vptr, DosQModelIndex *parent, int first, int last);
/// \brief Calls the QAbstractListModel::endResetModel() function
/// \param vptr The QAbstractListModel
DOS_API void DOS_CALL dos_qabstractlistmodel_endResetModel(DosQAbstractListModel *vptr);
/// \brief Calls the QAbstractItemModel::endInsertColumns() function
/// \param vptr The QAbstractItemModel
DOS_API void DOS_CALL dos_qabstractitemmodel_endInsertColumns(DosQAbstractItemModel *vptr);
/// \brief Calls the QAbstractItemModel::beginRemovetColumns() function
/// \param vptr The QAbstractItemModel
/// \param parent The parent QModelIndex
/// \param first The first column in the range
/// \param last The last column in the range
/// \note The \p parent QModelIndex is owned by the caller thus it will not be deleted
DOS_API void DOS_CALL dos_qabstractitemmodel_beginRemoveColumns(DosQAbstractItemModel *vptr, DosQModelIndex *parent, int first, int last);
/// \brief Calls the QAbstractItemModel::endRemoveColumns() function
/// \param vptr The QAbstractItemModel
DOS_API void DOS_CALL dos_qabstractitemmodel_endRemoveColumns(DosQAbstractItemModel *vptr);
/// \brief Calls the QAbstractItemModel::beginResetModel() function
/// \param vptr The QAbstractItemModel
DOS_API void DOS_CALL dos_qabstractitemmodel_beginResetModel(DosQAbstractItemModel *vptr);
/// \brief Calls the QAbstractItemModel::endResetModel() function
/// \param vptr The QAbstractItemModel
DOS_API void DOS_CALL dos_qabstractitemmodel_endResetModel(DosQAbstractItemModel *vptr);
/// \brief Emit the dataChanged signal
/// \param vptr The DosQAbstractListModel pointer
/// \param vptr The DosQAbstractItemModel pointer
/// \param topLeft The topLeft DosQModelIndex
/// \param bottomRight The bottomright DosQModelIndex
/// \param rolesPtr The roles array
/// \param rolesLength The roles array length
/// \note The \p topLeft, \p bottomRight and \p rolesPtr arguments are owned by the caller thus they will not be deleted
DOS_API void DOS_CALL dos_qabstractlistmodel_dataChanged(DosQAbstractListModel *vptr,
DOS_API void DOS_CALL dos_qabstractitemmodel_dataChanged(DosQAbstractItemModel *vptr,
const DosQModelIndex *topLeft,
const DosQModelIndex *bottomRight,
int *rolesPtr, int rolesLength);
/// \brief Calls the QAbstractItemModel::createIndex() function
DOS_API DosQModelIndex* DOS_CALL dos_qabstractitemmodel_createIndex(DosQAbstractItemModel *vptr,
int row, int column, void *data = 0);
/// \brief Calls the default QAbstractItemModel::setData() function
DOS_API bool DOS_CALL dos_qabstractitemmodel_setData(DosQAbstractItemModel *vptr,
DosQModelIndex* index, DosQVariant* value, int role);
/// \brief Calls the default QAbstractItemModel::roleNames() function
DOS_API DosQHashIntQByteArray* DOS_CALL dos_qabstractitemmodel_roleNames(DosQAbstractItemModel *vptr);
/// \brief Calls the default QAbstractItemModel::flags() function
DOS_API int DOS_CALL dos_qabstractitemmodel_flags(DosQAbstractItemModel *vptr,
DosQModelIndex* index);
/// \brief Calls the default QAbstractItemModel::headerData() function
DOS_API DosQVariant* DOS_CALL dos_qabstractitemmodel_headerData(DosQAbstractItemModel *vptr,
int section, int orientation, int role);
/// @}

88
lib/include/DOtherSide/DOtherSideTypes.h
View File

@ -31,9 +31,15 @@ typedef void DosQVariant;
/// A pointer to a QModelIndex
typedef void DosQModelIndex;
/// A pointer to a QAbstractItemModel
typedef void DosQAbstractItemModel;
/// A pointer to a QAbstractListModel
typedef void DosQAbstractListModel;
/// A pointer to a QAbstractTableModel
typedef void DosQAbstractTableModel;
/// A pointer to a QQmlApplicationEngine
typedef void DosQQmlApplicationEngine;
@ -68,42 +74,57 @@ typedef void DosQObject;
/// \note The \p argv array is owned by the library thus it \b shouldn't be deleted
typedef void (DOS_CALL *DObjectCallback)(void *self, DosQVariant *slotName, int argc, DosQVariant **argv);
/// Called when the QAbstractListModel::rowCount method must be executed
/// \param self The pointer of the QAbstractListModel in the binded language
/// Called when the QAbstractItemModel::rowCount method must be executed
/// \param self The pointer of the QAbstractItemModel in the binded language
/// \param index The parent DosQModelIndex
/// \param[out] result The rowCount result. This must be deferenced and filled from the binded language
/// \note The \p parent QModelIndex is owned by the DOtherSide library thus it \b shouldn't be deleted
/// \note The \p result arg is an out parameter so it should be deleted
typedef void (DOS_CALL *RowCountCallback)(void *self, const DosQModelIndex *parent, int *result);
/// Called when the QAbstractListModel::columnCount method must be executed
/// \param self The pointer to the QAbstractListModel in the binded language
/// Called when the QAbstractItemModel::columnCount method must be executed
/// \param self The pointer to the QAbstractItemModel in the binded language
/// \param index The parent DosQModelIndex
/// \param[out] result The rowCount result. This must be deferenced and filled from the binded language
/// \note The \p parent QModelIndex is owned by the DOtherSide library thus it \b shouldn't be deleted
/// \note The \p result arg is an out parameter so it should be deleted
typedef void (DOS_CALL *ColumnCountCallback)(void *self, const DosQModelIndex *parent, int *result);
/// Called when the QAbstractListModel::data method must be executed
/// \param self The pointer to the QAbstractListModel in the binded language
/// Called when the QAbstractItemModel::data method must be executed
/// \param self The pointer to the QAbstractItemModel in the binded language
/// \param index The DosQModelIndex to which we request the data
/// \param[out] result The DosQVariant result. This must be deferenced and filled from the binded language.
/// \note The \p index QModelIndex is owned by the DOtherSide library thus it \b shouldn't be deleted
/// \note The \p result arg is an out parameter so it should be deleted
typedef void (DOS_CALL *DataCallback)(void *self, const DosQModelIndex *index, int role, DosQVariant *result);
/// Called when the QAbstractListModel::setData method must be executed
/// Called when the QAbstractItemModel::setData method must be executed
typedef void (DOS_CALL *SetDataCallback)(void *self, const DosQModelIndex *index, const DosQVariant *value, int role, bool *result);
/// Called when the QAbstractListModel::roleNames method must be executed
/// Called when the QAbstractItemModel::roleNames method must be executed
typedef void (DOS_CALL *RoleNamesCallback)(void *self, DosQHashIntQByteArray *result);
/// Called when the QAbstractListModel::flags method must be called
/// Called when the QAbstractItemModel::flags method must be called
typedef void (DOS_CALL *FlagsCallback)(void *self, const DosQModelIndex *index, int *result);
/// Called when the QAbstractListModel::headerData method must be called
/// Called when the QAbstractItemModel::headerData method must be called
typedef void (DOS_CALL *HeaderDataCallback)(void *self, int section, int orientation, int role, DosQVariant *result);
/// Called when the QAbstractItemModel::index method must be called
typedef void (DOS_CALL *IndexCallback)(void *self, int row, int column, const DosQModelIndex *parent, DosQModelIndex *result);
/// Called when the QAbstractItemModel::parent method must be called
typedef void (DOS_CALL *ParentCallback)(void *self, const DosQModelIndex *child, DosQModelIndex *result);
/// Called when the QAbstractItemModel::hasChildren method must be called
typedef void (DOS_CALL *HasChildrenCallback)(void *self, const DosQModelIndex *parent, bool *result);
/// Called when the QAbstractItemModel::canFetchMore method must be called
typedef void (DOS_CALL *CanFetchMoreCallback)(void *self, const DosQModelIndex *parent, bool *result);
/// Called when the QAbstractItemModel::fetchMore method must be called
typedef void (DOS_CALL *FetchMoreCallback)(void *self, const DosQModelIndex *parent);
/// Callback called from QML for creating a registered type
/**
* When a type is created through the QML engine a new QObject \p "Wrapper" is created. This becomes a proxy
@ -199,14 +220,26 @@ struct QmlRegisterType {
typedef struct QmlRegisterType QmlRegisterType;
#endif
/// Represents a parameter definition
struct ParameterDefinition {
/// The parameter name
const char* name;
/// The parameter metatype
int metaType;
};
#ifndef __cplusplus
typedef struct ParameterDefinition ParameterDefinition;
#endif
/// Represents a single signal definition
struct SignalDefinition {
/// The signal name
const char *name;
/// The signal parameters count
/// The parameters count
int parametersCount;
/// The signal parameters metatypes
int *parametersMetaTypes;
/// The parameters
ParameterDefinition *parameters;
};
#ifndef __cplusplus
@ -217,7 +250,7 @@ typedef struct SignalDefinition SignalDefinition;
struct SignalDefinitions {
/// The total number of signals
int count;
/// The signal definitions array
/// The signals
SignalDefinition *definitions;
};
@ -231,10 +264,10 @@ struct SlotDefinition {
const char *name;
/// The slot return type
int returnMetaType;
/// The slot parameters count
/// The parameters count
int parametersCount;
/// The slot parameters metatypes
int *parametersMetaTypes;
/// The parameters
ParameterDefinition *parameters;
};
#ifndef __cplusplus
@ -285,6 +318,27 @@ struct PropertyDefinitions {
typedef struct PropertyDefinitions PropertyDefinitions;
#endif
/// Incapsulate all the QAbstractItemModel callbacks
struct DosQAbstractItemModelCallbacks
{
RowCountCallback rowCount;
ColumnCountCallback columnCount;
DataCallback data;
SetDataCallback setData;
RoleNamesCallback roleNames;
FlagsCallback flags;
HeaderDataCallback headerData;
IndexCallback index;
ParentCallback parent;
HasChildrenCallback hasChildren;
CanFetchMoreCallback canFetchMore;
FetchMoreCallback fetchMore;
};
#ifndef __cplusplus
typedef struct DosQAbstractItemModelCallbacks DosQAbstractItemModelCallbacks;
#endif
#ifdef __cplusplus
}
#endif

33
lib/include/DOtherSide/DOtherSideTypesCpp.h
View File

@ -12,46 +12,59 @@
namespace DOS {
struct ParameterDefinition {
ParameterDefinition(const ::ParameterDefinition &definition)
: name(QString::fromUtf8(definition.name))
, metaType(static_cast<QMetaType::Type>(definition.metaType))
{}
QString name;
QMetaType::Type metaType;
};
struct SignalDefinition {
SignalDefinition(QString n,
std::vector<QMetaType::Type> v)
std::vector<ParameterDefinition> v)
: name(std::move(n))
, returnType(QMetaType::Void)
, parameterTypes(std::move(v))
, parameters(std::move(v))
{}
SignalDefinition(::SignalDefinition cType)
: name(QString::fromUtf8(cType.name))
, returnType(QMetaType::Void)
{
for (int type : wrap_array(cType.parametersMetaTypes, cType.parametersCount))
parameterTypes.emplace_back(QMetaType::Type(type));
parameters.reserve(cType.parametersCount);
for (int i = 0; i < cType.parametersCount; ++i)
parameters.emplace_back(cType.parameters[i]);
}
QString name;
QMetaType::Type returnType;
std::vector<QMetaType::Type> parameterTypes;
std::vector<ParameterDefinition> parameters;
};
struct SlotDefinition {
SlotDefinition(QString n,
QMetaType::Type t,
std::vector<QMetaType::Type> v)
std::vector<ParameterDefinition> v)
: name(std::move(n))
, returnType(std::move(t))
, parameterTypes(std::move(v))
, parameters(std::move(v))
{}
SlotDefinition(::SlotDefinition cType)
: name(QString::fromUtf8(cType.name))
, returnType(QMetaType::Type(cType.returnMetaType))
{
for (int type : wrap_array(cType.parametersMetaTypes, cType.parametersCount))
parameterTypes.emplace_back(QMetaType::Type(type));
parameters.reserve(cType.parametersCount);
for (int i = 0; i < cType.parametersCount; ++i)
parameters.emplace_back(cType.parameters[i]);
}
QString name;
QMetaType::Type returnType;
std::vector<QMetaType::Type> parameterTypes;
std::vector<ParameterDefinition> parameters;
};
struct PropertyDefinition {

77
lib/include/DOtherSide/DosIQAbstractItemModelImpl.h Normal file
View File

@ -0,0 +1,77 @@
#pragma once
// Qt
#include <QtCore/QModelIndex>
#include <QtCore/QVariant>
#include <QtCore/QHash>
#include <QtCore/QByteArray>
#include <QtCore/QVector>
// DOtherSide
#include "DOtherSide/DosIQObjectImpl.h"
namespace DOS {
class DosIQAbstractItemModelImpl : public DosIQObjectImpl
{
public:
/// Destructor
virtual ~DosIQAbstractItemModelImpl() = default;
/// @see QAbstractItemModel::setData
virtual bool defaultSetData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) = 0;
/// @see QAbstractItemModel::flags
virtual Qt::ItemFlags defaultFlags(const QModelIndex &index) const = 0;
/// @see QAbstractItemModel::headerData
virtual QVariant defaultHeaderData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const = 0;
/// @see QAbstractItemModel::roleNames
virtual QHash<int, QByteArray> defaultRoleNames() const = 0;
/// @see QAbstractItemModel::beginInsertRows
virtual void publicBeginInsertRows(const QModelIndex &index, int first, int last) = 0;
/// @see QAbstractItemModel::endInsertRows
virtual void publicEndInsertRows() = 0;
/// @see QAbstractItemModel::beginRemoveRows
virtual void publicBeginRemoveRows(const QModelIndex &index, int first, int last) = 0;
/// @see QAbstractItemModel::endRemoveRows
virtual void publicEndRemoveRows() = 0;
/// @see QAbstractItemModel::beginInsertColumns
virtual void publicBeginInsertColumns(const QModelIndex &index, int first, int last) = 0;
/// @see QAbstractItemModel::endInsertColumns
virtual void publicEndInsertColumns() = 0;
/// @see QAbstractItemModel::beginRemoveColumns
virtual void publicBeginRemoveColumns(const QModelIndex &index, int first, int last) = 0;
/// @see QAbstractItemModel::endRemoveColumns
virtual void publicEndRemoveColumns() = 0;
/// @see QAbstractItemModel::beginResetModel
virtual void publicBeginResetModel() = 0;
/// @see QAbstractItemModel::endResetModel
virtual void publicEndResetModel() = 0;
/// @see QAbstractItemModel::dataChanged
virtual void publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles = QVector<int>()) = 0;
/// @see QAbstractItemModel::createIndex
virtual QModelIndex publicCreateIndex(int row, int column, void* data = 0) const = 0;
/// @see QAbstractItemModel::hasChildren
virtual bool defaultHasChildren(const QModelIndex &parent) const = 0;
/// @see QAbstractItemModel::canFetchMore
virtual bool defaultCanFetchMore(const QModelIndex &parent) const = 0;
/// @see QAbstractItemModel::fetchMore
virtual void defaultFetchMore(const QModelIndex &parent) = 0;
};
} // namespace dos

63
lib/include/DOtherSide/DosIQAbstractListModelImpl.h
View File

@ -1,63 +0,0 @@
#pragma once
// Qt
#include <QtCore/QModelIndex>
#include <QtCore/QVariant>
#include <QtCore/QHash>
#include <QtCore/QByteArray>
#include <QtCore/QVector>
// DOtherSide
#include "DOtherSide/DosIQObjectImpl.h"
namespace DOS {
class DosIQAbstractListModelImpl : public DosIQObjectImpl
{
public:
/// Destructor
virtual ~DosIQAbstractListModelImpl() = default;
/// @see QAbstractListModel::rowCount
virtual int rowCount(const QModelIndex &parent = QModelIndex()) const = 0;
/// @see QAbstractListModel::columnCount
virtual int columnCount(const QModelIndex &parent = QModelIndex()) const = 0;
/// @see QAbstractListModel::data
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const = 0;
/// @see QAbstractListModel::setData
virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) = 0;
/// @see QAbstractListModel::flags
virtual Qt::ItemFlags flags(const QModelIndex &index) const = 0;
/// @see QAbstractListModel::headerData
virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const = 0;
/// @see QAbstractListModel::roleNames
virtual QHash<int, QByteArray> roleNames() const = 0;
/// @see QAbstractListModel::beginInsertRows
virtual void publicBeginInsertRows(const QModelIndex &index, int first, int last) = 0;
/// @see QAbstractListModel::endInsertRows
virtual void publicEndInsertRows() = 0;
/// @see QAbstractListModel::beginRemoveRows
virtual void publicBeginRemoveRows(const QModelIndex &index, int first, int last) = 0;
/// @see QAbstractListModel::endRemoveRows
virtual void publicEndRemoveRows() = 0;
/// @see QAbstractListModel::beginResetModel
virtual void publicBeginResetModel() = 0;
/// @see QAbstractListModel::endResetModel
virtual void publicEndResetModel() = 0;
/// @see QAbstractListModel::dataChanged
virtual void publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles = QVector<int>()) = 0;
};
} // namespace dos

169
lib/include/DOtherSide/DosQAbstractItemModel.h Normal file
View File

@ -0,0 +1,169 @@
#pragma once
// Qt
#include <QAbstractItemModel>
#include <QAbstractListModel>
#include <QAbstractTableModel>
// DOtherSide
#include "DOtherSide/DOtherSideTypes.h"
#include "DOtherSide/DosIQAbstractItemModelImpl.h"
#include "DOtherSide/OnSlotExecutedHandler.h"
namespace DOS {
template<class T>
class DosQAbstractGenericModel : public T, public DosIQAbstractItemModelImpl
{
public:
/// Constructor
DosQAbstractGenericModel(void *modelObject,
DosIQMetaObjectPtr metaObject,
OnSlotExecuted onSlotExecuted,
DosQAbstractItemModelCallbacks callbacks);
/// @see IDynamicQObject::emitSignal
bool emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues) override;
/// @see QAbstractItemModel::metaObject()
const QMetaObject *metaObject() const override;
/// @see QAbstractItemModel::qt_metacall
int qt_metacall(QMetaObject::Call, int, void **) override;
/// Return the model's row count
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
/// Return the model's column count
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
/// Return the QVariant at the given index
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
/// Sets the QVariant value at the given index and role
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
/// Return the item flags for the given index
Qt::ItemFlags flags(const QModelIndex &index) const override;
/// Return the data for the given role and section in the header with the specified orientation
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
/// Return the index associated at the given row and column
QModelIndex index(int row, int column, const QModelIndex &parent) const override;
/// Return the parent for the given child index
QModelIndex parent(const QModelIndex &child) const override;
/// Return the dModelPointer
void *modelObject();
/// Return the roleNames
QHash<int, QByteArray> roleNames() const override;
/// Expose beginInsertRows
void publicBeginInsertRows(const QModelIndex &index, int first, int last) override;
/// Expose endInsertRows
void publicEndInsertRows() override;
/// Expose beginRemoveRows
void publicBeginRemoveRows(const QModelIndex &index, int first, int last) override;
/// Expose endInsertRows
void publicEndRemoveRows() override;
/// Expose beginInsertColumns
void publicBeginInsertColumns(const QModelIndex &index, int first, int last) override;
/// Expose endInsertColumns
void publicEndInsertColumns() override;
/// Expose beginRemoveColumns
void publicBeginRemoveColumns(const QModelIndex &index, int first, int last) override;
/// Expose endInsertColumns
void publicEndRemoveColumns() override;
/// Expose beginResetModel
void publicBeginResetModel() override;
/// Expose endResetModel
void publicEndResetModel() override;
/// Expose dataChanged
void publicDataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight,
const QVector<int> &roles = QVector<int>()) override;
/// Expose createIndex
QModelIndex publicCreateIndex(int row, int column, void *data = nullptr) const override;
/// Expose the not overriden flags
Qt::ItemFlags defaultFlags(const QModelIndex &index) const override;
/// Expose the not overriden header data
QVariant defaultHeaderData(int section, Qt::Orientation orientation, int role) const override;
/// Expose the not overriden roleNames
QHash<int, QByteArray> defaultRoleNames() const override;
/// Expose the not overriden setData
bool defaultSetData(const QModelIndex &index, const QVariant &value, int role) override;
/// Expose the hasChildren
bool hasChildren(const QModelIndex &parent = QModelIndex()) const override;
/// Expose the canFetchMore
bool canFetchMore(const QModelIndex &parent) const override;
/// Expose the not override canFetchMore
bool defaultCanFetchMore(const QModelIndex &parent) const override;
/// Expose the fetchMore
void fetchMore(const QModelIndex& parent) override;
/// Expose the not overriden fetchMore
void defaultFetchMore(const QModelIndex &parent) override;
private:
std::unique_ptr<DosIQObjectImpl> m_impl;
void *m_modelObject;
DosQAbstractItemModelCallbacks m_callbacks;
};
class DosQAbstractItemModel : public DosQAbstractGenericModel<QAbstractItemModel>
{
using SuperClass = DosQAbstractGenericModel<QAbstractItemModel>;
public:
using SuperClass::SuperClass;
bool defaultHasChildren(const QModelIndex &parent) const override;
};
class DosQAbstractTableModel : public DosQAbstractGenericModel<QAbstractTableModel>
{
using SuperClass = DosQAbstractGenericModel<QAbstractTableModel>;
public:
using SuperClass::SuperClass;
QModelIndex defaultParent(const QModelIndex& child) const;
QModelIndex defaultIndex(int row, int column, const QModelIndex& parent = QModelIndex()) const;
bool defaultHasChildren(const QModelIndex &parent) const override;
};
class DosQAbstractListModel : public DosQAbstractGenericModel<QAbstractListModel>
{
using SuperClass = DosQAbstractGenericModel<QAbstractListModel>;
public:
using SuperClass::SuperClass;
QModelIndex defaultParent(const QModelIndex& child) const;
QModelIndex defaultIndex(int row, int column, const QModelIndex& parent = QModelIndex()) const;
int defaultColumnCount(const QModelIndex &parent) const;
bool defaultHasChildren(const QModelIndex &parent) const override;
};
} // namespace DOS

173
lib/include/DOtherSide/DosQAbstractListModelWrapper.h → lib/include/DOtherSide/DosQAbstractItemModelWrapper.h
View File

@ -1,20 +1,20 @@
#pragma once
#include "DOtherSide/DosQAbstractListModel.h"
#include "DOtherSide/DosQAbstractItemModel.h"
#include "DOtherSide/DosQMetaObject.h"
namespace DOS {
template <int, int>
class DosQAbstractListModelWrapper : public QAbstractListModel, public DosIQAbstractListModelImpl
class DosQAbstractItemModelWrapper : public QAbstractItemModel, public DosIQObjectImpl
{
public:
static const QMetaObject staticMetaObject;
/// Constructor
DosQAbstractListModelWrapper(QObject *parent = nullptr);
DosQAbstractItemModelWrapper(QObject *parent = nullptr);
/// Destructor
~DosQAbstractListModelWrapper();
~DosQAbstractItemModelWrapper();
/// @see DosIQObjectImpl::metaObject
const QMetaObject *metaObject() const override;
@ -37,100 +37,83 @@ public:
/// Sets the qmlRegisterType id
static void setId(int id);
/// @see QAbstractListModel::rowCount
/// @see QAbstractItemModel::rowCount
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
/// @see QAbstractListModel::columnCount
/// @see QAbstractItemModel::columnCount
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
/// @see QAbstractListModel::data
/// @see QAbstractItemModel::data
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
/// @see QAbstractListModel::setData
/// @see QAbstractItemModel::setData
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
/// @see QAbstractListModel::flags
/// @see QAbstractItemModel::flags
Qt::ItemFlags flags(const QModelIndex &index) const override;
/// @see QAbstractListModel::headerData
/// @see QAbstractItemModel::headerData
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
/// @see QAbstractListModel::roleNames
/// @see QAbstractItemModel::roleNames
QHash<int, QByteArray> roleNames() const override;
/// @see DosIQAbstractListModelImpl::publicBeginInsertRows
void publicBeginInsertRows(const QModelIndex &index, int first, int last) override;
/// @see QAbstractItemModel::index
QModelIndex index(int row, int column, const QModelIndex &parent) const override;
/// @see DosIQAbstractListModelImpl::publicEndInsertRows
void publicEndInsertRows() override;
/// @see DosIQAbstractListModelImpl::publicBeginRemoveRows
void publicBeginRemoveRows(const QModelIndex &index, int first, int last) override;
/// @see DosIQAbstractListModelImpl::publicEndRemoveRows
void publicEndRemoveRows() override;
/// @see DosIQAbstractListModelImpl::publicBeginResetModel
void publicBeginResetModel() override;
/// @see DosIQAbstractListModelImpl::publicEndResetModel
void publicEndResetModel() override;
/// @see DosIQAbstractListModelImpl::publicDataChanged
void publicDataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight,
const QVector<int> &roles = QVector<int>()) override;
/// @see QAbstractItemModel::parent
QModelIndex parent(const QModelIndex &child) const override;
private:
void *m_dObject;
DosQAbstractListModel *m_impl;
QAbstractItemModel *m_impl;
static int m_id;
static QmlRegisterType m_data;
};
template<int N, int M>
const QMetaObject DosQAbstractListModelWrapper<N, M>::staticMetaObject = QAbstractListModel::staticMetaObject;
const QMetaObject DosQAbstractItemModelWrapper<N, M>::staticMetaObject = QAbstractItemModel::staticMetaObject;
template<int N, int M>
QmlRegisterType DosQAbstractListModelWrapper<N, M>::m_data;
QmlRegisterType DosQAbstractItemModelWrapper<N, M>::m_data;
template<int N, int M>
int DosQAbstractListModelWrapper<N, M>::m_id = -1;
int DosQAbstractItemModelWrapper<N, M>::m_id = -1;
template<int N, int M>
DosQAbstractListModelWrapper<N, M>::DosQAbstractListModelWrapper(QObject *parent)
: QAbstractListModel(parent)
DosQAbstractItemModelWrapper<N, M>::DosQAbstractItemModelWrapper(QObject *parent)
: QAbstractItemModel(parent)
, m_dObject(nullptr)
, m_impl(nullptr)
{
void *impl = nullptr;
m_data.createDObject(m_id, static_cast<QObject *>(this), &m_dObject, &impl);
beginResetModel();
m_impl = dynamic_cast<DosQAbstractListModel *>(static_cast<QObject *>(impl));
QObject::connect(m_impl, &DosQAbstractListModel::rowsAboutToBeInserted, this, &DosQAbstractListModelWrapper::beginInsertRows);
QObject::connect(m_impl, &DosQAbstractListModel::rowsInserted, this, &DosQAbstractListModelWrapper::endInsertRows);
QObject::connect(m_impl, &DosQAbstractListModel::rowsAboutToBeRemoved, this, &DosQAbstractListModelWrapper::beginRemoveRows);
QObject::connect(m_impl, &DosQAbstractListModel::rowsRemoved, this, &DosQAbstractListModelWrapper::endRemoveRows);
QObject::connect(m_impl, &DosQAbstractListModel::rowsAboutToBeMoved, this, &DosQAbstractListModelWrapper::beginMoveRows);
QObject::connect(m_impl, &DosQAbstractListModel::rowsMoved, this, &DosQAbstractListModelWrapper::endMoveRows);
QObject::connect(m_impl, &DosQAbstractListModel::columnsAboutToBeInserted, this, &DosQAbstractListModelWrapper::beginInsertColumns);
QObject::connect(m_impl, &DosQAbstractListModel::columnsInserted, this, &DosQAbstractListModelWrapper::endInsertColumns);
QObject::connect(m_impl, &DosQAbstractListModel::columnsAboutToBeRemoved, this, &DosQAbstractListModelWrapper::beginRemoveColumns);
QObject::connect(m_impl, &DosQAbstractListModel::columnsRemoved, this, &DosQAbstractListModelWrapper::endRemoveColumns);
QObject::connect(m_impl, &DosQAbstractListModel::columnsAboutToBeMoved, this, &DosQAbstractListModelWrapper::beginMoveColumns);
QObject::connect(m_impl, &DosQAbstractListModel::columnsMoved, this, &DosQAbstractListModelWrapper::endMoveColumns);
QObject::connect(m_impl, &DosQAbstractListModel::modelAboutToBeReset, this, &DosQAbstractListModelWrapper::beginResetModel);
QObject::connect(m_impl, &DosQAbstractListModel::modelReset, this, &DosQAbstractListModelWrapper::endResetModel);
QObject::connect(m_impl, &DosQAbstractListModel::dataChanged, this, &DosQAbstractListModelWrapper::dataChanged);
QObject::connect(m_impl, &DosQAbstractListModel::layoutAboutToBeChanged, this, &DosQAbstractListModelWrapper::layoutAboutToBeChanged);
QObject::connect(m_impl, &DosQAbstractListModel::layoutChanged, this, &DosQAbstractListModelWrapper::layoutChanged);
m_impl = dynamic_cast<QAbstractItemModel *>(static_cast<QObject *>(impl));
QObject::connect(m_impl, &QAbstractItemModel::rowsAboutToBeInserted, this, &DosQAbstractItemModelWrapper<N,M>::beginInsertRows);
QObject::connect(m_impl, &QAbstractItemModel::rowsInserted, this, &DosQAbstractItemModelWrapper<N,M>::endInsertRows);
QObject::connect(m_impl, &QAbstractItemModel::rowsAboutToBeRemoved, this, &DosQAbstractItemModelWrapper<N,M>::beginRemoveRows);
QObject::connect(m_impl, &QAbstractItemModel::rowsRemoved, this, &DosQAbstractItemModelWrapper<N,M>::endRemoveRows);
QObject::connect(m_impl, &QAbstractItemModel::rowsAboutToBeMoved, this, &DosQAbstractItemModelWrapper<N,M>::beginMoveRows);
QObject::connect(m_impl, &QAbstractItemModel::rowsMoved, this, &DosQAbstractItemModelWrapper<N,M>::endMoveRows);
QObject::connect(m_impl, &QAbstractItemModel::columnsAboutToBeInserted, this, &DosQAbstractItemModelWrapper<N,M>::beginInsertColumns);
QObject::connect(m_impl, &QAbstractItemModel::columnsInserted, this, &DosQAbstractItemModelWrapper<N,M>::endInsertColumns);
QObject::connect(m_impl, &QAbstractItemModel::columnsAboutToBeRemoved, this, &DosQAbstractItemModelWrapper<N,M>::beginRemoveColumns);
QObject::connect(m_impl, &QAbstractItemModel::columnsRemoved, this, &DosQAbstractItemModelWrapper<N,M>::endRemoveColumns);
QObject::connect(m_impl, &QAbstractItemModel::columnsAboutToBeMoved, this, &DosQAbstractItemModelWrapper<N,M>::beginMoveColumns);
QObject::connect(m_impl, &QAbstractItemModel::columnsMoved, this, &DosQAbstractItemModelWrapper<N,M>::endMoveColumns);
QObject::connect(m_impl, &QAbstractItemModel::modelAboutToBeReset, this, &DosQAbstractItemModelWrapper<N,M>::beginResetModel);
QObject::connect(m_impl, &QAbstractItemModel::modelReset, this, &DosQAbstractItemModelWrapper<N,M>::endResetModel);
QObject::connect(m_impl, &QAbstractItemModel::dataChanged, this, &DosQAbstractItemModelWrapper<N,M>::dataChanged);
QObject::connect(m_impl, &QAbstractItemModel::layoutAboutToBeChanged, this, &DosQAbstractItemModelWrapper<N,M>::layoutAboutToBeChanged);
QObject::connect(m_impl, &QAbstractItemModel::layoutChanged, this, &DosQAbstractItemModelWrapper<N,M>::layoutChanged);
endResetModel();
Q_ASSERT(m_dObject);
Q_ASSERT(m_impl);
}
template<int N, int M>
DosQAbstractListModelWrapper<N, M>::~DosQAbstractListModelWrapper()
DosQAbstractItemModelWrapper<N, M>::~DosQAbstractItemModelWrapper()
{
m_data.deleteDObject(m_id, m_dObject);
m_dObject = nullptr;
@ -139,145 +122,117 @@ DosQAbstractListModelWrapper<N, M>::~DosQAbstractListModelWrapper()
}
template<int N, int M>
const QMetaObject *DosQAbstractListModelWrapper<N, M>::metaObject() const
const QMetaObject *DosQAbstractItemModelWrapper<N, M>::metaObject() const
{
Q_ASSERT(m_impl);
return m_impl->metaObject();
}
template<int N, int M>
int DosQAbstractListModelWrapper<N, M>::qt_metacall(QMetaObject::Call call, int index, void **args)
int DosQAbstractItemModelWrapper<N, M>::qt_metacall(QMetaObject::Call call, int index, void **args)
{
Q_ASSERT(m_impl);
return m_impl->qt_metacall(call, index, args);
}
template<int N, int M>
bool DosQAbstractListModelWrapper<N, M>::emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues)
bool DosQAbstractItemModelWrapper<N, M>::emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues)
{
Q_ASSERT(m_impl);
return m_impl->emitSignal(this, name, argumentsValues);
return dynamic_cast<DosIQObjectImpl*>(this)->emitSignal(this, name, argumentsValues);
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::setQmlRegisterType(QmlRegisterType data)
void DosQAbstractItemModelWrapper<N, M>::setQmlRegisterType(QmlRegisterType data)
{
m_data = std::move(data);
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::setStaticMetaObject(const QMetaObject &metaObject)
void DosQAbstractItemModelWrapper<N, M>::setStaticMetaObject(const QMetaObject &metaObject)
{
*(const_cast<QMetaObject *>(&staticMetaObject)) = metaObject;
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::setId(int id)
void DosQAbstractItemModelWrapper<N, M>::setId(int id)
{
m_id = id;
}
template<int N, int M>
int DosQAbstractListModelWrapper<N, M>::rowCount(const QModelIndex &parent) const
int DosQAbstractItemModelWrapper<N, M>::rowCount(const QModelIndex &parent) const
{
Q_ASSERT(m_impl);
return m_impl->rowCount(parent);
}
template<int N, int M>
int DosQAbstractListModelWrapper<N, M>::columnCount(const QModelIndex &parent) const
int DosQAbstractItemModelWrapper<N, M>::columnCount(const QModelIndex &parent) const
{
Q_ASSERT(m_impl);
return m_impl->columnCount(parent);
}
template<int N, int M>
QVariant DosQAbstractListModelWrapper<N, M>::data(const QModelIndex &index, int role) const
QVariant DosQAbstractItemModelWrapper<N, M>::data(const QModelIndex &index, int role) const
{
Q_ASSERT(m_impl);
return m_impl->data(index, role);
}
template<int N, int M>
bool DosQAbstractListModelWrapper<N, M>::setData(const QModelIndex &index, const QVariant &value, int role)
bool DosQAbstractItemModelWrapper<N, M>::setData(const QModelIndex &index, const QVariant &value, int role)
{
Q_ASSERT(m_impl);
return m_impl->setData(index, value, role);
}
template<int N, int M>
Qt::ItemFlags DosQAbstractListModelWrapper<N, M>::flags(const QModelIndex &index) const
Qt::ItemFlags DosQAbstractItemModelWrapper<N, M>::flags(const QModelIndex &index) const
{
Q_ASSERT(m_impl);
return m_impl->flags(index);
}
template<int N, int M>
QVariant DosQAbstractListModelWrapper<N, M>::headerData(int section, Qt::Orientation orientation, int role) const
QVariant DosQAbstractItemModelWrapper<N, M>::headerData(int section, Qt::Orientation orientation, int role) const
{
Q_ASSERT(m_impl);
return m_impl->headerData(section, orientation, role);
}
template<int N, int M>
QHash<int, QByteArray> DosQAbstractListModelWrapper<N, M>::roleNames() const
QHash<int, QByteArray> DosQAbstractItemModelWrapper<N, M>::roleNames() const
{
Q_ASSERT(m_impl);
return m_impl->roleNames();
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicBeginInsertRows(const QModelIndex &index, int first, int last)
QModelIndex DosQAbstractItemModelWrapper<N, M>::index(int row, int column, const QModelIndex &parent) const
{
m_impl->publicBeginInsertRows(index, first, last);
Q_ASSERT(m_impl);
return m_impl->index(row, column, parent);
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicEndInsertRows()
QModelIndex DosQAbstractItemModelWrapper<N, M>::parent(const QModelIndex &child) const
{
m_impl->publicEndInsertRows();
Q_ASSERT(m_impl);
return m_impl->parent(child);
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicBeginRemoveRows(const QModelIndex &index, int first, int last)
{
m_impl->publicBeginRemoveRows(index, first, last);
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicEndRemoveRows()
{
m_impl->publicEndRemoveRows();
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicBeginResetModel()
{
m_impl->publicBeginResetModel();
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicEndResetModel()
{
m_impl->publicEndResetModel();
}
template<int N, int M>
void DosQAbstractListModelWrapper<N, M>::publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
{
m_impl->publicDataChanged(topLeft, bottomRight, roles);
}
template<int N, int M>
const QmlRegisterType &DosQAbstractListModelWrapper<N, M>::qmlRegisterType()
const QmlRegisterType &DosQAbstractItemModelWrapper<N, M>::qmlRegisterType()
{
return m_data;
}
namespace DQALMW {
namespace DQAIMW {
template<int N>
using RegisterTypeQObject = DosQAbstractListModelWrapper<N, 0>;
using RegisterTypeQObject = DosQAbstractItemModelWrapper<N, 0>;
template<int N>
int dosQmlRegisterType(QmlRegisterType args)
@ -318,7 +273,7 @@ int dosQmlRegisterType(QmlRegisterType args)
}
template<int N>
using RegisterSingletonTypeQObject = DosQAbstractListModelWrapper<N, 1>;
using RegisterSingletonTypeQObject = DosQAbstractItemModelWrapper<N, 1>;
template<int N>
QObject *singletontype_provider(QQmlEngine *engine, QJSEngine *scriptEngine)

94
lib/include/DOtherSide/DosQAbstractListModel.h
View File

@ -1,94 +0,0 @@
#pragma once
// Qt
#include <QAbstractListModel>
// DOtherSide
#include "DOtherSide/DOtherSideTypes.h"
#include "DOtherSide/DosIQAbstractListModelImpl.h"
#include "DOtherSide/OnSlotExecutedHandler.h"
namespace DOS {
class DosQAbstractListModel : public QAbstractListModel, public DosIQAbstractListModelImpl
{
public:
/// Constructor
DosQAbstractListModel(void *modelObject,
DosIQMetaObjectPtr metaObject,
OnSlotExecuted onSlotExecuted,
RowCountCallback rowCountCallback,
ColumnCountCallback columnCountCallback,
DataCallback dataCallback,
SetDataCallback setDataCallback,
RoleNamesCallback roleNamesCallback,
FlagsCallback flagsCallback,
HeaderDataCallback headerDataCallback);
/// @see IDynamicQObject::emitSignal
bool emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues) override;
/// @see QAbstractListModel::metaObject()
const QMetaObject *metaObject() const override;
/// @see QAbstractListModel::qt_metacall
int qt_metacall(QMetaObject::Call, int, void **) override;
/// Return the model's row count
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
/// Return the model's column count
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
/// Return the QVariant at the given index
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
/// Sets the QVariant value at the given index and role
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
/// Return the item flags for the given index
Qt::ItemFlags flags(const QModelIndex &index) const override;
/// Return the data for the given role and section in the header with the specified orientation
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
/// Return the dModelPointer
void *modelObject();
/// Return the roleNames
QHash<int, QByteArray> roleNames() const override;
/// Expose beginInsertRows
void publicBeginInsertRows(const QModelIndex &index, int first, int last) override;
/// Expose endInsertRows
void publicEndInsertRows() override;
/// Expose beginRemoveRows
void publicBeginRemoveRows(const QModelIndex &index, int first, int last) override;
/// Expose endInsertRows
void publicEndRemoveRows() override;
/// Expose beginResetModel
void publicBeginResetModel() override;
/// Expose endResetModel
void publicEndResetModel() override;
/// Expose dataChanged
void publicDataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight,
const QVector<int> &roles = QVector<int>()) override;
private:
std::unique_ptr<DosIQObjectImpl> m_impl;
void *m_modelObject;
RowCountCallback m_rowCountCallback;
ColumnCountCallback m_columnCountCallback;
DataCallback m_dataCallback;
SetDataCallback m_setDataCallback;
RoleNamesCallback m_roleNamesCallback;
FlagsCallback m_flagsCallback;
HeaderDataCallback m_headerDataCallback;
};
} // namespace DOS

16
lib/include/DOtherSide/DosQMetaObject.h
View File

@ -9,6 +9,9 @@
#include <QtCore/QString>
#include <QtCore/QHash>
#include <QtCore/QMetaMethod>
#include <QtCore/QAbstractItemModel>
#include <QtCore/QAbstractListModel>
#include <QtCore/QAbstractTableModel>
// DOtherSide
#include "DOtherSide/DOtherSideTypesCpp.h"
@ -49,14 +52,19 @@ public:
DosQObjectMetaObject();
};
/// This is the DosQMetaObject for a QAbstractListModel
class DosQAbstractListModelMetaObject : public BaseDosQMetaObject
/// This is the DosQMetaObject for a QAbstractItemModel
template<class T>
class DosQAbstractGenericModelMetaObject : public BaseDosQMetaObject
{
public:
DosQAbstractListModelMetaObject();
DosQAbstractGenericModelMetaObject();
};
/// This the generic version used by subclasses of QObject or QAbstractListModels
using DosQAbstractItemModelMetaObject = DosQAbstractGenericModelMetaObject<QAbstractItemModel>;
using DosQAbstractListModelMetaObject = DosQAbstractGenericModelMetaObject<QAbstractListModel>;
using DosQAbstractTableModelMetaObject = DosQAbstractGenericModelMetaObject<QAbstractTableModel>;
/// This the generic version used by subclasses of QObject or QAbstractItemModels
class DosQMetaObject : public BaseDosQMetaObject
{
public:

4
lib/meson.build
View File

@ -1,7 +1,7 @@
lib_version = '1.0.0'
lib_dependencies = dependency('qt5', modules : ['Core', 'Widgets', 'Quick', 'Qml'])
lib_dependencies = dependency('qt5', modules : ['Core', 'Gui', 'Widgets', 'Quick', 'Qml'])
lib_sources = [
'src/DosQAbstractListModel.cpp',
'src/DosQAbstractItemModel.cpp',
'src/DosQMetaObject.cpp',
'src/DosQObject.cpp',
'src/DosQObjectImpl.cpp',

224
lib/src/DOtherSide.cpp
View File

@ -18,7 +18,7 @@
#include "DOtherSide/DosQMetaObject.h"
#include "DOtherSide/DosQObject.h"
#include "DOtherSide/DosQObjectImpl.h"
#include "DOtherSide/DosQAbstractListModel.h"
#include "DOtherSide/DosQAbstractItemModel.h"
#include "DOtherSide/DosQDeclarative.h"
namespace {
@ -600,6 +600,43 @@ void dos_qmetaobject_delete(::DosQMetaObject *vptr)
delete factory;
}
::DosQMetaObject *dos_qabstracttablemodel_qmetaobject()
{
return new DOS::DosIQMetaObjectHolder(std::make_shared<DOS::DosQAbstractTableModelMetaObject>());
}
::DosQAbstractListModel *dos_qabstracttablemodel_create(void *dObjectPointer,
::DosQMetaObject *metaObjectPointer,
::DObjectCallback dObjectCallback,
::DosQAbstractItemModelCallbacks* callbacks)
{
auto metaObjectHolder = static_cast<DOS::DosIQMetaObjectHolder *>(metaObjectPointer);
auto model = new DOS::DosQAbstractTableModel(dObjectPointer,
metaObjectHolder->data(),
DOS::OnSlotExecutedHandler(dObjectPointer, dObjectCallback),
*callbacks);
QQmlEngine::setObjectOwnership(model, QQmlEngine::CppOwnership);
return static_cast<QObject *>(model);
}
DosQModelIndex *dos_qabstracttablemodel_index(DosQAbstractTableModel *vptr, int row, int column, DosQModelIndex *dosParent)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosQAbstractTableModel *>(object);
auto parent = static_cast<QModelIndex*>(dosParent);
auto result = new QModelIndex(model->defaultIndex(row, column, *parent));
return static_cast<DosQModelIndex*>(result);
}
DosQModelIndex *dos_qabstracttablemodel_parent(DosQAbstractTableModel *vptr, DosQModelIndex *dosChild)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosQAbstractTableModel *>(object);
auto child = static_cast<QModelIndex*>(dosChild);
auto result = new QModelIndex(model->defaultParent(*child));
return static_cast<DosQModelIndex*>(result);
}
::DosQMetaObject *dos_qabstractlistmodel_qmetaobject()
{
return new DOS::DosIQMetaObjectHolder(std::make_shared<DOS::DosQAbstractListModelMetaObject>());
@ -608,87 +645,216 @@ void dos_qmetaobject_delete(::DosQMetaObject *vptr)
::DosQAbstractListModel *dos_qabstractlistmodel_create(void *dObjectPointer,
::DosQMetaObject *metaObjectPointer,
::DObjectCallback dObjectCallback,
::RowCountCallback rowCountCallback,
::ColumnCountCallback columnCountCallback,
::DataCallback dataCallback,
::SetDataCallback setDataCallback,
::RoleNamesCallback roleNamesCallaback,
::FlagsCallback flagsCallback,
::HeaderDataCallback headerDataCallback)
::DosQAbstractItemModelCallbacks* callbacks)
{
auto metaObjectHolder = static_cast<DOS::DosIQMetaObjectHolder *>(metaObjectPointer);
auto model = new DOS::DosQAbstractListModel(dObjectPointer,
metaObjectHolder->data(),
DOS::OnSlotExecutedHandler(dObjectPointer, dObjectCallback),
rowCountCallback,
columnCountCallback,
dataCallback,
setDataCallback,
roleNamesCallaback,
flagsCallback,
headerDataCallback);
*callbacks);
QQmlEngine::setObjectOwnership(model, QQmlEngine::CppOwnership);
return static_cast<QObject *>(model);
}
void dos_qabstractlistmodel_beginInsertRows(::DosQAbstractListModel *vptr, ::DosQModelIndex *parentIndex, int first, int last)
DosQModelIndex *dos_qabstractlistmodel_index(DosQAbstractListModel *vptr, int row, int column, DosQModelIndex *dosParent)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosQAbstractListModel *>(object);
auto parent = static_cast<QModelIndex*>(dosParent);
auto result = new QModelIndex(model->defaultIndex(row, column, *parent));
return static_cast<DosQModelIndex*>(result);
}
DosQModelIndex *dos_qabstractlistmodel_parent(DosQAbstractListModel *vptr, DosQModelIndex *dosChild)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosQAbstractListModel *>(object);
auto child = static_cast<QModelIndex*>(dosChild);
auto result = new QModelIndex(model->defaultParent(*child));
return static_cast<DosQModelIndex*>(result);
}
int dos_qabstractlistmodel_columnCount(DosQAbstractListModel *vptr, DosQModelIndex *dosParent)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosQAbstractListModel *>(object);
auto parent = static_cast<QModelIndex*>(dosParent);
return model->defaultColumnCount(*parent);
}
::DosQMetaObject *dos_qabstractitemmodel_qmetaobject()
{
return new DOS::DosIQMetaObjectHolder(std::make_shared<DOS::DosQAbstractItemModelMetaObject>());
}
::DosQAbstractItemModel *dos_qabstractitemmodel_create(void *dObjectPointer,
::DosQMetaObject *metaObjectPointer,
::DObjectCallback dObjectCallback,
::DosQAbstractItemModelCallbacks* callbacks)
{
auto metaObjectHolder = static_cast<DOS::DosIQMetaObjectHolder *>(metaObjectPointer);
auto model = new DOS::DosQAbstractItemModel(dObjectPointer,
metaObjectHolder->data(),
DOS::OnSlotExecutedHandler(dObjectPointer, dObjectCallback),
*callbacks);
QQmlEngine::setObjectOwnership(model, QQmlEngine::CppOwnership);
return static_cast<QObject *>(model);
}
void dos_qabstractitemmodel_beginInsertRows(::DosQAbstractItemModel *vptr, ::DosQModelIndex *parentIndex, int first, int last)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto index = static_cast<QModelIndex *>(parentIndex);
model->publicBeginInsertRows(*index, first, last);
}
void dos_qabstractlistmodel_endInsertRows(::DosQAbstractListModel *vptr)
void dos_qabstractitemmodel_endInsertRows(::DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
model->publicEndInsertRows();
}
void dos_qabstractlistmodel_beginRemoveRows(::DosQAbstractListModel *vptr, ::DosQModelIndex *parentIndex, int first, int last)
void dos_qabstractitemmodel_beginRemoveRows(::DosQAbstractItemModel *vptr, ::DosQModelIndex *parentIndex, int first, int last)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto index = static_cast<QModelIndex *>(parentIndex);
model->publicBeginRemoveRows(*index, first, last);
}
void dos_qabstractlistmodel_endRemoveRows(::DosQAbstractListModel *vptr)
void dos_qabstractitemmodel_endRemoveRows(::DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
model->publicEndRemoveRows();
}
void dos_qabstractlistmodel_beginResetModel(::DosQAbstractListModel *vptr)
void dos_qabstractitemmodel_beginInsertColumns(::DosQAbstractItemModel *vptr, ::DosQModelIndex *parentIndex, int first, int last)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto index = static_cast<QModelIndex *>(parentIndex);
model->publicBeginInsertColumns(*index, first, last);
}
void dos_qabstractitemmodel_endInsertColumns(::DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
model->publicEndInsertColumns();
}
void dos_qabstractitemmodel_beginRemoveColumns(::DosQAbstractItemModel *vptr, ::DosQModelIndex *parentIndex, int first, int last)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto index = static_cast<QModelIndex *>(parentIndex);
model->publicBeginRemoveColumns(*index, first, last);
}
void dos_qabstractitemmodel_endRemoveColumns(::DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
model->publicEndRemoveColumns();
}
void dos_qabstractitemmodel_beginResetModel(::DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
model->publicBeginResetModel();
}
void dos_qabstractlistmodel_endResetModel(::DosQAbstractListModel *vptr)
void dos_qabstractitemmodel_endResetModel(::DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
model->publicEndResetModel();
}
void dos_qabstractlistmodel_dataChanged(::DosQAbstractListModel *vptr,
void dos_qabstractitemmodel_dataChanged(::DosQAbstractItemModel *vptr,
const ::DosQModelIndex *topLeftIndex,
const ::DosQModelIndex *bottomRightIndex,
int *rolesArrayPtr,
int rolesArrayLength)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractListModelImpl *>(object);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto topLeft = static_cast<const QModelIndex *>(topLeftIndex);
auto bottomRight = static_cast<const QModelIndex *>(bottomRightIndex);
auto roles = QVector<int>::fromStdVector(std::vector<int>(rolesArrayPtr, rolesArrayPtr + rolesArrayLength));
model->publicDataChanged(*topLeft, *bottomRight, roles);
}
DosQModelIndex *dos_qabstractitemmodel_createIndex(::DosQAbstractItemModel *vptr,
int row, int column, void *data)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
return new QModelIndex(model->publicCreateIndex(row, column, data));
}
bool dos_qabstractitemmodel_setData(DosQAbstractItemModel *vptr,
DosQModelIndex *dosIndex, DosQVariant *dosValue, int role)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto index = static_cast<QModelIndex*>(dosIndex);
auto value = static_cast<QVariant*>(dosValue);
return model->defaultSetData(*index, *value, role);
}
DosQHashIntQByteArray *dos_qabstractitemmodel_roleNames(DosQAbstractItemModel *vptr)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto result = new QHash<int, QByteArray>(model->defaultRoleNames());
return static_cast<DosQHashIntQByteArray*>(result);
}
int dos_qabstractitemmodel_flags(DosQAbstractItemModel *vptr, DosQModelIndex *dosIndex)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto index = static_cast<QModelIndex*>(dosIndex);
return model->defaultFlags(*index);
}
DosQVariant *dos_qabstractitemmodel_headerData(DosQAbstractItemModel *vptr, int section, int orientation, int role)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto result = new QVariant(model->defaultHeaderData(section, static_cast<Qt::Orientation>(orientation), role));
return static_cast<DosQVariant *>(result);
}
bool dos_qabstractitemmodel_hasChildren(DosQAbstractItemModel *vptr, DosQModelIndex *dosParentIndex)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto parentIndex = static_cast<QModelIndex*>(dosParentIndex);
return model->defaultHasChildren(*parentIndex);
}
bool dos_qabstractitemmodel_canFetchMore(DosQAbstractItemModel *vptr, DosQModelIndex *dosParentIndex)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto parentIndex = static_cast<QModelIndex*>(dosParentIndex);
return model->defaultCanFetchMore(*parentIndex);
}
void dos_qabstractitemmodel_fetchMore(DosQAbstractItemModel *vptr, DosQModelIndex *dosParentIndex)
{
auto object = static_cast<QObject *>(vptr);
auto model = dynamic_cast<DOS::DosIQAbstractItemModelImpl *>(object);
auto parentIndex = static_cast<QModelIndex*>(dosParentIndex);
model->defaultFetchMore(*parentIndex);
}
int dos_qdeclarative_qmlregistertype(const ::QmlRegisterType *cArgs)
{
auto holder = static_cast<DOS::DosIQMetaObjectHolder *>(cArgs->staticMetaObject);

303
lib/src/DosQAbstractItemModel.cpp Normal file
View File

@ -0,0 +1,303 @@
#include "DOtherSide/DosQAbstractItemModel.h"
#include "DOtherSide/DosQObjectImpl.h"
namespace {
template<class T>
DOS::DosQObjectImpl::ParentMetaCall createParentMetaCall(DOS::DosQAbstractGenericModel<T> *parent)
{
return [parent](QMetaObject::Call callType, int index, void **args)->int {
return parent->T::qt_metacall(callType, index, args);
};
}
}
namespace DOS {
template<class T>
DosQAbstractGenericModel<T>::DosQAbstractGenericModel(void *modelObject,
DosIQMetaObjectPtr metaObject,
OnSlotExecuted onSlotExecuted,
DosQAbstractItemModelCallbacks callbacks)
: m_impl(new DosQObjectImpl(this, ::createParentMetaCall(this), std::move(metaObject), std::move(onSlotExecuted)))
, m_modelObject(std::move(modelObject))
, m_callbacks(callbacks)
{}
template<class T>
bool DosQAbstractGenericModel<T>::emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues)
{
Q_ASSERT(m_impl);
return m_impl->emitSignal(emitter, name, argumentsValues);
}
template<class T>
const QMetaObject *DosQAbstractGenericModel<T>::metaObject() const
{
Q_ASSERT(m_impl);
return m_impl->metaObject();
}
template<class T>
int DosQAbstractGenericModel<T>::qt_metacall(QMetaObject::Call call, int index, void **args)
{
Q_ASSERT(m_impl);
return m_impl->qt_metacall(call, index, args);
}
template<class T>
int DosQAbstractGenericModel<T>::rowCount(const QModelIndex &parent) const
{
int result;
m_callbacks.rowCount(m_modelObject, &parent, &result);
return result;
}
template<class T>
int DosQAbstractGenericModel<T>::columnCount(const QModelIndex &parent) const
{
int result;
m_callbacks.columnCount(m_modelObject, &parent, &result);
return result;
}
template<class T>
QVariant DosQAbstractGenericModel<T>::data(const QModelIndex &index, int role) const
{
QVariant result;
m_callbacks.data(m_modelObject, &index, role, &result);
return result;
}
template<class T>
bool DosQAbstractGenericModel<T>::setData(const QModelIndex &index, const QVariant &value, int role)
{
bool result = false;
m_callbacks.setData(m_modelObject, &index, &value, role, &result);
return result;
}
template<class T>
Qt::ItemFlags DosQAbstractGenericModel<T>::flags(const QModelIndex &index) const
{
int result;
m_callbacks.flags(m_modelObject, &index, &result);
return Qt::ItemFlags(result);
}
template<class T>
QVariant DosQAbstractGenericModel<T>::headerData(int section, Qt::Orientation orientation, int role) const
{
QVariant result;
m_callbacks.headerData(m_modelObject, section, orientation, role, &result);
return result;
}
template<class T>
QModelIndex DosQAbstractGenericModel<T>::index(int row, int column, const QModelIndex &parent) const
{
QModelIndex result;
m_callbacks.index(m_modelObject, row, column, &parent, &result);
return result;
}
template<class T>
QModelIndex DosQAbstractGenericModel<T>::parent(const QModelIndex &child) const
{
QModelIndex result;
m_callbacks.parent(m_modelObject, &child, &result);
return result;
}
template<class T>
void *DosQAbstractGenericModel<T>::modelObject()
{
return m_modelObject;
}
template<class T>
QHash<int, QByteArray> DosQAbstractGenericModel<T>::roleNames() const
{
QHash<int, QByteArray> result;
m_callbacks.roleNames(m_modelObject, &result);
return result;
}
template<class T>
void DosQAbstractGenericModel<T>::publicBeginInsertColumns(const QModelIndex &index, int first, int last)
{
T::beginInsertColumns(index, first, last);
}
template<class T>
void DosQAbstractGenericModel<T>::publicEndInsertColumns()
{
T::endInsertColumns();
}
template<class T>
void DosQAbstractGenericModel<T>::publicBeginRemoveColumns(const QModelIndex &index, int first, int last)
{
T::beginRemoveColumns(index, first, last);
}
template<class T>
void DosQAbstractGenericModel<T>::publicEndRemoveColumns()
{
T::endRemoveColumns();
}
template<class T>
void DosQAbstractGenericModel<T>::publicBeginInsertRows(const QModelIndex &index, int first, int last)
{
T::beginInsertRows(index, first, last);
}
template<class T>
void DosQAbstractGenericModel<T>::publicEndInsertRows()
{
T::endInsertRows();
}
template<class T>
void DosQAbstractGenericModel<T>::publicBeginRemoveRows(const QModelIndex &index, int first, int last)
{
T::beginRemoveRows(index, first, last);
}
template<class T>
void DosQAbstractGenericModel<T>::publicEndRemoveRows()
{
T::endRemoveRows();
}
template<class T>
void DosQAbstractGenericModel<T>::publicBeginResetModel()
{
T::beginResetModel();
}
template<class T>
void DosQAbstractGenericModel<T>::publicEndResetModel()
{
T::endResetModel();
}
template<class T>
void DosQAbstractGenericModel<T>::publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
{
emit T::dataChanged(topLeft, bottomRight, roles);
}
template<class T>
QModelIndex DosQAbstractGenericModel<T>::publicCreateIndex(int row, int column, void *data) const
{
return T::createIndex(row, column, data);
}
template<class T>
Qt::ItemFlags DosQAbstractGenericModel<T>::defaultFlags(const QModelIndex &index) const
{
return T::flags(index);
}
template<class T>
QVariant DosQAbstractGenericModel<T>::defaultHeaderData(int section, Qt::Orientation orientation, int role) const
{
return T::headerData(section, orientation, role);
}
template<class T>
QHash<int, QByteArray> DosQAbstractGenericModel<T>::defaultRoleNames() const
{
return T::roleNames();
}
template<class T>
bool DosQAbstractGenericModel<T>::defaultSetData(const QModelIndex &index, const QVariant &value, int role)
{
return T::setData(index, value, role);
}
template<class T>
bool DosQAbstractGenericModel<T>::hasChildren(const QModelIndex &parent) const
{
bool result = false;
m_callbacks.hasChildren(m_modelObject, &parent, &result);
return result;
}
template<class T>
bool DosQAbstractGenericModel<T>::canFetchMore(const QModelIndex &parent) const
{
bool result = false;
m_callbacks.canFetchMore(m_modelObject, &parent, &result);
return result;
}
template<class T>
bool DosQAbstractGenericModel<T>::defaultCanFetchMore(const QModelIndex &parent) const
{
return this->T::canFetchMore(parent);
}
template<class T>
void DosQAbstractGenericModel<T>::fetchMore(const QModelIndex &parent)
{
m_callbacks.fetchMore(m_modelObject, &parent);
}
template<class T>
void DosQAbstractGenericModel<T>::defaultFetchMore(const QModelIndex &parent)
{
this->T::fetchMore(parent);
}
QModelIndex DosQAbstractListModel::defaultIndex(int row, int column, const QModelIndex &parent) const
{
return QAbstractListModel::index(row, column, parent);
}
int DosQAbstractListModel::defaultColumnCount(const QModelIndex &parent) const
{
return parent.isValid() ? 0 : 1;
}
bool DosQAbstractListModel::defaultHasChildren(const QModelIndex &parent) const
{
return parent.isValid() ? false : (rowCount() > 0);
}
QModelIndex DosQAbstractListModel::defaultParent(const QModelIndex &child) const
{
return QModelIndex();
}
QModelIndex DosQAbstractTableModel::defaultIndex(int row, int column, const QModelIndex &parent) const
{
return hasIndex(row, column, parent) ? createIndex(row, column) : QModelIndex();
}
bool DosQAbstractTableModel::defaultHasChildren(const QModelIndex &parent) const
{
if (parent.model() == this || !parent.isValid())
return rowCount(parent) > 0 && columnCount(parent) > 0;
return false;
}
QModelIndex DosQAbstractTableModel::defaultParent(const QModelIndex &child) const
{
return QModelIndex();
}
bool DosQAbstractItemModel::defaultHasChildren(const QModelIndex &parent) const
{
return QAbstractItemModel::hasChildren(parent);
}
} // namespace DOS
// Force instantiation
template class DOS::DosQAbstractGenericModel<QAbstractItemModel>;
template class DOS::DosQAbstractGenericModel<QAbstractListModel>;
template class DOS::DosQAbstractGenericModel<QAbstractTableModel>;

143
lib/src/DosQAbstractListModel.cpp
View File

@ -1,143 +0,0 @@
#include "DOtherSide/DosQAbstractListModel.h"
#include "DOtherSide/DosQObjectImpl.h"
namespace {
DOS::DosQObjectImpl::ParentMetaCall createParentMetaCall(QAbstractListModel *parent)
{
return [parent](QMetaObject::Call callType, int index, void **args)->int {
return parent->QAbstractListModel::qt_metacall(callType, index, args);
};
}
}
namespace DOS {
DosQAbstractListModel::DosQAbstractListModel(void *modelObject,
DosIQMetaObjectPtr metaObject,
OnSlotExecuted onSlotExecuted,
RowCountCallback rowCountCallback,
ColumnCountCallback columnCountCallback,
DataCallback dataCallback,
SetDataCallback setDataCallback,
RoleNamesCallback roleNamesCallback,
FlagsCallback flagsCallback,
HeaderDataCallback headerDataCallback)
: m_impl(new DosQObjectImpl(this, ::createParentMetaCall(this), std::move(metaObject), std::move(onSlotExecuted)))
, m_modelObject(std::move(modelObject))
, m_rowCountCallback(std::move(rowCountCallback))
, m_columnCountCallback(std::move(columnCountCallback))
, m_dataCallback(std::move(dataCallback))
, m_setDataCallback(std::move(setDataCallback))
, m_roleNamesCallback(std::move(roleNamesCallback))
, m_flagsCallback(std::move(flagsCallback))
, m_headerDataCallback(std::move(headerDataCallback))
{}
bool DosQAbstractListModel::emitSignal(QObject *emitter, const QString &name, const std::vector<QVariant> &argumentsValues)
{
Q_ASSERT(m_impl);
return m_impl->emitSignal(emitter, name, argumentsValues);
}
const QMetaObject *DosQAbstractListModel::metaObject() const
{
Q_ASSERT(m_impl);
return m_impl->metaObject();
}
int DosQAbstractListModel::qt_metacall(QMetaObject::Call call, int index, void **args)
{
Q_ASSERT(m_impl);
return m_impl->qt_metacall(call, index, args);
}
int DosQAbstractListModel::rowCount(const QModelIndex &parent) const
{
int result;
m_rowCountCallback(m_modelObject, &parent, &result);
return result;
}
int DosQAbstractListModel::columnCount(const QModelIndex &parent) const
{
int result;
m_columnCountCallback(m_modelObject, &parent, &result);
return result;
}
QVariant DosQAbstractListModel::data(const QModelIndex &index, int role) const
{
QVariant result;
m_dataCallback(m_modelObject, &index, role, &result);
return result;
}
bool DosQAbstractListModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
bool result = false;
m_setDataCallback(m_modelObject, &index, &value, role, &result);
return result;
}
Qt::ItemFlags DosQAbstractListModel::flags(const QModelIndex &index) const
{
int result;
m_flagsCallback(m_modelObject, &index, &result);
return Qt::ItemFlags(result);
}
QVariant DosQAbstractListModel::headerData(int section, Qt::Orientation orientation, int role) const
{
QVariant result;
m_headerDataCallback(m_modelObject, section, orientation, role, &result);
return result;
}
void *DosQAbstractListModel::modelObject()
{
return m_modelObject;
}
QHash<int, QByteArray> DosQAbstractListModel::roleNames() const
{
QHash<int, QByteArray> result;
m_roleNamesCallback(m_modelObject, &result);
return result;
}
void DOS::DosQAbstractListModel::publicBeginInsertRows(const QModelIndex &index, int first, int last)
{
beginInsertRows(index, first, last);
}
void DOS::DosQAbstractListModel::publicEndInsertRows()
{
endInsertRows();
}
void DOS::DosQAbstractListModel::publicBeginRemoveRows(const QModelIndex &index, int first, int last)
{
beginRemoveRows(index, first, last);
}
void DOS::DosQAbstractListModel::publicEndRemoveRows()
{
endRemoveRows();
}
void DOS::DosQAbstractListModel::publicBeginResetModel()
{
beginResetModel();
}
void DOS::DosQAbstractListModel::publicEndResetModel()
{
endResetModel();
}
void DOS::DosQAbstractListModel::publicDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
{
emit dataChanged(topLeft, bottomRight, roles);
}
} // namespace DOS

14
lib/src/DosQDeclarative.cpp
View File

@ -1,14 +1,14 @@
#include "DOtherSide/DosQDeclarative.h"
#include "DOtherSide/DosQObjectWrapper.h"
#include "DOtherSide/DosQAbstractListModelWrapper.h"
#include "DOtherSide/DosQAbstractItemModelWrapper.h"
namespace DOS {
bool isQAbstractListModel(const QMetaObject *metaObject)
bool isQAbstractItemModel(const QMetaObject *metaObject)
{
const QMetaObject *current = metaObject;
while (current) {
if (&QAbstractListModel::staticMetaObject == current)
if (&QAbstractItemModel::staticMetaObject == current)
return true;
current = current->superClass();
}
@ -19,8 +19,8 @@ int dosQmlRegisterType(QmlRegisterType args)
{
static int i = 0;
static int j = 0;
if (isQAbstractListModel(args.staticMetaObject->metaObject()))
return DQALMW::DosQmlRegisterHelper<35>::Register(j++, std::move(args));
if (isQAbstractItemModel(args.staticMetaObject->metaObject()))
return DQAIMW::DosQmlRegisterHelper<35>::Register(j++, std::move(args));
else
return DQOW::DosQmlRegisterHelper<35>::Register(i++, std::move(args));
}
@ -29,8 +29,8 @@ int dosQmlRegisterSingletonType(QmlRegisterType args)
{
static int i = 0;
static int j = 0;
if (isQAbstractListModel(args.staticMetaObject->metaObject()))
return DQALMW::DosQmlRegisterSingletonHelper<35>::Register(j++, std::move(args));
if (isQAbstractItemModel(args.staticMetaObject->metaObject()))
return DQAIMW::DosQmlRegisterSingletonHelper<35>::Register(j++, std::move(args));
else
return DQOW::DosQmlRegisterSingletonHelper<35>::Register(i++, std::move(args));
}

46
lib/src/DosQMetaObject.cpp
View File

@ -3,17 +3,17 @@
#include "private/qmetaobjectbuilder_p.h"
#include "private/qmetaobject_p.h"
#include "private/qobject_p.h"
#include <QtCore/QAbstractListModel>
#include <QtCore/QAbstractItemModel>
namespace {
QList<QByteArray> createParameterNames(const DOS::SignalDefinition &signal)
{
QList<QByteArray> result;
size_t size = signal.parameterTypes.size();
result.reserve(size);
for (size_t i = 0; i < size; ++i)
result << QString("arg%1").arg(i).toUtf8();
const auto &parameters = signal.parameters;
result.reserve(parameters.size());
for (size_t i = 0; i < parameters.size(); ++i)
result << parameters[i].name.toUtf8();
return result;
}
@ -23,12 +23,12 @@ QByteArray createSignature(const T &functionDefinition)
QString signature("%1(%2)");
QString arguments;
const auto &parameters = functionDefinition.parameterTypes;
const auto &parameters = functionDefinition.parameters;
for (size_t i = 0; i < parameters.size(); ++i) {
if (i != 0)
arguments += ",";
arguments += QMetaType::typeName(parameters[i]);
arguments += QMetaType::typeName(parameters[i].metaType);
}
return signature.arg(functionDefinition.name, arguments).toUtf8();
@ -41,19 +41,18 @@ Value valueOrDefault(std::unordered_map<Key, Value> const &map, const Key &k, Va
return it != std::end(map) ? it->second : std::move(value);
}
QMetaObject *createDynamicQObjectMetaObject()
{
QMetaObjectBuilder builder;
builder.setClassName("DosQObject");
builder.setSuperClass(&QObject::staticMetaObject);
return builder.toMetaObject();
}
template<class T> const char* className();
template<> const char* className<QObject>() { return "DosQObject"; }
template<> const char* className<QAbstractItemModel>() { return "DosQAbstractItemModel"; }
template<> const char* className<QAbstractListModel>() { return "DosQAbstractListModel"; }
template<> const char* className<QAbstractTableModel>() { return "DosQAbstractTableModel"; }
QMetaObject *createDynamicQAbstractListModelMetaObject()
template <class T>
QMetaObject *createDynamicMetaObject()
{
QMetaObjectBuilder builder;
builder.setClassName("DosQAbstractListModel");
builder.setSuperClass(&QAbstractListModel::staticMetaObject);
builder.setClassName(className<T>());
builder.setSuperClass(&T::staticMetaObject);
return builder.toMetaObject();
}
@ -91,13 +90,20 @@ const DosIQMetaObject *BaseDosQMetaObject::superClassDosMetaObject() const
}
DosQObjectMetaObject::DosQObjectMetaObject()
: BaseDosQMetaObject(::createDynamicQObjectMetaObject())
: BaseDosQMetaObject(::createDynamicMetaObject<QObject>())
{}
DosQAbstractListModelMetaObject::DosQAbstractListModelMetaObject()
: BaseDosQMetaObject(::createDynamicQAbstractListModelMetaObject())
template<class T>
DosQAbstractGenericModelMetaObject<T>::DosQAbstractGenericModelMetaObject()
: BaseDosQMetaObject(::createDynamicMetaObject<T>())
{}
// Force template instantations
template class DosQAbstractGenericModelMetaObject<QAbstractItemModel>;
template class DosQAbstractGenericModelMetaObject<QAbstractListModel>;
template class DosQAbstractGenericModelMetaObject<QAbstractTableModel>;
DosQMetaObject::DosQMetaObject(DosIQMetaObjectPtr superClassMetaObject,
const QString &className,
const SignalDefinitions &signalDefinitions,

2
meson.build
View File

@ -1,4 +1,4 @@
project('DOtherSide', 'cpp', default_options : ['cpp_std=c++11'])
project('DOtherSide', 'cpp', default_options : ['cpp_std=c++14'])
subdir('lib')
subdir('test')

2
test/CMakeLists.txt
View File

@ -15,7 +15,7 @@ find_package(Qt5QuickTest REQUIRED)
add_executable(${PROJECT_NAME} Resources.qrc
test_dotherside.cpp
MockQObject.cpp
MockQAbstractListModel.cpp
MockQAbstractItemModel.cpp
Global.h
main.qml
testQObject.qml

95
test/MockQAbstractListModel.cpp → test/MockQAbstractItemModel.cpp
View File

@ -1,4 +1,4 @@
#include "MockQAbstractListModel.h"
#include "MockQAbstractItemModel.h"
#include <QMetaType>
using namespace std;
@ -12,16 +12,17 @@ namespace
VoidPointer initializeMetaObject()
{
void* superClassMetaObject = dos_qabstractlistmodel_qmetaobject();
void* superClassMetaObject = dos_qabstractitemmodel_qmetaobject();
// Signals
::SignalDefinition signalDefinitionArray[1];
ParameterDefinition nameChanged[1];
nameChanged[0].metaType = QMetaType::QString;
nameChanged[0].name = "name";
signalDefinitionArray[0].name = "nameChanged";
signalDefinitionArray[0].parametersCount = 1;
int nameChanged[1];
nameChanged[0] = QMetaType::QString;
signalDefinitionArray[0].parametersMetaTypes = nameChanged;
signalDefinitionArray[0].parameters = nameChanged;
::SignalDefinitions signalDefinitions;
signalDefinitions.count = 1;
@ -33,14 +34,15 @@ namespace
slotDefinitionArray[0].name = "name";
slotDefinitionArray[0].returnMetaType = QMetaType::QString;
slotDefinitionArray[0].parametersCount = 0;
slotDefinitionArray[0].parametersMetaTypes = nullptr;
slotDefinitionArray[0].parameters = nullptr;
slotDefinitionArray[1].name = "setName";
slotDefinitionArray[1].returnMetaType = QMetaType::Void;
int setNameParameters[1];
setNameParameters[0] = QMetaType::QString;
ParameterDefinition setNameParameters[1];
setNameParameters[0].name = "name";
setNameParameters[0].metaType = QMetaType::QString;
slotDefinitionArray[1].parametersCount = 1;
slotDefinitionArray[1].parametersMetaTypes = setNameParameters;
slotDefinitionArray[1].parameters = setNameParameters;
::SlotDefinitions slotDefinitions;
slotDefinitions.count = 2;
@ -63,43 +65,52 @@ namespace
}
}
MockQAbstractListModel::MockQAbstractListModel()
: m_vptr(dos_qabstractlistmodel_create(this, metaObject(), &onSlotCalled, &onRowCountCalled,
&onColumnCountCalled, &onDataCalled, &onSetDataCalled,
&onRoleNamesCalled, &onFlagsCalled, &onHeaderDataCalled), &dos_qobject_delete)
MockQAbstractItemModel::MockQAbstractItemModel()
: m_vptr(nullptr, &dos_qobject_delete)
, m_names({"John", "Mary", "Andy", "Anna"})
{
DosQAbstractItemModelCallbacks callbacks;
callbacks.rowCount = &onRowCountCalled;
callbacks.columnCount = &onColumnCountCalled;
callbacks.data = &onDataCalled;
callbacks.setData = &onSetDataCalled;
callbacks.roleNames = &onRoleNamesCalled;
callbacks.flags = &onFlagsCalled;
callbacks.headerData = &onHeaderDataCalled;
callbacks.index = &onIndexCalled;
callbacks.parent = &onParentCalled;
m_vptr.reset(dos_qabstractitemmodel_create(this, metaObject(), &onSlotCalled, &callbacks));
}
DosQMetaObject *MockQAbstractListModel::metaObject()
DosQMetaObject *MockQAbstractItemModel::metaObject()
{
static VoidPointer result = initializeMetaObject();
return result.get();
}
DosQObject *MockQAbstractListModel::data()
DosQObject *MockQAbstractItemModel::data()
{
return m_vptr.get();
}
string MockQAbstractListModel::objectName() const
string MockQAbstractItemModel::objectName() const
{
CharPointer result (dos_qobject_objectName(m_vptr.get()), &dos_chararray_delete);
return string(result.get());
}
void MockQAbstractListModel::setObjectName(const string &objectName)
void MockQAbstractItemModel::setObjectName(const string &objectName)
{
dos_qobject_setObjectName(m_vptr.get(), objectName.c_str());
}
string MockQAbstractListModel::name() const
string MockQAbstractItemModel::name() const
{
return m_name;
}
void MockQAbstractListModel::setName(const string &name)
void MockQAbstractItemModel::setName(const string &name)
{
if (m_name == name)
return;
@ -107,7 +118,7 @@ void MockQAbstractListModel::setName(const string &name)
nameChanged(name);
}
void MockQAbstractListModel::nameChanged(const string &name)
void MockQAbstractItemModel::nameChanged(const string &name)
{
int argc = 1;
DosQVariant* argv[1];
@ -116,9 +127,9 @@ void MockQAbstractListModel::nameChanged(const string &name)
dos_qvariant_delete(argv[0]);
}
void MockQAbstractListModel::onSlotCalled(void *selfVPtr, DosQVariant *dosSlotNameVariant, int dosSlotArgc, DosQVariant **dosSlotArgv)
void MockQAbstractItemModel::onSlotCalled(void *selfVPtr, DosQVariant *dosSlotNameVariant, int dosSlotArgc, DosQVariant **dosSlotArgv)
{
auto self = static_cast<MockQAbstractListModel*>(selfVPtr);
auto self = static_cast<MockQAbstractItemModel*>(selfVPtr);
string slotName = toStringFromQVariant(dosSlotNameVariant);
if (slotName == "name") {
@ -133,21 +144,22 @@ void MockQAbstractListModel::onSlotCalled(void *selfVPtr, DosQVariant *dosSlotNa
}
}
void MockQAbstractListModel::onRowCountCalled(void *selfVPtr, const DosQModelIndex *index, int *result)
void MockQAbstractItemModel::onRowCountCalled(void *selfVPtr, const DosQModelIndex *index, int *result)
{
auto self = static_cast<MockQAbstractListModel*>(selfVPtr);
auto self = static_cast<MockQAbstractItemModel*>(selfVPtr);
*result = self->m_names.size();
}
void MockQAbstractListModel::onColumnCountCalled(void *selfVPtr, const DosQModelIndex *index, int *result)
void MockQAbstractItemModel::onColumnCountCalled(void *selfVPtr, const DosQModelIndex *index, int *result)
{
auto self = static_cast<MockQAbstractListModel*>(selfVPtr);
auto self = static_cast<MockQAbstractItemModel*>(selfVPtr);
Q_UNUSED(self)
*result = 1;
}
void MockQAbstractListModel::onDataCalled(void *selfVPtr, const DosQModelIndex *index, int role, DosQVariant *result)
void MockQAbstractItemModel::onDataCalled(void *selfVPtr, const DosQModelIndex *index, int role, DosQVariant *result)
{
auto self = static_cast<MockQAbstractListModel*>(selfVPtr);
auto self = static_cast<MockQAbstractItemModel*>(selfVPtr);
if (!dos_qmodelindex_isValid(index))
return;
@ -161,9 +173,9 @@ void MockQAbstractListModel::onDataCalled(void *selfVPtr, const DosQModelIndex *
dos_qvariant_setString(result, self->m_names[row].c_str());
}
void MockQAbstractListModel::onSetDataCalled(void *selfVPtr, const DosQModelIndex *index, const DosQVariant *value, int role, bool *result)
void MockQAbstractItemModel::onSetDataCalled(void *selfVPtr, const DosQModelIndex *index, const DosQVariant *value, int role, bool *result)
{
auto self = static_cast<MockQAbstractListModel*>(selfVPtr);
auto self = static_cast<MockQAbstractItemModel*>(selfVPtr);
*result = false;
if (!dos_qmodelindex_isValid(index))
@ -176,22 +188,37 @@ void MockQAbstractListModel::onSetDataCalled(void *selfVPtr, const DosQModelInde
return;
self->m_names[row] = toStringFromQVariant(value);
dos_qabstractlistmodel_dataChanged(self->data(), index, index, 0, 0);
dos_qabstractitemmodel_dataChanged(self->data(), index, index, 0, 0);
*result = true;
}
void MockQAbstractListModel::onRoleNamesCalled(void *selfVPtr, DosQHashIntQByteArray *result)
void MockQAbstractItemModel::onRoleNamesCalled(void *selfVPtr, DosQHashIntQByteArray *result)
{
}
void MockQAbstractListModel::onFlagsCalled(void *selfVPtr, const DosQModelIndex *index, int *result)
void MockQAbstractItemModel::onFlagsCalled(void *selfVPtr, const DosQModelIndex *index, int *result)
{
}
void MockQAbstractListModel::onHeaderDataCalled(void *selfVPtr, int section, int orientation, int role, DosQVariant *result)
void MockQAbstractItemModel::onHeaderDataCalled(void *selfVPtr, int section, int orientation, int role, DosQVariant *result)
{
}
void MockQAbstractItemModel::onIndexCalled(void *selfVPtr, int row, int column, const DosQModelIndex *parent, DosQModelIndex *result)
{
auto self = static_cast<MockQAbstractItemModel*>(selfVPtr);
auto index = dos_qabstractitemmodel_createIndex(self->data(), row, column, 0);
dos_qmodelindex_assign(result, index);
dos_qmodelindex_delete(index);
}
void MockQAbstractItemModel::onParentCalled(void *selfVPtr, const DosQModelIndex *child, DosQModelIndex *result)
{
auto index = dos_qmodelindex_create();
dos_qmodelindex_assign(result, index);
dos_qmodelindex_delete(index);
}

6
test/MockQAbstractListModel.h → test/MockQAbstractItemModel.h
View File

@ -4,10 +4,10 @@
#include <vector>
#include <string>
class MockQAbstractListModel
class MockQAbstractItemModel
{
public:
MockQAbstractListModel();
MockQAbstractItemModel();
DosQMetaObject *metaObject();
DosQObject *data();
@ -28,6 +28,8 @@ private:
static void onRoleNamesCalled(void *selfVPtr, DosQHashIntQByteArray *result);
static void onFlagsCalled(void *selfVPtr, const DosQModelIndex *index, int *result);
static void onHeaderDataCalled(void *selfVPtr, int section, int orientation, int role, DosQVariant *result);
static void onIndexCalled(void *selfVPtr, int row, int column, const DosQModelIndex *parent, DosQModelIndex *result);
static void onParentCalled(void *selfVPtr, const DosQModelIndex *child, DosQModelIndex *result);
VoidPointer m_vptr;
std::string m_name;

32
test/MockQObject.cpp
View File

@ -17,18 +17,20 @@ namespace {
::SignalDefinition signalDefinitionArray[2];
// nameChanged
ParameterDefinition nameChanged[1];
nameChanged[0].name = "name";
nameChanged[0].metaType = QMetaType::QString;
signalDefinitionArray[0].name = "nameChanged";
signalDefinitionArray[0].parametersCount = 1;
int nameChanged[1];
nameChanged[0] = QMetaType::QString;
signalDefinitionArray[0].parametersMetaTypes = nameChanged;
signalDefinitionArray[0].parameters = nameChanged;
// arrayPropertyChanged
ParameterDefinition arrayPropertyChanged[1];
arrayPropertyChanged[0].metaType = QMetaType::QVariantList;
arrayPropertyChanged[0].name = "arrayProperty";
signalDefinitionArray[1].name = "arrayPropertyChanged";
signalDefinitionArray[1].parametersCount = 1;
int arrayPropertyChanged[1];
arrayPropertyChanged[0] = QMetaType::QVariantList;
signalDefinitionArray[1].parametersMetaTypes = arrayPropertyChanged;
signalDefinitionArray[1].parameters = arrayPropertyChanged;
::SignalDefinitions signalDefinitions;
signalDefinitions.count = 2;
@ -40,26 +42,28 @@ namespace {
slotDefinitionArray[0].name = "name";
slotDefinitionArray[0].returnMetaType = QMetaType::QString;
slotDefinitionArray[0].parametersCount = 0;
slotDefinitionArray[0].parametersMetaTypes = nullptr;
slotDefinitionArray[0].parameters = nullptr;
ParameterDefinition setNameParameters[1];
setNameParameters[0].metaType = QMetaType::QString;
setNameParameters[0].name = "name";
slotDefinitionArray[1].name = "setName";
slotDefinitionArray[1].returnMetaType = QMetaType::Void;
int setNameParameters[1];
setNameParameters[0] = QMetaType::QString;
slotDefinitionArray[1].parametersCount = 1;
slotDefinitionArray[1].parametersMetaTypes = setNameParameters;
slotDefinitionArray[1].parameters = setNameParameters;
slotDefinitionArray[2].name = "arrayProperty";
slotDefinitionArray[2].returnMetaType = QMetaType::QVariantList;
slotDefinitionArray[2].parametersCount = 0;
slotDefinitionArray[2].parametersMetaTypes = nullptr;
slotDefinitionArray[2].parameters = nullptr;
ParameterDefinition setArrayPropertyParameters[1];
setArrayPropertyParameters[0].metaType = QMetaType::QVariantList;
setArrayPropertyParameters[0].name = "arrayProperty";
slotDefinitionArray[3].name = "setArrayProperty";
slotDefinitionArray[3].returnMetaType = QMetaType::Void;
int setArrayPropertyParameters[1];
setArrayPropertyParameters[0] = QMetaType::QVariantList;
slotDefinitionArray[3].parametersCount = 1;
slotDefinitionArray[3].parametersMetaTypes = setArrayPropertyParameters;
slotDefinitionArray[3].parameters = setArrayPropertyParameters;
::SlotDefinitions slotDefinitions;
slotDefinitions.count = 4;

4
test/meson.build
View File

@ -1,5 +1,5 @@
test_dependencies = dependency('qt5', modules : ['Core', 'Widgets', 'Quick', 'Qml', 'Test'])
test_sources = 'test_dotherside.cpp'
test_dependencies = dependency('qt5', modules : ['Core', 'Gui', 'Widgets', 'Quick', 'Qml', 'Test'])
test_sources = ['test_dotherside.cpp', 'MockQAbstractItemModel.cpp', 'MockQObject.cpp']
test_resources = 'Resources.qrc'
test_include_directories = ['../lib/include', '../lib/include/Qt']
test_pch = '../pch/test_pch.h'

14
test/test_dotherside.cpp
View File

@ -19,10 +19,10 @@
#include <DOtherSide/DosQObject.h>
#include <DOtherSide/DosQMetaObject.h>
#include <DOtherSide/DosQObject.h>
#include <DOtherSide/DosQAbstractListModel.h>
#include <DOtherSide/DosQAbstractItemModel.h>
#include "MockQObject.h"
#include "MockQAbstractListModel.h"
#include "MockQAbstractItemModel.h"
using namespace std;
using namespace DOS;
@ -424,16 +424,16 @@ private:
};
/*
* Test QAbstractListModel
* Test QAbstractItemModel
*/
class TestQAbstractListModel : public QObject
class TestQAbstractItemModel : public QObject
{
Q_OBJECT
private slots:
void init()
{
testObject.reset(new MockQAbstractListModel());
testObject.reset(new MockQAbstractItemModel());
testObject->setObjectName("testObject");
testObject->setName("foo");
@ -516,7 +516,7 @@ private slots:
private:
QString value;
unique_ptr<MockQAbstractListModel> testObject;
unique_ptr<MockQAbstractItemModel> testObject;
unique_ptr<QQmlApplicationEngine> engine;
};
@ -697,7 +697,7 @@ int main(int argc, char *argv[])
success &= ExecuteGuiTest<TestQQmlApplicationEngine>(argc, argv);
success &= ExecuteGuiTest<TestQQmlContext>(argc, argv);
success &= ExecuteGuiTest<TestQObject>(argc, argv);
success &= ExecuteGuiTest<TestQAbstractListModel>(argc, argv);
success &= ExecuteGuiTest<TestQAbstractItemModel>(argc, argv);
success &= ExecuteGuiTest<TestQDeclarativeIntegration>(argc, argv);
success &= ExecuteGuiTest<TestQQuickView>(argc, argv);
return success ? 0 : 1;