淡入淡出显示图像控件

1. using System;
2. using System.Collections.Generic;
3. using System.ComponentModel;
4. using System.Data;
5. using System.Drawing;
6. using System.Text;
7. using System.Windows.Forms;
8. using System.Drawing.Imaging;
10. namespace ImageFlash
11. {
12.     public class AnimateControl : Control
13.     {
14.         private Image _image;
15.         private System.Threading.Timer _timer;
16.         private static readonly int Interval = 100;
17.         private bool _stop = true;
18.         private bool _flashIn = true;
19.         private float _opaque;
20.         private bool _flash;
21.         private float _step = 0.02f;
23.         public AnimateControl()
24.         {
25.             SetStyle(
26.                 ControlStyles.AllPaintingInWmPaint |
27.                 ControlStyles.UserPaint |
28.                 ControlStyles.ResizeRedraw |
29.                 ControlStyles.OptimizedDoubleBuffer, true);
30.         }
32.         [DefaultValue(null)]
33.         public Image Image
34.         {
35.             get { return _image; }
36.             set
37.             {
38.                 if (!_stop)
39.                     throw new Exception("Flashing");
40.                 _image = value;
41.                 if (DesignMode)
42.                     Invalidate();
43.             }
44.         }
46.         [DefaultValue(true)]
47.         public bool FlashIn
48.         {
49.             get { return _flashIn; }
50.             set 
51.             {
52.                 if (!_stop)
53.                     throw new Exception("Flashing");
54.                 _flashIn = value; 
55.             }
56.         }
58.         [DefaultValue(0.02f)]
59.         public float Step
60.         {
61.             get { return _step; }
62.             set
63.             {
64.                 if (!_stop)
65.                     throw new Exception("Flashing");
66.                 if (value < 0)
67.                     _step = 0.01f;
68.                 else if (value > 1)
69.                     _step = 1f;
70.                 else
71.                     _step = value;
72.             }
73.         }
75.         private System.Threading.Timer Timer
76.         {
77.             get
78.             {
79.                 if (_timer == null)
80.                 {
81.                     _timer = new System.Threading.Timer(
82.                         new System.Threading.TimerCallback(Animate),
83.                         null,
84.                         -1,
85.                         Interval);
86.                 }
87.                 return _timer;
88.             }
89.         }
91.         protected override void OnPaint(PaintEventArgs pe)
92.         {
93.             base.OnPaint(pe);
95.             if (!DesignMode && _flash)
96.             {
97.                 AnimateDraw(pe.Graphics, _opaque);
98.             }
99.             else if (DesignMode)
100.             {
101.                 if (_image != null)
102.                     pe.Graphics.DrawImage(
103.                         _image,
104.                         0,
105.                         0);
106.             }
107.         }
109.         private void AnimateDraw(Graphics g, float op)
110.         {
111.             if (_image == null)
112.                 return;
114.             float[][] matrix = new float[][]{
115.                 new float[]{op,0,0,0,0},
116.                 new float[]{0,op,0,0,0},
117.                 new float[]{0,0,op,0,0},
118.                 new float[]{0,0,0,op,0},
119.                 new float[]{0,0,0,0,1.0f}};
120.             ImageAttributes attributes = new ImageAttributes();
121.             ColorMatrix colorMatrix = new ColorMatrix(matrix);
123.             int width = _image.Width;
124.             int height = _image.Height;
126.             attributes.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
127.             g.DrawImage(
128.                 _image,
129.                 new Rectangle(0, 0, width, height),
130.                 0,
131.                 0,
132.                 width,
133.                 height,
134.                 GraphicsUnit.Pixel,
135.                 attributes);
136.         }
138.         private void Animate(object obj)
139.         {
140.             bool exit = false;
141.             if (_flashIn)
142.             {
143.                 _opaque += _step;
144.                 if (_opaque > 1)
145.                 {
146.                     _opaque = 1f;
147.                     exit = true;
148.                 }
149.             }
150.             else
151.             {
152.                 _opaque -= _step;
153.                 if (_opaque < 0)
154.                 {
155.                     _opaque = 0f;
156.                     exit = true;
157.                 }
158.             }
160.             Invalidate();
161.             if (exit)
162.             {
163.                 _timer.Change(-1, Interval);
164.                 _stop = true;
165.             }
166.         }
168.         public void StartFlash()
169.         {
170.             if (!_stop)
171.                 return;
172.             _flash = true;
173.             _stop = false;
174.             _opaque = _flashIn ? 0f : 1f;
175.             Timer.Change(0, Interval);
176.         }
178.         public void StopFlash()
179.         {
180.             if (!_stop)
181.             {
182.                 Timer.Change(-1, Interval);
183.                 _stop = true;
184.                 _flash = false;
185.             }
186.         }
188.         protected override Size DefaultSize
189.         {
190.             get
191.             {
192.                 return new Size(200,200);
193.             }
194.         }
196.         protected override void Dispose(bool disposing)
197.         {
198.             base.Dispose(disposing);
200.             if (disposing)
201.             {
202.                 if (_timer != null)
203.                 {
204.                     _timer.Dispose();
205.                     _timer = null;
206.                 }
208.                 if (_image != null)
209.                 {
210.                     _image.Dispose();
211.                     _image = null;
212.                 }
213.             }
214.         }
215.     }
216. }