Code/Sandbox/Plugins/LodGeneratorPlugin/control/RampControl.cpp

   1 #include "StdAfx.h"
   2 #include "RampControl.h"
   3 #include <algorithm>
   4 #include <QPainter>
   5 #include <QMouseEvent>
   6 #include <QAction>
   7 #include <QMenu>
   8 #include "../panel/LODInterface.h"
   9
  10 using namespace LODGenerator;
  11
  12 /*****************************************************************************************************/
  13 CCRampControl::CCRampControl()
  14 {
  15         m_max = 5;
  16         m_ptLeftDown = QPoint(0,0);
  17         m_bLeftDown = false;
  18         m_menuPoint.setX(0);
  19         m_menuPoint.setY(0);
  20         m_movedHandles = false;
  21         m_canMoveSelected = false;
  22         m_mouseMoving = false;
  23 }
  24
  25 CCRampControl::CCRampControl(QWidget* qWidget):QWidget(qWidget)
  26 {
  27         m_max = 5;
  28         m_ptLeftDown = QPoint(0,0);
  29         m_bLeftDown = false;
  30         m_menuPoint.setX(0);
  31         m_menuPoint.setY(0);
  32         m_movedHandles = false;
  33         m_canMoveSelected = false;
  34         m_mouseMoving = false;
  35
  36         setMouseTracking(true);
  37 }
  38
  39 CCRampControl::~CCRampControl()
  40 {
  41
  42 }
  43
  44 void CCRampControl::SetStats(RampControlMeshInfo stats)
  45 {
  46         m_currentStats = stats;
  47 }
  48
  49 void CCRampControl::DrawBackground(QPainter& painter)
  50 {
  51         CLodGeneratorInteractionManager* pInstance = CLodGeneratorInteractionManager::Instance();
  52         const int nNumMoves = pInstance->GetNumMoves();
  53
  54         QPen pen;
  55         pen.setWidth(0.1);
  56         //pen.setColor(QColor(128,128,128));
  57         pen.setColor(QColor(0,255,0));
  58         painter.setPen(pen);
  59
  60         QRect rc= this->rect();
  61         painter.setBackgroundMode(Qt::OpaqueMode);
  62
  63         {
  64                 m_selectedError=-1.0f;
  65                 m_totalError = 0.0f;
  66
  67                 for (int i=0; i<nNumMoves; i++)
  68                 {
  69                         m_totalError+=pInstance->GetErrorAtMove(i);
  70                 }
  71
  72                 if (m_totalError>0.0f)
  73                 {
  74                         m_totalError=logf(m_totalError);
  75                 }
  76                 else
  77                 {
  78                         m_totalError=1.0f;
  79                 }
  80
  81                 //pen.setColor(QColor(64,64,64));
  82                 pen.setColor(QColor(255,0,255));
  83                 painter.setPen(pen);
  84
  85                 float bar=floorf(m_totalError);
  86
  87                 /*
  88                 while (bar>0.0f)
  89                 {
  90                         QRect lrc=rc;
  91
  92                         lrc.setBottom(lrc.bottom() - (int)(rc.height()*bar/m_totalError));
  93                         lrc.setTop(lrc.bottom()-1);
  94
  95                         pen.setColor(QColor(255,0,255));
  96                         painter.setPen(pen);
  97                         //pen.setColor(QColor(64,64,64));
  98                         painter.drawRect(lrc);
  99                         bar-=2;
 100                 }
 101                 */
 102
 103                 pen.setColor(QColor(255,255,255));
 104                 painter.setPen(pen);
 105                 float currentError=0.0f;
 106                 int lastX=-1;
 107
 108                 float yScale=(nNumMoves>1)?(1.0f/(float)(nNumMoves-1)):1.0f;
 109                 for (int i=0; i<nNumMoves; i++)
 110                 {
 111                         QRect lrc;
 112                         lrc.setLeft(lrc.left() + +(int)floorf(rc.width()*(1.0f-i*yScale)));
 113                         if (lrc.left()!=lastX)
 114                         {
 115                                 lrc.setRight(lrc.left() + 1);
 116                                 lrc.setBottom(rc.bottom() -(int)(rc.height()*((currentError==0.0f)?0.0f:logf(currentError))/m_totalError));
 117                                 lrc.setTop(lrc.bottom()-1);
 118
 119                                 pen.setColor(QColor(255,255,255));
 120                                 painter.setPen(pen);
 121                                 painter.drawRect(lrc);
 122                                 lastX=lrc.left();
 123                         }
 124
 125                         HandleData handleData;
 126                         if ( GetSelectedData(handleData) )
 127                         {
 128                                 float selectedPercentage=handleData.percentage;
 129                                 int selected=(int)floorf(nNumMoves*(1.0f-selectedPercentage/100.0f)+0.5f);
 130                                 if (i==selected)
 131                                 {
 132                                         m_selectedError=currentError;
 133                                 }
 134                         }
 135
 136                         currentError+=pInstance->GetErrorAtMove(i);
 137                 }
 138         }
 139 }
 140
 141 void CCRampControl::DrawForeground(QPainter& painter)
 142 {
 143         QPen pen;
 144         pen.setWidth(1);
 145         pen.setColor(QColor(255,255,255));
 146         painter.setPen(pen);
 147         QRect rc= this->rect();
 148         painter.setBackgroundMode(Qt::TransparentMode);
 149
 150         HandleData handleData;
 151         if ( GetSelectedData(handleData) )
 152         {
 153                 IStatObj::SStatistics loadedStats = CLodGeneratorInteractionManager::Instance()->GetLoadedStatistics();
 154                 QString str;
 155                 int tris=m_currentStats.nIndices/3;
 156                 int verts=m_currentStats.nVertices;
 157                 if ( tris != 0 && verts != 0 )
 158                 {
 159                         int tempValue;
 160                         QRect ret;
 161                         tempValue = (int)(((float)tris / (float)(loadedStats.nIndices/3)) * 100.0f);
 162                         str = QString("Tris:%1 ( %2 %)\n").arg(tris).arg(tempValue);
 163                         painter.drawText(rc,Qt::AlignRight | Qt::TextSingleLine,str,&ret);
 164                         //dc.DrawText(str, rc, DT_RIGHT|DT_SINGLELINE|DT_END_ELLIPSIS);
 165                         rc.setTop(rc.top() + ret.height());
 166                         tempValue = (int)(((float)verts / (float)loadedStats.nVertices) * 100.0f);
 167                         str = QString("Verts:%1 ( %2 %)\n").arg(verts).arg(tempValue);
 168                         painter.drawText(rc,Qt::AlignRight | Qt::TextSingleLine,str,&ret);
 169                         rc.setTop(rc.top() + ret.height());
 170                         str = QString("Error:%1 \n").arg(m_selectedError);//arg(QString::number(m_selectedError, 'g', 1));
 171                         painter.drawText(rc,Qt::AlignRight | Qt::TextSingleLine,str,&ret);
 172                         //str.Format("Error:%.1f\n", m_selectedError);
 173                 }
 174         }
 175
 176         painter.setBackgroundMode(Qt::OpaqueMode);
 177 }
 178
 179 void CCRampControl::DrawFrame(QPainter& painter)
 180 {
 181         QRect rect= this->rect();
 182         QPen pen;
 183         pen.setWidth(2);
 184         pen.setColor(QColor(0,0,0));
 185         painter.setPen(pen);
 186         QLine line;
 187         float x0 = rect.left();
 188         float x1 = rect.right();
 189         float y0 = rect.top();
 190         float y1 = rect.bottom();
 191         line.setLine(x0,y0,x0,y1);
 192         painter.drawLine(line);
 193         line.setLine(x1,y0,x1,y1);
 194         painter.drawLine(line);
 195         line.setLine(x0,y0,x1,y0);
 196         painter.drawLine(line);
 197         line.setLine(x0,y1,x1,y1);
 198         painter.drawLine(line);
 199
 200 }
 201
 202 void CCRampControl::DrawRamp(QPainter& painter)
 203 {
 204         DrawFrame(painter);
 205         DrawBackground(painter);
 206
 207         QRect rect= this->rect();
 208         QPen pen;
 209         pen.setWidth(1);
 210         pen.setColor(QColor(0,0,0));
 211         painter.setPen(pen);
 212
 213         QLine line;
 214         float x0,y0,x1,y1;
 215 //      x0 = rect.left();
 216 //      x1 = rect.right();
 217 //      y0 = rect.top() + ((rect.bottom() - rect.top())/2);
 218 //      y1 = y0;
 219 //      line.setLine(x0,y0,x1 - x0,y1 - y0);
 220 //      painter.drawLine(line);
 221
 222         for (int idx = 0; idx < 100; ++idx)
 223         {
 224                 x0 = (int)((((float)(rect.right()-rect.left()))/100.0f)*idx);
 225                 y0 = rect.bottom() - 5;//rect.top() + ((rect.bottom() - rect.top())/2) - 5;
 226                 x1 = x0;
 227                 y1 = y0 + 5;
 228
 229                 if (idx % 5 == 0)
 230                         y0 -= 2;
 231
 232                 if (idx % 10 == 0)
 233                         y0 -= 3;
 234
 235                 line.setLine(x0,y0,x1,y1);
 236                 painter.drawLine(line);
 237         }
 238
 239         DrawForeground(painter);
 240
 241 //      if (GetFocus() == this)
 242 //      {
 243 //              dc.DrawFocusRect(&rect);
 244 //      }
 245 }
 246
 247
 248 void CCRampControl::DrawHandle(QPainter& painter, const HandleData& data)
 249 {
 250         QPen pen;
 251         pen.setWidth(1);
 252         pen.setColor(QColor(0,0,0));
 253         painter.setPen(pen);
 254
 255         QRect rect= this->rect();
 256
 257         QLine line;
 258         float x0,y0,x1,y1;
 259
 260         const float pixelsPercent = ((float)rect.right() - (float)rect.left()) / 100.0f;
 261
 262         x0 = (int)(pixelsPercent * data.percentage);
 263         data.flags & hfSelected && m_drawPercentage ? y0 = rect.top() + 14 : y0 = rect.top();
 264         x1 = x0;
 265         y1 = rect.bottom();
 266
 267         CPen linebrush;
 268         if ( data.flags & hfHotitem )
 269         {
 270                 pen.setColor(QColor(255,0,0));
 271                 painter.setPen(pen);
 272         }
 273
 274         line.setLine(x0,y0,x1,y1);
 275         painter.drawLine(line);
 276
 277
 278         x0 = x0 - 3;
 279         x1 = x1 + 4;
 280         y1 = y1;
 281         y0 = y1 - 7;
 282
 283         pen.setColor(QColor(255,255,255));
 284         painter.setPen(pen);
 285
 286         QBrush qBrush;
 287         qBrush.setColor(QColor(255,255,255));
 288         qBrush.setStyle(Qt::SolidPattern);
 289         painter.setBrush(qBrush);
 290
 291         QRect qRect(x0,y0,x1 - x0,y1 - y0);
 292         painter.drawRect(qRect);
 293
 294         if ( data.flags & hfSelected )
 295         {
 296                 pen.setColor(QColor(255,0,0));
 297                 painter.setPen(pen);
 298                 painter.drawRect(qRect);
 299
 300                 if ( m_drawPercentage )
 301                 {
 302                         const QString str = QString("%1").arg((int)data.percentage);;
 303
 304                         x0 = (int)(pixelsPercent * data.percentage) - 7;
 305                         x1 = x1 + 5;
 306                         y1 = rect.top();
 307                         y0 = rect.top()+10;
 308
 309                         const QRectF qqRect(x0,y0,x1-x0,y1-y0);
 310                         painter.setBackgroundMode(Qt::TransparentMode);
 311                         painter.drawText(qqRect,Qt::AlignCenter | Qt::TextSingleLine | Qt::TextDontClip,str,NULL);
 312                         painter.setBackgroundMode(Qt::OpaqueMode);
 313                 }
 314         }
 315 }
 316
 317
 318 void CCRampControl::paintEvent(QPaintEvent * ev)
 319 {
 320         QWidget::paintEvent(ev);
 321
 322         QPainter painter(this);
 323         //----------------------------------------------------------------------------
 324
 325         DrawRamp(painter);
 326         const int handleCount = m_handles.size();
 327         for (int idx = 0; idx < handleCount; ++idx)
 328         {
 329                 DrawHandle(painter, m_handles[idx]);
 330         }
 331
 332         //----------------------------------------------------------------------------
 333 }
 334
 335 void CCRampControl::OnLButtonDblClk(QPoint point)
 336 {
 337         float percent = DeterminePercentage(point);
 338         if ( !HitAnyHandles(percent) )
 339         {
 340                 if ( AddHandle(percent) )
 341                         OnLodAdded((int)percent);
 342         }
 343         update();
 344 }
 345
 346 void CCRampControl::mousePressEvent(QMouseEvent *ev)
 347 {
 348         Qt::MouseButton mouseButton = ev->button();
 349         QPoint point = ev->pos();
 350         if (mouseButton == Qt::LeftButton)
 351         {
 352                 OnLButtonDown(point);
 353         }
 354
 355 }
 356
 357 void CCRampControl::mouseReleaseEvent(QMouseEvent *ev)
 358 {
 359         Qt::MouseButton mouseButton = ev->button();
 360         QPoint point = ev->pos();
 361         if (mouseButton == Qt::LeftButton)
 362         {
 363                 OnLButtonUp(point);
 364         }
 365
 366 }
 367
 368 void CCRampControl::mouseMoveEvent(QMouseEvent *ev)
 369 {
 370         QPoint point = ev->pos();
 371         OnMouseMove(point);
 372 }
 373
 374 void CCRampControl::mouseDoubleClickEvent(QMouseEvent *ev)
 375 {
 376         Qt::MouseButton mouseButton = ev->button();
 377         QPoint point = ev->pos();
 378         if (mouseButton == Qt::LeftButton)
 379         {
 380                 OnLButtonDblClk(point);
 381         }
 382 }
 383
 384 void CCRampControl::keyPressEvent(QKeyEvent *ev)
 385 {
 386         OnKeyDown(ev->nativeScanCode(),ev->count());
 387 }
 388
 389 void CCRampControl::keyReleaseEvent(QKeyEvent *ev)
 390 {
 391         OnKeyUp(ev->nativeScanCode(),ev->count());
 392 }
 393
 394 void CCRampControl::OnLButtonDown(QPoint point)
 395 {
 396         float percent = DeterminePercentage(point);
 397         if ( HitAnyHandles(percent) && !(GetKeyState(VK_CONTROL) & 0x8000) )
 398         {
 399                 ClearSelectedHandles();
 400                 OnSelectionCleared();
 401         }
 402
 403         m_ptLeftDown = point;
 404         m_bLeftDown = true;
 405         m_canMoveSelected = IsSelectedHandle(percent);
 406         update();
 407 }
 408
 409 void CCRampControl::OnLButtonUp(QPoint point)
 410 {
 411         float percent = DeterminePercentage(point);
 412         if ( m_movedHandles == false )
 413         {
 414                 if ( !HitAnyHandles(percent) && !(GetKeyState(VK_CONTROL) & 0x8000) )
 415                 {
 416                         ClearSelectedHandles();
 417                         OnSelectionCleared();
 418                 }
 419                 else if ( HitAnyHandles(percent) )
 420                 {
 421                         if ( IsSelectedHandle(percent) )
 422                         {
 423                                 DeSelectHandle(percent);
 424                         }
 425                         else
 426                         {
 427                                 if ( SelectHandle(percent) )
 428                                         OnLodSelected();
 429                         }
 430                 }
 431         }
 432
 433         m_ptLeftDown = QPoint(0,0);
 434         m_bLeftDown = false;
 435
 436         m_mouseMoving = false;
 437         m_canMoveSelected = false;
 438         m_movedHandles = false;
 439         //SetFocus();
 440         ReleaseCapture();
 441         update();
 442 }
 443
 444 void CCRampControl::OnMouseMove(QPoint point)
 445 {
 446         float abspercent = DeterminePercentage(point);
 447         SetHotItem(abspercent);
 448         update();
 449
 450         const int handleCount = m_handles.size();
 451         if ( !m_bLeftDown || handleCount == 0 )
 452                 return;
 453
 454         if (m_movedHandles == false && !m_mouseMoving && !m_canMoveSelected)
 455                 m_canMoveSelected = SelectHandle(abspercent);
 456
 457         m_mouseMoving = true;
 458
 459         if ( !m_canMoveSelected )
 460                 return;
 461
 462         //SetCapture();
 463
 464         bool modified = false;
 465
 466         QPoint movement = point - m_ptLeftDown;
 467         float percent = DeterminePercentage(movement);
 468
 469         //early out if we hit the edge limits
 470         for (int idx = 0; idx < handleCount; ++idx)
 471         {
 472                 if ( m_handles[idx].flags & hfSelected && ((movement.x() < 0 && m_handles[idx].percentage <= 1) || (movement.x() > 0 && m_handles[idx].percentage >= 99)))
 473                 {
 474                         return;
 475                 }
 476         }
 477
 478         if ( movement.x() > 0)
 479         {
 480                 // move the hanldes clamping in direction where required
 481                 for (int idx = handleCount-1; idx >= 0; --idx)
 482                 {
 483                         if ( m_handles[idx].flags & hfSelected )
 484                         {
 485                                 float amountClamped = MoveHandle(m_handles[idx], percent);
 486                                 if ( amountClamped != 0.0f)
 487                                         percent += amountClamped;
 488                                 modified = true;
 489                         }
 490                 }
 491         }
 492         else if (movement.x() < 0)
 493         {
 494                 // move the hanldes clamping in direction where required
 495                 for (int idx = 0; idx < handleCount; ++idx)
 496                 {
 497                         if ( m_handles[idx].flags & hfSelected )
 498                         {
 499                                 float amountClamped = MoveHandle(m_handles[idx], percent);
 500                                 if ( amountClamped != 0.0f)
 501                                         percent += amountClamped;
 502                                 modified = true;
 503                         }
 504                 }
 505         }
 506         m_ptLeftDown = point;
 507
 508         if ( modified )
 509         {
 510                 m_movedHandles = true;
 511                 OnLodValueChanged();
 512                 update();
 513                 SortHandles();
 514         }
 515 }
 516
 517 void CCRampControl::OnKeyUp(int nChar, int nRepCnt)
 518 {
 519
 520 }
 521
 522 void CCRampControl::OnKeyDown(int nChar, int nRepCnt)
 523 {
 524         if ( nChar == VK_DELETE )
 525         {
 526                 RemoveSelectedHandles();
 527                 OnLodDeleted();
 528         }
 529
 530         if ( nChar == VK_LEFT )
 531         {
 532                 SelectPreviousHandle();
 533                 OnLodSelected();
 534         }
 535
 536         if ( nChar == VK_RIGHT )
 537         {
 538                 SelectNextHandle();
 539                 OnLodSelected();
 540         }
 541
 542         update();
 543 }
 544
 545 void CCRampControl::OnKillFocus()
 546 {
 547         SetHotItem(-1.0f);
 548         update();
 549 }
 550
 551 void CCRampControl::contextMenuEvent(QContextMenuEvent * ev)
 552 {
 553         m_menuPoint = ev->pos();;
 554         float percent = DeterminePercentage(m_menuPoint);
 555         bool hit = HitAnyHandles(percent);
 556         bool maxed = GetHandleCount() == GetMaxHandles();
 557
 558         QAction*    Act_Add;
 559         QAction*    Act_Delete;
 560         QAction*    Act_Select;
 561         QAction*    Act_SelectAll;
 562         QAction*    Act_SelectNone;
 563
 564         Act_Add     = new QAction(tr("Add"), this);
 565         Act_Add->setEnabled(!maxed);
 566         //Act_Add->setIcon(QIcon("Resources/logo.png"));
 567         Act_Delete     = new QAction(tr("Delete"), this);
 568         Act_Select     = new QAction(tr("Select"), this);
 569         Act_SelectAll     = new QAction(tr("Select All"), this);
 570         Act_SelectNone     = new QAction(tr("Select None"), this);
 571
 572         connect(Act_Add, SIGNAL(triggered()), this, SLOT(ADDChange()));
 573         connect(Act_Delete, SIGNAL(triggered()), this, SLOT(DeleteChange()));
 574         connect(Act_Select, SIGNAL(triggered()), this, SLOT(SelectChange()));
 575         connect(Act_SelectAll, SIGNAL(triggered()), this, SLOT(SelectAllChange()));
 576         connect(Act_SelectNone, SIGNAL(triggered()), this, SLOT(SelectNoneChange()));
 577
 578         QMenu* menu = new QMenu();
 579         menu->addAction(Act_Add);
 580         menu->addSeparator();
 581         menu->addAction(Act_Delete);
 582         menu->addAction(Act_Select);
 583         menu->addSeparator();
 584         menu->addAction(Act_SelectAll);
 585         menu->addAction(Act_SelectNone);
 586         menu->exec(ev->globalPos());
 587         delete menu;
 588         delete Act_Add;
 589         delete Act_Delete;
 590         delete Act_Select;
 591         delete Act_SelectAll;
 592         delete Act_SelectNone;
 593 }
 594
 595 // void CCRampControl::OnContextMenu(QPoint point)
 596 // {
 597 //      m_menuPoint = point;
 598 //      ScreenToClient(&m_menuPoint);
 599 //      float percent = DeterminePercentage(m_menuPoint);
 600 //      bool hit = HitAnyHandles(percent);
 601 //      bool maxed = GetHandleCount() == GetMaxHandles();
 602 //
 603 //
 604 //      CMenu *menu = new CMenu;
 605 //      menu->CreatePopupMenu();
 606 //      menu->AppendMenu(!maxed ? MF_STRING : MF_STRING|MF_GRAYED, ID_MENU_ADD, "&Add");
 607 //      menu->AppendMenu(MF_SEPARATOR,0,"");
 608 //      menu->AppendMenu(hit ? MF_STRING : MF_STRING|MF_GRAYED, ID_MENU_DELETE, "&Delete");
 609 //      menu->AppendMenu(hit ? MF_STRING : MF_STRING|MF_GRAYED, ID_MENU_SELECT, "&Select");
 610 //      menu->AppendMenu(MF_SEPARATOR,0,"");
 611 //      menu->AppendMenu(MF_STRING, ID_MENU_SELECTALL, "Select A&ll");
 612 //      menu->AppendMenu(MF_STRING, ID_MENU_SELECTNONE, "Select &None");
 613 //      AddCustomMenuOptions(menu);
 614 //      menu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON,point.x,point.y,pWnd);
 615 //      delete menu;
 616 //
 617 // }
 618
 619 void CCRampControl::ADDChange(bool checked)
 620 {
 621         float percent = DeterminePercentage(m_menuPoint);
 622         if ( AddHandle(percent) )
 623                 OnLodAdded((int)percent);
 624         update();
 625 }
 626
 627 void CCRampControl::DeleteChange(bool checked)
 628 {
 629         ClearSelectedHandles();
 630         float percent = DeterminePercentage(m_menuPoint);
 631         SelectHandle(percent);
 632         RemoveSelectedHandles();
 633         OnLodDeleted();
 634         update();
 635 }
 636
 637 void CCRampControl::SelectChange(bool checked)
 638 {
 639         ClearSelectedHandles();
 640         float percent = DeterminePercentage(m_menuPoint);
 641         SelectHandle(percent);
 642         OnLodSelected();
 643         update();
 644 }
 645
 646 void CCRampControl::SelectAllChange(bool checked)
 647 {
 648         SelectAllHandles();
 649         OnLodSelected();
 650         update();
 651 }
 652
 653 void CCRampControl::SelectNoneChange(bool checked)
 654 {
 655         ClearSelectedHandles();
 656         OnSelectionCleared();
 657         update();
 658 }
 659
 660 void CCRampControl::OnSize(int nType, int cx, int cy)
 661 {
 662         update();
 663 }
 664
 665 float CCRampControl::DeterminePercentage(const QPoint& point)
 666 {
 667         QRect rect= this->rect();
 668         float percent = ((float)(point.x() - rect.left()) / (float)(rect.right()-rect.left())) * 100.0f;
 669         return percent;
 670 }
 671
 672 bool CCRampControl::AddHandle(const float percent)
 673 {
 674         if (m_handles.size() >= m_max)
 675                 return false;
 676
 677         HandleData data;
 678         data.percentage = percent;
 679         data.flags = 0;
 680         m_handles.push_back(data);
 681
 682         SortHandles();
 683         return true;
 684 }
 685
 686 void CCRampControl::SortHandles()
 687 {
 688         std::sort(m_handles.begin(),m_handles.end(),SortHandle);
 689 }
 690
 691 bool CCRampControl::SortHandle(const CCRampControl::HandleData& dataA, const CCRampControl::HandleData& dataB)
 692 {
 693         return dataA.percentage < dataB.percentage;
 694 }
 695
 696 void CCRampControl::ClearSelectedHandles()
 697 {
 698         const int handleCount = m_handles.size();
 699         for (int idx = 0; idx < handleCount; ++idx)
 700         {
 701                 m_handles[idx].flags &= ~hfSelected;
 702         }
 703 }
 704
 705 void CCRampControl::Reset()
 706 {
 707         m_handles.clear();
 708 }
 709
 710 bool CCRampControl::SelectHandle(const float percent)
 711 {
 712         const int handleCount = m_handles.size();
 713         for (int idx = 0; idx < handleCount; ++idx)
 714         {
 715                 if ( HitTestHandle(m_handles[idx],percent) && !(m_handles[idx].flags & hfSelected) )
 716                 {
 717                         m_handles[idx].flags |= hfSelected;
 718                         return true;
 719                 }
 720         }
 721         return false;
 722 }
 723
 724 bool CCRampControl::DeSelectHandle(const float percent)
 725 {
 726         const int handleCount = m_handles.size();
 727         for (int idx = 0; idx < handleCount; ++idx)
 728         {
 729                 if ( HitTestHandle(m_handles[idx],percent) && (m_handles[idx].flags & hfSelected))
 730                 {
 731                         m_handles[idx].flags &= ~hfSelected;
 732                         return true;
 733                 }
 734         }
 735         return false;
 736 }
 737
 738 bool CCRampControl::IsSelectedHandle(const float percent)
 739 {
 740         const int handleCount = m_handles.size();
 741         for (int idx = 0; idx < handleCount; ++idx)
 742         {
 743                 if ( HitTestHandle(m_handles[idx],percent) )
 744                         if ( m_handles[idx].flags & hfSelected )
 745                                 return true;
 746         }
 747         return false;
 748 }
 749
 750 void CCRampControl::SelectAllHandles()
 751 {
 752         const int handleCount = m_handles.size();
 753         for (int idx = 0; idx < handleCount; ++idx)
 754         {
 755                 m_handles[idx].flags |= hfSelected;
 756         }
 757 }
 758
 759 float CCRampControl::MoveHandle(HandleData& data, const float percent)
 760 {
 761         float clampedby = 0.0f;
 762         data.percentage += percent;
 763         if ( data.percentage < 0.0f )
 764         {
 765                 clampedby = -data.percentage;
 766                 data.percentage = 0.0f;
 767         }
 768
 769         if ( data.percentage > 99.99f )
 770         {
 771                 clampedby = -(data.percentage - 99.0f);
 772                 data.percentage = 99.0f;
 773         }
 774         return clampedby;
 775 }
 776
 777 bool CCRampControl::HitAnyHandles(const float percent)
 778 {
 779         const int handleCount = m_handles.size();
 780         for (int idx = 0; idx < handleCount; ++idx)
 781         {
 782                 if ( HitTestHandle(m_handles[idx],percent) )
 783                         return true;
 784         }
 785         return false;
 786 }
 787
 788 bool CCRampControl::HitTestHandle(const HandleData& data, const float percent)
 789 {
 790         if ( percent > data.percentage-1 && percent < data.percentage+1 )
 791                 return true;
 792         return false;
 793 }
 794
 795 bool CCRampControl::CheckSelected(const CCRampControl::HandleData& data)
 796 {
 797     return data.flags & CCRampControl::hfSelected;
 798 }
 799
 800 void CCRampControl::RemoveSelectedHandles()
 801 {
 802     m_handles.erase(remove_if(m_handles.begin(),m_handles.end(),CCRampControl::CheckSelected),m_handles.end());
 803         SortHandles();
 804 }
 805
 806 void CCRampControl::SelectNextHandle()
 807 {
 808         bool selected = false;
 809         const int count = m_handles.size();
 810         for ( int idx = count-1; idx >= 0; --idx )
 811         {
 812                 if ( (m_handles[idx].flags & hfSelected) && ( idx+1 < count ) )
 813                 {
 814                         m_handles[idx+1].flags |= hfSelected;
 815                         selected = true;
 816                 }
 817                 m_handles[idx].flags &= ~hfSelected;
 818         }
 819
 820         if ( selected == false && count > 0 )
 821         {
 822                 m_handles[0].flags |= hfSelected;
 823         }
 824 }
 825
 826 void CCRampControl::SelectPreviousHandle()
 827 {
 828         bool selected = false;
 829         const int count = m_handles.size();
 830         for ( int idx = 0; idx < count; ++idx )
 831         {
 832                 if ( (m_handles[idx].flags & hfSelected) && ( idx-1 >= 0) )
 833                 {
 834                         m_handles[idx-1].flags |= hfSelected;
 835                         selected = true;
 836                 }
 837                 m_handles[idx].flags &= ~hfSelected;
 838         }
 839
 840         if ( selected == false && count > 0 )
 841         {
 842                 m_handles[count-1].flags |= hfSelected;
 843
 844         }
 845 }
 846
 847 /*************************************************************************************/
 848 const bool CCRampControl::GetSelectedData(CCRampControl::HandleData & data)
 849 {
 850         const int handleCount = m_handles.size();
 851         for (int idx = 0; idx < handleCount; ++idx)
 852         {
 853                 if ( m_handles[idx].flags & hfSelected )
 854                 {
 855                         data = m_handles[idx];
 856                         return true;
 857                 }
 858         }
 859         return false;
 860 }
 861
 862 const int CCRampControl::GetHandleCount()
 863 {
 864         return m_handles.size();
 865 }
 866
 867 const CCRampControl::HandleData CCRampControl::GetHandleData(const int idx)
 868 {
 869         return m_handles[idx];
 870 }
 871
 872 const int CCRampControl::GetHotHandleIndex()
 873 {
 874         const int count = m_handles.size();
 875         for ( int idx = 0; idx < count; ++idx )
 876         {
 877                 if ( m_handles[idx].flags & hfHotitem )
 878                 {
 879                         return idx;
 880                 }
 881         }
 882         return -1;
 883 }
 884
 885 void CCRampControl::SetHotItem(const float percentage)
 886 {
 887         const int count = m_handles.size();
 888         for ( int idx = 0; idx < count; ++idx )
 889         {
 890                 if ( HitTestHandle(m_handles[idx],percentage) )
 891                 {
 892                         m_handles[idx].flags |= hfHotitem;
 893                 }
 894                 else
 895                 {
 896                         m_handles[idx].flags &= ~hfHotitem;
 897                 }
 898         }
 899 }