MFC自制进度条

改变进度条的颜色http://www.codefans.net/articles/1454.shtml

使用方法

1.将三个文件添加到工程
2.在对话框上添加一个进度条；
新建一个类CGradientProgressCtrl，其基类为CProgressCtrl
3.为进度条添加变量，变量类型CGradientProgressCtrl，否则运行不成功

 

添加方法：进度条右键-->添加变量

 添加变量后，系统会自动在.h文件中添加变量定义CGradientProgressCtrl  progress;

在.c文件中的DoDataExchange函数中进行控件绑定并添加关联DDX_Control代码

4.
应用：
m_process1.SetRange(0, 100);
m_process1.ShowPercent(TRUE);
m_process1.SetStartColor(RGB(0, 0, 255));
m_process1.SetEndColor(RGB(255, 255, 0));
m_process1.SetTextColor(RGB(0, 0, 255));
m_process1.SetBkColor(RGB(125, 125, 125));
m_process1.SetPos(50);//设置百分比

5、其中GradientProgressCtrl.h

 #if !defined(AFX_ENHPROGRESSCTRL_H__12909D73_C393_11D1_9FAE_8192554015AD__INCLUDED_)
 #define AFX_ENHPROGRESSCTRL_H__12909D73_C393_11D1_9FAE_8192554015AD__INCLUDED_

 #if _MSC_VER >= 1000
 #pragma once
 #endif // _MSC_VER >= 1000
 // EnhProgressCtrl.h : header file

 // GradientProgressCtrl.h : header file

 #include "MemDC.h"

 /////////////////////////////////////////////////////////////////////////////
 // CGradientProgressCtrl window

 class CGradientProgressCtrl : public CProgressCtrl
 {
 // Construction
 public:
     CGradientProgressCtrl();

 // Attributes
 public:
 // Attributes

     void SetRange(int nLower, int nUpper);
     void SetRange32( int nLower, int nUpper );
     int SetPos(int nPos);
     int SetStep(int nStep);
     int StepIt(void);

 // Operations
 public:

     // Set Functions
     void SetTextColor(COLORREF color)   {m_clrText = color;}
     void SetBkColor(COLORREF color)      {m_clrBkGround = color;}
     void SetStartColor(COLORREF color)  {m_clrStart = color;}
     void SetEndColor(COLORREF color)    {m_clrEnd = color;}

     // Show the percent caption
     void ShowPercent(BOOL bShowPercent = TRUE)  {m_bShowPercent = bShowPercent;}

     // Get Functions
     COLORREF GetTextColor(void) {return m_clrText;}
     COLORREF GetBkColor(void)        {return m_clrBkGround;}
     COLORREF GetStartColor(void)    {return m_clrStart;}
     COLORREF GetEndColor(void)  {return m_clrEnd;}


 // Overrides
     // ClassWizard generated virtual function overrides
     //{{AFX_VIRTUAL(CGradientProgressCtrl)
     protected:
     //}}AFX_VIRTUAL

 // Implementation
 public:
     virtual ~CGradientProgressCtrl();

     // Generated message map functions
 protected:
     void DrawGradient(CPaintDC *pDC, const RECT &rectClient, const int &nMaxWidth, const BOOL &bVertical);
     int m_nLower, m_nUpper, m_nStep, m_nCurrentPosition;
     COLORREF    m_clrStart, m_clrEnd, m_clrBkGround, m_clrText;
     BOOL m_bShowPercent;
     //{{AFX_MSG(CGradientProgressCtrl)
     afx_msg void OnPaint();
     afx_msg BOOL OnEraseBkgnd(CDC* pDC);
     //}}AFX_MSG

     DECLARE_MESSAGE_MAP()
 };

 /////////////////////////////////////////////////////////////////////////////

 //{{AFX_INSERT_LOCATION}}
 // Microsoft Developer Studio will insert additional declarations immediately before the previous line.

 #endif // !defined(AFX_ENHPROGRESSCTRL_H__12909D73_C393_11D1_9FAE_8192554015AD__INCLUDED_)

