一、前言

技術沒有先進與落后，只有合適與不合適，

本篇的自定義控制元件是：進度條（ProgressBar），

進度條的實作方式多種多樣，主流的方式有：使用多張圖片去實作、使用1個或2個Panel放到UserControl上去實作、多載系統進度條去實作等等，

本次所實作的進度條仍是使用GDI+去實作，當然，如果只是實作最基本的扁平化的進度條，那完全不需要再寫本篇文章，因為直接小改下第一篇的LTrackBar就行了，

既然寫這篇文章，就是實作不一樣的、比較好玩和好看的進度條，如環形進度條、餅形進度條等等，

本篇使用的知識都是前幾篇中已經講過的，并沒有新的技術，但是卻附加了一些想像力，一些不拘一格、稍稍突破常規的想像力，

相信看完的你，一定會有所識訓，

本文地址：https://www.cnblogs.com/lesliexin/p/13575517.html

二、前期分析

（一）為什么需要自定義進度條？

系統自帶的滾動條樣式太過單調，同時不夠“扁平化”，所以便去實作自己的滾動條，

（二）實作目標

1，支持三種樣式

（1）橫條（Bar）

（2）圓餅（Pie）

（3）圓弧（Arc）

2，支持顯示和隱藏百分比

（1）橫條（Bar）

（2）圓餅（Pie）

（3）圓弧（Arc）

3，支持多種進度形狀

（1）連續

（2）分段塊

（3）兩段式：先分段塊再連續

（4）螺旋

（注：只有“橫條”樣式時才支持螺旋形狀）

4，支持Marquee樣式

當進度無法確定時，便需要使用Marquee樣式，同系統進度條的“Marquee”樣式類似，

不過支持更多的Marquee樣式，

（1）左右擺動

（2）回圈穿過

（3）往復（連續）

（4）劃過（連續）

（5）往復（分段塊）

（6）劃過（分段塊）

（7）螺旋

5，支持調整進度條各元素尺寸和顏色

（1）設定邊框厚度和顏色

（2）設定背景大小和顏色

（3）設定進度繪制位置和顏色

（4）設定進度文本顏色

（5）設定弧線厚度（僅樣式為“圓弧（Arc）”時有效）

（6）設定“分段塊”厚度（僅進度條形狀為“分段塊”時有效）

三、進度條拆解

看了上面的實作目標，是不是感覺眼花繚亂、無從下手？

下面我就對進度條進行拆分講解，一步一步來看上面的效果是怎么實作的，

（一）組成元素

進度條由三個部分組成，分別是：進度、邊框、背景，

下面是各種樣式下，三個組成部分的拆分，

1，橫條（Bar）

2，圓餅（Pie）

3，圓弧（Arc）

（二）元素屬性

進度條的三個組成元素，都有著各自相關的屬性，

（注：因為“顏色”屬性是必備的，所以不再贅述，）

1，邊框

其相關屬性為：邊框的厚度，

當“厚度”為0時，看起來進度條就沒有邊框；

當“厚度”超過控制元件高度的二分之一時，整個進度條就變成了邊框的顏色，

（注：因為是先繪制“背景”，再繪制“邊框”，所以是“整個進度條變成邊框的顏色”）

A，對于 “橫條（Bar）”，其邊框厚度如下圖所示：

B，對于“圓餅（Pie）”、“圓弧（Arc）”，其邊框厚度如下圖所示：

2，背景

其相關屬性為：背景的大小

背景的大小就是背景繪制的范圍，這里用一個自造詞“收縮寬度”來進行描述，

當“收縮寬度”為0時，背景大小＝控制元件本身大小；

當“收縮寬度”為x時，背景寬度＝控制元件寬度－2*x，背景高度＝控制元件高度－2*x；

當“收縮寬度”超過控制元件高度的二分之一時，背景高度＝控制元件高度－2*（控制元件高度/2）＝0，此時進度條將沒有了背景，

A，對于 “橫條（Bar）”，其收縮寬度如下圖所示：

B，對于“圓餅（Pie）”、“圓弧（Arc）”，其收縮寬度如下圖所示：

3，進度

其相關屬性有：進度繪制范圍、進度樣式

A，進度繪制范圍

顧名思義，就是進度可繪制的范圍，這里用“繪制邊框距離”來進行描述，

當“繪制邊框距離”為0時，進度的繪制范圍＝控制元件本身大小；

當“繪制邊框距離”為x時，進度的繪制起點：（x,x），繪制終點：（控制元件寬度－x，控制元件高度－x），所以繪制范圍＝（控制元件寬度－2*x，控制元件高度－2*x）；

當“繪制邊框距離”超過控制元件高度的二分之一時，進度的繪制高度將為0，也代表著沒有進度，

A，對于 “橫條（Bar）”，其繪制邊框距離如下圖所示：

B，對于“圓餅（Pie）”，其繪制邊框距離如下圖所示：

C，對于“圓弧（Arc）”，其繪制邊框距離如下圖所示：

B，進度樣式

進度樣式就是前節實作目標中各種進度的樣式，有連續的、有分段塊的、有螺旋的等等，

這此樣式大部分一看都知道如何實作的，

比如“連續”，在“橫條（Bar）”樣式中，就是填充一個矩形；在“圓餅（Pie）”中，就是填充一個扇形；在“圓弧（Arc）”中，就是畫一段弧線，

比如“分段塊”，在“橫條（Bar）”樣式中，就是等間隔填充多個矩形；在“圓餅（Pie）”中，就是等間隔填充一個扇形；在“圓弧（Arc）”中，就是等間隔畫一段弧線，

在這里，我將詳細講解一個特殊的形狀：“螺旋”，因為“螺旋”樣式除了不太能直觀想像出來之外，還有不少細節需要處理，

因為只有“橫條（Bar）”樣式進度條有“螺旋”樣式，所以接下來的講解都是以“橫條（Bar）”為基礎進行講解的，

同時，為了避免干擾，前面的兩個屬性“邊框”和“背景”都將保持默認值，即：沒有邊框，背景大小＝控制元件大小，“進度繪制范圍”也是默認值，即繪制范圍＝控制元件大小，

（1）“螺旋”樣式實作講解

A，進度明確時

即進度是已知且確定的，比如5%，33%等等，其外觀樣式如下：

其示意圖如下：

其中藍色的平行四邊形就是“螺旋”，其本身是一個背景透明、上有多個藍色平行四邊形的圖片，

