168492376
/
qskinny
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

property WRITE accessors added to QskMetaInvokable

This commit is contained in:
Uwe Rathmann 2018-03-09 12:24:18 +01:00
parent 0e832e27f8
commit b788f7da2c
8 changed files with 193 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
playground/invoker/Invoker.cpp
View File

@ -4,25 +4,35 @@
*****************************************************************************/
#include "Invoker.h"
#include <QThread>
#include <QMetaProperty>
Invoker::Invoker( QObject* parent ):
QObject( parent )
{
}
void Invoker::addCallback( const QObject* object,
void Invoker::addFunctionCall( const QObject* object,
const QskMetaFunction& function )
{
m_callbacks.append( QskMetaCallback( object, function ) );
}
void Invoker::addCallback( const QObject* object,
void Invoker::addMethodCall( const QObject* object,
const char* methodName )
{
m_callbacks.append( QskMetaCallback( object, methodName ) );
}
void Invoker::addPropertyCall( const QObject* object,
const char* property )
{
const auto* mo = object->metaObject();
auto metaProperty = mo->property( mo->indexOfProperty( property ) );
m_callbacks.append( QskMetaCallback( object, metaProperty ) );
}
void Invoker::invoke( qreal realValue, int intValue,
Qt::ConnectionType connectionType )
{

12
playground/invoker/Invoker.h
View File

@ -17,9 +17,11 @@ class Invoker : public QObject
public:
Invoker( QObject* parent = nullptr );
void addCallback( const QskMetaFunction& );
void addCallback( const QObject*, const QskMetaFunction& );
void addCallback( const QObject*, const char* methodName );
void addFunctionCall( const QskMetaFunction& );
void addFunctionCall( const QObject*, const QskMetaFunction& );
void addMethodCall( const QObject*, const char* methodName );
void addPropertyCall( const QObject*, const char* property );
void invoke( qreal d, int i, Qt::ConnectionType );
@ -27,9 +29,9 @@ private:
QVector< QskMetaCallback > m_callbacks;
};
inline void Invoker::addCallback( const QskMetaFunction& function )
inline void Invoker::addFunctionCall( const QskMetaFunction& function )
{
addCallback( this, function );
addFunctionCall( this, function );
}
#endif

2
playground/invoker/invoker.pro
View File

@ -1,5 +1,7 @@
include( $${PWD}/../playground.pri )
QMAKE_MOC_OPTIONS += -nw # disable warning about missing READ
TARGET = invoker
HEADERS += \

91
playground/invoker/main.cpp
View File

@ -43,6 +43,10 @@ class MyObject : public QObject
{
Q_OBJECT
Q_PROPERTY( int number WRITE setNumber )
Q_PROPERTY( qreal value WRITE setValue )
Q_PROPERTY( QString valueString WRITE setValueString )
public:
MyObject( QObject* parent = nullptr ):
QObject( parent )
@ -54,6 +58,21 @@ public:
qDebug() << "invokable" << d << i;
}
void setNumber( int number )
{
qDebug() << "setNumber" << number;
}
void setValue( qreal value )
{
qDebug() << "setValue" << value;
}
void setValueString( const QString& s )
{
qDebug() << "setValueString" << s;
}
public Q_SLOTS:
void print0( double d, int i ) const
{
@ -97,46 +116,52 @@ public:
m_thread( new QThread( this ) )
{
#if 1
m_invoker.addCallback( m_object, "print0(double,int)" );
m_invoker.addCallback( m_object, "print1(double,int)" );
m_invoker.addCallback( m_object, SLOT(print2(int,double)) );
m_invoker.addCallback( m_object, "print3(double)" );
m_invoker.addCallback( m_object, "print4(int)" );
m_invoker.addCallback( m_object, "print4(int)" );
m_invoker.addCallback( m_object, "printS(QString)" );
m_invoker.addCallback( m_object, "printInvokable(double,int)" );
m_invoker.addPropertyCall( m_object, "number" );
m_invoker.addPropertyCall( m_object, "value" );
m_invoker.addPropertyCall( m_object, "valueString" );
#endif
#if 1
m_invoker.addMethodCall( m_object, "print0(double,int)" );
m_invoker.addMethodCall( m_object, "print1(double,int)" );
m_invoker.addMethodCall( m_object, SLOT(print2(int,double)) );
m_invoker.addMethodCall( m_object, "print3(double)" );
m_invoker.addMethodCall( m_object, "print4(int)" );
m_invoker.addMethodCall( m_object, "print4(int)" );
m_invoker.addMethodCall( m_object, "printS(QString)" );
m_invoker.addMethodCall( m_object, "printInvokable(double,int)" );
#endif
#if 1
auto f = [this]( int i, double d ) { qDebug() << i << d << ( ++m_num ); };
m_invoker.addCallback( m_object, &MyObject::print0 );
m_invoker.addCallback( m_object, &MyObject::print1 );
m_invoker.addCallback( QskMetaFunction() );
m_invoker.addCallback( debugNone1 );
m_invoker.addCallback( debugNone2 );
m_invoker.addCallback( debugValue );
m_invoker.addCallback( debugValueI1 );
m_invoker.addCallback( debugValueI2 );
m_invoker.addCallback( debugValueD );
m_invoker.addCallback( m_object, &MyObject::print0 );
m_invoker.addCallback( m_object, &MyObject::print1 );
m_invoker.addCallback( m_object, &MyObject::print2 );
m_invoker.addCallback( m_object, &MyObject::print3 );
m_invoker.addCallback( m_object, &MyObject::print4 );
m_invoker.addCallback( m_object, &MyObject::printS );
m_invoker.addCallback( m_object, []( double d, int i ) { qDebug() << d << i; } );
m_invoker.addFunctionCall( m_object, &MyObject::print0 );
m_invoker.addFunctionCall( m_object, &MyObject::print1 );
m_invoker.addFunctionCall( QskMetaFunction() );
m_invoker.addFunctionCall( debugNone1 );
m_invoker.addFunctionCall( debugNone2 );
m_invoker.addFunctionCall( debugValue );
m_invoker.addFunctionCall( debugValueI1 );
m_invoker.addFunctionCall( debugValueI2 );
m_invoker.addFunctionCall( debugValueD );
m_invoker.addFunctionCall( m_object, &MyObject::print0 );
m_invoker.addFunctionCall( m_object, &MyObject::print1 );
m_invoker.addFunctionCall( m_object, &MyObject::print2 );
m_invoker.addFunctionCall( m_object, &MyObject::print3 );
m_invoker.addFunctionCall( m_object, &MyObject::print4 );
m_invoker.addFunctionCall( m_object, &MyObject::printS );
m_invoker.addFunctionCall( m_object, []( double d, int i ) { qDebug() << d << i; } );
m_invoker.addCallback( m_object, f );
m_invoker.addCallback( m_object, fs );
m_invoker.addFunctionCall( m_object, f );
m_invoker.addFunctionCall( m_object, fs );
m_invoker.addCallback( m_object, []( double d ) { qDebug() << d; } );
m_invoker.addCallback( []() { qDebug() << "HERE"; } );
m_invoker.addCallback( []( int i, double d ) { qDebug() << i << d; } );
m_invoker.addCallback( []( int i ) { qDebug() << "I1" << i; } );
m_invoker.addCallback( []( int i ) { qDebug() << "I2" << i; } );
m_invoker.addCallback( []( double d ) { qDebug() << "V" << d; } );
m_invoker.addCallback( []( const double& d ) { qDebug() << "R" << d; } );
m_invoker.addFunctionCall( m_object, []( double d ) { qDebug() << d; } );
m_invoker.addFunctionCall( []() { qDebug() << "HERE"; } );
m_invoker.addFunctionCall( []( int i, double d ) { qDebug() << i << d; } );
m_invoker.addFunctionCall( []( int i ) { qDebug() << "I1" << i; } );
m_invoker.addFunctionCall( []( int i ) { qDebug() << "I2" << i; } );
m_invoker.addFunctionCall( []( double d ) { qDebug() << "V" << d; } );
m_invoker.addFunctionCall( []( const double& d ) { qDebug() << "R" << d; } );
#endif
}

9
src/common/QskMetaCallback.cpp
View File

@ -21,6 +21,15 @@ QskMetaCallback::QskMetaCallback( const QObject* object,
{
}
QskMetaCallback::QskMetaCallback( const QObject* object,
const QMetaProperty& property, Qt::ConnectionType connectionType ):
m_object( const_cast< QObject* >( object ) ),
m_invokable( property ),
m_hasObject( object != nullptr ),
m_connectionType( static_cast< ushort >( connectionType & 0x3 ) )
{
}
QskMetaCallback::QskMetaCallback( const QObject* object,
const QskMetaFunction& function, Qt::ConnectionType connectionType ):
m_object( const_cast< QObject* >( object ) ),

3
src/common/QskMetaCallback.h
View File

@ -23,6 +23,9 @@ public:
QskMetaCallback( const QObject*, const QMetaMethod&,
Qt::ConnectionType = Qt::AutoConnection );
QskMetaCallback( const QObject*, const QMetaProperty&,
Qt::ConnectionType = Qt::AutoConnection );
QskMetaCallback( const QObject*, const char* methodName,
Qt::ConnectionType = Qt::AutoConnection );

115
src/common/QskMetaInvokable.cpp
View File

@ -35,9 +35,32 @@ namespace
};
}
static void qskInvokeSetProperty( QObject* object,
const QMetaObject* metaObject, int propertyIndex,
void* args[], Qt::ConnectionType connectionType )
{
#if 1
if ( connectionType != Qt::DirectConnection )
return; // TODO ...
#endif
if ( propertyIndex >= 0 && object->metaObject() == metaObject )
{
int status = -1;
int flags = 0;
void *argv[] = { args[1], nullptr, &status, &flags };
#if 1
QMetaObject::metacall( object,
QMetaObject::WriteProperty, propertyIndex, argv );
#else
metaObject->d.static_metacall(object, QMetaObject::WriteProperty, idx, argv);
#endif
}
}
QskMetaInvokable::QskMetaInvokable( const QMetaMethod& method ):
m_methodData { method.enclosingMetaObject(), method.methodIndex() },
m_metaData { method.enclosingMetaObject(), method.methodIndex() },
m_type( MetaMethod )
{
}
@ -52,6 +75,12 @@ QskMetaInvokable::QskMetaInvokable( const QMetaObject* metaObject, const char* m
{
}
QskMetaInvokable::QskMetaInvokable( const QMetaProperty& property ):
m_metaData { property.enclosingMetaObject(), property.propertyIndex() },
m_type( MetaProperty )
{
}
QskMetaInvokable::QskMetaInvokable( const QskMetaFunction& function ):
m_functionData { function.functionCall() },
m_type( MetaFunction )
@ -65,9 +94,10 @@ QskMetaInvokable::QskMetaInvokable( const QskMetaInvokable& other ):
switch( m_type )
{
case MetaMethod:
case MetaProperty:
{
m_methodData.metaObject = other.m_methodData.metaObject;
m_methodData.methodIndex = other.m_methodData.methodIndex;
m_metaData.metaObject = other.m_metaData.metaObject;
m_metaData.index = other.m_metaData.index;
break;
}
@ -95,12 +125,13 @@ QskMetaInvokable& QskMetaInvokable::operator=( const QskMetaInvokable& other )
switch( other.m_type )
{
case MetaMethod:
case MetaProperty:
{
if ( m_type == MetaFunction )
Function::deref( m_functionData.functionCall );
m_methodData.metaObject = other.m_methodData.metaObject;
m_methodData.methodIndex = other.m_methodData.methodIndex;
m_metaData.metaObject = other.m_metaData.metaObject;
m_metaData.index = other.m_metaData.index;
break;
}
@ -127,20 +158,26 @@ QskMetaInvokable& QskMetaInvokable::operator=( const QskMetaInvokable& other )
bool QskMetaInvokable::operator==( const QskMetaInvokable& other ) const
{
if ( m_type == other.m_type )
if ( m_type != other.m_type )
return false;
switch( m_type )
{
if ( m_type == MetaMethod )
case MetaMethod:
case MetaProperty:
{
return ( m_methodData.metaObject == other.m_methodData.metaObject )
&& ( m_methodData.methodIndex == other.m_methodData.methodIndex );
return ( m_metaData.metaObject == other.m_metaData.metaObject )
&& ( m_metaData.index == other.m_metaData.index );
}
if ( m_type == MetaFunction )
case MetaFunction:
{
return m_functionData.functionCall == other.m_functionData.functionCall;
}
default:
{
return true;
}
}
return true;
}
bool QskMetaInvokable::isNull() const
@ -148,17 +185,18 @@ bool QskMetaInvokable::isNull() const
switch( m_type )
{
case MetaMethod:
case MetaProperty:
{
const auto& d = m_methodData;
if ( d.metaObject && ( d.methodIndex >= 0 )
&& ( d.methodIndex < d.metaObject->methodCount() ) )
{
return false;
}
const auto& d = m_metaData;
return true;
if ( d.metaObject == nullptr || d.index < 0 )
return true;
const int count = ( m_type == MetaMethod )
? d.metaObject->methodCount() : d.metaObject->propertyCount();
return d.index >= count;
}
case MetaFunction:
{
return m_functionData.functionCall == nullptr;
@ -199,6 +237,18 @@ QVector< int > QskMetaInvokable::parameterTypes() const
break;
}
case MetaProperty:
{
// should be doable without QMetaProperty. TODO ...
const auto property = QskMetaInvokable::property();
if ( property.isWritable() )
{
paramTypes.reserve( 1 );
paramTypes += property.userType();
}
break;
}
case MetaFunction:
{
auto types = function().parameterTypes();
@ -228,6 +278,7 @@ int QskMetaInvokable::returnType() const
{
return function().returnType();
}
case MetaProperty:
default:
{
return QMetaType::Void;
@ -237,12 +288,20 @@ int QskMetaInvokable::returnType() const
QMetaMethod QskMetaInvokable::method() const
{
if ( m_type == MetaMethod )
return m_methodData.metaObject->method( m_methodData.methodIndex );
if ( m_type == MetaMethod && m_metaData.metaObject )
return m_metaData.metaObject->method( m_metaData.index );
return QMetaMethod();
}
QMetaProperty QskMetaInvokable::property() const
{
if ( m_type == MetaProperty && m_metaData.metaObject )
return m_metaData.metaObject->property( m_metaData.index );
return QMetaProperty();
}
QskMetaFunction QskMetaInvokable::function() const
{
if ( m_type == MetaFunction && m_functionData.functionCall )
@ -264,8 +323,16 @@ void QskMetaInvokable::invoke( QObject* object, void* args[],
{
case MetaMethod:
{
QskMetaMethod::invoke( object, m_methodData.metaObject,
m_methodData.methodIndex, args, connectionType );
QskMetaMethod::invoke( object, m_metaData.metaObject,
m_metaData.index, args, connectionType );
break;
}
case MetaProperty:
{
qskInvokeSetProperty( object,
m_metaData.metaObject, m_metaData.index,
args, connectionType );
break;
}

14
src/common/QskMetaInvokable.h
View File

@ -16,6 +16,7 @@ template< typename T > class QVector;
class QskMetaFunction;
class QMetaObject;
class QMetaMethod;
class QMetaProperty;
class QObject;
class QSK_EXPORT QskMetaInvokable
@ -28,6 +29,9 @@ public:
// A QMetaMethod
MetaMethod,
// The WRITE accessor of a QMetaProperty
MetaProperty,
// A function pointer, for what Qt calls "functor based" callbacks
MetaFunction
};
@ -35,10 +39,13 @@ public:
QskMetaInvokable();
QskMetaInvokable( const QskMetaFunction& );
QskMetaInvokable( const QMetaMethod& );
QskMetaInvokable( const QObject*, const char* methodName );
QskMetaInvokable( const QMetaObject*, const char* methodName );
QskMetaInvokable( const QMetaProperty& );
QskMetaInvokable( const QskMetaInvokable& );
~QskMetaInvokable();
@ -62,6 +69,7 @@ public:
void reset();
QMetaMethod method() const;
QMetaProperty property() const;
QskMetaFunction function() const;
private:
@ -70,16 +78,16 @@ private:
void* functionCall;
};
struct MethodData
struct MetaData
{
const QMetaObject* metaObject;
int methodIndex;
int index; // method or property index
};
union
{
FunctionData m_functionData;
MethodData m_methodData;
MetaData m_metaData;
};
int m_type : 3;