QSkinny 0.8.0
C++/Qt UI toolkit
Loading...
Searching...
No Matches
QskMetaInvokable.cpp
1/******************************************************************************
2 * QSkinny - Copyright (C) The authors
3 * SPDX-License-Identifier: BSD-3-Clause
4 *****************************************************************************/
5
6#include "QskMetaInvokable.h"
7#include "QskMetaFunction.h"
8#include "QskInternalMacros.h"
9
10#include <qmetaobject.h>
11#include <qobject.h>
12#include <qcoreapplication.h>
13#include <qthread.h>
14
15#if QT_CONFIG(thread)
16#include <qsemaphore.h>
17#endif
18
19QSK_QT_PRIVATE_BEGIN
20#include <private/qobject_p.h>
21QSK_QT_PRIVATE_END
22
23static void qskRegisterMetaInvokable()
24{
25 qRegisterMetaType< QskMetaInvokable >();
26}
27
28Q_CONSTRUCTOR_FUNCTION( qskRegisterMetaInvokable )
29
30namespace
31{
32 using CallFunction = QObjectPrivate::StaticMetaCallFunction;
33
34 class Function : public QskMetaFunction
35 {
36 public:
37 inline Function( void* functionCall )
38 : QskMetaFunction( static_cast< FunctionCall* >( functionCall ) )
39 {
40 }
41
42 static inline void ref( void* functionCall )
43 {
44 if ( functionCall )
45 static_cast< FunctionCall* >( functionCall )->ref();
46 }
47
48 static inline void deref( void* functionCall )
49 {
50 if ( functionCall )
51 static_cast< FunctionCall* >( functionCall )->destroyIfLastRef();
52 }
53 };
54
55 class MetaCallEvent final : public QMetaCallEvent
56 {
57 public:
58 MetaCallEvent( QMetaObject::Call call, const QMetaObject* metaObject,
59 ushort offset, ushort index, void* args[], QSemaphore* semaphore )
60 : QMetaCallEvent( offset, index,
61 metaObject->d.static_metacall, nullptr, -1, args, semaphore )
62 , m_call( call )
63 , m_callFunction( metaObject->d.static_metacall )
64 , m_index( index )
65 {
66 }
67
68 MetaCallEvent( QMetaObject::Call call, const QMetaObject* metaObject,
69 ushort offset, ushort index, int argc )
70 : QMetaCallEvent( offset, index,
71 metaObject->d.static_metacall, nullptr, -1, argc )
72 , m_call( call )
73 , m_callFunction( metaObject->d.static_metacall )
74 , m_index( index )
75 {
76 }
77
78 void placeMetaCall( QObject* object ) override
79 {
80 m_callFunction( object, m_call, m_index, args() );
81 }
82
83 private:
84 const QMetaObject::Call m_call;
85
86 // as those members from QMetaCallEvent are not accessible
87 CallFunction m_callFunction;
88 const ushort m_index;
89 };
90}
91
92QMetaMethod qskMetaMethod( const QObject* object, const char* methodName )
93{
94 return object ? qskMetaMethod( object->metaObject(), methodName ) : QMetaMethod();
95}
96
97QMetaMethod qskMetaMethod( const QMetaObject* metaObject, const char* methodName )
98{
99 if ( metaObject == nullptr || methodName == nullptr )
100 return QMetaMethod();
101
102 constexpr char signalIndicator = '0' + QSIGNAL_CODE;
103 constexpr char slotIndicator = '0' + QSLOT_CODE;
104
105 int index = -1;
106
107 if ( methodName[ 0 ] == signalIndicator )
108 {
109 auto signature = QMetaObject::normalizedSignature( methodName + 1 );
110 index = metaObject->indexOfSignal( signature );
111 }
112 else if ( methodName[ 0 ] == slotIndicator )
113 {
114 auto signature = QMetaObject::normalizedSignature( methodName + 1 );
115 index = metaObject->indexOfSlot( signature );
116 }
117 else
118 {
119 auto signature = QMetaObject::normalizedSignature( methodName );
120 index = metaObject->indexOfMethod( signature );
121 }
122
123 return ( index >= 0 ) ? metaObject->method( index ) : QMetaMethod();
124}
125
126QMetaMethod qskNotifySignal( const QObject* object, const char* propertyName )
127{
128 return object ? qskNotifySignal( object->metaObject(), propertyName ) : QMetaMethod();
129}
130
131QMetaMethod qskNotifySignal( const QMetaObject* metaObject, const char* propertyName )
132{
133 if ( metaObject == nullptr || propertyName == nullptr )
134 return QMetaMethod();
135
136 const int propertyIndex = metaObject->indexOfProperty( propertyName );
137 if ( propertyIndex )
138 {
139 const auto property = metaObject->property( propertyIndex );
140 return property.notifySignal();
141 }
142
143 return QMetaMethod();
144}
145
146static void qskInvokeMetaCall(
147 QObject* object, const QMetaObject* metaObject,
148 QMetaObject::Call call, ushort offset, ushort index, void* args[],
149 Qt::ConnectionType connectionType )
150{
151 QPointer< QObject > receiver( object );
152
153 int invokeType = connectionType & 0x3;
154
155 if ( invokeType == Qt::AutoConnection )
156 {
157 invokeType = ( object && object->thread() != QThread::currentThread() )
158 ? Qt::QueuedConnection : Qt::DirectConnection;
159 }
160
161 switch ( invokeType )
162 {
163 case Qt::DirectConnection:
164 {
165 if ( receiver.isNull() )
166 {
167#if 1
168 // do we really always need an object, what about Q_GADGET ???
169 return;
170#endif
171 }
172
173 /*
174 QMetaObject::metacall seems to be made for situations we don't have.
175 Need to dive deeper into the Qt code to be 100% sure TODO ...
176 */
177
178 metaObject->d.static_metacall( receiver, call, index, args );
179 break;
180 }
181 case Qt::BlockingQueuedConnection:
182 {
183 if ( receiver.isNull() ||
184 ( receiver->thread() == QThread::currentThread() ) )
185 {
186 // We would end up in a deadlock, better do nothing
187 return;
188 }
189
190#if QT_CONFIG(thread)
191 QSemaphore semaphore;
192
193 auto event = new MetaCallEvent( call, metaObject,
194 offset, index, args, &semaphore );
195
196#else
197 auto event = new MetaCallEvent( call, metaObject,
198 offset, index, args, nullptr );
199#endif
200
201 QCoreApplication::postEvent( receiver, event );
202
203#if QT_CONFIG(thread)
204 semaphore.acquire();
205#endif
206
207 break;
208 }
209 case Qt::QueuedConnection:
210 {
211 if ( receiver == nullptr )
212 return;
213
214 MetaCallEvent* event = nullptr;
215
216 if ( call == QMetaObject::InvokeMetaMethod )
217 {
218#if 1
219 // should be doable without QMetaMethod. TODO ...
220 const auto method = metaObject->method( offset + index );
221#endif
222 const int argc = method.parameterCount() + 1;
223
224 event = new MetaCallEvent( call, metaObject, offset, index, argc );
225
226 /*
227 The first one is the return type, one that is always
228 invalid for Queued Connections.
229 */
230
231 auto types = event->types();
232 auto arguments = event->args();
233
234#if QT_VERSION >= QT_VERSION_CHECK( 6, 0, 0 )
235 types[0] = QMetaType();
236 arguments[ 0 ] = nullptr;
237#else
238 types[0] = 0;
239 arguments[ 0 ] = nullptr;
240#endif
241 for ( int i = 1; i < argc; i++ )
242 {
243 if ( args[ i ] == nullptr )
244 {
245 Q_ASSERT( args[ i ] != nullptr );
246 receiver = nullptr;
247 break;
248 }
249
250 const auto type = method.parameterType( i - 1 );
251 const auto arg = args[ i ];
252
253#if QT_VERSION >= QT_VERSION_CHECK( 6, 0, 0 )
254 types[ i ] = QMetaType( type );
255 arguments[ i ] = QMetaType( type ).create( arg );
256#else
257 types[ i ] = type;
258 arguments[ i ] = QMetaType::create( type, arg );
259#endif
260 }
261 }
262 else
263 {
264 // should be doable without QMetaMethod. TODO ...
265 const auto property = metaObject->property( offset + index );
266
267 event = new MetaCallEvent( call, metaObject, offset, index, 1 );
268
269 const auto type = property.userType();
270 const auto arg = args[ 0 ];
271
272#if QT_VERSION >= QT_VERSION_CHECK( 6, 0, 0 )
273 event->types()[0] = QMetaType( type );
274 event->args()[ 0 ] = QMetaType( type ).create( arg );
275#else
276 event->types()[0] = type;
277 event->args()[ 0 ] = QMetaType::create( type, arg );
278#endif
279 }
280
281 if ( receiver )
282 QCoreApplication::postEvent( receiver, event );
283 else
284 delete event;
285
286 break;
287 }
288 }
289}
290
291void qskInvokeMetaPropertyWrite( QObject* context, const QMetaProperty& property,
292 void* args[], Qt::ConnectionType connectionType )
293{
294 qskInvokeMetaPropertyWrite( context, property.enclosingMetaObject(),
295 property.propertyIndex(), args, connectionType );
296}
297
298void qskInvokeMetaPropertyWrite( QObject* context, const QMetaObject* metaObject,
299 int propertyIndex, void* args[], Qt::ConnectionType connectionType )
300{
301 // check for is writable ???
302
303 if ( metaObject && ( propertyIndex >= 0 ) &&
304 ( propertyIndex < metaObject->propertyCount() ) )
305 {
306 const auto offset = metaObject->propertyOffset();
307 const auto index = propertyIndex - offset;
308
309 qskInvokeMetaCall( context, metaObject, QMetaObject::WriteProperty,
310 offset, index, args + 1, connectionType );
311 }
312}
313
314void qskInvokeMetaMethod( QObject* object,
315 const QMetaMethod& method, void* args[],
316 Qt::ConnectionType connectionType )
317{
318 qskInvokeMetaMethod( object, method.enclosingMetaObject(),
319 method.methodIndex(), args, connectionType );
320}
321
322void qskInvokeMetaMethod( QObject* object,
323 const QMetaObject* metaObject, int methodIndex, void* args[],
324 Qt::ConnectionType connectionType )
325{
326 if ( metaObject && ( methodIndex >= 0 ) &&
327 ( methodIndex < metaObject->methodCount() ) )
328 {
329 const auto offset = metaObject->methodOffset();
330 const auto index = methodIndex - offset;
331
332 qskInvokeMetaCall( object, metaObject, QMetaObject::InvokeMetaMethod,
333 offset, index, args, connectionType );
334 }
335}
336
337QskMetaInvokable::QskMetaInvokable( const QMetaMethod& method )
338 : m_metaData{ method.enclosingMetaObject(), method.methodIndex() }
339 , m_type( MetaMethod )
340{
341}
342
343QskMetaInvokable::QskMetaInvokable( const QObject* object, const char* methodName )
344 : QskMetaInvokable( qskMetaMethod( object, methodName ) )
345{
346}
347
348QskMetaInvokable::QskMetaInvokable( const QMetaObject* metaObject, const char* methodName )
349 : QskMetaInvokable( qskMetaMethod( metaObject, methodName ) )
350{
351}
352
353QskMetaInvokable::QskMetaInvokable( const QMetaProperty& property )
354 : m_metaData{ property.enclosingMetaObject(), property.propertyIndex() }
355 , m_type( MetaProperty )
356{
357}
358
359QskMetaInvokable::QskMetaInvokable( const QskMetaFunction& function )
360 : m_functionData{ function.functionCall() }
361 , m_type( MetaFunction )
362{
363 Function::ref( m_functionData.functionCall );
364}
365
366QskMetaInvokable::QskMetaInvokable( const QskMetaInvokable& other )
367 : m_type( other.m_type )
368{
369 switch ( m_type )
370 {
371 case MetaMethod:
372 case MetaProperty:
373 {
374 m_metaData.metaObject = other.m_metaData.metaObject;
375 m_metaData.index = other.m_metaData.index;
376
377 break;
378 }
379 case MetaFunction:
380 {
381 m_functionData.functionCall = other.m_functionData.functionCall;
382 Function::ref( m_functionData.functionCall );
383
384 break;
385 }
386
387 default:
388 break;
389 }
390}
391
392QskMetaInvokable::~QskMetaInvokable()
393{
394 if ( m_type == MetaFunction )
395 Function::deref( m_functionData.functionCall );
396}
397
398QskMetaInvokable& QskMetaInvokable::operator=( const QskMetaInvokable& other )
399{
400 switch ( other.m_type )
401 {
402 case MetaMethod:
403 case MetaProperty:
404 {
405 if ( m_type == MetaFunction )
406 Function::deref( m_functionData.functionCall );
407
408 m_metaData.metaObject = other.m_metaData.metaObject;
409 m_metaData.index = other.m_metaData.index;
410
411 break;
412 }
413 case MetaFunction:
414 {
415 if ( m_type == MetaFunction )
416 Function::deref( m_functionData.functionCall );
417
418 m_functionData.functionCall = other.m_functionData.functionCall;
419 Function::ref( m_functionData.functionCall );
420
421 break;
422 }
423
424 default:
425 if ( m_type == MetaFunction )
426 Function::deref( m_functionData.functionCall );
427 }
428
429 m_type = other.m_type;
430
431 return *this;
432}
433
434bool QskMetaInvokable::operator==( const QskMetaInvokable& other ) const
435{
436 if ( m_type != other.m_type )
437 return false;
438
439 switch ( m_type )
440 {
441 case MetaMethod:
442 case MetaProperty:
443 {
444 return ( m_metaData.metaObject == other.m_metaData.metaObject ) &&
445 ( m_metaData.index == other.m_metaData.index );
446 }
447 case MetaFunction:
448 {
449 return m_functionData.functionCall == other.m_functionData.functionCall;
450 }
451 default:
452 {
453 return true;
454 }
455 }
456}
457
458bool QskMetaInvokable::isNull() const
459{
460 switch ( m_type )
461 {
462 case MetaMethod:
463 case MetaProperty:
464 {
465 const auto& d = m_metaData;
466
467 if ( d.metaObject == nullptr || d.index < 0 )
468 return true;
469
470 const int count = ( m_type == MetaMethod )
471 ? d.metaObject->methodCount() : d.metaObject->propertyCount();
472
473 return d.index >= count;
474 }
475 case MetaFunction:
476 {
477 return m_functionData.functionCall == nullptr;
478 }
479
480 default:
481 return true;
482 }
483}
484
485void QskMetaInvokable::reset()
486{
487 if ( m_type == MetaFunction )
488 Function::deref( m_functionData.functionCall );
489
490 m_type = Invalid;
491}
492
493int QskMetaInvokable::parameterCount() const
494{
495 switch ( m_type )
496 {
497 case MetaMethod:
498 {
499 // should be doable without QMetaMethod. TODO ...
500 const auto method = QskMetaInvokable::method();
501 return method.parameterCount();
502 }
503 case MetaProperty:
504 {
505 return 1;
506 }
507 case MetaFunction:
508 {
509 return function().parameterCount();
510 }
511 default:
512 break;
513 }
514
515 return 0;
516}
517
518int QskMetaInvokable::parameterType( int index ) const
519{
520 switch ( m_type )
521 {
522 case MetaMethod:
523 {
524 const auto method = QskMetaInvokable::method();
525 return method.parameterType( index );
526 }
527 case MetaProperty:
528 {
529 const auto property = QskMetaInvokable::property();
530 return property.userType();
531 }
532 case MetaFunction:
533 {
534 auto types = function().parameterTypes();
535 return types[ index ];
536 }
537 default:
538 {
539 return QMetaType::UnknownType;
540 }
541 }
542}
543
544int QskMetaInvokable::returnType() const
545{
546 switch ( m_type )
547 {
548 case MetaMethod:
549 {
550 return method().returnType();
551 }
552 case MetaFunction:
553 {
554 return function().returnType();
555 }
556 case MetaProperty:
557 {
558 return QMetaType::Void;
559 }
560 default:
561 {
562 return QMetaType::Void;
563 }
564 }
565}
566
567QByteArray QskMetaInvokable::name() const
568{
569 switch ( m_type )
570 {
571 case MetaMethod:
572 {
573 return method().name();
574 }
575 case MetaProperty:
576 {
577 return property().name();
578 }
579 case MetaFunction:
580 {
581 // what to do here ???
582 return QByteArray();
583 }
584 default:
585 {
586 return QByteArray();
587 }
588 }
589}
590
591QMetaMethod QskMetaInvokable::method() const
592{
593 if ( m_type == MetaMethod && m_metaData.metaObject )
594 return m_metaData.metaObject->method( m_metaData.index );
595
596 return QMetaMethod();
597}
598
599QMetaProperty QskMetaInvokable::property() const
600{
601 if ( m_type == MetaProperty && m_metaData.metaObject )
602 return m_metaData.metaObject->property( m_metaData.index );
603
604 return QMetaProperty();
605}
606
607QskMetaFunction QskMetaInvokable::function() const
608{
609 if ( m_type == MetaFunction && m_functionData.functionCall )
610 {
611 Function function( m_functionData.functionCall );
612 return *static_cast< QskMetaFunction* >( &function );
613 }
614
615 return QskMetaFunction();
616}
617
618void QskMetaInvokable::invoke( QObject* object, void* args[],
619 Qt::ConnectionType connectionType )
620{
621 if ( isNull() )
622 return;
623
624 switch ( m_type )
625 {
626 case MetaMethod:
627 {
628 qskInvokeMetaMethod( object, m_metaData.metaObject,
629 m_metaData.index, args, connectionType );
630
631 break;
632 }
633 case MetaProperty:
634 {
635 qskInvokeMetaPropertyWrite(
636 object, m_metaData.metaObject, m_metaData.index, args, connectionType );
637
638 break;
639 }
640 case MetaFunction:
641 {
642 if ( m_functionData.functionCall )
643 {
644 Function function( m_functionData.functionCall );
645 function.invoke( object, args, connectionType );
646 }
647
648 break;
649 }
650
651 default:
652 break;
653 }
654}