xbutton.cs

破解的飞信源代码

namespace Imps.Client.Pc.Controls
{
    using Imps.Client.Pc;
    using Imps.Client.Pc.XControlStyle;
    using Imps.Client.Utils;
    using System;
    using System.Drawing;
    using System.Reflection;
    using System.Windows.Forms;

    public class XButton : Button
    {
        private bool _autoArrangementX = true;
        private bool _autoSizeToImage;
        private Image _backgroundImageDisable;
        private Image _backgroundImageDown;
        private Image _backgroundImageNormal;
        private Image _backgroundImgaeHover;
        private int _State;
        private static XButtonStyle _Style = new XButtonStyle();

        private Image getPaintImage()
        {
            Image backgroundImage = null;
            if (this.BackgroundImage == null)
            {
                backgroundImage = Style.Background.Images[this._State];
                if (!base.Enabled)
                {
                    backgroundImage = Style.Background.Images[3];
                }
                return backgroundImage;
            }
            switch (this._State)
            {
                case 0:
                    backgroundImage = this.BackgroundImage;
                    break;

                case 1:
                    backgroundImage = this.BackgroundImageHover;
                    break;

                case 2:
                    backgroundImage = this.BackgroundImageDown;
                    break;
            }
            if (!base.Enabled)
            {
                backgroundImage = this.BackgroundImageDisable;
            }
            if (backgroundImage == null)
            {
                backgroundImage = this.BackgroundImage;
            }
            return backgroundImage;
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);
            this.ResizeOnBackgroundImage();
            if (this.BackgroundImage == null)
            {
                Style.StyleChanged += new EventHandler(this.style_StyleChanged);
            }
        }

        protected override void OnHandleDestroyed(EventArgs e)
        {
            Style.StyleChanged -= new EventHandler(this.style_StyleChanged);
            base.OnHandleDestroyed(e);
        }

        protected override void OnMouseDown(MouseEventArgs mevent)
        {
            this._State = 2;
            base.OnMouseDown(mevent);
        }

        protected override void OnMouseEnter(EventArgs e)
        {
            this._State = 1;
            base.OnMouseEnter(e);
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            this._State = 0;
            base.OnMouseLeave(e);
        }

        protected override void OnMouseUp(MouseEventArgs mevent)
        {
            if (base.ClientRectangle.Contains(mevent.X, mevent.Y))
            {
                this._State = 1;
            }
            else
            {
                this._State = 0;
            }
            base.OnMouseUp(mevent);
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            if (Style.UseTheme)
            {
                this.OnPaintBackground(e);
                Image image = this.getPaintImage();
                ((Bitmap) image).MakeTransparent(Style.TransparentColor);
                if (base.ClientRectangle.Width > image.Width)
                {
                    Rectangle srcRect = Rectangle.FromLTRB(0, 0, image.Width / 2, image.Height);
                    Rectangle rectangle2 = new Rectangle(image.Width / 2, 0, 1, image.Height);
                    Rectangle rectangle3 = Rectangle.FromLTRB((image.Width / 2) + 1, 0, image.Width, image.Height);
                    Rectangle destRect = new Rectangle(base.ClientRectangle.Left, base.ClientRectangle.Top, srcRect.Width, base.Height);
                    Rectangle rectangle5 = new Rectangle(base.ClientRectangle.Width - rectangle3.Width, base.ClientRectangle.Top, rectangle3.Width, base.Height);
                    Rectangle rectangle6 = new Rectangle(destRect.Right, base.ClientRectangle.Top, (base.ClientRectangle.Width - rectangle5.Width) - destRect.Width, base.ClientRectangle.Bottom);
                    g.DrawImage(image, rectangle6, rectangle2, GraphicsUnit.Pixel);
                    g.DrawImage(image, destRect, srcRect, GraphicsUnit.Pixel);
                    g.DrawImage(image, rectangle5, rectangle3, GraphicsUnit.Pixel);
                }
                else
                {
                    int num = (((base.ClientRectangle.Width / 2) * 2) == base.ClientRectangle.Width) ? 0 : 1;
                    Rectangle rectangle7 = Rectangle.FromLTRB(0, 0, (base.ClientRectangle.Width / 2) + num, image.Height);
                    Rectangle rectangle8 = Rectangle.FromLTRB(image.Width - (base.ClientRectangle.Width / 2), 0, image.Width, image.Height);
                    Rectangle rectangle9 = new Rectangle(base.ClientRectangle.Left, base.ClientRectangle.Top, rectangle7.Width, base.Height);
                    Rectangle rectangle10 = new Rectangle(base.ClientRectangle.Width - rectangle8.Width, base.ClientRectangle.Top, rectangle8.Width, base.Height);
                    g.DrawImage(image, rectangle9, rectangle7, GraphicsUnit.Pixel);
                    g.DrawImage(image, rectangle10, rectangle8, GraphicsUnit.Pixel);
                }
                Rectangle rc = base.ClientRectangle;
                Rectangle rect = new Rectangle(0, 0, base.Height, base.Height);
                if (base.ImageAlign == ContentAlignment.MiddleCenter)
                {
                    rect.X = (base.Width - rect.Width) / 2;
                }
                else if (base.ImageAlign == ContentAlignment.MiddleRight)
                {
                    rect.X = base.Width - rect.Width;
                }
                if (this._State == 2)
                {
                    rect.Offset(1, 1);
                    rc.Offset(1, 1);
                }
                if (base.Image != null)
                {
                    if (base.Enabled)
                    {
                        Imps.Client.Pc.DrawHelper.DrawImage(g, rect, base.Image, 2);
                    }
                    else
                    {
                        Imps.Client.Pc.DrawHelper.DrawImageDisabled(g, rect, base.Image, 2);
                    }
                }
                if (this.BackgroundImage == null)
                {
                    Imps.Client.Pc.DrawHelper.DrawString(e.Graphics, this.Text, rc, Control.DefaultFont, new SolidBrush(Style.TextColor), StringAlignment.Center, base.Enabled);
                }
                else if (base.Enabled)
                {
                    Imps.Client.Pc.DrawHelper.DrawString(e.Graphics, this.Text, rc, this.Font, new SolidBrush(this.ForeColor), StringAlignment.Center, base.Enabled);
                }
                else
                {
                    Imps.Client.Pc.DrawHelper.DrawStringDisabled(e.Graphics, this.Text, rc, this.Font, StringAlignment.Center, this.ForeColor);
                }
                if (base.ContainsFocus)
                {
                    ControlPaint.DrawFocusRectangle(e.Graphics, new Rectangle(3, 3, base.Width - 6, base.Height - 6));
                }
            }
            else
            {
                base.OnPaint(e);
            }
        }

