QtCollider/widgets/QcGraph.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 "QcGraph.h"
  23 #include "../QcWidgetFactory.h"
  24 #include "../style/routines.hpp"
  25
  26 #include <QPainter>
  27 #include <QMouseEvent>
  28 #include <QApplication>
  29
  30 #include <cmath>
  31
  32 QC_DECLARE_QWIDGET_FACTORY(QcGraph);
  33
  34 void QcGraphModel::append( QcGraphElement * e ) {
  35   if( _elems.count() ) {
  36     QcGraphElement *prev = _elems.last();
  37     prev->_next = e;
  38     e->_prev = prev;
  39   }
  40   _elems.append(e);
  41   Q_EMIT( appended(e) );
  42 }
  43
  44 void QcGraphModel::removeAt( int i ) {
  45   QcGraphElement *e = _elems[i];
  46   int ci = _conns.count();
  47   while( ci-- ) {
  48     Connection c = _conns[ci];
  49     if( c.a == e || c.b == e ) _conns.removeAt(ci);
  50   }
  51   if( e->_prev ) e->_prev->_next = e->_next;
  52   if( e->_next ) e->_next->_prev = e->_prev;
  53   _elems.removeAt(i);
  54   Q_EMIT( removed(e) );
  55   delete e;
  56 }
  57
  58
  59
  60 QcGraph::QcGraph() :
  61   QtCollider::Style::Client(this),
  62   _defaultThumbSize( QSize(18,18) ),
  63   _style(DotElements),
  64   _drawLines( true ),
  65   _drawRects( true ),
  66   _editable( true ),
  67   _step( 0.01 ),
  68   _selectionForm( ElasticSelection ),
  69   _xOrder( NoOrder ),
  70   _gridOn( false ),
  71   _geometryDirty( false ),
  72   _lastIndex(-1)
  73 {
  74   QPalette plt( palette() );
  75
  76   setFocusPolicy( Qt::StrongFocus );
  77   setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
  78
  79   connect( &_model, SIGNAL(removed(QcGraphElement*)), this, SLOT(onElementRemoved(QcGraphElement*)) );
  80 }
  81
  82 VariantList QcGraph::value() const
  83 {
  84   VariantList x;
  85   VariantList y;
  86   QList<QcGraphElement*> elems = _model.elements();
  87   Q_FOREACH( QcGraphElement* e, elems ) {
  88     QPointF val = e->value;
  89     x.data.append( val.x() );
  90     y.data.append( val.y() );
  91   }
  92
  93   VariantList values;
  94   values.data.append( QVariant::fromValue<VariantList>(x) );
  95   values.data.append( QVariant::fromValue<VariantList>(y) );
  96
  97   return values;
  98 }
  99
 100 QcGraphElement *QcGraph::currentElement() const
 101 {
 102   return _selection.count() ? _selection.elems.first().elem : 0;
 103 }
 104
 105 int QcGraph::index() const
 106 {
 107   QcGraphElement *e = currentElement();
 108   return e ? _model.elements().indexOf(e) : -1;
 109 }
 110
 111 float QcGraph::currentX() const
 112 {
 113   QcGraphElement *e = currentElement();
 114   return e ? e->value.x() : 0.f;
 115 }
 116
 117 float QcGraph::currentY() const
 118 {
 119   QcGraphElement *e = currentElement();
 120   return e ? e->value.y() : 0.f;
 121 }
 122
 123 void QcGraph::setValue( const VariantList &list )
 124 {
 125   if( list.data.count() != 2 ) return;
 126   VariantList xList = list.data[0].value<VariantList>();
 127   VariantList yList = list.data[1].value<VariantList>();
 128
 129   int newc = qMin( xList.data.count(), yList.data.count() );
 130   if( !newc ) return;
 131
 132   int c = _model.elementCount();
 133   while( c > newc )
 134   {
 135     --c;
 136     _model.removeAt( c );
 137   }
 138
 139   int i;
 140   for( i = 0; i < newc; ++i )
 141   {
 142     QPointF val( xList.data[i].value<float>(),
 143                 yList.data[i].value<float>() );
 144     if( i < c ) {
 145       QcGraphElement *e = _model.elementAt(i);
 146       setValue( e, val );
 147     }
 148     else {
 149       QcGraphElement *e = new QcGraphElement(_defaultThumbSize);
 150       setValue( e, val );
 151       _model.append( e );
 152     }
 153   }
 154
 155   if( newc ) ensureOrder();
 156
 157   _geometryDirty = true;
 158
 159   update();
 160 }
 161
 162 void QcGraph::setStrings( const VariantList &list )
 163 {
 164   int strc = list.data.count();
 165   int c = _model.elementCount();
 166   int i;
 167   for( i = 0; i < c && i < strc; ++i ) {
 168     QcGraphElement *e = _model.elementAt(i);
 169     e->text = list.data[i].toString();
 170   }
 171   update();
 172 }
 173
 174 void QcGraph::setCurves( const VariantList & curves )
 175 {
 176   for( int i = 0; i < curves.data.size() && i < _model.elementCount(); ++i ) {
 177     QVariant data = curves.data[i];
 178     QcGraphElement::CurveType type;
 179     double curvature;
 180     if( data.type() == QVariant::Int ) {
 181       type = (QcGraphElement::CurveType) data.toInt();
 182       curvature = 0.0;
 183     }
 184     else {
 185       type = QcGraphElement::Curvature;
 186       curvature = data.value<double>();
 187     }
 188     _model.elementAt(i)->setCurveType( type, curvature );
 189   }
 190   update();
 191 }
 192
 193 void QcGraph::setCurves( double curvature )
 194 {
 195   Q_FOREACH( QcGraphElement* e, _model.elements() )
 196     e->setCurveType( QcGraphElement::Curvature, curvature );
 197   update();
 198 }
 199
 200 void QcGraph::setCurves( int typeId )
 201 {
 202   QcGraphElement::CurveType type = (QcGraphElement::CurveType)typeId;
 203   Q_FOREACH( QcGraphElement* e, _model.elements() )
 204     e->setCurveType( type );
 205   update();
 206 }
 207
 208 void QcGraph::setStringAt( int i, const QString & str )
 209 {
 210   int c = _model.elementCount();
 211   if( i >= 0 && i < c ) {
 212     QcGraphElement *e = _model.elementAt(i);
 213     e->text = str;
 214     update();
 215   }
 216 }
 217
 218 void QcGraph::connectElements( int src, VariantList targets )
 219 {
 220   int c = _model.elementCount();
 221   if( src < 0 || src >= c ) return;
 222
 223   Q_FOREACH( QVariant var, targets.data ) {
 224     int trg = var.toInt();
 225     if( trg < 0 || trg >= c ) continue;
 226     _model.connect( src, trg );
 227   }
 228
 229   update();
 230 }
 231
 232 void QcGraph::setIndex( int i ) {
 233   select(i);
 234 }
 235
 236 void QcGraph::select( int i, bool exclusive ) {
 237   if( i >= 0 && i < _model.elementCount() ) {
 238     if( exclusive ) setAllDeselected();
 239     setIndexSelected( i, true );
 240     update();
 241   }
 242 }
 243
 244 void QcGraph::deselect( int i ) {
 245   if( i >= 0 && i < _model.elementCount() ) {
 246     setIndexSelected( i, false );
 247     update();
 248   }
 249 }
 250
 251 void QcGraph::deselectAll() {
 252   setAllDeselected();
 253 }
 254
 255 void QcGraph::setCurrentX( float f )
 256 {
 257   QcGraphElement *e = currentElement();
 258   if(!e) return;
 259
 260   QPointF val = e->value;
 261   val.setX( f );
 262   if( _xOrder != NoOrder ) orderRestrictValue(e,val,true);
 263   else restrictValue(val);
 264   e->value = val;
 265
 266   update();
 267 }
 268
 269 void QcGraph::setCurrentY( float f )
 270 {
 271   QcGraphElement *e = currentElement();
 272   if(!e) return;
 273
 274   QPointF val = e->value;
 275   val.setY( f );
 276   if( _xOrder != NoOrder ) orderRestrictValue(e,val,true);
 277   else restrictValue(val);
 278   e->value = val;
 279
 280   update();
 281 }
 282
 283 void QcGraph::setThumbSize( int s )
 284 {
 285   QSize size(s,s);
 286
 287   _defaultThumbSize = size;
 288
 289   int c = _model.elementCount();
 290   for( int i=0; i<c; ++i ) {
 291     QcGraphElement *e = _model.elementAt(i);
 292     e->size = size;
 293   }
 294
 295   _largestThumbSize = size;
 296   _geometryDirty = false;
 297
 298   update();
 299 }
 300
 301 void QcGraph::setThumbWidth( int w )
 302 {
 303   _defaultThumbSize.setWidth(w);
 304
 305   int c = _model.elementCount();
 306   for( int i=0; i<c; ++i ) {
 307     QcGraphElement *e = _model.elementAt(i);
 308     e->size.setWidth(w);
 309   }
 310
 311   // For backward compatibility, switch to style that supports
 312   // different thumb width and height:
 313   _style = RectElements;
 314   _largestThumbSize.setWidth(w);
 315
 316   update();
 317 }
 318
 319 void QcGraph::setThumbHeight( int h )
 320 {
 321   _defaultThumbSize.setHeight(h);
 322
 323   int c = _model.elementCount();
 324   for( int i=0; i<c; ++i ) {
 325     QcGraphElement *e = _model.elementAt(i);
 326     e->size.setHeight(h);
 327   }
 328
 329   // For backward compatibility, switch to style that supports
 330   // different thumb width and height:
 331   _style = RectElements;
 332   _largestThumbSize.setHeight(h);
 333
 334   update();
 335 }
 336
 337 void QcGraph::setThumbSizeAt( int i, int s )
 338 {
 339   if( i < 0 || i >= _model.elementCount() ) return;
 340   _model.elementAt(i)->size = QSize(s,s);
 341   _geometryDirty = true;
 342   update();
 343 }
 344
 345 void QcGraph::setThumbWidthAt( int i, int w )
 346 {
 347   if( i < 0 || i >= _model.elementCount() ) return;
 348   _model.elementAt(i)->size.setWidth(w);
 349   // For backward compatibility, switch to style that supports
 350   // different thumb width and height:
 351   _style = RectElements;
 352   _geometryDirty = true;
 353   update();
 354 }
 355
 356 void QcGraph::setThumbHeightAt( int i, int h )
 357 {
 358   if( i < 0 || i >= _model.elementCount() ) return;
 359   _model.elementAt(i)->size.setHeight(h);
 360   // For backward compatibility, switch to style that supports
 361   // different thumb width and height:
 362   _style = RectElements;
 363   _geometryDirty = true;
 364   update();
 365 }
 366
 367 void QcGraph::setFillColor( const QColor & color )
 368 {
 369   int c = _model.elementCount();
 370   for( int i=0; i<c; ++i ) {
 371     QcGraphElement *e = _model.elementAt(i);
 372     e->fillColor = color;
 373   }
 374   update();
 375 }
 376
 377 void QcGraph::setFillColorAt( int i, const QColor & color )
 378 {
 379   int c = _model.elementCount();
 380   if( i >= 0 && i < c ) {
 381     QcGraphElement *e = _model.elementAt(i);
 382     e->fillColor = color;
 383     update();
 384   }
 385 }
 386
 387 void QcGraph::setEditableAt( int i, bool b )
 388 {
 389   int c = _model.elementCount();
 390   if( i >= 0 && i < c ) {
 391     QcGraphElement *e = _model.elementAt(i);
 392     e->editable = b;
 393   }
 394 }
 395
 396 void QcGraph::setStep( double step )
 397 {
 398   _step = qMax( 0.0, step );
 399
 400   if( _model.elementCount() ) {
 401     ensureOrder();
 402     update();
 403   };
 404 }
 405
 406 void QcGraph::setHorizontalOrder( int i ) {
 407   _xOrder = (Order) i;
 408   if( _xOrder != NoOrder ) {
 409     ensureOrder();
 410     update();
 411   }
 412 }
 413
 414 void QcGraph::onElementRemoved( QcGraphElement *e )
 415 {
 416   _selection.elems.removeAll( SelectedElement(e) );
 417 }
 418
 419 void QcGraph::setAllDeselected()
 420 {
 421   int c = _model.elementCount();
 422   for( int i = 0; i < c; ++i ) {
 423     QcGraphElement *e = _model.elementAt(i);
 424     e->selected = false;
 425   }
 426   _selection.elems.clear();
 427 }
 428
 429 void QcGraph::setIndexSelected( int index, bool select )
 430 {
 431   Q_ASSERT( index >= 0 && index < _model.elementCount() );
 432
 433   QcGraphElement *e = _model.elementAt( index );
 434   if( e->selected == select ) return;
 435
 436   if( select ) {
 437     e->selected = true;
 438     int c = _model.elementCount();
 439     int si = 0;
 440     int i = 0;
 441     while( i < index ) {
 442       if( _model.elementAt(i)->selected ) ++si;
 443       ++i;
 444     }
 445     _selection.elems.insert( si, SelectedElement(e) );
 446     _lastIndex = index;
 447   }
 448   else {
 449     e->selected = false;
 450     _selection.elems.removeAll( SelectedElement(e) );
 451   }
 452
 453   update();
 454 }
 455
 456 inline static void qc_graph_round( double &val, double &step, bool &grid )
 457 {
 458   if( val < 0.0 ) {
 459     val = 0.0;
 460   }
 461   else if ( grid ) {
 462     double ratio = ( val + (step*0.5) > 1.0 ) ? floor(1.0/step) : round(val/step);
 463     val = ratio * step;
 464   }
 465   else if ( val > 1.0 ) {
 466     val = 1.0;
 467   }
 468 }
 469
 470 inline void QcGraph::restrictValue( QPointF & val )
 471 {
 472   double x = val.x();
 473   double y = val.y();
 474   bool grid = _step > 0.0;
 475   qc_graph_round(x,_step,grid);
 476   qc_graph_round(y,_step,grid);
 477   val.setX(x);
 478   val.setY(y);
 479 }
 480
 481 void QcGraph::orderRestrictValue( QcGraphElement *e, QPointF & val, bool selected )
 482 {
 483   restrictValue(val);
 484
 485   double x0 = e->value.x();
 486   double x = val.x();
 487
 488   if( x == x0 ) {
 489     return;
 490   }
 491   else if( x < x0 ) {
 492     // new x is smaller, check if not too small;
 493     QcGraphElement *prev = e->prev();
 494     if( prev && (selected || !prev->selected) && x < prev->value.x() )
 495       val.setX( prev->value.x() );
 496   }
 497   else {
 498     // new x is larger, check if not too large;
 499     QcGraphElement *next = e->next();
 500     if( next && (selected || !next->selected) && x > next->value.x() )
 501       val.setX( next->value.x() );
 502   }
 503 }
 504
 505 inline void QcGraph::setValue( QcGraphElement * e, const QPointF& pt )
 506 {
 507   QPointF val(pt);
 508   restrictValue( val );
 509   e->value = val;
 510 }
 511
 512 void QcGraph::ensureOrder()
 513 {
 514   int c = _model.elementCount();
 515   double x_min = 0.0;
 516   for( int i = 0; i < c; ++i ) {
 517     QcGraphElement *e = _model.elementAt(i);
 518     QPointF val = e->value;
 519     if( _xOrder != NoOrder && val.x() < x_min ) val.setX(x_min);
 520     setValue( e, val );
 521     x_min = e->value.x();
 522   }
 523 }
 524
 525 void QcGraph::moveFree( QcGraphElement *e, const QPointF & val )
 526 {
 527   if( !e->editable ) return;
 528   setValue( e, val );
 529 }
 530
 531 void QcGraph::moveOrderRestricted( QcGraphElement *e, const QPointF & val )
 532 {
 533   if( !e->editable ) return;
 534   QPointF v(val);
 535   orderRestrictValue( e, v, true );
 536   e->value = v;
 537 }
 538
 539 void QcGraph::moveSelected( const QPointF & dif, SelectionForm form, bool cached )
 540 {
 541   int c = _selection.count();
 542
 543   switch( form ) {
 544
 545   case ElasticSelection: {
 546
 547     switch( _xOrder ) {
 548
 549     case NoOrder:
 550
 551       for( int i = 0; i < c; ++i ) {
 552         SelectedElement & se = _selection.elems[i];
 553         moveFree( se.elem, (cached ? se.moveOrigin : se.elem->value) + dif );
 554       }
 555
 556       break;
 557
 558     case RigidOrder:
 559
 560       if( dif.x() <= 0 ) {
 561         for( int i = 0; i < c; ++i ) {
 562           SelectedElement & se = _selection.elems[i];
 563           moveOrderRestricted( se.elem, (cached ? se.moveOrigin : se.elem->value) + dif );
 564         }
 565       }
 566       else {
 567         for( int i = _selection.count() - 1; i >= 0; --i ) {
 568           SelectedElement & se = _selection.elems[i];
 569           moveOrderRestricted( se.elem, (cached ? se.moveOrigin : se.elem->value) + dif );
 570         }
 571       }
 572
 573       break;
 574     }
 575
 576     break;
 577   }
 578
 579   case RigidSelection: {
 580
 581     // reduce dif until acceptable by all nodes
 582     QPointF d(dif);
 583     for( int i = 0; i < c; ++i ) {
 584       SelectedElement & se = _selection.elems[i];
 585       // if any node in selection is not editable, abort, since
 586       // we want to keep the selection form!
 587       if( !se.elem->editable ) return;
 588       QPointF val0 = (cached ? se.moveOrigin : se.elem->value);
 589       QPointF val = val0 + d;
 590       if( _xOrder == NoOrder ) {
 591         restrictValue( val );
 592       }
 593       else {
 594         orderRestrictValue( se.elem, val, false );
 595       }
 596       d = val - val0;
 597     }
 598
 599     // if no dif left, do not bother moving
 600     if( d.isNull() ) return;
 601
 602     // move all with the new dif
 603     for( int i = 0; i < c; ++i ) {
 604       SelectedElement & se = _selection.elems[i];
 605       if( !se.elem->editable ) continue;
 606       se.elem->value = (cached ? se.moveOrigin : se.elem->value) + d;
 607     }
 608
 609     break;
 610   }
 611
 612
 613   }
 614 }
 615
 616 void QcGraph::addCurve( QPainterPath &path, QcGraphElement *e1, QcGraphElement *e2 )
 617 {
 618   QcGraphElement::CurveType type = e1->curveType;
 619
 620   const QPointF &pt1 = e1->value;
 621   const QPointF &pt2 = e2->value;
 622
 623   // coefficients for control points of cubic curve
 624   // approximating first quarter of sinusoid
 625   // technically: y = sin(pi*x/2) over x = [0,1]
 626   static const float ax = 1.0/3.0;
 627   static const float ay = 0.52359877f; // pi/6
 628   static const float bx = 2.0/3.0;
 629   static const float by = 1.0;
 630
 631   switch( type ) {
 632   case QcGraphElement::Step:
 633     path.moveTo( pt1 );
 634     path.lineTo( pt1.x(), pt2.y() );
 635     path.lineTo( pt2 );
 636     break;
 637   case QcGraphElement::Linear:
 638     path.moveTo( pt1 );
 639     path.lineTo( pt2 );
 640     break;
 641   case QcGraphElement::Sine: {
 642     // half of difference between end points
 643     float dx = (pt2.x() - pt1.x()) * 0.5f;
 644     float dy = (pt2.y() - pt1.y()) * 0.5f;
 645
 646     // middle point
 647     QPointF mid = pt1 + QPointF( dx, dy );
 648
 649     path.moveTo( pt1 );
 650     path.cubicTo( pt1 + QPointF( dx*(1-bx), dy*(1-by) ), pt1 + QPointF( dx*(1-ax), dy*(1-ay) ), mid );
 651     path.cubicTo( mid + QPointF( dx*ax, dy*ay ), mid + QPointF( dx*bx, dy*by ), pt2 );
 652
 653     break;
 654   }
 655   case QcGraphElement::Welch: {
 656     // difference between points
 657     float dx = (pt2.x() - pt1.x());
 658     float dy = (pt2.y() - pt1.y());
 659
 660     path.moveTo( pt1 );
 661     if( dy > 0 )
 662       path.cubicTo( pt1 + QPointF( dx*ax, dy*ay ), pt1 + QPointF( dx*bx, dy*by ), pt2 );
 663     else
 664       path.cubicTo( pt1 + QPointF( dx*(1-bx), dy*(1-by) ), pt1 + QPointF( dx*(1-ax), dy*(1-ay) ), pt2 );
 665
 666     break;
 667   }
 668   case QcGraphElement::Exponential: {
 669
 670     // FIXME: find a Bezier curve approximation
 671
 672     path.moveTo( pt1 );
 673
 674     float dx = (pt2.x() - pt1.x());
 675     float dy = (pt2.y() - pt1.y());
 676
 677     // prevent NaN, optimize
 678     if( pt1.y() <= 0.f || pt2.y() <= 0.f ) {
 679       path.lineTo( dy < 0 ? QPointF(pt1.x(),pt2.y()) : QPointF(pt2.x(), pt1.y()) );
 680       path.lineTo( pt2 );
 681     }
 682     else {
 683       const float n = 100.f;
 684       const float yratio = pt2.y() / pt1.y();
 685       for( float ph=1/n; ph<=(1-1/n); ph+=1/n ) {
 686         qreal y = pt1.y() * pow( yratio, ph );
 687         path.lineTo( pt1.x() + (dx * ph), y );
 688       }
 689       path.lineTo( pt2 );
 690     }
 691
 692     break;
 693   }
 694   case QcGraphElement::Curvature:
 695
 696     // FIXME: find a Bezier curve approximation
 697
 698     path.moveTo( pt1 );
 699
 700     // prevent NaN
 701     double curve = qBound( -100.0, e1->curvature, 100.0 );
 702
 703     if( std::abs( curve ) < 0.0001 ) {
 704       path.lineTo( pt2 );
 705     }
 706     else {
 707       float dx = (pt2.x() - pt1.x());
 708       float dy = (pt2.y() - pt1.y());
 709       double denom = 1.0 - exp( curve );
 710       const float n = 100.f;
 711       for( float ph=1/n; ph<=(1-1/n); ph+=1/n ) {
 712         double numer = 1.0 - exp( ph * curve );
 713         qreal y = pt1.y() + dy * (numer / denom);
 714         path.lineTo( pt1.x() + (dx * ph), y );
 715       }
 716       path.lineTo( pt2 );
 717     }
 718     break;
 719   }
 720 }
 721
 722 QSize QcGraph::drawnElementSize( QcGraphElement *e )
 723 {
 724   if (_style == DotElements) {
 725     int s = qMin(e->size.width(), e->size.height());
 726     return QSize(s,s);
 727   }
 728   else
 729     return e->size;
 730 }
 731
 732 QRect QcGraph::valueRect()
 733 {
 734   using namespace QtCollider::Style;
 735
 736   if (_geometryDirty)
 737   {
 738       int w = 0;
 739       int h = 0;
 740       int c = _model.elementCount();
 741       if (_style == RectElements)
 742       {
 743           for (int i = 0; i < c; ++i) {
 744               QSize s = _model.elementAt(i)->size;
 745               w = qMax(w, s.width());
 746               h = qMax(h, s.height());
 747           }
 748       }
 749       else
 750       {
 751           for (int i = 0; i < c; ++i) {
 752               QSize s = _model.elementAt(i)->size;
 753               w = qMax(w, qMin(s.width(), s.height()));
 754           }
 755           h = w;
 756       }
 757       _largestThumbSize = QSize(w,h);
 758       _geometryDirty = false;
 759   }
 760
 761   return marginsRect( sunkenContentsRect( rect() ), _largestThumbSize ).adjusted(1,1,-1,-1);
 762 }
 763
 764 QRectF QcGraph::labelRect( QcGraphElement *e, const QPointF &pt, const QRect &bounds, const QFontMetrics &fm )
 765 {
 766   QRectF textRect( fm.boundingRect(e->text) );
 767   QSize sz( drawnElementSize(e) );
 768   qreal hnd_w_2 = sz.width() * 0.5;
 769   qreal hnd_h_2 = sz.height() * 0.5;
 770   textRect.moveBottomLeft( pt + QPointF(hnd_w_2, -hnd_h_2) );
 771   if( textRect.y() < bounds.y() )
 772     textRect.moveTop( pt.y() + hnd_h_2 );
 773   if( textRect.right() > bounds.right() )
 774     textRect.moveRight( pt.x() - hnd_w_2 );
 775   return textRect;
 776 }
 777
 778 void QcGraph::paintEvent( QPaintEvent * )
 779 {
 780   using namespace QtCollider::Style;
 781   using QtCollider::Style::Ellipse;
 782   using QtCollider::Style::RoundRect;
 783
 784   QPainter p( this );
 785   const QPalette & plt = palette();
 786
 787   p.setRenderHint( QPainter::Antialiasing, true );
 788   RoundRect frame(rect(), 2);
 789   drawSunken( &p, plt, frame, background(), hasFocus() ? focusColor() : QColor() );
 790   p.setRenderHint( QPainter::Antialiasing, false );
 791
 792   QRect contentsRect( valueRect() );
 793
 794   //draw grid;
 795
 796   p.setPen( gridColor() );
 797   p.setBrush( Qt::NoBrush );
 798   p.drawRect( contentsRect );
 799
 800   if( _gridOn ) {
 801     float dx = _gridMetrics.x();
 802     float dy = _gridMetrics.y();
 803     float cl = contentsRect.left();
 804     float cr = contentsRect.right();
 805     float ct = contentsRect.top();
 806     float cb = contentsRect.bottom();
 807
 808     if( contentsRect.width() > 0.f && dx > 0.f && dx < 1.f ) {
 809       dx *= contentsRect.width();
 810       int i = 1;
 811       float x;
 812       while( (x = i * dx + cl) < cr ) {
 813         p.drawLine( x, ct, x, cb );
 814         ++i;
 815       }
 816     }
 817
 818     if( contentsRect.height() > 0.f && dy > 0.f && dy < 1.f ) {
 819       dy *= contentsRect.height();
 820       int i = 1;
 821       float y;
 822       while( (y = cb - i * dy) > ct ) {
 823         p.drawLine( cl, y, cr, y );
 824         ++i;
 825       }
 826     }
 827   }
 828
 829   QList<QcGraphElement*> elems = _model.elements();
 830
 831   int c = elems.count();
 832   if( !c ) return;
 833
 834   const QColor & strokeClr = strokeColor();
 835
 836   p.setPen( strokeClr );
 837
 838   // draw lines;
 839   if( _drawLines ) {
 840
 841     QPainterPath lines;
 842     QList<QcGraphModel::Connection> conns = _model.connections();
 843
 844     if( conns.count() ) {
 845
 846       Q_FOREACH( QcGraphModel::Connection c, conns ) {
 847         addCurve( lines, c.a, c.b );
 848       }
 849
 850     }
 851     else {
 852
 853       QcGraphElement *e1 = elems[0];
 854       int i;
 855       for( i = 1; i < c; ++i ) {
 856         QcGraphElement *e2 = elems[i];
 857         addCurve( lines, e1, e2 );
 858         e1 = e2;
 859       }
 860
 861     }
 862
 863     p.save();
 864     p.setRenderHint( QPainter::Antialiasing, true );
 865     p.setBrush( Qt::NoBrush );
 866     p.translate( contentsRect.x(), contentsRect.y() + contentsRect.height() );
 867     p.scale( contentsRect.width(), -contentsRect.height() );
 868     p.drawPath( lines );
 869     p.restore();
 870   }
 871
 872   // draw rects and strings
 873   if( _drawRects ) {
 874
 875     p.setRenderHint( QPainter::Antialiasing, true );
 876
 877     QFontMetrics fm( font() );
 878     QColor rectColor = plt.color(QPalette::Button).lighter(105);
 879     QColor circleColor = rectColor; circleColor.setAlpha(70);
 880     QColor dotColor = plt.color(QPalette::Text);
 881     const QColor & selectClr = selectionColor();
 882     QRectF rect;
 883     QPointF pt;
 884     int i;
 885
 886     for( i = 0; i < c; ++i ) {
 887
 888       QcGraphElement *e = elems[i];
 889
 890       rect.setSize( drawnElementSize(e) );
 891
 892       pt = Style::pos( e->value, contentsRect );
 893       rect.moveCenter( pt.toPoint() );
 894
 895       if( _style == DotElements )
 896           drawDotElement(e, rect, contentsRect,
 897                          dotColor, circleColor, strokeClr, selectClr,
 898                          plt, fm, &p);
 899       else
 900           drawRectElement(e, rect, rectColor, strokeClr, selectClr, plt, &p  );
 901
 902     }
 903
 904   }
 905 }
 906
 907 void QcGraph::drawDotElement
 908 ( QcGraphElement *e, const QRectF &rect, const QRect & bounds,
 909   const QColor & dotColor, const QColor & circleColor,
 910   const QColor & textColor, const QColor & selectColor,
 911   const QPalette &plt, const QFontMetrics &fm, QPainter *p )
 912 {
 913   using namespace QtCollider::Style;
 914   using QtCollider::Style::Ellipse;
 915
 916   // base
 917   Ellipse thumb(rect);
 918   drawRaised( p, plt, thumb, circleColor );
 919
 920   // marker
 921   QRectF r( thumb._rect );
 922   qreal wdif = r.width() * 0.3;
 923   qreal hdif = r.height() * 0.3;
 924   p->setPen( Qt::NoPen );
 925   p->setBrush( e->fillColor.isValid() ? e->fillColor : dotColor );
 926   p->drawEllipse( r.adjusted( wdif, hdif, -wdif, -hdif ) );
 927
 928   // selection indicator
 929   if( e->selected ) {
 930     p->setBrush(Qt::NoBrush);
 931     p->setPen( selectColor );
 932     p->drawEllipse( thumb._rect.adjusted(1,1,-1,-1) );
 933   }
 934
 935   // label
 936   p->setPen( textColor );
 937   QString text = e->text;
 938   if( !text.isEmpty() ) {
 939     QRectF lblRect( labelRect( e, rect.center(), bounds, fm ) );
 940     p->drawText( lblRect, 0, text );
 941   }
 942 }
 943
 944 void QcGraph::drawRectElement
 945 (
 946   QcGraphElement *e, const QRectF &rect,
 947   const QColor & fillColor,
 948   const QColor & textColor,
 949   const QColor & selectColor,
 950   const QPalette &plt, QPainter *p )
 951 {
 952   using namespace QtCollider::Style;
 953   using QtCollider::Style::RoundRect;
 954
 955   // base
 956   RoundRect base(rect, 5);
 957   drawRaised( p, plt, base, e->fillColor.isValid() ? e->fillColor : fillColor  );
 958
 959   // selection indicator
 960   if( e->selected ) {
 961     p->setBrush(Qt::NoBrush);
 962     p->setPen( selectColor );
 963     p->drawRoundedRect( base._rect, 5, 5 );
 964   }
 965
 966     // label
 967   p->setPen( textColor );
 968   QString text = e->text;
 969   if( !text.isEmpty() ) {
 970     p->drawText( rect, Qt::AlignCenter, text );
 971   }
 972 }
 973
 974 void QcGraph::mousePressEvent( QMouseEvent *ev )
 975 {
 976   using namespace QtCollider::Style;
 977
 978   QList<QcGraphElement*> elems = _model.elements();
 979   int c = elems.count();
 980   if( !c ) return;
 981
 982   QPointF mpos = ev->pos();
 983   QRectF valueRect( this->valueRect() );
 984
 985   QRectF r;
 986
 987   int i;
 988   for( i = 0; i < c; ++i ) {
 989     QcGraphElement *e = elems[i];
 990     r.setSize( drawnElementSize(e) );
 991     QPointF pt( Style::pos( e->value, valueRect ) );
 992     r.moveCenter( pt );
 993     if( r.contains( mpos ) ) {
 994
 995       if( ev->modifiers() & Qt::ShiftModifier ) {
 996         setIndexSelected( i, !e->selected );
 997       }
 998       else {
 999         if( !e->selected ) {
1000           setAllDeselected();
1001           setIndexSelected( i, true );
1002         }
1003       }
1004
1005       _selection.cached = false;
1006       if( e->selected ) {
1007           // if the element that was hit ended up selected
1008           // prepare for moving
1009         _selection.shallMove = true;
1010         _selection.moveOrigin = Style::value(mpos, valueRect);
1011       }
1012       else {
1013         _selection.shallMove = false;
1014       }
1015
1016       update();
1017       return;
1018     }
1019   }
1020
1021   _selection.shallMove = false;
1022
1023   if( !(ev->modifiers() & Qt::ShiftModifier) ) {
1024     setAllDeselected();
1025   }
1026
1027   update();
1028 }
1029
1030 void QcGraph::mouseMoveEvent( QMouseEvent *ev )
1031 {
1032   using namespace QtCollider::Style;
1033
1034   if( !ev->buttons() ) return;
1035
1036   if( !_editable || !_selection.shallMove || !_selection.size() ) return;
1037
1038   if( !_selection.cached ) {
1039     int c = _selection.count();
1040     for( int i = 0; i < c; ++i ) {
1041       SelectedElement &se = _selection.elems[i];
1042       se.moveOrigin = se.elem->value;
1043     }
1044     _selection.cached = true;
1045   }
1046
1047   QRectF valueRect( this->valueRect() );
1048   QPointF dValue( Style::value( ev->pos(), valueRect ) );
1049   dValue = dValue - _selection.moveOrigin;
1050
1051   moveSelected( dValue, _selectionForm, true );
1052
1053   update();
1054   doAction( ev->modifiers() );
1055 }
1056
1057 void QcGraph::keyPressEvent( QKeyEvent *event )
1058 {
1059   int mods = event->modifiers();
1060   if( mods & Qt::AltModifier || mods & Qt::ShiftModifier )
1061   {
1062     // selection mode
1063
1064     int c = _model.elementCount();
1065     if(!c) return;
1066
1067     switch( event->key() ) {
1068       case Qt::Key_Right:
1069       {
1070           // select the index after the last selected one (wrapping)
1071           // or extend selection to the right
1072
1073           int i = -1;
1074           if(_selection.count()) {
1075               for (i = c - 1; i >= 0; --i) {
1076                   if(_model.elementAt(i)->selected)
1077                       break;
1078               }
1079           }
1080
1081           if( event->modifiers() & Qt::ShiftModifier ) {
1082               i = qMin(i + 1, c - 1);
1083               setIndexSelected( i, true );
1084           }
1085           else {
1086               ++i;
1087               if (i >= c) i = 0;
1088               setAllDeselected();
1089               setIndexSelected( i, true );
1090           }
1091
1092           break;
1093       }
1094       case Qt::Key_Left:
1095       {
1096           // select the index before the first selected one (wrapping)
1097           // or extend selection to the left
1098           int i = c;
1099           if(_selection.count()) {
1100               for(i = 0; i < c; ++i) {
1101                   if(_model.elementAt(i)->selected)
1102                       break;
1103               }
1104           }
1105
1106           if( event->modifiers() & Qt::ShiftModifier ) {
1107               i = qMax(i - 1, 0);
1108               setIndexSelected( i, true );
1109           }
1110           else {
1111               --i;
1112               if (i < 0) i = c - 1;
1113               setAllDeselected();
1114               setIndexSelected( i, true );
1115           }
1116
1117           break;
1118       }
1119       default: break;
1120     }
1121   }
1122   else
1123   {
1124     // editing mode
1125
1126     if( !_editable || !_selection.size() ) return;
1127
1128     QPointF dValue;
1129
1130     switch( event->key() ) {
1131       case Qt::Key_Up:
1132         dValue.setY( _step );
1133         break;
1134       case Qt::Key_Down:
1135         dValue.setY( - _step );
1136         break;
1137       case Qt::Key_Right:
1138         dValue.setX( _step );
1139         break;
1140       case Qt::Key_Left:
1141         dValue.setX( - _step );
1142         break;
1143       default:
1144         return;
1145     }
1146
1147     moveSelected( dValue, _selectionForm, false );
1148
1149     update();
1150     doAction( event->modifiers() );
1151   }
1152 }
1153
1154 void QcGraph::doAction( Qt::KeyboardModifiers mods )
1155 {
1156   Qt::KeyboardModifier ctrlMod =
1157 #ifdef Q_OS_MAC
1158       Qt::MetaModifier;
1159 #else
1160       Qt::ControlModifier;
1161 #endif
1162
1163   if( mods & ctrlMod )
1164     Q_EMIT( metaAction() );
1165   else
1166     Q_EMIT( action() );
1167 }