Ghosts Theme Converted to C#

using System;
using System.IO;
using System.Drawing;
using System.Diagnostics;
using System.Windows.Forms;
using System.ComponentModel;
using Microsoft.VisualBasic;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Runtime.InteropServices;

//---------/CREDITS/-----------
//
//Themebase creator: Aeonhack
//Site: elitevs.net
//Created: 08/02/2011
//Changed: 12/06/2011
//Version: 1.5.4
//
//Theme creator: Mavamaarten
//Created: 9/12/2011
//Changed: 3/03/2012
//Version: 2.0
//
//Thanks to Tedd for helping
//with combobox & tabcontrol!
//
//Converted to C# by: Ethernal Five
//On: 3/04/2012
//--------/CREDITS/------------

#region "THEMEBASE"
abstract class ThemeContainer154 : ContainerControl
{

    #region " Initialization "

    protected Graphics G;

    protected Bitmap B;
    public ThemeContainer154()
    {
        SetStyle((ControlStyles)139270, true);

        _ImageSize = Size.Empty;
        Font = new Font("Verdana", 8);

        MeasureBitmap = new Bitmap(1, 1);
        MeasureGraphics = Graphics.FromImage(MeasureBitmap);

        DrawRadialPath = new GraphicsPath();

        InvalidateCustimization();
    }

    protected override sealed void OnHandleCreated(EventArgs e)
    {
        if (DoneCreation)
            InitializeMessages();

        InvalidateCustimization();
        ColorHook();

        if (!(_LockWidth == 0))
            Width = _LockWidth;
        if (!(_LockHeight == 0))
            Height = _LockHeight;
        if (!_ControlMode)
            base.Dock = DockStyle.Fill;

        Transparent = _Transparent;
        if (_Transparent && _BackColor)
            BackColor = Color.Transparent;

        base.OnHandleCreated(e);
    }

    private bool DoneCreation;
    protected override sealed void OnParentChanged(EventArgs e)
    {
        base.OnParentChanged(e);

        if (Parent == null)
            return;
        _IsParentForm = Parent is Form;

        if (!_ControlMode)
        {
            InitializeMessages();

            if (_IsParentForm)
            {
                ParentForm.FormBorderStyle = _BorderStyle;
                ParentForm.TransparencyKey = _TransparencyKey;

                if (!DesignMode)
                {
                    ParentForm.Shown += FormShown;
                }
            }

            Parent.BackColor = BackColor;
        }

        OnCreation();
        DoneCreation = true;
        InvalidateTimer();
    }

    #endregion

    private void DoAnimation(bool i)
    {
        OnAnimation();
        if (i)
            Invalidate();
    }

    protected override sealed void OnPaint(PaintEventArgs e)
    {
        if (Width == 0 || Height == 0)
            return;

        if (_Transparent && _ControlMode)
        {
            PaintHook();
            e.Graphics.DrawImage(B, 0, 0);
        }
        else
        {
            G = e.Graphics;
            PaintHook();
        }
    }

    protected override void OnHandleDestroyed(EventArgs e)
    {
        ThemeShare.RemoveAnimationCallback(DoAnimation);
        base.OnHandleDestroyed(e);
    }

    private bool HasShown;
    private void FormShown(object sender, EventArgs e)
    {
        if (_ControlMode || HasShown)
            return;

        if (_StartPosition == FormStartPosition.CenterParent || _StartPosition == FormStartPosition.CenterScreen)
        {
            Rectangle SB = Screen.PrimaryScreen.Bounds;
            Rectangle CB = ParentForm.Bounds;
            ParentForm.Location = new Point(SB.Width / 2 - CB.Width / 2, SB.Height / 2 - CB.Width / 2);
        }

        HasShown = true;
    }


    #region " Size Handling "

    private Rectangle Frame;
    protected override sealed void OnSizeChanged(EventArgs e)
    {
        if (_Movable && !_ControlMode)
        {
            Frame = new Rectangle(7, 7, Width - 14, _Header - 7);
        }

        InvalidateBitmap();
        Invalidate();

        base.OnSizeChanged(e);
    }

    protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
    {
        if (!(_LockWidth == 0))
            width = _LockWidth;
        if (!(_LockHeight == 0))
            height = _LockHeight;
        base.SetBoundsCore(x, y, width, height, specified);
    }

    #endregion

    #region " State Handling "

    protected MouseState State;
    private void SetState(MouseState current)
    {
        State = current;
        Invalidate();
    }

    protected override void OnMouseMove(MouseEventArgs e)
    {
        if (!(_IsParentForm && ParentForm.WindowState == FormWindowState.Maximized))
        {
            if (_Sizable && !_ControlMode)
                InvalidateMouse();
        }

        base.OnMouseMove(e);
    }

    protected override void OnEnabledChanged(EventArgs e)
    {
        if (Enabled)
            SetState(MouseState.None);
        else
            SetState(MouseState.Block);
        base.OnEnabledChanged(e);
    }

    protected override void OnMouseEnter(EventArgs e)
    {
        SetState(MouseState.Over);
        base.OnMouseEnter(e);
    }

    protected override void OnMouseUp(MouseEventArgs e)
    {
        SetState(MouseState.Over);
        base.OnMouseUp(e);
    }

    protected override void OnMouseLeave(EventArgs e)
    {
        SetState(MouseState.None);

        if (GetChildAtPoint(PointToClient(MousePosition)) != null)
        {
            if (_Sizable && !_ControlMode)
            {
                Cursor = Cursors.Default;
                Previous = 0;
            }
        }

        base.OnMouseLeave(e);
    }

    protected override void OnMouseDown(MouseEventArgs e)
    {
        if (e.Button == System.Windows.Forms.MouseButtons.Left)
            SetState(MouseState.Down);

        if (!(_IsParentForm && ParentForm.WindowState == FormWindowState.Maximized || _ControlMode))
        {
            if (_Movable && Frame.Contains(e.Location))
            {
                Capture = false;
                WM_LMBUTTONDOWN = true;
                DefWndProc(ref Messages[0]);
            }
            else if (_Sizable && !(Previous == 0))
            {
                Capture = false;
                WM_LMBUTTONDOWN = true;
                DefWndProc(ref Messages[Previous]);
            }
        }

        base.OnMouseDown(e);
    }

    private bool WM_LMBUTTONDOWN;
    protected override void WndProc(ref Message m)
    {
        base.WndProc(ref m);

        if (WM_LMBUTTONDOWN && m.Msg == 513)
        {
            WM_LMBUTTONDOWN = false;

            SetState(MouseState.Over);
            if (!_SmartBounds)
                return;

            if (IsParentMdi)
            {
                CorrectBounds(new Rectangle(Point.Empty, Parent.Parent.Size));
            }
            else
            {
                CorrectBounds(Screen.FromControl(Parent).WorkingArea);
            }
        }
    }

    private Point GetIndexPoint;
    private bool B1;
    private bool B2;
    private bool B3;
    private bool B4;
    private int GetIndex()
    {
        GetIndexPoint = PointToClient(MousePosition);
        B1 = GetIndexPoint.X < 7;
        B2 = GetIndexPoint.X > Width - 7;
        B3 = GetIndexPoint.Y < 7;
        B4 = GetIndexPoint.Y > Height - 7;

        if (B1 && B3)
            return 4;
        if (B1 && B4)
            return 7;
        if (B2 && B3)
            return 5;
        if (B2 && B4)
            return 8;
        if (B1)
            return 1;
        if (B2)
            return 2;
        if (B3)
            return 3;
        if (B4)
            return 6;
        return 0;
    }

    private int Current;
    private int Previous;
    private void InvalidateMouse()
    {
        Current = GetIndex();
        if (Current == Previous)
            return;

        Previous = Current;
        switch (Previous)
        {
            case 0:
                Cursor = Cursors.Default;
                break;
            case 1:
            case 2:
                Cursor = Cursors.SizeWE;
                break;
            case 3:
            case 6:
                Cursor = Cursors.SizeNS;
                break;
            case 4:
            case 8:
                Cursor = Cursors.SizeNWSE;
                break;
            case 5:
            case 7:
                Cursor = Cursors.SizeNESW;
                break;
        }
    }

    private Message[] Messages = new Message[9];
    private void InitializeMessages()
    {
        Messages[0] = Message.Create(Parent.Handle, 161, new IntPtr(2), IntPtr.Zero);
        for (int I = 1; I <= 8; I++)
        {
            Messages[I] = Message.Create(Parent.Handle, 161, new IntPtr(I + 9), IntPtr.Zero);
        }
    }

    private void CorrectBounds(Rectangle bounds)
    {
        if (Parent.Width > bounds.Width)
            Parent.Width = bounds.Width;
        if (Parent.Height > bounds.Height)
            Parent.Height = bounds.Height;

        int X = Parent.Location.X;
        int Y = Parent.Location.Y;

        if (X < bounds.X)
            X = bounds.X;
        if (Y < bounds.Y)
            Y = bounds.Y;

        int Width = bounds.X + bounds.Width;
        int Height = bounds.Y + bounds.Height;

        if (X + Parent.Width > Width)
            X = Width - Parent.Width;
        if (Y + Parent.Height > Height)
            Y = Height - Parent.Height;

        Parent.Location = new Point(X, Y);
    }

    #endregion


    #region " Base Properties "

    public override DockStyle Dock
    {
        get { return base.Dock; }
        set
        {
            if (!_ControlMode)
                return;
            base.Dock = value;
        }
    }

    private bool _BackColor;
    [Category("Misc")]
    public override Color BackColor
    {
        get { return base.BackColor; }
        set
        {
            if (value == base.BackColor)
                return;

            if (!IsHandleCreated && _ControlMode && value == Color.Transparent)
            {
                _BackColor = true;
                return;
            }

            base.BackColor = value;
            if (Parent != null)
            {
                if (!_ControlMode)
                    Parent.BackColor = value;
                ColorHook();
            }
        }
    }

    public override Size MinimumSize
    {
        get { return base.MinimumSize; }
        set
        {
            base.MinimumSize = value;
            if (Parent != null)
                Parent.MinimumSize = value;
        }
    }

    public override Size MaximumSize
    {
        get { return base.MaximumSize; }
        set
        {
            base.MaximumSize = value;
            if (Parent != null)
                Parent.MaximumSize = value;
        }
    }

    public override string Text
    {
        get { return base.Text; }
        set
        {
            base.Text = value;
            Invalidate();
        }
    }

    public override Font Font
    {
        get { return base.Font; }
        set
        {
            base.Font = value;
            Invalidate();
        }
    }

    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public override Color ForeColor
    {
        get { return Color.Empty; }
        set { }
    }
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public override Image BackgroundImage
    {
        get { return null; }
        set { }
    }
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public override ImageLayout BackgroundImageLayout
    {
        get { return ImageLayout.None; }
        set { }
    }

    #endregion

    #region " Public Properties "

    private bool _SmartBounds = true;
    public bool SmartBounds
    {
        get { return _SmartBounds; }
        set { _SmartBounds = value; }
    }

    private bool _Movable = true;
    public bool Movable
    {
        get { return _Movable; }
        set { _Movable = value; }
    }

    private bool _Sizable = true;
    public bool Sizable
    {
        get { return _Sizable; }
        set { _Sizable = value; }
    }

    private Color _TransparencyKey;
    public Color TransparencyKey
    {
        get
        {
            if (_IsParentForm && !_ControlMode)
                return ParentForm.TransparencyKey;
            else
                return _TransparencyKey;
        }
        set
        {
            if (value == _TransparencyKey)
                return;
            _TransparencyKey = value;

            if (_IsParentForm && !_ControlMode)
            {
                ParentForm.TransparencyKey = value;
                ColorHook();
            }
        }
    }

    private FormBorderStyle _BorderStyle;
    public FormBorderStyle BorderStyle
    {
        get
        {
            if (_IsParentForm && !_ControlMode)
                return ParentForm.FormBorderStyle;
            else
                return _BorderStyle;
        }
        set
        {
            _BorderStyle = value;

            if (_IsParentForm && !_ControlMode)
            {
                ParentForm.FormBorderStyle = value;

                if (!(value == FormBorderStyle.None))
                {
                    Movable = false;
                    Sizable = false;
                }
            }
        }
    }

    private FormStartPosition _StartPosition;
    public FormStartPosition StartPosition
    {
        get
        {
            if (_IsParentForm && !_ControlMode)
                return ParentForm.StartPosition;
            else
                return _StartPosition;
        }
        set
        {
            _StartPosition = value;

            if (_IsParentForm && !_ControlMode)
            {
                ParentForm.StartPosition = value;
            }
        }
    }

    private bool _NoRounding;
    public bool NoRounding
    {
        get { return _NoRounding; }
        set
        {
            _NoRounding = value;
            Invalidate();
        }
    }

    private Image _Image;
    public Image Image
    {
        get { return _Image; }
        set
        {
            if (value == null)
                _ImageSize = Size.Empty;
            else
                _ImageSize = value.Size;

            _Image = value;
            Invalidate();
        }
    }

