单据状态图

介绍单据状态图片显示，能够很美观的看到单据的状态，源码不是我写的 是网上下载的  只是时间久了 忘记哪位博主大神写的了  只是略作修改，系统能够正常使用。

这里粘贴系统用的代码，希望能帮助各位。

namespace RwxFramework.Library
{
    /// <summary>
    /// 提供透明和旋转功能的基础控件
    /// </summary>
    public partial class CYBaseControl : Control
    {
        private float _iBorderThickness = 1f;
        private float _iOpacity = 1f;
        private Brush _brushBg = null;
        private Pen _penFg = null;

        public CYBaseControl()
        {
            this.SetStyle(ControlStyles.SupportsTransparentBackColor |
                ControlStyles.Opaque, true);
            this.BackColor = Color.Transparent;
            BackgroundBrush = Brushes.Transparent;
            ForegroundPen = Pens.Black;
            this.TabStop = false;
        }

        #region Propertys
        #region HideParent
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string Text
        {
            get { return base.Text; }
            set { base.Text = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override Image BackgroundImage
        {
            get { return base.BackgroundImage; }
            set { base.BackgroundImage = value; }
        }

        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override ImageLayout BackgroundImageLayout
        {
            get
            {
                return base.BackgroundImageLayout;
            }
            set
            {
                base.BackgroundImageLayout = value;
            }
        }
        #endregion

        public override Color BackColor
        {
            get
            {
                return base.BackColor;
            }
            set
            {
                base.BackColor = value;
                ResetBgBrush();
            }
        }

        //[EditorAttribute(typeof(BrushTypeEditor), typeof(System.Drawing.Design.UITypeEditor))]  
        //public double Background
        //{
        //    get;
        //    set;
        //}

        public override Color ForeColor
        {
            get
            {
                return base.ForeColor;
            }
            set
            {
                base.ForeColor = value;
                ResetFgPen();
            }
        }

        public float BorderThickness
        {
            get { return _iBorderThickness; }
            set
            {
                if (value < 0)
                {
                    throw new Exception("Out off range");
                }
                _iBorderThickness = value;
                ResetFgPen();
                ResetDrawRect();
            }
        }

        public virtual float RotateAngle
        {
            get;
            set;
        }


        public float Opacity
        {
            get { return _iOpacity; }
            set
            {
                if (value > 1 || value < 0)
                {
                    throw new Exception("Out of range,the Value be in [0,1]");
                }
                else
                {
                    _iOpacity = value;
                    ResetBrushes();
                }
            }
        }

        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.ExStyle = 0x20;
                return cp;
            }
        }

        protected virtual Brush BackgroundBrush
        {
            get { return _brushBg; }
            set { _brushBg = value; }
        }

        protected virtual Pen ForegroundPen
        {
            get { return _penFg; }
            set { _penFg = value; }
        }

        protected virtual RectangleF DrawRect
        {
            get;
            set;
        }
        #endregion

        #region Methods
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
        }

        protected override void OnSizeChanged(EventArgs e)
        {
            base.OnSizeChanged(e);
            ResetDrawRect();
        }
        protected override void OnPaddingChanged(EventArgs e)
        {
            base.OnPaddingChanged(e);
            ResetDrawRect();
        }

        protected void ResetBrushes()
        {
            ResetBgBrush();
            ResetFgPen();
        }

        protected void ResetBgBrush()
        {
            BackgroundBrush = new SolidBrush(GetOpacityColor(BackColor, Opacity));
        }

        protected void ResetFgPen()
        {
            ForegroundPen = new Pen(GetOpacityColor(ForeColor, Opacity), BorderThickness);
        }

        protected Color GetOpacityColor(Color baseColor, float op)
        {
            return Color.FromArgb(Convert.ToInt32(op * baseColor.A), baseColor);
        }

        private void ResetDrawRect()
        {
            float dbwidth = 2 * BorderThickness;
            float halfwidth = BorderThickness / 2;
            int paddingWhith = Padding.Left + Padding.Right;
            int paddingHeight = Padding.Top + Padding.Bottom;
            if (dbwidth > Width - paddingWhith || dbwidth > Height - paddingHeight)
            {
                DrawRect = this.Bounds;
            }
            else
            {
                DrawRect = new RectangleF(Padding.Left + halfwidth,
                    Padding.Top + halfwidth,
                    Width - BorderThickness - paddingWhith,
                    Height - BorderThickness - paddingHeight);
            }
        }
        #endregion
    }
}

namespace RwxFramework.Library
{
    [ToolboxBitmap(typeof(OpacityImage), "Resources.PictureObject.png")]
    public partial class OpacityImage : CYBaseControl
    {
        private Image _image = RwxFramework.Library.Properties.Resources.no;
        private ImageFillMode _fillMode = ImageFillMode.Zoom;

