QtCollider/primitives/prim_QObject.cpp

   1 /************************************************************************
   2 *
   3 * Copyright 2010-2012 Jakob Leben (jakob.leben@gmail.com)
   4 *
   5 * This file is part of SuperCollider Qt GUI.
   6 *
   7 * This program is free software: you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation, either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 *
  20 ************************************************************************/
  21
  22 #include "primitives.h"
  23 #include "../QObjectProxy.h"
  24 #include "../QcObjectFactory.h"
  25 #include "../QcApplication.h"
  26 #include "../Common.h"
  27 #include "../Slot.h"
  28
  29 #include <PyrObject.h>
  30 #include <PyrKernel.h>
  31 #include <GC.h>
  32 #include <SCBase.h>
  33
  34 #include <QMetaObject>
  35 #include <QMetaProperty>
  36 #include <QMetaMethod>
  37
  38 #define IS_OBJECT_NIL( a ) \
  39   IsNil( slotRawObject(a)->slots )
  40
  41 #define QOBJECT_FROM_SLOT( s ) \
  42   ((QObjectProxy*) slotRawPtr( slotRawObject( s )->slots ))
  43
  44 #define CLASS_NAME( slot ) \
  45   slotRawSymbol( &slotRawObject( slot )->classptr->name )->name
  46
  47 namespace QtCollider {
  48
  49 int QObject_Finalize( struct VMGlobals *, struct PyrObject * );
  50
  51 QC_LANG_PRIMITIVE( QObject_New, 2, PyrSlot *r, PyrSlot *a, VMGlobals *g )
  52 {
  53   PyrObject *scObject = slotRawObject( r );
  54   QString qtClassName = Slot::toString( a+0 );
  55
  56   qcSCObjectDebugMsg( 1, scObject, QString("CREATE: %2").arg(qtClassName) );
  57
  58   if( !QcApplication::compareThread() ) return QtCollider::wrongThreadError();
  59
  60   QcAbstractFactory *f = QtCollider::factories().value( qtClassName );
  61
  62   if( !f ) {
  63     qcErrorMsg( QString("Factory for class '%1' not found!").arg(qtClassName) );
  64     return errFailed;
  65   }
  66
  67   QObjectProxy *proxy = 0;
  68
  69   Variant arg[10];
  70
  71   PyrSlot *slotArg = a+1;
  72
  73   if( isKindOfSlot( slotArg, class_Array ) ) {
  74     PyrObject *array = slotRawObject( slotArg );
  75     PyrSlot *s = array->slots;
  76     int size = array->size;
  77     for( int i = 0; i<size && i<10; ++i, ++s ) {
  78       arg[i].setData( s );
  79     }
  80   }
  81   else {
  82     arg[0].setData( slotArg );
  83   }
  84
  85   proxy = f->newInstance( scObject, arg );
  86   if( !proxy ) return errFailed;
  87
  88   SetPtr( scObject->slots, proxy );
  89
  90   InstallFinalizer( g, scObject, 1, QObject_Finalize );
  91
  92   return errNone;
  93 }
  94
  95 QC_LANG_PRIMITIVE( QObject_Destroy, 0, PyrSlot *r, PyrSlot *a, VMGlobals *g )
  96 {
  97   qcSCObjectDebugMsg( 1, slotRawObject(r), "DESTROY" );
  98
  99   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 100
 101   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 102
 103   // Post the destruction event asynchronously;
 104   DestroyEvent *e = new DestroyEvent( QObjectProxy::DestroyObject );
 105   QApplication::postEvent( proxy, e );
 106
 107   return errNone;
 108 }
 109
 110 int QObject_Finalize( struct VMGlobals *, struct PyrObject *obj )
 111 {
 112   qcSCObjectDebugMsg( 1, obj, "FINALIZE" );
 113
 114   QObjectProxy *proxy = (QObjectProxy*) slotRawPtr( obj->slots );
 115
 116   // Invalidate proxy's SC object pointer directly.
 117   // Note that it is protected by language mutex;
 118   proxy->finalize();
 119
 120   // Post the destruction event asynchronously;
 121   DestroyEvent *e = new DestroyEvent( QObjectProxy::DestroyProxyAndObject );
 122   QApplication::postEvent( proxy, e );
 123
 124   return errNone;
 125 }
 126
 127 QC_LANG_PRIMITIVE( QObject_ManuallyFinalize, 0, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 128 {
 129   qcSCObjectDebugMsg( 1, slotRawObject(r), "MANUAL FINALIZE" );
 130
 131   // WARNING we assume that proxy's deletion will be deferred until any
 132   // language shutdown code using it will have been executed, so any
 133   // shutdown code is safe.
 134
 135   return QObject_Finalize( g, slotRawObject(r) );
 136 }
 137
 138 QC_LANG_PRIMITIVE( QObject_SetParent, 1, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 139 {
 140   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 141
 142   QObjectProxy *parent = Slot::toObjectProxy( a );
 143   if( !parent ) return errWrongType;
 144
 145   qcSCObjectDebugMsg( 1, slotRawObject(r), "SET PARENT" );
 146
 147   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 148
 149   bool ok = proxy->setParent( parent );
 150
 151   return ok ? errNone : errFailed;
 152 }
 153
 154 static void qcGetProperties( const QMetaObject *mo, PyrSlot *r, VMGlobals *g )
 155 {
 156   int count = mo->propertyCount();
 157
 158   PyrObject *array = newPyrArray( g->gc, count, 0, true );
 159   SetObject( r, array );
 160
 161   PyrSlot *s = array->slots;
 162   for( int i = 0; i < count; ++i, ++s ) {
 163     SetSymbol( s, getsym( mo->property(i).name() ) );
 164     array->size++;
 165   }
 166 }
 167
 168 static void qcGetMethods (
 169   const QMetaObject *mo,
 170   bool getPlain, bool getSignals, bool getSlots,
 171   PyrSlot *r, VMGlobals *g )
 172 {
 173   int count = mo->methodCount();
 174
 175   PyrObject *array = newPyrArray( g->gc, count, 0, true );
 176   SetObject( r, array );
 177
 178   PyrSlot *s = array->slots;
 179   for( int i = 0; i < count; ++i ) {
 180     QMetaMethod method = mo->method(i);
 181     switch( method.methodType() ) {
 182       case QMetaMethod::Method:
 183         if( !getPlain || (method.access() != QMetaMethod::Public) ) continue;
 184         break;
 185       case QMetaMethod::Signal:
 186         if( !getSignals ) continue;
 187         break;
 188       case QMetaMethod::Slot:
 189         if( !getSlots || (method.access() != QMetaMethod::Public) ) continue;
 190         break;
 191       default:
 192         continue;
 193     }
 194     Slot::setString( s, QString::fromLatin1( method.signature() ) );
 195     array->size++;
 196     g->gc->GCWrite( array, s );
 197     ++s;
 198   }
 199 }
 200
 201 QC_LANG_PRIMITIVE( QMetaObject_Properties, 0, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 202 {
 203   if( !QcApplication::compareThread() ) return QtCollider::wrongThreadError();
 204
 205   QString className = Slot::toString( slotRawObject(r)->slots+0 );
 206
 207   QcAbstractFactory *f = QtCollider::factories().value( className );
 208
 209   if( !f ) {
 210     qcErrorMsg( QString("Factory for class '%1' not found!").arg(className) );
 211     return errFailed;
 212   }
 213
 214   const QMetaObject *mo = f->metaObject();
 215   qcGetProperties( mo, r, g );
 216
 217   return errNone;
 218 }
 219
 220 QC_LANG_PRIMITIVE( QMetaObject_Methods, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 221 {
 222   if( !QcApplication::compareThread() ) return QtCollider::wrongThreadError();
 223
 224   QString className = Slot::toString(slotRawObject(r)->slots+0);
 225
 226   QcAbstractFactory *f = QtCollider::factories().value( className );
 227
 228   if( !f ) {
 229     qcErrorMsg( QString("Factory for class '%1' not found!").arg(className) );
 230     return errFailed;
 231   }
 232
 233   bool getPlain = IsTrue(a+0);
 234   bool getSignals = IsTrue(a+1);
 235   bool getSlots = IsTrue(a+2);
 236
 237   const QMetaObject *mo = f->metaObject();
 238   qcGetMethods( mo, getPlain, getSignals, getSlots, r, g );
 239
 240   return errNone;
 241 }
 242
 243 QC_LANG_PRIMITIVE( QObject_GetProperties, 0, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 244 {
 245   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 246   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 247
 248   QObject *obj = proxy->object();
 249   if( !obj ) {
 250     SetNil(r);
 251     return errNone;
 252   }
 253
 254   const QMetaObject *mo = obj->metaObject();
 255   qcGetProperties( mo, r, g );
 256
 257   return errNone;
 258 }
 259
 260 QC_LANG_PRIMITIVE( QObject_GetMethods, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 261 {
 262   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 263   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 264
 265   QObject *obj = proxy->object();
 266   if( !obj ) {
 267     SetNil(r);
 268     return errNone;
 269   }
 270
 271   bool getPlain = IsTrue(a+0);
 272   bool getSignals = IsTrue(a+1);
 273   bool getSlots = IsTrue(a+2);
 274
 275   const QMetaObject *mo = obj->metaObject();
 276   qcGetMethods( mo, getPlain, getSignals, getSlots, r, g );
 277
 278   return errNone;
 279 }
 280
 281 QC_LANG_PRIMITIVE( QObject_SetProperty, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 282 {
 283   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 284
 285   if( NotSym( a ) ) return errWrongType;
 286   PyrSymbol *property = slotRawSymbol( a );
 287   bool sync = IsTrue( a+2 );
 288
 289   qcSCObjectDebugMsg( 1, slotRawObject(r), QString("SET: %1").arg(property->name) );
 290
 291   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 292
 293   QVariant val = Slot::toVariant( a+1 );
 294
 295   if( sync ) {
 296     proxy->setProperty( property->name, val );
 297   } else {
 298     SetPropertyEvent *e = new SetPropertyEvent();
 299     e->property = property;
 300     e->value = val;
 301     QApplication::postEvent( proxy, e );
 302   }
 303
 304   return errNone;
 305 }
 306
 307 QC_LANG_PRIMITIVE( QObject_GetProperty, 1, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 308 {
 309   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 310
 311   if( NotSym(a) ) return errWrongType;
 312   PyrSymbol *symProp = slotRawSymbol( a );
 313
 314   qcSCObjectDebugMsg( 1, slotRawObject(r), QString("GET: %1").arg(symProp->name) );
 315
 316   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 317
 318   QVariant val = proxy->property( symProp->name );
 319   if( !val.isValid() ) {
 320     qcErrorMsg(QString("Failed to get the value of property '%1'").arg(symProp->name));
 321     return errFailed;
 322   }
 323
 324   if( Slot::setVariant(r, val) )
 325     return errNone;
 326   else
 327     return errFailed;
 328 }
 329
 330 QC_LANG_PRIMITIVE( QObject_SetEventHandler, 4, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 331 {
 332   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 333
 334   if( NotInt( a+0 ) || NotSym( a+1 ) ) return errWrongType;
 335   int eventType = Slot::toInt( a+0 );
 336   PyrSymbol *method = 0; slotSymbolVal( a+1, &method );
 337   Synchronicity sync = IsTrue( a+2 ) ? Synchronous : Asynchronous;
 338   bool enabled = IsTrue( a+3 );
 339
 340   qcSCObjectDebugMsg( 1, slotRawObject(r),
 341                       QString("SET EVENT HANDLER: type %1 -> %2 [%3, %4]")
 342                       .arg(eventType).arg(method->name)
 343                       .arg(sync == Synchronous ? "SYNC" : "ASYNC")
 344                       .arg(enabled ? "on" : "off") );
 345
 346   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 347
 348   bool ok = proxy->setEventHandler( eventType, method, sync, enabled );
 349
 350   return ok ? errNone : errFailed;
 351 }
 352
 353 QC_LANG_PRIMITIVE( QObject_SetEventHandlerEnabled, 2, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 354 {
 355   if( NotInt( a+0 ) ) return errWrongType;
 356   bool enabled = IsTrue( a+1 );
 357   if( !enabled && !IsFalse( a+1 ) ) return errWrongType;
 358   int type = Slot::toInt( a+0 );
 359
 360   qcSCObjectDebugMsg( 1, slotRawObject(r),
 361                       QString("SET EVENT HANDLER STATE: type %1 = %2")
 362                       .arg(type).arg(enabled ? "on" : "off") );
 363
 364   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 365
 366   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 367
 368   bool ok = proxy->setEventHandlerEnabled( type, enabled );
 369
 370   return ok ? errNone : errFailed;
 371 }
 372
 373 QC_LANG_PRIMITIVE( QObject_ConnectMethod, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 374 {
 375   QString signal = Slot::toString( a+0 );
 376   if( signal.isEmpty() || NotSym( a+1 ) ) return errWrongType;
 377   PyrSymbol *handler = 0; slotSymbolVal( a+1, &handler );
 378   Qt::ConnectionType ctype =
 379     Slot::toBool( a+2 ) ? Qt::DirectConnection : Qt::QueuedConnection;
 380
 381   qcSCObjectDebugMsg( 1, slotRawObject(r),
 382                       QString("CONNECT METHOD: %1 -> %2 [%3]").arg(signal).arg(handler->name)
 383                       .arg( IsTrue(a+2) ? "SYNC" : "ASYNC") );
 384
 385   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 386
 387   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 388
 389   bool ok = proxy->connectMethod( signal.toAscii().constData(), handler, ctype );
 390
 391   return ok ? errNone : errFailed;
 392 }
 393
 394 QC_LANG_PRIMITIVE( QObject_DisconnectMethod, 2, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 395 {
 396   QString signal = Slot::toString( a+0 );
 397   if( signal.isEmpty() || NotSym( a+1 ) ) return errWrongType;
 398   PyrSymbol *handler = 0; slotSymbolVal( a+1, &handler );
 399
 400   qcSCObjectDebugMsg( 1, slotRawObject(r),
 401                       QString("DISCONNECT METHOD: %1 -> %2").arg(signal).arg(handler->name) );
 402
 403   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 404
 405   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 406
 407   bool ok = proxy->disconnectMethod( signal.toAscii().constData(), handler );
 408
 409   return ok ? errNone : errFailed;
 410 }
 411
 412 QC_LANG_PRIMITIVE( QObject_ConnectObject, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 413 {
 414   QString signal = Slot::toString( a+0 );
 415   if( signal.isEmpty() || NotObj( a+1 ) ) return errWrongType;
 416   PyrObject *handlerObj = slotRawObject( a+1 );
 417   Qt::ConnectionType ctype =
 418     Slot::toBool( a+2 ) ? Qt::DirectConnection : Qt::QueuedConnection;
 419
 420   qcSCObjectDebugMsg( 1, slotRawObject(r),
 421                       QString("CONNECT OBJECT: %1 -> %2 [%3]")
 422                       .arg(signal)
 423                       .arg( slotRawSymbol( &handlerObj->classptr->name )->name )
 424                       .arg( IsTrue(a+2) ? "SYNC" : "ASYNC") );
 425
 426   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 427
 428   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 429
 430   bool ok = proxy->connectObject( signal.toAscii().constData(), handlerObj, ctype );
 431
 432   return ok ? errNone : errFailed;
 433 }
 434
 435 QC_LANG_PRIMITIVE( QObject_DisconnectObject, 2, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 436 {
 437   QString signal = Slot::toString( a+0 );
 438   if( signal.isEmpty() || NotObj( a+1 ) ) return errWrongType;
 439   PyrObject *handlerObj = slotRawObject( a+1 );
 440
 441   qcSCObjectDebugMsg( 1, slotRawObject(r),
 442                       QString("DISCONNECT OBJECT: %1").arg(signal) );
 443
 444   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 445
 446   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 447
 448   bool ok = proxy->disconnectObject( signal.toAscii().constData(), handlerObj );
 449
 450   return ok ? errNone : errFailed;
 451 }
 452
 453 QC_LANG_PRIMITIVE( QObject_ConnectSlot, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 454 {
 455   // Args: signal, receiver, slot
 456   if( !isKindOfSlot( a+1, class_QObject )
 457       || NotSym( a+0 ) || NotSym( a+2 ) ) return errWrongType;
 458
 459   PyrSymbol *symSig = slotRawSymbol( a+0 );
 460   PyrSymbol *symSlot = slotRawSymbol( a+2 );
 461   QObjectProxy *sndProxy = QOBJECT_FROM_SLOT( r );
 462   QObjectProxy *rcvProxy = QOBJECT_FROM_SLOT( a+1 );
 463
 464   qcSCObjectDebugMsg( 1, slotRawObject(r),
 465                       QString("CONNECT TO SLOT: %1 -> %2").arg(symSig->name).arg(symSlot->name) );
 466
 467   QString strSig = QString("2") + symSig->name;
 468   QString strSlot = QString("1") + symSlot->name;
 469
 470   sndProxy->lock();
 471   rcvProxy->lock();
 472   bool ok;
 473   if( !sndProxy->object() || !rcvProxy->object() ) {
 474     ok = true;
 475   }
 476   else {
 477     ok = QObject::connect( sndProxy->object(), strSig.toStdString().c_str(),
 478                            rcvProxy->object(), strSlot.toStdString().c_str() );
 479   }
 480   sndProxy->unlock();
 481   rcvProxy->unlock();
 482
 483   if (!ok)  {
 484     qcErrorMsg( QString("Failed to connect %1::%2 to %3::%4!\n")
 485                 .arg(sndProxy->scClassName()).arg(symSig->name)
 486                 .arg(rcvProxy->scClassName()).arg(symSlot->name)
 487               );
 488     return errFailed;
 489   }
 490
 491   return errNone;
 492 }
 493
 494 QC_LANG_PRIMITIVE( QObject_InvokeMethod, 3, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 495 {
 496   if( NotSym( a+0 ) ) return errWrongType;
 497
 498   PyrSymbol *method = slotRawSymbol( a+0 );
 499   PyrSlot *methodArgs = a+1;
 500   bool sync = !IsFalse( a+2 );
 501
 502   qcSCObjectDebugMsg( 1, slotRawObject(r),
 503                       QString("INVOKE: '%1' [%2]").arg(method->name).arg(sync ? "SYNC" : "ASYNC") );
 504
 505   QObjectProxy *proxy = QOBJECT_FROM_SLOT( r );
 506
 507   PyrSlot *retSlot;
 508   Qt::ConnectionType cType;
 509
 510   if( sync ) {
 511     if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 512     retSlot = r;
 513     cType = Qt::DirectConnection;
 514   }
 515   else {
 516     retSlot = 0;
 517     cType = Qt::QueuedConnection;
 518   }
 519
 520   bool ok = proxy->invokeMethod( method->name, retSlot, methodArgs, cType );
 521
 522   return ok ? errNone : errFailed;
 523 }
 524
 525 QC_LANG_PRIMITIVE( QObject_IsValid, 0, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 526 {
 527   // NOTE Though we could check validity without posting an event (by locking the proxy),
 528   // we post a sync event to maximize the chance that a DeferredDelete event issued earlier
 529   // can get processed by the object in question before it is checked for validity.
 530
 531   QObjectProxy *proxy = Slot::toObjectProxy( r );
 532
 533   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 534
 535   SetBool( r, proxy->object() != 0 );
 536
 537   return errNone;
 538 }
 539
 540 QC_LANG_PRIMITIVE( QObject_GetChildren, 1, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 541 {
 542   if( NotSym(a) && NotNil(a) ) return errWrongType;
 543
 544   QObjectProxy *proxy = Slot::toObjectProxy( r );
 545   PyrSymbol *className = IsSym( a ) ? slotRawSymbol( a ) : 0;
 546
 547   qcSCObjectDebugMsg( 1, slotRawObject(r),
 548                       QString("GET CHILDREN: of class '%1'")
 549                       .arg( className ? className->name : "QObject" ) );
 550
 551   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 552
 553   QList<PyrObject*> children = proxy->children( className );
 554
 555   int count = children.count();
 556   PyrObject *array = newPyrArray( g->gc, count, 0, true );
 557   SetObject( r, array );
 558
 559   PyrSlot *s = array->slots;
 560   Q_FOREACH( PyrObject *obj, children ) {
 561     SetObject( s, obj );
 562     ++array->size;
 563     g->gc->GCWrite( array, s );
 564     ++s;
 565   }
 566
 567   return errNone;
 568 }
 569
 570 QC_LANG_PRIMITIVE( QObject_GetParent, 1, PyrSlot *r, PyrSlot *a, VMGlobals *g )
 571 {
 572   if( NotSym(a) && NotNil(a) ) return errWrongType;
 573
 574   QObjectProxy *proxy = Slot::toObjectProxy( r );
 575   PyrSymbol *className = IsSym( a ) ? slotRawSymbol( a ) : 0;
 576
 577   qcSCObjectDebugMsg( 1, slotRawObject(r), QString("GET PARENT") );
 578
 579   if( !proxy->compareThread() ) return QtCollider::wrongThreadError();
 580
 581   PyrObject *parent = proxy->parent( className );
 582
 583   if( parent ) SetObject( r, parent );
 584   else SetNil( r );
 585
 586   return errNone;
 587 }
 588
 589 void defineQObjectPrimitives()
 590 {
 591   LangPrimitiveDefiner definer;
 592   definer.define<QObject_New>();
 593   definer.define<QObject_Destroy>();
 594   definer.define<QObject_ManuallyFinalize>();
 595   definer.define<QObject_SetParent>();
 596   definer.define<QMetaObject_Properties>();
 597   definer.define<QMetaObject_Methods>();
 598   definer.define<QObject_GetProperties>();
 599   definer.define<QObject_GetMethods>();
 600   definer.define<QObject_SetProperty>();
 601   definer.define<QObject_GetProperty>();
 602   definer.define<QObject_SetEventHandler>();
 603   definer.define<QObject_SetEventHandlerEnabled>();
 604   definer.define<QObject_ConnectMethod>();
 605   definer.define<QObject_DisconnectMethod>();
 606   definer.define<QObject_ConnectObject>();
 607   definer.define<QObject_DisconnectObject>();
 608   definer.define<QObject_ConnectSlot>();
 609   definer.define<QObject_InvokeMethod>();
 610   definer.define<QObject_IsValid>();
 611   definer.define<QObject_GetChildren>();
 612   definer.define<QObject_GetParent>();
 613 }
 614
 615 }  // namespace QtCollider