    private Dictionary<string, Color> Items = new Dictionary<string, Color>();
    public Bloom[] Colors
    {
        get
        {
            List<Bloom> T = new List<Bloom>();
            Dictionary<string, Color>.Enumerator E = Items.GetEnumerator();

            while (E.MoveNext())
            {
                T.Add(new Bloom(E.Current.Key, E.Current.Value));
            }

            return T.ToArray();
        }
        set
        {
            foreach (Bloom B in value)
            {
                if (Items.ContainsKey(B.Name))
                    Items[B.Name] = B.Value;
            }

            InvalidateCustimization();
            ColorHook();
            Invalidate();
        }
    }

    private string _Customization;
    public string Customization
    {
        get { return _Customization; }
        set
        {
            if (value == _Customization)
                return;

            byte[] Data = null;
            Bloom[] Items = Colors;

            try
            {
                Data = Convert.FromBase64String(value);
                for (int I = 0; I <= Items.Length - 1; I++)
                {
                    Items[I].Value = Color.FromArgb(BitConverter.ToInt32(Data, I * 4));
                }
            }
            catch
            {
                return;
            }

            _Customization = value;

            Colors = Items;
            ColorHook();
            Invalidate();
        }
    }

    private bool _Transparent;
    public bool Transparent
    {
        get { return _Transparent; }
        set
        {
            _Transparent = value;
            if (!(IsHandleCreated || _ControlMode))
                return;

            if (!value && !(BackColor.A == 255))
            {
                throw new Exception("Unable to change value to false while a transparent BackColor is in use.");
            }

            SetStyle(ControlStyles.Opaque, !value);
            SetStyle(ControlStyles.SupportsTransparentBackColor, value);

            InvalidateBitmap();
            Invalidate();
        }
    }

    #endregion

    #region " Private Properties "

    private Size _ImageSize;
    protected Size ImageSize
    {
        get { return _ImageSize; }
    }

    private bool _IsParentForm;
    protected bool IsParentForm
    {
        get { return _IsParentForm; }
    }

    protected bool IsParentMdi
    {
        get
        {
            if (Parent == null)
                return false;
            return Parent.Parent != null;
        }
    }

    private int _LockWidth;
    protected int LockWidth
    {
        get { return _LockWidth; }
        set
        {
            _LockWidth = value;
            if (!(LockWidth == 0) && IsHandleCreated)
                Width = LockWidth;
        }
    }

    private int _LockHeight;
    protected int LockHeight
    {
        get { return _LockHeight; }
        set
        {
            _LockHeight = value;
            if (!(LockHeight == 0) && IsHandleCreated)
                Height = LockHeight;
        }
    }

    private int _Header = 24;
    protected int Header
    {
        get { return _Header; }
        set
        {
            _Header = value;

            if (!_ControlMode)
            {
                Frame = new Rectangle(7, 7, Width - 14, value - 7);
                Invalidate();
            }
        }
    }

    private bool _ControlMode;
    protected bool ControlMode
    {
        get { return _ControlMode; }
        set
        {
            _ControlMode = value;

            Transparent = _Transparent;
            if (_Transparent && _BackColor)
                BackColor = Color.Transparent;

            InvalidateBitmap();
            Invalidate();
        }
    }

    private bool _IsAnimated;
    protected bool IsAnimated
    {
        get { return _IsAnimated; }
        set
        {
            _IsAnimated = value;
            InvalidateTimer();
        }
    }

    #endregion


    #region " Property Helpers "

    protected Pen GetPen(string name)
    {
        return new Pen(Items[name]);
    }
    protected Pen GetPen(string name, float width)
    {
        return new Pen(Items[name], width);
    }

    protected SolidBrush GetBrush(string name)
    {
        return new SolidBrush(Items[name]);
    }

    protected Color GetColor(string name)
    {
        return Items[name];
    }

    protected void SetColor(string name, Color value)
    {
        if (Items.ContainsKey(name))
            Items[name] = value;
        else
            Items.Add(name, value);
    }
    protected void SetColor(string name, byte r, byte g, byte b)
    {
        SetColor(name, Color.FromArgb(r, g, b));
    }
    protected void SetColor(string name, byte a, byte r, byte g, byte b)
    {
        SetColor(name, Color.FromArgb(a, r, g, b));
    }
    protected void SetColor(string name, byte a, Color value)
    {
        SetColor(name, Color.FromArgb(a, value));
    }

    private void InvalidateBitmap()
    {
        if (_Transparent && _ControlMode)
        {
            if (Width == 0 || Height == 0)
                return;
            B = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
            G = Graphics.FromImage(B);
        }
        else
        {
            G = null;
            B = null;
        }
    }

    private void InvalidateCustimization()
    {
        MemoryStream M = new MemoryStream(Items.Count * 4);

        foreach (Bloom B in Colors)
        {
            M.Write(BitConverter.GetBytes(B.Value.ToArgb()), 0, 4);
        }

        M.Close();
        _Customization = Convert.ToBase64String(M.ToArray());
    }

    private void InvalidateTimer()
    {
        if (DesignMode || !DoneCreation)
            return;

        if (_IsAnimated)
        {
            ThemeShare.AddAnimationCallback(DoAnimation);
        }
        else
        {
            ThemeShare.RemoveAnimationCallback(DoAnimation);
        }
    }

    #endregion


    #region " User Hooks "

    protected abstract void ColorHook();
    protected abstract void PaintHook();

    protected virtual void OnCreation()
    {
    }

    protected virtual void OnAnimation()
    {
    }

    #endregion


    #region " Offset "

    private Rectangle OffsetReturnRectangle;
    protected Rectangle Offset(Rectangle r, int amount)
    {
        OffsetReturnRectangle = new Rectangle(r.X + amount, r.Y + amount, r.Width - (amount * 2), r.Height - (amount * 2));
        return OffsetReturnRectangle;
    }

    private Size OffsetReturnSize;
    protected Size Offset(Size s, int amount)
    {
        OffsetReturnSize = new Size(s.Width + amount, s.Height + amount);
        return OffsetReturnSize;
    }

    private Point OffsetReturnPoint;
    protected Point Offset(Point p, int amount)
    {
        OffsetReturnPoint = new Point(p.X + amount, p.Y + amount);
        return OffsetReturnPoint;
    }

    #endregion

    #region " Center "


    private Point CenterReturn;
    protected Point Center(Rectangle p, Rectangle c)
    {
        CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X + c.X, (p.Height / 2 - c.Height / 2) + p.Y + c.Y);
        return CenterReturn;
    }
    protected Point Center(Rectangle p, Size c)
    {
        CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X, (p.Height / 2 - c.Height / 2) + p.Y);
        return CenterReturn;
    }

    protected Point Center(Rectangle child)
    {
        return Center(Width, Height, child.Width, child.Height);
    }
    protected Point Center(Size child)
    {
        return Center(Width, Height, child.Width, child.Height);
    }
    protected Point Center(int childWidth, int childHeight)
    {
        return Center(Width, Height, childWidth, childHeight);
    }

    protected Point Center(Size p, Size c)
    {
        return Center(p.Width, p.Height, c.Width, c.Height);
    }

    protected Point Center(int pWidth, int pHeight, int cWidth, int cHeight)
    {
        CenterReturn = new Point(pWidth / 2 - cWidth / 2, pHeight / 2 - cHeight / 2);
        return CenterReturn;
    }

    #endregion

    #region " Measure "

    private Bitmap MeasureBitmap;

    private Graphics MeasureGraphics;
    protected Size Measure()
    {
        lock (MeasureGraphics)
        {
            return MeasureGraphics.MeasureString(Text, Font, Width).ToSize();
        }
    }
    protected Size Measure(string text)
    {
        lock (MeasureGraphics)
        {
            return MeasureGraphics.MeasureString(text, Font, Width).ToSize();
        }
    }

    #endregion


    #region " DrawPixel "


    private SolidBrush DrawPixelBrush;
    protected void DrawPixel(Color c1, int x, int y)
    {
        if (_Transparent)
        {
            B.SetPixel(x, y, c1);
        }
        else
        {
            DrawPixelBrush = new SolidBrush(c1);
            G.FillRectangle(DrawPixelBrush, x, y, 1, 1);
        }
    }

    #endregion

    #region " DrawCorners "


    private SolidBrush DrawCornersBrush;
    protected void DrawCorners(Color c1, int offset)
    {
        DrawCorners(c1, 0, 0, Width, Height, offset);
    }
    protected void DrawCorners(Color c1, Rectangle r1, int offset)
    {
        DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height, offset);
    }
    protected void DrawCorners(Color c1, int x, int y, int width, int height, int offset)
    {
        DrawCorners(c1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
    }

    protected void DrawCorners(Color c1)
    {
        DrawCorners(c1, 0, 0, Width, Height);
    }
    protected void DrawCorners(Color c1, Rectangle r1)
    {
        DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height);
    }
    protected void DrawCorners(Color c1, int x, int y, int width, int height)
    {
        if (_NoRounding)
            return;

        if (_Transparent)
        {
            B.SetPixel(x, y, c1);
            B.SetPixel(x + (width - 1), y, c1);
            B.SetPixel(x, y + (height - 1), c1);
            B.SetPixel(x + (width - 1), y + (height - 1), c1);
        }
        else
        {
            DrawCornersBrush = new SolidBrush(c1);
            G.FillRectangle(DrawCornersBrush, x, y, 1, 1);
            G.FillRectangle(DrawCornersBrush, x + (width - 1), y, 1, 1);
            G.FillRectangle(DrawCornersBrush, x, y + (height - 1), 1, 1);
            G.FillRectangle(DrawCornersBrush, x + (width - 1), y + (height - 1), 1, 1);
        }
    }

    #endregion

    #region " DrawBorders "

    protected void DrawBorders(Pen p1, int offset)
    {
        DrawBorders(p1, 0, 0, Width, Height, offset);
    }
    protected void DrawBorders(Pen p1, Rectangle r, int offset)
    {
        DrawBorders(p1, r.X, r.Y, r.Width, r.Height, offset);
    }
    protected void DrawBorders(Pen p1, int x, int y, int width, int height, int offset)
    {
        DrawBorders(p1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
    }

    protected void DrawBorders(Pen p1)
    {
        DrawBorders(p1, 0, 0, Width, Height);
    }
    protected void DrawBorders(Pen p1, Rectangle r)
    {
        DrawBorders(p1, r.X, r.Y, r.Width, r.Height);
    }
    protected void DrawBorders(Pen p1, int x, int y, int width, int height)
    {
        G.DrawRectangle(p1, x, y, width - 1, height - 1);
    }

    #endregion

    #region " DrawText "

    private Point DrawTextPoint;

    private Size DrawTextSize;
    protected void DrawText(Brush b1, HorizontalAlignment a, int x, int y)
    {
        DrawText(b1, Text, a, x, y);
    }
    protected void DrawText(Brush b1, string text, HorizontalAlignment a, int x, int y)
    {
        if (text.Length == 0)
            return;

        DrawTextSize = Measure(text);
        DrawTextPoint = new Point(Width / 2 - DrawTextSize.Width / 2, Header / 2 - DrawTextSize.Height / 2);

        switch (a)
        {
            case HorizontalAlignment.Left:
                G.DrawString(text, Font, b1, x, DrawTextPoint.Y + y);
                break;
            case HorizontalAlignment.Center:
                G.DrawString(text, Font, b1, DrawTextPoint.X + x, DrawTextPoint.Y + y);
                break;
            case HorizontalAlignment.Right:
                G.DrawString(text, Font, b1, Width - DrawTextSize.Width - x, DrawTextPoint.Y + y);
                break;
        }
    }

    protected void DrawText(Brush b1, Point p1)
    {
        if (Text.Length == 0)
            return;
        G.DrawString(Text, Font, b1, p1);
    }
    protected void DrawText(Brush b1, int x, int y)
    {
        if (Text.Length == 0)
            return;
        G.DrawString(Text, Font, b1, x, y);
    }

    #endregion

    #region " DrawImage "


    private Point DrawImagePoint;
    protected void DrawImage(HorizontalAlignment a, int x, int y)
    {
        DrawImage(_Image, a, x, y);
    }
    protected void DrawImage(Image image, HorizontalAlignment a, int x, int y)
    {
        if (image == null)
            return;
        DrawImagePoint = new Point(Width / 2 - image.Width / 2, Header / 2 - image.Height / 2);

        switch (a)
        {
            case HorizontalAlignment.Left:
                G.DrawImage(image, x, DrawImagePoint.Y + y, image.Width, image.Height);
                break;
            case HorizontalAlignment.Center:
                G.DrawImage(image, DrawImagePoint.X + x, DrawImagePoint.Y + y, image.Width, image.Height);
                break;
            case HorizontalAlignment.Right:
                G.DrawImage(image, Width - image.Width - x, DrawImagePoint.Y + y, image.Width, image.Height);
                break;
        }
    }

    protected void DrawImage(Point p1)
    {
        DrawImage(_Image, p1.X, p1.Y);
    }
    protected void DrawImage(int x, int y)
    {
        DrawImage(_Image, x, y);
    }

    protected void DrawImage(Image image, Point p1)
    {
        DrawImage(image, p1.X, p1.Y);
    }
    protected void DrawImage(Image image, int x, int y)
    {
        if (image == null)
            return;
        G.DrawImage(image, x, y, image.Width, image.Height);
    }

    #endregion

    #region " DrawGradient "

    private LinearGradientBrush DrawGradientBrush;

    private Rectangle DrawGradientRectangle;
    protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(blend, DrawGradientRectangle);
    }
    protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height, float angle)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(blend, DrawGradientRectangle, angle);
    }

    protected void DrawGradient(ColorBlend blend, Rectangle r)
    {
        DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, 90f);
        DrawGradientBrush.InterpolationColors = blend;
        G.FillRectangle(DrawGradientBrush, r);
    }
    protected void DrawGradient(ColorBlend blend, Rectangle r, float angle)
    {
        DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, angle);
        DrawGradientBrush.InterpolationColors = blend;
        G.FillRectangle(DrawGradientBrush, r);
    }


    protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(c1, c2, DrawGradientRectangle);
    }
    protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height, float angle)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(c1, c2, DrawGradientRectangle, angle);
    }

    protected void DrawGradient(Color c1, Color c2, Rectangle r)
    {
        DrawGradientBrush = new LinearGradientBrush(r, c1, c2, 90f);
        G.FillRectangle(DrawGradientBrush, r);
    }
    protected void DrawGradient(Color c1, Color c2, Rectangle r, float angle)
    {
        DrawGradientBrush = new LinearGradientBrush(r, c1, c2, angle);
        G.FillRectangle(DrawGradientBrush, r);
    }

    #endregion

    #region " DrawRadial "

    private GraphicsPath DrawRadialPath;
    private PathGradientBrush DrawRadialBrush1;
    private LinearGradientBrush DrawRadialBrush2;

    private Rectangle DrawRadialRectangle;
    public void DrawRadial(ColorBlend blend, int x, int y, int width, int height)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(blend, DrawRadialRectangle, width / 2, height / 2);
    }
    public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, Point center)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(blend, DrawRadialRectangle, center.X, center.Y);
    }
    public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, int cx, int cy)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(blend, DrawRadialRectangle, cx, cy);
    }

    public void DrawRadial(ColorBlend blend, Rectangle r)
    {
        DrawRadial(blend, r, r.Width / 2, r.Height / 2);
    }
    public void DrawRadial(ColorBlend blend, Rectangle r, Point center)
    {
        DrawRadial(blend, r, center.X, center.Y);
    }
    public void DrawRadial(ColorBlend blend, Rectangle r, int cx, int cy)
    {
        DrawRadialPath.Reset();
        DrawRadialPath.AddEllipse(r.X, r.Y, r.Width - 1, r.Height - 1);

        DrawRadialBrush1 = new PathGradientBrush(DrawRadialPath);
        DrawRadialBrush1.CenterPoint = new Point(r.X + cx, r.Y + cy);
        DrawRadialBrush1.InterpolationColors = blend;

        if (G.SmoothingMode == SmoothingMode.AntiAlias)
        {
            G.FillEllipse(DrawRadialBrush1, r.X + 1, r.Y + 1, r.Width - 3, r.Height - 3);
        }
        else
        {
            G.FillEllipse(DrawRadialBrush1, r);
        }
    }


    protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(c1, c2, DrawGradientRectangle);
    }
    protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height, float angle)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(c1, c2, DrawGradientRectangle, angle);
    }

    protected void DrawRadial(Color c1, Color c2, Rectangle r)
    {
        DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, 90f);
        G.FillRectangle(DrawGradientBrush, r);
    }
    protected void DrawRadial(Color c1, Color c2, Rectangle r, float angle)
    {
        DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, angle);
        G.FillEllipse(DrawGradientBrush, r);
    }

    #endregion

    #region " CreateRound "

    private GraphicsPath CreateRoundPath;

    private Rectangle CreateRoundRectangle;
    public GraphicsPath CreateRound(int x, int y, int width, int height, int slope)
    {
        CreateRoundRectangle = new Rectangle(x, y, width, height);
        return CreateRound(CreateRoundRectangle, slope);
    }

    public GraphicsPath CreateRound(Rectangle r, int slope)
    {
        CreateRoundPath = new GraphicsPath(FillMode.Winding);
        CreateRoundPath.AddArc(r.X, r.Y, slope, slope, 180f, 90f);
        CreateRoundPath.AddArc(r.Right - slope, r.Y, slope, slope, 270f, 90f);
        CreateRoundPath.AddArc(r.Right - slope, r.Bottom - slope, slope, slope, 0f, 90f);
        CreateRoundPath.AddArc(r.X, r.Bottom - slope, slope, slope, 90f, 90f);
        CreateRoundPath.CloseFigure();
        return CreateRoundPath;
    }

    #endregion

}

