Control.cs

/////////////////////////////////////////////////////////////////
//                                                            //
//  Neoforce Controls                                         //
//                                                            //
////////////////////////////////////////////////////////////////
//                                                            //
//         File: Control.cs                                   //
//                                                            //
//      Version: 0.7                                          //
//                                                            //
//         Date: 11/09/2010                                   //
//                                                            //
//       Author: Tom Shane                                    //
//                                                            //
////////////////////////////////////////////////////////////////
//                                                            //
//  Copyright (c) by Tom Shane                                //
//                                                            //
////////////////////////////////////////////////////////////////

#region //// Using /////////////

////////////////////////////////////////////////////////////////////////////
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

#if (!XBOX && !XBOX_FAKE)
using System.Media;
using System.Collections;
using System.ComponentModel;
#endif
////////////////////////////////////////////////////////////////////////////

#endregion

namespace TomShane.Neoforce.Controls
{

    #region //// Classes ///////////


    ////////////////////////////////////////////////////////////////////////////  
    /// <summary>
    /// Defines the gamepad actions mapping.
    /// </summary>
    public class GamePadActions
    {
        public GamePadButton Click = GamePadButton.A;
        public GamePadButton Press = GamePadButton.Y;
        public GamePadButton Left = GamePadButton.LeftStickLeft;
        public GamePadButton Right = GamePadButton.LeftStickRight;
        public GamePadButton Up = GamePadButton.LeftStickUp;
        public GamePadButton Down = GamePadButton.LeftStickDown;
        public GamePadButton NextControl = GamePadButton.RightShoulder;
        public GamePadButton PrevControl = GamePadButton.LeftShoulder;
        public GamePadButton ContextMenu = GamePadButton.X;
    }
    ////////////////////////////////////////////////////////////////////////////  

    ////////////////////////////////////////////////////////////////////////////  
    /// <summary>
    /// Defines type used as a controls collection.
    /// </summary>
    public class ControlsList : EventedList<Control>
    {
        public ControlsList() : base() { }
        public ControlsList(int capacity) : base(capacity) { }
        public ControlsList(IEnumerable<Control> collection) : base(collection) { }
    }
    ////////////////////////////////////////////////////////////////////////////  

    ////////////////////////////////////////////////////////////////////////////  
    /// <summary>
    /// Defines the base class for all controls.
    /// </summary>    
    public class Control : Component
    {

        #region //// Consts/////////////

        ////////////////////////////////////////////////////////////////////////////
        public static readonly Color UndefinedColor = new Color(255, 255, 255, 0);
        ////////////////////////////////////////////////////////////////////////////

        #endregion

        #region //// Fields ////////////

        ////////////////////////////////////////////////////////////////////////////    
        internal static ControlsList Stack = new ControlsList();
        ////////////////////////////////////////////////////////////////////////////    

#if (!XBOX && !XBOX_FAKE)
        ////////////////////////////////////////////////////////////////////////////    
        private Cursor cursor = null;
        ////////////////////////////////////////////////////////////////////////////    
#endif

        ////////////////////////////////////////////////////////////////////////////    
        private Color color = UndefinedColor;
        private Color textColor = UndefinedColor;
        private Color backColor = Color.Transparent;
        private byte alpha = 255;
        private Anchors anchor = Anchors.Left | Anchors.Top;
        private Anchors resizeEdge = Anchors.All;
        private string text = "Control";
        private bool visible = true;
        private bool enabled = true;
        private SkinControl skin = null;
        private Control parent = null;
        private Control root = null;
        private int left = 0;
        private int top = 0;
        private int width = 64;
        private int height = 64;
        private bool suspended = false;
        private ContextMenu contextMenu = null;
        private long tooltipTimer = 0;
        private long doubleClickTimer = 0;
        private MouseButton doubleClickButton = MouseButton.None;
        private Type toolTipType = typeof(ToolTip);
        private ToolTip toolTip = null;
        private bool doubleClicks = true;
        private bool outlineResizing = false;
        private bool outlineMoving = false;
        private string name = "Control";
        private object tag = null;
        private GamePadActions gamePadActions = new GamePadActions();
        private bool designMode = false;
        private bool partialOutline = true;
        private Rectangle drawingRect = Rectangle.Empty;
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////    
        private ControlsList controls = new ControlsList();
        private Rectangle movableArea = Rectangle.Empty;
        private bool passive = false;
        private bool detached = false;
        private bool movable = false;
        private bool resizable = false;
        private bool invalidated = true;
        private bool canFocus = true;
        private int resizerSize = 4;
        private int minimumWidth = 0;
        private int maximumWidth = 4096;
        private int minimumHeight = 0;
        private int maximumHeight = 4096;
        private int topModifier = 0;
        private int leftModifier = 0;
        private int virtualHeight = 64;
        private int virtualWidth = 64;
        private bool stayOnBack = false;
        private bool stayOnTop = false;
        ////////////////////////////////////////////////////////////////////////////  

        ////////////////////////////////////////////////////////////////////////////    
        private RenderTarget2D target;
        private Point pressSpot = Point.Zero;
        private int[] pressDiff = new int[4];
        private Alignment resizeArea = Alignment.None;
        private bool hovered = false;
        private bool inside = false;
        private bool[] pressed = new bool[32];
        private bool isMoving = false;
        private bool isResizing = false;
        private Margins margins = new Margins(4, 4, 4, 4);
        private Margins anchorMargins = new Margins();
        private Margins clientMargins = new Margins();
        private Rectangle outlineRect = Rectangle.Empty;
        /// <summary>
        /// Tracks the position of the mouse scroll wheel
        /// </summary>
        private int scrollWheel = 0;
        ////////////////////////////////////////////////////////////////////////////                     

        #endregion

        #region //// Properties ////////

#if (!XBOX && !XBOX_FAKE)
        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the cursor displaying over the control.
        /// </summary>
        public Cursor Cursor
        {
            get { return cursor; }
            set { cursor = value; }
        }
        ////////////////////////////////////////////////////////////////////////////
#endif

        ////////////////////////////////////////////////////////////////////////////       
        /// <summary>
        /// Gets a list of all child controls.
        /// </summary>
        public virtual IEnumerable<Control> Controls { get { return controls; } }

        /// <summary>
        /// Gets or sets a rectangular area that reacts on moving the control with the mouse.
        /// </summary>
        public virtual Rectangle MovableArea { get { return movableArea; } set { movableArea = value; } }

        /// <summary>
        /// Gets a value indicating whether this control is a child control.
        /// </summary>
        public virtual bool IsChild { get { return (parent != null); } }

        /// <summary>
        /// Gets a value indicating whether this control is a parent control.
        /// </summary>
        public virtual bool IsParent { get { return (controls != null && controls.Count > 0); } }

        /// <summary>
        /// Gets a value indicating whether this control is a root control.
        /// </summary>
        public virtual bool IsRoot { get { return (root == this); } }