5、其中GradientProgressCtrl.c

 // GradientProgressCtrl.cpp : implementation file

 #include "stdafx.h"
 #include "GradientProgressCtrl.h"

 #ifdef _DEBUG
 #define new DEBUG_NEW
 #undef THIS_FILE
 static char THIS_FILE[] = __FILE__;
 #endif

 /////////////////////////////////////////////////////////////////////////////
 // CGradientProgressCtrl

 CGradientProgressCtrl::CGradientProgressCtrl()
 {
     // Defaults assigned by CProgressCtrl()
     m_nLower = 0;
     m_nUpper = 100;
     m_nCurrentPosition = 0;
     m_nStep = 10;

     // Initial colors
     m_clrStart  = COLORREF(RGB(255, 0,0));
     m_clrEnd =   COLORREF(RGB(0,0,255));
     m_clrBkGround = COLORREF(RGB(0, 0, 0)); //::GetSysColor(COLOR_3DFACE);
     m_clrText = COLORREF(RGB(255, 255, 255));

     // Initial show percent
     m_bShowPercent = FALSE;
 }

 CGradientProgressCtrl::~CGradientProgressCtrl()
 {
 }


 BEGIN_MESSAGE_MAP(CGradientProgressCtrl, CProgressCtrl)
     //{{AFX_MSG_MAP(CGradientProgressCtrl)
     ON_WM_PAINT()
     ON_WM_ERASEBKGND()
     //}}AFX_MSG_MAP
 END_MESSAGE_MAP()

 /////////////////////////////////////////////////////////////////////////////
 // CGradientProgressCtrl message handlers

 /////////////////////////////////////////////////////////////////////////////
 /*
     OnPaint

     The main drawing routine.  Consists of two parts
     (1) Call the DrawGradient routine to draw the visible part of the progress gradient
     (2) If needed, show the percentage text

  */
 /////////////////////////////////////////////////////////////////////////////
 void CGradientProgressCtrl::OnPaint()
 {
     CPaintDC dc(this); // device context for painting

     // TODO: Add your message handler code here
     CRect rectClient;
     GetClientRect(&rectClient);
     // If the current positionis  invalid then we should fade into the  background
     if (m_nCurrentPosition <= m_nLower || m_nCurrentPosition > m_nUpper)
     {
         CRect rect;
         GetClientRect(rect);
         CBrush brush;
         brush.CreateSolidBrush(COLORREF(RGB(0, 0, 0)));// ::GetSysColor(COLOR_3DFACE));
         dc.FillRect(&rect, &brush);
         VERIFY(brush.DeleteObject());
         return;
     }

     // The actions to take depend on whether or not we are a vertical control
     DWORD dwStyles = GetStyle();
     BOOL bVertical = (BOOL)(dwStyles & PBS_VERTICAL);


     // Figure out what part should be visible so we can stop the gradient when needed
     float maxWidth;
     if (bVertical)
         maxWidth = ((float)m_nCurrentPosition/(float)m_nUpper * (float)rectClient.bottom);
     else
         maxWidth = ((float)m_nCurrentPosition/(float)m_nUpper * (float)rectClient.right);


     // Draw the gradient
         DrawGradient(&dc, rectClient, (int)maxWidth, bVertical);

     // Show percent indicator if needed
     if (m_bShowPercent)
     {
         CString strPercent;
         float fp = 100.0f;
         fp *= (float)(m_nCurrentPosition-m_nLower);
         fp /= (float)(m_nUpper-m_nLower);
         strPercent.Format(_T("%3.0f %%"), fp);

         dc.SetTextColor(m_clrText);
         dc.SetBkMode(TRANSPARENT);
         dc.DrawText(strPercent, &rectClient, DT_VCENTER |  DT_CENTER | DT_SINGLELINE);
     }

     // Do not call CProgressCtrl::OnPaint() for painting messages
 }


 /////////////////////////////////////////////////////////////////////////////
 /*
     SetRange

     Overridden base class member to remember where the indicator thinks
     it is and the boundary range of the control.

     Params
         nLower      lower bound
         nUpper      uppoer bound

 */
 /////////////////////////////////////////////////////////////////////////////
 void CGradientProgressCtrl:: SetRange(int nLower, int nUpper)
 {
     m_nLower = nLower;
     m_nUpper = nUpper;
     m_nCurrentPosition = nLower;
     CProgressCtrl::SetRange(nLower, nUpper);
 }

 /////////////////////////////////////////////////////////////////////////////
 /*
     SetRange32

     Overridden base class member to remember where the indicator thinks
     it is and the boundary range of the control.

     Params
         nLower      lower bound
         nUpper      uppoer bound

 */
 /////////////////////////////////////////////////////////////////////////////
 void CGradientProgressCtrl:: SetRange32( int nLower, int nUpper )
 {
     m_nLower = nLower;
     m_nUpper = nUpper;
     m_nCurrentPosition = nLower;
     CProgressCtrl::SetRange(nLower, nUpper);
 }


 /////////////////////////////////////////////////////////////////////////////
 /*
     SetPos

     Overridden base class member to retain where the current progress indicator
     is located.

     Params
         nPos        Current position in range

 */
 /////////////////////////////////////////////////////////////////////////////
 int CGradientProgressCtrl:: SetPos(int nPos)
 {
     m_nCurrentPosition = nPos;
     return (CProgressCtrl::SetPos(nPos));
 }

 /////////////////////////////////////////////////////////////////////////////
 /*
     SetStep

     Overridden base class member to retain the step interval used when
     filling the progress control

     Params
         nStep       step interval for filling progress control

 */
 /////////////////////////////////////////////////////////////////////////////
 int CGradientProgressCtrl:: SetStep(int nStep)
 {
     m_nStep = nStep;
     return (CProgressCtrl::SetStep(nStep));
 }

 /////////////////////////////////////////////////////////////////////////////
 /*
     StepIt

     Overridden base class member to increment the control according to the
     current position and the step interval

     Params
         nStep       step interval for filling progress control

 */
 /////////////////////////////////////////////////////////////////////////////
 int CGradientProgressCtrl:: StepIt(void)
 {
     m_nCurrentPosition += m_nStep;
     return (CProgressCtrl::StepIt());
 }


 /////////////////////////////////////////////////////////////////////////////
 /*
     DrawGradient

     Called from OnPaint, it does most of the work of filling in the client
     rectangle with the appropriate colors.  The normal routine would fill
     the entire client rectangle, but we truncate the drawing to reflect
     the current position in the progress control

     Params
         pDC         pointer to CPaintDC for rendering
         rectClient  client rectangle where we should draw
         nMaxWidth   where we should stop drawing the gradient
 */
 /////////////////////////////////////////////////////////////////////////////
 void CGradientProgressCtrl::DrawGradient(CPaintDC *pDC, const RECT &rectClient, const int &nMaxWidth, const BOOL &bVertical)
 {
     RECT rectFill;             // Rectangle for filling band
     float fStep;              // How wide is each band?
     CBrush brush;           // Brush to fill in the bar


     CMYMemDC memDC(pDC);

     // First find out the largest color distance between the start and end colors.  This distance
     // will determine how many steps we use to carve up the client region and the size of each
     // gradient rect.
     int r, g, b;                    // First distance, then starting value
     float rStep, gStep, bStep;      // Step size for each color

     BOOL  bSameColor = FALSE;       // Handle case if start color == end color

     // Get the color differences
     r = (GetRValue(m_clrEnd) - GetRValue(m_clrStart));
     g = (GetGValue(m_clrEnd) - GetGValue(m_clrStart));
     b =  (GetBValue(m_clrEnd) - GetBValue(m_clrStart));

     // Check to see if colors are same
     if((r == 0) && (g == 0) && (b == 0))
     {
         bSameColor = TRUE;
         //Added the three lines below to fix the drawing
         //problem which used to occur when both the start
         //and end colors are same.
         r = GetRValue(m_clrStart);
         g = GetGValue(m_clrStart);
         b = GetBValue(m_clrStart);
     }

     int nSteps;
     //Select max. possible value for nSteps if the colors are equal
     if(bSameColor && m_clrStart == 0)
         nSteps = 255;
     else    // Make the number of steps equal to the greatest distance
         nSteps = max(abs(r), max(abs(g), abs(b)));

     // Determine how large each band should be in order to cover the
     // client with nSteps bands (one for every color intensity level)
     if (bVertical)
         fStep = (float)rectClient.bottom / (float)nSteps;
     else
         fStep = (float)rectClient.right / (float)nSteps;

     // Calculate the step size for each color
     rStep = r/(float)nSteps;
     gStep = g/(float)nSteps;
     bStep = b/(float)nSteps;//这三个变量都设置为0就不会出现渐变颜色

     // Reset the colors to the starting position
     r = GetRValue(m_clrStart);
     g = GetGValue(m_clrStart);
     b = GetBValue(m_clrStart);

     // Start filling bands
     for (int iOnBand = 0; iOnBand < nSteps; iOnBand++)
     {
         // Fill the vertical control
         if (bVertical)
         {
             ::SetRect(&rectFill,
                         0,                          // Upper left X
                         (int)(iOnBand * fStep),     // Upper left Y
                         rectClient.right+1,     // Lower right X
                         (int)((iOnBand+1) * fStep));// Lower right Y

             // CDC::FillSolidRect is faster, but it does not handle 8-bit color depth
             VERIFY(brush.CreateSolidBrush(RGB(r+rStep*iOnBand, g + gStep*iOnBand, b + bStep *iOnBand)));
             memDC.FillRect(&rectFill,&brush);
             VERIFY(brush.DeleteObject());


             // If we are past the maximum for the current position we need to get out of the loop.
             // Before we leave, we repaint the remainder of the client area with the background color.
             if (rectFill.bottom > nMaxWidth)
             {
                 ::SetRect(&rectFill, 0, rectFill.bottom, rectClient.right, rectClient.bottom);
                 VERIFY(brush.CreateSolidBrush(m_clrBkGround));
                 memDC.FillRect(&rectFill, &brush);
                 VERIFY(brush.DeleteObject());
                 return;
             }
         }

         else // Fill the horizontal control
         {
             ::SetRect(&rectFill,
                         (int)(iOnBand * fStep),     // Upper left X
                          0,                         // Upper left Y
                         (int)((iOnBand+1) * fStep), // Lower right X
                         rectClient.bottom+1);       // Lower right Y

             // CDC::FillSolidRect is faster, but it does not handle 8-bit color depth
             VERIFY(brush.CreateSolidBrush(RGB(r+rStep*iOnBand, g + gStep*iOnBand, b + bStep *iOnBand)));
             memDC.FillRect(&rectFill,&brush);
             VERIFY(brush.DeleteObject());


             // If we are past the maximum for the current position we need to get out of the loop.
             // Before we leave, we repaint the remainder of the client area with the background color.
             if (rectFill.right > nMaxWidth)
             {
                 ::SetRect(&rectFill, rectFill.right, 0, rectClient.right, rectClient.bottom);
                 VERIFY(brush.CreateSolidBrush(m_clrBkGround));
                 memDC.FillRect(&rectFill, &brush);
                 VERIFY(brush.DeleteObject());
                 return;
             }
         }

     }
 }



 /////////////////////////////////////////////////////////////////////////////
 /*
     OnEraseBkgnd

     Overridden CWnd function so that all drawing is done in the OnPaint call.
     We return TRUE so that CWnd doesn't try to erase our background.

     Params
         pDC         pointer to CDC for rendering
 */
 /////////////////////////////////////////////////////////////////////////////
 BOOL CGradientProgressCtrl::OnEraseBkgnd(CDC* pDC)
 {
     // TODO: Add your message handler code here and/or call default
     return TRUE;
 }