abstract class ThemeControl154 : Control
{


    #region " Initialization "

    protected Graphics G;

    protected Bitmap B;
    public ThemeControl154()
    {
        SetStyle((ControlStyles)139270, true);

        _ImageSize = Size.Empty;
        Font = new Font("Verdana", 8);

        MeasureBitmap = new Bitmap(1, 1);
        MeasureGraphics = Graphics.FromImage(MeasureBitmap);

        DrawRadialPath = new GraphicsPath();

        InvalidateCustimization();
        //Remove?
    }

    protected override sealed void OnHandleCreated(EventArgs e)
    {
        InvalidateCustimization();
        ColorHook();

        if (!(_LockWidth == 0))
            Width = _LockWidth;
        if (!(_LockHeight == 0))
            Height = _LockHeight;

        Transparent = _Transparent;
        if (_Transparent && _BackColor)
            BackColor = Color.Transparent;

        base.OnHandleCreated(e);
    }

    private bool DoneCreation;
    protected override sealed void OnParentChanged(EventArgs e)
    {
        if (Parent != null)
        {
            OnCreation();
            DoneCreation = true;
            InvalidateTimer();
        }

        base.OnParentChanged(e);
    }

    #endregion

    private void DoAnimation(bool i)
    {
        OnAnimation();
        if (i)
            Invalidate();
    }

    protected override sealed void OnPaint(PaintEventArgs e)
    {
        if (Width == 0 || Height == 0)
            return;

        if (_Transparent)
        {
            PaintHook();
            e.Graphics.DrawImage(B, 0, 0);
        }
        else
        {
            G = e.Graphics;
            PaintHook();
        }
    }

    protected override void OnHandleDestroyed(EventArgs e)
    {
        ThemeShare.RemoveAnimationCallback(DoAnimation);
        base.OnHandleDestroyed(e);
    }

    #region " Size Handling "

    protected override sealed void OnSizeChanged(EventArgs e)
    {
        if (_Transparent)
        {
            InvalidateBitmap();
        }

        Invalidate();
        base.OnSizeChanged(e);
    }

    protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
    {
        if (!(_LockWidth == 0))
            width = _LockWidth;
        if (!(_LockHeight == 0))
            height = _LockHeight;
        base.SetBoundsCore(x, y, width, height, specified);
    }

    #endregion

    #region " State Handling "

    private bool InPosition;
    protected override void OnMouseEnter(EventArgs e)
    {
        InPosition = true;
        SetState(MouseState.Over);
        base.OnMouseEnter(e);
    }

    protected override void OnMouseUp(MouseEventArgs e)
    {
        if (InPosition)
            SetState(MouseState.Over);
        base.OnMouseUp(e);
    }

    protected override void OnMouseDown(MouseEventArgs e)
    {
        if (e.Button == System.Windows.Forms.MouseButtons.Left)
            SetState(MouseState.Down);
        base.OnMouseDown(e);
    }

    protected override void OnMouseLeave(EventArgs e)
    {
        InPosition = false;
        SetState(MouseState.None);
        base.OnMouseLeave(e);
    }

    protected override void OnEnabledChanged(EventArgs e)
    {
        if (Enabled)
            SetState(MouseState.None);
        else
            SetState(MouseState.Block);
        base.OnEnabledChanged(e);
    }

    protected MouseState State;
    private void SetState(MouseState current)
    {
        State = current;
        Invalidate();
    }

    #endregion


    #region " Base Properties "

    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public override Color ForeColor
    {
        get { return Color.Empty; }
        set { }
    }
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public override Image BackgroundImage
    {
        get { return null; }
        set { }
    }
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public override ImageLayout BackgroundImageLayout
    {
        get { return ImageLayout.None; }
        set { }
    }

    public override string Text
    {
        get { return base.Text; }
        set
        {
            base.Text = value;
            Invalidate();
        }
    }
    public override Font Font
    {
        get { return base.Font; }
        set
        {
            base.Font = value;
            Invalidate();
        }
    }

    private bool _BackColor;
    [Category("Misc")]
    public override Color BackColor
    {
        get { return base.BackColor; }
        set
        {
            if (!IsHandleCreated && value == Color.Transparent)
            {
                _BackColor = true;
                return;
            }

            base.BackColor = value;
            if (Parent != null)
                ColorHook();
        }
    }

    #endregion

    #region " Public Properties "

    private bool _NoRounding;
    public bool NoRounding
    {
        get { return _NoRounding; }
        set
        {
            _NoRounding = value;
            Invalidate();
        }
    }

    private Image _Image;
    public Image Image
    {
        get { return _Image; }
        set
        {
            if (value == null)
            {
                _ImageSize = Size.Empty;
            }
            else
            {
                _ImageSize = value.Size;
            }

            _Image = value;
            Invalidate();
        }
    }

    private bool _Transparent;
    public bool Transparent
    {
        get { return _Transparent; }
        set
        {
            _Transparent = value;
            if (!IsHandleCreated)
                return;

            if (!value && !(BackColor.A == 255))
            {
                throw new Exception("Unable to change value to false while a transparent BackColor is in use.");
            }

            SetStyle(ControlStyles.Opaque, !value);
            SetStyle(ControlStyles.SupportsTransparentBackColor, value);

            if (value)
                InvalidateBitmap();
            else
                B = null;
            Invalidate();
        }
    }

    private Dictionary<string, Color> Items = new Dictionary<string, Color>();
    public Bloom[] Colors
    {
        get
        {
            List<Bloom> T = new List<Bloom>();
            Dictionary<string, Color>.Enumerator E = Items.GetEnumerator();

            while (E.MoveNext())
            {
                T.Add(new Bloom(E.Current.Key, E.Current.Value));
            }

            return T.ToArray();
        }
        set
        {
            foreach (Bloom B in value)
            {
                if (Items.ContainsKey(B.Name))
                    Items[B.Name] = B.Value;
            }

            InvalidateCustimization();
            ColorHook();
            Invalidate();
        }
    }

    private string _Customization;
    public string Customization
    {
        get { return _Customization; }
        set
        {
            if (value == _Customization)
                return;

            byte[] Data = null;
            Bloom[] Items = Colors;

            try
            {
                Data = Convert.FromBase64String(value);
                for (int I = 0; I <= Items.Length - 1; I++)
                {
                    Items[I].Value = Color.FromArgb(BitConverter.ToInt32(Data, I * 4));
                }
            }
            catch
            {
                return;
            }

            _Customization = value;

            Colors = Items;
            ColorHook();
            Invalidate();
        }
    }

    #endregion

    #region " Private Properties "

    private Size _ImageSize;
    protected Size ImageSize
    {
        get { return _ImageSize; }
    }

    private int _LockWidth;
    protected int LockWidth
    {
        get { return _LockWidth; }
        set
        {
            _LockWidth = value;
            if (!(LockWidth == 0) && IsHandleCreated)
                Width = LockWidth;
        }
    }

    private int _LockHeight;
    protected int LockHeight
    {
        get { return _LockHeight; }
        set
        {
            _LockHeight = value;
            if (!(LockHeight == 0) && IsHandleCreated)
                Height = LockHeight;
        }
    }

    private bool _IsAnimated;
    protected bool IsAnimated
    {
        get { return _IsAnimated; }
        set
        {
            _IsAnimated = value;
            InvalidateTimer();
        }
    }

    #endregion


    #region " Property Helpers "

    protected Pen GetPen(string name)
    {
        return new Pen(Items[name]);
    }
    protected Pen GetPen(string name, float width)
    {
        return new Pen(Items[name], width);
    }

    protected SolidBrush GetBrush(string name)
    {
        return new SolidBrush(Items[name]);
    }

    protected Color GetColor(string name)
    {
        return Items[name];
    }

    protected void SetColor(string name, Color value)
    {
        if (Items.ContainsKey(name))
            Items[name] = value;
        else
            Items.Add(name, value);
    }
    protected void SetColor(string name, byte r, byte g, byte b)
    {
        SetColor(name, Color.FromArgb(r, g, b));
    }
    protected void SetColor(string name, byte a, byte r, byte g, byte b)
    {
        SetColor(name, Color.FromArgb(a, r, g, b));
    }
    protected void SetColor(string name, byte a, Color value)
    {
        SetColor(name, Color.FromArgb(a, value));
    }

    private void InvalidateBitmap()
    {
        if (Width == 0 || Height == 0)
            return;
        B = new Bitmap(Width, Height, PixelFormat.Format32bppPArgb);
        G = Graphics.FromImage(B);
    }

    private void InvalidateCustimization()
    {
        MemoryStream M = new MemoryStream(Items.Count * 4);

        foreach (Bloom B in Colors)
        {
            M.Write(BitConverter.GetBytes(B.Value.ToArgb()), 0, 4);
        }

        M.Close();
        _Customization = Convert.ToBase64String(M.ToArray());
    }

