QtCollider/QWidgetProxy.cpp

   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 #include "QWidgetProxy.h"
  23 #include "painting.h"
  24 #include "Common.h"
  25
  26 #include <QApplication>
  27 #include <QLayout>
  28 #include <QMouseEvent>
  29 #include <QKeyEvent>
  30 #include <QPainter>
  31 #include <QFontMetrics>
  32 #include <QUrl>
  33
  34 using namespace QtCollider;
  35
  36 QAtomicInt QWidgetProxy::_globalEventMask = 0;
  37
  38 QWidgetProxy::QWidgetProxy( QWidget *w, PyrObject *po )
  39 : QObjectProxy( w, po ), _keyEventWidget( w ), _mouseEventWidget( w )
  40 { }
  41
  42 void QWidgetProxy::setKeyEventWidget( QWidget *w )
  43 {
  44   if( w == 0 || w == _keyEventWidget ) return;
  45
  46   QWidget *me = widget();
  47
  48   if( _keyEventWidget != me )
  49     _keyEventWidget->removeEventFilter( this );
  50
  51   _keyEventWidget = w;
  52
  53   if( _keyEventWidget != me ) {
  54     _keyEventWidget->installEventFilter( this );
  55   }
  56 }
  57
  58 void QWidgetProxy::setMouseEventWidget( QWidget *w )
  59 {
  60   if( w == 0 || w == _mouseEventWidget ) return;
  61
  62   QWidget *me = widget();
  63
  64   if( _mouseEventWidget != me )
  65     _mouseEventWidget->removeEventFilter( this );
  66
  67   _mouseEventWidget = w;
  68
  69   if( _mouseEventWidget != me ) {
  70     _mouseEventWidget->installEventFilter( this );
  71   }
  72 }
  73
  74 bool QWidgetProxy::alwaysOnTop()
  75 {
  76   QWidget *w = widget();
  77   if(!w) return false;
  78
  79   Qt::WindowFlags flags = w->windowFlags();
  80   if( flags & Qt::Window && flags & Qt::WindowStaysOnTopHint ) return true;
  81   else return false;
  82 }
  83
  84 void QWidgetProxy::refresh() {
  85   QWidget *w = widget();
  86   if( w ) sendRefreshEventRecursive( w );
  87 }
  88
  89 void QWidgetProxy::setLayout ( QObjectProxy *layoutProxy ) {
  90
  91   QWidget *w = widget();
  92   QLayout *l = qobject_cast<QLayout*>( layoutProxy->object() );
  93   if( !w || !l ) return;
  94
  95   QLayout *exLayout = w->layout();
  96   if( exLayout != l ) {
  97     if( exLayout != 0 ) {
  98       qcDebugMsg( 2, QString("Deleting old layout.") );
  99       delete exLayout;
 100     }
 101     qcDebugMsg( 2, QString("Setting layout.") );
 102     w->setLayout( l );
 103     l->activate();
 104   }
 105   else {
 106     qcDebugMsg( 2, QString("Layout same as existing. Will do nothing.") );
 107   }
 108 }
 109
 110 bool QWidgetProxy::setParent( QObjectProxy *parentProxy )
 111 {
 112   QObject *parent = parentProxy->object();
 113   if( !parent || !widget() ) return true;
 114
 115   if( parent->isWidgetType() ) {
 116     QWidget *pw = qobject_cast<QWidget*>(parent);
 117     bool ok = pw->metaObject()->invokeMethod( pw, "addChild", Q_ARG( QWidget*, widget() ) );
 118     if( !ok ) widget()->setParent( pw );
 119     return true;
 120   }
 121   return false;
 122 }
 123
 124 void QWidgetProxy::customEvent( QEvent *e )
 125 {
 126   int type = e->type();
 127   switch( type ) {
 128     case QtCollider::Event_Proxy_BringFront:
 129       bringFrontEvent();
 130       return;
 131     case QtCollider::Event_Proxy_SetFocus:
 132       setFocusEvent( static_cast<SetFocusEvent*>(e) );
 133       return;
 134     case QtCollider::Event_Proxy_SetAlwaysOnTop:
 135       setAlwaysOnTopEvent( static_cast<SetAlwaysOnTopEvent*>(e) );
 136       return;
 137     case QtCollider::Event_Proxy_StartDrag:
 138       startDragEvent( static_cast<StartDragEvent*>(e) );
 139       return;
 140     default:
 141       QObjectProxy::customEvent(e);
 142   }
 143 }
 144
 145 void QWidgetProxy::bringFrontEvent() {
 146   QWidget *w = widget();
 147   if( !w ) return;
 148
 149   w->setWindowState( w->windowState() & ~Qt::WindowMinimized
 150                                       | Qt::WindowActive );
 151   w->show();
 152   w->raise();
 153
 154   return;
 155 }
 156
 157 void QWidgetProxy::setFocusEvent( QtCollider::SetFocusEvent *e ) {
 158   if( !widget() ) return;
 159
 160   if( e->focus )
 161     widget()->setFocus( Qt::OtherFocusReason );
 162   else
 163     widget()->clearFocus();
 164 }
 165
 166 void QWidgetProxy::setAlwaysOnTopEvent( QtCollider::SetAlwaysOnTopEvent *e )
 167 {
 168   QWidget *w = widget();
 169   if( !w ) return;
 170
 171   Qt::WindowFlags flags = w->windowFlags();
 172   if( flags & Qt::Window ) {
 173     if( e->alwaysOnTop ) flags |= Qt::WindowStaysOnTopHint;
 174     else flags &= ~Qt::WindowStaysOnTopHint;
 175
 176     // record the initial state to restore it later
 177     QPoint pos = w->pos();
 178     bool visible = w->isVisible();
 179
 180     w->setWindowFlags( flags );
 181
 182     // setting window flags will move the window to (0,0) and hide it,
 183     // so restore the initial state
 184     w->move(pos);
 185     if( visible ) w->show();
 186   }
 187 }
 188
 189 void QWidgetProxy::startDragEvent( StartDragEvent* e )
 190 {
 191   QWidget *w = widget();
 192   if( !w ) return;
 193
 194   QFont f;
 195   const QString & label = e->label;
 196   QFontMetrics fm( f );
 197   QSize size = fm.size( 0, label ) + QSize(8,4);
 198
 199   QPixmap pix( size );
 200   QPainter p( &pix );
 201   p.setBrush( QColor(255,255,255) );
 202   QRect r( pix.rect() );
 203   p.drawRect(r.adjusted(0,0,-1,-1));
 204   p.drawText( r, Qt::AlignCenter, label );
 205   p.end();
 206
 207   QMimeData *mime = new QMimeData();
 208   mime->setData( "application/supercollider", QByteArray() );
 209
 210   QDrag *drag = new QDrag(w);
 211   drag->setMimeData( mime );
 212   drag->setPixmap( pix );
 213   drag->setHotSpot( QPoint( 0, + r.height() + 2 ) );
 214   drag->exec();
 215 }
 216
 217 bool QWidgetProxy::filterEvent( QObject *o, QEvent *e, EventHandlerData &eh, QList<QVariant> & args )
 218 {
 219   // NOTE We assume that qObject need not be checked here, as we wouldn't get events if
 220   // it wasn't existing
 221
 222   int type = e->type();
 223
 224   eh = eventHandlers().value( type );
 225   if( eh.type != type ) return false;
 226
 227   switch( type ) {
 228
 229     case QEvent::KeyPress:
 230       return ((_globalEventMask & KeyPress) || eh.enabled)
 231         && interpretKeyEvent( o, e, args );
 232
 233     case QEvent::KeyRelease:
 234       return ((_globalEventMask & KeyRelease) || eh.enabled)
 235         && interpretKeyEvent( o, e, args );
 236
 237     case QEvent::MouseButtonPress:
 238     case QEvent::MouseMove:
 239     case QEvent::MouseButtonRelease:
 240     case QEvent::MouseButtonDblClick:
 241     case QEvent::Enter:
 242       return eh.enabled && interpretMouseEvent( o, e, args );
 243
 244     case QEvent::Wheel:
 245       return interpretMouseWheelEvent( o, e, args );
 246
 247     case QEvent::DragEnter:
 248     case QEvent::DragMove:
 249     case QEvent::Drop:
 250       return eh.enabled && interpretDragEvent( o, e, args );
 251
 252     default:
 253       return eh.enabled;
 254
 255   }
 256 }
 257
 258 bool QWidgetProxy::interpretMouseEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 259 {
 260   if( o != _mouseEventWidget || !_mouseEventWidget->isEnabled() ) return false;
 261
 262   QWidget *w = widget();
 263
 264   if( e->type() == QEvent::Enter ) {
 265     QPoint pos = QCursor::pos();
 266
 267
 268     if( w ) pos = w->mapFromGlobal( pos );
 269
 270     args << pos.x();
 271     args << pos.y();
 272     return true;
 273   }
 274
 275   QMouseEvent *mouse = static_cast<QMouseEvent*>( e );
 276   QPoint pt = ( _mouseEventWidget == w ?
 277                 mouse->pos() :
 278                 _mouseEventWidget->mapTo( w, mouse->pos() ) );
 279   args << pt.x();
 280   args << pt.y();
 281
 282   args << (int) mouse->modifiers();
 283
 284   if( e->type() == QEvent::MouseMove ) return true;
 285
 286   int button;
 287   switch( mouse->button() ) {
 288     case Qt::LeftButton:
 289       button = 0; break;
 290     case Qt::RightButton:
 291       button = 1; break;
 292     case Qt::MidButton:
 293       button = 2; break;
 294     default:
 295       button = -1;
 296   }
 297
 298   args << button;
 299
 300   switch( e->type() ) {
 301     case QEvent::MouseButtonPress:
 302       args << 1; break;
 303     case QEvent::MouseButtonDblClick:
 304       args << 2; break;
 305     default: ;
 306   }
 307
 308   return true;
 309 }
 310
 311 bool QWidgetProxy::interpretMouseWheelEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 312 {
 313   // NOTE: There seems to be a bug in wheel event propagation:
 314   // the event is propagated to parent twice!
 315   // Therefore we do not let the propagated events through to SC,
 316   // (we only let the "spontaneous" ones).
 317
 318   if( o != _mouseEventWidget || !e->spontaneous() || !_mouseEventWidget->isEnabled() ) return false;
 319
 320   QWheelEvent *we = static_cast<QWheelEvent*>(e);
 321
 322   QWidget *w = widget();
 323   QPoint pt = _mouseEventWidget == w ?
 324               we->pos() :
 325               _mouseEventWidget->mapTo( w, we->pos() );
 326   Qt::Orientation ort = we->orientation();
 327   // calculate degrees: delta is in 1/8 of a degree.
 328   int deg = we->delta() / 8;
 329
 330   args << pt.x();
 331   args << pt.y();
 332   args << (int) we->modifiers();
 333   args << (ort == Qt::Horizontal ? deg : 0);
 334   args << (ort == Qt::Vertical ? deg : 0);
 335
 336   return true;
 337 }
 338
 339 bool QWidgetProxy::interpretKeyEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 340 {
 341   if( o != _keyEventWidget || !_keyEventWidget->isEnabled() ) return false;
 342
 343   QKeyEvent *ke = static_cast<QKeyEvent*>( e );
 344
 345   QString text = ke->text();
 346   int unicode = ( text.count() == 1 ? text[0].unicode() : 0 );
 347
 348   args << text;
 349   args << (int) ke->modifiers();
 350   args << unicode;
 351   args << ke->key();
 352   args << ke->spontaneous();
 353
 354   return true;
 355 }
 356
 357 bool QWidgetProxy::interpretDragEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 358 {
 359   if( o != _mouseEventWidget ) return false;
 360
 361   QDropEvent *dnd = static_cast<QDropEvent*>(e);
 362
 363   if( dnd->type() == QEvent::DragEnter ) {
 364     const QMimeData *data = dnd->mimeData();
 365     if( data->hasFormat( "application/supercollider" ) ) {
 366       // nothing to do; drag data is stored in QView.currentDrag
 367       return true;
 368     }
 369     else if( data->hasColor() ) {
 370       args << data->colorData();
 371     }
 372     else if( data->hasUrls() ) {
 373       QList<QUrl> urls = data->urls();
 374       if( urls.count() > 1 ) {
 375         VariantList urlArray;
 376         Q_FOREACH( QUrl url, data->urls() ) urlArray.data << url.toString();
 377         args << QVariant::fromValue<VariantList>( urlArray );
 378       }
 379       else if( urls.count() == 1 ) {
 380         args << urls[0].toString();
 381       }
 382     }
 383     else if( data->hasText() ) {
 384       args << data->text();
 385     }
 386     else {
 387       // we can't use the data, let the widget handle DnD
 388       return false;
 389     }
 390   }
 391   else {
 392     QPoint pos = dnd->pos();
 393     args << pos.x() << pos.y();
 394   }
 395
 396   return true;
 397 }
 398
 399
 400 void QWidgetProxy::customPaint( QPainter *painter )
 401 {
 402   if( QtCollider::paintingAnnounced() ) {
 403     qcDebugMsg(1, "WARNING: Custom painting already in progress. Will not paint." );
 404     return;
 405   }
 406
 407   QtCollider::announcePainting();
 408
 409   QtCollider::lockLang();
 410
 411   if( QtCollider::beginPainting( painter ) ) {
 412     invokeScMethod( s_doDrawFunc, QList<QVariant>(), 0, true );
 413     QtCollider::endPainting();
 414   }
 415
 416   QtCollider::unlockLang();
 417 }
 418
 419 void QWidgetProxy::sendRefreshEventRecursive( QWidget *w ) {
 420   QEvent event( static_cast<QEvent::Type>( QtCollider::Event_Refresh ) );
 421   QApplication::sendEvent( w, &event );
 422
 423   const QObjectList &children = w->children();
 424   Q_FOREACH( QObject *child, children ) {
 425     if( child->isWidgetType() )
 426         sendRefreshEventRecursive( static_cast<QWidget*>( child ) );
 427   }
 428 }