QtCollider/widgets/QcRangeSlider.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 "QcRangeSlider.h"
  23 #include "../QcWidgetFactory.h"
  24 #include "../style/routines.hpp"
  25
  26 #include <QKeyEvent>
  27 #include <QMouseEvent>
  28 #include <QApplication>
  29 #include <QPainter>
  30
  31 #define HND 10
  32
  33 QC_DECLARE_QWIDGET_FACTORY(QcRangeSlider);
  34
  35 QcRangeSlider::QcRangeSlider() :
  36   QtCollider::Style::Client(this),
  37   _lo( 0.f ),
  38   _hi( 1.f ),
  39   _step( 0.01f ),
  40   mouseMode( None )
  41 {
  42   setFocusPolicy( Qt::StrongFocus );
  43   setOrientation( Qt::Vertical );
  44 }
  45
  46 void QcRangeSlider::setOrientation( Qt::Orientation o )
  47 {
  48   _ort = o;
  49
  50   if( _ort == Qt::Horizontal ) {
  51     setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
  52   }
  53   else {
  54     setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Expanding );
  55   }
  56
  57   updateGeometry();
  58   update();
  59 }
  60
  61 void QcRangeSlider::setLoValue( float val )
  62 {
  63   val = qMax( 0.f, qMin( 1.f, val ) );
  64   if( val <= _hi ) {
  65     _lo = val;
  66   }
  67   else {
  68     _lo = _hi;
  69     _hi = val;
  70   }
  71   update();
  72 }
  73
  74 void QcRangeSlider::setHiValue( float val )
  75 {
  76   val = qMax( 0.f, qMin( 1.f, val ) );
  77   if( val >= _lo ) {
  78     _hi = val;
  79   }
  80   else {
  81     _hi = _lo;
  82     _lo = val;
  83   }
  84   update();
  85 }
  86
  87 void QcRangeSlider::setRange( double val, double range )
  88 {
  89   range = qBound( 0.0, range, 1.0 );
  90   _lo = qBound( 0.0, val, 1.0 - range);
  91   _hi = _lo + range;
  92   update();
  93 }
  94
  95 QSize QcRangeSlider::sizeHint() const
  96 {
  97   return ( _ort == Qt::Horizontal ? QSize( 150, 20 ) : QSize( 20, 150 ) );
  98 }
  99
 100 QSize QcRangeSlider::minimumSizeHint() const
 101 {
 102   return ( _ort == Qt::Horizontal ? QSize( 30, 20 ) : QSize( 20, 30 ) );
 103 }
 104
 105 void QcRangeSlider::increment( double factor )
 106 {
 107   moveBy( factor * _step );
 108 }
 109
 110 void QcRangeSlider::decrement( double factor )
 111 {
 112   moveBy( -factor * _step );
 113 }
 114
 115 void QcRangeSlider::increment()
 116 {
 117   float step = _step;
 118   modifyStep( &step );
 119   moveBy( step );
 120 }
 121
 122 void QcRangeSlider::decrement()
 123 {
 124   float step = _step;
 125   modifyStep( &step );
 126   moveBy( -step );
 127 }
 128
 129 QRect QcRangeSlider::thumbRect()
 130 {
 131   using namespace QtCollider::Style;
 132   QRect contRect( sunkenContentsRect(rect()) );
 133   int hnd2 = HND * 2;
 134   if( _ort == Qt::Horizontal ) {
 135     double valRange = contRect.width() - hnd2;
 136     double left = _lo * valRange;
 137     double right = _hi * valRange; right += hnd2;
 138     return QRect( left + contRect.x(), contRect.y(), right - left, contRect.height() );
 139   }
 140   else {
 141     double valRange = contRect.height() - hnd2;
 142     int up = (1.0 - _hi) * valRange;
 143     int down = (1.0 - _lo) * valRange; down += hnd2;
 144     return QRect( contRect.x(), contRect.y() + up, contRect.width(), down - up );
 145   }
 146 }
 147
 148 double QcRangeSlider::valueFromPos( const QPoint& pos )
 149 {
 150   using namespace QtCollider::Style;
 151
 152   bool horiz = _ort == Qt::Horizontal;
 153
 154   QSize margins = horiz ? QSize(HND*2, 0) : QSize(0, HND*2);
 155   QRect valBounds = marginsRect( sunkenContentsRect(rect()), margins );
 156
 157   return horiz ? xValue( pos.x(), valBounds ) : yValue( pos.y(), valBounds );
 158 }
 159
 160 void QcRangeSlider::moveBy( float dif )
 161 {
 162   if( _lo + dif < 0.f ) {
 163     _hi += 0.f - _lo;
 164     _lo = 0.f;
 165   }
 166   else if( _hi + dif > 1.f ) {
 167     _lo += 1.f - _hi;
 168     _hi = 1.f;
 169   }
 170   else {
 171     _lo += dif;
 172     _hi += dif;
 173   }
 174   update();
 175 }
 176
 177 void QcRangeSlider::mouseMoveEvent ( QMouseEvent * e )
 178 {
 179   using namespace QtCollider::Style;
 180
 181   if( !e->buttons() ) return;
 182
 183   if( mouseMode == SetHi || mouseMode == SetLo )
 184   {
 185     float val = valueFromPos( e->pos() );
 186     if( mouseMode == SetLo ) {
 187       if( val > _hi ) mouseMode = SetHi;
 188       setLoValue( val );
 189     }
 190     else if( mouseMode == SetHi ) {
 191       if( val < _lo ) mouseMode = SetLo;
 192       setHiValue( val );
 193     }
 194   }
 195   else if( mouseMode != None )
 196   {
 197     QPoint pt = e->pos() - dragOrigin;
 198     QRect contRect( sunkenContentsRect(rect()) );
 199
 200     double dif;
 201     if( _ort == Qt::Horizontal ) {
 202       double range = contRect.width() - HND*2;
 203       dif = range > 0 ?  pt.x() / range : 0.0;
 204     }
 205     else {
 206       double range = contRect.height() - HND*2;
 207       dif = range > 0 ? - pt.y() / range : 0.0;
 208     }
 209
 210     if( dif != 0.0 ) {
 211       switch( mouseMode ) {
 212         case Move:
 213           setRange( dragVal + dif, dragRange ); break;
 214         case MoveHi:
 215           setHiValue( qMax(dragVal + dif, (double)_lo) ); break;
 216         case MoveLo:
 217           setLoValue( qMin(dragVal + dif, (double)_hi) ); break;
 218       }
 219     }
 220   }
 221
 222   Q_EMIT( action() );
 223 }
 224
 225 void QcRangeSlider::mousePressEvent ( QMouseEvent * e )
 226 {
 227   using namespace QtCollider::Style;
 228
 229   if( e->modifiers() & Qt::ShiftModifier ) {
 230     double center = (_hi + _lo) * 0.5;
 231     double val = valueFromPos( e->pos() );
 232     if( val < center ) {
 233       mouseMode = SetLo;
 234       setLoValue( val );
 235     }
 236     else {
 237       mouseMode = SetHi;
 238       setHiValue( val );
 239     }
 240     Q_EMIT( action() );
 241   }
 242   else {
 243     QRect thumb( thumbRect() );
 244
 245     int len, pos;
 246
 247     if( _ort == Qt::Horizontal ) {
 248       len = thumb.width();
 249       pos = e->pos().x() - thumb.left();
 250     }
 251     else {
 252       len = thumb.height();
 253       pos = thumb.top() + len - e->pos().y();
 254     }
 255
 256     if( pos < 0 || pos > len ) return;
 257
 258     dragOrigin = e->pos();
 259
 260     if( pos < HND ) {
 261       mouseMode = MoveLo;
 262       dragVal = _lo;
 263     }
 264     else if( pos >= len - HND ) {
 265       mouseMode = MoveHi;
 266       dragVal = _hi;
 267     }
 268     else {
 269       mouseMode = Move;
 270       dragVal = _lo;
 271       dragRange = _hi - _lo;
 272     }
 273   }
 274
 275   update();
 276 }
 277
 278 void QcRangeSlider::mouseReleaseEvent ( QMouseEvent * e )
 279 {
 280   Q_UNUSED(e);
 281   mouseMode = None;
 282 }
 283
 284 void QcRangeSlider::keyPressEvent ( QKeyEvent *e )
 285 {
 286   switch( e->key() ) {
 287     case Qt::Key_Up:
 288     case Qt::Key_Right:
 289       increment(); break;
 290     case Qt::Key_Down:
 291     case Qt::Key_Left:
 292       decrement(); break;
 293     case Qt::Key_A:
 294       _lo = 0.f; _hi = 1.f; update(); break;
 295     case Qt::Key_N:
 296       _lo = 0.f; _hi = 0.f; update(); break;
 297     case Qt::Key_X:
 298       _lo = 1.f; _hi = 1.f; update(); break;
 299     case Qt::Key_C:
 300       _lo = 0.5; _hi = 0.5; update(); break;
 301     default:
 302       return QWidget::keyPressEvent( e );
 303   }
 304   Q_EMIT( action() );
 305 }
 306
 307 inline void drawMarker( QPainter *p, const QPalette &plt, Qt::Orientation ort, bool first, const QPoint & pt, int len )
 308 {
 309   p->save();
 310   p->setRenderHint( QPainter::Antialiasing, false );
 311
 312   QPen pen(plt.color(QPalette::ButtonText));
 313
 314   bool vert = ort == Qt::Vertical;
 315
 316   if(vert) {
 317     pen.setWidth(1); p->setPen(pen);
 318     p->drawPoint( QPoint( pt.x() + len * 0.5, first ? pt.y() - 5 : pt.y() + 5 ) );
 319
 320     pen.setWidth(2); p->setPen(pen);
 321     QLine line( pt.x() + 1, pt.y(), pt.x() + len - 1, pt.y() );
 322     p->drawLine(line);
 323   } else {
 324     pen.setWidth(1); p->setPen(pen);
 325     p->drawPoint( QPoint( first ? pt.x() - 5 : pt.x() + 5, pt.y() + len * 0.5 ) );
 326
 327     pen.setWidth(2); p->setPen(pen);
 328     QLine line( pt.x(), pt.y() + 1, pt.x(), pt.y() + len - 1 );
 329     p->drawLine(line);
 330   }
 331   p->restore();
 332 }
 333
 334 void QcRangeSlider::paintEvent ( QPaintEvent *e )
 335 {
 336   using namespace QtCollider::Style;
 337
 338   Q_UNUSED(e);
 339
 340   QPainter p(this);
 341   p.setRenderHint( QPainter::Antialiasing, true );
 342
 343   QPalette plt = palette();
 344
 345   RoundRect frame(rect(), 2);
 346   QColor baseColor( grooveColor() );
 347   drawSunken( &p, plt, frame, baseColor, hasFocus() ? focusColor() : QColor() );
 348
 349   QRect contRect( sunkenContentsRect(rect()) );
 350
 351   QRect hndRect;
 352   QRect valRect;
 353   int HND2 = HND * 2;
 354   bool horiz = _ort == Qt::Horizontal;
 355
 356   if( horiz ) {
 357     double valRange = contRect.width() - HND2;
 358     int lo = _lo * valRange;
 359     int hi = _hi * valRange;
 360     valRect = QRect( lo + HND + contRect.x(), contRect.y(), hi - lo, contRect.height() );
 361     hndRect = valRect.adjusted( -HND, 0, HND, 0 );
 362   }
 363   else {
 364     double valRange = contRect.height() - HND2;
 365     int hi = _hi * valRange;
 366     int lo = _lo * valRange;
 367     valRect = QRect( contRect.x(), contRect.y() + contRect.height() - hi - HND, contRect.width(), hi - lo );
 368     hndRect = valRect.adjusted( 0, -HND, 0, HND );
 369   }
 370
 371   // handle
 372
 373   RoundRect handle(hndRect, 2);
 374   drawRaised( &p, plt, handle, plt.color(QPalette::Button).lighter(105) );
 375
 376   // markers
 377
 378   if( horiz ) {
 379     int mark_len = hndRect.height() - 4;
 380
 381     QPoint pt( hndRect.left() + HND, hndRect.top() + 2 );
 382     drawMarker( &p, plt, _ort, true, pt, mark_len );
 383
 384     pt.setX( hndRect.right() - HND + 1 );
 385     drawMarker( &p, plt, _ort, false, pt, mark_len );
 386   } else {
 387     int mark_len = hndRect.width() - 4;
 388     QPoint pt( hndRect.left() + 2, hndRect.top() + HND );
 389     drawMarker( &p, plt, _ort, true, pt, mark_len );
 390
 391     pt.setY( hndRect.bottom() - HND + 1 );
 392     drawMarker( &p, plt, _ort, false, pt, mark_len );
 393   }
 394
 395   // value region
 396
 397   if( horiz ? valRect.width() > 2 : valRect.height() > 2 ) {
 398     p.setRenderHint( QPainter::Antialiasing, false );
 399
 400     QColor c( plt.color(QPalette::ButtonText) );
 401     c.setAlpha(50);
 402
 403     p.setPen(Qt::NoPen);
 404     p.setBrush(c);
 405     if( horiz )
 406       p.drawRect(valRect.adjusted( 1, 2, -1, -2 ));
 407     else
 408       p.drawRect(valRect.adjusted( 2, 1, -2, -1 ));
 409   }
 410 }