Code/Sandbox/Plugins/MFCToolsPlugin/Controls/ColorGradientCtrl.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "ColorGradientCtrl.h"
   5 #include "MemDC.h"
   6 #include "Dialogs/CustomColorDialog.h"
   7 #include "WndGridHelper.h"
   8 #include "Util/MFCUtil.h"
   9
  10 IMPLEMENT_DYNAMIC(CColorGradientCtrl, CWnd)
  11
  12 #define MIN_TIME_EPSILON 0.01f
  13
  14 //////////////////////////////////////////////////////////////////////////
  15 CColorGradientCtrl::CColorGradientCtrl()
  16 {
  17         m_bAutoDelete = false;
  18         m_nActiveKey = -1;
  19         m_nHitKeyIndex = -1;
  20         m_nKeyDrawRadius = 3;
  21         m_bTracking = false;
  22         m_pSpline = 0;
  23         m_fMinTime = -1;
  24         m_fMaxTime = 1;
  25         m_fMinValue = -1;
  26         m_fMaxValue = 1;
  27         m_fTooltipScaleX = 1;
  28         m_fTooltipScaleY = 1;
  29         m_bLockFirstLastKey = false;
  30         m_bNoZoom = true;
  31
  32         ClearSelection();
  33
  34         m_bSelectedKeys.reserve(0);
  35
  36         m_fTimeMarker = -10;
  37
  38         m_grid.zoom.x = 100;
  39 }
  40
  41 CColorGradientCtrl::~CColorGradientCtrl()
  42 {
  43 }
  44
  45 //////////////////////////////////////////////////////////////////////////
  46 BEGIN_MESSAGE_MAP(CColorGradientCtrl, CWnd)
  47 ON_WM_SIZE()
  48 ON_WM_ERASEBKGND()
  49 ON_WM_PAINT()
  50 ON_WM_LBUTTONDOWN()
  51 ON_WM_RBUTTONDOWN()
  52 ON_WM_MOUSEMOVE()
  53 ON_WM_LBUTTONUP()
  54 ON_WM_RBUTTONUP()
  55 ON_WM_SETCURSOR()
  56 ON_WM_LBUTTONDBLCLK()
  57 ON_WM_RBUTTONDOWN()
  58 ON_WM_KEYDOWN()
  59 END_MESSAGE_MAP()
  60
  61 /////////////////////////////////////////////////////////////////////////////
  62 // CColorGradientCtrl message handlers
  63
  64 /////////////////////////////////////////////////////////////////////////////
  65 BOOL CColorGradientCtrl::Create(DWORD dwStyle, const CRect& rc, CWnd* pParentWnd, UINT nID)
  66 {
  67         if (dwStyle & CLRGRD_STYLE_AUTO_DELETE)
  68                 m_bAutoDelete = true;
  69         LPCTSTR lpClassName = AfxRegisterWndClass(CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, AfxGetApp()->LoadStandardCursor(IDC_ARROW), NULL, NULL);
  70         return CreateEx(0, lpClassName, "SplineCtrl", dwStyle, rc, pParentWnd, nID);
  71 }
  72
  73 //////////////////////////////////////////////////////////////////////////
  74 void CColorGradientCtrl::PostNcDestroy()
  75 {
  76         if (m_bAutoDelete)
  77                 delete this;
  78 }
  79
  80 //////////////////////////////////////////////////////////////////////////
  81 BOOL CColorGradientCtrl::OnEraseBkgnd(CDC* pDC)
  82 {
  83         return TRUE;
  84 }
  85
  86 //////////////////////////////////////////////////////////////////////////
  87 void CColorGradientCtrl::OnSize(UINT nType, int cx, int cy)
  88 {
  89         __super::OnSize(nType, cx, cy);
  90
  91         m_offscreenBitmap.DeleteObject();
  92         if (!m_offscreenBitmap.GetSafeHandle())
  93         {
  94                 CDC* pDC = GetDC();
  95                 m_offscreenBitmap.CreateCompatibleBitmap(pDC, cx, cy);
  96                 ReleaseDC(pDC);
  97         }
  98
  99         CRect rc;
 100         GetClientRect(rc);
 101         m_rcGradient = rc;
 102         m_rcGradient.bottom -= 11;
 103         //m_rcGradient.DeflateRect(4,4);
 104
 105         m_grid.rect = m_rcGradient;
 106         if (m_bNoZoom)
 107                 m_grid.zoom.x = m_grid.rect.Width();
 108
 109         m_rcKeys = rc;
 110         m_rcKeys.top = m_rcKeys.bottom - 10;
 111
 112         if (m_tooltip.m_hWnd)
 113         {
 114                 m_tooltip.DelTool(this, 1);
 115                 m_tooltip.AddTool(this, "", m_rcGradient, 1);
 116         }
 117 }
 118
 119 //////////////////////////////////////////////////////////////////////////
 120 BOOL CColorGradientCtrl::PreTranslateMessage(MSG* pMsg)
 121 {
 122         if (!m_tooltip.m_hWnd)
 123         {
 124                 CRect rc;
 125                 GetClientRect(rc);
 126                 m_tooltip.Create(this);
 127                 m_tooltip.SetDelayTime(TTDT_AUTOPOP, 500);
 128                 m_tooltip.SetDelayTime(TTDT_INITIAL, 0);
 129                 m_tooltip.SetDelayTime(TTDT_RESHOW, 0);
 130                 m_tooltip.SetMaxTipWidth(600);
 131                 m_tooltip.AddTool(this, "", rc, 1);
 132                 m_tooltip.Activate(FALSE);
 133         }
 134         m_tooltip.RelayEvent(pMsg);
 135
 136         return __super::PreTranslateMessage(pMsg);
 137 }
 138
 139 //////////////////////////////////////////////////////////////////////////
 140 void CColorGradientCtrl::SetZoom(float fZoom)
 141 {
 142         m_grid.zoom.x = fZoom;
 143 }
 144
 145 //////////////////////////////////////////////////////////////////////////
 146 void CColorGradientCtrl::SetOrigin(float fOffset)
 147 {
 148         m_grid.origin.x = fOffset;
 149 }
 150
 151 //////////////////////////////////////////////////////////////////////////
 152 CPoint CColorGradientCtrl::KeyToPoint(int nKey)
 153 {
 154         if (nKey >= 0)
 155         {
 156                 return TimeToPoint(m_pSpline->GetKeyTime(nKey));
 157         }
 158         return CPoint(0, 0);
 159 }
 160
 161 //////////////////////////////////////////////////////////////////////////
 162 CPoint CColorGradientCtrl::TimeToPoint(float time)
 163 {
 164         return CPoint(m_grid.WorldToClient(Vec2(time, 0)).x, m_rcGradient.Height() / 2);
 165
 166         CPoint point;
 167         point.x = (time - m_fMinTime) * (m_rcGradient.Width() / (m_fMaxTime - m_fMinTime)) + m_rcGradient.left;
 168         point.y = m_rcGradient.Height() / 2;
 169         return point;
 170 }
 171
 172 //////////////////////////////////////////////////////////////////////////
 173 COLORREF CColorGradientCtrl::TimeToColor(float time)
 174 {
 175         ISplineInterpolator::ValueType val;
 176         m_pSpline->Interpolate(time, val);
 177         COLORREF col = ValueToColor(val);
 178         return col;
 179 }
 180
 181 //////////////////////////////////////////////////////////////////////////
 182 void CColorGradientCtrl::PointToTimeValue(CPoint point, float& time, ISplineInterpolator::ValueType& val)
 183 {
 184         time = XOfsToTime(point.x);
 185         ColorToValue(TimeToColor(time), val);
 186 }
 187
 188 //////////////////////////////////////////////////////////////////////////
 189 float CColorGradientCtrl::XOfsToTime(int x)
 190 {
 191         return m_grid.ClientToWorld(CPoint(x, 0)).x;
 192
 193         // m_fMinTime to m_fMaxTime time range.
 194         float time = m_fMinTime + (float)((m_fMaxTime - m_fMinTime) * (x - m_rcGradient.left)) / m_rcGradient.Width();
 195         return time;
 196 }
 197
 198 //////////////////////////////////////////////////////////////////////////
 199 CPoint CColorGradientCtrl::XOfsToPoint(int x)
 200 {
 201         return TimeToPoint(XOfsToTime(x));
 202 }
 203
 204 //////////////////////////////////////////////////////////////////////////
 205 COLORREF CColorGradientCtrl::XOfsToColor(int x)
 206 {
 207         return TimeToColor(XOfsToTime(x));
 208 }
 209
 210 //////////////////////////////////////////////////////////////////////////
 211 void CColorGradientCtrl::OnPaint()
 212 {
 213         CPaintDC PaintDC(this);
 214
 215         CRect rcClient;
 216         GetClientRect(&rcClient);
 217
 218         if (m_pSpline)
 219                 m_bSelectedKeys.resize(m_pSpline->GetKeyCount());
 220         {
 221                 if (!m_offscreenBitmap.GetSafeHandle())
 222                         m_offscreenBitmap.CreateCompatibleBitmap(&PaintDC, rcClient.Width(), rcClient.Height());
 223
 224                 CMemoryDC dc(PaintDC, &m_offscreenBitmap);
 225
 226                 if (!IsWindowEnabled())
 227                 {
 228                         CRect rc;
 229                         GetClientRect(rc);
 230                         rc.IntersectRect(rc, CRect(PaintDC.m_ps.rcPaint));
 231                         CBrush keysBrush;
 232                         keysBrush.CreateSolidBrush(GetXtremeColor(COLOR_BTNFACE));
 233                         dc.FillRect(rc, &keysBrush);
 234                         return;
 235                 }
 236
 237                 //////////////////////////////////////////////////////////////////////////
 238                 // Fill keys backgound.
 239                 //////////////////////////////////////////////////////////////////////////
 240                 CRect rcKeys;
 241                 rcKeys.IntersectRect(m_rcKeys, CRect(PaintDC.m_ps.rcPaint));
 242                 CBrush keysBrush;
 243                 keysBrush.CreateSolidBrush(GetXtremeColor(COLOR_BTNFACE));
 244                 dc.FillRect(rcKeys, &keysBrush);
 245                 //////////////////////////////////////////////////////////////////////////
 246
 247                 //Draw Keys and Curve
 248                 if (m_pSpline)
 249                 {
 250                         DrawGradient(&dc);
 251                         DrawKeys(&dc);
 252                 }
 253         }
 254 }
 255
 256 //////////////////////////////////////////////////////////////////////////
 257 void CColorGradientCtrl::DrawGradient(CDC* pDC)
 258 {
 259         int cx = m_rcGradient.Width();
 260         int cy = m_rcGradient.Height();
 261
 262         //Draw Curve
 263         // create and select a thick, white pen
 264         CPen pen;
 265         pen.CreatePen(PS_SOLID, 1, RGB(128, 255, 128));
 266         CPen* pOldPen = pDC->SelectObject(&pen);
 267
 268         CRect rcClip;
 269         pDC->GetClipBox(rcClip);
 270         rcClip.IntersectRect(rcClip, m_rcGradient);
 271
 272         for (int x = rcClip.left; x < rcClip.right; x++)
 273         {
 274                 COLORREF col = XOfsToColor(x);
 275                 CPen pen;
 276                 pen.CreatePen(PS_SOLID, 1, col);
 277                 pDC->SelectObject(&pen);
 278                 pDC->MoveTo(CPoint(x, m_rcGradient.top));
 279                 pDC->LineTo(CPoint(x, m_rcGradient.bottom));
 280         }
 281
 282         // Put back the old objects
 283         pDC->SelectObject(pOldPen);
 284 }
 285
 286 //////////////////////////////////////////////////////////////////////////
 287 void CColorGradientCtrl::DrawKeys(CDC* pDC)
 288 {
 289         if (!m_pSpline)
 290                 return;
 291
 292         // create and select a white pen
 293         CPen pen;
 294         pen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
 295         CPen* pOldPen = pDC->SelectObject(&pen);
 296
 297         CRect rcClip;
 298         pDC->GetClipBox(rcClip);
 299
 300         m_bSelectedKeys.resize(m_pSpline->GetKeyCount());
 301
 302         for (int i = 0; i < m_pSpline->GetKeyCount(); i++)
 303         {
 304                 float time = m_pSpline->GetKeyTime(i);
 305                 CPoint pt = TimeToPoint(time);
 306
 307                 if (pt.x < rcClip.left - 8 || pt.x > rcClip.right + 8)
 308                         continue;
 309
 310                 COLORREF clr = TimeToColor(time);
 311                 CBrush brush(clr);
 312                 CBrush* pOldBrush = pDC->SelectObject(&brush);
 313
 314                 // Find the midpoints of the top, right, left, and bottom
 315                 // of the client area. They will be the vertices of our polygon.
 316                 CPoint pts[3];
 317                 pts[0].x = pt.x;
 318                 pts[0].y = m_rcKeys.top + 1;
 319                 pts[1].x = pt.x - 5;
 320                 pts[1].y = m_rcKeys.top + 8;
 321                 pts[2].x = pt.x + 5;
 322                 pts[2].y = m_rcKeys.top + 8;
 323                 pDC->Polygon(pts, 3);
 324
 325                 if (m_bSelectedKeys[i])
 326                 {
 327                         CPen pen;
 328                         pen.CreatePen(PS_SOLID, 1, RGB(200, 0, 0));
 329                         CPen* pOldPen = pDC->SelectObject(&pen);
 330                         pDC->Polygon(pts, 3);
 331                         pDC->SelectObject(pOldPen);
 332                 }
 333
 334                 pDC->SelectObject(pOldBrush);
 335         }
 336
 337         CPen timePen;
 338         timePen.CreatePen(PS_SOLID, 1, RGB(255, 0, 255));
 339         if (!(GetStyle() & CLRGRD_STYLE_NO_TIME_MARKER))
 340         {
 341                 pDC->SelectObject(&timePen);
 342                 CPoint pt = TimeToPoint(m_fTimeMarker);
 343                 pDC->MoveTo(pt.x, m_rcGradient.top + 1);
 344                 pDC->LineTo(pt.x, m_rcGradient.bottom - 1);
 345         }
 346
 347         pDC->SelectObject(pOldPen);
 348 }
 349
 350 void CColorGradientCtrl::UpdateTooltip()
 351 {
 352         if (m_nHitKeyIndex >= 0)
 353         {
 354                 float time = m_pSpline->GetKeyTime(m_nHitKeyIndex);
 355                 ISplineInterpolator::ValueType val;
 356                 m_pSpline->GetKeyValue(m_nHitKeyIndex, val);
 357
 358                 COLORREF col = TimeToColor(time);
 359                 int cont_s = (m_pSpline->GetKeyFlags(m_nHitKeyIndex) >> SPLINE_KEY_TANGENT_IN_SHIFT) & SPLINE_KEY_TANGENT_LINEAR ? 1 : 2;
 360                 int cont_d = (m_pSpline->GetKeyFlags(m_nHitKeyIndex) >> SPLINE_KEY_TANGENT_OUT_SHIFT) & SPLINE_KEY_TANGENT_LINEAR ? 1 : 2;
 361
 362                 CString tipText;
 363                 tipText.Format("%.2f : %d,%d,%d [%d,%d]",
 364                                time * m_fTooltipScaleX, GetRValue(col), GetGValue(col), GetBValue(col), cont_s, cont_d);
 365                 m_tooltip.UpdateTipText(tipText, this, 1);
 366                 m_tooltip.Activate(TRUE);
 367         }
 368 }
 369
 370 /////////////////////////////////////////////////////////////////////////////
 371 //Mouse Message Handlers
 372 //////////////////////////////////////////////////////////////////////////
 373 void CColorGradientCtrl::OnLButtonDown(UINT nFlags, CPoint point)
 374 {
 375         CWnd::OnLButtonDown(nFlags, point);
 376
 377         if (m_bTracking)
 378                 return;
 379         if (!m_pSpline)
 380                 return;
 381
 382         SetFocus();
 383
 384         switch (m_hitCode)
 385         {
 386         case HIT_KEY:
 387                 StartTracking();
 388                 SetActiveKey(m_nHitKeyIndex);
 389                 break;
 390
 391         /*
 392            case HIT_SPLINE:
 393            {
 394            // Cycle the spline slope of the nearest key.
 395            int flags = m_pSpline->GetKeyFlags(m_nHitKeyIndex);
 396            if (m_nHitKeyDist < 0)
 397             // Toggle left side.
 398             flags ^= SPLINE_KEY_TANGENT_LINEAR << SPLINE_KEY_TANGENT_IN_SHIFT;
 399            if (m_nHitKeyDist > 0)
 400             // Toggle right side.
 401             flags ^= SPLINE_KEY_TANGENT_LINEAR << SPLINE_KEY_TANGENT_OUT_SHIFT;
 402            m_pSpline->SetKeyFlags(m_nHitKeyIndex, flags);
 403            m_pSpline->Update();
 404
 405            SetActiveKey(-1);
 406            SendNotifyEvent( CLRGRDN_CHANGE );
 407            if (m_updateCallback)
 408             m_updateCallback(this);
 409            break;
 410            }
 411          */
 412
 413         case HIT_NOTHING:
 414                 SetActiveKey(-1);
 415                 break;
 416         }
 417         Invalidate();
 418 }
 419
 420 //////////////////////////////////////////////////////////////////////////
 421 void CColorGradientCtrl::OnRButtonDown(UINT nFlags, CPoint point)
 422 {
 423         CWnd::OnRButtonDown(nFlags, point);
 424
 425         NMHDR nmh;
 426         nmh.hwndFrom = m_hWnd;
 427         nmh.idFrom = ::GetDlgCtrlID(m_hWnd);
 428         nmh.code = NM_RCLICK;
 429
 430         GetOwner()->SendMessage(WM_NOTIFY, (WPARAM)GetDlgCtrlID(), (LPARAM)&nmh);
 431 }
 432
 433 //////////////////////////////////////////////////////////////////////////
 434 void CColorGradientCtrl::OnLButtonDblClk(UINT nFlags, CPoint point)
 435 {
 436         if (!m_pSpline)
 437                 return;
 438
 439         RECT rc;
 440         GetClientRect(&rc);
 441
 442         switch (m_hitCode)
 443         {
 444         case HIT_SPLINE:
 445                 {
 446                         int iIndex = InsertKey(point);
 447                         SetActiveKey(iIndex);
 448                         EditKey(iIndex);
 449
 450                         RedrawWindow();
 451                 }
 452                 break;
 453         case HIT_KEY:
 454                 {
 455                         EditKey(m_nHitKeyIndex);
 456                 }
 457                 break;
 458         }
 459
 460         CWnd::OnLButtonDblClk(nFlags, point);
 461 }
 462
 463 //////////////////////////////////////////////////////////////////////////
 464 void CColorGradientCtrl::OnMouseMove(UINT nFlags, CPoint point)
 465 {
 466         if (!m_pSpline)
 467                 return;
 468
 469         if (GetCapture() != this)
 470                 StopTracking();
 471
 472         if (m_bTracking)
 473                 TrackKey(point);
 474
 475         if (m_bTracking)
 476                 UpdateTooltip();
 477
 478         CWnd::OnMouseMove(nFlags, point);
 479 }
 480
 481 //////////////////////////////////////////////////////////////////////////
 482 void CColorGradientCtrl::OnLButtonUp(UINT nFlags, CPoint point)
 483 {
 484         if (!m_pSpline)
 485                 return;
 486
 487         if (m_bTracking)
 488                 StopTracking();
 489
 490         CWnd::OnLButtonUp(nFlags, point);
 491 }
 492
 493 //////////////////////////////////////////////////////////////////////////
 494 void CColorGradientCtrl::OnRButtonUp(UINT nFlags, CPoint point)
 495 {
 496         if (!m_pSpline)
 497                 return;
 498         CWnd::OnRButtonUp(nFlags, point);
 499 }
 500
 501 /////////////////////////////////////////////////////////////////////////////
 502 void CColorGradientCtrl::SetActiveKey(int nIndex)
 503 {
 504         ClearSelection();
 505
 506         //Activate New Key
 507         if (nIndex >= 0)
 508         {
 509                 m_bSelectedKeys[nIndex] = true;
 510         }
 511         m_nActiveKey = nIndex;
 512         Invalidate();
 513 }
 514
 515 /////////////////////////////////////////////////////////////////////////////
 516 void CColorGradientCtrl::SetSpline(ISplineInterpolator* pSpline, BOOL bRedraw)
 517 {
 518         if (pSpline != m_pSpline)
 519         {
 520                 //if (pSpline && pSpline->GetNumDimensions() != 3)
 521                 //return;
 522                 m_pSpline = pSpline;
 523                 m_nActiveKey = -1;
 524         }
 525
 526         ClearSelection();
 527
 528         if (bRedraw)
 529                 RedrawWindow();
 530 }
 531
 532 //////////////////////////////////////////////////////////////////////////
 533 ISplineInterpolator* CColorGradientCtrl::GetSpline()
 534 {
 535         return m_pSpline;
 536 }
 537
 538 /////////////////////////////////////////////////////////////////////////////
 539 BOOL CColorGradientCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 540 {
 541         BOOL b = FALSE;
 542
 543         CPoint point;
 544         GetCursorPos(&point);
 545         ScreenToClient(&point);
 546
 547         switch (HitTest(point))
 548         {
 549         case HIT_SPLINE:
 550                 {
 551                         HCURSOR hCursor;
 552                         hCursor = AfxGetApp()->LoadCursor(IDC_ARRWHITE);
 553                         SetCursor(hCursor);
 554                         b = TRUE;
 555                 } break;
 556         case HIT_KEY:
 557                 {
 558                         HCURSOR hCursor;
 559                         hCursor = AfxGetApp()->LoadCursor(IDC_ARRBLCK);
 560                         SetCursor(hCursor);
 561                         b = TRUE;
 562                 } break;
 563         default:
 564                 break;
 565         }
 566
 567         if (m_tooltip.m_hWnd && m_pSpline)
 568         {
 569                 if (m_nHitKeyIndex >= 0)
 570                 {
 571                         UpdateTooltip();
 572                 }
 573                 else if (!m_bTracking)
 574                 {
 575                         m_tooltip.Activate(FALSE);
 576                 }
 577         }
 578
 579         if (!b)
 580                 return CWnd::OnSetCursor(pWnd, nHitTest, message);
 581         else return TRUE;
 582 }
 583
 584 /////////////////////////////////////////////////////////////////////////////
 585 void CColorGradientCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
 586 {
 587         BOOL bProcessed = false;
 588
 589         if (m_nActiveKey != -1 && m_pSpline)
 590         {
 591                 switch (nChar)
 592                 {
 593                 case VK_DELETE:
 594                         {
 595                                 RemoveKey(m_nActiveKey);
 596                                 bProcessed = true;
 597                         } break;
 598                 case VK_UP:
 599                         {
 600                                 CUndo undo("Move Spline Key");
 601                                 CPoint point = KeyToPoint(m_nActiveKey);
 602                                 point.x -= 1;
 603                                 SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 604                                 TrackKey(point);
 605                                 bProcessed = true;
 606                         } break;
 607                 case VK_DOWN:
 608                         {
 609                                 CUndo undo("Move Spline Key");
 610                                 CPoint point = KeyToPoint(m_nActiveKey);
 611                                 point.x += 1;
 612                                 SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 613                                 TrackKey(point);
 614                                 bProcessed = true;
 615                         } break;
 616                 case VK_LEFT:
 617                         {
 618                                 CUndo undo("Move Spline Key");
 619                                 CPoint point = KeyToPoint(m_nActiveKey);
 620                                 point.x -= 1;
 621                                 SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 622                                 TrackKey(point);
 623                                 bProcessed = true;
 624                         } break;
 625                 case VK_RIGHT:
 626                         {
 627                                 CUndo undo("Move Spline Key");
 628                                 CPoint point = KeyToPoint(m_nActiveKey);
 629                                 point.y += 1;
 630                                 SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 631                                 TrackKey(point);
 632                                 bProcessed = true;
 633                         } break;
 634
 635                 default:
 636                         break; //do nothing
 637                 }
 638
 639                 RedrawWindow();
 640         }
 641
 642         if (!bProcessed)
 643                 CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
 644 }
 645
 646 //////////////////////////////////////////////////////////////////////////////
 647 CColorGradientCtrl::EHitCode CColorGradientCtrl::HitTest(CPoint point)
 648 {
 649         if (!m_pSpline)
 650                 return HIT_NOTHING;
 651
 652         ISplineInterpolator::ValueType val;
 653         float time;
 654         PointToTimeValue(point, time, val);
 655
 656         CPoint splinePt = TimeToPoint(time);
 657
 658         //bool bSplineHit = abs(splinePt.x-point.x) < 4 && abs(splinePt.y-point.y) < 4;
 659
 660         CRect rc;
 661         GetClientRect(rc);
 662
 663         m_nHitKeyIndex = -1;
 664
 665         if (rc.PtInRect(point))
 666         {
 667                 m_nHitKeyDist = 0xFFFF;
 668                 m_hitCode = HIT_SPLINE;
 669
 670                 for (int i = 0; i < m_pSpline->GetKeyCount(); i++)
 671                 {
 672                         CPoint splinePt = TimeToPoint(m_pSpline->GetKeyTime(i));
 673                         if (abs(point.x - splinePt.x) < abs(m_nHitKeyDist))
 674                         {
 675                                 m_nHitKeyIndex = i;
 676                                 m_nHitKeyDist = point.x - splinePt.x;
 677                         }
 678                 }
 679                 if (abs(m_nHitKeyDist) < 4)
 680                         m_hitCode = HIT_KEY;
 681         }
 682         else
 683                 m_hitCode = HIT_NOTHING;
 684
 685         return m_hitCode;
 686 }
 687
 688 ///////////////////////////////////////////////////////////////////////////////
 689 void CColorGradientCtrl::StartTracking()
 690 {
 691         m_bTracking = TRUE;
 692         SetCapture();
 693
 694         GetIEditor()->GetIUndoManager()->Begin();
 695         SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 696
 697         HCURSOR hCursor;
 698         hCursor = AfxGetApp()->LoadCursor(IDC_ARRBLCKCROSS);
 699         SetCursor(hCursor);
 700
 701 }
 702
 703 //////////////////////////////////////////////////////////////////////////
 704 void CColorGradientCtrl::TrackKey(CPoint point)
 705 {
 706         if (point.x < m_rcGradient.left || point.y > m_rcGradient.right)
 707                 return;
 708
 709         int nKey = m_nHitKeyIndex;
 710
 711         if (nKey >= 0)
 712         {
 713                 ISplineInterpolator::ValueType val;
 714                 float time;
 715                 PointToTimeValue(point, time, val);
 716
 717                 // Clamp to min/max time.
 718                 if (time < m_fMinTime || time > m_fMaxTime)
 719                         return;
 720
 721                 int i;
 722                 for (i = 0; i < m_pSpline->GetKeyCount(); i++)
 723                 {
 724                         // Switch to next key.
 725                         if (fabs(m_pSpline->GetKeyTime(i) - time) < MIN_TIME_EPSILON)
 726                         {
 727                                 if (i != nKey)
 728                                         return;
 729                         }
 730                 }
 731
 732                 if (!m_bLockFirstLastKey || (nKey != 0 && nKey != m_pSpline->GetKeyCount() - 1))
 733                 {
 734                         m_pSpline->SetKeyTime(nKey, time);
 735                         m_pSpline->Update();
 736                 }
 737
 738                 SendNotifyEvent(CLRGRDN_CHANGE);
 739                 if (m_updateCallback)
 740                         m_updateCallback(this);
 741
 742                 RedrawWindow();
 743         }
 744 }
 745
 746 //////////////////////////////////////////////////////////////////////////
 747 void CColorGradientCtrl::StopTracking()
 748 {
 749         if (!m_bTracking)
 750                 return;
 751
 752         GetIEditor()->GetIUndoManager()->Accept("Spline Move");
 753
 754         if (m_nHitKeyIndex >= 0)
 755         {
 756                 CPoint point;
 757                 GetCursorPos(&point);
 758                 ScreenToClient(&point);
 759
 760                 CRect rc;
 761                 GetClientRect(rc);
 762                 rc.InflateRect(100, 100);
 763                 if (!rc.PtInRect(point))
 764                 {
 765                         RemoveKey(m_nHitKeyIndex);
 766                 }
 767         }
 768
 769         m_bTracking = FALSE;
 770         ReleaseCapture();
 771 }
 772
 773 //////////////////////////////////////////////////////////////////////////
 774 void CColorGradientCtrl::EditKey(int nKey)
 775 {
 776         if (!m_pSpline)
 777                 return;
 778
 779         if (nKey < 0 || nKey >= m_pSpline->GetKeyCount())
 780                 return;
 781
 782         SetActiveKey(nKey);
 783
 784         ISplineInterpolator::ValueType val;
 785         m_pSpline->GetKeyValue(nKey, val);
 786
 787         SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 788
 789         CCustomColorDialog dlg(ValueToColor(val));
 790         dlg.SetColorChangeCallback(functor(*this, &CColorGradientCtrl::OnKeyColorChanged));
 791         if (dlg.DoModal() == IDOK)
 792         {
 793                 CUndo undo("Modify Gradient Color");
 794                 OnKeyColorChanged(dlg.GetColor());
 795         }
 796         else
 797         {
 798                 OnKeyColorChanged(ValueToColor(val));
 799         }
 800 }
 801
 802 //////////////////////////////////////////////////////////////////////////
 803 void CColorGradientCtrl::OnKeyColorChanged(COLORREF color)
 804 {
 805         int nKey = m_nActiveKey;
 806         if (!m_pSpline)
 807                 return;
 808         if (nKey < 0 || nKey >= m_pSpline->GetKeyCount())
 809                 return;
 810
 811         ISplineInterpolator::ValueType val;
 812         ColorToValue(color, val);
 813         m_pSpline->SetKeyValue(nKey, val);
 814         Invalidate();
 815
 816         if (m_bLockFirstLastKey)
 817         {
 818                 if (nKey == 0)
 819                         m_pSpline->SetKeyValue(m_pSpline->GetKeyCount() - 1, val);
 820                 else if (nKey == m_pSpline->GetKeyCount() - 1)
 821                         m_pSpline->SetKeyValue(0, val);
 822         }
 823         m_pSpline->Update();
 824         SendNotifyEvent(CLRGRDN_CHANGE);
 825         if (m_updateCallback)
 826                 m_updateCallback(this);
 827
 828         GetIEditor()->UpdateViews(eRedrawViewports);
 829 }
 830
 831 //////////////////////////////////////////////////////////////////////////
 832 void CColorGradientCtrl::RemoveKey(int nKey)
 833 {
 834         if (!m_pSpline)
 835                 return;
 836         if (m_bLockFirstLastKey)
 837         {
 838                 if (nKey == 0 || nKey == m_pSpline->GetKeyCount() - 1)
 839                         return;
 840         }
 841
 842         CUndo undo("Remove Spline Key");
 843
 844         SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 845         m_nActiveKey = -1;
 846         m_nHitKeyIndex = -1;
 847         if (m_pSpline)
 848         {
 849                 m_pSpline->RemoveKey(nKey);
 850                 m_pSpline->Update();
 851         }
 852         SendNotifyEvent(CLRGRDN_CHANGE);
 853         if (m_updateCallback)
 854                 m_updateCallback(this);
 855
 856         Invalidate();
 857 }
 858
 859 //////////////////////////////////////////////////////////////////////////
 860 int CColorGradientCtrl::InsertKey(CPoint point)
 861 {
 862         CUndo undo("Spline Insert Key");
 863
 864         ISplineInterpolator::ValueType val;
 865
 866         float time;
 867         PointToTimeValue(point, time, val);
 868
 869         if (time < m_fMinTime || time > m_fMaxTime)
 870                 return -1;
 871
 872         int i;
 873         for (i = 0; i < m_pSpline->GetKeyCount(); i++)
 874         {
 875                 // Skip if any key already have time that is very close.
 876                 if (fabs(m_pSpline->GetKeyTime(i) - time) < MIN_TIME_EPSILON)
 877                         return i;
 878         }
 879
 880         SendNotifyEvent(CLRGRDN_BEFORE_CHANGE);
 881
 882         m_pSpline->InsertKey(time, val);
 883         m_pSpline->Interpolate(time, val);
 884         ClearSelection();
 885         Invalidate();
 886
 887         SendNotifyEvent(CLRGRDN_CHANGE);
 888         if (m_updateCallback)
 889                 m_updateCallback(this);
 890
 891         for (i = 0; i < m_pSpline->GetKeyCount(); i++)
 892         {
 893                 // Find key with added time.
 894                 if (m_pSpline->GetKeyTime(i) == time)
 895                         return i;
 896         }
 897
 898         return -1;
 899 }
 900
 901 //////////////////////////////////////////////////////////////////////////
 902 void CColorGradientCtrl::ClearSelection()
 903 {
 904         m_nActiveKey = -1;
 905         if (m_pSpline)
 906                 m_bSelectedKeys.resize(m_pSpline->GetKeyCount());
 907         for (int i = 0; i < (int)m_bSelectedKeys.size(); i++)
 908                 m_bSelectedKeys[i] = false;
 909 }
 910
 911 //////////////////////////////////////////////////////////////////////////
 912 void CColorGradientCtrl::SetTimeMarker(float fTime)
 913 {
 914         if (!m_pSpline)
 915                 return;
 916
 917         {
 918                 CPoint pt = TimeToPoint(m_fTimeMarker);
 919                 CRect rc = CRect(pt.x, m_rcGradient.top, pt.x, m_rcGradient.bottom);
 920                 rc.NormalizeRect();
 921                 rc.InflateRect(1, 0);
 922                 InvalidateRect(rc);
 923         }
 924         {
 925                 CPoint pt = TimeToPoint(fTime);
 926                 CRect rc = CRect(pt.x, m_rcGradient.top, pt.x, m_rcGradient.bottom);
 927                 rc.NormalizeRect();
 928                 rc.InflateRect(1, 0);
 929                 InvalidateRect(rc);
 930         }
 931         m_fTimeMarker = fTime;
 932 }
 933
 934 //////////////////////////////////////////////////////////////////////////
 935 void CColorGradientCtrl::SendNotifyEvent(int nEvent)
 936 {
 937         NMHDR nmh;
 938         nmh.hwndFrom = m_hWnd;
 939         nmh.idFrom = ::GetDlgCtrlID(m_hWnd);
 940         nmh.code = nEvent;
 941
 942         GetOwner()->SendMessage(WM_NOTIFY, (WPARAM)GetDlgCtrlID(), (LPARAM)&nmh);
 943 }
 944
 945 //////////////////////////////////////////////////////////////////////////
 946 COLORREF CColorGradientCtrl::ValueToColor(ISplineInterpolator::ValueType val)
 947 {
 948         return CMFCUtils::ColorLinearToGamma(ColorF(val[0], val[1], val[2]));
 949 }
 950
 951 //////////////////////////////////////////////////////////////////////////
 952 void CColorGradientCtrl::ColorToValue(COLORREF col, ISplineInterpolator::ValueType& val)
 953 {
 954         ColorF colLin = CMFCUtils::ColorGammaToLinear(col);
 955         val[0] = colLin.r;
 956         val[1] = colLin.g;
 957         val[2] = colLin.b;
 958         val[3] = 0;
 959 }