QtCollider/widgets/QcMultiSlider.cpp

   1 /************************************************************************
   2 *
   3 * Copyright 2010-2012 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 "QcMultiSlider.h"
  23 #include "../QcWidgetFactory.h"
  24 #include "../style/routines.hpp"
  25
  26 #include <QApplication>
  27 #include <QMouseEvent>
  28 #include <QPainter>
  29
  30 #include <cmath>
  31
  32 QC_DECLARE_QWIDGET_FACTORY(QcMultiSlider);
  33
  34 QcMultiSlider::QcMultiSlider() :
  35   QtCollider::Style::Client(this),
  36   _currentIndex(0),
  37   _selectionSize(1),
  38   roundStep( 0.f ),
  39   editable( true ),
  40   ort( Qt::Vertical),
  41   elastic( false ),
  42   thumbSize( QSizeF( 12.f, 12.f ) ),
  43   gap( 1 ),
  44   drawRects( true ),
  45   drawLines( false ),
  46   isFilled( false ),
  47   highlight( false ),
  48   startIndex( 0 )
  49 {
  50   setFocusPolicy( Qt::StrongFocus );
  51   setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
  52   connect( this, SIGNAL(modified()), this, SLOT(update()) );
  53   connect( this, SIGNAL(interacted()), this, SLOT(doAction()) );
  54 }
  55
  56 void QcMultiSlider::setSliderCount( int newSize )
  57 {
  58   while( newSize > _values.size() )
  59     _values.append( 0.f );
  60   while( newSize < _values.size() )
  61     _values.removeLast();
  62   update();
  63 }
  64
  65 QVector<double> QcMultiSlider::values() const
  66 {
  67   return QVector<double>::fromList(_values);
  68 }
  69
  70 void QcMultiSlider::setValues( const QVector<double> & vec )
  71 {
  72   _values.clear();
  73
  74   Q_FOREACH( double value, vec )
  75     _values << qBound(0.0, rounded(value), 1.0);
  76
  77   update();
  78 }
  79
  80
  81 double QcMultiSlider::value() const
  82 {
  83   if( _currentIndex >= 0 && _currentIndex < _values.count() )
  84     return _values[_currentIndex];
  85   else
  86     return 0.0;
  87 }
  88
  89 void QcMultiSlider::setValue( double val )
  90 {
  91   if( _currentIndex >= 0 && _currentIndex < _values.count() )
  92     setValue( _currentIndex, val );
  93
  94   update();
  95 }
  96
  97 QVector<double> QcMultiSlider::reference() const
  98 {
  99   return QVector<double>::fromList(_ref);
 100 }
 101
 102 void QcMultiSlider::setReference( const QVector<double> & vec )
 103 {
 104   _ref.clear();
 105
 106   Q_FOREACH( double value, vec )
 107     _ref << qBound( 0.0, value, 1.0 );
 108
 109   update();
 110 }
 111
 112 void QcMultiSlider::setStep( double step ) {
 113   if( roundStep == step ) return;
 114   roundStep = step;
 115   if( step == 0.0 ) return;
 116   int c = _values.count();
 117   int i;
 118   for( i=0; i<c; ++i ) setValue( i, _values[i] );
 119   update();
 120 }
 121
 122 void QcMultiSlider::setIndex( int i ) {
 123   if( i >= 0 && i < _values.count() ) {
 124     _currentIndex = i;
 125     _selectionSize = 1;
 126     update();
 127   }
 128 }
 129
 130 void QcMultiSlider::setSelectionSize( int i ) {
 131   _selectionSize = qMin(i, _values.count() - _currentIndex);
 132   update();
 133 }
 134
 135 inline void QcMultiSlider::setValue( int index, double value )
 136 {
 137   _values[index] = qBound( 0.0, rounded(value), 1.0 );
 138 }
 139
 140 inline double QcMultiSlider::rounded ( double value )
 141 {
 142   return roundStep > 0.0 ?
 143     qRound( value / roundStep ) * roundStep :
 144     value;
 145 }
 146
 147 QRect QcMultiSlider::contentsRect()
 148 {
 149   return QtCollider::Style::sunkenContentsRect(rect()).adjusted(2, 2,-2,-2);
 150 }
 151
 152 QRect QcMultiSlider::valueRect( int count, qreal & spacing )
 153 {
 154   QRect r( contentsRect() );
 155
 156   bool horiz = ort == Qt::Horizontal;
 157
 158   spacing = elastic ? (qreal) (horiz ? r.height() : r.width()) / count : thumbSize.width() + gap;
 159
 160   if( !isFilled ) {
 161     int hnd = thumbSize.height();
 162     if( horiz ) {
 163       r.setWidth( r.width() - hnd );
 164       r.moveLeft( r.left() + hnd * 0.5 );
 165     }
 166     else {
 167       r.setHeight( r.height() - hnd );
 168       r.moveTop( r.top() + hnd * 0.5 );
 169     }
 170   }
 171
 172   return r;
 173 }
 174
 175 void QcMultiSlider::mousePressEvent( QMouseEvent *e )
 176 {
 177   using namespace QtCollider::Style;
 178
 179   moveOrigin = e->pos();
 180   int c = _values.count();
 181
 182   if( !c ) return;
 183
 184   bool horiz = ort == Qt::Horizontal;
 185   double spacing;
 186
 187   QRect r( valueRect( c - startIndex, spacing ) );
 188
 189   int i;
 190   float val;
 191
 192   if( horiz ) {
 193     i = spacing > 0.f ? floor((float)(moveOrigin.y() - r.y()) / spacing) : 0;
 194     val = xValue((qreal)moveOrigin.x(), r);
 195   }
 196   else {
 197     i = spacing > 0.f ? floor((float)(moveOrigin.x() - r.x()) / spacing) : 0;
 198     val = yValue((qreal)moveOrigin.y(), r);
 199   }
 200
 201   i += startIndex;
 202
 203   if( i >= startIndex && i < c ) {
 204     _currentIndex = i;
 205     _selectionSize = 1;
 206
 207     if( editable ) setValue( i, val );
 208     if( editable || highlight ) Q_EMIT( modified() );
 209
 210     Q_EMIT( interacted() );
 211   }
 212 }
 213
 214 void QcMultiSlider::mouseMoveEvent( QMouseEvent *e )
 215 {
 216   using namespace QtCollider::Style;
 217
 218   if( !e->buttons() ) return;
 219
 220   int c = _values.count();
 221
 222   QPoint pos = e->pos();
 223
 224   if( !c ) {
 225     moveOrigin = pos;
 226     return;
 227   }
 228
 229   double xStep;
 230
 231   QRect r( valueRect( c - startIndex, xStep ) );
 232
 233   float xOrig, yOrig, xDest, yDest;
 234   int xOffset, xRange;
 235   int iOrig, iDest, iMax;
 236
 237   if( ort == Qt::Vertical ) {
 238     xOffset = r.left(); xRange = r.width();
 239     xOrig = moveOrigin.x();
 240     yOrig = yValue(moveOrigin.y(), r);
 241     xDest = pos.x();
 242     yDest = yValue(pos.y(), r);
 243   }
 244   else {
 245     xOffset = r.top(); xRange = r.height();
 246     xOrig = moveOrigin.y();
 247     yOrig = xValue(moveOrigin.x(), r);
 248     xDest = pos.y();
 249     yDest = xValue(pos.x(), r);
 250   }
 251
 252   if( xStep > 0.0 ) {
 253     iOrig = floor((xOrig - xOffset) / xStep); iOrig += startIndex;
 254     iDest = floor((xDest - xOffset) / xStep); iDest += startIndex;
 255     iMax = elastic ? c : qMin( c, int( (float)xRange / xStep) + startIndex + 1);
 256   }
 257   else
 258   {
 259     iOrig = iDest = iMax = startIndex;
 260   }
 261
 262   if( editable && (iOrig != iDest) ) {
 263     float k = (yDest - yOrig) / (xDest - xOrig);
 264     float n = yOrig - (xOrig - xOffset) * k;
 265     int i = iOrig - startIndex;
 266
 267     while( iOrig < iDest ) {
 268       ++i;
 269       if( iOrig >= startIndex && iOrig < iMax  ) {
 270         float y = (i * xStep) * k + n;
 271         setValue( iOrig, y );
 272       }
 273       ++iOrig;
 274     }
 275     while( iOrig > iDest ) {
 276       if( iOrig >= startIndex && iOrig < iMax ) {
 277         float y = (i * xStep) * k + n;
 278         setValue( iOrig, y );
 279       }
 280       --iOrig; --i;
 281     }
 282   }
 283
 284   if( iDest >= startIndex && iDest < iMax ) {
 285     if( editable ) setValue( iDest, yDest );
 286
 287     _currentIndex = iDest;
 288     _selectionSize = 1;
 289   }
 290
 291   moveOrigin = pos;
 292
 293   Q_EMIT( modified() );
 294   Q_EMIT( interacted() );
 295 }
 296
 297 void QcMultiSlider::paintEvent( QPaintEvent *e )
 298 {
 299   using namespace QtCollider::Style;
 300   using QtCollider::Style::Ellipse;
 301   using QtCollider::Style::RoundRect;
 302
 303   Q_UNUSED(e);
 304   QPainter p(this);
 305   p.setRenderHint( QPainter::Antialiasing, true );
 306
 307   QPalette pal = palette();
 308
 309   RoundRect frame(rect(), 2);
 310   drawSunken( &p, pal, frame, pal.color(QPalette::Base), hasFocus() ? focusColor() : QColor() );
 311
 312   if( !_values.count() ) return;
 313
 314   p.setRenderHint( QPainter::Antialiasing, false );
 315
 316   bool horiz = ort == Qt::Horizontal;
 317
 318   QColor fillColor =
 319     _fillColor.isValid() ? _fillColor : pal.color( QPalette::Text );
 320   QColor strokeColor =
 321     _strokeColor.isValid() ? _strokeColor : pal.color( QPalette::Text );
 322
 323   QRect bounds( contentsRect() );
 324
 325   p.setClipRect( bounds );
 326
 327   if( horiz ) {
 328     p.translate( bounds.topLeft() );
 329     p.rotate(90);
 330     p.scale(1.0, -1.0);
 331     bounds.setSize( QSize( bounds.height(), bounds.width() ) );
 332   }
 333   else {
 334     p.translate( bounds.left(), bounds.top() + bounds.height() );
 335     p.scale(1.0, -1.0);
 336   }
 337
 338   int count = _values.count() - startIndex;
 339   double spacing, width, yscale;
 340
 341   spacing = elastic ? (double) bounds.width() / count : thumbSize.width() + gap;
 342   width = elastic ? qMin( spacing, (double) thumbSize.width() ) : thumbSize.width();
 343   yscale = bounds.height();
 344   if( !isFilled ) yscale -= thumbSize.height();
 345
 346   // selection
 347
 348   if( highlight ) {
 349     int i = _currentIndex - startIndex;
 350     int c = qMin( count - i, _selectionSize );
 351     if(c) {
 352       QRect r;
 353       r.setHeight( bounds.height() );
 354       r.setWidth( c * spacing );
 355       r.moveLeft( i * spacing );
 356
 357       QColor hlColor = fillColor;
 358       hlColor.setAlpha( 70 );
 359       p.fillRect( r, hlColor );
 360     }
 361   }
 362
 363   p.setPen( strokeColor );
 364
 365   // lines
 366
 367   if( drawLines ) {
 368     bool fill = isFilled & !drawRects;
 369
 370     p.save();
 371
 372     p.setRenderHint( QPainter::Antialiasing, true );
 373     p.translate( spacing * 0.5, isFilled ? 0.0 : thumbSize.height() * 0.5 );
 374     p.scale( 1.0, (qreal) yscale );
 375     if( fill ) p.setBrush( fillColor );
 376
 377     QPainterPath path;
 378
 379     // value line
 380
 381     path.moveTo( 0, _values[startIndex] );
 382     for( int i = 1; i < count; ++i )
 383       path.lineTo( (qreal) i * spacing, _values[i + startIndex] );
 384
 385     // reference line
 386
 387     int refcount = _ref.count() - startIndex;
 388     if( refcount > 0 || fill ) {
 389       qreal x, y;
 390       int i = count - 1;
 391
 392       x = i * spacing;
 393       y = i < refcount ? _ref[i + startIndex] : 0.f;
 394       if( fill ) path.lineTo(x, y);
 395       else path.moveTo(x, y);
 396
 397       while( --i >= 0 ) {
 398         x = i * spacing;
 399         y = i < refcount ? _ref[i + startIndex] : 0.f;
 400         path.lineTo(x, y);
 401       }
 402
 403       if( fill ) path.closeSubpath();
 404     }
 405
 406     p.drawPath( path );
 407
 408     p.restore();
 409   }
 410
 411   // rects
 412
 413   if( drawRects ) {
 414     p.setRenderHint( QPainter::Antialiasing, false );
 415     p.translate( (spacing - width) * 0.5, 0 );
 416     p.setBrush( fillColor );
 417
 418     QRectF r;
 419     r.setWidth( width );
 420
 421     if( isFilled ) {
 422       int refcount = _ref.count() - startIndex;
 423       for( int i = 0; i < count; ++i ) {
 424         int ref = (i < refcount ? _ref[i + startIndex] : 0.f) * yscale;
 425         int val = _values[i + startIndex] * yscale;
 426         r.moveLeft( i * spacing );
 427         r.moveTop( ref );
 428         r.setHeight( val - ref );
 429         if(horiz) p.drawRect(r.normalized().adjusted(0,0,-1,-1));
 430         else p.drawRect(r.normalized().adjusted(0,1,-1,0));
 431       }
 432     }
 433     else {
 434       r.setHeight( thumbSize.height() );
 435       for( int i = 0; i < count; ++i ) {
 436         r.moveLeft( i * spacing );
 437         r.moveTop( _values[i + startIndex] * yscale );
 438         if(horiz) p.drawRect(r.adjusted(0,0,-1,-1));
 439         else p.drawRect(r.adjusted(0,1,-1,0));
 440       }
 441     }
 442   }
 443 }
 444
 445 void QcMultiSlider::doAction()
 446 {
 447   Qt::KeyboardModifier ctrlMod =
 448 #ifdef Q_OS_MAC
 449       Qt::MetaModifier;
 450 #else
 451       Qt::ControlModifier;
 452 #endif
 453
 454   if( QApplication::keyboardModifiers() & ctrlMod )
 455     Q_EMIT( metaAction() );
 456   else
 457     Q_EMIT( action() );
 458 }