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