進度的增減實質上就是這個圖片在控制元件上的左右移動，

那么，這個圖片要和控制元件大小相等，特別是寬度相等，但是在使用GDI+去生成這個圖片時，卻不能讓圖片寬度與控制元件寬度相等，

我們在往圖片繪制平行四邊行時，是從右往左依次繪制的，之所以從右側開始繪制，是為了保證進度條的右側樣式是固定的，固定在一個比較美觀的狀態，因為在進度變化時，即圖片左右移動時，我們目光的焦點是在右側，所以一個固定的右側樣式就比較重要，否則當控制元件寬度變化時，右側的樣式就隨之變化，

當圖片寬度與控制元件寬度相等時，會出現下面這種情況，即進度條的最右側下方有空白，如下圖所示：

（其中上面圖形是實際繪制圖片，下面圖形是將圖片截取，和進度條寬度相等后樣式）

所以我們令圖片的寬度＝控制元件的寬度+1個平行四邊行的寬度，在繪制完圖片后，我們從中截取出一個和控制元件寬度一樣的圖片，這樣，整體的樣式就比較好看，如下圖所示：
（其中上面圖形是實際繪制圖片，下面圖形是將圖片截取，和進度條寬度相等后樣式）

綜上，就是按照下圖所示的5步依次實作：

B，進度未知時

即進度是不確定的，就像系統進度條的Marquee樣式那樣，其外觀樣式如下：

同上，上方仍是一個背景透明、上有多個藍色平行四邊形的圖片，上圖的效果就是這個圖片在不段的回圈移動，

具體示意如下，圖片不斷向右側移動，當右側超過一個平等四邊行時，圖片恢復原位，然后不斷回圈，

通過上方的示意圖，我們發現一個特點，就是圖片的寬度不再等于（控制元件的寬度+1個平行四邊行的寬度），而是等于（控制元件的寬度+2個平行四邊行的寬度），原因如下：

在畫示意圖時，為了方便直觀查看，平行四邊形正好是兩個相對的直角三角行，而實際繪制時，很少會有這種樣式，大多都是兩個相對的鈍角三角行組成的平等四邊形的樣子，如下圖所示：

這種情況下，如果圖片的寬度＝控制元件的寬度+1個平行四邊行的寬度，那么在移動到最右側時和復位時都會出現額外的空白，如下圖所示：

所以，才會令：圖片的寬度＝控制元件的寬度+2個平行四邊行的寬度，

（三）其它屬性

除了前面的與進度條元素直接相關的屬性外，還有一些其他屬性，這些屬性都是在某種特定樣式下才起有作用，

1，弧線寬度

在“圓弧（Arc）”樣式的進度條中，“進度”就是一段圓弧，所以在其他屬性外，還要有“弧線本身寬度”這樣一個屬性，

在默認情況下，弧線寬度＝控制元件寬度/10，因為當進度達到100%時，弧線就變成了圓環，此時看起來有弧線的地方占控制元件寬度的五分之一，是一個比較常規的寬度，

通過呼叫弧線寬度，可以實作一些特殊的效果，

2，分段塊寬度

在進度樣式為“分段塊”時，為了支持不同的分段寬度，所以要有本屬性，

為了繪制出更好的效果，“分段塊寬度”不僅僅是有顏色的那部分的寬度，而是為：有顏色部分的寬度+兩個顏色間隔，

經過除錯，發現當（顏色：間隔＝2：1）時，外觀比較好看和自然，

所以，一個“分段塊寬度”＝2/3有顏色寬度+1/3無顏色寬度，

因為“橫條（Bar）”、“圓餅（Pie）”、“圓弧（Arc）”都支持“分段塊”，所以在“橫條（Bar）”中，“分段塊寬度”指的就是寬度；而在“圓餅（Pie）”、“圓弧（Arc）”中，“分段塊寬度”指的是角度，

四、開始實作

（一）前期準備，

此處僅作提綱，具體操作見前篇，

新建類：LProgressBar.cs

添加繼承：Control（需要添加參考：System.Windows.Forms.dll）

修改可訪問性為：public

（二）添加屬性

1，進度值

進度值指的是當前的進度，這里將進度范圍固定為：0~100，

這樣的好處是方便計算和繪制，使用時也更加直觀，

2，邊框厚度

詳細見前節中的講解，

（注：我是先寫完的代碼，然后再寫文章，有時在寫文章時會發現屬性的命名不太正規，比如“邊框厚度”這個屬性，用“BorderSize”更好，但是我在寫代碼時我想的是“環繞一圈的線”，所以就成了下面圖中的“SurroundLineSize”，但是在寫文章時發現不好描述，就改成了“邊框厚度”，不過再去修改代碼意義不大，重要的是技術思想本身，下同，）

3，邊框顏色

顧名思義，就是邊框的顏色，

4，背景收縮寬度

詳細見前節中的講解，

5，背景顏色

6，進度繪制范圍邊緣

詳細見前節中的講解，

7，弧線厚度

詳細見前節中的講解，

8，進度顏色

進度顏色是進度本身的顏色，

9，分段塊寬度

詳細見前節中的講解，

10，進度樣式

進度樣式描述的是進度本身的外觀，如連續、分段塊、螺旋等等，

進度樣式是一個列舉，明細如下：

11，進度條型別

進度條型別指的是進度條的樣式外觀，如橫條、圓餅、圓弧等，

進度條型別是一個列舉，明細如下：

12，進度條模式

進度模式指的進度是明確的還是不明確的，

進度明確，比如當前進度是1%、45%等等，

進度不明確，比如加載某個檔案時一直在加載，但不知道加載了多少，也就是系統進度條的Marquee樣式，

進度條模式是一個列舉，明細如下：

13，Marquee回圈一遍時間

Marquee樣式時影片的快慢，

14，Marquees樣式

Marquee樣式影片，

該屬性是一個列舉，明細如下：

15，Marquee型別

Marquee樣式同樣是影片，所以支持勻速和緩入緩出效果，

該屬性是一個列舉，明細如下：

16，進度文本型別

可以設定進度條是否顯示文本，以及是否顯示百分比，

該屬性是一個列舉，明細如下：

17，進度文本顏色

18，建構式

這里的建構式中，除了使用了之前文章中固定的“雙緩沖”外，還額外設定了幾個屬性，這幾個屬性是為了讓控制元件支持透明，所以下面才可以令背景色和前景色為透明色，

這種情況下，整個控制元件就相當于一個完全透明的畫布，可以任由我們繪制，