    private void InvalidateTimer()
    {
        if (DesignMode || !DoneCreation)
            return;

        if (_IsAnimated)
        {
            ThemeShare.AddAnimationCallback(DoAnimation);
        }
        else
        {
            ThemeShare.RemoveAnimationCallback(DoAnimation);
        }
    }
    #endregion


    #region " User Hooks "

    protected abstract void ColorHook();
    protected abstract void PaintHook();

    protected virtual void OnCreation()
    {
    }

    protected virtual void OnAnimation()
    {
    }

    #endregion


    #region " Offset "

    private Rectangle OffsetReturnRectangle;
    protected Rectangle Offset(Rectangle r, int amount)
    {
        OffsetReturnRectangle = new Rectangle(r.X + amount, r.Y + amount, r.Width - (amount * 2), r.Height - (amount * 2));
        return OffsetReturnRectangle;
    }

    private Size OffsetReturnSize;
    protected Size Offset(Size s, int amount)
    {
        OffsetReturnSize = new Size(s.Width + amount, s.Height + amount);
        return OffsetReturnSize;
    }

    private Point OffsetReturnPoint;
    protected Point Offset(Point p, int amount)
    {
        OffsetReturnPoint = new Point(p.X + amount, p.Y + amount);
        return OffsetReturnPoint;
    }

    #endregion

    #region " Center "


    private Point CenterReturn;
    protected Point Center(Rectangle p, Rectangle c)
    {
        CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X + c.X, (p.Height / 2 - c.Height / 2) + p.Y + c.Y);
        return CenterReturn;
    }
    protected Point Center(Rectangle p, Size c)
    {
        CenterReturn = new Point((p.Width / 2 - c.Width / 2) + p.X, (p.Height / 2 - c.Height / 2) + p.Y);
        return CenterReturn;
    }

    protected Point Center(Rectangle child)
    {
        return Center(Width, Height, child.Width, child.Height);
    }
    protected Point Center(Size child)
    {
        return Center(Width, Height, child.Width, child.Height);
    }
    protected Point Center(int childWidth, int childHeight)
    {
        return Center(Width, Height, childWidth, childHeight);
    }

    protected Point Center(Size p, Size c)
    {
        return Center(p.Width, p.Height, c.Width, c.Height);
    }

    protected Point Center(int pWidth, int pHeight, int cWidth, int cHeight)
    {
        CenterReturn = new Point(pWidth / 2 - cWidth / 2, pHeight / 2 - cHeight / 2);
        return CenterReturn;
    }

    #endregion

    #region " Measure "

    private Bitmap MeasureBitmap;
    //TODO: Potential issues during multi-threading.
    private Graphics MeasureGraphics;

    protected Size Measure()
    {
        return MeasureGraphics.MeasureString(Text, Font, Width).ToSize();
    }
    protected Size Measure(string text)
    {
        return MeasureGraphics.MeasureString(text, Font, Width).ToSize();
    }

    #endregion


    #region " DrawPixel "


    private SolidBrush DrawPixelBrush;
    protected void DrawPixel(Color c1, int x, int y)
    {
        if (_Transparent)
        {
            B.SetPixel(x, y, c1);
        }
        else
        {
            DrawPixelBrush = new SolidBrush(c1);
            G.FillRectangle(DrawPixelBrush, x, y, 1, 1);
        }
    }

    #endregion

    #region " DrawCorners "


    private SolidBrush DrawCornersBrush;
    protected void DrawCorners(Color c1, int offset)
    {
        DrawCorners(c1, 0, 0, Width, Height, offset);
    }
    protected void DrawCorners(Color c1, Rectangle r1, int offset)
    {
        DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height, offset);
    }
    protected void DrawCorners(Color c1, int x, int y, int width, int height, int offset)
    {
        DrawCorners(c1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
    }

    protected void DrawCorners(Color c1)
    {
        DrawCorners(c1, 0, 0, Width, Height);
    }
    protected void DrawCorners(Color c1, Rectangle r1)
    {
        DrawCorners(c1, r1.X, r1.Y, r1.Width, r1.Height);
    }
    protected void DrawCorners(Color c1, int x, int y, int width, int height)
    {
        if (_NoRounding)
            return;

        if (_Transparent)
        {
            B.SetPixel(x, y, c1);
            B.SetPixel(x + (width - 1), y, c1);
            B.SetPixel(x, y + (height - 1), c1);
            B.SetPixel(x + (width - 1), y + (height - 1), c1);
        }
        else
        {
            DrawCornersBrush = new SolidBrush(c1);
            G.FillRectangle(DrawCornersBrush, x, y, 1, 1);
            G.FillRectangle(DrawCornersBrush, x + (width - 1), y, 1, 1);
            G.FillRectangle(DrawCornersBrush, x, y + (height - 1), 1, 1);
            G.FillRectangle(DrawCornersBrush, x + (width - 1), y + (height - 1), 1, 1);
        }
    }

    #endregion

    #region " DrawBorders "

    protected void DrawBorders(Pen p1, int offset)
    {
        DrawBorders(p1, 0, 0, Width, Height, offset);
    }
    protected void DrawBorders(Pen p1, Rectangle r, int offset)
    {
        DrawBorders(p1, r.X, r.Y, r.Width, r.Height, offset);
    }
    protected void DrawBorders(Pen p1, int x, int y, int width, int height, int offset)
    {
        DrawBorders(p1, x + offset, y + offset, width - (offset * 2), height - (offset * 2));
    }

    protected void DrawBorders(Pen p1)
    {
        DrawBorders(p1, 0, 0, Width, Height);
    }
    protected void DrawBorders(Pen p1, Rectangle r)
    {
        DrawBorders(p1, r.X, r.Y, r.Width, r.Height);
    }
    protected void DrawBorders(Pen p1, int x, int y, int width, int height)
    {
        G.DrawRectangle(p1, x, y, width - 1, height - 1);
    }

    #endregion

    #region " DrawText "

    private Point DrawTextPoint;

    private Size DrawTextSize;
    protected void DrawText(Brush b1, HorizontalAlignment a, int x, int y)
    {
        DrawText(b1, Text, a, x, y);
    }
    protected void DrawText(Brush b1, string text, HorizontalAlignment a, int x, int y)
    {
        if (text.Length == 0)
            return;

        DrawTextSize = Measure(text);
        DrawTextPoint = Center(DrawTextSize);

        switch (a)
        {
            case HorizontalAlignment.Left:
                G.DrawString(text, Font, b1, x, DrawTextPoint.Y + y);
                break;
            case HorizontalAlignment.Center:
                G.DrawString(text, Font, b1, DrawTextPoint.X + x, DrawTextPoint.Y + y);
                break;
            case HorizontalAlignment.Right:
                G.DrawString(text, Font, b1, Width - DrawTextSize.Width - x, DrawTextPoint.Y + y);
                break;
        }
    }

    protected void DrawText(Brush b1, Point p1)
    {
        if (Text.Length == 0)
            return;
        G.DrawString(Text, Font, b1, p1);
    }
    protected void DrawText(Brush b1, int x, int y)
    {
        if (Text.Length == 0)
            return;
        G.DrawString(Text, Font, b1, x, y);
    }

    #endregion

    #region " DrawImage "


    private Point DrawImagePoint;
    protected void DrawImage(HorizontalAlignment a, int x, int y)
    {
        DrawImage(_Image, a, x, y);
    }
    protected void DrawImage(Image image, HorizontalAlignment a, int x, int y)
    {
        if (image == null)
            return;
        DrawImagePoint = Center(image.Size);

        switch (a)
        {
            case HorizontalAlignment.Left:
                G.DrawImage(image, x, DrawImagePoint.Y + y, image.Width, image.Height);
                break;
            case HorizontalAlignment.Center:
                G.DrawImage(image, DrawImagePoint.X + x, DrawImagePoint.Y + y, image.Width, image.Height);
                break;
            case HorizontalAlignment.Right:
                G.DrawImage(image, Width - image.Width - x, DrawImagePoint.Y + y, image.Width, image.Height);
                break;
        }
    }

    protected void DrawImage(Point p1)
    {
        DrawImage(_Image, p1.X, p1.Y);
    }
    protected void DrawImage(int x, int y)
    {
        DrawImage(_Image, x, y);
    }

    protected void DrawImage(Image image, Point p1)
    {
        DrawImage(image, p1.X, p1.Y);
    }
    protected void DrawImage(Image image, int x, int y)
    {
        if (image == null)
            return;
        G.DrawImage(image, x, y, image.Width, image.Height);
    }

    #endregion

    #region " DrawGradient "

    private LinearGradientBrush DrawGradientBrush;

    private Rectangle DrawGradientRectangle;
    protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(blend, DrawGradientRectangle);
    }
    protected void DrawGradient(ColorBlend blend, int x, int y, int width, int height, float angle)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(blend, DrawGradientRectangle, angle);
    }

    protected void DrawGradient(ColorBlend blend, Rectangle r)
    {
        DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, 90f);
        DrawGradientBrush.InterpolationColors = blend;
        G.FillRectangle(DrawGradientBrush, r);
    }
    protected void DrawGradient(ColorBlend blend, Rectangle r, float angle)
    {
        DrawGradientBrush = new LinearGradientBrush(r, Color.Empty, Color.Empty, angle);
        DrawGradientBrush.InterpolationColors = blend;
        G.FillRectangle(DrawGradientBrush, r);
    }


    protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(c1, c2, DrawGradientRectangle);
    }
    protected void DrawGradient(Color c1, Color c2, int x, int y, int width, int height, float angle)
    {
        DrawGradientRectangle = new Rectangle(x, y, width, height);
        DrawGradient(c1, c2, DrawGradientRectangle, angle);
    }

    protected void DrawGradient(Color c1, Color c2, Rectangle r)
    {
        DrawGradientBrush = new LinearGradientBrush(r, c1, c2, 90f);
        G.FillRectangle(DrawGradientBrush, r);
    }
    protected void DrawGradient(Color c1, Color c2, Rectangle r, float angle)
    {
        DrawGradientBrush = new LinearGradientBrush(r, c1, c2, angle);
        G.FillRectangle(DrawGradientBrush, r);
    }

    #endregion

    #region " DrawRadial "

    private GraphicsPath DrawRadialPath;
    private PathGradientBrush DrawRadialBrush1;
    private LinearGradientBrush DrawRadialBrush2;

    private Rectangle DrawRadialRectangle;
    public void DrawRadial(ColorBlend blend, int x, int y, int width, int height)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(blend, DrawRadialRectangle, width / 2, height / 2);
    }
    public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, Point center)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(blend, DrawRadialRectangle, center.X, center.Y);
    }
    public void DrawRadial(ColorBlend blend, int x, int y, int width, int height, int cx, int cy)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(blend, DrawRadialRectangle, cx, cy);
    }

    public void DrawRadial(ColorBlend blend, Rectangle r)
    {
        DrawRadial(blend, r, r.Width / 2, r.Height / 2);
    }
    public void DrawRadial(ColorBlend blend, Rectangle r, Point center)
    {
        DrawRadial(blend, r, center.X, center.Y);
    }
    public void DrawRadial(ColorBlend blend, Rectangle r, int cx, int cy)
    {
        DrawRadialPath.Reset();
        DrawRadialPath.AddEllipse(r.X, r.Y, r.Width - 1, r.Height - 1);

        DrawRadialBrush1 = new PathGradientBrush(DrawRadialPath);
        DrawRadialBrush1.CenterPoint = new Point(r.X + cx, r.Y + cy);
        DrawRadialBrush1.InterpolationColors = blend;

        if (G.SmoothingMode == SmoothingMode.AntiAlias)
        {
            G.FillEllipse(DrawRadialBrush1, r.X + 1, r.Y + 1, r.Width - 3, r.Height - 3);
        }
        else
        {
            G.FillEllipse(DrawRadialBrush1, r);
        }
    }


    protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(c1, c2, DrawRadialRectangle);
    }
    protected void DrawRadial(Color c1, Color c2, int x, int y, int width, int height, float angle)
    {
        DrawRadialRectangle = new Rectangle(x, y, width, height);
        DrawRadial(c1, c2, DrawRadialRectangle, angle);
    }

    protected void DrawRadial(Color c1, Color c2, Rectangle r)
    {
        DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, 90f);
        G.FillEllipse(DrawRadialBrush2, r);
    }
    protected void DrawRadial(Color c1, Color c2, Rectangle r, float angle)
    {
        DrawRadialBrush2 = new LinearGradientBrush(r, c1, c2, angle);
        G.FillEllipse(DrawRadialBrush2, r);
    }

    #endregion

    #region " CreateRound "

    private GraphicsPath CreateRoundPath;

    private Rectangle CreateRoundRectangle;
    public GraphicsPath CreateRound(int x, int y, int width, int height, int slope)
    {
        CreateRoundRectangle = new Rectangle(x, y, width, height);
        return CreateRound(CreateRoundRectangle, slope);
    }

    public GraphicsPath CreateRound(Rectangle r, int slope)
    {
        CreateRoundPath = new GraphicsPath(FillMode.Winding);
        CreateRoundPath.AddArc(r.X, r.Y, slope, slope, 180f, 90f);
        CreateRoundPath.AddArc(r.Right - slope, r.Y, slope, slope, 270f, 90f);
        CreateRoundPath.AddArc(r.Right - slope, r.Bottom - slope, slope, slope, 0f, 90f);
        CreateRoundPath.AddArc(r.X, r.Bottom - slope, slope, slope, 90f, 90f);
        CreateRoundPath.CloseFigure();
        return CreateRoundPath;
    }

    #endregion

}

