Return to SmoothProgressBar.cs CVS log

Up to [cleanflash] / cleanflash / CleanFlashCommon

Annotation of cleanflash/CleanFlashCommon/SmoothProgressBar.cs, revision 1.1.1.1

1.1       root        1: using System;
                      2: using System.Drawing;
                      3: using System.Drawing.Drawing2D;
                      4: using System.Windows.Forms;
                      5: 
                      6: namespace CleanFlashCommon {
                      7:     public class SmoothProgressBar : UserControl {
                      8:         int min = 0;
                      9:         int max = 100;
                     10:         int val = 0;
                     11:         Color Color1 = Color.Black;
                     12:         Color Color2 = Color.White;
                     13: 
                     14:         protected override void OnResize(EventArgs e) {
                     15:             Invalidate();
                     16:         }
                     17: 
                     18:         protected override void OnPaint(PaintEventArgs e) {
                     19:             using (Graphics graphics = e.Graphics) {
                     20:                 using (Brush brush = new LinearGradientBrush(ClientRectangle, Color1, Color2, 0.0F)) {
                     21:                     float percent = (val - min) / (float)(max - min);
                     22:                     Rectangle rect = ClientRectangle;
                     23: 
                     24:                     // Calculate area for drawing the progress.
                     25:                     rect.Width = (int)(rect.Width * percent);
                     26: 
                     27:                     // Draw the progress meter.
                     28:                     graphics.FillRectangle(brush, rect);
                     29:                 }
                     30: 
                     31:                 // Draw a three-dimensional border around the control.
                     32:                 Draw3DBorder(graphics);
                     33:             }
                     34:         }
                     35: 
                     36:         public int Minimum {
                     37:             get {
                     38:                 return min;
                     39:             }
                     40: 
                     41:             set {
                     42:                 min = Math.Max(0, Math.Min(max, value));
                     43: 
                     44:                 if (val < min) {
                     45:                     val = min;
                     46:                 }
                     47: 
                     48:                 Invalidate();
                     49:             }
                     50:         }
                     51: 
                     52:         public int Maximum {
                     53:             get {
                     54:                 return max;
                     55:             }
                     56: 
                     57:             set {
                     58:                 if (value < min) {
                     59:                     min = value;
                     60:                 }
                     61: 
                     62:                 max = value;
                     63: 
                     64:                 if (val > max) {
                     65:                     val = max;
                     66:                 }
                     67: 
                     68:                 Invalidate();
                     69:             }
                     70:         }
                     71: 
                     72:         public int Value {
                     73:             get {
                     74:                 return val;
                     75:             }
                     76: 
                     77:             set {
                     78:                 int oldValue = val;
                     79: 
                     80:                 // Make sure that the value does not stray outside the valid range.
                     81:                 if (value < min) {
                     82:                     val = min;
                     83:                 } else if (value > max) {
                     84:                     val = max;
                     85:                 } else {
                     86:                     val = value;
                     87:                 }
                     88: 
                     89:                 // Invalidate only the changed area.
                     90:                 float percent;
                     91: 
                     92:                 Rectangle newValueRect = ClientRectangle;
                     93:                 Rectangle oldValueRect = ClientRectangle;
                     94: 
                     95:                 // Use a new value to calculate the rectangle for progress.
                     96:                 percent = (val - min) / (float)(max - min);
                     97:                 newValueRect.Width = (int)(newValueRect.Width * percent);
                     98: 
                     99:                 // Use an old value to calculate the rectangle for progress.
                    100:                 percent = (oldValue - min) / (float)(max - min);
                    101:                 oldValueRect.Width = (int)(oldValueRect.Width * percent);
                    102: 
                    103:                 Rectangle updateRect = new Rectangle();
                    104: 
                    105:                 // Find only the part of the screen that must be updated.
                    106:                 if (newValueRect.Width > oldValueRect.Width) {
                    107:                     updateRect.X = oldValueRect.Size.Width;
                    108:                     updateRect.Width = newValueRect.Width - oldValueRect.Width;
                    109:                 } else {
                    110:                     updateRect.X = newValueRect.Size.Width;
                    111:                     updateRect.Width = oldValueRect.Width - newValueRect.Width;
                    112:                 }
                    113: 
                    114:                 updateRect.Height = Height;
                    115: 
                    116:                 // Invalidate the intersection region only.
                    117:                 Invalidate(updateRect);
                    118:             }
                    119:         }
                    120: 
                    121:         public Color ProgressBarColor1 {
                    122:             get {
                    123:                 return Color1;
                    124:             }
                    125: 
                    126:             set {
                    127:                 Color1 = value;
                    128: 
                    129:                 // Invalidate the control to get a repaint.
                    130:                 Invalidate();
                    131:             }
                    132:         }
                    133: 
                    134:         public Color ProgressBarColor2 {
                    135:             get {
                    136:                 return Color2;
                    137:             }
                    138: 
                    139:             set {
                    140:                 Color2 = value;
                    141: 
                    142:                 // Invalidate the control to get a repaint.
                    143:                 Invalidate();
                    144:             }
                    145:         }
                    146: 
                    147:         private void Draw3DBorder(Graphics g) {
                    148:             int PenWidth = (int)Pens.White.Width;
                    149: 
                    150:             g.DrawLine(Pens.DarkGray,
                    151:             new Point(ClientRectangle.Left, ClientRectangle.Top),
                    152:             new Point(ClientRectangle.Width - PenWidth, ClientRectangle.Top));
                    153:             g.DrawLine(Pens.DarkGray,
                    154:             new Point(ClientRectangle.Left, ClientRectangle.Top),
                    155:             new Point(ClientRectangle.Left, ClientRectangle.Height - PenWidth));
                    156:             g.DrawLine(Pens.White,
                    157:             new Point(ClientRectangle.Left, ClientRectangle.Height - PenWidth),
                    158:             new Point(ClientRectangle.Width - PenWidth, ClientRectangle.Height - PenWidth));
                    159:             g.DrawLine(Pens.White,
                    160:             new Point(ClientRectangle.Width - PenWidth, ClientRectangle.Top),
                    161:             new Point(ClientRectangle.Width - PenWidth, ClientRectangle.Height - PenWidth));
                    162:         }
                    163:     }
                    164: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.