6、其中MemDC.h

 #if !defined(AFX_MEMDC_H__CA1D3541_7235_11D1_ABBA_00A0243D1382__INCLUDED_)
 #define AFX_MEMDC_H__CA1D3541_7235_11D1_ABBA_00A0243D1382__INCLUDED_

 #if _MSC_VER >= 1000
 #pragma once
 #endif // _MSC_VER >= 1000
 // MemDC.h : header file
 //

 //////////////////////////////////////////////////
 // CMemDC - memory DC
 //
 // Author: Keith Rule
 // Email:  [email protected]
 // Copyright 1996-1997, Keith Rule
 //
 // You may freely use or modify this code provided this
 // Copyright is included in all derived versions.
 //
 // History - 10/3/97 Fixed scrolling bug.
 //                   Added print support.
 //           25 feb 98 - fixed minor assertion bug
 //
 // This class implements a memory Device Context

 class CMYMemDC : public CDC
 {
 public:

     // constructor sets up the memory DC
     CMYMemDC(CDC* pDC) : CDC()
     {
         ASSERT(pDC != NULL);

         m_pDC = pDC;
         m_pOldBitmap = NULL;
         m_bMemDC = !pDC->IsPrinting();

         if (m_bMemDC)   // Create a Memory DC
         {
             pDC->GetClipBox(&m_rect);
             CreateCompatibleDC(pDC);
             m_bitmap.CreateCompatibleBitmap(pDC, m_rect.Width(), m_rect.Height());
             m_pOldBitmap = SelectObject(&m_bitmap);
             SetWindowOrg(m_rect.left, m_rect.top);
         }
         else        // Make a copy of the relevent parts of the current DC for printing
         {
             m_bPrinting = pDC->m_bPrinting;
             m_hDC       = pDC->m_hDC;
             m_hAttribDC = pDC->m_hAttribDC;
         }
     }

     // Destructor copies the contents of the mem DC to the original DC
     ~CMYMemDC()
     {
         if (m_bMemDC) {
             // Copy the offscreen bitmap onto the screen.
             m_pDC->BitBlt(m_rect.left, m_rect.top, m_rect.Width(), m_rect.Height(),
                 this, m_rect.left, m_rect.top, SRCCOPY);

             //Swap back the original bitmap.
             SelectObject(m_pOldBitmap);
         } else {
             // All we need to do is replace the DC with an illegal value,
             // this keeps us from accidently deleting the handles associated with
             // the CDC that was passed to the constructor.
             m_hDC = m_hAttribDC = NULL;
         }
     }

     // Allow usage as a pointer
     CMYMemDC* operator->() {return this;}

     // Allow usage as a pointer
     operator CMYMemDC*() {return this;}

 private:
     CBitmap  m_bitmap;      // Offscreen bitmap
     CBitmap* m_pOldBitmap;  // bitmap originally found in CMYMemDC
     CDC*     m_pDC;         // Saves CDC passed in constructor
     CRect    m_rect;        // Rectangle of drawing area.
     BOOL     m_bMemDC;      // TRUE if CDC really is a Memory DC.
 };

 /////////////////////////////////////////////////////////////////////////////

 //{{AFX_INSERT_LOCATION}}
 // Microsoft Developer Studio will insert additional declarations immediately before the previous line.

 #endif // !defined(AFX_MEMDC_H__CA1D3541_7235_11D1_ABBA_00A0243D1382__INCLUDED_)