static class ThemeShare
{

    #region " Animation "

    private static int Frames;
    private static bool Invalidate;

    public static PrecisionTimer ThemeTimer = new PrecisionTimer();
    //1000 / 50 = 20 FPS
    public static int FPS = 20;

    public static int Rate = 50;
    public delegate void AnimationDelegate(bool invalidate);


    private static List<AnimationDelegate> Callbacks = new List<AnimationDelegate>();
    private static void HandleCallbacks(IntPtr state, bool reserve)
    {
        Invalidate = (Frames >= FPS);
        if (Invalidate)
            Frames = 0;

        lock (Callbacks)
        {
            for (int I = 0; I <= Callbacks.Count - 1; I++)
            {
                Callbacks[I].Invoke(Invalidate);
            }
        }

        Frames += Rate;
    }

    private static void InvalidateThemeTimer()
    {
        if (Callbacks.Count == 0)
        {
            ThemeTimer.Delete();
        }
        else
        {
            ThemeTimer.Create(0, (uint)Rate, HandleCallbacks);
        }
    }

    public static void AddAnimationCallback(AnimationDelegate callback)
    {
        lock (Callbacks)
        {
            if (Callbacks.Contains(callback))
                return;

            Callbacks.Add(callback);
            InvalidateThemeTimer();
        }
    }

    public static void RemoveAnimationCallback(AnimationDelegate callback)
    {
        lock (Callbacks)
        {
            if (!Callbacks.Contains(callback))
                return;

            Callbacks.Remove(callback);
            InvalidateThemeTimer();
        }
    }

    #endregion

}

enum MouseState : byte
{
    None = 0,
    Over = 1,
    Down = 2,
    Block = 3
}

struct Bloom
{

    public string _Name;
    public string Name
    {
        get { return _Name; }
    }

    private Color _Value;
    public Color Value
    {
        get { return _Value; }
        set { _Value = value; }
    }

    public string ValueHex
    {
        get { return string.Concat("#", _Value.R.ToString("X2", null), _Value.G.ToString("X2", null), _Value.B.ToString("X2", null)); }
        set
        {
            try
            {
                _Value = ColorTranslator.FromHtml(value);
            }
            catch
            {
                return;
            }
        }
    }


    public Bloom(string name, Color value)
    {
        _Name = name;
        _Value = value;
    }
}

//------------------
//Creator: aeonhack
//Site: elitevs.net
//Created: 11/30/2011
//Changed: 11/30/2011
//Version: 1.0.0
//------------------
class PrecisionTimer : IDisposable
{

    private bool _Enabled;
    public bool Enabled
    {
        get { return _Enabled; }
    }

    private IntPtr Handle;

    private TimerDelegate TimerCallback;
    [DllImport("kernel32.dll", EntryPoint = "CreateTimerQueueTimer")]
    private static extern bool CreateTimerQueueTimer(ref IntPtr handle, IntPtr queue, TimerDelegate callback, IntPtr state, uint dueTime, uint period, uint flags);

    [DllImport("kernel32.dll", EntryPoint = "DeleteTimerQueueTimer")]
    private static extern bool DeleteTimerQueueTimer(IntPtr queue, IntPtr handle, IntPtr callback);

    public delegate void TimerDelegate(IntPtr r1, bool r2);

    public void Create(uint dueTime, uint period, TimerDelegate callback)
    {
        if (_Enabled)
            return;

        TimerCallback = callback;
        bool Success = CreateTimerQueueTimer(ref Handle, IntPtr.Zero, TimerCallback, IntPtr.Zero, dueTime, period, 0);

        if (!Success)
            ThrowNewException("CreateTimerQueueTimer");
        _Enabled = Success;
    }

    public void Delete()
    {
        if (!_Enabled)
            return;
        bool Success = DeleteTimerQueueTimer(IntPtr.Zero, Handle, IntPtr.Zero);

        if (!Success && !(Marshal.GetLastWin32Error() == 997))
        {
            //ThrowNewException("DeleteTimerQueueTimer")
        }

        _Enabled = !Success;
    }

    private void ThrowNewException(string name)
    {
        throw new Exception(string.Format("{0} failed. Win32Error: {1}", name, Marshal.GetLastWin32Error()));
    }

    public void Dispose()
    {
        Delete();
    }
}
#endregion

class GhostTheme : ThemeContainer154
{


    protected override void ColorHook()
    {
    }

    private bool _ShowIcon;
    public bool ShowIcon
    {
        get { return _ShowIcon; }
        set
        {
            _ShowIcon = value;
            Invalidate();
        }
    }

    protected override void PaintHook()
    {
        G.Clear(Color.DimGray);
        ColorBlend hatch = new ColorBlend(2);
        DrawBorders(Pens.Gray, 1);
        hatch.Colors[0] = Color.DimGray;
        hatch.Colors[1] = Color.FromArgb(60, 60, 60);
        hatch.Positions[0] = 0;
        hatch.Positions[1] = 1;
        DrawGradient(hatch, new Rectangle(0, 0, Width, 24));
        hatch.Colors[0] = Color.FromArgb(100, 100, 100);
        hatch.Colors[1] = Color.DimGray;
        DrawGradient(hatch, new Rectangle(0, 0, Width, 12));
        HatchBrush asdf = null;
        asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(15, Color.Black), Color.FromArgb(0, Color.Gray));
        hatch.Colors[0] = Color.FromArgb(120, Color.Black);
        hatch.Colors[1] = Color.FromArgb(0, Color.Black);
        DrawGradient(hatch, new Rectangle(0, 0, Width, 30));
        G.FillRectangle(asdf, 0, 0, Width, 24);
        G.DrawLine(Pens.Black, 6, 24, Width - 7, 24);
        G.DrawLine(Pens.Black, 6, 24, 6, Height - 7);
        G.DrawLine(Pens.Black, 6, Height - 7, Width - 7, Height - 7);
        G.DrawLine(Pens.Black, Width - 7, 24, Width - 7, Height - 7);
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(1, 24, 5, Height - 6 - 24));
        G.FillRectangle(asdf, 1, 24, 5, Height - 6 - 24);
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(Width - 6, 24, Width - 1, Height - 6 - 24));
        G.FillRectangle(asdf, Width - 6, 24, Width - 2, Height - 6 - 24);
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(1, Height - 6, Width - 2, Height - 1));
        G.FillRectangle(asdf, 1, Height - 6, Width - 2, Height - 1);
        DrawBorders(Pens.Black);
        asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
        G.FillRectangle(asdf, 7, 25, Width - 14, Height - 24 - 8);
        G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 7, 25, Width - 14, Height - 24 - 8);
        DrawCorners(Color.Fuchsia);
        DrawCorners(Color.Fuchsia, 0, 1, 1, 1);
        DrawCorners(Color.Fuchsia, 1, 0, 1, 1);
        DrawPixel(Color.Black, 1, 1);

        DrawCorners(Color.Fuchsia, 0, Height - 2, 1, 1);
        DrawCorners(Color.Fuchsia, 1, Height - 1, 1, 1);
        DrawPixel(Color.Black, Width - 2, 1);

        DrawCorners(Color.Fuchsia, Width - 1, 1, 1, 1);
        DrawCorners(Color.Fuchsia, Width - 2, 0, 1, 1);
        DrawPixel(Color.Black, 1, Height - 2);

        DrawCorners(Color.Fuchsia, Width - 1, Height - 2, 1, 1);
        DrawCorners(Color.Fuchsia, Width - 2, Height - 1, 1, 1);
        DrawPixel(Color.Black, Width - 2, Height - 2);

        ColorBlend cblend = new ColorBlend(2);
        cblend.Colors[0] = Color.FromArgb(35, Color.Black);
        cblend.Colors[1] = Color.FromArgb(0, 0, 0, 0);
        cblend.Positions[0] = 0;
        cblend.Positions[1] = 1;
        DrawGradient(cblend, 7, 25, 15, Height - 6 - 24, 0);
        cblend.Colors[0] = Color.FromArgb(0, 0, 0, 0);
        cblend.Colors[1] = Color.FromArgb(35, Color.Black);
        DrawGradient(cblend, Width - 24, 25, 17, Height - 6 - 24, 0);
        cblend.Colors[1] = Color.FromArgb(0, 0, 0, 0);
        cblend.Colors[0] = Color.FromArgb(35, Color.Black);
        DrawGradient(cblend, 7, 25, this.Width - 14, 17, 90);
        cblend.Colors[0] = Color.FromArgb(0, 0, 0, 0);
        cblend.Colors[1] = Color.FromArgb(35, Color.Black);
        DrawGradient(cblend, 8, this.Height - 24, this.Width - 14, 17, 90);
        if (_ShowIcon == false)
        {
            G.DrawString(Text, Font, Brushes.White, new Point(6, 6));
        }
        else
        {
            G.DrawIcon(FindForm().Icon, new Rectangle(new Point(9, 5), new Size(16, 16)));
            G.DrawString(Text, Font, Brushes.White, new Point(28, 6));
        }

    }

    public GhostTheme()
    {
        TransparencyKey = Color.Fuchsia;
    }
}

class GhostButton : ThemeControl154
{
    private bool Glass = true;
    private Color _color;

    int a = 0;

    protected override void ColorHook()
    {
    }

    protected override void OnAnimation()
    {
        base.OnAnimation();
        switch (State)
        {
            case MouseState.Over:
                if (a < 20)
                {
                    a += 5;
                    Invalidate();
                    Application.DoEvents();
                }
                break;
            case MouseState.None:
                if (a > 0)
                {
                    a -= 5;
                    if (a < 0)
                        a = 0;
                    Invalidate();
                    Application.DoEvents();
                }
                break;
        }
    }

    public bool EnableGlass
    {
        get { return Glass; }
        set { Glass = value; }
    }

    public Color Color
    {
        get { return _color; }
        set { _color = value; }
    }

    protected override void OnTextChanged(System.EventArgs e)
    {
        base.OnTextChanged(e);
        Graphics gg = this.CreateGraphics();
        SizeF textSize = this.CreateGraphics().MeasureString(Text, Font);
        gg.DrawString(Text, Font, Brushes.White, new RectangleF(0, 0, this.Width, this.Height));
    }

    protected override void PaintHook()
    {
        G.Clear(_color);
        if (State == MouseState.Over)
        {
            ColorBlend cblend = new ColorBlend(2);
            cblend.Colors[0] = Color.FromArgb(200, 50, 50, 50);
            cblend.Colors[1] = Color.FromArgb(200, 70, 70, 70);
            cblend.Positions[0] = 0;
            cblend.Positions[1] = 1;
            DrawGradient(cblend, new Rectangle(0, 0, Width, Height));
            cblend.Colors[0] = Color.FromArgb(0, 0, 0, 0);
            cblend.Colors[1] = Color.FromArgb(40, Color.White);
            if (Glass)
                DrawGradient(cblend, new Rectangle(0, 0, Width, Height / 5 * 2));
        }
        else if (State == MouseState.None)
        {
            ColorBlend cblend = new ColorBlend(2);
            cblend.Colors[0] = Color.FromArgb(200, 50, 50, 50);
            cblend.Colors[1] = Color.FromArgb(200, 70, 70, 70);
            cblend.Positions[0] = 0;
            cblend.Positions[1] = 1;
            DrawGradient(cblend, new Rectangle(0, 0, Width, Height));
            cblend.Colors[0] = Color.FromArgb(0, 0, 0, 0);
            cblend.Colors[1] = Color.FromArgb(40, Color.White);
            if (Glass)
                DrawGradient(cblend, new Rectangle(0, 0, Width, Height / 5 * 2));
        }
        else
        {
            ColorBlend cblend = new ColorBlend(2);
            cblend.Colors[0] = Color.FromArgb(200, 30, 30, 30);
            cblend.Colors[1] = Color.FromArgb(200, 50, 50, 50);
            cblend.Positions[0] = 0;
            cblend.Positions[1] = 1;
            DrawGradient(cblend, new Rectangle(0, 0, Width, Height));
            cblend.Colors[0] = Color.FromArgb(0, 0, 0, 0);
            cblend.Colors[1] = Color.FromArgb(40, Color.White);
            if (Glass)
                DrawGradient(cblend, new Rectangle(0, 0, Width, Height / 5 * 2));
        }
        G.FillRectangle(new SolidBrush(Color.FromArgb(a, System.Drawing.Color.White)), 0, 0, Width, Height);
        HatchBrush hatch = null;
        hatch = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(25, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(hatch, 0, 0, Width, Height);
        SizeF textSize = this.CreateGraphics().MeasureString(Text, Font, Width - 4);
        StringFormat sf = new StringFormat();
        sf.LineAlignment = StringAlignment.Center;
        sf.Alignment = StringAlignment.Center;
        G.DrawString(Text, Font, Brushes.White, new RectangleF(2, 2, this.Width - 5, this.Height - 4), sf);
        DrawBorders(Pens.Black);
        DrawBorders(new Pen(Color.FromArgb(90, 90, 90)), 1);
    }

    public GhostButton()
    {
        IsAnimated = true;
    }

}

class GhostProgressbar : ThemeControl154
{
    private int _Maximum = 100;
    private int _Value;
    private int HOffset = 0;
    private int Progress;

