QtCollider/QObjectProxy.h

   1 /************************************************************************
   2 *
   3 * Copyright 2010-2011 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 #ifndef QC_QOBJECT_PROXY_H
  23 #define QC_QOBJECT_PROXY_H
  24
  25 #include "Common.h"
  26
  27 #include <QObject>
  28 #include <QString>
  29 #include <QVariant>
  30 #include <QVector>
  31 #include <QEvent>
  32
  33 #include <PyrObject.h>
  34 #include <PyrSlot.h>
  35 #include <PyrSymbol.h>
  36
  37 #define qcProxyDebugMsg( LEVEL, MSG ) \
  38   qcDebugMsg( LEVEL, QString("[%1]: ").arg(_scClassName) + QString(MSG) )
  39
  40 struct VariantList;
  41
  42 class QObjectProxy;
  43 class QcSignalSpy;
  44 class QcMethodSignalHandler;
  45 class QcFunctionSignalHandler;
  46
  47 namespace QtCollider {
  48   struct SetPropertyEvent;
  49   class DestroyEvent;
  50   struct ScMethodCallEvent;
  51
  52   class ProxyToken : public QObject {
  53     Q_OBJECT
  54   public:
  55     ProxyToken( QObjectProxy *p, QObject *parent )
  56     : QObject(parent), proxy(p) { }
  57     QObjectProxy *proxy;
  58   };
  59 }
  60
  61 class QObjectProxy : public QObject
  62 {
  63   friend class QcMethodSignalHandler;
  64   friend class QcFunctionSignalHandler;
  65
  66   Q_OBJECT
  67
  68   public:
  69
  70     enum DestroyAction {
  71       DestroyProxy,
  72       DestroyObject,
  73       DestroyProxyAndObject,
  74     };
  75
  76     struct EventHandlerData
  77     {
  78       EventHandlerData() : type( QEvent::None ) {}
  79       int type;
  80       PyrSymbol *method;
  81       QtCollider::Synchronicity sync;
  82       bool enabled;
  83     };
  84
  85     QObjectProxy( QObject *qObject, PyrObject *scObject );
  86
  87     virtual ~QObjectProxy();
  88
  89     // Check if this is the right thread.
  90     // WARNING: must be called with language locked!
  91     bool compareThread();
  92
  93     // WARNING: must be called with language locked!
  94     void finalize() { _scObject = 0; }
  95
  96     inline QObject *object() const { return qObject; }
  97     inline PyrObject *scObject() const { return _scObject; }
  98
  99     // Lock for usage of object() outside Qt thread.
 100     inline void lock() { mutex.lock(); }
 101     inline void unlock() { mutex.unlock(); }
 102
 103     QString scClassName() const { return _scClassName; }
 104
 105     QList<PyrObject*> children( PyrSymbol *className );
 106     PyrObject *parent( PyrSymbol *className );
 107     virtual bool setParent( QObjectProxy *parent );
 108
 109     bool setProperty( const char *property, const QVariant & val );
 110     QVariant property( const char *property );
 111
 112     bool connectObject( const char *signal, PyrObject *object, Qt::ConnectionType );
 113     bool connectMethod( const char *signal, PyrSymbol *method, Qt::ConnectionType );
 114     bool disconnectObject( const char *signal, PyrObject *object );
 115     bool disconnectMethod( const char *signal, PyrSymbol *method);
 116     bool setEventHandler( int eventType, PyrSymbol *method, QtCollider::Synchronicity, bool enabled = true );
 117     bool setEventHandlerEnabled( int eventType, bool enabled );
 118
 119     // thread-safe if connection == queued
 120     bool invokeMethod( const char *method, PyrSlot *ret, PyrSlot *arg, Qt::ConnectionType );
 121
 122     void destroy( DestroyAction );
 123
 124     static QObjectProxy *fromObject( QObject * );
 125
 126   protected:
 127
 128     void invokeScMethod
 129       ( PyrSymbol *method, const QList<QVariant> & args = QList<QVariant>(),
 130         PyrSlot *result = 0, bool locked = false );
 131
 132     virtual bool eventFilter( QObject * watched, QEvent * event );
 133
 134     virtual void customEvent( QEvent * );
 135
 136     virtual bool filterEvent( QObject *, QEvent *, EventHandlerData &, QList<QVariant> & args );
 137
 138     bool invokeEventHandler( QEvent *e, EventHandlerData &, QList<QVariant> & args );
 139
 140     const QVector<EventHandlerData> & eventHandlers() { return _eventHandlers; }
 141
 142   private Q_SLOTS:
 143
 144     void invalidate();
 145
 146   private:
 147
 148     void scMethodCallEvent( QtCollider::ScMethodCallEvent * );
 149     bool setPropertyEvent( QtCollider::SetPropertyEvent * );
 150     bool destroyEvent( QtCollider::DestroyEvent * );
 151
 152     QObject *qObject;
 153     // NOTE: scObject is protected by the language lock. Should not use it without it!
 154     PyrObject *_scObject;
 155     // NOTE: for the reason above we extract SC class name at construction
 156     QString _scClassName;
 157
 158     QVector<EventHandlerData> _eventHandlers;
 159     QList<QcMethodSignalHandler*> methodSigHandlers;
 160     QList<QcFunctionSignalHandler*> funcSigHandlers;
 161     QMutex mutex;
 162 };
 163
 164 namespace QtCollider {
 165
 166 struct SetPropertyEvent : public QEvent
 167 {
 168   SetPropertyEvent() : QEvent( (QEvent::Type) QtCollider::Event_Proxy_SetProperty ) {}
 169   PyrSymbol *property;
 170   QVariant value;
 171 };
 172
 173 class DestroyEvent : public QEvent
 174 {
 175 public:
 176   DestroyEvent( QObjectProxy::DestroyAction act ) :
 177     QEvent( (QEvent::Type) QtCollider::Event_Proxy_Destroy ),
 178     _action( act )
 179   {}
 180   QObjectProxy::DestroyAction action() { return _action; }
 181 private:
 182   QObjectProxy::DestroyAction _action;
 183 };
 184
 185 struct ScMethodCallEvent : public QEvent
 186 {
 187   ScMethodCallEvent( PyrSymbol *m,
 188                      const QList<QVariant> &l = QList<QVariant>(),
 189                      bool b_locked = false )
 190   : QEvent( (QEvent::Type) QtCollider::Event_ScMethodCall ),
 191     method( m ),
 192     args( l ),
 193     locked( b_locked )
 194   {}
 195
 196   PyrSymbol *method;
 197   QList<QVariant> args;
 198   bool locked;
 199 };
 200
 201 } // namespace
 202
 203 Q_DECLARE_METATYPE( QObjectProxy * );
 204
 205 #endif //QC_QOBJECT_PROXY_H