这是截屏动画效果:

这是最后10种特效: 

  1.         #region 旋转放大  
  2.  
  3.         // 原理:使用Graphics的RotateTransform()方法进行坐标变换  
  4.         private void Animator21()  
  5.         {  
  6.             const float anglePer = 6; // 每次旋转的角度,应能被360整除  
  7.             const int roundCount = 2; // 旋转周数  
  8.             try 
  9.             {  
  10.                 OnDrawStarted(this, EventArgs.Empty);  
  11.                 //ClearBackground();  
  12.  
  13.                 for (float angle = anglePer; angle <= 360 * roundCount; angle += anglePer) // 每次旋转若干度度,同时进行缩放  
  14.                 {  
  15.                     dc.Clear(Color.FromKnownColor(KnownColor.ButtonFace)); // 清空DC的内容  
  16.                     dc.TranslateTransform(bmp.Width / 2, bmp.Height / 2); // 平移坐标轴,以进行基于图片中心的旋转  
  17.                     dc.RotateTransform(angle); // 旋转坐标轴  
  18.                     dc.ScaleTransform(angle / 360 / roundCount, angle / 360 / roundCount); // 缩放  
  19.                     dc.TranslateTransform(-bmp.Width / 2, -bmp.Height / 2); // 平移坐标轴(复原),用于显示处理后的图像  
  20.                     dc.DrawImage(bmp, 0, 0); // 在DC中绘制图像  
  21.                     dc.ResetTransform(); // 重置DC的所有变换,准备下一次循环  
  22.  
  23.                     ShowBmp();  
  24.                     Thread.Sleep(10 * delay);  
  25.                 }  
  26.             }  
  27.             catch (Exception ex)  
  28.             {  
  29.                 ShowError(ex.Message);  
  30.             }  
  31.             finally 
  32.             {  
  33.                 OnDrawCompleted(this, EventArgs.Empty);  
  34.             }  
  35.         }  
  36.  
  37.         #endregion  
  38.  
  39.         #region 椭圆拉幕  
  40.  
  41.         // 原理:使用TextureBrush载入图像,然后用Graphics的FillEllipse()方法逐渐扩大显示面积  
  42.         private void Animator22()  
  43.         {  
  44.             const int stepCount = 3; // 椭圆外接矩形的高每次的增量像素  
  45.             try 
  46.             {  
  47.                 OnDrawStarted(this, EventArgs.Empty);  
  48.                 ClearBackground();  
  49.  
  50.                 TextureBrush textureBrush = new TextureBrush(bmp); // 建立材质画刷  
  51.                 // 以高度为椭圆由小到大的增量  
  52.                 // 系数1.5使椭圆加大,直到椭圆的内接矩形等于bmp尺寸  
  53.                 // 系数1.5为当前长宽比椭圆的估算系数  
  54.                 for (int i = 1; i <= 1.5 * bmp.Height / 2f; i += stepCount)  
  55.                 {  
  56.                     RectangleF rect = new RectangleF(bmp.Width / 2f - i * bmp.Width / bmp.Height, bmp.Height / 2 - i,  
  57.                         2 * i * bmp.Width / bmp.Height, 2 * i); // 在DC中心位置距离椭圆的外接矩形  
  58.                     dc.FillEllipse(textureBrush, rect); // 填充  
  59.  
  60.                     ShowBmp(rect);  
  61.                     Thread.Sleep(10 * delay);  
  62.                 }  
  63.             }  
  64.             catch (Exception ex)  
  65.             {  
  66.                 ShowError(ex.Message);  
  67.             }  
  68.             finally 
  69.             {  
  70.                 OnDrawCompleted(this, EventArgs.Empty);  
  71.             }  
  72.         }  
  73.  
  74.         #endregion  
  75.  
  76.         #region 对角拉伸  
  77.  
  78.         // 原理:使用Graphics的DrawImage()方法的一个重载版本,将图像绘制在平行四边形中  
  79.         private void Animator23()  
  80.         {  
  81.             const float stepCount = 4.5f; // 平行四边形左上定点所在矩形对角线的增量  
  82.             try 
  83.             {  
  84.                 OnDrawStarted(this, EventArgs.Empty);  
  85.                 ClearBackground();  
  86.  
  87.                 // 绘制平行四边形的三个点为:左上、右上、左下  
  88.                 // 平行四边形的右上、左下为固定点,不断改变左上点的坐标,使其趋于矩形  
  89.                 // 平行四边形的左上点沿矩形对角线(中心到左上)方向改变,故先计算矩形对角线的一半,并以此为循环变量  
  90.                 double diagonal = Math.Sqrt(Math.Pow(bmp.Width, 2f) + Math.Pow(bmp.Height, 2f)) / 2f; // 矩形对角线的一半  
  91.                 double a = Math.Atan(Convert.ToDouble(bmp.Height) / bmp.Width); // 计算矩形对角线与底边(Width)的夹角  
  92.                 for (double i = diagonal; i >= 0; i -= stepCount)  
  93.                 {  
  94.                     // 计算当前左上点的坐标  
  95.                     Point point = new Point((int)(Math.Cos(a) * i), (int)(Math.Sin(a) * i));  
  96.                     // 生成平行四边形左上、右上、左下坐标点数组  
  97.                     Point[] points = { point, new Point(bmp.Width, 0), new Point(0, bmp.Height) };  
  98.                     dc.DrawImage(bmp, points); // 将图像绘制在平行四边形中  
  99.  
  100.                     ShowBmp();  
  101.                     Thread.Sleep(10 * delay);  
  102.                 }  
  103.                 // 平行四边形左上定点的位置最终不一定为(0, 0),故在循环结束后绘制整个位图  
  104.                 dc.DrawImage(bmp, 0, 0);  
  105.  
  106.                 ShowBmp();  
  107.             }  
  108.             catch (Exception ex)  
  109.             {  
  110.                 ShowError(ex.Message);  
  111.             }  
  112.             finally 
  113.             {  
  114.                 OnDrawCompleted(this, EventArgs.Empty);  
  115.             }  
  116.         }  
  117.  
  118.         #endregion  
  119.  
  120.         #region 旋转扫描  
  121.  
  122.         // 原理:使用TextureBrush载入图像,然后用Graphics的FillPie()方法逐渐扩大扇形显示面积  
  123.         private void Animator24()  
  124.         {  
  125.             const int anglePer = 5; // 每次旋转的角度,应能被360整除  
  126.             try 
  127.             {  
  128.                 OnDrawStarted(this, EventArgs.Empty);  
  129.                 ClearBackground();  
  130.  
  131.                 // 建立椭圆外接矩形区域,该区域的内接椭圆的内接矩形应不小于bmp尺寸  
  132.                 // 内部使用BitBlt() API函数,大的区域基本不会影响速度  
  133.                 // 坐标平移后应保证该矩形的内接椭圆中心与bmp中心重合  
  134.                 Rectangle rect = new Rectangle(-bmp.Width, -bmp.Height, bmp.Width * 3, bmp.Height * 3);  
  135.                 TextureBrush textureBrush = new TextureBrush(bmp); // 建立材质画刷  
  136.                 // 以扇形跨越角度(单位度)为增量,即角速度相等,线速度并不相等  
  137.                 for (int i = 0; i <= 360; i += anglePer)  
  138.                 {  
  139.                     dc.FillPie(textureBrush, rect, 180, i); // 填充扇形  
  140.  
  141.                     ShowBmp(rect);  
  142.                     Thread.Sleep(10 * delay);  
  143.                 }  
  144.             }  
  145.             catch (Exception ex)  
  146.             {  
  147.                 ShowError(ex.Message);  
  148.             }  
  149.             finally 
  150.             {  
  151.                 OnDrawCompleted(this, EventArgs.Empty);  
  152.             }  
  153.         }  
  154.  
  155.         #endregion  
  156.  
  157.         #region 多径扫描  
  158.  
  159.         // 原理:使用TextureBrush载入图像,然后用Graphics的FillPie()方法分多个角度同步显示逐渐扩大的扇形区域  
  160.         private void Animator25()  
  161.         {  
  162.             const float pieCount = 8; // 同时扫描的扇形数量  
  163.             try 
  164.             {  
  165.                 OnDrawStarted(this, EventArgs.Empty);  
  166.                 ClearBackground();  
  167.  
  168.                 // 建立椭圆外接矩形区域,该区域的内接椭圆的内接矩形应不小于bmp尺寸  
  169.                 // 内部使用BitBlt() API函数,大的区域基本不会影响速度  
  170.                 // 坐标平移后应保证该矩形的内接椭圆中心与bmp中心重合  
  171.                 Rectangle rect = new Rectangle(-bmp.Width, -bmp.Height, bmp.Width * 3, bmp.Height * 3);  
  172.                 TextureBrush textureBrush = new TextureBrush(bmp); // 建立材质画刷  
  173.                 // 以扇形跨越角度(单位度)为增量,即角速度相等,线速度并不相等  
  174.                 // 共pieCount个扇形每个扇形共计360/pieCount度  
  175.                 for (int angle = 1; angle <= Math.Ceiling(360 / pieCount); angle++)  
  176.                 {  
  177.                     // 扫描每个扇形区域  
  178.                     for (int i = 0; i < pieCount; i++)  
  179.                     {  
  180.                         dc.FillPie(textureBrush, rect, i * 360 / pieCount, angle); // 填充扇形  
  181.                     }  
  182.  
  183.                     ShowBmp(rect);  
  184.                     Thread.Sleep(20 * delay);  
  185.                 }  
  186.             }  
  187.             catch (Exception ex)  
  188.             {  
  189.                 ShowError(ex.Message);  
  190.             }  
  191.             finally 
  192.             {  
  193.                 OnDrawCompleted(this, EventArgs.Empty);  
  194.             }  
  195.         }  
  196.  
  197.         #endregion  
  198.  
  199.         #region 随机落幕(改进版)  
  200.  
  201.         // 原理:将图像分成宽度相等的列,然后每次随机若干列前进一定的量,直到所有的竖条均到达图像底端  
  202.         private void Animator26()  
  203.         {  
  204.             const float lineWidth = 15; // 竖条宽度  
  205.             const int stepCount = 6; // 竖条每次前进量  
  206.             try 
  207.             {  
  208.                 OnDrawStarted(this, EventArgs.Empty);  
  209.                 ClearBackground();  
  210.  
  211.                 int colCount = (int)Math.Ceiling(bmp.Width / lineWidth); // 计算列数  
  212.                 Random rnd = new Random(); // 随机数类  
  213.                 // 该数组保存每个列前进的位置,即每个列的高度,自动初始化为0  
  214.                 int[] colIndex = new int[colCount];  
  215.                 // 按随机次序逐一显示每个竖条  
  216.                 bool flag = false// 表示是否所有的列均显示完成,即到达了图像的底边  
  217.  
  218.                 Region region = new Region(new GraphicsPath()); // 空区域  
  219.                 TextureBrush textureBrush = new TextureBrush(bmp); // 建立位图材质画刷  
  220.                 do // 循环直到所有列均显示完毕,即到达底端  
  221.                 {  
  222.                     for (int i = 0; i < colCount; i++)  
  223.                     {  
  224.                         int col = rnd.Next(colCount); // 随机生成要显示的列  
  225.                         if (colIndex[col] < bmp.Height) // 该列未显示完  
  226.                         {  
  227.                             colIndex[col] += stepCount; // 记录该列新的位置  
  228.                             RectangleF rect = new RectangleF(col * lineWidth, 0, lineWidth, colIndex[col]);  
  229.                             region.Union(rect);  
  230.                         }  
  231.                         else 
  232.                         {  
  233.                             i--; // 保证每次处理列数为colCount  
  234.                         }  
  235.                     }  
  236.                     dc.FillRegion(textureBrush, region);  
  237.  
  238.                     ShowBmp(region.GetBounds(dc));  
  239.                     Thread.Sleep(10 * delay);  
  240.  
  241.                     flag = true// 假设所有列已显示完成  
  242.                     for (int i = 0; i < colIndex.Length; i++)  
  243.                     {  
  244.                         if (colIndex[i] < bmp.Height)  
  245.                         {  
  246.                             flag = false// 存在未显示完的列,仍需循环  
  247.                             break;  
  248.                         }  
  249.                     }  
  250.                 } while (!flag);  
  251.             }  
  252.             catch (Exception ex)  
  253.             {  
  254.                 ShowError(ex.Message);  
  255.             }  
  256.             finally 
  257.             {  
  258.                 OnDrawCompleted(this, EventArgs.Empty);  
  259.             }  
  260.         }  
  261.  
  262.         #endregion  
  263.  
  264.         #region 螺线内旋  
  265.  
  266.         // 原理:从图像左上角开始,以分块大小顺时针内旋显示图像  
  267.         private void Animator27()  
  268.         {  
  269.             const float blockSize = 45; // 正方块的边长  
  270.             try 
  271.             {  
  272.                 OnDrawStarted(this, EventArgs.Empty);  
  273.                 ClearBackground();  
  274.  
  275.                 int cols = (int)Math.Ceiling(bmp.Width / blockSize); // 按照分块尺寸划分的列总计  
  276.                 int rows = (int)Math.Ceiling(bmp.Height / blockSize); // 按照分块尺寸划分的行总计  
  277.                 Point block = new Point(0, 0); // 当前显示块的坐标  
  278.                 Rectangle area = new Rectangle(0, 0, cols, rows); // 尚未显示分块的区域坐标  
  279.                 int direction = 0; // 内旋方向,0表示向右,1表示向下,2表示向左,3表示向上  
  280.                 for (int i = 0; i < cols * rows; i++) // 循环分块总数次  
  281.                 {  
  282.                     RectangleF rect = new RectangleF(block.X * blockSize, block.Y * blockSize, blockSize, blockSize);  
  283.                     dc.DrawImage(bmp, rect, rect, GraphicsUnit.Pixel);  
  284.                     switch (direction)  
  285.                     {  
  286.                         case 0: // 当前向右  
  287.                             if (block.X < area.Width - 1) // 尚未到达右边界  
  288.                             {  
  289.                                 block.X++; // 继续向右  
  290.                             }  
  291.                             else // 已到达右边界  
  292.                             {  
  293.                                 direction = 1; // 方向改为向下  
  294.                                 block.Y++; // 向下  
  295.                                 area.Y++; // 修改待显示区域的上边界  
  296.                             }  
  297.                             break;  
  298.                         case 1: // 当前向下  
  299.                             if (block.Y < area.Height - 1) // 尚未到达下边界  
  300.                             {  
  301.                                 block.Y++; // 继续向下  
  302.                             }  
  303.                             else // 已到达下边界  
  304.                             {  
  305.                                 direction = 2; // 方向改为向左  
  306.                                 block.X--; // 向左  
  307.                                 area.Width--; // 修改待显示区域的右边界  
  308.                             }  
  309.                             break;  
  310.                         case 2: // 当前向左  
  311.                             if (block.X > area.X) // 尚未到达左边界  
  312.                             {  
  313.                                 block.X--; // 继续向左  
  314.                             }  
  315.                             else // 已到达左边界  
  316.                             {  
  317.                                 direction = 3; // 方向改为向上  
  318.                                 block.Y--; // 向上  
  319.                                 area.Height--; // 修改待显示区域的下边界  
  320.                             }  
  321.                             break;  
  322.                         default// 当前向上  
  323.                             if (block.Y > area.Y) // 尚未到达上边界  
  324.                             {  
  325.                                 block.Y--; // 继续向上  
  326.                             }  
  327.                             else // 已到达上边界  
  328.                             {  
  329.                                 direction = 0; // 方向改为向右  
  330.                                 block.X++; // 向右  
  331.                                 area.X++; // 修改待显示区域的左边界  
  332.                             }  
  333.                             break;  
  334.                     }  
  335.  
  336.                     ShowBmp(rect);  
  337.                     Thread.Sleep(10 * delay);  
  338.                 }  
  339.             }  
  340.             catch (Exception ex)  
  341.             {  
  342.                 ShowError(ex.Message);  
  343.             }  
  344.             finally 
  345.             {  
  346.                 OnDrawCompleted(this, EventArgs.Empty);  
  347.             }  
  348.         }  
  349.  
  350.         #endregion  
  351.  
  352.         #region 灰度扫描(改进版)  
  353.  
  354.         // 原理:使用ImageAttributes类和颜色转换矩阵处理图像,从下到上灰度显示图像,然后从上到下转换为正片  
  355.         private void Animator28()  
  356.         {  
  357.             const int stepCount = 6; // 每次显示的像素量  
  358.             try 
  359.             {  
  360.                 OnDrawStarted(this, EventArgs.Empty);  
  361.                 ClearBackground();  
  362.  
  363.                 // ImageAttributes类的实例用于调整颜色,由DrawImage()方法调用  
  364.                 ImageAttributes attributes = new ImageAttributes();  
  365.                 // 建立5*5阶RGBA颜色矩阵  
  366.                 ColorMatrix matrix = new ColorMatrix();  
  367.                 // 根据亮度方程将矩阵设为灰度变换  
  368.                 for (int i = 0; i < 3; i++)  
  369.                 {  
  370.                     matrix[0, i] = 0.299f;  
  371.                     matrix[1, i] = 0.587f;  
  372.                     matrix[2, i] = 0.114f;  
  373.                 }  
  374.                 attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);  
  375.                 // 建立灰度位图并将输入位图转换为灰度  
  376.                 Bitmap grayBmp = new Bitmap(bmp.Width, bmp.Height);  
  377.                 Graphics grayDc = Graphics.FromImage(grayBmp);  
  378.                 grayDc.DrawImage(bmp, new Rectangle(0, 0, bmp.Width, bmp.Height), 0, 0, bmp.Width, bmp.Height, GraphicsUnit.Pixel, attributes);  
  379.  
  380.                 // 以灰度方式从下到上绘制整个图像  
  381.                 for (int y = bmp.Height - 1; y >= 0; y -= stepCount)  
  382.                 {  
  383.                     Rectangle rect = new Rectangle(0, y, bmp.Width, stepCount);  
  384.                     dc.DrawImage(grayBmp, rect, rect, GraphicsUnit.Pixel);  
  385.  
  386.                     ShowBmp(rect);  
  387.                     Thread.Sleep(10 * delay);  
  388.                 }  
  389.                 // 以正片方式从上到下绘制整个图像  
  390.                 for (int y = 0; y < bmp.Height; y += stepCount)  
  391.                 {  
  392.                     Rectangle rect = new Rectangle(0, y, bmp.Width, stepCount);  
  393.                     dc.DrawImage(bmp, rect, rect, GraphicsUnit.Pixel);  
  394.  
  395.                     ShowBmp(rect);  
  396.                     Thread.Sleep(10 * delay);  
  397.                 }  
  398.             }  
  399.             catch (Exception ex)  
  400.             {  
  401.                 ShowError(ex.Message);  
  402.             }  
  403.             finally 
  404.             {  
  405.                 OnDrawCompleted(this, EventArgs.Empty);  
  406.             }  
  407.         }  
  408.  
  409.         #endregion  
  410.  
  411.         #region 负片追踪(改进版)  
  412.  
  413.         // 原理:使用ImageAttributes类和颜色转换矩阵处理图像,从左到右负片显示图像,同时,以滞后方式显示正片  
  414.         private void Animator29()  
  415.         {  
  416.             const float stepCount = 4; // 每次显示的像素量  
  417.             const float delayCount = 280; // 转换为正片的滞后像素数,该值必须能被stepCount整除  
  418.             try 
  419.             {  
  420.                 OnDrawStarted(this, EventArgs.Empty);  
  421.                 ClearBackground();  
  422.  
  423.                 // ImageAttributes类的实例用于调整颜色,由DrawImage()方法调用  
  424.                 ImageAttributes attributes = new ImageAttributes();  
  425.                 // 建立5*5阶RGBA颜色矩阵  
  426.                 ColorMatrix matrix = new ColorMatrix();  
  427.                 // 将矩阵设为负片变换  
  428.                 matrix.Matrix00 = matrix.Matrix11 = matrix.Matrix22 = -1f;  
  429.                 matrix.Matrix30 = matrix.Matrix31 = matrix.Matrix32 = 1f;  
  430.                 attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);  
  431.                 // 建立负片图像  
  432.                 Bitmap negativeBmp = new Bitmap(bmp.Width, bmp.Height);  
  433.                 // 转换负片图像  
  434.                 Graphics negativeDc = Graphics.FromImage(negativeBmp);  
  435.                 negativeDc.DrawImage(bmp, new Rectangle(0, 0, bmp.Width, bmp.Height), 0, 0, bmp.Width, bmp.Height, GraphicsUnit.Pixel, attributes);  
  436.  
  437.                 // 以负片方式从左到右绘制整个图像,正片绘制在负片进行到delay时开始,并以合适的速度前进,恰好与负片同时到达右边  
  438.                 for (int x = 0; x < bmp.Width; x += (int)stepCount)  
  439.                 {  
  440.                     // 负片显示区域  
  441.                     RectangleF rect1 = new RectangleF(x, 0, stepCount, bmp.Height);  
  442.                     dc.DrawImage(negativeBmp, rect1, rect1, GraphicsUnit.Pixel);  
  443.                     RectangleF rect2 = RectangleF.Empty;  
  444.                     if (x >= delayCount) // 显示正片区域  
  445.                     {  
  446.                         // 正片显示区域计算方法:  
  447.                         // 正片起始位置:(x - delay) * bmp.Width / (bmp.Width - delay)  
  448.                         // 当前负片已显示到delay,还需显示bmp.Width - delay,而正片还需显示bmp.Width  
  449.                         // 即负片每显示一次,正片需显示负片的bmp.Width / (bmp.Width - delay)倍  
  450.                         // 因此,正片每次的起始位置为(x - delay) * bmp.Width / (bmp.Width - delay)  
  451.                         // 正片增量:bmp.Width / ((bmp.Width - delay) / stepCount)  
  452.                         // 正片共需显示bmp.Width  
  453.                         // 负片还有((bmp.Width - delay) / stepCount)次便显示完成,即正片也有同样的次数  
  454.                         // 因此,正片每次显示bmp.Width / ((bmp.Width - delay) / stepCount)  
  455.                         rect2 = new RectangleF((x - delayCount) * bmp.Width / (bmp.Width - delayCount), 0,  
  456.                             bmp.Width / ((bmp.Width - delayCount) / stepCount), bmp.Height);  
  457.                         dc.DrawImage(bmp, rect2, rect2, GraphicsUnit.Pixel);  
  458.                     }  
  459.  
  460.                     ShowBmp(RectangleF.Union(rect1, rect2));  
  461.                     Thread.Sleep(10 * delay);  
  462.                 }  
  463.             }  
  464.             catch (Exception ex)  
  465.             {  
  466.                 ShowError(ex.Message);  
  467.             }  
  468.             finally 
  469.             {  
  470.                 OnDrawCompleted(this, EventArgs.Empty);  
  471.             }  
  472.         }  
  473.  
  474.         #endregion  
  475.  
  476.         #region 水平卷轴  
  477.  
  478.         // 原理:从左到右显示逐步图像,在已显示区域的右边缘压缩显示剩余图像  
  479.         private void Animator30()  
  480.         {  
  481.             const float blockWidth = 80; // 压缩图像区域的宽度(像素)  
  482.             const float stepCount = 6; // 每次显示步进宽度(像素)  
  483.             try 
  484.             {  
  485.                 OnDrawStarted(this, EventArgs.Empty);  
  486.                 ClearBackground();  
  487.  
  488.                 for (int x = 0; x <= Math.Ceiling((bmp.Width - blockWidth) / stepCount); x++)  
  489.                 {  
  490.                     // 绘制不压缩的显示区域  
  491.                     RectangleF rect = new RectangleF(x * stepCount, 0, stepCount, bmp.Height);  
  492.                     dc.DrawImage(bmp, rect, rect, GraphicsUnit.Pixel);  
  493.                     // 绘制压缩区域  
  494.                     RectangleF sourRect = new RectangleF((x + 1) * stepCount, 0, bmp.Width - x * stepCount, bmp.Height); // 尚未显示的区域  
  495.                     RectangleF destRect = new RectangleF((x + 1) * stepCount, 0, blockWidth, bmp.Height); // 压缩竖条区域  
  496.                     dc.DrawImage(bmp, destRect, sourRect, GraphicsUnit.Pixel);  
  497.  
  498.                     ShowBmp(RectangleF.Union(rect, destRect));  
  499.                     Thread.Sleep(10 * delay);  
  500.                 }  
  501.             }  
  502.             catch (Exception ex)  
  503.             {  
  504.                 ShowError(ex.Message);  
  505.             }  
  506.             finally 
  507.             {  
  508.                 OnDrawCompleted(this, EventArgs.Empty);  
  509.             }  
  510.         }  
  511.  
  512.         #endregion  
  513.     }  
  514.  

下面的链接或附件可以下载该软件完整的源文件,包含所有资源和一个已编译的可执行文件,至少需要.NET 3.5架构支持:
http://mengliao.blog.51cto.com/p_w_upload/201101/876134_1294304450.rar
(全文完)