    protected override void ColorHook()
    {
    }

    public int Maximum
    {
        get { return _Maximum; }
        set
        {
            if (value < 1)
                value = 1;
            if (value < _Value)
                _Value = value;
            _Maximum = value;
            Invalidate();
        }
    }
    public int Value
    {
        get { return _Value; }
        set
        {
            if (value > _Maximum)
                value = Maximum;
            _Value = value;
            Invalidate();
        }
    }
    public bool Animated
    {
        get { return IsAnimated; }
        set
        {
            IsAnimated = value;
            Invalidate();
        }
    }

    protected override void OnAnimation()
    {
        HOffset -= 1;
        if (HOffset == 7)
            HOffset = 0;
    }

    protected override void PaintHook()
    {
        HatchBrush hatch = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(60, Color.Black));
        G.Clear(Color.FromArgb(0, 30, 30, 30));
        ColorBlend cblend = new ColorBlend(2);
        cblend.Colors[0] = Color.FromArgb(50, 50, 50);
        cblend.Colors[1] = Color.FromArgb(70, 70, 70);
        cblend.Positions[0] = 0;
        cblend.Positions[1] = 1;
        DrawGradient(cblend, new Rectangle(0, 0, Convert.ToInt32(((Width / _Maximum) * _Value) - 2), Height - 2));
        cblend.Colors[1] = Color.FromArgb(80, 80, 80);
        DrawGradient(cblend, new Rectangle(0, 0, Convert.ToInt32(((Width / _Maximum) * _Value) - 2), Height / 5 * 2));
        G.RenderingOrigin = new Point(HOffset, 0);
        hatch = new HatchBrush(HatchStyle.ForwardDiagonal, Color.FromArgb(40, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(hatch, 0, 0, Convert.ToInt32(((Width / _Maximum) * _Value) - 2), Height - 2);
        DrawBorders(Pens.Black);
        DrawBorders(new Pen(Color.FromArgb(90, 90, 90)), 1);
        DrawCorners(Color.Black);
        G.DrawLine(new Pen(Color.FromArgb(200, 90, 90, 90)), Convert.ToInt32(((Width / _Maximum) * _Value) - 2), 1, Convert.ToInt32(((Width / _Maximum) * _Value) - 2), Height - 2);
        G.DrawLine(Pens.Black, Convert.ToInt32(((Width / _Maximum) * _Value) - 2) + 1, 2, Convert.ToInt32(((Width / _Maximum) * _Value) - 2) + 1, Height - 3);
        Progress = Convert.ToInt32(((Width / _Maximum) * _Value));
        ColorBlend cblend2 = new ColorBlend(3);
        cblend2.Colors[0] = Color.FromArgb(0, Color.Gray);
        cblend2.Colors[1] = Color.FromArgb(80, Color.DimGray);
        cblend2.Colors[2] = Color.FromArgb(0, Color.Gray);
        cblend2.Positions = new float[] {
            0,
            0.5F,
            1
        };
        if (Value > 0)
            G.FillRectangle(new SolidBrush(Color.FromArgb(5, 5, 5)), Convert.ToInt32(((Width / _Maximum) * _Value)) - 1, 2, Width - Convert.ToInt32(((Width / _Maximum) * _Value)) - 1, Height - 4);
    }

    public GhostProgressbar()
    {
        _Maximum = 100;
        IsAnimated = true;
    }
}

[DefaultEvent("CheckedChanged")]
class GhostCheckbox : ThemeControl154
{
    private bool _Checked;

    private int X;
    public event CheckedChangedEventHandler CheckedChanged;
    public delegate void CheckedChangedEventHandler(object sender);

    public bool Checked
    {
        get { return _Checked; }
        set
        {
            _Checked = value;
            Invalidate();
            if (CheckedChanged != null)
            {
                CheckedChanged(this);
            }
        }
    }


    protected override void ColorHook()
    {
    }

    protected override void OnTextChanged(System.EventArgs e)
    {
        base.OnTextChanged(e);
        int textSize = 0;
        textSize = (int)this.CreateGraphics().MeasureString(Text, Font).Width;
        this.Width = 20 + textSize;
    }

    protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
    {
        base.OnMouseMove(e);
        X = e.X;
        Invalidate();
    }

    protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
    {
        base.OnMouseDown(e);
        if (_Checked == true)
            _Checked = false;
        else
            _Checked = true;
    }

    protected override void PaintHook()
    {
        G.Clear(Color.FromArgb(60, 60, 60));
        HatchBrush asdf = null;
        asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(0, 0, Width, Height));
        asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
        G.FillRectangle(asdf, 0, 0, Width, Height);
        G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 0, 0, Width, Height);

        G.FillRectangle(new SolidBrush(Color.FromArgb(10, 10, 10)), 3, 3, 10, 10);
        if (_Checked)
        {
            ColorBlend cblend = new ColorBlend(2);
            cblend.Colors[0] = Color.FromArgb(60, 60, 60);
            cblend.Colors[1] = Color.FromArgb(80, 80, 80);
            cblend.Positions[0] = 0;
            cblend.Positions[1] = 1;
            DrawGradient(cblend, new Rectangle(3, 3, 10, 10));
            cblend.Colors[0] = Color.FromArgb(70, 70, 70);
            cblend.Colors[1] = Color.FromArgb(100, 100, 100);
            DrawGradient(cblend, new Rectangle(3, 3, 10, 4));
            HatchBrush hatch = null;
            hatch = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.FromArgb(60, Color.Black), Color.FromArgb(0, Color.Gray));
            G.FillRectangle(hatch, 3, 3, 10, 10);
        }
        else
        {
            HatchBrush hatch = null;
            hatch = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.FromArgb(20, Color.White), Color.FromArgb(0, Color.Gray));
            G.FillRectangle(hatch, 3, 3, 10, 10);
        }

        if (State == MouseState.Over & X < 15)
        {
            G.FillRectangle(new SolidBrush(Color.FromArgb(30, Color.Gray)), new Rectangle(3, 3, 10, 10));
        }
        else if (State == MouseState.Down)
        {
            G.FillRectangle(new SolidBrush(Color.FromArgb(30, Color.Black)), new Rectangle(3, 3, 10, 10));
        }

        G.DrawRectangle(Pens.Black, 0, 0, 15, 15);
        G.DrawRectangle(new Pen(Color.FromArgb(90, 90, 90)), 1, 1, 13, 13);
        G.DrawString(Text, Font, Brushes.White, 17, 1);
    }

    public GhostCheckbox()
    {
        this.Size = new Size(16, 50);
    }
}

[DefaultEvent("CheckedChanged")]
class GhostRadiobutton : ThemeControl154
{
    private int X;

    private bool _Checked;
    public bool Checked
    {
        get { return _Checked; }
        set
        {
            _Checked = value;
            InvalidateControls();
            if (CheckedChanged != null)
            {
                CheckedChanged(this);
            }
            Invalidate();
        }
    }

    public event CheckedChangedEventHandler CheckedChanged;
    public delegate void CheckedChangedEventHandler(object sender);

    protected override void OnCreation()
    {
        InvalidateControls();
    }

    private void InvalidateControls()
    {
        if (!IsHandleCreated || !_Checked)
            return;

        foreach (Control C in Parent.Controls)
        {
            if (!object.ReferenceEquals(C, this) && C is GhostRadiobutton)
            {
                ((GhostRadiobutton)C).Checked = false;
            }
        }
    }

    protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
    {
        if (!_Checked)
            Checked = true;
        base.OnMouseDown(e);
    }

    protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
    {
        base.OnMouseMove(e);
        X = e.X;
        Invalidate();
    }


    protected override void ColorHook()
    {
    }

    protected override void OnTextChanged(System.EventArgs e)
    {
        base.OnTextChanged(e);
        int textSize = 0;
        textSize = (int)this.CreateGraphics().MeasureString(Text, Font).Width;
        this.Width = 20 + textSize;
    }

    protected override void PaintHook()
    {
        G.Clear(Color.FromArgb(60, 60, 60));
        HatchBrush asdf = null;
        asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(0, 0, Width, Height));
        asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
        G.FillRectangle(asdf, 0, 0, Width, Height);
        G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 0, 0, Width, Height);

        G.SmoothingMode = SmoothingMode.AntiAlias;
        G.FillEllipse(new SolidBrush(Color.Black), 2, 2, 11, 11);
        G.DrawEllipse(Pens.Black, 0, 0, 13, 13);
        G.DrawEllipse(new Pen(Color.FromArgb(90, 90, 90)), 1, 1, 11, 11);

        if (_Checked == false)
        {
            HatchBrush hatch = null;
            hatch = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.FromArgb(20, Color.White), Color.FromArgb(0, Color.Gray));
            G.FillEllipse(hatch, 2, 2, 10, 10);
        }
        else
        {
            G.FillEllipse(new SolidBrush(Color.FromArgb(80, 80, 80)), 3, 3, 7, 7);
            HatchBrush hatch = null;
            hatch = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.FromArgb(60, Color.Black), Color.FromArgb(0, Color.Gray));
            G.FillRectangle(hatch, 3, 3, 7, 7);
        }

        if (State == MouseState.Over & X < 13)
        {
            G.FillEllipse(new SolidBrush(Color.FromArgb(20, Color.White)), 2, 2, 11, 11);
        }

        G.DrawString(Text, Font, Brushes.White, 16, 0);
    }

    public GhostRadiobutton()
    {
        this.Size = new Size(50, 14);
    }
}

class GhostTabControl : TabControl
{
    //Stupid VB.Net bug. Please don't use more than 9999 tabs :3
    private int[] Xstart = new int[10000];
    //Stupid VB.Net bug. Please don't use more than 9999 tabs :3
    private int[] Xstop = new int[10000];

    public GhostTabControl()
    {
        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.ResizeRedraw | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
        DoubleBuffered = true;
        foreach (TabPage p in TabPages)
        {
            p.BackColor = Color.White;
            Application.DoEvents();
            p.BackColor = Color.Transparent;
        }
    }
    protected override void CreateHandle()
    {
        base.CreateHandle();
        Alignment = TabAlignment.Top;
    }

    protected override void OnMouseClick(System.Windows.Forms.MouseEventArgs e)
    {
        base.OnMouseClick(e);
        int index = 0;
        int height = (int)this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8;
        foreach (int a in Xstart)
        {
            if (e.X > a & e.X < Xstop[index] & e.Y < height & e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                SelectedIndex = index;
                Invalidate();
            }
            else
            {
            }
            index += 1;
        }
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        Bitmap B = new Bitmap(Width, Height);
        Graphics G = Graphics.FromImage(B);
        G.Clear(Color.FromArgb(60, 60, 60));
        HatchBrush asdf = null;
        asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(0, 0, Width, Height));
        asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
        G.FillRectangle(asdf, 0, 0, Width, Height);
        G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 0, 0, Width, Height);

        G.FillRectangle(Brushes.Black, 0, 0, Width, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8);
        G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.Black)), 2, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 7, Width - 2, Height - 2);

        int totallength = 0;
        int index = 0;
        foreach (TabPage tab in TabPages)
        {
            if (SelectedIndex == index)
            {
                G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), totallength, 1, this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 10);
                asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
                G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), totallength, 1, this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 10);
                asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
                G.FillRectangle(asdf, totallength, 1, this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 10);
                G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), totallength, 1, this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 10);

                LinearGradientBrush gradient = new LinearGradientBrush(new Point(totallength, 1), new Point(totallength, (int)this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8), Color.FromArgb(15, Color.White), Color.Transparent);
                G.FillRectangle(gradient, totallength, 1, this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 5);

                G.DrawLine(new Pen(Color.FromArgb(60, 60, 60)), totallength + this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, 2, totallength + this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8);
                G.DrawLine(new Pen(Color.FromArgb(60, 60, 60)), totallength, 2, totallength, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8);

                G.DrawLine(new Pen(Color.FromArgb(60, 60, 60)), totallength + this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8, Width - 1, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8);
                G.DrawLine(new Pen(Color.FromArgb(60, 60, 60)), 1, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8, totallength, this.CreateGraphics().MeasureString("Mava is awesome", Font).Height + 8);

            }
            Xstart[index] = totallength;
            Xstop[index] = totallength + (int)this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15;
            G.DrawString(tab.Text, Font, Brushes.White, totallength + 8, 5);
            totallength += (int)this.CreateGraphics().MeasureString(tab.Text, Font).Width + 15;
            index += 1;
        }

        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), 1, 1, Width - 2, 1);
        //boven
        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), 1, Height - 2, Width - 2, Height - 2);
        //onder
        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), 1, 1, 1, Height - 2);
        //links
        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), Width - 2, 1, Width - 2, Height - 2);
        //rechts

        G.DrawLine(Pens.Black, 0, 0, Width - 1, 0);
        //boven
        G.DrawLine(Pens.Black, 0, Height - 1, Width, Height - 1);
        //onder
        G.DrawLine(Pens.Black, 0, 0, 0, Height - 1);
        //links
        G.DrawLine(Pens.Black, Width - 1, 0, Width - 1, Height - 1);
        //rechts

        e.Graphics.DrawImage(B, 0, 0);
        G.Dispose();
        B.Dispose();
    }

    protected override void OnSelectedIndexChanged(System.EventArgs e)
    {
        base.OnSelectedIndexChanged(e);
        Invalidate();
    }
}