        private void ResizeOnBackgroundImage()
        {
            try
            {
                this.BackColor = Color.Transparent;
                if (this.BackgroundImage != null)
                {
                    if (this.AutoSizeToImage)
                    {
                        base.Size = this.BackgroundImage.Size;
                    }
                    else
                    {
                        base.Height = this.BackgroundImage.Height;
                    }
                }
                else if (Style.Background.Images.Count > 0)
                {
                    Image image = Style.Background.Images[0];
                    base.Height = image.Height;
                }
            }
            catch
            {
            }
        }

        private void style_StyleChanged(object sender, EventArgs e)
        {
            this.ResizeOnBackgroundImage();
            base.Invalidate();
        }

        public bool AutoArrangementX
        {
            get
            {
                return this._autoArrangementX;
            }
            set
            {
                this._autoArrangementX = value;
            }
        }

        public bool AutoSizeToImage
        {
            get
            {
                return this._autoSizeToImage;
            }
            set
            {
                this._autoSizeToImage = value;
            }
        }

        public Image BackgroundImage
        {
            get
            {
                return this._backgroundImageNormal;
            }
            set
            {
                this._backgroundImageNormal = value;
            }
        }

        public Image BackgroundImageDisable
        {
            get
            {
                return this._backgroundImageDisable;
            }
            set
            {
                this._backgroundImageDisable = value;
            }
        }

        public Image BackgroundImageDown
        {
            get
            {
                return this._backgroundImageDown;
            }
            set
            {
                this._backgroundImageDown = value;
            }
        }

        public Image BackgroundImageHover
        {
            get
            {
                return this._backgroundImgaeHover;
            }
            set
            {
                this._backgroundImgaeHover = value;
            }
        }

        public bool ChangeSkin
        {
            get
            {
                return (this.BackgroundImage == null);
            }
            set
            {
                if (!value)
                {
                    if (this.BackgroundImage == null)
                    {
                        Assembly asm = Assembly.GetAssembly(typeof(XButton));
                        this.BackgroundImage = ResourceHelper.GetResImage(asm, "Imps.Client.Pc.Resource.button_up.png");
                        this.BackgroundImageHover = ResourceHelper.GetResImage(asm, "Imps.Client.Pc.Resource.button_over.png");
                        this.BackgroundImageDown = ResourceHelper.GetResImage(asm, "Imps.Client.Pc.Resource.button_down.png");
                        this.BackgroundImageDisable = ResourceHelper.GetResImage(asm, "Imps.Client.Pc.Resource.button_dis.png");
                    }
                }
                else
                {
                    this.BackgroundImage = null;
                    this.BackgroundImageHover = null;
                    this.BackgroundImageDown = null;
                    this.BackgroundImageDisable = null;
                }
            }
        }

        public static XButtonStyle Style
        {
            get
            {
                return _Style;
            }
        }
    }
}