        /// <summary>
        /// Gets or sets a value indicating whether this control can receive focus. 
        /// </summary>
        public virtual bool CanFocus { get { return canFocus; } set { canFocus = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this control is rendered off the parents texture.
        /// </summary>
        public virtual bool Detached { get { return detached; } set { detached = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this controls can receive user input events.
        /// </summary>
        public virtual bool Passive { get { return passive; } set { passive = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this control can be moved by the mouse.
        /// </summary>
        public virtual bool Movable { get { return movable; } set { movable = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this control can be resized by the mouse.
        /// </summary>
        public virtual bool Resizable { get { return resizable; } set { resizable = value; } }

        /// <summary>
        /// Gets or sets the size of the rectangular borders around the control used for resizing by the mouse.
        /// </summary>
        public virtual int ResizerSize { get { return resizerSize; } set { resizerSize = value; } }

        /// <summary>
        /// Gets or sets the ContextMenu associated with this control.
        /// </summary>
        public virtual ContextMenu ContextMenu { get { return contextMenu; } set { contextMenu = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this control should process mouse double-clicks.
        /// </summary>
        public virtual bool DoubleClicks { get { return doubleClicks; } set { doubleClicks = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this control should use ouline resizing.
        /// </summary>
        public virtual bool OutlineResizing { get { return outlineResizing; } set { outlineResizing = value; } }

        /// <summary>
        /// Gets or sets a value indicating whether this control should use outline moving.
        /// </summary>
        public virtual bool OutlineMoving { get { return outlineMoving; } set { outlineMoving = value; } }

        /// <summary>
        /// Gets or sets the object that contains data about the control.
        /// </summary>
        public virtual object Tag { get { return tag; } set { tag = value; } }

        /// <summary>
        /// Gets or sets the value indicating the distance from another control. Usable with StackPanel control.
        /// </summary>
        public virtual Margins Margins { get { return margins; } set { margins = value; } }

        /// <summary>
        /// Gets or sets the value indicating wheter control is in design mode.
        /// </summary>
        public virtual bool DesignMode { get { return designMode; } set { designMode = value; } }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets gamepad actions for the control.
        /// </summary>
        public virtual GamePadActions GamePadActions
        {
            get { return gamePadActions; }
            set { gamePadActions = value; }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the value indicating whether the control outline is displayed only for certain edges. 
        /// </summary>   
        public virtual bool PartialOutline
        {
            get { return partialOutline; }
            set { partialOutline = value; }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the value indicating whether the control is allowed to be brought in the front.
        /// </summary>
        public virtual bool StayOnBack
        {
            get { return stayOnBack; }
            set
            {
                if (value && stayOnTop) stayOnTop = false;
                stayOnBack = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the value indicating that the control should stay on top of other controls.
        /// </summary>
        public virtual bool StayOnTop
        {
            get { return stayOnTop; }
            set
            {
                if (value && stayOnBack) stayOnBack = false;
                stayOnTop = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets a name of the control.
        /// </summary>
        public virtual string Name
        {
            get { return name; }
            set { name = value; }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets a value indicating whether this control has input focus.
        /// </summary>
        public virtual bool Focused
        {
            get
            {
                return (Manager.FocusedControl == this);
            }
            set
            {
                this.Invalidate();
                if (value)
                {
                    bool f = Focused;
                    Manager.FocusedControl = this;
                    if (!Suspended && value && !f) OnFocusGained(new EventArgs());
                    if (Focused && Root != null && Root is Container)
                    {
                        (Root as Container).ScrollTo(this);
                    }
                }
                else
                {
                    bool f = Focused;
                    if (Manager.FocusedControl == this) Manager.FocusedControl = null;
                    if (!Suspended && !value && f) OnFocusLost(new EventArgs());
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets a value indicating current state of the control.
        /// </summary>
        public virtual ControlState ControlState
        {
            get
            {
                if (DesignMode) return ControlState.Enabled;
                else if (Suspended) return ControlState.Disabled;
                else
                {
                    if (!enabled) return ControlState.Disabled;

                    if ((IsPressed && inside) || (Focused && IsPressed)) return ControlState.Pressed;
                    else if (hovered && !IsPressed) return ControlState.Hovered;
                    else if ((Focused && !inside) || (hovered && IsPressed && !inside) || (Focused && !hovered && inside)) return ControlState.Focused;
                    else return ControlState.Enabled;
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual Type ToolTipType
        {
            get { return toolTipType; }
            set
            {
                toolTipType = value;
                if (toolTip != null)
                {
                    toolTip.Dispose();
                    toolTip = null;
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual ToolTip ToolTip
        {
            get
            {
                if (toolTip == null)
                {
                    Type[] t = new Type[1] { typeof(Manager) };
                    object[] p = new object[1] { Manager };

                    toolTip = (ToolTip)toolTipType.GetConstructor(t).Invoke(p);
                    toolTip.Init();
                    toolTip.Visible = false;
                }
                return toolTip;
            }
            set
            {
                toolTip = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal protected virtual bool IsPressed
        {
            get
            {
                for (int i = 0; i < pressed.Length - 1; i++)
                {
                    if (pressed[i]) return true;
                }
                return false;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal virtual int TopModifier
        {
            get { return topModifier; }
            set { topModifier = value; }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal virtual int LeftModifier
        {
            get { return leftModifier; }
            set { leftModifier = value; }
        }
        ////////////////////////////////////////////////////////////////////////////
        internal virtual int VirtualHeight
        {
            get { return GetVirtualHeight(); }
            //set { virtualHeight = value; }
        }
        ////////////////////////////////////////////////////////////////////////////  
        internal virtual int VirtualWidth
        {
            get { return GetVirtualWidth(); }
            //set { virtualWidth = value; }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets an area where is the control supposed to be drawn.
        /// </summary>
        public Rectangle DrawingRect
        {
            get { return drawingRect; }
            private set { drawingRect = value; }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets a value indicating whether this control should receive any events.
        /// </summary>
        public virtual bool Suspended
        {
            get { return suspended; }
            set { suspended = value; }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////
        internal protected virtual bool Hovered
        {
            get { return hovered; }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal protected virtual bool Inside
        {
            get { return inside; }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal protected virtual bool[] Pressed
        {
            get { return pressed; }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets a value indicating whether this controls is currently being moved.
        /// </summary>
        protected virtual bool IsMoving
        {
            get
            {
                return isMoving;
            }
            set
            {
                isMoving = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets a value indicating whether this controls is currently being resized.
        /// </summary>
        protected virtual bool IsResizing
        {
            get
            {
                return isResizing;
            }
            set
            {
                isResizing = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////        
        /// <summary>
        /// Gets or sets the edges of the container to which a control is bound and determines how a control is resized with its parent.
        /// </summary>
        public virtual Anchors Anchor
        {
            get
            {
                return anchor;
            }
            set
            {
                anchor = value;
                SetAnchorMargins();
                if (!Suspended) OnAnchorChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////        
        /// <summary>
        /// Gets or sets the edges of the contol which are allowed for resizing.
        /// </summary>
        public virtual Anchors ResizeEdge
        {
            get
            {
                return resizeEdge;
            }
            set
            {
                resizeEdge = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the skin used for rendering the control.
        /// </summary>
        public virtual SkinControl Skin
        {
            get
            {
                return skin;
            }
            set
            {
                skin = value;
                ClientMargins = skin.ClientMargins;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the text associated with this control.
        /// </summary>
        public virtual string Text
        {
            get { return text; }
            set
            {
                text = value;
                Invalidate();
                if (!Suspended) OnTextChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////                      

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the alpha value for this control.
        /// </summary>
        public virtual byte Alpha
        {
            get
            {
                return alpha;
            }
            set
            {
                alpha = value;
                if (!Suspended) OnAlphaChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the background color for the control.
        /// </summary>
        public virtual Color BackColor
        {
            get
            {
                return backColor;
            }
            set
            {
                backColor = value;
                Invalidate();
                if (!Suspended) OnBackColorChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the color for the control.
        /// </summary>
        public virtual Color Color
        {
            get
            {
                return color;
            }
            set
            {
                if (value != color)
                {
                    color = value;
                    Invalidate();
                    if (!Suspended) OnColorChanged(new EventArgs());
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////    
        /// <summary>
        /// Gets or sets the text color for the control.
        /// </summary>
        public virtual Color TextColor
        {
            get
            {
                return textColor;
            }
            set
            {
                if (value != textColor)
                {
                    textColor = value;
                    Invalidate();
                    if (!Suspended) OnTextColorChanged(new EventArgs());
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////  

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets a value indicating whether the control can respond to user interaction.
        /// </summary>
        public virtual bool Enabled
        {
            get
            {
                return enabled;
            }
            set
            {
                if (Root != null && Root != this && !Root.Enabled && value) return;

                enabled = value;
                Invalidate();

                foreach (Control c in controls)
                {
                    c.Enabled = value;
                }

                if (!Suspended) OnEnabledChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets a value that indicates whether the control is rendered.
        /// </summary>
        public virtual bool Visible
        {
            get
            {
                return (visible && (parent == null || parent.Visible));
            }
            set
            {
                visible = value;
                Invalidate();

                if (!Suspended) OnVisibleChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the parent for the control.
        /// </summary>
        public virtual Control Parent
        {
            get
            {
                return parent;
            }
            set
            {
                if (parent != value)
                {
                    if (value != null) value.Add(this);
                    else Manager.Add(this);
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the root for the control.
        /// </summary>
        public virtual Control Root
        {
            get
            {
                return root;
            }
            private set
            {
                if (root != value)
                {
                    root = value;

                    foreach (Control c in controls)
                    {
                        c.Root = root;
                    }

                    if (!Suspended) OnRootChanged(new EventArgs());
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////          

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the distance, in pixels, between the left edge of the control and the left edge of its parent.
        /// </summary>
        public virtual int Left
        {
            get
            {
                return left;
            }
            set
            {
                if (left != value)
                {
                    int old = left;
                    left = value;

                    SetAnchorMargins();

                    if (!Suspended) OnMove(new MoveEventArgs(left, top, old, top));
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////        
        /// <summary>
        /// Gets or sets the distance, in pixels, between the top edge of the control and the top edge of its parent.
        /// </summary>
        public virtual int Top
        {
            get
            {
                return top;
            }
            set
            {
                if (top != value)
                {
                    int old = top;
                    top = value;

                    SetAnchorMargins();

                    if (!Suspended) OnMove(new MoveEventArgs(left, top, left, old));
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Gets or sets the width of the control.
        /// </summary>
        public virtual int Width
        {
            get
            {
                return width;
            }
            set
            {
                if (value < 0 && Parent != null && value > int.MinValue)
                {
                    var mult = value / -100f;
                    value = (int)(parent.Width * mult);
                }

                if (width != value)
                {
                    int old = width;
                    width = value;

                    if (skin != null)
                    {
                        if (width + skin.OriginMargins.Horizontal > MaximumWidth) width = MaximumWidth - skin.OriginMargins.Horizontal;
                    }
                    else
                    {
                        if (width > MaximumWidth) width = MaximumWidth;
                    }
                    if (width < MinimumWidth) width = MinimumWidth;

                    if (width > 0) SetAnchorMargins();

                    if (!Suspended) OnResize(new ResizeEventArgs(width, height, old, height));
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////   
        /// <summary>
        /// Gets or sets the height of the control.
        /// </summary>
        public virtual int Height
        {
            get
            {
                return height;
            }
            set
            {
                if (value < 0 && Parent != null && value > int.MinValue)
                {
                    var mult = value / -100f;
                    value = (int)(parent.Height * mult);
                }

                if (height != value)
                {
                    int old = height;

                    height = value;

                    if (skin != null)
                    {
                        if (height + skin.OriginMargins.Vertical > MaximumHeight)
                            height = MaximumHeight - skin.OriginMargins.Vertical;
                    }
                    else
                    {
                        if (height > MaximumHeight) height = MaximumHeight;
                    }
                    if (height < MinimumHeight) height = MinimumHeight;

                    if (height > 0) SetAnchorMargins();

                    if (!Suspended) OnResize(new ResizeEventArgs(width, height, width, old));
                }

            }

        }
        ////////////////////////////////////////////////////////////////////////////       

        ////////////////////////////////////////////////////////////////////////////            
        /// <summary>
        /// Gets or sets the minimum width in pixels the control can be sized to.
        /// </summary>
        public virtual int MinimumWidth
        {
            get
            {
                return minimumWidth;
            }
            set
            {
                minimumWidth = value;
                if (minimumWidth < 0) minimumWidth = 0;
                if (minimumWidth > maximumWidth) minimumWidth = maximumWidth;
                if (width < MinimumWidth) Width = MinimumWidth;
            }
        }
        ////////////////////////////////////////////////////////////////////////////            

        ////////////////////////////////////////////////////////////////////////////            
        /// <summary>
        /// /// Gets or sets the minimum height in pixels the control can be sized to.
        /// </summary>
        public virtual int MinimumHeight
        {
            get
            {
                return minimumHeight;
            }
            set
            {
                minimumHeight = value;
                if (minimumHeight < 0) minimumHeight = 0;
                if (minimumHeight > maximumHeight) minimumHeight = maximumHeight;
                if (height < MinimumHeight) Height = MinimumHeight;
            }
        }
        ////////////////////////////////////////////////////////////////////////////            

        ////////////////////////////////////////////////////////////////////////////                
        /// <summary>
        /// /// Gets or sets the maximum width in pixels the control can be sized to.
        /// </summary>
        public virtual int MaximumWidth
        {
            get
            {
                int max = maximumWidth;
                if (max > Manager.TargetWidth) max = Manager.TargetWidth;
                return max;
            }
            set
            {
                maximumWidth = value;
                if (maximumWidth < minimumWidth) maximumWidth = minimumWidth;
                if (width > MaximumWidth) Width = MaximumWidth;
            }
        }
        ////////////////////////////////////////////////////////////////////////////            

        ////////////////////////////////////////////////////////////////////////////            
        /// <summary>
        /// Gets or sets the maximum height in pixels the control can be sized to.
        /// </summary>
        public virtual int MaximumHeight
        {
            get
            {
                int max = maximumHeight;
                if (max > Manager.TargetHeight) max = Manager.TargetHeight;
                return max;
            }
            set
            {
                maximumHeight = value;
                if (maximumHeight < minimumHeight) maximumHeight = minimumHeight;
                if (height > MaximumHeight) Height = MaximumHeight;
            }
        }
        ////////////////////////////////////////////////////////////////////////////                

        ////////////////////////////////////////////////////////////////////////////
        public virtual int AbsoluteLeft
        {
            get
            {
                if (parent == null) return left + LeftModifier;
                else if (parent.Skin == null) return parent.AbsoluteLeft + left + LeftModifier;
                else return parent.AbsoluteLeft + left - parent.Skin.OriginMargins.Left + LeftModifier;
            }
        }
        ////////////////////////////////////////////////////////////////////////////
        public virtual int AbsoluteTop
        {
            get
            {
                if (parent == null) return top + TopModifier;
                else if (parent.Skin == null) return parent.AbsoluteTop + top + TopModifier;
                else return parent.AbsoluteTop + top - parent.Skin.OriginMargins.Top + TopModifier;
            }
        }
        ////////////////////////////////////////////////////////////////////////////  

        ////////////////////////////////////////////////////////////////////////////
        public virtual int OriginLeft
        {
            get
            {
                if (skin == null) return AbsoluteLeft;
                return AbsoluteLeft - skin.OriginMargins.Left;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual int OriginTop
        {
            get
            {
                if (skin == null) return AbsoluteTop;
                return AbsoluteTop - skin.OriginMargins.Top;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////    
        public virtual int OriginWidth
        {
            get
            {
                if (skin == null) return width;
                return width + skin.OriginMargins.Left + skin.OriginMargins.Right;
            }
        }
        ////////////////////////////////////////////////////////////////////////////        

        ////////////////////////////////////////////////////////////////////////////    
        public virtual int OriginHeight
        {
            get
            {
                if (skin == null) return height;
                return height + skin.OriginMargins.Top + skin.OriginMargins.Bottom;
            }
        }
        ////////////////////////////////////////////////////////////////////////////  

        ////////////////////////////////////////////////////////////////////////////
        public virtual Margins ClientMargins
        {
            get { return clientMargins; }
            set
            {
                clientMargins = value;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual int ClientLeft
        {
            get
            {
                //if (skin == null) return Left;
                return ClientMargins.Left;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual int ClientTop
        {
            get
            {
                //if (skin == null) return Top;
                return ClientMargins.Top;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////    
        public virtual int ClientWidth
        {
            get
            {
                //if (skin == null) return Width;
                return OriginWidth - ClientMargins.Left - ClientMargins.Right;
            }
            set
            {
                Width = value + ClientMargins.Horizontal - skin.OriginMargins.Horizontal;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////    
        public virtual int ClientHeight
        {
            get
            {
                //if (skin == null) return Height;
                return OriginHeight - ClientMargins.Top - ClientMargins.Bottom;
            }
            set
            {
                Height = value + ClientMargins.Vertical - skin.OriginMargins.Vertical;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual Rectangle AbsoluteRect
        {
            get
            {
                return new Rectangle(AbsoluteLeft, AbsoluteTop, OriginWidth, OriginHeight);
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual Rectangle OriginRect
        {
            get
            {
                return new Rectangle(OriginLeft, OriginTop, OriginWidth, OriginHeight);
            }
        }
        ////////////////////////////////////////////////////////////////////////////              

        ////////////////////////////////////////////////////////////////////////////              
        public virtual Rectangle ClientRect
        {
            get
            {
                return new Rectangle(ClientLeft, ClientTop, ClientWidth, ClientHeight);
            }
        }
        ////////////////////////////////////////////////////////////////////////////              

        ////////////////////////////////////////////////////////////////////////////              
        public virtual Rectangle ControlRect
        {
            get
            {
                return new Rectangle(Left, Top, Width, Height);
            }
            set
            {
                Left = value.Left;
                Top = value.Top;
                Width = value.Width;
                Height = value.Height;
            }
        }
        ////////////////////////////////////////////////////////////////////////////              

        ////////////////////////////////////////////////////////////////////////////              
        private Rectangle OutlineRect
        {
            get { return outlineRect; }
            set
            {
                outlineRect = value;
                if (value != Rectangle.Empty)
                {
                    if (outlineRect.Width > MaximumWidth) outlineRect.Width = MaximumWidth;
                    if (outlineRect.Height > MaximumHeight) outlineRect.Height = MaximumHeight;
                    if (outlineRect.Width < MinimumWidth) outlineRect.Width = MinimumWidth;
                    if (outlineRect.Height < MinimumHeight) outlineRect.Height = MinimumHeight;
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////              

        #endregion

        #region //// Events ////////////

        ////////////////////////////////////////////////////////////////////////////        
        public event EventHandler Click;
        public event EventHandler DoubleClick;
        public event MouseEventHandler MouseDown;
        public event MouseEventHandler MousePress;
        public event MouseEventHandler MouseUp;
        public event MouseEventHandler MouseMove;
        public event MouseEventHandler MouseOver;
        public event MouseEventHandler MouseOut;
        /// <summary>
        /// Occurs when the mouse scroll wheel position changes
        /// </summary>
        public event MouseEventHandler MouseScroll;
        public event KeyEventHandler KeyDown;
        public event KeyEventHandler KeyPress;
        public event KeyEventHandler KeyUp;
        public event GamePadEventHandler GamePadDown;
        public event GamePadEventHandler GamePadUp;
        public event GamePadEventHandler GamePadPress;
        public event MoveEventHandler Move;
        public event MoveEventHandler ValidateMove;
        public event ResizeEventHandler Resize;
        public event ResizeEventHandler ValidateResize;
        public event DrawEventHandler Draw;
        public event EventHandler MoveBegin;
        public event EventHandler MoveEnd;
        public event EventHandler ResizeBegin;
        public event EventHandler ResizeEnd;
        public event EventHandler ColorChanged;
        public event EventHandler TextColorChanged;
        public event EventHandler BackColorChanged;
        public event EventHandler TextChanged;
        public event EventHandler AnchorChanged;
        public event EventHandler SkinChanging;
        public event EventHandler SkinChanged;
        public event EventHandler ParentChanged;
        public event EventHandler RootChanged;
        public event EventHandler VisibleChanged;
        public event EventHandler EnabledChanged;
        public event EventHandler AlphaChanged;
        public event EventHandler FocusLost;
        public event EventHandler FocusGained;
        public event DrawEventHandler DrawTexture;
        ////////////////////////////////////////////////////////////////////////////

        #endregion

        #region //// Constructors //////

        ////////////////////////////////////////////////////////////////////////////
        public Control(Manager manager)
            : base(manager)
        {
            if (Manager == null)
            {
                throw new Exception("Control cannot be created. Manager instance is needed.");
            }
            else if (Manager.Skin == null)
            {
                throw new Exception("Control cannot be created. No skin loaded.");
            }

            text = Utilities.DeriveControlName(this);
            root = this;

            InitSkin();

            CheckLayer(skin, "Control");

            if (Skin != null)
            {
                SetDefaultSize(width, height);
                SetMinimumSize(MinimumWidth, MinimumHeight);
                ResizerSize = skin.ResizerSize;
            }

            Stack.Add(this);
        }
        ////////////////////////////////////////////////////////////////////////////       

        #endregion

        #region //// Destructors ///////

        ////////////////////////////////////////////////////////////////////////////
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (parent != null) parent.Remove(this);
                else if (Manager != null) Manager.Remove(this);
                if (Manager.OrderList != null) Manager.OrderList.Remove(this);

                // Possibly we added the menu to another parent than this control, 
                // so we dispose it manually, beacause in logic it belongs to this control.        
                if (contextMenu != null)
                {
                    contextMenu.Dispose();
                    contextMenu = null;
                }

                // Recursively disposing all controls. The collection might change from its children, 
                // so we check it on count greater than zero.
                if (controls != null)
                {
                    int c = controls.Count;
                    for (int i = 0; i < c; i++)
                    {
                        if (controls.Count > 0)
                        {
                            controls[0].Dispose();
                        }
                    }
                }

                // Disposes tooltip owned by Manager        
                if (toolTip != null && !Manager.Disposing)
                {
                    toolTip.Dispose();
                    toolTip = null;
                }

                // Removing this control from the global stack.
                Stack.Remove(this);

                if (target != null)
                {
                    target.Dispose();
                    target = null;
                }
            }
            base.Dispose(disposing);
        }
        ////////////////////////////////////////////////////////////////////////////

        #endregion

        #region //// Methods ///////////

        #region //// Private ///////////

        ////////////////////////////////////////////////////////////////////////////   
        private int GetVirtualHeight()
        {
            if (this.Parent is Container && (this.Parent as Container).AutoScroll)
            {
                int maxy = 0;

                foreach (Control c in Controls)
                {
                    if ((c.Anchor & Anchors.Bottom) != Anchors.Bottom && c.Visible)
                    {
                        if (c.Top + c.Height > maxy) maxy = c.Top + c.Height;
                    }
                }
                if (maxy < Height) maxy = Height;

                return maxy;
            }
            else
            {
                return Height;
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////   
        private int GetVirtualWidth()
        {
            if (this.Parent is Container && (this.Parent as Container).AutoScroll)
            {
                int maxx = 0;

                foreach (Control c in Controls)
                {
                    if ((c.Anchor & Anchors.Right) != Anchors.Right && c.Visible)
                    {
                        if (c.Left + c.Width > maxx) maxx = c.Left + c.Width;
                    }
                }
                if (maxx < Width) maxx = Width;

                return maxx;
            }
            else
            {
                return Width;
            }
        }
        ////////////////////////////////////////////////////////////////////////////    

        ////////////////////////////////////////////////////////////////////////////
        private Rectangle GetClippingRect(Control c)
        {
            Rectangle r = Rectangle.Empty;

            r = new Rectangle(c.OriginLeft - root.AbsoluteLeft,
                              c.OriginTop - root.AbsoluteTop,
                              c.OriginWidth,
                              c.OriginHeight);

            int x1 = r.Left;
            int x2 = r.Right;
            int y1 = r.Top;
            int y2 = r.Bottom;

            Control ctrl = c.Parent;
            while (ctrl != null)
            {
                int cx1 = ctrl.OriginLeft - root.AbsoluteLeft;
                int cy1 = ctrl.OriginTop - root.AbsoluteTop;
                int cx2 = cx1 + ctrl.OriginWidth;
                int cy2 = cy1 + ctrl.OriginHeight;

                if (x1 < cx1) x1 = cx1;
                if (y1 < cy1) y1 = cy1;
                if (x2 > cx2) x2 = cx2;
                if (y2 > cy2) y2 = cy2;

                ctrl = ctrl.Parent;
            }

            int fx2 = x2 - x1;
            int fy2 = y2 - y1;

            if (x1 < 0) x1 = 0;
            if (y1 < 0) y1 = 0;
            if (fx2 < 0) fx2 = 0;
            if (fy2 < 0) fy2 = 0;
            if (x1 > root.Width) { x1 = root.Width; }
            if (y1 > root.Height) { y1 = root.Height; }
            if (fx2 > root.Width) fx2 = root.Width;
            if (fy2 > root.Height) fy2 = root.Height;

            Rectangle ret = new Rectangle(x1, y1, fx2, fy2);

            return ret;
        }
        ////////////////////////////////////////////////////////////////////////////       

        ////////////////////////////////////////////////////////////////////////////
        private RenderTarget2D CreateRenderTarget(int width, int height)
        {
            if (width > 0 && height > 0)
            {
                return new RenderTarget2D(Manager.GraphicsDevice,
                                          width,
                                          height,
                                          false,
                                          SurfaceFormat.Color,
                                          DepthFormat.None,
                                          Manager.GraphicsDevice.PresentationParameters.MultiSampleCount,
                                          Manager._RenderTargetUsage);

            }

            return null;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal virtual void PrepareTexture(Renderer renderer, GameTime gameTime)
        {
            if (visible)
            {
                if (invalidated)
                {
                    OnDrawTexture(new DrawEventArgs(renderer, new Rectangle(0, 0, OriginWidth, OriginHeight), gameTime));

                    if (target == null || target.Width < OriginWidth || target.Height < OriginHeight)
                    {
                        if (target != null)
                        {
                            target.Dispose();
                            target = null;
                        }

                        int w = OriginWidth + (Manager.TextureResizeIncrement - (OriginWidth % Manager.TextureResizeIncrement));
                        int h = OriginHeight + (Manager.TextureResizeIncrement - (OriginHeight % Manager.TextureResizeIncrement));

                        if (h > Manager.TargetHeight) h = Manager.TargetHeight;
                        if (w > Manager.TargetWidth) w = Manager.TargetWidth;

                        target = CreateRenderTarget(w, h);
                    }

                    if (target != null)
                    {
                        Manager.GraphicsDevice.SetRenderTarget(target);
                        target.GraphicsDevice.Clear(backColor);

                        Rectangle rect = new Rectangle(0, 0, OriginWidth, OriginHeight);
                        DrawControls(renderer, rect, gameTime, false);

                        Manager.GraphicsDevice.SetRenderTarget(null);
                    }
                    invalidated = false;
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private bool CheckDetached(Control c)
        {
            Control parent = c.Parent;
            while (parent != null)
            {
                if (parent.Detached)
                {
                    return true;
                }
                parent = parent.Parent;
            }

            return c.Detached;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void DrawChildControls(Renderer renderer, GameTime gameTime, bool firstDetachedLevel)
        {
            if (controls != null)
            {
                foreach (Control c in controls)
                {
                    // We skip detached controls for first level after root (they are rendered separately in Draw() method)
                    if (((c.Root == c.Parent && !c.Detached) || c.Root != c.Parent) && AbsoluteRect.Intersects(c.AbsoluteRect) && c.visible)
                    {
                        Manager.GraphicsDevice.ScissorRectangle = GetClippingRect(c);

                        Rectangle rect = new Rectangle(c.OriginLeft - root.AbsoluteLeft, c.OriginTop - root.AbsoluteTop, c.OriginWidth, c.OriginHeight);
                        if (c.Root != c.Parent && ((!c.Detached && CheckDetached(c)) || firstDetachedLevel))
                        {
                            rect = new Rectangle(c.OriginLeft, c.OriginTop, c.OriginWidth, c.OriginHeight);
                            Manager.GraphicsDevice.ScissorRectangle = rect;
                        }

                        renderer.Begin(BlendingMode.Default);
                        c.DrawingRect = rect;
                        c.DrawControl(renderer, rect, gameTime);

                        DrawEventArgs args = new DrawEventArgs();
                        args.Rectangle = rect;
                        args.Renderer = renderer;
                        args.GameTime = gameTime;
                        c.OnDraw(args);
                        renderer.End();

                        c.DrawChildControls(renderer, gameTime, firstDetachedLevel);

                        c.DrawOutline(renderer, true);
                    }
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////      
        private void DrawControls(Renderer renderer, Rectangle rect, GameTime gameTime, bool firstDetach)
        {
            renderer.Begin(BlendingMode.Default);

            DrawingRect = rect;
            DrawControl(renderer, rect, gameTime);

            DrawEventArgs args = new DrawEventArgs();
            args.Rectangle = rect;
            args.Renderer = renderer;
            args.GameTime = gameTime;
            OnDraw(args);

            renderer.End();

            DrawChildControls(renderer, gameTime, firstDetach);
        }
        ////////////////////////////////////////////////////////////////////////////      

        ////////////////////////////////////////////////////////////////////////////      
        private void DrawDetached(Control control, Renderer renderer, GameTime gameTime)
        {
            if (control.Controls != null)
            {
                foreach (Control c in control.Controls)
                {
                    if (c.Detached && c.Visible)
                    {
                        c.DrawControls(renderer, new Rectangle(c.OriginLeft, c.OriginTop, c.OriginWidth, c.OriginHeight), gameTime, true);
                    }
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////              

        ////////////////////////////////////////////////////////////////////////////   
        internal virtual void Render(Renderer renderer, GameTime gameTime)
        {
            if (visible && target != null)
            {
                bool draw = true;

                if (draw)
                {
                    renderer.Begin(BlendingMode.Default);
                    renderer.Draw(target, OriginLeft, OriginTop, new Rectangle(0, 0, OriginWidth, OriginHeight), Color.FromNonPremultiplied(255, 255, 255, Alpha));
                    renderer.End();

                    DrawDetached(this, renderer, gameTime);

                    DrawOutline(renderer, false);
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////       
        private void DrawOutline(Renderer renderer, bool child)
        {
            if (!OutlineRect.IsEmpty)
            {
                Rectangle r = OutlineRect;
                if (child)
                {
                    r = new Rectangle(OutlineRect.Left + (parent.AbsoluteLeft - root.AbsoluteLeft), OutlineRect.Top + (parent.AbsoluteTop - root.AbsoluteTop), OutlineRect.Width, OutlineRect.Height);
                }

                Texture2D t = Manager.Skin.Controls["Control.Outline"].Layers[0].Image.Resource;

                int s = resizerSize;
                Rectangle r1 = new Rectangle(r.Left + leftModifier, r.Top + topModifier, r.Width, s);
                Rectangle r2 = new Rectangle(r.Left + leftModifier, r.Top + s + topModifier, resizerSize, r.Height - (2 * s));
                Rectangle r3 = new Rectangle(r.Right - s + leftModifier, r.Top + s + topModifier, s, r.Height - (2 * s));
                Rectangle r4 = new Rectangle(r.Left + leftModifier, r.Bottom - s + topModifier, r.Width, s);

                Color c = Manager.Skin.Controls["Control.Outline"].Layers[0].States.Enabled.Color;

                renderer.Begin(BlendingMode.Default);
                if ((ResizeEdge & Anchors.Top) == Anchors.Top || !partialOutline) renderer.Draw(t, r1, c);
                if ((ResizeEdge & Anchors.Left) == Anchors.Left || !partialOutline) renderer.Draw(t, r2, c);
                if ((ResizeEdge & Anchors.Right) == Anchors.Right || !partialOutline) renderer.Draw(t, r3, c);
                if ((ResizeEdge & Anchors.Bottom) == Anchors.Bottom || !partialOutline) renderer.Draw(t, r4, c);
                renderer.End();
            }
            else if (DesignMode && Focused)
            {
                Rectangle r = ControlRect;
                if (child)
                {
                    r = new Rectangle(r.Left + (parent.AbsoluteLeft - root.AbsoluteLeft), r.Top + (parent.AbsoluteTop - root.AbsoluteTop), r.Width, r.Height);
                }

                Texture2D t = Manager.Skin.Controls["Control.Outline"].Layers[0].Image.Resource;

                int s = resizerSize;
                Rectangle r1 = new Rectangle(r.Left + leftModifier, r.Top + topModifier, r.Width, s);
                Rectangle r2 = new Rectangle(r.Left + leftModifier, r.Top + s + topModifier, resizerSize, r.Height - (2 * s));
                Rectangle r3 = new Rectangle(r.Right - s + leftModifier, r.Top + s + topModifier, s, r.Height - (2 * s));
                Rectangle r4 = new Rectangle(r.Left + leftModifier, r.Bottom - s + topModifier, r.Width, s);

                Color c = Manager.Skin.Controls["Control.Outline"].Layers[0].States.Enabled.Color;

                renderer.Begin(BlendingMode.Default);
                renderer.Draw(t, r1, c);
                renderer.Draw(t, r2, c);
                renderer.Draw(t, r3, c);
                renderer.Draw(t, r4, c);
                renderer.End();
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////
        public virtual void SetPosition(int left, int top)
        {
            this.left = left;
            this.top = top;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual void SetSize(int width, int height)
        {
            this.width = width;
            this.height = height;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        internal void SetAnchorMargins()
        {
            if (Parent != null)
            {
                anchorMargins.Left = Left;
                anchorMargins.Top = Top;
                anchorMargins.Right = Parent.VirtualWidth - Width - Left;
                anchorMargins.Bottom = Parent.VirtualHeight - Height - Top;
            }
            else
            {
                anchorMargins = new Margins();
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void ProcessAnchor(ResizeEventArgs e)
        {
            if (((Anchor & Anchors.Right) == Anchors.Right) && ((Anchor & Anchors.Left) != Anchors.Left))
            {
                Left = Parent.VirtualWidth - Width - anchorMargins.Right;
            }
            else if (((Anchor & Anchors.Right) == Anchors.Right) && ((Anchor & Anchors.Left) == Anchors.Left))
            {
                Width = Parent.VirtualWidth - Left - anchorMargins.Right;
            }
            else if (((Anchor & Anchors.Right) != Anchors.Right) && ((Anchor & Anchors.Left) != Anchors.Left))
            {
                int diff = (e.Width - e.OldWidth);
                if (e.Width % 2 != 0 && diff != 0)
                {
                    diff += (diff / Math.Abs(diff));
                }
                Left += (diff / 2);
            }
            if (((Anchor & Anchors.Bottom) == Anchors.Bottom) && ((Anchor & Anchors.Top) != Anchors.Top))
            {
                Top = Parent.VirtualHeight - Height - anchorMargins.Bottom;
            }
            else if (((Anchor & Anchors.Bottom) == Anchors.Bottom) && ((Anchor & Anchors.Top) == Anchors.Top))
            {
                Height = Parent.VirtualHeight - Top - anchorMargins.Bottom;
            }
            else if (((Anchor & Anchors.Bottom) != Anchors.Bottom) && ((Anchor & Anchors.Top) != Anchors.Top))
            {
                int diff = (e.Height - e.OldHeight);
                if (e.Height % 2 != 0 && diff != 0)
                {
                    diff += (diff / Math.Abs(diff));
                }
                Top += (diff / 2);
            }
        }
        //////////////////////////////////////////////////////////////////////////// 

        #endregion

        #region //// Protected /////////

        ////////////////////////////////////////////////////////////////////////////
        public override void Init()
        {
            base.Init();

            OnMove(new MoveEventArgs());
            OnResize(new ResizeEventArgs());
        }
        //////////////////////////////////////////////////////////////////////////// 

        ////////////////////////////////////////////////////////////////////////////
        protected internal virtual void InitSkin()
        {
            if (Manager != null && Manager.Skin != null && Manager.Skin.Controls != null)
            {
                SkinControl s = Manager.Skin.Controls[Utilities.DeriveControlName(this)];
                if (s != null) Skin = new SkinControl(s);
                else Skin = new SkinControl(Manager.Skin.Controls["Control"]);
            }
            else
            {
                throw new Exception("Control skin cannot be initialized. No skin loaded.");
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void SetDefaultSize(int width, int height)
        {
            if (skin.DefaultSize.Width > 0) Width = skin.DefaultSize.Width;
            else Width = width;
            if (skin.DefaultSize.Height > 0) Height = skin.DefaultSize.Height;
            else Height = height;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void SetMinimumSize(int minimumWidth, int minimumHeight)
        {
            if (skin.MinimumSize.Width > 0) MinimumWidth = skin.MinimumSize.Width;
            else MinimumWidth = minimumWidth;
            if (skin.MinimumSize.Height > 0) MinimumHeight = skin.MinimumSize.Height;
            else MinimumHeight = minimumHeight;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal void OnDeviceSettingsChanged(DeviceEventArgs e)
        {
            if (!e.Handled)
            {
                Invalidate();
            }
        }
        //////////////////////////////////////////////////////////////////////////// 

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void DrawControl(Renderer renderer, Rectangle rect, GameTime gameTime)
        {
            if (backColor != UndefinedColor && backColor != Color.Transparent)
            {
                renderer.Draw(Manager.Skin.Images["Control"].Resource, rect, backColor);
            }
            renderer.DrawLayer(this, skin.Layers[0], rect);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal override void Update(GameTime gameTime)
        {
            base.Update(gameTime);

            ToolTipUpdate();

            if (controls != null)
            {
                ControlsList list = new ControlsList();
                list.AddRange(controls);
                foreach (Control c in list)
                {
                    c.Update(gameTime);
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal virtual void CheckLayer(SkinControl skin, string layer)
        {
            if (!(skin != null && skin.Layers != null && skin.Layers.Count > 0 && skin.Layers[layer] != null))
            {
                throw new Exception("Unable to read skin layer \"" + layer + "\" for control \"" + Utilities.DeriveControlName(this) + "\".");
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal virtual void CheckLayer(SkinControl skin, int layer)
        {
            if (!(skin != null && skin.Layers != null && skin.Layers.Count > 0 && skin.Layers[layer] != null))
            {
                throw new Exception("Unable to read skin layer with index \"" + layer.ToString() + "\" for control \"" + Utilities.DeriveControlName(this) + "\".");
            }
        }
        ////////////////////////////////////////////////////////////////////////////            

        #endregion

        #region //// Public ////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual Control GetControl(string name)
        {
            Control ret = null;
            foreach (Control c in Controls)
            {
                if (c.Name.ToLower() == name.ToLower())
                {
                    ret = c;
                    break;
                }
                else
                {
                    ret = c.GetControl(name);
                    if (ret != null) break;
                }
            }
            return ret;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual void Add(Control control)
        {
            if (control != null)
            {
                if (!controls.Contains(control))
                {
                    if (control.Parent != null) control.Parent.Remove(control);
                    else Manager.Remove(control);

                    control.Manager = Manager;
                    control.parent = this;
                    control.Root = root;
                    control.Enabled = (Enabled ? control.Enabled : Enabled);
                    controls.Add(control);

                    virtualHeight = GetVirtualHeight();
                    virtualWidth = GetVirtualWidth();

                    Manager.DeviceSettingsChanged += new DeviceEventHandler(control.OnDeviceSettingsChanged);
                    Manager.SkinChanging += new SkinEventHandler(control.OnSkinChanging);
                    Manager.SkinChanged += new SkinEventHandler(control.OnSkinChanged);
                    Resize += new ResizeEventHandler(control.OnParentResize);

                    control.SetAnchorMargins();

                    if (!Suspended) OnParentChanged(new EventArgs());
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual void Remove(Control control)
        {
            if (control != null)
            {
                if (control.Focused && control.Root != null) control.Root.Focused = true;
                else if (control.Focused) control.Focused = false;

                controls.Remove(control);

                control.parent = null;
                control.Root = control;

                Resize -= control.OnParentResize;
                Manager.DeviceSettingsChanged -= control.OnDeviceSettingsChanged;
                Manager.SkinChanging -= control.OnSkinChanging;
                Manager.SkinChanged -= control.OnSkinChanged;

                if (!Suspended) OnParentChanged(new EventArgs());
            }
        }
        ////////////////////////////////////////////////////////////////////////////     

        ////////////////////////////////////////////////////////////////////////////     
        public virtual bool Contains(Control control, bool recursively)
        {
            if (Controls != null)
            {
                foreach (Control c in Controls)
                {
                    if (c == control) return true;
                    if (recursively && c.Contains(control, true)) return true;
                }
            }
            return false;
        }
        ////////////////////////////////////////////////////////////////////////////     

        ////////////////////////////////////////////////////////////////////////////
        public virtual void Invalidate()
        {
            invalidated = true;

            if (parent != null)
            {
                parent.Invalidate();
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual void BringToFront()
        {
            if (Manager != null) Manager.BringToFront(this);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual void SendToBack()
        {
            if (Manager != null) Manager.SendToBack(this);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        public virtual void Show()
        {
            Visible = true;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////     
        public virtual void Hide()
        {
            Visible = false;
        }
        ////////////////////////////////////////////////////////////////////////////     

        ////////////////////////////////////////////////////////////////////////////
        public virtual void Refresh()
        {
            OnMove(new MoveEventArgs(left, top, left, top));
            OnResize(new ResizeEventArgs(width, height, width, height));
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////   
        public virtual void SendMessage(Message message, EventArgs e)
        {
            MessageProcess(message, e);
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////   
        protected virtual void MessageProcess(Message message, EventArgs e)
        {
            switch (message)
            {
                case Message.Click:
                    {
                        ClickProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MouseDown:
                    {
                        MouseDownProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MouseUp:
                    {
                        MouseUpProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MousePress:
                    {
                        MousePressProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MouseScroll:
                    {
                        MouseScrollProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MouseMove:
                    {
                        MouseMoveProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MouseOver:
                    {
                        MouseOverProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.MouseOut:
                    {
                        MouseOutProcess(e as MouseEventArgs);
                        break;
                    }
                case Message.GamePadDown:
                    {
                        GamePadDownProcess(e as GamePadEventArgs);
                        break;
                    }
                case Message.GamePadUp:
                    {
                        GamePadUpProcess(e as GamePadEventArgs);
                        break;
                    }
                case Message.GamePadPress:
                    {
                        GamePadPressProcess(e as GamePadEventArgs);
                        break;
                    }
                case Message.KeyDown:
                    {
                        KeyDownProcess(e as KeyEventArgs);
                        break;
                    }
                case Message.KeyUp:
                    {
                        KeyUpProcess(e as KeyEventArgs);
                        break;
                    }
                case Message.KeyPress:
                    {
                        KeyPressProcess(e as KeyEventArgs);
                        break;
                    }
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        #endregion

        #region //// GamePad ///////////

        ////////////////////////////////////////////////////////////////////////////    
        private void GamePadPressProcess(GamePadEventArgs e)
        {
            Invalidate();
            if (!Suspended) OnGamePadPress(e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void GamePadUpProcess(GamePadEventArgs e)
        {
            Invalidate();

            if (e.Button == GamePadActions.Press && pressed[(int)e.Button])
            {
                pressed[(int)e.Button] = false;
            }

            if (!Suspended) OnGamePadUp(e);

            if (e.Button == GamePadActions.ContextMenu && !e.Handled)
            {
                if (contextMenu != null)
                {
                    contextMenu.Show(this, AbsoluteLeft + 8, AbsoluteTop + 8);
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void GamePadDownProcess(GamePadEventArgs e)
        {
            Invalidate();

            ToolTipOut();

            if (e.Button == GamePadActions.Press && !IsPressed)
            {
                pressed[(int)e.Button] = true;
            }

            if (!Suspended) OnGamePadDown(e);
        }
        ////////////////////////////////////////////////////////////////////////////   

        #endregion

        #region //// Keyboard //////////

        ////////////////////////////////////////////////////////////////////////////    
        private void KeyPressProcess(KeyEventArgs e)
        {
            Invalidate();
            if (!Suspended) OnKeyPress(e);
        }
        ////////////////////////////////////////////////////////////////////////////        


        ////////////////////////////////////////////////////////////////////////////
        private void KeyDownProcess(KeyEventArgs e)
        {
            Invalidate();

            ToolTipOut();

            if (e.Key == Microsoft.Xna.Framework.Input.Keys.Space && !IsPressed)
            {
                pressed[(int)MouseButton.None] = true;
            }

            if (!Suspended) OnKeyDown(e);
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////
        private void KeyUpProcess(KeyEventArgs e)
        {
            Invalidate();

            if (e.Key == Microsoft.Xna.Framework.Input.Keys.Space && pressed[(int)MouseButton.None])
            {
                pressed[(int)MouseButton.None] = false;
            }

            if (!Suspended) OnKeyUp(e);

            if (e.Key == Microsoft.Xna.Framework.Input.Keys.Apps && !e.Handled)
            {
                if (contextMenu != null)
                {
                    contextMenu.Show(this, AbsoluteLeft + 8, AbsoluteTop + 8);
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        #endregion

        #region //// Mouse /////////////

        ////////////////////////////////////////////////////////////////////////////
        private void MouseDownProcess(MouseEventArgs e)
        {
            Invalidate();
            pressed[(int)e.Button] = true;

            if (e.Button == MouseButton.Left)
            {
                pressSpot = new Point(TransformPosition(e).Position.X, TransformPosition(e).Position.Y);

                if (CheckResizableArea(e.Position))
                {
                    pressDiff[0] = pressSpot.X;
                    pressDiff[1] = pressSpot.Y;
                    pressDiff[2] = Width - pressSpot.X;
                    pressDiff[3] = Height - pressSpot.Y;

                    IsResizing = true;
                    if (outlineResizing) OutlineRect = ControlRect;
                    if (!Suspended) OnResizeBegin(e);
                }
                else if (CheckMovableArea(e.Position))
                {
                    IsMoving = true;
                    if (outlineMoving) OutlineRect = ControlRect;
                    if (!Suspended) OnMoveBegin(e);
                }
            }

            ToolTipOut();

            if (!Suspended) OnMouseDown(TransformPosition(e));
        }
        ////////////////////////////////////////////////////////////////////////////      

        ////////////////////////////////////////////////////////////////////////////
        private void MouseUpProcess(MouseEventArgs e)
        {
            Invalidate();
            if (pressed[(int)e.Button] || isMoving || isResizing)
            {
                pressed[(int)e.Button] = false;

                if (e.Button == MouseButton.Left)
                {
                    if (IsResizing)
                    {
                        IsResizing = false;
                        if (outlineResizing)
                        {
                            Left = OutlineRect.Left;
                            Top = OutlineRect.Top;
                            Width = OutlineRect.Width;
                            Height = OutlineRect.Height;
                            OutlineRect = Rectangle.Empty;
                        }
                        if (!Suspended) OnResizeEnd(e);
                    }
                    else if (IsMoving)
                    {
                        IsMoving = false;
                        if (outlineMoving)
                        {
                            Left = OutlineRect.Left;
                            Top = OutlineRect.Top;
                            OutlineRect = Rectangle.Empty;
                        }
                        if (!Suspended) OnMoveEnd(e);
                    }
                }
                if (!Suspended) OnMouseUp(TransformPosition(e));
            }
        }
        ////////////////////////////////////////////////////////////////////////////  

        ////////////////////////////////////////////////////////////////////////////
        void MousePressProcess(MouseEventArgs e)
        {
            if (pressed[(int)e.Button] && !IsMoving && !IsResizing)
            {
                if (!Suspended) OnMousePress(TransformPosition(e));
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        void MouseScrollProcess(MouseEventArgs e)
        {
            if (!IsMoving && !IsResizing && !Suspended)
            {
                OnMouseScroll(e);
            }
        }

        ////////////////////////////////////////////////////////////////////////////
        private void MouseOverProcess(MouseEventArgs e)
        {
            Invalidate();
            hovered = true;
            ToolTipOver();

#if (!XBOX && !XBOX_FAKE)
            if (cursor != null && Manager.Cursor != cursor) Manager.Cursor = cursor;
#endif

            if (!Suspended) OnMouseOver(e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void MouseOutProcess(MouseEventArgs e)
        {
            Invalidate();
            hovered = false;
            ToolTipOut();

#if (!XBOX && !XBOX_FAKE)
            Manager.Cursor = Manager.Skin.Cursors["Default"].Resource;
#endif

            if (!Suspended) OnMouseOut(e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void MouseMoveProcess(MouseEventArgs e)
        {
            if (CheckPosition(e.Position) && !inside)
            {
                inside = true;
                Invalidate();
            }
            else if (!CheckPosition(e.Position) && inside)
            {
                inside = false;
                Invalidate();
            }

            PerformResize(e);

            if (!IsResizing && IsMoving)
            {
                int x = (parent != null) ? parent.AbsoluteLeft : 0;
                int y = (parent != null) ? parent.AbsoluteTop : 0;

                int l = e.Position.X - x - pressSpot.X - leftModifier;
                int t = e.Position.Y - y - pressSpot.Y - topModifier;

                if (!Suspended)
                {
                    MoveEventArgs v = new MoveEventArgs(l, t, Left, Top);
                    OnValidateMove(v);

                    l = v.Left;
                    t = v.Top;
                }

                if (outlineMoving)
                {
                    OutlineRect = new Rectangle(l, t, OutlineRect.Width, OutlineRect.Height);
                    if (parent != null) parent.Invalidate();
                }
                else
                {
                    Left = l;
                    Top = t;
                }
            }

            if (!Suspended)
            {
                OnMouseMove(TransformPosition(e));
            }
        }
        ////////////////////////////////////////////////////////////////////////////      

        ////////////////////////////////////////////////////////////////////////////
        private void ClickProcess(EventArgs e)
        {
            long timer = (long)TimeSpan.FromTicks(DateTime.Now.Ticks).TotalMilliseconds;

            MouseEventArgs ex = (e is MouseEventArgs) ? (MouseEventArgs)e : new MouseEventArgs();

            if ((doubleClickTimer == 0 || (timer - doubleClickTimer > Manager.DoubleClickTime)) ||
                !doubleClicks)
            {
                TimeSpan ts = new TimeSpan(DateTime.Now.Ticks);
                doubleClickTimer = (long)ts.TotalMilliseconds;
                doubleClickButton = ex.Button;

                if (!Suspended) OnClick(e);


            }
            else if (timer - doubleClickTimer <= Manager.DoubleClickTime && (ex.Button == doubleClickButton && ex.Button != MouseButton.None))
            {
                doubleClickTimer = 0;
                if (!Suspended) OnDoubleClick(e);
            }
            else
            {
                doubleClickButton = MouseButton.None;
            }

            if (ex.Button == MouseButton.Right && contextMenu != null && !e.Handled)
            {
                contextMenu.Show(this, ex.Position.X, ex.Position.Y);
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void ToolTipUpdate()
        {
            if (Manager.ToolTipsEnabled && toolTip != null && tooltipTimer > 0 && (TimeSpan.FromTicks(DateTime.Now.Ticks).TotalMilliseconds - tooltipTimer) >= Manager.ToolTipDelay)
            {
                tooltipTimer = 0;
                toolTip.Visible = true;
                Manager.Add(toolTip);
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void ToolTipOver()
        {
            if (Manager.ToolTipsEnabled && toolTip != null && tooltipTimer == 0)
            {
                TimeSpan ts = new TimeSpan(DateTime.Now.Ticks);
                tooltipTimer = (long)ts.TotalMilliseconds;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void ToolTipOut()
        {
            if (Manager.ToolTipsEnabled && toolTip != null)
            {
                tooltipTimer = 0;
                toolTip.Visible = false;
                Manager.Remove(toolTip);
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private bool CheckPosition(Point pos)
        {
            if ((pos.X >= AbsoluteLeft) && (pos.X < AbsoluteLeft + Width))
            {
                if ((pos.Y >= AbsoluteTop) && (pos.Y < AbsoluteTop + Height))
                {
                    return true;
                }
            }
            return false;
        }
        ////////////////////////////////////////////////////////////////////////////                           

        ////////////////////////////////////////////////////////////////////////////
        private bool CheckMovableArea(Point pos)
        {
            if (movable)
            {
                Rectangle rect = movableArea;

                if (rect == Rectangle.Empty)
                {
                    rect = new Rectangle(0, 0, width, height);
                }

                pos.X -= AbsoluteLeft;
                pos.Y -= AbsoluteTop;

                if ((pos.X >= rect.X) && (pos.X < rect.X + rect.Width))
                {
                    if ((pos.Y >= rect.Y) && (pos.Y < rect.Y + rect.Height))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private bool CheckResizableArea(Point pos)
        {
            if (resizable)
            {
                pos.X -= AbsoluteLeft;
                pos.Y -= AbsoluteTop;

                if ((pos.X >= 0 && pos.X < resizerSize && pos.Y >= 0 && pos.Y < Height) ||
                    (pos.X >= Width - resizerSize && pos.X < Width && pos.Y >= 0 && pos.Y < Height) ||
                    (pos.Y >= 0 && pos.Y < resizerSize && pos.X >= 0 && pos.X < Width) ||
                    (pos.Y >= Height - resizerSize && pos.Y < Height && pos.X >= 0 && pos.X < Width))
                {
                    return true;
                }
            }
            return false;
        }
        ////////////////////////////////////////////////////////////////////////////                

        ////////////////////////////////////////////////////////////////////////////
        protected MouseEventArgs TransformPosition(MouseEventArgs e)
        {
            MouseEventArgs ee = new MouseEventArgs(e.State, e.Button, e.Position);
            ee.Difference = e.Difference;

            ee.Position.X = ee.State.X - AbsoluteLeft;
            ee.Position.Y = ee.State.Y - AbsoluteTop;
            return ee;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private int CheckWidth(ref int w)
        {
            int diff = 0;

            if (w > MaximumWidth)
            {
                diff = MaximumWidth - w;
                w = MaximumWidth;
            }
            if (w < MinimumWidth)
            {
                diff = MinimumWidth - w;
                w = MinimumWidth;
            }

            return diff;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private int CheckHeight(ref int h)
        {
            int diff = 0;

            if (h > MaximumHeight)
            {
                diff = MaximumHeight - h;
                h = MaximumHeight;
            }
            if (h < MinimumHeight)
            {
                diff = MinimumHeight - h;
                h = MinimumHeight;
            }

            return diff;
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////   
        private void PerformResize(MouseEventArgs e)
        {
            if (resizable && !IsMoving)
            {
                if (!IsResizing)
                {
#if (!XBOX && !XBOX_FAKE)
                    GetResizePosition(e);
                    Manager.Cursor = Cursor = GetResizeCursor();
#endif
                }

                if (IsResizing)
                {
                    invalidated = true;

                    bool top = false;
                    bool bottom = false;
                    bool left = false;
                    bool right = false;

                    if ((resizeArea == Alignment.TopCenter ||
                        resizeArea == Alignment.TopLeft ||
                        resizeArea == Alignment.TopRight) && (resizeEdge & Anchors.Top) == Anchors.Top) top = true;

                    else if ((resizeArea == Alignment.BottomCenter ||
                             resizeArea == Alignment.BottomLeft ||
                             resizeArea == Alignment.BottomRight) && (resizeEdge & Anchors.Bottom) == Anchors.Bottom) bottom = true;

                    if ((resizeArea == Alignment.MiddleLeft ||
                        resizeArea == Alignment.BottomLeft ||
                        resizeArea == Alignment.TopLeft) && (resizeEdge & Anchors.Left) == Anchors.Left) left = true;

                    else if ((resizeArea == Alignment.MiddleRight ||
                             resizeArea == Alignment.BottomRight ||
                             resizeArea == Alignment.TopRight) && (resizeEdge & Anchors.Right) == Anchors.Right) right = true;

                    int w = Width;
                    int h = Height;
                    int l = Left;
                    int t = Top;

                    if (outlineResizing && !OutlineRect.IsEmpty)
                    {
                        l = OutlineRect.Left;
                        t = OutlineRect.Top;
                        w = OutlineRect.Width;
                        h = OutlineRect.Height;
                    }

                    int px = e.Position.X - (parent != null ? parent.AbsoluteLeft : 0);
                    int py = e.Position.Y - (parent != null ? parent.AbsoluteTop : 0);

                    if (left)
                    {
                        w = w + (l - px) + leftModifier + pressDiff[0];
                        l = px - leftModifier - pressDiff[0] - CheckWidth(ref w);

                    }
                    else if (right)
                    {
                        w = px - l - leftModifier + pressDiff[2];
                        CheckWidth(ref w);
                    }

                    if (top)
                    {
                        h = h + (t - py) + topModifier + pressDiff[1];
                        t = py - topModifier - pressDiff[1] - CheckHeight(ref h);
                    }
                    else if (bottom)
                    {
                        h = py - t - topModifier + pressDiff[3];
                        CheckHeight(ref h);
                    }

                    if (!Suspended)
                    {
                        ResizeEventArgs v = new ResizeEventArgs(w, h, Width, Height);
                        OnValidateResize(v);

                        if (top)
                        {
                            // Compensate for a possible height change from Validate event
                            t += (h - v.Height);
                        }
                        if (left)
                        {
                            // Compensate for a possible width change from Validate event
                            l += (w - v.Width);
                        }
                        w = v.Width;
                        h = v.Height;
                    }

                    if (outlineResizing)
                    {
                        OutlineRect = new Rectangle(l, t, w, h);
                        if (parent != null) parent.Invalidate();
                    }
                    else
                    {
                        Width = w;
                        Height = h;
                        Top = t;
                        Left = l;
                    }
                }
            }
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////
#if (!XBOX && !XBOX_FAKE)
        private Cursor GetResizeCursor()
        {
            Cursor cur = Cursor;
            switch (resizeArea)
            {
                case Alignment.TopCenter:
                    {
                        return ((resizeEdge & Anchors.Top) == Anchors.Top) ? Manager.Skin.Cursors["Vertical"].Resource : Cursor;
                    }
                case Alignment.BottomCenter:
                    {
                        return ((resizeEdge & Anchors.Bottom) == Anchors.Bottom) ? Manager.Skin.Cursors["Vertical"].Resource : Cursor;
                    }
                case Alignment.MiddleLeft:
                    {
                        return ((resizeEdge & Anchors.Left) == Anchors.Left) ? Manager.Skin.Cursors["Horizontal"].Resource : Cursor;
                    }
                case Alignment.MiddleRight:
                    {
                        return ((resizeEdge & Anchors.Right) == Anchors.Right) ? Manager.Skin.Cursors["Horizontal"].Resource : Cursor;
                    }
                case Alignment.TopLeft:
                    {
                        return ((resizeEdge & Anchors.Left) == Anchors.Left && (resizeEdge & Anchors.Top) == Anchors.Top) ? Manager.Skin.Cursors["DiagonalLeft"].Resource : Cursor;
                    }
                case Alignment.BottomRight:
                    {
                        return ((resizeEdge & Anchors.Bottom) == Anchors.Bottom && (resizeEdge & Anchors.Right) == Anchors.Right) ? Manager.Skin.Cursors["DiagonalLeft"].Resource : Cursor;
                    }
                case Alignment.TopRight:
                    {
                        return ((resizeEdge & Anchors.Top) == Anchors.Top && (resizeEdge & Anchors.Right) == Anchors.Right) ? Manager.Skin.Cursors["DiagonalRight"].Resource : Cursor;
                    }
                case Alignment.BottomLeft:
                    {
                        return ((resizeEdge & Anchors.Bottom) == Anchors.Bottom && (resizeEdge & Anchors.Left) == Anchors.Left) ? Manager.Skin.Cursors["DiagonalRight"].Resource : Cursor;
                    }
            }
            return Manager.Skin.Cursors["Default"].Resource;
        }
#endif
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        private void GetResizePosition(MouseEventArgs e)
        {
            int x = e.Position.X - AbsoluteLeft;
            int y = e.Position.Y - AbsoluteTop;
            bool l = false, t = false, r = false, b = false;

            resizeArea = Alignment.None;

            if (CheckResizableArea(e.Position))
            {
                if (x < resizerSize) l = true;
                if (x >= Width - resizerSize) r = true;
                if (y < resizerSize) t = true;
                if (y >= Height - resizerSize) b = true;

                if (l && t) resizeArea = Alignment.TopLeft;
                else if (l && b) resizeArea = Alignment.BottomLeft;
                else if (r && t) resizeArea = Alignment.TopRight;
                else if (r && b) resizeArea = Alignment.BottomRight;
                else if (l) resizeArea = Alignment.MiddleLeft;
                else if (t) resizeArea = Alignment.TopCenter;
                else if (r) resizeArea = Alignment.MiddleRight;
                else if (b) resizeArea = Alignment.BottomCenter;
            }
            else
            {
                resizeArea = Alignment.None;
            }
        }
        ////////////////////////////////////////////////////////////////////////////

        #endregion

        #region //// Handlers //////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMouseUp(MouseEventArgs e)
        {
            if (MouseUp != null) MouseUp.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMouseDown(MouseEventArgs e)
        {
            if (MouseDown != null) MouseDown.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMouseMove(MouseEventArgs e)
        {
            if (MouseMove != null) MouseMove.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMouseOver(MouseEventArgs e)
        {
            if (MouseOver != null) MouseOver.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////       

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMouseOut(MouseEventArgs e)
        {
            if (MouseOut != null) MouseOut.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////           

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnClick(EventArgs e)
        {
            if (Click != null) Click.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnDoubleClick(EventArgs e)
        {
            if (DoubleClick != null) DoubleClick.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMove(MoveEventArgs e)
        {
            if (parent != null) parent.Invalidate();
            if (Move != null) Move.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////                               

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnResize(ResizeEventArgs e)
        {
            Invalidate();
            if (Resize != null) Resize.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnValidateResize(ResizeEventArgs e)
        {
            if (ValidateResize != null) ValidateResize.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnValidateMove(MoveEventArgs e)
        {
            if (ValidateMove != null) ValidateMove.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////          


        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMoveBegin(EventArgs e)
        {
            if (MoveBegin != null) MoveBegin.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMoveEnd(EventArgs e)
        {
            if (MoveEnd != null) MoveEnd.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnResizeBegin(EventArgs e)
        {
            if (ResizeBegin != null) ResizeBegin.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnResizeEnd(EventArgs e)
        {
            if (ResizeEnd != null) ResizeEnd.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnParentResize(object sender, ResizeEventArgs e)
        {
            ProcessAnchor(e);
        }
        ////////////////////////////////////////////////////////////////////////////      

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnKeyUp(KeyEventArgs e)
        {
            if (KeyUp != null) KeyUp.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnKeyDown(KeyEventArgs e)
        {
            if (KeyDown != null) KeyDown.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnKeyPress(KeyEventArgs e)
        {
            if (KeyPress != null) KeyPress.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnGamePadUp(GamePadEventArgs e)
        {
            if (GamePadUp != null) GamePadUp.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnGamePadDown(GamePadEventArgs e)
        {
            if (GamePadDown != null) GamePadDown.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnGamePadPress(GamePadEventArgs e)
        {
            if (GamePadPress != null) GamePadPress.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal void OnDraw(DrawEventArgs e)
        {
            if (Draw != null) Draw.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////   

        ////////////////////////////////////////////////////////////////////////////
        protected void OnDrawTexture(DrawEventArgs e)
        {
            if (DrawTexture != null) DrawTexture.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////   


        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnColorChanged(EventArgs e)
        {
            if (ColorChanged != null) ColorChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnTextColorChanged(EventArgs e)
        {
            if (TextColorChanged != null) TextColorChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnBackColorChanged(EventArgs e)
        {
            if (BackColorChanged != null) BackColorChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnTextChanged(EventArgs e)
        {
            if (TextChanged != null) TextChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnAnchorChanged(EventArgs e)
        {
            if (AnchorChanged != null) AnchorChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal virtual void OnSkinChanged(EventArgs e)
        {
            if (SkinChanged != null) SkinChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected internal virtual void OnSkinChanging(EventArgs e)
        {
            if (SkinChanging != null) SkinChanging.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnParentChanged(EventArgs e)
        {
            if (ParentChanged != null) ParentChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnRootChanged(EventArgs e)
        {
            if (RootChanged != null) RootChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnVisibleChanged(EventArgs e)
        {
            if (VisibleChanged != null) VisibleChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnEnabledChanged(EventArgs e)
        {
            if (EnabledChanged != null) EnabledChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnAlphaChanged(EventArgs e)
        {
            if (AlphaChanged != null) AlphaChanged.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnFocusLost(EventArgs e)
        {
            if (FocusLost != null) FocusLost.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnFocusGained(EventArgs e)
        {
            if (FocusGained != null) FocusGained.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        protected virtual void OnMousePress(MouseEventArgs e)
        {
            if (MousePress != null) MousePress.Invoke(this, e);
        }
        ////////////////////////////////////////////////////////////////////////////

        protected virtual void OnMouseScroll(MouseEventArgs e)
        {
            if (MouseScroll != null) MouseScroll.Invoke(this, e);
        }

        #endregion

        #endregion

    }
    ////////////////////////////////////////////////////////////////////////////

    #endregion

}