home *** CD-ROM | disk | FTP | other *** search
/ Large Pack of OldSkool DOS MOD Trackers / beaversweeper_v101.zip / src / RoundSliderCtrl.cpp < prev    next >
C/C++ Source or Header  |  2005-10-07  |  17KB  |  665 lines
  1. // RoundSliderCtrl.cpp : implementation file
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "tracker.h"
  6. #include "RoundSliderCtrl.h"
  7.  
  8. #include <math.h>
  9.  
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  15.  
  16.  
  17. static const double pi = 3.141592653589793238462643383279;
  18.  
  19. // The following 3 functions were taken from 'CRoundButton.cpp', written and
  20. // copyright (c) 1997,1998 by Chris Maunder (chrismaunder@codeguru.com).
  21. // To be honest, I never had a look at their implementation, I just use them.
  22. // This is cut-and-paste-programming at its best... if it works... :)
  23.  
  24. // prototypes
  25. COLORREF GetColour(double dAngle, COLORREF crBright, COLORREF crDark);
  26. void DrawCircle(CDC* pDC, CPoint p, LONG lRadius, COLORREF crColour, BOOL bDashed = FALSE);
  27. void DrawCircle(CDC* pDC, CPoint p, LONG lRadius, COLORREF crBright, COLORREF crDark);
  28.  
  29.  
  30. // Calculate colour for a point at the given angle by performing a linear
  31. // interpolation between the colours crBright and crDark based on the cosine
  32. // of the angle between the light source and the point.
  33. //
  34. // Angles are measured from the +ve x-axis (i.e. (1,0) = 0 degrees, (0,1) = 90 degrees )
  35. // But remember: +y points down!
  36.  
  37. COLORREF GetColour(double dAngle, COLORREF crBright, COLORREF crDark)
  38. {
  39. #define Rad2Deg    180.0/3.1415 
  40. #define LIGHT_SOURCE_ANGLE    -2.356        // -2.356 radians = -135 degrees, i.e. From top left
  41.  
  42.     ASSERT(dAngle > -3.1416 && dAngle < 3.1416);
  43.     double dAngleDifference = LIGHT_SOURCE_ANGLE - dAngle;
  44.  
  45.     if (dAngleDifference < -3.1415) dAngleDifference = 6.293 + dAngleDifference;
  46.     else if (dAngleDifference > 3.1415) dAngleDifference = 6.293 - dAngleDifference;
  47.  
  48.     double Weight = 0.5*(cos(dAngleDifference)+1.0);
  49.  
  50.     BYTE Red   = (BYTE) (Weight*GetRValue(crBright) + (1.0-Weight)*GetRValue(crDark));
  51.     BYTE Green = (BYTE) (Weight*GetGValue(crBright) + (1.0-Weight)*GetGValue(crDark));
  52.     BYTE Blue  = (BYTE) (Weight*GetBValue(crBright) + (1.0-Weight)*GetBValue(crDark));
  53.  
  54.     //TRACE("LightAngle = %0.0f, Angle = %3.0f, Diff = %3.0f, Weight = %0.2f, RGB%3d,%3d,%3d\n", 
  55.     //      LIGHT_SOURCE_ANGLE*Rad2Deg, dAngle*Rad2Deg, dAngleDifference*Rad2Deg,Weight,Red,Green,Blue);
  56.  
  57.     return RGB(Red, Green, Blue);
  58. }
  59.  
  60. void DrawCircle(CDC* pDC, CPoint p, LONG lRadius, COLORREF crColour, BOOL bDashed)
  61. {
  62.     const int nDashLength = 1;
  63.     LONG lError, lXoffset, lYoffset;
  64.     int  nDash = 0;
  65.     BOOL bDashOn = TRUE;
  66.  
  67.     //Check to see that the coordinates are valid
  68.     ASSERT( (p.x + lRadius <= LONG_MAX) && (p.y + lRadius <= LONG_MAX) );
  69.     ASSERT( (p.x - lRadius >= LONG_MIN) && (p.y - lRadius >= LONG_MIN) );
  70.  
  71.     //Set starting values
  72.     lXoffset = lRadius;
  73.     lYoffset = 0;
  74.     lError     = -lRadius;
  75.  
  76.     do {
  77.         if (bDashOn) {
  78.             pDC->SetPixelV(p.x + lXoffset, p.y + lYoffset, crColour);
  79.             pDC->SetPixelV(p.x + lXoffset, p.y - lYoffset, crColour);
  80.             pDC->SetPixelV(p.x + lYoffset, p.y + lXoffset, crColour);
  81.             pDC->SetPixelV(p.x + lYoffset, p.y - lXoffset, crColour);
  82.             pDC->SetPixelV(p.x - lYoffset, p.y + lXoffset, crColour);
  83.             pDC->SetPixelV(p.x - lYoffset, p.y - lXoffset, crColour);
  84.             pDC->SetPixelV(p.x - lXoffset, p.y + lYoffset, crColour);
  85.             pDC->SetPixelV(p.x - lXoffset, p.y - lYoffset, crColour);
  86.         }
  87.  
  88.         //Advance the error term and the constant X axis step
  89.         lError += lYoffset++;
  90.  
  91.         //Check to see if error term has overflowed
  92.         if ((lError += lYoffset) >= 0)
  93.             lError -= --lXoffset * 2;
  94.  
  95.         if (bDashed && (++nDash == nDashLength)) {
  96.             nDash = 0;
  97.             bDashOn = !bDashOn;
  98.         }
  99.  
  100.     } while (lYoffset <= lXoffset);    //Continue until halfway point
  101. } 
  102.  
  103. void DrawCircle(CDC* pDC, CPoint p, LONG lRadius, COLORREF crBright, COLORREF crDark)
  104. {
  105.     LONG lError, lXoffset, lYoffset;
  106.  
  107.     //Check to see that the coordinates are valid
  108.     ASSERT( (p.x + lRadius <= LONG_MAX) && (p.y + lRadius <= LONG_MAX) );
  109.     ASSERT( (p.x - lRadius >= LONG_MIN) && (p.y - lRadius >= LONG_MIN) );
  110.  
  111.     //Set starting values
  112.     lXoffset = lRadius;
  113.     lYoffset = 0;
  114.     lError     = -lRadius;
  115.  
  116.     do {
  117.         const double Pi = 3.141592654, 
  118.                      Pi_on_2 = Pi * 0.5,
  119.                      Three_Pi_on_2 = Pi * 1.5;
  120.         COLORREF crColour;
  121.         double     dAngle = atan2((float)lYoffset, (float)lXoffset);
  122.  
  123.         //Draw the current pixel, reflected across all eight arcs
  124.         crColour = GetColour(dAngle, crBright, crDark);
  125.         pDC->SetPixelV(p.x + lXoffset, p.y + lYoffset, crColour);
  126.  
  127.         crColour = GetColour(Pi_on_2 - dAngle, crBright, crDark);
  128.         pDC->SetPixelV(p.x + lYoffset, p.y + lXoffset, crColour);
  129.  
  130.         crColour = GetColour(Pi_on_2 + dAngle, crBright, crDark);
  131.         pDC->SetPixelV(p.x - lYoffset, p.y + lXoffset, crColour);
  132.  
  133.         crColour = GetColour(Pi - dAngle, crBright, crDark);
  134.         pDC->SetPixelV(p.x - lXoffset, p.y + lYoffset, crColour);
  135.  
  136.         crColour = GetColour(-Pi + dAngle, crBright, crDark);
  137.         pDC->SetPixelV(p.x - lXoffset, p.y - lYoffset, crColour);
  138.  
  139.         crColour = GetColour(-Pi_on_2 - dAngle, crBright, crDark);
  140.         pDC->SetPixelV(p.x - lYoffset, p.y - lXoffset, crColour);
  141.  
  142.         crColour = GetColour(-Pi_on_2 + dAngle, crBright, crDark);
  143.         pDC->SetPixelV(p.x + lYoffset, p.y - lXoffset, crColour);
  144.  
  145.         crColour = GetColour(-dAngle, crBright, crDark);
  146.         pDC->SetPixelV(p.x + lXoffset, p.y - lYoffset, crColour);
  147.  
  148.         //Advance the error term and the constant X axis step
  149.         lError += lYoffset++;
  150.  
  151.         //Check to see if error term has overflowed
  152.         if ((lError += lYoffset) >= 0)
  153.             lError -= --lXoffset * 2;
  154.  
  155.     } while (lYoffset <= lXoffset);    //Continue until halfway point
  156. } 
  157.  
  158. /////////////////////////////////////////////////////////////////////////////
  159. // CRoundSliderCtrl
  160.  
  161. IMPLEMENT_DYNAMIC(CRoundSliderCtrl, CSliderCtrl)
  162.  
  163. CRoundSliderCtrl::CRoundSliderCtrl()
  164. {
  165. //    m_strText = "%ld░";
  166.     m_strText = "%f";
  167.     m_nKnobRadius = 7;
  168.     m_nZero = 0;
  169.     m_bInverted = false;
  170.     m_bDragging = false;
  171.     m_bDrawRadioButton = true;
  172. }
  173.  
  174. CRoundSliderCtrl::~CRoundSliderCtrl()
  175. {
  176. }
  177.  
  178. BEGIN_MESSAGE_MAP(CRoundSliderCtrl, CSliderCtrl)
  179.     //{{AFX_MSG_MAP(CRoundSliderCtrl)
  180.     ON_WM_SIZE()
  181.     ON_WM_ERASEBKGND()
  182.     ON_WM_PAINT()
  183.     ON_WM_LBUTTONDOWN()
  184.     ON_WM_MOUSEMOVE()
  185.     ON_WM_LBUTTONUP()
  186.     ON_WM_KEYDOWN()
  187.     ON_WM_KEYUP()
  188.     //}}AFX_MSG_MAP
  189. END_MESSAGE_MAP()
  190.  
  191. void CRoundSliderCtrl::PreSubclassWindow() 
  192. {
  193.     CSliderCtrl::PreSubclassWindow();
  194.  
  195.     SetRange(0, 359, FALSE);
  196.     SetLineSize(1);
  197.     SetPageSize(10);
  198.  
  199.     Init();
  200. }
  201.  
  202. BOOL CRoundSliderCtrl::PreCreateWindow(CREATESTRUCT& cs) 
  203. {
  204.     if(!CSliderCtrl::PreCreateWindow(cs)) return FALSE;
  205.  
  206.     SetRange(0, 359, FALSE);
  207.     SetLineSize(1);
  208.     SetPageSize(10);
  209.  
  210.     Init();
  211.  
  212.     return TRUE;
  213. }
  214.  
  215. void CRoundSliderCtrl::OnSize(UINT nType, int cx, int cy) 
  216. {
  217.     CSliderCtrl::OnSize(nType, cx, cy);
  218.     
  219.     Init();
  220. }
  221.  
  222. void CRoundSliderCtrl::Init()
  223. {
  224.     CRect rc;
  225.     GetClientRect(rc);
  226.  
  227.     // Resize the window to make it square
  228.     rc.bottom = rc.right = max(rc.bottom, rc.right);
  229.  
  230.     // Get the vital statistics of the window
  231.     m_ptCenter = rc.CenterPoint();
  232.     m_ptCenter.y-=8;
  233.     m_nRadius = rc.bottom/2-(m_nKnobRadius+1)-5;
  234.  
  235.     // Set the window region so mouse clicks only activate the round section 
  236.     // of the slider
  237. /*
  238.  
  239.     m_rgn.DeleteObject(); 
  240.     SetWindowRgn(NULL, FALSE);
  241.     m_rgn.CreateEllipticRgnIndirect(rc);
  242.     SetWindowRgn(m_rgn, TRUE);
  243. */
  244.     // VerifyPos();
  245. }
  246.  
  247. #pragma warning(disable:4100) // Unreferenced formal parameter
  248. BOOL CRoundSliderCtrl::OnEraseBkgnd(CDC* pDC) 
  249. {
  250.     return TRUE;
  251. }
  252. #pragma warning(default:4100)
  253.  
  254. void CRoundSliderCtrl::OnPaint() 
  255. {
  256.     const int nMin = GetRangeMin();
  257.     const int nMax = GetRangeMax()+1;
  258.  
  259.     int nRadius = m_nRadius;
  260.  
  261.     // Draw (clear) the background
  262.     CRect rc;
  263.     GetClientRect(rc);
  264.  
  265.     CPaintDC dc_(this); // device context for painting
  266.  
  267. #ifdef USE_MEM_DC
  268.     CMemDC pDC(&dc);
  269. #else
  270.     CDC dcc;
  271.     dcc.CreateCompatibleDC(0);
  272.     CBitmap bmp;
  273.     bmp.CreateCompatibleBitmap( &dc_, rc.right, rc.bottom );
  274.     dcc.SelectObject( &bmp );
  275.     CDC* pDC = &dcc;
  276. #endif
  277.  
  278.     pDC->SelectStockObject(NULL_BRUSH);
  279.     pDC->FillSolidRect(rc, ::GetSysColor(COLOR_BTNFACE));
  280.  
  281.  
  282. //  pDC->FillSolidRect(rc, ::GetSysColor(COLOR_BACKGROUND));
  283.   // Draw the sliders channel
  284.     if (!m_bDrawRadioButton)
  285.     {
  286.         DrawCircle(pDC, m_ptCenter, nRadius--, ::GetSysColor(COLOR_3DDKSHADOW),::GetSysColor(COLOR_3DHIGHLIGHT));
  287.         DrawCircle(pDC, m_ptCenter, nRadius, ::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DLIGHT));
  288.     }
  289.     int nPos = (((GetPos()-nMin)*360/(nMax-nMin)) + m_nZero + 360) % 360;
  290.     if(m_bInverted) nPos = 360-nPos;
  291.  
  292.     const double dPos = ((double)(nPos))*pi/180.0;
  293.  
  294. #pragma warning(disable:4244) // Disable warning "Converting 'double' to 'int', possible loss of data"
  295.     CPoint    ptKnobCenter;
  296.     
  297.     if (m_bDrawRadioButton)
  298.     {
  299.         ptKnobCenter = CPoint(    m_ptCenter.x + (nRadius-m_nKnobRadius) * sin(dPos), 
  300.                                 m_ptCenter.y - (nRadius-m_nKnobRadius) *
  301. cos(dPos));
  302.     }
  303.     else
  304.     {
  305.         ptKnobCenter = CPoint(    m_ptCenter.x + (nRadius) * sin(dPos), 
  306.                                 m_ptCenter.y - (nRadius) * cos(dPos));
  307.     }
  308. #pragma warning(default:4244)
  309.     nRadius+=2;
  310.  
  311.     DrawCircle(pDC, m_ptCenter, nRadius--, ::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DDKSHADOW));
  312.     DrawCircle(pDC, m_ptCenter, nRadius--, ::GetSysColor(COLOR_3DLIGHT), ::GetSysColor(COLOR_3DSHADOW));
  313.     
  314.     // Draw the knob
  315.     int nKnobRadius;
  316.     if (m_bDrawRadioButton)
  317.     {
  318. #pragma warning(disable:4244) // Disable warning "Converting 'double' to 'int', possible loss of data"
  319.         nKnobRadius= m_nKnobRadius*0.8;
  320. #pragma warning(default:4244)
  321.     }
  322.     else
  323.     {
  324.         nKnobRadius= m_nKnobRadius;
  325.     }
  326.     const CRect rcKnob(    ptKnobCenter.x - nKnobRadius, ptKnobCenter.y - nKnobRadius, 
  327.                         ptKnobCenter.x + nKnobRadius, ptKnobCenter.y + nKnobRadius);
  328.  
  329.     CRgn rgnKnob;
  330.     rgnKnob.CreateEllipticRgnIndirect(rcKnob);
  331.     CBrush brKnob(::GetSysColor(COLOR_BTNFACE));
  332.     pDC->FillRgn(&rgnKnob, &brKnob);
  333.     rgnKnob.DeleteObject();
  334.  
  335.     if (!m_bDrawRadioButton)
  336.     {
  337.         if(m_bDragging)
  338.         {
  339.             DrawCircle(pDC, ptKnobCenter, --nKnobRadius, ::GetSysColor(COLOR_3DDKSHADOW),::GetSysColor(COLOR_3DHIGHLIGHT));
  340.             DrawCircle(pDC, ptKnobCenter, --nKnobRadius, ::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DLIGHT));
  341.         }
  342.         else
  343.         {
  344.             DrawCircle(pDC, ptKnobCenter, --nKnobRadius, ::GetSysColor(COLOR_3DHIGHLIGHT), ::GetSysColor(COLOR_3DDKSHADOW));
  345.             DrawCircle(pDC, ptKnobCenter, --nKnobRadius, ::GetSysColor(COLOR_3DLIGHT), ::GetSysColor(COLOR_3DSHADOW));
  346.         }
  347.     }
  348.     else
  349.     {
  350.             DrawCircle(pDC, ptKnobCenter, --nKnobRadius, ::GetSysColor(COLOR_3DDKSHADOW),::GetSysColor(COLOR_3DHIGHLIGHT));
  351.             DrawCircle(pDC, ptKnobCenter, --nKnobRadius, ::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DLIGHT));
  352.     }
  353.  
  354.     // Draw the focus circle on the inside of the knob
  355.     if (!m_bDrawRadioButton)
  356.         if(GetFocus() == this)
  357.         {
  358.             DrawCircle(pDC, ptKnobCenter, nKnobRadius-2, RGB(0, 0, 0), TRUE);
  359.         }
  360.  
  361.     // Draw the text
  362.     const CString strFormattedText = OnFormatText();
  363.  
  364.     if(!strFormattedText.IsEmpty())
  365.     {
  366.         CWnd* pOwner = GetParentOwner();
  367.         if(pOwner)
  368.         {
  369.             CFont* pFont = pOwner->GetFont();
  370.             pDC->SelectObject(pFont);
  371.         }
  372.  
  373.         const CSize szExtent = pDC->GetTextExtent(strFormattedText);
  374.         const CPoint ptText = CPoint(m_ptCenter.x - szExtent.cx/2, m_nRadius+m_ptCenter.y/* + szExtent.cy*/);
  375.  
  376.         pDC->SetBkMode(TRANSPARENT);
  377.         if(!IsWindowEnabled())
  378.         {
  379.             pDC->DrawState(ptText, szExtent, strFormattedText, DSS_DISABLED, TRUE, 0,(HBRUSH)NULL);
  380.         }
  381.         else
  382.         {
  383.             pDC->TextOut(ptText.x, ptText.y, strFormattedText);
  384.         }
  385.     }
  386.  
  387.     #ifdef USE_MEM_DC
  388.         CMemDC pDC(&dc);
  389.     #else
  390.         dc_.BitBlt( 0, 0, rc.right, rc.bottom, pDC, 0, 0, SRCCOPY );
  391.     #endif
  392.  
  393.     // Don't call CSliderCtrl::OnPaint()
  394. }
  395.  
  396. void CRoundSliderCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  397. {
  398.     if(!m_bDragging)
  399.     {
  400.         m_bDragging = true;
  401.         m_bDragChanged = false;
  402.         SetCapture();
  403.         SetFocus();
  404.         if(SetKnob(point))
  405.         {
  406.             m_bDragChanged = true;
  407.             PostMessageToParent(TB_THUMBTRACK);
  408.         }
  409.         RedrawWindow();
  410.     }
  411.     else
  412.     {
  413.         CSliderCtrl::OnLButtonDown(nFlags, point);
  414.     }
  415. }
  416.  
  417. void CRoundSliderCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  418. {
  419.     if(m_bDragging)
  420.     {
  421.         if(SetKnob(point))
  422.         {
  423.             m_bDragChanged = true;
  424.             PostMessageToParent(TB_THUMBTRACK);
  425.             RedrawWindow();
  426.         }
  427.     }
  428.     else
  429.     {
  430.         CSliderCtrl::OnMouseMove(nFlags, point);
  431.     }
  432. }
  433.  
  434. void CRoundSliderCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
  435. {
  436.     if(m_bDragging)
  437.     {
  438.         m_bDragging = false;
  439.         ::ReleaseCapture();
  440.         if(SetKnob(point))
  441.         {
  442.             PostMessageToParent(TB_THUMBTRACK);
  443.             m_bDragChanged = true;
  444.         }
  445.         if(m_bDragChanged)
  446.         {
  447.             PostMessageToParent(TB_THUMBPOSITION);
  448.             m_bDragChanged = false;
  449.         }
  450.         RedrawWindow();
  451.     }
  452.     else
  453.     {
  454.         CSliderCtrl::OnLButtonUp(nFlags, point);
  455.     }
  456. }
  457.  
  458. bool CRoundSliderCtrl::SetKnob(const CPoint& pt)
  459. {
  460.     const int nMin = GetRangeMin();
  461.     const int nMax = GetRangeMax()+1;
  462.  
  463.     CSize szDelta = pt - m_ptCenter;
  464.     if(m_bInverted) szDelta.cx *= -1;
  465.  
  466.     double dNewPos = 0.0;
  467.  
  468.     if(szDelta.cx != 0)
  469.     {
  470.         dNewPos = 90.0 - atan(-(double)szDelta.cy / (double)szDelta.cx) * 180.0 / pi;
  471.     }
  472.  
  473.     if(((szDelta.cx == 0) && (szDelta.cy >= 0)) || (szDelta.cx < 0))
  474.     {
  475.         dNewPos += 180.0;
  476.     }
  477.  
  478.     dNewPos -= m_nZero;
  479.  
  480.     while(dNewPos < 0.0) dNewPos += 360.0;
  481.     while(dNewPos >= 360.0) dNewPos -= 360.0;
  482.  
  483.     const int nNewPos = nMin + (int)(dNewPos*(nMax-nMin)/360.0);
  484.     const bool bChanged = (nNewPos != GetPos());
  485.  
  486.     if(bChanged)
  487.     {
  488.         SetPos(nNewPos);
  489.     }
  490.  
  491.     return bChanged;
  492. }
  493.  
  494. void CRoundSliderCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  495. {
  496.     const int nMin = GetRangeMin();
  497.     const int nMax = GetRangeMax()+1;
  498.  
  499.     switch(nChar)
  500.     {
  501.     case VK_LEFT:
  502.     case VK_UP:
  503.         {
  504.             int nNewPos = GetPos()-GetLineSize();
  505.             while(nNewPos < nMin) nNewPos += (nMax - nMin);
  506.             SetPos(nNewPos);
  507.             RedrawWindow();
  508.             PostMessageToParent(TB_LINEUP);
  509.         }
  510.         break;
  511.     
  512.     case VK_RIGHT:
  513.     case VK_DOWN:
  514.         {
  515.             int nNewPos = GetPos()+GetLineSize();
  516.             while(nNewPos >= nMax) nNewPos -= (nMax - nMin);
  517.             SetPos(nNewPos);
  518.             RedrawWindow();
  519.             PostMessageToParent(TB_LINEDOWN);
  520.         }
  521.         break;
  522.  
  523.     case VK_PRIOR:
  524.         {
  525.             int nNewPos = GetPos()-GetPageSize();
  526.             while(nNewPos < nMin) nNewPos += (nMax - nMin);
  527.             SetPos(nNewPos);
  528.             RedrawWindow();
  529.             PostMessageToParent(TB_PAGEUP);
  530.         }
  531.         break;
  532.  
  533.     case VK_NEXT:
  534.         {
  535.             int nNewPos = GetPos()+GetPageSize();
  536.             while(nNewPos >= nMax) nNewPos -= (nMax - nMin);
  537.             SetPos(nNewPos);
  538.             RedrawWindow();
  539.             PostMessageToParent(TB_PAGEDOWN);
  540.         }
  541.         break;
  542.  
  543.     case VK_HOME:
  544.     case VK_END:
  545.         // Do nothing (ignore keystroke)
  546.         break;
  547.  
  548.     default:
  549.         CSliderCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
  550.     }
  551. }
  552.  
  553. void CRoundSliderCtrl::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
  554. {
  555.     switch(nChar)
  556.     {
  557.     case VK_LEFT:
  558.     case VK_UP:
  559.     case VK_RIGHT:
  560.     case VK_DOWN:
  561.     case VK_PRIOR:
  562.     case VK_NEXT:
  563.         PostMessageToParent(TB_ENDTRACK);
  564.         break;
  565.  
  566.     case VK_HOME:
  567.     case VK_END:
  568.         // Do nothing
  569.         break;
  570.  
  571.     default:
  572.         CSliderCtrl::OnKeyUp(nChar, nRepCnt, nFlags);
  573.     }
  574. }
  575.  
  576. void CRoundSliderCtrl::PostMessageToParent(const int nTBCode) const
  577. {
  578.     CWnd* pWnd = GetParent();
  579.     if(pWnd) pWnd->PostMessage(WM_HSCROLL, (WPARAM)((GetPos() << 16) | nTBCode),(LPARAM)GetSafeHwnd());
  580. }
  581.  
  582. void CRoundSliderCtrl::SetScale (const float scale)
  583. {
  584.   m_scale = scale;
  585. }
  586. float CRoundSliderCtrl::GetScale (void) const
  587. {
  588.   return m_scale;
  589. }
  590. void CRoundSliderCtrl::SetText(const CString& strNewText)
  591. {
  592.     m_strText = strNewText;
  593. }
  594.  
  595. CString CRoundSliderCtrl::GetText() const
  596. {
  597.     return m_strText;
  598. }
  599.  
  600. void CRoundSliderCtrl::SetKnobRadius(const int nNewKnobRadius)
  601. {
  602.     ASSERT(nNewKnobRadius > 4);
  603.  
  604.     m_nKnobRadius = nNewKnobRadius;
  605. }
  606.  
  607. void CRoundSliderCtrl::SetDrawRadioButton(const bool nDrawRadioButton)
  608. {
  609.     m_bDrawRadioButton = nDrawRadioButton;
  610. }
  611.  
  612. int CRoundSliderCtrl::GetKnobRadius() const
  613. {
  614.     return m_nKnobRadius;
  615. }
  616.  
  617. void CRoundSliderCtrl::SetZero(const int nZero)
  618. {
  619.     ASSERT(nZero >= 0 && nZero < 360);
  620.  
  621.     m_nZero = nZero;
  622. }
  623.  
  624. int CRoundSliderCtrl::GetZero() const
  625. {
  626.     return m_nZero;
  627. }
  628.  
  629. void CRoundSliderCtrl::SetInverted(const bool bNewInverted)
  630. {
  631.     m_bInverted = bNewInverted;
  632. }
  633.  
  634. bool CRoundSliderCtrl::GetInverted()
  635. {
  636.     return m_bInverted;
  637. }
  638.  
  639. // Overrideables
  640. CString CRoundSliderCtrl::OnFormatText()
  641. {
  642.     CString strFormattedText;
  643.     strFormattedText.Format(GetText(), GetPos()*m_scale);
  644.     return strFormattedText;
  645. }
  646.  
  647. #ifdef _DEBUG
  648. void CRoundSliderCtrl::AssertValid() const
  649. {
  650.     CSliderCtrl::AssertValid();
  651.  
  652.     ASSERT(m_nZero >= 0 && m_nZero < 360);
  653.     ASSERT(m_nKnobRadius > 4);
  654. }
  655.  
  656. void CRoundSliderCtrl::Dump(CDumpContext& dc) const
  657. {
  658.     CSliderCtrl::Dump(dc);
  659.  
  660.     dc    << "m_strText = '" << m_strText << "'\n"
  661.         << "m_nKnobRadius = " << m_nKnobRadius << "\n"
  662.         << "m_nZero = " << m_nZero;
  663. }
  664. #endif // _DEBUG
  665.