MFC自制进度条

来源：互联网发布：车解码器软件编辑：程序博客网时间：2024/05/01 14:21

改变进度条的颜色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

[cpp] view plain copy
#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

[cpp] view plain copy
// 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

[cpp] view plain copy
#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:  keithr@europa.com  
// 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_)  

阅读全文

0 0