（三）重寫方法

對于本進度條而言，只是用來指示進度資訊，所以不需要事件，只需要重寫最基本的OnPaint方法就行了，

不過，由于在OnPaint中要繪制的樣式以及型別太多，所以代碼量較大，但是代碼難度不大，我會先將OnPaint代碼全部放上，然后著重講一下實作的原理，

而Marquee樣式本質上就是一個影片效果，回圈的繪制一些圖形或改變圖形的大小位置，所以我們使用一個定時器來進行觸發，定時的改變圖形或圖形大小位置，

protected override void OnPaint(PaintEventArgs e)
{
    base.OnPaint(e);
    e.Graphics.SmoothingMode = SmoothingMode.HighQuality;

    //進度實際繪制寬度、高度
    float fRealWidth = Width - _DrawMargin * 2;
    float fRealHeight = Height - _DrawMargin * 2;

    float fRealLeftTop = _DrawMargin - 0.5f;
    if (fRealLeftTop < 0) fRealLeftTop = 0;

    //上下左右各留0.5個像素，防止切邊
    bool bDrawSurroundLine = _SurroundLineSize > 0 ? true : false;
    bool bDrawInner = _ShrinkSize * 2 < Math.Min(Width, Height) ? true : false;
    float fSurroundLineSizeF = Convert.ToSingle(_SurroundLineSize);
    RectangleF rectInner = new RectangleF(_ShrinkSize, _ShrinkSize, (Width - 1) - _ShrinkSize * 2, (Height - 1) - _ShrinkSize * 2);
    RectangleF retcSurrondLine = new RectangleF(fSurroundLineSizeF / 2, fSurroundLineSizeF / 2, (Width - 1) - fSurroundLineSizeF, (Height - 1) - fSurroundLineSizeF);
    //弧線寬度為總寬度的十分之一，因為是圓弧，所以最終看起來是五分之一
    float fSurroundArcSize = _ArcSize > 0 ? _ArcSize : Width / 10;
    RectangleF retcSurrondArc = new RectangleF(fSurroundArcSize / 2 + fRealLeftTop, fSurroundArcSize / 2 + fRealLeftTop, (fRealWidth - 1) - fSurroundArcSize, (fRealHeight - 1) - fSurroundArcSize);

    SolidBrush sbInner = new SolidBrush(_ShrinkColor);
    SolidBrush sbFore = new SolidBrush(L_SliderColor);
    SolidBrush sbText = new SolidBrush(_TextColor);
    Pen penSurrondLine = new Pen(_SurroundLineColor, fSurroundLineSizeF);
    Pen penSurroundArc = new Pen(L_SliderColor, fSurroundArcSize);

    //滑塊寬度為總寬度的五分之一
    float fSlider = Convert.ToSingle(fRealWidth) / 5;
    if (_ProgressType != ProgressType.Bar)
    {
        //360/5
        fSlider = 72;
    }

    float fRange = 0;
    if (L_MarqueeStyle == MarqueeStyle.Swing) fRange = fRealWidth - fSlider;
    else if (L_MarqueeStyle == MarqueeStyle.Cross) fRange = fRealWidth + fSlider;
    else fRange = fRealWidth;

    float fBlockSize = _BlockSize;
    if (fBlockSize < 3) fBlockSize = 3.0f;
    if (_ProgressType == ProgressType.Bar)
    {
        if (fBlockSize > fRealWidth) fBlockSize = fRealWidth;
    }
    else
    {
        if (fBlockSize > 360.0f) fBlockSize = 360.0f;
    }

    #region Bar
    if (_ProgressType == ProgressType.Bar)
    {
        //畫內部
        if (bDrawInner)
        {
            e.Graphics.FillRectangle(sbInner, rectInner);
        }

        //畫線
        if (bDrawSurroundLine)
        {
            e.Graphics.DrawRectangle(penSurrondLine, retcSurrondLine.X, retcSurrondLine.Y, retcSurrondLine.Width, retcSurrondLine.Height);
        }

        if (_ProgressMode == ProgressMode.Known)
        {

            #region Continuous
            if (_ProgressStyle == ProgressStyle.Continuous)
            {
                //畫進度
                float fProgress = Convert.ToSingle(_Value) * fRealWidth / 100;
                e.Graphics.FillRectangle(sbFore, _DrawMargin - 0.5f, fRealLeftTop, fProgress, fRealHeight);
            }
            #endregion
            #region Blocks
            else if (_ProgressStyle == ProgressStyle.Blocks)
            {
                //獲取方塊數
                float fBlocks = Convert.ToSingle(fRealWidth) / fBlockSize;
                int iShowBlocks = Convert.ToInt32(fBlocks * _Value / 100);
                //畫進度
                for (int i = 0; i < iShowBlocks; i++)
                {
                    e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                }
            }
            #endregion
            #region Helical
            else if (_ProgressStyle == ProgressStyle.Helical)
            {
                float fProgress = Convert.ToSingle(_Value) * fRealWidth / 100;

                //這里為了獲得更好看的效果，要多加1個Block
                float fBmpWidth = fRealWidth + fBlockSize;
                float fBlocks = fBmpWidth / fBlockSize;

                Bitmap bmp = new Bitmap(Convert.ToInt32(fBmpWidth), Convert.ToInt32(fRealHeight));
                GraphicsPath gp = new GraphicsPath();
                for (int i = 0; i < fBlocks; i++)
                {
                    gp.AddPolygon(new PointF[]
                    {
                    //top-right
                    new PointF(fBmpWidth - i * fBlockSize ,0),
                    //bottom-right
                    new PointF(fBmpWidth - i * fBlockSize - fBlockSize,fRealHeight),
                    //bottom-left
                    new PointF(fBmpWidth - i * fBlockSize - fBlockSize*5/3,fRealHeight),
                    //top-left
                    new PointF(fBmpWidth - i * fBlockSize - fBlockSize*2/3,0),

                    });
                    gp.CloseFigure();
                }
                gp.CloseAllFigures();

                Graphics g = Graphics.FromImage(bmp);
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.FillPath(sbFore, gp);
                gp.Dispose();
                g.Dispose();
                e.Graphics.DrawImage(bmp, new RectangleF(fRealLeftTop, fRealLeftTop, fProgress, fRealHeight), new RectangleF(bmp.Width - fProgress - fBlockSize, 0, fProgress, bmp.Height), GraphicsUnit.Pixel);
                bmp.Dispose();
            }
            #endregion
            #region BlocksToContinuous
            else if (_ProgressStyle == ProgressStyle.BlocksToContinuous)
            {
                float fBlocks = Convert.ToSingle(fRealWidth) / fBlockSize;
                if (_Value <= 50)
                {
                    int iShowBlocks = Convert.ToInt32(fBlocks * _Value * 2 / 100);
                    //畫進度
                    for (int i = 0; i < iShowBlocks; i++)
                    {
                        e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                    }
                }
                else
                {
                    int iShowBlocks = Convert.ToInt32(fBlocks * ((_Value - 50f) * 2 / 100));
                    for (int i = iShowBlocks; i < Convert.ToInt32(fBlocks); i++)
                    {
                        e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                    }

                    //畫進度
                    float fProgress = Convert.ToSingle((_Value - 50) * 2) * fRealWidth / 100;
                    e.Graphics.FillRectangle(sbFore, fRealLeftTop, fRealLeftTop, fProgress, fRealHeight);

                }
            }
            #endregion
        }
        else
        {
            #region Marquee
            if (_ProgressStyle == ProgressStyle.Marquee)
            {
                if (L_MarqueeType == MarqueeType.SlowInSlowOut)
                {
                    if (L_MarqueeStyle == MarqueeStyle.Swing)
                    {
                        double fz = fRange * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                        e.Graphics.FillRectangle(sbFore, Convert.ToSingle(fz) + fRealLeftTop, fRealLeftTop, fSlider, fRealHeight);
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Cross)
                    {
                        double fz = fRange * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2 - fSlider;
                        float fz2 = Convert.ToSingle(fz) + fRealLeftTop;
                        float fW = fSlider;
                        if (fz2 < fRealLeftTop)
                        {
                            fW = fz2 + fSlider - (fRealLeftTop);
                            fz2 = fRealLeftTop;
                        }
                        if (fz2 + fSlider > Width - (fRealLeftTop))
                        {
                            fW = Width - (fRealLeftTop) - fz2;
                        }
                        e.Graphics.FillRectangle(sbFore, fz2, fRealLeftTop, fW, fRealHeight);
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
                    {
                        double fz = fRange * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                        e.Graphics.FillRectangle(sbFore, fRealLeftTop, fRealLeftTop, Convert.ToSingle(fz), fRealHeight);
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                    {
                        double fz = fRange * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                        if (!bAcrossed)
                        {
                            e.Graphics.FillRectangle(sbFore, fRealLeftTop, fRealLeftTop, Convert.ToSingle(fz), fRealHeight);
                        }
                        else
                        {
                            e.Graphics.FillRectangle(sbFore, Convert.ToSingle(fz) + fRealLeftTop, fRealLeftTop, fRealWidth - Convert.ToSingle(fz), fRealHeight);
                        }
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Blocks)
                    {
                        double fz = fRange * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                        float fBlocks = Convert.ToSingle(fRealWidth) / fBlockSize;
                        float fNowBlocks = Convert.ToSingle(fz) / fBlockSize;

                        for (int i = 0; i < fNowBlocks; i++)
                        {
                            e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                        }
                    }
                    else
                    {
                        double fz = fRange * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                        float fBlocks = Convert.ToSingle(fRealWidth) / fBlockSize;
                        float fNowBlocks = Convert.ToSingle(fz) / fBlockSize;
                        if (!bAcrossed)
                        {
                            for (int i = 0; i < fNowBlocks; i++)
                            {
                                e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                            }
                        }
                        else
                        {
                            for (int i = Convert.ToInt32(fNowBlocks); i < fBlocks; i++)
                            {
                                e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                            }
                        }
                    }
                }
                else
                {
                    if (L_MarqueeStyle == MarqueeStyle.Swing)
                    {
                        e.Graphics.FillRectangle(sbFore, Convert.ToSingle(dMarqueeValue) + fRealLeftTop, fRealLeftTop, fSlider, fRealHeight);
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Cross)
                    {
                        float fz2 = Convert.ToSingle(dMarqueeValue) + fRealLeftTop;
                        float fW = fSlider;
                        if (fz2 < fRealLeftTop)
                        {
                            fW = fz2 + fSlider - (fRealLeftTop);
                            fz2 = fRealLeftTop;
                        }
                        if (fz2 + fSlider > Width - (fRealLeftTop))
                        {
                            fW = Width - (fRealLeftTop) - fz2;
                        }
                        e.Graphics.FillRectangle(sbFore, fz2, fRealLeftTop, fW, fRealHeight);
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
                    {
                        e.Graphics.FillRectangle(sbFore, fRealLeftTop, fRealLeftTop, Convert.ToSingle(dMarqueeValue), fRealHeight);
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                    {
                        if (!bAcrossed)
                        {
                            e.Graphics.FillRectangle(sbFore, fRealLeftTop, fRealLeftTop, Convert.ToSingle(dMarqueeValue), fRealHeight);
                        }
                        else
                        {
                            e.Graphics.FillRectangle(sbFore, Convert.ToSingle(dMarqueeValue) + fRealLeftTop, fRealLeftTop, fRealWidth - Convert.ToSingle(dMarqueeValue), fRealHeight);
                        }
                    }
                    else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Blocks)
                    {
                        float fBlocks = Convert.ToSingle(fRealWidth) / fBlockSize;
                        float fNowBlocks = Convert.ToSingle(dMarqueeValue) / fBlockSize;

                        for (int i = 0; i < fNowBlocks; i++)
                        {
                            e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                        }
                    }
                    else
                    {
                        float fBlocks = Convert.ToSingle(fRealWidth) / fBlockSize;
                        float fNowBlocks = Convert.ToSingle(dMarqueeValue) / fBlockSize;
                        if (!bAcrossed)
                        {
                            for (int i = 0; i < fNowBlocks; i++)
                            {
                                e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                            }
                        }
                        else
                        {
                            for (int i = Convert.ToInt32(fNowBlocks); i < fBlocks; i++)
                            {
                                e.Graphics.FillRectangle(sbFore, i * fBlockSize + fRealLeftTop, fRealLeftTop, fBlockSize * 2 / 3, fRealHeight);
                            }
                        }
                    }
                }
            }
            #endregion
            #region Helical
            else if (_ProgressStyle == ProgressStyle.Helical)
            {                        
                //這里為了獲得更好看的效果，要多加2個Block
                float fBmpWidth = fRealWidth + fBlockSize*2;
                float fBlocks = fBmpWidth / fBlockSize;

                Bitmap bmp = new Bitmap(Convert.ToInt32(fBmpWidth), Convert.ToInt32(fRealHeight));
                GraphicsPath gp = new GraphicsPath();
                for (int i = 0; i < fBlocks; i++)
                {
                    gp.AddPolygon(new PointF[]
                    {
                    //top-right
                    new PointF(fBmpWidth - i * fBlockSize ,0),
                    //bottom-right
                    new PointF(fBmpWidth - i * fBlockSize - fBlockSize,fRealHeight),
                    //bottom-left
                    new PointF(fBmpWidth - i * fBlockSize - fBlockSize*5/3,fRealHeight),
                    //top-left
                    new PointF(fBmpWidth - i * fBlockSize - fBlockSize*2/3,0),

                    });
                    gp.CloseFigure();
                }
                gp.CloseAllFigures();

                Graphics g = Graphics.FromImage(bmp);
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.FillPath(sbFore, gp);
                gp.Dispose();
                g.Dispose();
                e.Graphics.DrawImage(bmp, new RectangleF(fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight), new RectangleF(Convert.ToSingle(dMarqueeValue) + fBlockSize, 0, fRealWidth, bmp.Height), GraphicsUnit.Pixel);
                bmp.Dispose();
            }
            #endregion
        }
    }
    #endregion
    #region Arc
    else if (_ProgressType == ProgressType.Arc)
    {
        //畫內部
        if (bDrawInner)
        {
            e.Graphics.FillEllipse(sbInner, rectInner);
        }

        //畫線
        if (bDrawSurroundLine)
        {
            e.Graphics.DrawEllipse(penSurrondLine, retcSurrondLine.X, retcSurrondLine.Y, retcSurrondLine.Width, retcSurrondLine.Height);
        }

        #region Continuous
        if (_ProgressStyle == ProgressStyle.Continuous)
        {
            float fProgress = Convert.ToSingle(_Value * 3.6);
            if (fProgress > 0)
            {
                e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270, fProgress);
            }
        }
        #endregion
        #region Blocks
        else if (_ProgressStyle == ProgressStyle.Blocks)
        {
            //獲取方塊數
            float fBlocks = 360.0f / fBlockSize;
            int iShowBlocks = Convert.ToInt32(fBlocks * _Value / 100);
            //畫進度
            for (int i = 0; i < iShowBlocks; i++)
            {
                //對于DrawArc而言，會產生在超過360度而導致重疊，所以需要判斷，同時使用360-1，以防止相接，
                //后續可以再進行優化：如果所分配的不正好是3的倍數，則取一相近值，使其能被3整除，
                e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
            }
        }
        #endregion
        #region BlocksToContinuous
        else if (_ProgressStyle == ProgressStyle.BlocksToContinuous)
        {
            //獲取方塊數
            float fBlocks = 360.0f / fBlockSize;
            if (_Value <= 50)
            {
                int iShowBlocks = Convert.ToInt32(fBlocks * _Value * 2 / 100);
                //畫進度
                for (int i = 0; i < iShowBlocks; i++)
                {
                    //對于DrawArc而言，會產生在超過360度而導致重疊，所以需要判斷，同時使用360-1，以防止相接，
                    //后續可以再進行優化：如果所分配的不正好是3的倍數，則取一相近值，使其能被3整除，
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                }
            }
            else
            {
                int iShowBlocks = Convert.ToInt32(fBlocks * (_Value - 50f) * 2 / 100);
                //畫進度
                for (int i = iShowBlocks; i < Convert.ToInt32(fBlocks); i++)
                {
                    //對于DrawArc而言，會產生在超過360度而導致重疊，所以需要判斷，同時使用360-1，以防止相接，
                    //后續可以再進行優化：如果所分配的不正好是3的倍數，則取一相近值，使其能被3整除，
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                }

                float fProgress = (_Value - 50f) * 2 * 3.6f;
                if (fProgress > 0)
                {
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270, fProgress);
                }
            }
        }
        #endregion
        #region Marquee
        else if (_ProgressStyle == ProgressStyle.Marquee)
        {
            if (L_MarqueeType == MarqueeType.SlowInSlowOut)
            {
                if (L_MarqueeStyle == MarqueeStyle.Cross || L_MarqueeStyle == MarqueeStyle.Swing)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2 + 270 - fSlider / 2;
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, Convert.ToSingle(fz), fSlider);
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    if (!bAcrossed)
                    {
                        e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270, Convert.ToSingle(fz));
                    }
                    else
                    {
                        e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + Convert.ToSingle(fz), Convert.ToSingle(360 - fz));
                    }
                }
                else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270, Convert.ToSingle(fz));
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Blocks)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    float fBlocks = Convert.ToSingle(fz / fBlockSize);
                    float fAllBlocks = 360.0f / fBlockSize;
                    if (!bAcrossed)
                    {
                        for (int i = 0; i < fBlocks; i++)
                        {
                            e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                    else
                    {
                        for (float i = fAllBlocks - 1; i >= fBlocks; i--)
                        {
                            e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                }
                else
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    float fBlocks = Convert.ToSingle(fz / fBlockSize);

                    for (int i = 0; i < fBlocks; i++)
                    {
                        e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                    }

                }

            }
            else
            {
                if (L_MarqueeStyle == MarqueeStyle.Cross || L_MarqueeStyle == MarqueeStyle.Swing)
                {
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, Convert.ToSingle(dMarqueeValue), fSlider);
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                {
                    if (!bAcrossed)
                    {
                        e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270, Convert.ToSingle(dMarqueeValue));
                    }
                    else
                    {
                        e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + Convert.ToSingle(dMarqueeValue), Convert.ToSingle(360 - dMarqueeValue));
                    }
                }
                else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
                {
                    e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270, Convert.ToSingle(dMarqueeValue));
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Blocks)
                {
                    float fBlocks = Convert.ToSingle(dMarqueeValue / fBlockSize);
                    float fAllBlocks = 360.0f / fBlockSize;
                    if (!bAcrossed)
                    {
                        for (int i = 0; i < fBlocks; i++)
                        {
                            e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                    else
                    {
                        for (float i = fAllBlocks - 1; i >= fBlocks; i--)
                        {
                            e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                }
                else
                {
                    float fBlocks = Convert.ToSingle(dMarqueeValue / fBlockSize);
                    for (int i = 0; i < fBlocks; i++)
                    {
                        e.Graphics.DrawArc(penSurroundArc, retcSurrondArc, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                    }
                }
            }

        }
        #endregion
    }
    #endregion
    #region Pie
    else if (_ProgressType == ProgressType.Pie)
    {
        //畫內部
        if (bDrawInner)
        {
            e.Graphics.FillEllipse(sbInner, rectInner);
        }

        //畫線
        if (bDrawSurroundLine)
        {
            e.Graphics.DrawEllipse(penSurrondLine, retcSurrondLine.X, retcSurrondLine.Y, retcSurrondLine.Width, retcSurrondLine.Height);
        }

        #region Continuous
        if (_ProgressStyle == ProgressStyle.Continuous)
        {
            //畫進度
            //360/100;
            float fProgress = Convert.ToSingle(_Value * 3.6);
            if (fProgress > 0)
            {
                //如果不進行fProgress>0的判斷，在設計器調整大小時如果處于其它控制元件上方時會出來例外，導致繪制失敗，雖然仍可以進行編譯和使用，
                e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270, fProgress);
            }
        }
        #endregion
        #region Blocks
        else if (_ProgressStyle == ProgressStyle.Blocks)
        {
            //獲取方塊數
            float fBlocks = 360.0f / fBlockSize;
            int iShowBlocks = Convert.ToInt32(fBlocks * _Value / 100);
            //畫進度
            for (int i = 0; i < iShowBlocks; i++)
            {
                //對于DrawArc而言，會產生在超過360度而導致重疊，所以需要判斷，同時使用360-1，以防止相接，
                //后續可以再進行優化：如果所分配的不正好是3的倍數，則取一相近值，使其能被3整除，
                e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
            }
        }
        #endregion
        #region 
        else if (_ProgressStyle == ProgressStyle.BlocksToContinuous)
        {
            //獲取方塊數
            float fBlocks = 360.0f / fBlockSize;
            if (_Value <= 50)
            {
                int iShowBlocks = Convert.ToInt32(fBlocks * _Value * 2 / 100);
                //畫進度
                for (int i = 0; i < iShowBlocks; i++)
                {
                    //對于DrawArc而言，會產生在超過360度而導致重疊，所以需要判斷，同時使用360-1，以防止相接，
                    //后續可以再進行優化：如果所分配的不正好是3的倍數，則取一相近值，使其能被3整除，
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                }
            }
            else
            {
                int iShowBlocks = Convert.ToInt32(fBlocks * (_Value - 50f) * 2 / 100);
                //畫進度
                for (int i = iShowBlocks; i < Convert.ToInt32(fBlocks); i++)
                {
                    //對于DrawArc而言，會產生在超過360度而導致重疊，所以需要判斷，同時使用360-1，以防止相接，
                    //后續可以再進行優化：如果所分配的不正好是3的倍數，則取一相近值，使其能被3整除，
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                }

                //畫進度
                //360/100;
                float fProgress = (_Value - 50f) * 2 * 3.6f;
                if (fProgress > 0)
                {
                    //如果不進行fProgress>0的判斷，在設計器調整大小時如果處于其它控制元件上方時會出來例外，導致繪制失敗，雖然仍可以進行編譯和使用，
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270, fProgress);
                }
            }
        }
        #endregion
        #region Marquee
        else if (_ProgressStyle == ProgressStyle.Marquee)
        {
            if (L_MarqueeType == MarqueeType.SlowInSlowOut)
            {
                if (L_MarqueeStyle == MarqueeStyle.Cross || L_MarqueeStyle == MarqueeStyle.Swing)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2 + 270 - fSlider / 2;
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, Convert.ToSingle(fz), fSlider);
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    if (!bAcrossed)
                    {
                        e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270, Convert.ToSingle(fz));
                    }
                    else
                    {
                        e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + Convert.ToSingle(fz), Convert.ToSingle(360 - fz));
                    }
                }
                else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270, Convert.ToSingle(fz));
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Blocks)
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    float fBlocks = Convert.ToSingle(fz / fBlockSize);
                    float fAllBlocks = 360.0f / fBlockSize;
                    if (!bAcrossed)
                    {
                        for (int i = 0; i < fBlocks; i++)
                        {
                            e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                    else
                    {
                        for (float i = fAllBlocks - 1; i >= fBlocks; i--)
                        {
                            e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                }
                else
                {
                    double fz = 360 * (Math.Sin((dMarqueeValue - 90) * Math.PI / 180) + 1) / 2;
                    float fBlocks = Convert.ToSingle(fz / fBlockSize);

                    for (int i = 0; i < fBlocks; i++)
                    {
                        e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                    }

                }
            }
            else
            {
                if (L_MarqueeStyle == MarqueeStyle.Cross || L_MarqueeStyle == MarqueeStyle.Swing)
                {
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, Convert.ToSingle(dMarqueeValue), fSlider);
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                {
                    if (!bAcrossed)
                    {
                        e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270, Convert.ToSingle(dMarqueeValue));
                    }
                    else
                    {
                        e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + Convert.ToSingle(dMarqueeValue), Convert.ToSingle(360 - dMarqueeValue));
                    }
                }
                else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
                {
                    e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270, Convert.ToSingle(dMarqueeValue));
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Blocks)
                {
                    float fBlocks = Convert.ToSingle(dMarqueeValue / fBlockSize);
                    float fAllBlocks = 360.0f / fBlockSize;
                    if (!bAcrossed)
                    {
                        for (int i = 0; i < fBlocks; i++)
                        {
                            e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                    else
                    {
                        for (float i = fAllBlocks - 1; i >= fBlocks; i--)
                        {
                            e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                        }
                    }
                }
                else
                {
                    float fBlocks = Convert.ToSingle(dMarqueeValue / fBlockSize);
                    for (int i = 0; i < fBlocks; i++)
                    {
                        e.Graphics.FillPie(sbFore, fRealLeftTop, fRealLeftTop, fRealWidth, fRealHeight, 270 + i * fBlockSize, fBlockSize * 2 / 3 > (359.0f - i * fBlockSize) ? (359.0f - i * fBlockSize) : fBlockSize * 2 / 3);
                    }
                }
            }

        }
        #endregion
    }
    #endregion

    #region Text

    if (_ProgressText != ProgressText.None)
    {
        if (_ProgressStyle != ProgressStyle.Marquee)
        {
            string sText = _ProgressText == ProgressText.Number ? _Value.ToString() : _Value.ToString() + "%";
            SizeF sizeText = e.Graphics.MeasureString(sText, Font);
            float fx = (Width - sizeText.Width) / 2f;
            float fy = (Height - sizeText.Height) / 2f;
            e.Graphics.DrawString(sText, Font, _TextColor == Color.Empty ? sbFore : sbText, fx, fy);
        }
    }

    #endregion

    sbInner.Dispose();
    sbFore.Dispose();
    sbText.Dispose();
}