class GhostTabControlLagFree : TabControl
{
    private Color _Forecolor = Color.White;
    public override Color ForeColor
    {
        get { return _Forecolor; }
        set { _Forecolor = value; }
    }

    public GhostTabControlLagFree()
    {
        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.ResizeRedraw | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
        DoubleBuffered = true;
        foreach (TabPage p in TabPages)
        {
            try
            {
                p.BackColor = Color.Black;
                p.BackColor = Color.Transparent;
            }
            catch
            {
            }
        }
    }
    protected override void CreateHandle()
    {
        base.CreateHandle();
        Alignment = TabAlignment.Top;
        foreach (TabPage p in TabPages)
        {
            try
            {
                p.BackColor = Color.Black;
                p.BackColor = Color.Transparent;
            }
            catch
            {
            }
        }
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        Bitmap B = new Bitmap(Width, Height);
        Graphics G = Graphics.FromImage(B);

        G.Clear(Color.FromArgb(60, 60, 60));

        HatchBrush asdf = null;
        asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(0, 0, Width, Height));
        asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
        G.FillRectangle(asdf, 0, 0, Width, Height);
        G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 0, 0, Width, Height);

        G.FillRectangle(Brushes.Black, new Rectangle(new Point(0, 4), new Size(Width - 2, 20)));

        G.DrawRectangle(Pens.Black, new Rectangle(new Point(0, 3), new Size(Width - 1, Height - 4)));
        G.DrawRectangle(new Pen(Color.FromArgb(90, 90, 90)), new Rectangle(new Point(1, 4), new Size(Width - 3, Height - 6)));

        for (int i = 0; i <= TabCount - 1; i++)
        {
            if (i == SelectedIndex)
            {
                Rectangle x2 = new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 2, GetTabRect(i).Width + 2, GetTabRect(i).Height - 1);

                asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
                G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 3, GetTabRect(i).Width + 1, GetTabRect(i).Height - 2));
                asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
                G.FillRectangle(asdf, new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 3, GetTabRect(i).Width + 1, GetTabRect(i).Height - 2));
                G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 3, GetTabRect(i).Width + 1, GetTabRect(i).Height - 2));

                LinearGradientBrush gradient = new LinearGradientBrush(new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 2, GetTabRect(i).Width + 2, GetTabRect(i).Height - 1), Color.FromArgb(15, Color.White), Color.Transparent, 90f);
                G.FillRectangle(gradient, new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 2, GetTabRect(i).Width + 2, GetTabRect(i).Height - 1));
                G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), new Point(GetTabRect(i).Right, 4), new Point(GetTabRect(i).Right, GetTabRect(i).Height + 3));
                if (!(SelectedIndex == 0))
                {
                    G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), new Point(GetTabRect(i).X, 4), new Point(GetTabRect(i).X, GetTabRect(i).Height + 3));
                    G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), new Point(1, GetTabRect(i).Height + 3), new Point(GetTabRect(i).X, GetTabRect(i).Height + 3));
                }
                G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), new Point(GetTabRect(i).Right, GetTabRect(i).Height + 3), new Point(Width - 2, GetTabRect(i).Height + 3));
                G.DrawString(TabPages[i].Text, Font, new SolidBrush(_Forecolor), x2, new StringFormat
                {
                    LineAlignment = StringAlignment.Center,
                    Alignment = StringAlignment.Center
                });
            }
            else
            {
                Rectangle x2 = new Rectangle(GetTabRect(i).X, GetTabRect(i).Y + 2, GetTabRect(i).Width + 2, GetTabRect(i).Height - 1);
                G.DrawString(TabPages[i].Text, Font, new SolidBrush(_Forecolor), x2, new StringFormat
                {
                    LineAlignment = StringAlignment.Center,
                    Alignment = StringAlignment.Center
                });
            }
        }

        e.Graphics.DrawImage(B, 0, 0);
        G.Dispose();
        B.Dispose();
    }
}

class GhostListBoxPretty : ThemeControl154
{
    private ListBox withEventsField_LBox = new ListBox();
    public ListBox LBox
    {
        get { return withEventsField_LBox; }
        set
        {
            if (withEventsField_LBox != null)
            {
                withEventsField_LBox.DrawItem -= DrawItem;
            }
            withEventsField_LBox = value;
            if (withEventsField_LBox != null)
            {
                withEventsField_LBox.DrawItem += DrawItem;
            }
        }
    }
    private string[] __Items = { "" };
    public string[] Items
    {
        get
        {
            return __Items;
        }
        set
        {
            __Items = value;
            LBox.Items.Clear();
            Invalidate();
            LBox.Items.AddRange(value);
            Invalidate();
        }
    }

    public string SelectedItem
    {
        get { return LBox.SelectedItem.ToString(); }
    }

    public GhostListBoxPretty()
    {
        Controls.Add(LBox);
        Size = new Size(131, 101);

        LBox.BackColor = Color.FromArgb(0, 0, 0);
        LBox.BorderStyle = BorderStyle.None;
        LBox.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawVariable;
        LBox.Location = new Point(3, 3);
        LBox.ForeColor = Color.White;
        LBox.ItemHeight = 20;
        LBox.Items.Clear();
        LBox.IntegralHeight = false;
        Invalidate();
    }
    protected override void ColorHook()
    {
    }

    protected override void OnResize(System.EventArgs e)
    {
        base.OnResize(e);
        LBox.Width = Width - 4;
        LBox.Height = Height - 4;
    }

    protected override void PaintHook()
    {
        G.Clear(Color.Black);
        G.DrawRectangle(Pens.Black, 0, 0, Width - 2, Height - 2);
        G.DrawRectangle(new Pen(Color.FromArgb(90, 90, 90)), 1, 1, Width - 3, Height - 3);
        LBox.Size = new Size(Width - 5, Height - 5);
    }
    public void DrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e)
    {
        if (e.Index < 0)
            return;
        e.DrawBackground();
        e.DrawFocusRectangle();
        if (e.State.ToString().Contains("Selected"))
        {
            e.Graphics.FillRectangle(Brushes.Black, e.Bounds);
            Rectangle x2 = new Rectangle(e.Bounds.Location, new Size(e.Bounds.Width - 1, e.Bounds.Height));
            Rectangle x3 = new Rectangle(x2.Location, new Size(x2.Width, (x2.Height / 2) - 2));
            LinearGradientBrush G1 = new LinearGradientBrush(new Point(x2.X, x2.Y), new Point(x2.X, x2.Y + x2.Height), Color.FromArgb(60, 60, 60), Color.FromArgb(50, 50, 50));
            HatchBrush H = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(15, Color.Black), Color.Transparent);
            e.Graphics.FillRectangle(G1, x2);
            G1.Dispose();
            e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(25, Color.White)), x3);
            e.Graphics.FillRectangle(H, x2);
            G1.Dispose();
            e.Graphics.DrawString(" " + LBox.Items[e.Index].ToString(), Font, Brushes.White, e.Bounds.X, e.Bounds.Y + 2);
        }
        else
        {
            e.Graphics.DrawString(" " + LBox.Items[e.Index].ToString(), Font, Brushes.White, e.Bounds.X, e.Bounds.Y + 2);
        }
    }
    public void AddRange(object[] Items)
    {
        LBox.Items.Remove("");
        LBox.Items.AddRange(Items);
        Invalidate();
    }
    public void AddItem(object Item)
    {
        LBox.Items.Remove("");
        LBox.Items.Add(Item);
        Invalidate();
    }
}

class GhostListboxLessPretty : ListBox
{

    public GhostListboxLessPretty()
    {
        SetStyle(ControlStyles.DoubleBuffer, true);
        Font = new Font("Microsoft Sans Serif", 9);
        BorderStyle = System.Windows.Forms.BorderStyle.None;
        DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
        ItemHeight = 20;
        ForeColor = Color.DeepSkyBlue;
        BackColor = Color.FromArgb(7, 7, 7);
        IntegralHeight = false;
    }

    protected override void WndProc(ref System.Windows.Forms.Message m)
    {
        base.WndProc(ref m);
        if (m.Msg == 15)
            CustomPaint();
    }

    protected override void OnDrawItem(System.Windows.Forms.DrawItemEventArgs e)
    {
        try
        {
            if (e.Index < 0)
                return;
            e.DrawBackground();
            Rectangle rect = new Rectangle(new Point(e.Bounds.Left, e.Bounds.Top + 2), new Size(Bounds.Width, 16));
            e.DrawFocusRectangle();
            if (e.State.ToString().Contains("Selected"))
            {
                e.Graphics.FillRectangle(Brushes.Black, e.Bounds);
                Rectangle x2 = new Rectangle(e.Bounds.Location, new Size(e.Bounds.Width - 1, e.Bounds.Height));
                Rectangle x3 = new Rectangle(x2.Location, new Size(x2.Width, (x2.Height / 2)));
                LinearGradientBrush G1 = new LinearGradientBrush(new Point(x2.X, x2.Y), new Point(x2.X, x2.Y + x2.Height), Color.FromArgb(60, 60, 60), Color.FromArgb(50, 50, 50));
                HatchBrush H = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(15, Color.Black), Color.Transparent);
                e.Graphics.FillRectangle(G1, x2);
                G1.Dispose();
                e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(25, Color.White)), x3);
                e.Graphics.FillRectangle(H, x2);
                G1.Dispose();
                e.Graphics.DrawString(" " + Items[e.Index].ToString(), Font, Brushes.White, e.Bounds.X, e.Bounds.Y + 1);
            }
            else
            {
                e.Graphics.DrawString(" " + Items[e.Index].ToString(), Font, Brushes.White, e.Bounds.X, e.Bounds.Y + 1);
            }
            e.Graphics.DrawRectangle(new Pen(Color.FromArgb(0, 0, 0)), new Rectangle(1, 1, Width - 3, Height - 3));
            e.Graphics.DrawRectangle(new Pen(Color.FromArgb(90, 90, 90)), new Rectangle(0, 0, Width - 1, Height - 1));
            base.OnDrawItem(e);
        }
        catch
        {
        }
    }

    public void CustomPaint()
    {
        CreateGraphics().DrawRectangle(new Pen(Color.FromArgb(0, 0, 0)), new Rectangle(1, 1, Width - 3, Height - 3));
        CreateGraphics().DrawRectangle(new Pen(Color.FromArgb(90, 90, 90)), new Rectangle(0, 0, Width - 1, Height - 1));
    }
}

class GhostComboBox : ComboBox
{

    private int X;
    public GhostComboBox()
        : base()
    {
        TextChanged += GhostCombo_TextChanged;
        DropDownClosed += GhostComboBox_DropDownClosed;
        SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.ResizeRedraw | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
        DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
        ItemHeight = 20;
        BackColor = Color.FromArgb(30, 30, 30);
        DropDownStyle = ComboBoxStyle.DropDownList;
    }

    protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
    {
        base.OnMouseMove(e);
        X = e.X;
        Invalidate();
    }

