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 #ifdef Q_WS_X11
  35 # include "hacks/hacks_x11.hpp"
  36 # include <QX11Info>
  37 # include <X11/Xlib.h>
  38 // X11 defines the following, clashing with QEvent::Type enum
  39 # undef KeyPress
  40 # undef KeyRelease
  41 #endif
  42
  43 using namespace QtCollider;
  44
  45 QAtomicInt QWidgetProxy::_globalEventMask = 0;
  46
  47 QWidgetProxy::QWidgetProxy( QWidget *w, PyrObject *po )
  48 : QObjectProxy( w, po ), _keyEventWidget( w ), _mouseEventWidget( w )
  49 { }
  50
  51 void QWidgetProxy::setKeyEventWidget( QWidget *w )
  52 {
  53   if( w == 0 || w == _keyEventWidget ) return;
  54
  55   QWidget *me = widget();
  56
  57   if( _keyEventWidget != me )
  58     _keyEventWidget->removeEventFilter( this );
  59
  60   _keyEventWidget = w;
  61
  62   if( _keyEventWidget != me ) {
  63     _keyEventWidget->installEventFilter( this );
  64   }
  65 }
  66
  67 void QWidgetProxy::setMouseEventWidget( QWidget *w )
  68 {
  69   if( w == 0 || w == _mouseEventWidget ) return;
  70
  71   QWidget *me = widget();
  72
  73   if( _mouseEventWidget != me )
  74     _mouseEventWidget->removeEventFilter( this );
  75
  76   _mouseEventWidget = w;
  77
  78   if( _mouseEventWidget != me ) {
  79     _mouseEventWidget->installEventFilter( this );
  80   }
  81 }
  82
  83 bool QWidgetProxy::alwaysOnTop()
  84 {
  85   QWidget *w = widget();
  86   if(!w) return false;
  87
  88   Qt::WindowFlags flags = w->windowFlags();
  89   if( flags & Qt::Window && flags & Qt::WindowStaysOnTopHint ) return true;
  90   else return false;
  91 }
  92
  93 void QWidgetProxy::refresh() {
  94   QWidget *w = widget();
  95   if( w ) sendRefreshEventRecursive( w );
  96 }
  97
  98 void QWidgetProxy::setLayout ( QObjectProxy *layoutProxy ) {
  99
 100   QWidget *w = widget();
 101   QLayout *l = qobject_cast<QLayout*>( layoutProxy->object() );
 102   if( !w || !l ) return;
 103
 104   QLayout *exLayout = w->layout();
 105   if( exLayout != l ) {
 106     if( exLayout != 0 ) {
 107       qcDebugMsg( 2, QString("Deleting old layout.") );
 108       delete exLayout;
 109     }
 110     qcDebugMsg( 2, QString("Setting layout.") );
 111     w->setLayout( l );
 112     l->activate();
 113   }
 114   else {
 115     qcDebugMsg( 2, QString("Layout same as existing. Will do nothing.") );
 116   }
 117 }
 118
 119 bool QWidgetProxy::setParent( QObjectProxy *parentProxy )
 120 {
 121   QObject *parent = parentProxy->object();
 122   if( !parent || !widget() ) return true;
 123
 124   if( parent->isWidgetType() ) {
 125     QWidget *pw = qobject_cast<QWidget*>(parent);
 126     bool ok = pw->metaObject()->invokeMethod( pw, "addChild", Q_ARG( QWidget*, widget() ) );
 127     if( !ok ) widget()->setParent( pw );
 128     return true;
 129   }
 130   return false;
 131 }
 132
 133 void QWidgetProxy::customEvent( QEvent *e )
 134 {
 135   int type = e->type();
 136   switch( type ) {
 137     case QtCollider::Event_Proxy_BringFront:
 138       bringFrontEvent();
 139       return;
 140     case QtCollider::Event_Proxy_SetFocus:
 141       setFocusEvent( static_cast<SetFocusEvent*>(e) );
 142       return;
 143     case QtCollider::Event_Proxy_SetAlwaysOnTop:
 144       setAlwaysOnTopEvent( static_cast<SetAlwaysOnTopEvent*>(e) );
 145       return;
 146     case QtCollider::Event_Proxy_StartDrag:
 147       startDragEvent( static_cast<StartDragEvent*>(e) );
 148       return;
 149     default:
 150       QObjectProxy::customEvent(e);
 151   }
 152 }
 153
 154
 155
 156
 157 void QWidgetProxy::bringFrontEvent() {
 158   QWidget *w = widget();
 159   if( !w ) return;
 160
 161   w->setWindowState( w->windowState() & ~Qt::WindowMinimized
 162                                       | Qt::WindowActive );
 163   w->show();
 164   w->raise();
 165
 166 #ifdef Q_WS_X11
 167   raise_window(QX11Info::display(), w);
 168 #endif
 169 }
 170
 171 void QWidgetProxy::setFocusEvent( QtCollider::SetFocusEvent *e ) {
 172   if( !widget() ) return;
 173
 174   if( e->focus )
 175     widget()->setFocus( Qt::OtherFocusReason );
 176   else
 177     widget()->clearFocus();
 178 }
 179
 180 void QWidgetProxy::setAlwaysOnTopEvent( QtCollider::SetAlwaysOnTopEvent *e )
 181 {
 182   QWidget *w = widget();
 183   if( !w ) return;
 184
 185   Qt::WindowFlags flags = w->windowFlags();
 186   if( flags & Qt::Window ) {
 187     if( e->alwaysOnTop ) flags |= Qt::WindowStaysOnTopHint;
 188     else flags &= ~Qt::WindowStaysOnTopHint;
 189
 190     // record the initial state to restore it later
 191     QPoint pos = w->pos();
 192     bool visible = w->isVisible();
 193
 194     w->setWindowFlags( flags );
 195
 196     // setting window flags will move the window to (0,0) and hide it,
 197     // so restore the initial state
 198     w->move(pos);
 199     if( visible ) w->show();
 200   }
 201 }
 202
 203 void QWidgetProxy::startDragEvent( StartDragEvent* e )
 204 {
 205   QWidget *w = widget();
 206   if( !w ) return;
 207
 208   QFont f;
 209   const QString & label = e->label;
 210   QFontMetrics fm( f );
 211   QSize size = fm.size( 0, label ) + QSize(8,4);
 212
 213   QPixmap pix( size );
 214   QPainter p( &pix );
 215   p.setBrush( QColor(255,255,255) );
 216   QRect r( pix.rect() );
 217   p.drawRect(r.adjusted(0,0,-1,-1));
 218   p.drawText( r, Qt::AlignCenter, label );
 219   p.end();
 220
 221   QMimeData *mime = e->data;
 222   e->data = 0; // prevent deleting the data when event destroyed;
 223
 224   QDrag *drag = new QDrag(w);
 225   drag->setMimeData( mime );
 226   drag->setPixmap( pix );
 227   drag->setHotSpot( QPoint( 0, + r.height() + 2 ) );
 228   drag->exec();
 229 }
 230
 231 bool QWidgetProxy::filterEvent( QObject *o, QEvent *e, EventHandlerData &eh, QList<QVariant> & args )
 232 {
 233   // NOTE We assume that qObject need not be checked here, as we wouldn't get events if
 234   // it wasn't existing
 235
 236   switch( eh.type ) {
 237
 238     case QEvent::KeyPress:
 239       return ((_globalEventMask & KeyPress) || eh.enabled)
 240         && interpretKeyEvent( o, e, args );
 241
 242     case QEvent::KeyRelease:
 243       return ((_globalEventMask & KeyRelease) || eh.enabled)
 244         && interpretKeyEvent( o, e, args );
 245
 246     case QEvent::MouseButtonPress:
 247     case QEvent::MouseMove:
 248     case QEvent::MouseButtonRelease:
 249     case QEvent::MouseButtonDblClick:
 250     case QEvent::Enter:
 251     case QEvent::Leave:
 252       return eh.enabled && interpretMouseEvent( o, e, args );
 253
 254     case QEvent::Wheel:
 255       return eh.enabled && interpretMouseWheelEvent( o, e, args );
 256
 257     case QEvent::DragEnter:
 258     case QEvent::DragMove:
 259     case QEvent::Drop:
 260       return eh.enabled && interpretDragEvent( o, e, args );
 261
 262     default:
 263       return eh.enabled;
 264
 265   }
 266 }
 267
 268 bool QWidgetProxy::interpretMouseEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 269 {
 270   if( o != _mouseEventWidget || !_mouseEventWidget->isEnabled() ) return false;
 271
 272   QWidget *w = widget();
 273
 274   QEvent::Type etype = e->type();
 275
 276   if( etype == QEvent::Enter || etype == QEvent::Leave )
 277     return true;
 278
 279   QMouseEvent *mouse = static_cast<QMouseEvent*>( e );
 280   QPoint pt = ( _mouseEventWidget == w ?
 281                 mouse->pos() :
 282                 _mouseEventWidget->mapTo( w, mouse->pos() ) );
 283   args << pt.x();
 284   args << pt.y();
 285
 286   args << (int) mouse->modifiers();
 287
 288   if( etype == QEvent::MouseMove )
 289   {
 290     int buttons = mouse->buttons();
 291
 292     if( buttons == 0 ) {
 293       // Special treatment of mouse-tracking events.
 294
 295       QWidget *win = w->window();
 296
 297       // Only accept if window has a special property enabled.
 298       if( !(win && win->property("_qc_win_mouse_tracking").toBool()) )
 299         return false;
 300
 301       // Reject the events when mouse pointer leaves the window,
 302       // resulting in out-of-bounds coordinates
 303       if( win == w ) {
 304         if( pt.x() < 0 || pt.x() >= w->width() || pt.y() < 0 || pt.y() >= w->height() )
 305           return false;
 306       }
 307     }
 308
 309     args << (int) mouse->buttons();
 310   }
 311   else
 312   {
 313     // MouseButtonPress, MouseButtonDblClick, MouseButtonRelease
 314
 315     int button;
 316
 317     switch( mouse->button() ) {
 318       case Qt::LeftButton:
 319         button = 0; break;
 320       case Qt::RightButton:
 321         button = 1; break;
 322       case Qt::MidButton:
 323         button = 2; break;
 324       default:
 325         button = -1;
 326     }
 327
 328     args << button;
 329
 330     if( etype == QEvent::MouseButtonPress )
 331       args << 1;
 332     else if( etype == QEvent::MouseButtonDblClick )
 333       args << 2;
 334   }
 335
 336   return true;
 337 }
 338
 339 bool QWidgetProxy::interpretMouseWheelEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 340 {
 341   // NOTE: There seems to be a bug in wheel event propagation:
 342   // the event is propagated to parent twice!
 343   // Therefore we do not let the propagated events through to SC,
 344   // (we only let the "spontaneous" ones).
 345
 346   if( o != _mouseEventWidget || !e->spontaneous() || !_mouseEventWidget->isEnabled() ) return false;
 347
 348   QWheelEvent *we = static_cast<QWheelEvent*>(e);
 349
 350   QWidget *w = widget();
 351   QPoint pt = _mouseEventWidget == w ?
 352               we->pos() :
 353               _mouseEventWidget->mapTo( w, we->pos() );
 354   Qt::Orientation ort = we->orientation();
 355   // calculate degrees: delta is in 1/8 of a degree.
 356   int deg = we->delta() / 8;
 357
 358   args << pt.x();
 359   args << pt.y();
 360   args << (int) we->modifiers();
 361   args << (ort == Qt::Horizontal ? deg : 0);
 362   args << (ort == Qt::Vertical ? deg : 0);
 363
 364   return true;
 365 }
 366
 367 bool QWidgetProxy::interpretKeyEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 368 {
 369   if( o != _keyEventWidget || !_keyEventWidget->isEnabled() ) return false;
 370
 371   QKeyEvent *ke = static_cast<QKeyEvent*>( e );
 372
 373   int key = ke->key();
 374
 375   int mods = ke->modifiers();
 376
 377   QChar character;
 378
 379 #ifdef Q_WS_MAC
 380   bool isLetter = key >= Qt::Key_A && key <= Qt::Key_Z;
 381   if (mods & Qt::MetaModifier && isLetter)
 382   {
 383       character = QChar(key - Qt::Key_A + 1);
 384   }
 385   else if(mods & Qt::AltModifier && isLetter)
 386   {
 387       character = (mods & Qt::ShiftModifier) ? QChar(key) : QChar(key - Qt::Key_A + 97 );
 388   }
 389   else
 390 #endif
 391   {
 392       QString text( ke->text() );
 393       if (text.count()) character = text[0];
 394   }
 395
 396   int unicode = character.unicode();
 397
 398 #ifdef Q_WS_X11
 399   KeySym sym = ke->nativeVirtualKey();
 400   int keycode = XKeysymToKeycode( QX11Info::display(), sym );
 401 #else
 402   // FIXME: On Mac OS X, this does not work for modifier keys
 403   int keycode = ke->nativeVirtualKey();
 404 #endif
 405
 406   args << character;
 407   args << mods;
 408   args << unicode;
 409   args << keycode;
 410   args << key;
 411   args << ke->spontaneous();
 412
 413   return true;
 414 }
 415
 416 static QString urlAsString( const QUrl & url )
 417 {
 418   if(url.scheme() == "file")
 419     return url.toLocalFile();
 420   else
 421     return url.toString();
 422 }
 423
 424 static bool interpretMimeData( const QMimeData *data, QList<QVariant> &args )
 425 {
 426   if( data->hasUrls() )
 427   {
 428     QList<QUrl> urls = data->urls();
 429     if( urls.count() > 1 ) {
 430       VariantList list;
 431       Q_FOREACH( QUrl url, urls )
 432         list.data << urlAsString( url );
 433       args << QVariant::fromValue<VariantList>(list);
 434     }
 435     else {
 436       args << urlAsString( urls[0] );
 437     }
 438   }
 439   else if( data->hasText() )
 440   {
 441     args << data->text();
 442   }
 443   else
 444   {
 445     return false;
 446   }
 447
 448   return true;
 449 }
 450
 451 bool QWidgetProxy::interpretDragEvent( QObject *o, QEvent *e, QList<QVariant> &args )
 452 {
 453   if( o != _mouseEventWidget ) return false;
 454
 455   QDropEvent *dnd = static_cast<QDropEvent*>(e);
 456
 457   const QMimeData *data = dnd->mimeData();
 458
 459   if( dnd->type() == QEvent::DragEnter )
 460   {
 461     bool internal = data->hasFormat( "application/supercollider" );
 462     args << internal;
 463     if(!internal)
 464       interpretMimeData(data, args);
 465   }
 466   else
 467   {
 468     QPoint pos = dnd->pos();
 469     args << pos.x() << pos.y();
 470   }
 471
 472   return true;
 473 }
 474
 475
 476 void QWidgetProxy::customPaint( QPainter *painter )
 477 {
 478   if( QtCollider::paintingAnnounced() ) {
 479     qcDebugMsg(1, "WARNING: Custom painting already in progress. Will not paint." );
 480     return;
 481   }
 482
 483   QtCollider::announcePainting();
 484
 485   QtCollider::lockLang();
 486
 487   if( QtCollider::beginPainting( painter ) ) {
 488     invokeScMethod( SC_SYM(doDrawFunc), QList<QVariant>(), 0, true );
 489     QtCollider::endPainting();
 490   }
 491
 492   QtCollider::unlockLang();
 493 }
 494
 495 void QWidgetProxy::sendRefreshEventRecursive( QWidget *w ) {
 496   QEvent event( static_cast<QEvent::Type>( QtCollider::Event_Refresh ) );
 497   QApplication::sendEvent( w, &event );
 498
 499   const QObjectList &children = w->children();
 500   Q_FOREACH( QObject *child, children ) {
 501     if( child->isWidgetType() )
 502         sendRefreshEventRecursive( static_cast<QWidget*>( child ) );
 503   }
 504 }