OnPaint

private void TTimer_Tick(object sender, EventArgs e)
{
    //進度實際繪制寬度、高度
    float fRealWidth = Width - _DrawMargin * 2;
    float fRealHeight = Height - _DrawMargin * 2;

    float fSlider = Convert.ToSingle(fRealWidth) / 5;
    if (_ProgressType != ProgressType.Bar)
    {
        //360/5
        fSlider = 72;
    }

    float fRange = 0;
    if (L_MarqueeStyle == MarqueeStyle.Swing) fRange = fRealWidth - fSlider;
    else if (L_MarqueeStyle == MarqueeStyle.Cross) fRange = fRealWidth + fSlider;
    else fRange = fRealWidth;

    double dStep = Convert.ToDouble(L_MarqueeTime) / 10;
    double dMarqueePer = 180.0 / dStep;
    if (L_MarqueeType == MarqueeType.Even)
    {
        if (_ProgressType == ProgressType.Bar)
        {
            dMarqueePer = fRange / dStep;
        }
        else
        {
            dMarqueePer = 360.0 / dStep;
        }
    }

    double dPeriod = 180;
    if (L_MarqueeStyle == MarqueeStyle.Swing || L_MarqueeStyle == MarqueeStyle.Reciprocation_Blocks || L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous) dPeriod = 360;

    if (_ProgressType == ProgressType.Bar)
    {
        if (_ProgressStyle == ProgressStyle.Marquee)
        {
            if (L_MarqueeType == MarqueeType.SlowInSlowOut)
            {
                if (dMarqueeValue > dPeriod)
                {
                    bAcrossed = !bAcrossed;
                    dMarqueeValue = 0;
                }
                dMarqueeValue += dMarqueePer;
                Invalidate();
            }
            else
            {
                if (L_MarqueeStyle == MarqueeStyle.Cross)
                {
                    bToRight = true;
                    if (dMarqueeValue > fRange) dMarqueeValue = https://www.cnblogs.com/lesliexin/archive/2020/11/05/-fSlider;
                }
                else if (L_MarqueeStyle == MarqueeStyle.Across_Blocks || L_MarqueeStyle == MarqueeStyle.Across_Continuous)
                {
                    bToRight = true;
                    if (dMarqueeValue > fRange)
                    {
                        bAcrossed = !bAcrossed;
                        dMarqueeValue = 0;
                    }
                }
                else
                {
                    if (dMarqueeValue > fRange) bToRight = false;
                    if (dMarqueeValue < 0) bToRight = true;
                }
                dMarqueeValue = bToRight ? dMarqueeValue + dMarqueePer : dMarqueeValue - dMarqueePer;
                Invalidate();
            }
        }
        else
        {
            if (dMarqueeValue > 0) dMarqueeValue = https://www.cnblogs.com/lesliexin/archive/2020/11/05/0;
            dMarqueeValue -= 1;
            if (dMarqueeValue <-_BlockSize) dMarqueeValue = https://www.cnblogs.com/lesliexin/archive/2020/11/05/0;                   
            Invalidate();
        }
    }
    else if (_ProgressType == ProgressType.Arc || _ProgressType == ProgressType.Pie)
    {
        //為了更符合直觀認識，即：轉到頂部時速度最變到最慢，到最底部時速度加到最快，所以需要從270度開始，
        if (L_MarqueeType == MarqueeType.SlowInSlowOut)
        {
            if (dMarqueeValue > dPeriod)
            {
                bAcrossed = !bAcrossed;
                dMarqueeValue = 0;
            }
            dMarqueeValue += dMarqueePer;
            Invalidate();
        }
        else
        {
            if (L_MarqueeStyle == MarqueeStyle.Cross)
            {
                bToRight = true;
                if (dMarqueeValue > 360) dMarqueeValue = https://www.cnblogs.com/lesliexin/archive/2020/11/05/0;
            }
            else if (L_MarqueeStyle == MarqueeStyle.Across_Blocks || L_MarqueeStyle == MarqueeStyle.Across_Continuous)
            {
                bToRight = true;
                if (dMarqueeValue > 360)
                {
                    bAcrossed = !bAcrossed;
                    dMarqueeValue = 0;
                }
            }
            else if (L_MarqueeStyle == MarqueeStyle.Reciprocation_Blocks || L_MarqueeStyle == MarqueeStyle.Reciprocation_Continuous)
            {
                if (dMarqueeValue > 360) bToRight = false;
                if (dMarqueeValue < 0) bToRight = true;
            }
            else
            {
                if (dMarqueeValue > 270 - fSlider / 2) bToRight = false;
                if (dMarqueeValue < -90 - fSlider / 2) bToRight = true;
            }

            dMarqueeValue = bToRight ? dMarqueeValue + dMarqueePer : dMarqueeValue - dMarqueePer;
            Invalidate();
        }
    }

}