    protected override void OnMouseLeave(System.EventArgs e)
    {
        base.OnMouseLeave(e);
        X = -1;
        Invalidate();
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        if (!(DropDownStyle == ComboBoxStyle.DropDownList))
            DropDownStyle = ComboBoxStyle.DropDownList;
        Bitmap B = new Bitmap(Width, Height);
        Graphics G = Graphics.FromImage(B);

        G.Clear(Color.FromArgb(50, 50, 50));
        LinearGradientBrush GradientBrush = new LinearGradientBrush(new Rectangle(0, 0, Width, Height / 5 * 2), Color.FromArgb(20, 0, 0, 0), Color.FromArgb(15, Color.White), 90f);
        G.FillRectangle(GradientBrush, new Rectangle(0, 0, Width, Height / 5 * 2));
        HatchBrush hatch = null;
        hatch = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(20, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(hatch, 0, 0, Width, Height);

        int S1 = (int)G.MeasureString("...", Font).Height;
        if (SelectedIndex != -1)
        {
            G.DrawString(Items[SelectedIndex].ToString(), Font, new SolidBrush(Color.White), 4, Height / 2 - S1 / 2);
        }
        else
        {
            if ((Items != null) & Items.Count > 0)
            {
                G.DrawString(Items[0].ToString(), Font, new SolidBrush(Color.White), 4, Height / 2 - S1 / 2);
            }
            else
            {
                G.DrawString("...", Font, new SolidBrush(Color.White), 4, Height / 2 - S1 / 2);
            }
        }

        if (MouseButtons == System.Windows.Forms.MouseButtons.None & X > Width - 25)
        {
            G.FillRectangle(new SolidBrush(Color.FromArgb(7, Color.White)), Width - 25, 1, Width - 25, Height - 3);
        }
        else if (MouseButtons == System.Windows.Forms.MouseButtons.None & X < Width - 25 & X >= 0)
        {
            G.FillRectangle(new SolidBrush(Color.FromArgb(7, Color.White)), 2, 1, Width - 27, Height - 3);
        }

        G.DrawRectangle(Pens.Black, 0, 0, Width - 1, Height - 1);
        G.DrawRectangle(new Pen(Color.FromArgb(90, 90, 90)), 1, 1, Width - 3, Height - 3);
        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), Width - 25, 1, Width - 25, Height - 3);
        G.DrawLine(Pens.Black, Width - 24, 0, Width - 24, Height);
        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), Width - 23, 1, Width - 23, Height - 3);

        G.FillPolygon(Brushes.Black, Triangle(new Point(Width - 14, Height / 2), new Size(5, 3)));
        G.FillPolygon(Brushes.White, Triangle(new Point(Width - 15, Height / 2 - 1), new Size(5, 3)));

        e.Graphics.DrawImage(B, 0, 0);
        G.Dispose();
        B.Dispose();
    }

    protected override void OnDrawItem(DrawItemEventArgs e)
    {
        if (e.Index < 0)
            return;
        Rectangle rect = new Rectangle();
        rect.X = e.Bounds.X;
        rect.Y = e.Bounds.Y;
        rect.Width = e.Bounds.Width - 1;
        rect.Height = e.Bounds.Height - 1;

        e.DrawBackground();
        if ((int)e.State == 785 | (int)e.State == 17)
        {
            e.Graphics.FillRectangle(Brushes.Black, e.Bounds);
            Rectangle x2 = new Rectangle(e.Bounds.Location, new Size(e.Bounds.Width - 1, e.Bounds.Height));
            Rectangle x3 = new Rectangle(x2.Location, new Size(x2.Width, (x2.Height / 2) - 1));
            LinearGradientBrush G1 = new LinearGradientBrush(new Point(x2.X, x2.Y), new Point(x2.X, x2.Y + x2.Height), Color.FromArgb(60, 60, 60), Color.FromArgb(50, 50, 50));
            HatchBrush H = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(15, Color.Black), Color.Transparent);
            e.Graphics.FillRectangle(G1, x2);
            G1.Dispose();
            e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(25, Color.White)), x3);
            e.Graphics.FillRectangle(H, x2);
            G1.Dispose();
            e.Graphics.DrawString(" " + Items[e.Index].ToString(), Font, Brushes.White, e.Bounds.X, e.Bounds.Y + 2);
        }
        else
        {
            e.Graphics.FillRectangle(new SolidBrush(BackColor), e.Bounds);
            e.Graphics.DrawString(" " + Items[e.Index].ToString(), Font, Brushes.White, e.Bounds.X, e.Bounds.Y + 2);
        }
        base.OnDrawItem(e);
    }

    public Point[] Triangle(Point Location, Size Size)
    {
        Point[] ReturnPoints = new Point[4];
        ReturnPoints[0] = Location;
        ReturnPoints[1] = new Point(Location.X + Size.Width, Location.Y);
        ReturnPoints[2] = new Point(Location.X + Size.Width / 2, Location.Y + Size.Height);
        ReturnPoints[3] = Location;

        return ReturnPoints;
    }

    private void GhostComboBox_DropDownClosed(object sender, System.EventArgs e)
    {
        DropDownStyle = ComboBoxStyle.Simple;
        Application.DoEvents();
        DropDownStyle = ComboBoxStyle.DropDownList;
    }

    private void GhostCombo_TextChanged(object sender, System.EventArgs e)
    {
        Invalidate();
    }
}

[Designer("System.Windows.Forms.Design.ParentControlDesigner,System.Design", typeof(IDesigner))]
class GhostGroupBox : ThemeControl154
{

    public GhostGroupBox()
        : base()
    {
        SetStyle(ControlStyles.ResizeRedraw, true);
        SetStyle(ControlStyles.ContainerControl, true);
        DoubleBuffered = true;
        BackColor = Color.Transparent;
    }


    protected override void ColorHook()
    {
    }

    protected override void PaintHook()
    {
        G.Clear(Color.FromArgb(60, 60, 60));
        HatchBrush asdf = null;
        asdf = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.FromArgb(35, Color.Black), Color.FromArgb(0, Color.Gray));
        G.FillRectangle(new SolidBrush(Color.FromArgb(60, 60, 60)), new Rectangle(0, 0, Width, Height));
        asdf = new HatchBrush(HatchStyle.LightDownwardDiagonal, Color.DimGray);
        G.FillRectangle(asdf, 0, 0, Width, Height);
        G.FillRectangle(new SolidBrush(Color.FromArgb(230, 20, 20, 20)), 0, 0, Width, Height);
        G.FillRectangle(new SolidBrush(Color.FromArgb(70, Color.Black)), 1, 1, Width - 2, this.CreateGraphics().MeasureString(Text, Font).Height + 8);

        G.DrawLine(new Pen(Color.FromArgb(90, 90, 90)), 1, this.CreateGraphics().MeasureString(Text, Font).Height + 8, Width - 2, this.CreateGraphics().MeasureString(Text, Font).Height + 8);

        DrawBorders(Pens.Black);
        DrawBorders(new Pen(Color.FromArgb(90, 90, 90)), 1);
        G.DrawString(Text, Font, Brushes.White, 5, 5);
    }
}

[DefaultEvent("TextChanged")]
class GhostTextBox : ThemeControl154
{

    private HorizontalAlignment _TextAlign = HorizontalAlignment.Left;
    public HorizontalAlignment TextAlign
    {
        get { return _TextAlign; }
        set
        {
            _TextAlign = value;
            if (Base != null)
            {
                Base.TextAlign = value;
            }
        }
    }
    private int _MaxLength = 32767;
    public int MaxLength
    {
        get { return _MaxLength; }
        set
        {
            _MaxLength = value;
            if (Base != null)
            {
                Base.MaxLength = value;
            }
        }
    }
    private bool _ReadOnly;
    public bool ReadOnly
    {
        get { return _ReadOnly; }
        set
        {
            _ReadOnly = value;
            if (Base != null)
            {
                Base.ReadOnly = value;
            }
        }
    }
    private bool _UseSystemPasswordChar;
    public bool UseSystemPasswordChar
    {
        get { return _UseSystemPasswordChar; }
        set
        {
            _UseSystemPasswordChar = value;
            if (Base != null)
            {
                Base.UseSystemPasswordChar = value;
            }
        }
    }
    private bool _Multiline;
    public bool Multiline
    {
        get { return _Multiline; }
        set
        {
            _Multiline = value;
            if (Base != null)
            {
                Base.Multiline = value;

                if (value)
                {
                    LockHeight = 0;
                    Base.Height = Height - 11;
                }
                else
                {
                    LockHeight = Base.Height + 11;
                }
            }
        }
    }
    public override string Text
    {
        get { return base.Text; }
        set
        {
            base.Text = value;
            if (Base != null)
            {
                Base.Text = value;
            }
        }
    }
    public override Font Font
    {
        get { return base.Font; }
        set
        {
            base.Font = value;
            if (Base != null)
            {
                Base.Font = value;
                Base.Location = new Point(3, 5);
                Base.Width = Width - 6;

                if (!_Multiline)
                {
                    LockHeight = Base.Height + 11;
                }
            }
        }
    }

    protected override void OnCreation()
    {
        if (!Controls.Contains(Base))
        {
            Controls.Add(Base);
        }
    }

    private TextBox Base;
    public GhostTextBox()
    {
        Base = new TextBox();

        Base.Font = Font;
        Base.Text = Text;
        Base.MaxLength = _MaxLength;
        Base.Multiline = _Multiline;
        Base.ReadOnly = _ReadOnly;
        Base.UseSystemPasswordChar = _UseSystemPasswordChar;

        Base.BorderStyle = BorderStyle.None;

        Base.Location = new Point(5, 5);
        Base.Width = Width - 10;

        if (_Multiline)
        {
            Base.Height = Height - 11;
        }
        else
        {
            LockHeight = Base.Height + 11;
        }

        Base.TextChanged += OnBaseTextChanged;
        Base.KeyDown += OnBaseKeyDown;


        SetColor("Text", Color.White);
        SetColor("Back", 0, 0, 0);
        SetColor("Border1", Color.Black);
        SetColor("Border2", 90, 90, 90);
    }

    private Color C1;
    private Pen P1;

    private Pen P2;
    protected override void ColorHook()
    {
        C1 = GetColor("Back");

        P1 = GetPen("Border1");
        P2 = GetPen("Border2");

        Base.ForeColor = GetColor("Text");
        Base.BackColor = C1;
    }

    protected override void PaintHook()
    {
        G.Clear(C1);

        DrawBorders(P1, 1);
        DrawBorders(P2);
    }
    private void OnBaseTextChanged(object s, EventArgs e)
    {
        Text = Base.Text;
    }
    private void OnBaseKeyDown(object s, KeyEventArgs e)
    {
        if (e.Control && e.KeyCode == Keys.A)
        {
            Base.SelectAll();
            e.SuppressKeyPress = true;
        }
    }
    protected override void OnResize(EventArgs e)
    {
        Base.Location = new Point(5, 5);
        Base.Width = Width - 10;

        if (_Multiline)
        {
            Base.Height = Height - 11;
        }


        base.OnResize(e);
    }

}

class GhostControlBox : ThemeControl154
{
    private int X;
    Color BG;
    Color Edge;
    Pen BEdge;
    protected override void ColorHook()
    {
        BG = GetColor("Background");
        Edge = GetColor("Edge color");
        BEdge = new Pen(GetColor("Button edge color"));
    }

    public GhostControlBox()
    {
        SetColor("Background", Color.FromArgb(64, 64, 64));
        SetColor("Edge color", Color.Black);
        SetColor("Button edge color", Color.FromArgb(90, 90, 90));
        this.Size = new Size(71, 19);
        this.Anchor = AnchorStyles.Top | AnchorStyles.Right;
    }

    protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
    {
        base.OnMouseMove(e);
        X = e.X;
        Invalidate();
    }

    protected override void OnClick(System.EventArgs e)
    {
        base.OnClick(e);
        if (X <= 22)
        {
            FindForm().WindowState = FormWindowState.Minimized;
        }
        else if (X > 22 & X <= 44)
        {
            if (FindForm().WindowState != FormWindowState.Maximized)
                FindForm().WindowState = FormWindowState.Maximized;
            else
                FindForm().WindowState = FormWindowState.Normal;
        }
        else if (X > 44)
        {
            FindForm().Close();
        }
    }

    protected override void PaintHook()
    {
        //Draw outer edge
        G.Clear(Edge);

        //Fill buttons
        LinearGradientBrush SB = new LinearGradientBrush(new Rectangle(new Point(1, 1), new Size(Width - 2, Height - 2)), BG, Color.FromArgb(30, 30, 30), 90f);
        G.FillRectangle(SB, new Rectangle(new Point(1, 1), new Size(Width - 2, Height - 2)));

        //Draw icons
        G.DrawString("0", new Font("Marlett", 8.25F), Brushes.White, new Point(5, 5));
        if (FindForm().WindowState != FormWindowState.Maximized)
            G.DrawString("1", new Font("Marlett", 8.25F), Brushes.White, new Point(27, 4));
        else
            G.DrawString("2", new Font("Marlett", 8.25F), Brushes.White, new Point(27, 4));
        G.DrawString("r", new Font("Marlett", 10), Brushes.White, new Point(49, 3));

        //Glassy effect
        ColorBlend CBlend = new ColorBlend(2);
        CBlend.Colors = new Color[] {
            Color.FromArgb(100, Color.Black),
            Color.Transparent
        };
        CBlend.Positions = new float[] {
            0,
            1
        };
        DrawGradient(CBlend, new Rectangle(new Point(1, 8), new Size(68, 8)), 90f);

        //Draw button outlines
        G.DrawRectangle(BEdge, new Rectangle(new Point(1, 1), new Size(20, 16)));
        G.DrawRectangle(BEdge, new Rectangle(new Point(23, 1), new Size(20, 16)));
        G.DrawRectangle(BEdge, new Rectangle(new Point(45, 1), new Size(24, 16)));

        //Mouse states
        switch (State)
        {
            case MouseState.Over:
                if (X <= 22)
                {
                    G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.White)), new Rectangle(new Point(1, 1), new Size(21, Height - 2)));
                }
                else if (X > 22 & X <= 44)
                {
                    G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.White)), new Rectangle(new Point(23, 1), new Size(21, Height - 2)));
                }
                else if (X > 44)
                {
                    G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.White)), new Rectangle(new Point(45, 1), new Size(25, Height - 2)));
                }
                break;
            case MouseState.Down:
                if (X <= 22)
                {
                    G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.Black)), new Rectangle(new Point(1, 1), new Size(21, Height - 2)));
                }
                else if (X > 22 & X <= 44)
                {
                    G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.Black)), new Rectangle(new Point(23, 1), new Size(21, Height - 2)));
                }
                else if (X > 44)
                {
                    G.FillRectangle(new SolidBrush(Color.FromArgb(20, Color.Black)), new Rectangle(new Point(45, 1), new Size(25, Height - 2)));
                }
                break;
        }
    }
}