QtCollider/Slot.cpp

   1 /************************************************************************
   2 *
   3 * Copyright 2010 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 "Slot.h"
  23 #include "QObjectProxy.h"
  24 #include "Common.h"
  25
  26 #include <PyrObject.h>
  27 #include <PyrKernel.h>
  28 #include <GC.h>
  29 #include <VMGlobals.h>
  30
  31 #include <QPalette>
  32 #include <QWidget>
  33
  34 #include <qmath.h>
  35
  36 using namespace QtCollider;
  37
  38 static QPalette::ColorRole paletteColorRoles[] = {
  39   QPalette::Window,
  40   QPalette::WindowText,
  41   QPalette::Button,
  42   QPalette::ButtonText,
  43   QPalette::Base,
  44   QPalette::Text,
  45   QPalette::Highlight,
  46   QPalette::HighlightedText,
  47 };
  48
  49 int Slot::setRect( PyrSlot *slot, const QRectF &r )
  50 {
  51   if( !isKindOfSlot( slot, class_Rect ) ) {
  52     return errWrongType;
  53   }
  54
  55   PyrSlot *slots = slotRawObject( slot )->slots;
  56   SetFloat( slots+0, r.x() );
  57   SetFloat( slots+1, r.y() );
  58   SetFloat( slots+2, r.width() );
  59   SetFloat( slots+3, r.height() );
  60
  61   return errNone;
  62 }
  63
  64 int Slot::setPoint( PyrSlot *slot, const QPointF &pt )
  65 {
  66   if( !isKindOfSlot( slot, class_Point ) ) {
  67     return errWrongType;
  68   }
  69
  70   PyrSlot *slots = slotRawObject( slot )->slots;
  71   SetFloat( slots+0, pt.x() );
  72   SetFloat( slots+1, pt.y() );
  73
  74   return errNone;
  75 }
  76
  77 void Slot::setSize( PyrSlot *slot, const QSizeF &sz )
  78 {
  79   PyrObject *obj = instantiateObject( gMainVMGlobals->gc, class_Size, 0, true, true );
  80   SetObject( slot, obj );
  81
  82   PyrSlot *slots = obj->slots;
  83   SetFloat( slots+0, sz.width() );
  84   SetFloat( slots+1, sz.height() );
  85 }
  86
  87 void Slot::setString( PyrSlot *slot, const QString& arg )
  88 {
  89   PyrString *str = newPyrString( gMainVMGlobals->gc,
  90                                  arg.toStdString().c_str(), 0, true );
  91   SetObject( slot, str );
  92 }
  93
  94 int Slot::setColor( PyrSlot *slot, const QColor &c )
  95 {
  96   if( !isKindOfSlot( slot, class_Color) ) return errWrongType;
  97
  98   PyrSlot *slots = slotRawObject( slot )->slots;
  99
 100   SetFloat( slots+0, c.red() / 255.0 );
 101   SetFloat( slots+1, c.green() / 255.0 );
 102   SetFloat( slots+2, c.blue() / 255.0 );
 103   SetFloat( slots+3, c.alpha() / 255.0 );
 104
 105   return errNone;
 106 }
 107
 108 int Slot::setPalette( PyrSlot *slot, const QPalette &plt )
 109 {
 110   if( !isKindOfSlot( slot, class_QPalette ) ) return errWrongType;
 111
 112   PyrSlot *s = slotRawObject( slot )->slots;
 113
 114   for( int i=0; i<8; ++i, ++s ) {
 115     if( setColor( s, plt.color( paletteColorRoles[i] ) ) ) return errFailed;
 116   }
 117
 118   return errNone;
 119 }
 120
 121 void Slot::setQObject( PyrSlot *s, QObject *o )
 122 {
 123   if( !o ) {
 124     SetNil(s);
 125     return;
 126   }
 127
 128   QObjectProxy *proxy = QObjectProxy::fromObject(o);
 129   if( proxy && proxy->scObject() )
 130     SetObject( s, proxy->scObject() );
 131   else
 132     SetNil( s );
 133 }
 134
 135 void Slot::setTreeWidgetItem( PyrSlot *s, const SafePtr<QcTreeWidget::Item> & itemPtr )
 136 {
 137   PyrObject *obj = instantiateObject( gMainVMGlobals->gc, class_QTreeViewItem, 0, true, true );
 138   QcTreeWidget::Item::initialize( gMainVMGlobals, obj, itemPtr );
 139   SetObject( s, obj );
 140 }
 141
 142 void Slot::setVariantList( PyrSlot *slot, const VariantList& varList )
 143 {
 144   VMGlobals *g = gMainVMGlobals;
 145
 146   int count = varList.data.count();
 147
 148   PyrObject *array = newPyrArray( g->gc, count, 0, true );
 149   SetObject( slot, array );
 150
 151   int i;
 152   PyrSlot *s = array->slots;
 153   for( i = 0; i < count; ++i, ++s ) {
 154     if( Slot::setVariant( s, varList.data[i] ) ) {
 155       qcDebugMsg(1, "WARNING: Could not set one slot of array" );
 156     }
 157     array->size++;
 158     g->gc->GCWrite( array, s );
 159   }
 160 }
 161
 162 int Slot::setVariant( PyrSlot *slot, const QVariant &val )
 163 {
 164   bool b_val;
 165   int type = val.userType();
 166
 167   switch( type ) {
 168     case QMetaType::Bool:
 169         b_val = val.toBool();
 170         if( b_val ) SetTrue( slot );
 171         else SetFalse( slot );
 172         return errNone;
 173     case QMetaType::QPoint:
 174     case QMetaType::QPointF:
 175         return Slot::setPoint( slot, val.toPointF() );
 176     case QMetaType::QSize:
 177     case QMetaType::QSizeF:
 178         Slot::setSize( slot, val.toSizeF() );
 179         return errNone;
 180     case QMetaType::QRect:
 181     case QMetaType::QRectF:
 182         return Slot::setRect( slot, val.toRectF() );
 183     case QMetaType::QString:
 184         Slot::setString( slot, val.toString() );
 185         return errNone;
 186     case QMetaType::QColor:
 187          return Slot::setColor( slot, val.value<QColor>() );
 188     case QMetaType::QPalette:
 189         return Slot::setPalette( slot, val.value<QPalette>() );
 190     case QMetaType::Float:
 191     case QMetaType::Double:
 192         SetFloat( slot, val.value<double>() );
 193         return errNone;
 194     case QMetaType::Int:
 195         SetInt( slot, val.toInt() );
 196         return errNone;
 197     case QMetaType::QObjectStar:
 198         Slot::setQObject( slot, val.value<QObject*>() );
 199         return errNone;
 200     case QMetaType::QWidgetStar:
 201         Slot::setQObject( slot, val.value<QWidget*>() );
 202         return errNone;
 203     case QMetaType::Void:
 204         SetNil( slot );
 205         return errNone;
 206     default:
 207         if( type == qMetaTypeId<PyrObject*>() ) {
 208           SetObject( slot, val.value<PyrObject*>() );
 209         }
 210         else if( type == qMetaTypeId<VariantList>() ) {
 211           Slot::setVariantList( slot, val.value<VariantList>() );
 212         }
 213         else if( type == qMetaTypeId<QcTreeWidget::ItemPtr>() ) {
 214           Slot::setTreeWidgetItem( slot, val.value< QtCollider::SafePtr<QcTreeWidget::Item> >() );
 215         }
 216         else {
 217           qcErrorMsg( "the QVariant could not be interpreted!" );
 218           return errFailed;
 219         }
 220         return errNone;
 221   }
 222 }
 223
 224 bool Slot::toBool( PyrSlot *slot )
 225 {
 226   return IsTrue( slot );
 227 }
 228
 229 int Slot::toInt( PyrSlot *slot )
 230 {
 231   int i;
 232   if( slotIntVal( slot, &i ) ) return 0;
 233   return i;
 234 }
 235
 236 float Slot::toFloat( PyrSlot *slot )
 237 {
 238   float f;
 239   if( slotFloatVal( slot, &f ) ) return 0.f;
 240   return f;
 241 }
 242
 243 double Slot::toDouble( PyrSlot *slot )
 244 {
 245   double d;
 246   if( slotDoubleVal( slot, &d ) ) return 0.0;
 247   return d;
 248 }
 249
 250 QString Slot::toString( PyrSlot *slot )
 251 {
 252   if( IsSym(slot) ) {
 253     return QString( slotRawSymbol(slot)->name );
 254   }
 255   else if( isKindOfSlot( slot, class_String ) ) {
 256     int len = slotRawObject( slot )->size;
 257     return QString::fromAscii( slotRawString(slot)->s, len );
 258   }
 259   return QString();
 260 }
 261
 262 QPointF Slot::toPoint( PyrSlot *slot )
 263 {
 264   if( !isKindOfSlot( slot, class_Point ) ) {
 265     return QPointF();
 266   }
 267   PyrSlot *slots = slotRawObject( slot )->slots;
 268   float x, y;
 269   int err;
 270   err = slotFloatVal( slots+0, &x ); if( err ) return QPointF();
 271   err = slotFloatVal( slots+1, &y ); if( err ) return QPointF();
 272   return QPointF( x, y );
 273 }
 274
 275 QRectF Slot::toRect( PyrSlot *slot )
 276 {
 277   if( !isKindOfSlot( slot, class_Rect ) ) {
 278     return QRectF();
 279   }
 280
 281   PyrSlot *slots = slotRawObject( slot )->slots;
 282   float bounds[4];
 283   for( int i=0; i<4; ++i )
 284   {
 285     int err = slotFloatVal(slots + i, &bounds[i]);
 286     if( err ) return QRectF();
 287   }
 288
 289   return QRectF( bounds[0], bounds[1], bounds[2], bounds[3] );
 290 }
 291
 292 QSizeF Slot::toSize( PyrSlot *slot )
 293 {
 294   if( !isKindOfSlot( slot, class_Size ) ) {
 295     return QSizeF();
 296   }
 297
 298   PyrSlot *slots = slotRawObject( slot )->slots;
 299   float w = 0.f, h = 0.f;
 300   slotFloatVal( slots+0, &w );
 301   slotFloatVal( slots+1, &h );
 302
 303   return QSizeF( w, h );
 304 }
 305
 306 QColor Slot::toColor( PyrSlot *slot )
 307 {
 308   if( !isKindOfSlot( slot, class_Color) )
 309     return QColor();
 310
 311   PyrSlot *slots = slotRawObject(slot)->slots;
 312
 313   float r,g,b,a;
 314   r = g = b = a = 0.f;
 315   int err;
 316   err = slotFloatVal(slots+0, &r);
 317   if (err) return err;
 318   err = slotFloatVal(slots+1, &g);
 319   if (err) return err;
 320   err = slotFloatVal(slots+2, &b);
 321   if (err) return err;
 322   err = slotFloatVal(slots+3, &a);
 323   if (err) return err;
 324   return QColor( r*255, g*255, b*255, a*255 );
 325 }
 326
 327 QFont Slot::toFont( PyrSlot *slot )
 328 {
 329   if( !isKindOfSlot( slot, class_QFont ) )
 330     return QFont();
 331
 332   PyrSlot *slots = slotRawObject(slot)->slots;
 333
 334   QString family = Slot::toString( slots+0 );
 335   float fSize = Slot::toFloat( slots+1 );
 336   bool bold = IsTrue( slots+2 );
 337   bool italic = IsTrue( slots+3 );
 338   bool isPtSize = IsTrue( slots+4 );
 339
 340   QFont f;
 341
 342   if( !family.isEmpty() ) f.setFamily( family );
 343
 344   if( fSize > 0.f ) {
 345     if( isPtSize ) {
 346       f.setPointSizeF( fSize );
 347     }
 348     else {
 349       int pixSize = ( fSize > 1.f ? qRound(fSize) : 1 );
 350       f.setPixelSize( pixSize );
 351     }
 352   }
 353
 354   f.setBold( bold );
 355
 356   f.setItalic( italic );
 357
 358   return f;
 359 }
 360
 361 QPalette Slot::toPalette( PyrSlot *slot )
 362 {
 363   if( !isKindOfSlot( slot, class_QPalette ) )
 364     return QPalette();
 365
 366   PyrSlot *slots = slotRawObject( slot )->slots;
 367   QPalette palette;
 368
 369   for( int i=0; i<8; ++i, ++slots ) {
 370     QColor c = Slot::toColor(slots);
 371     if( !c.isValid() ) continue;
 372     palette.setColor( paletteColorRoles[i], c );
 373   }
 374
 375   return palette;
 376 }
 377
 378 VariantList Slot::toVariantList( PyrSlot *slot )
 379 {
 380   if( isKindOfSlot( slot, class_Array ) ) {
 381     PyrObject *obj = slotRawObject( slot );
 382     PyrSlot *slots = obj->slots;
 383     int size = obj->size;
 384     VariantList list;
 385     for( int i = 0; i < size; ++i, ++slots )
 386       list.data << Slot::toVariant( slots );
 387     return list;
 388   }
 389   else if( isKindOfSlot( slot, class_SymbolArray ) ) {
 390     PyrSymbolArray *symarray = slotRawSymbolArray( slot );
 391     PyrSymbol **symbols = symarray->symbols;
 392     int size = symarray->size;
 393     VariantList list;
 394     for( int i = 0; i < size; ++i, ++symbols )
 395       list.data << QVariant( QString( (*symbols)->name) );
 396     return list;
 397   }
 398
 399   return VariantList();
 400 }
 401
 402 QObjectProxy* Slot::toObjectProxy( PyrSlot *slot )
 403 {
 404   if( !isKindOfSlot( slot, class_QObject ) ) return 0;
 405   QObjectProxy *proxy = 0;
 406   PyrSlot *proxySlot = slotRawObject( slot )->slots;
 407   if( IsPtr( proxySlot ) ) proxy = (QObjectProxy*) slotRawPtr( proxySlot );
 408   return proxy;
 409 }
 410
 411 QcTreeWidget::ItemPtr Slot::toTreeWidgetItem( PyrSlot *slot )
 412 {
 413   if( !isKindOfSlot( slot, class_QTreeViewItem ) ) return QcTreeWidget::ItemPtr();
 414   PyrSlot *ptrSlot = slotRawObject(slot)->slots+0;
 415   if( IsPtr( ptrSlot ) ) {
 416     QcTreeWidget::ItemPtr *safePtr = static_cast<QcTreeWidget::ItemPtr*>( slotRawPtr(ptrSlot) );
 417     return *safePtr;
 418   }
 419   else {
 420     return QcTreeWidget::ItemPtr();
 421   }
 422 }
 423
 424 QVariant Slot::toVariant( PyrSlot *slot )
 425 {
 426   QObjectProxy *proxy;
 427   switch (GetTag(slot)) {
 428     case tagChar :
 429     case tagNil :
 430       return QVariant();
 431     case tagInt :
 432       return QVariant( toInt(slot) );
 433     case tagSym :
 434       return QVariant( toString(slot) );
 435     case tagFalse :
 436       return QVariant( false );
 437     case tagTrue :
 438       return QVariant( true );
 439     case tagObj :
 440     {
 441       if( isKindOfSlot( slot, class_String ) ) {
 442         return QVariant( toString(slot) );
 443       }
 444       else if( isKindOfSlot( slot, class_Point ) ) {
 445         return QVariant( toPoint( slot ) );
 446       }
 447       else if( isKindOfSlot( slot, class_Rect ) ) {
 448         return QVariant( toRect(slot) );
 449       }
 450       else if( isKindOfSlot( slot, class_Size ) ) {
 451         return QVariant( toSize(slot) );
 452       }
 453       else if( isKindOfSlot( slot, class_Color) ) {
 454         return QVariant::fromValue<QColor>( toColor(slot) );
 455       }
 456       else if( isKindOfSlot( slot, class_QFont ) ) {
 457         return QVariant::fromValue<QFont>( toFont(slot) );
 458       }
 459       else if( isKindOfSlot( slot, class_QPalette ) ) {
 460         return QVariant::fromValue<QPalette>( toPalette(slot) );
 461       }
 462       else if( isKindOfSlot( slot, class_QObject ) ) {
 463         proxy = toObjectProxy(slot);
 464         return QVariant::fromValue<QObjectProxy*>( proxy );
 465       }
 466       else if( isKindOfSlot( slot, class_Array ) || isKindOfSlot( slot, class_SymbolArray ) ) {
 467         return QVariant::fromValue<VariantList>( toVariantList(slot) );
 468       }
 469       else if( isKindOfSlot( slot, class_QTreeViewItem ) ) {
 470         return QVariant::fromValue<QcTreeWidget::ItemPtr>( toTreeWidgetItem(slot) );
 471       }
 472       else {
 473         qcErrorMsg("Could not interpret slot!");
 474         return QVariant();
 475       }
 476     }
 477     default:
 478       return QVariant( toDouble( slot ) );
 479   }
 480 }
 481
 482 using namespace Slot;
 483
 484 void QtCollider::Variant::setData( PyrSlot *slot )
 485 {
 486   QObjectProxy *proxy;
 487   switch (GetTag(slot)) {
 488     case tagChar :
 489     case tagNil :
 490       _type = QMetaType::Void;
 491       _ptr = 0;
 492       break;
 493     case tagInt :
 494       _type = QMetaType::Int;
 495       _ptr = new int( toInt(slot) );
 496       break;
 497     case tagSym :
 498       _type = QMetaType::QString;
 499       _ptr = new QString( toString(slot) );
 500       break;
 501     case tagFalse :
 502       _type = QMetaType::Bool;
 503       _ptr = new bool( false );
 504       break;
 505     case tagTrue :
 506       _type = QMetaType::Bool;
 507       _ptr = new bool( true );
 508       break;
 509     case tagObj :
 510     {
 511       if( isKindOfSlot( slot, class_String ) ) {
 512         _type = QMetaType::QString;
 513         _ptr = new QString( toString(slot) );
 514       }
 515       else if( isKindOfSlot( slot, class_Point ) ) {
 516         _type = QMetaType::QPointF;
 517         _ptr = new QPointF( toPoint(slot) );
 518       }
 519       else if( isKindOfSlot( slot, class_Rect ) ) {
 520         _type = QMetaType::QRectF;
 521         _ptr = new QRectF( toRect(slot) );
 522       }
 523       else if( isKindOfSlot( slot, class_Size ) ) {
 524         _type = QMetaType::QSizeF;
 525         _ptr = new QSizeF( toSize(slot) );
 526       }
 527       else if( isKindOfSlot( slot, class_Color) ) {
 528         _type = QMetaType::QColor;
 529         _ptr = new QColor( toColor(slot) );
 530       }
 531       else if( isKindOfSlot( slot, class_Array ) || isKindOfSlot( slot, class_SymbolArray ) ) {
 532         _type = qMetaTypeId<VariantList>();
 533         _ptr = new VariantList( toVariantList(slot) );
 534       }
 535       else if( isKindOfSlot( slot, class_QObject ) ) {
 536         proxy = toObjectProxy(slot);
 537         if( !proxy ) {
 538           _type = QMetaType::Void;
 539           _ptr = 0;
 540         }
 541         else {
 542           _type = qMetaTypeId<QObjectProxy*>();
 543           _ptr = new QObjectProxy*( proxy );
 544         }
 545       }
 546       else if( isKindOfSlot( slot, class_QTreeViewItem ) ) {
 547         _type = qMetaTypeId<QcTreeWidget::ItemPtr>();
 548         _ptr = new QcTreeWidget::ItemPtr( toTreeWidgetItem(slot) );
 549       }
 550       else {
 551         qcErrorMsg("Could not interpret slot!");
 552         _type = QMetaType::Void;
 553         _ptr = 0;
 554       }
 555       break;
 556     }
 557     default :
 558       _type = QMetaType::Double;
 559       _ptr = new double( toDouble(slot) );
 560   }
 561 }