Timer_Tick

畫進度條，其實就是將進度條的三個組成部分——背景、邊框、進度——分別繪制出來，

1，背景

（1）橫條（Bar）

填充一個矩形，這里的矩形范圍是控制元件范圍減去“背景收縮寬度”后的范圍，

（2）圓餅（Pie）和圓弧（Arc）

填充一個圓形，同樣范圍是控制元件范圍減去“背景收縮寬度”后的范圍，

2，邊框

（1）橫條（Bar）

繪制一個矩形框，畫筆寬度就是邊框寬度，注意繪制的范圍，包含起點和寬高，寬高是要分別減去一半的邊框寬度的，因為繪制畫筆時，是從畫筆寬度中間作畫，

（2）圓餅（Pie）和圓弧（Arc）

繪制一個圓，畫筆寬度就是邊框寬度，同樣需要注意繪制的范圍，具體同上，

3，進度

這是實作時最復雜的地方，難度并不大，主要是要繪制的效果太多了，

在畫進度時要分兩種情況，一種是進度明確的，一種是進度不明確的（Marquee樣式），

在每種情況中，進度都有多種樣式，比如連續、分段塊等等，

（1），進度明確

1.1，連續

（1）橫條（Bar）

填充一個矩形，注意繪制的起點為屬性“進度繪制范邊緣”的值，而矩形寬度為當前進度值除以100再乘以可繪制范圍，