        public Image Image
        {
            get { return _image; }
            set
            {
                if (value == null)
                {
                    _image = RwxFramework.Library.Properties.Resources.no;
                }
                else
                {
                    _image = value;
                }
                ResetPaintImage();
            }
        }
        public bool _isaudit = false;
        public bool IsAudit
        {
            get { return _isaudit; }
            set
            {
                _isaudit = value;
                ShowImage(value);
            }
        }


        public ImageFillMode FillMode
        {
            get { return _fillMode; }
            set
            {
                _fillMode = value;
                ResetPaintImage();
            }
        }

        protected override RectangleF DrawRect
        {
            get
            {
                return base.DrawRect;
            }
            set
            {
                base.DrawRect = value;
                ResetPaintImage();
            }
        }

        protected Image PaintImage
        {
            get;
            private set;
        }
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            if (PaintImage != null)
            {
                e.Graphics.DrawImage(PaintImage, Point.Empty);
            }
        }
        private void ResetPaintImage()
        {
            if (PaintImage != null)
            {
                PaintImage.Dispose();
                PaintImage = null;
            }
            if (_image != null && _image.Width > 0 && _image.Height > 0 && DrawRect.Width > 0 && DrawRect.Height > 0)
            {
                PaintImage = new Bitmap((int)DrawRect.Width, (int)DrawRect.Height);
                using (Graphics g = Graphics.FromImage(PaintImage))
                {
                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                    g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;

                    System.Drawing.Imaging.ImageAttributes ima = new System.Drawing.Imaging.ImageAttributes();
                    ColorMatrix cm = new ColorMatrix();
                    cm.Matrix33 = Opacity;
                    ima.SetColorMatrix(cm);
                    Point pt = Point.Empty;
                    switch (FillMode)
                    {
                        case ImageFillMode.Center:
                            pt = new Point((int)(DrawRect.Width - _image.Width) / 2, (int)(DrawRect.Height - _image.Height) / 2);
                            g.DrawImage(_image, new Rectangle(pt, _image.Size), 0, 0, _image.Width, _image.Height, GraphicsUnit.Pixel, ima);
                            break;
                        case ImageFillMode.Strength:
                            g.DrawImage(_image, Rectangle.Round(DrawRect), 0, 0, _image.Width, _image.Height, GraphicsUnit.Pixel, ima);
                            break;
                        case ImageFillMode.Title:
                            ima.SetWrapMode(System.Drawing.Drawing2D.WrapMode.Tile);
                            TextureBrush brush = new TextureBrush(_image, new Rectangle(0, 0, _image.Width, _image.Height), ima);
                            g.FillRectangle(brush, DrawRect);
                            break;
                        case ImageFillMode.Zoom:
                            float IntWidth; //新的图片宽
                            float IntHeight; //新的图片高   

                            float TargetWidth = DrawRect.Width;
                            float TargetHeight = DrawRect.Height;

                            if (_image.Width > TargetWidth && _image.Height <= TargetHeight)//宽度比目的图片宽度大，长度比目的图片长度小
                            {
                                IntWidth = TargetWidth;
                                IntHeight = (IntWidth * _image.Height) / _image.Width;
                            }
                            else if (_image.Width <= TargetWidth && _image.Height > TargetHeight)//宽度比目的图片宽度小，长度比目的图片长度大
                            {
                                IntHeight = TargetHeight;
                                IntWidth = (IntHeight * _image.Width) / _image.Height;
                            }
                            else if (_image.Width <= TargetWidth && _image.Height <= TargetHeight) //长宽比目的图片长宽都小
                            {
                                IntHeight = _image.Width;
                                IntWidth = _image.Height;
                            }
                            else//长宽比目的图片的长宽都大
                            {
                                IntWidth = TargetWidth;
                                IntHeight = (IntWidth * _image.Height) / _image.Width;
                                if (IntHeight > TargetHeight)//重新计算
                                {
                                    IntHeight = TargetHeight;
                                    IntWidth = (IntHeight * _image.Width) / _image.Height;
                                }
                            }
                            g.DrawImage(_image,
                                (TargetWidth - IntWidth) / 2,
                                (TargetHeight - IntHeight) / 2,
                                IntWidth,
                                IntHeight);
                            break;
                    }                   
                    g.Dispose();
                }
            }
            else
            {
                PaintImage = null;
            }
        }
        public void RefreshImage()
        {
            int width = base.Width;
            base.Width = width + 1;
            width = base.Width;
            base.Width = width - 1;
        }

        public void ShowImage(bool audit)
        {
            if (audit)
            {
                this.Image = RwxFramework.Library.Properties.Resources.Audit;
            }
            else
            {
                this.Image = RwxFramework.Library.Properties.Resources.no;
            }
            this.RefreshImage();
        }

    }

    public enum ImageFillMode
    {
        Zoom,
        Title,
        Strength,
        Center
    }
}