簡而言之就是按百分比繪制矩形，

（2）圓餅（Pie）

填充一個扇形，除了繪制范圍起點外，需要注意的是起始角度，對于方法 FillPie 而言，以水平向右方向為0度，而我們實作的起始角度是在垂直向上方向，所以啟始角度要為270，

同上，繪制的解雇就是按百分比計算：當前值/100*360，

（3）圓弧（Arc）

畫一段弧線，同上需要注意啟始角度要為270，同時還要注意的還有“弧線厚度”這一屬性，所以計算繪制范圍時要減去相應的值，

同上，繪制的解雇就是按百分比計算：當前值/100*360，

1.2，分段塊

（1）橫條（Bar）

首先計算出當前可繪制的寬度范圍，然后除以“分段塊寬度”，計算出一共可畫多少個“塊”，這里需要注意“分段塊寬度”是包含2/3的有顏色部分和1/3無顏色部分（充當間隔），在前一節中有詳細講解，

然后依次將這些“塊”繪制即可，

（2）圓餅（Pie）

同上，不過這里的“分段塊寬度”指的是角度，同樣計算出需要多少個“小扇形”，然后依次繪制即可，

（3）圓弧（Arc）

同上，不過這里的“分段塊寬度”指的是角度，同樣計算出需要多少個“小段弧線”，然后依次繪制即可，

1.3，兩段式

通過上圖我們可發現，兩段式就是將“連續”和“分段塊”結合起來，先繪制一遍“分段塊”再繪制一遍“連續”，

這里需要注意的一點是每一遍都只占50%，所以在計算相應的范圍時要乘以2，

因為“連續”和“分段塊”前面都以講過，此處便不再贅述，

1.4，螺旋

螺旋只有“橫條（Bar）”才支持，其本身是“分段塊”的變形，所以會使用“分段塊寬度”這一屬性，

在前節進行過詳細講解，所以此處不再贅述，

2，進度不明確（Marquee樣式）

雖然有多種Marquee樣式，但歸到最后無非三大類：位置變化、范圍變化、螺旋，

其中，“螺旋”在前節中詳細講解過，所以此處不再贅述，

無論“位置變化”還是“范圍變化”，都是通過定時器去按間隔回圈改變相應的值，而“勻速”效果和“緩動”效果則是在每個間隔變化的值是否相等而已，

關于勻速和緩動我前幾篇文章都有詳細講過，此處不再贅述，

（1）位置變化

通過上面這些圖，一目了然，位置變化，對于橫條（Bar）而言，就是改變起始位置；對于圓餅（Pie）和圓弧（Arc）而言，則是改變起始角度，

（2）范圍變化

通過上面這些圖，一目了然，范圍變化，對于橫條（Bar）而言，就是使繪制范圍發生變化，準確的說是寬度的變化；對于圓餅（Pie）和圓弧（Arc）而言，則是繪制角度的大小變化，

（3）位置和范圍都發生變化

通過上面這些圖，一目了然，屬于前兩者的結合體，

（四）其它說明

在實作時，我并沒有去限制圓餅（Pie）和圓弧（Arc）一定得是正圓，也就是令其寬度和高度必須相等，

因為這樣可以實作一些比較好玩的效果，如下：

五、效果演示

為了更好的展示出進度條的特點，所以我們按下圖這樣構造一個演示程式，

本文中大部分圖片和動圖都是使用本演示程式錄制的，

具體演示程式及源代碼工程在文末有下載，請下載后自動體驗，

六、結束語

我們會發現Marquee樣式的影片和我們常見的加載（Loading）影片有些類似，實際上，加載影片的實作方式正是本文中實作Marquee樣式時所使用的方式，所以后面我們會去實作“加載（Loading）控制元件”，

本文只是起一個拋磚引玉的作用，讀者不要被我的思路所限制，你可以盡情的去實作你想要的效果，

技術并沒有先進和落后，只有合適與不合適，

所以，對自己掌握的知識多抱有一些信心，盡情釋放自己的想像力，并在實踐中提升自己，

七、源代碼及工程下載

https://files.cnblogs.com/files/lesliexin/04,LProgressBar.7z

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/203283.html

標籤：.NET技术

上一篇：Visual Studio中Git的簡單使用

下一篇：在VS的依賴項中參考專案

[C#] （原創）一步一步教你自定義控制元件——04，ProgressBar（進度條）

一、前言

二、前期分析

（一）為什么需要自定義進度條？

（二）實作目標

1，支持三種樣式

2，支持顯示和隱藏百分比

3，支持多種進度形狀

4，支持Marquee樣式

5，支持調整進度條各元素尺寸和顏色

三、進度條拆解

（一）組成元素

1，橫條（Bar）

2，圓餅（Pie）

3，圓弧（Arc）

（二）元素屬性

1，邊框

A，對于 “橫條（Bar）”，其邊框厚度如下圖所示：

B，對于“圓餅（Pie）”、“圓弧（Arc）”，其邊框厚度如下圖所示：

2，背景

A，對于 “橫條（Bar）”，其收縮寬度如下圖所示：

B，對于“圓餅（Pie）”、“圓弧（Arc）”，其收縮寬度如下圖所示：

3，進度

A，對于 “橫條（Bar）”，其繪制邊框距離如下圖所示：

B，對于“圓餅（Pie）”，其繪制邊框距離如下圖所示：

C，對于“圓弧（Arc）”，其繪制邊框距離如下圖所示：

（1）“螺旋”樣式實作講解

（三）其它屬性

1，弧線寬度

2，分段塊寬度

四、開始實作

（一）前期準備，

（二）添加屬性

1，進度值

2，邊框厚度

3，邊框顏色

4，背景收縮寬度

5，背景顏色

6，進度繪制范圍邊緣

7，弧線厚度

8， 進度顏色

9，分段塊寬度

10，進度樣式

11，進度條型別

12，進度條模式

13，Marquee回圈一遍時間

14，Marquees樣式

15，Marquee型別

16，進度文本型別

17，進度文本顏色

18，建構式

（三）重寫方法

1，背景

2，邊框

3，進度

（1），進度明確

2，進度不明確（Marquee樣式）

（四）其它說明

五、效果演示

六、結束語

七、源代碼及工程下載

8，進度顏色