using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;

namespace DevComponents.DotNetBar.Layout
{
    /// <summary>
    /// Represents the base item for layout control.
    /// </summary>
    [ToolboxItem(false), DesignTimeVisible(false)]
    [Designer("DevComponents.DotNetBar.Layout.Design.LayoutItemBaseDesigner, DevComponents.DotNetBar.Layout.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=7eb7c3a35b91de04")]
    public class LayoutItemBase : IComponent, IDisposable, INotifyPropertyChanged
    {
        #region Constructor
        /// <summary>
        /// Initializes a new instance of the LayoutItemBase class.
        /// </summary>
        public LayoutItemBase()
        {
            _Style = new SimpleStyle();
            _Style.PropertyChanged += StylePropertyChanged;
        }
        #endregion

        #region Implementation
        /// <summary>
        /// Paints the item. Actual code doing painting goes into the OnPaint method which should be overridden.
        /// </summary>
        /// <param name="context">Provides Paint Context.</param>
        internal void Paint(PaintContext context)
        {
            OnPaint(context);
        }
        /// <summary>
        /// Paints the background of the item.
        /// </summary>
        /// <param name="context"></param>
        protected virtual void OnPaintBackground(PaintContext context)
        {
            Rectangle bounds = _Bounds;
            Graphics g = context.Graphics;

            if (_Style.IsPainted)
            {
                DrawingHelpers.PaintStyle(g, _Style, bounds);
            }
        }
        protected virtual void PaintText(PaintContext context, bool isImageVisible, Color textColor, Rectangle textBounds, Brush textBrush)
        {
            Graphics g = context.Graphics;
            eTextAlignment textAlign = _TextAlignment;
            if (textAlign == eTextAlignment.Default)
                textAlign = context.TextAlignment;
            using (StringFormat format = new StringFormat())
            {
                if (textAlign == eTextAlignment.Right)
                {
                    if (isImageVisible && (_ImagePosition == eLayoutPosition.Right || _ImagePosition == eLayoutPosition.Default))
                        textBounds.Width -= _ActualImageBounds.Width + _ImageTextSpacing;
                    format.Alignment = StringAlignment.Far;
                }
                else if (textAlign == eTextAlignment.Center)
                    format.Alignment = StringAlignment.Center;
                if (_TextLineAlignment == eTextLineAlignment.Middle)
                    format.LineAlignment = StringAlignment.Center;
                else if (_TextLineAlignment == eTextLineAlignment.Bottom)
                    format.LineAlignment = StringAlignment.Far;
                format.HotkeyPrefix = context.HotkeyPrefix;
                Font font = GetTextFont(context.DefaultFont);
                if (_TextMarkup == null)
                    g.DrawString(_Text, font, textBrush, textBounds, format);
                else
                {
                    TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, font, textColor, false);
                    d.HotKeyPrefixVisible = (context.HotkeyPrefix == System.Drawing.Text.HotkeyPrefix.Show);
                    Rectangle mr = new Rectangle(textBounds.X, textBounds.Y, _TextMarkup.Bounds.Width, _TextMarkup.Bounds.Height);
                    _TextMarkup.Bounds = mr;
                    _TextMarkup.Render(d);
                }
            }
        }
        protected virtual void PaintImage(PaintContext context, Color textColor)
        {
            Graphics g = context.Graphics;
            if (!string.IsNullOrEmpty(_Symbol))
            {
                Font font = _SymbolSize > 0 ? Symbols.GetFontAwesome(_SymbolSize) : Symbols.FontAwesome;
                TextDrawing.DrawStringLegacy(g, _Symbol, font,
                    (_SymbolColor.IsEmpty ? textColor : _SymbolColor),
                    new Rectangle(_ActualImageBounds.Location, Size.Empty),
                    eTextFormat.Default);
            }
            else
                g.DrawImage(_Image, _ActualImageBounds);
        }
        /// <summary>
        /// Actual painting implementation.
        /// </summary>
        /// <param name="context"></param>
        protected virtual void OnPaint(PaintContext context)
        {
            Rectangle bounds = _Bounds;
            Graphics g = context.Graphics;

            OnPaintBackground(context);

            bounds = Helpers.Deflate(bounds, _Padding);
            bool isImageVisible = IsImageVisible;
            Color textColor = context.LabelTextColor;

            if (_TextVisible && !string.IsNullOrEmpty(_Text))
            {
                Rectangle textBounds = _ActualTextBounds;
                if (_StripTextBaseline > 0 && UseStripBaseline)
                    textBounds = new Rectangle(textBounds.X,
                                                textBounds.Y + (_StripTextBaseline - _TextBaseline),
                                                textBounds.Width,
                                                textBounds.Height);

                bool dispose = false;
                Brush textBrush = context.LabelTextBrush;

                if (this.IsKeyboardFocusWithin && context.FocusStyle != null && !context.FocusStyle.TextColor.IsEmpty)
                {
                    textColor = context.FocusStyle.TextColor;
                    textBrush = new SolidBrush(textColor);
                    dispose = true;
                }
                else if (!_Style.TextColor.IsEmpty)
                {
                    textColor = _Style.TextColor;
                    textBrush = new SolidBrush(textColor);
                    dispose = true;
                }

                PaintText(context,isImageVisible, textColor, textBounds, textBrush);

                if (dispose)
                    textBrush.Dispose();
            }


            if (isImageVisible)
            {
                PaintImage(context, textColor);
            }

            if (_IsSelected)
                OnPaintSelection(context);
        }
        /// <summary>
        /// Returns whether strip text base line value is used when calculating position of the rendered text label.
        /// </summary>
        protected bool UseStripBaseline
        {
            get
            {
                return TextBaseLineEnabled && TextPosition == eLayoutPosition.Default && (!IsImageVisible || IsImageVisible && (_ImagePosition == eLayoutPosition.Default || _ImagePosition == eLayoutPosition.Left || _ImagePosition == eLayoutPosition.Right));
            }
        }

        private bool _TextBaseLineEnabled = true;
        /// <summary>
        /// Indicates whether shared text baseline between items is enabled so the text-base aligns.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether shared text baseline between items is enabled so the text-base aligns.")]
        public bool TextBaseLineEnabled
        {
            get { return _TextBaseLineEnabled; }
            set
            {
                if (value != _TextBaseLineEnabled)
                {
                    bool oldValue = _TextBaseLineEnabled;
                    _TextBaseLineEnabled = value;
                    OnTextBaseLineEnabledChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TextBaseLineEnabled property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextBaseLineEnabledChanged(bool oldValue, bool newValue)
        {
            UpdateTextBounds();
            this.Invalidate();
            OnPropertyChanged(new PropertyChangedEventArgs("TextBaseLineEnabled"));
        }
        

        private static readonly Color SelectionColor = ColorHelpers.GetColor(0x696969);
        /// <summary>
        /// Paints the selection adorner around the item.
        /// </summary>
        /// <param name="context"></param>
        protected virtual void OnPaintSelection(PaintContext context)
        {
            if (this.DesignMode) return;
            Rectangle r = _Bounds;
            r.Width--;
            r.Height--;
            Graphics g = context.Graphics;
            using (Pen pen = new Pen(SelectionColor))
            {
                pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
                g.DrawRectangle(pen, r);
            }
        }

        /// <summary>
        /// Updates bounds of the item in response to the scrolling of LayoutControl.
        /// </summary>
        /// <param name="xScroll"></param>
        /// <param name="yScroll"></param>
        internal virtual void UpdateScrollBounds(int xScroll, int yScroll, bool moveControls)
        {
            _Bounds.Offset(xScroll, yScroll);
            if (!_ActualTextBounds.IsEmpty)
                _ActualTextBounds.Offset(xScroll, yScroll);
            if(!_ActualImageBounds.IsEmpty)
                _ActualImageBounds.Offset(xScroll, yScroll);
        }

        private Rectangle _Bounds;
        /// <summary>
        /// Gets the bounds of the item.
        /// </summary>
        [Browsable(false)]
        public virtual Rectangle Bounds
        {
            get
            {
                return _Bounds;
            }
        }
        /// <summary>
        /// Processes accelerator key for the item.
        /// </summary>
        /// <param name="charCode"></param>
        internal virtual bool ProcessMnemonic(char charCode)
        {
            return false;
        }

        /// <summary>
        /// Sets new bounds of the item.
        /// </summary>
        /// <param name="r">New bounds.</param>
        public virtual void SetBounds(Rectangle r)
        {
            _Bounds = r;
            UpdateLayout();
        }
        /// <summary>
        /// Sets new bounds of the item and actual text size.
        /// </summary>
        /// <param name="r"></param>
        /// <param name="actualTextSize"></param>
        public virtual void SetBounds(Rectangle r, Size actualTextSize)
        {
            _Bounds = r;
            ActualTextSize = actualTextSize;
            UpdateLayout();
        }
        /// <summary>
        /// Updates the item layout. Actual layout is performed in OnUpdateLayout method.
        /// </summary>
        internal void UpdateLayout()
        {
            OnUpdateLayout();
        }
        /// <summary>
        /// Actual layout update implementation.
        /// </summary>
        protected virtual void OnUpdateLayout()
        {
            UpdateTextBounds();
        }
        /// <summary>
        /// Updates the layout of the text inside of item.
        /// </summary>
        protected virtual void UpdateTextBounds()
        {
            Rectangle bounds = Helpers.Deflate(_Bounds, _Padding);
            _ActualTextBounds = Helpers.Deflate(bounds, _TextPadding);
            _ActualImageBounds = Rectangle.Empty;
            bool isImageVisible = IsImageVisible;
            Size imageSize = Size.Empty;
            if (isImageVisible)
                imageSize = GetImageSize();

            eTextAlignment textAlignment = _TextAlignment;
            if (textAlignment == eTextAlignment.Default)
            {
                LayoutControl lc = GetLayoutControl();
                if (lc != null)
                    textAlignment = lc.LabelTextAlignment;
            }

            if (_TextPosition == eLayoutPosition.Default || _TextPosition == eLayoutPosition.Left ||
                _TextPosition == eLayoutPosition.Right)
            {
                if (_TextLineAlignment == eTextLineAlignment.Middle)
                    _ActualTextBounds.Y += (_ActualTextBounds.Height - _ActualTextSize.Height) / 2;
                else if (_TextLineAlignment == eTextLineAlignment.Bottom)
                    _ActualTextBounds.Y = _ActualTextBounds.Bottom - _ActualTextSize.Height;
            }

            if (_TextPosition == eLayoutPosition.Default || _TextPosition == eLayoutPosition.Left || _TextPosition == eLayoutPosition.Top)
            {
                _ActualTextBounds.Size = _ActualTextSize;
            }
            else if (_TextPosition == eLayoutPosition.Bottom)
            {
                _ActualTextBounds.Y = _ActualTextBounds.Bottom - _ActualTextSize.Height;
                _ActualTextBounds.Size = _ActualTextSize;
            }
            else if (_TextPosition == eLayoutPosition.Right)
            {
                _ActualTextBounds.X = _ActualTextBounds.Right - _ActualTextSize.Width;
                _ActualTextBounds.Size = _ActualTextSize;
            }
            else if (_TextPosition == eLayoutPosition.Top)
            {
                _ActualTextBounds.Y = _ActualTextBounds.Bottom - _ActualTextSize.Height;
                _ActualTextBounds.Size = _ActualTextSize;
            }

            if (isImageVisible)
            {
                if (_ImagePosition == eLayoutPosition.Default || _ImagePosition == eLayoutPosition.Right)
                {
                    if (textAlignment == eTextAlignment.Right)
                        _ActualImageBounds = new Rectangle(_ActualTextBounds.Right - imageSize.Width, _ActualTextBounds.Y + (-_ActualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
                    else
                        _ActualImageBounds = new Rectangle(_ActualTextBounds.X + _ImageTextSpacing + _RealTextSize.Width, _ActualTextBounds.Y + (_ActualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
                }
                else if (_ImagePosition == eLayoutPosition.Left)
                {
                    if (textAlignment == eTextAlignment.Right)
                        _ActualImageBounds = new Rectangle(_ActualTextBounds.Right - (_RealTextSize.Width + imageSize.Width + _ImageTextSpacing), _ActualTextBounds.Y + (_ActualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
                    else
                    {
                        _ActualImageBounds = new Rectangle(_ActualTextBounds.X, _ActualTextBounds.Y + (_ActualTextBounds.Height - imageSize.Height) / 2, imageSize.Width, imageSize.Height);
                        _ActualTextBounds.X += _ActualImageBounds.Width + _ImageTextSpacing;
                    }
                }
                else if (_ImagePosition == eLayoutPosition.Top)
                {
                    _ActualImageBounds = new Rectangle(_ActualTextBounds.X + (_ActualTextBounds.Width - imageSize.Width) / 2,
                                             _ActualTextBounds.Y - (imageSize.Height + _ImageTextSpacing),
                                             imageSize.Width,
                                             imageSize.Height);
                }
                else if (_ImagePosition == eLayoutPosition.Bottom)
                {
                    _ActualImageBounds = new Rectangle(_ActualTextBounds.X + (_ActualTextBounds.Width - imageSize.Width) / 2,
                                             _ActualTextBounds.Bottom + _ImageTextSpacing,
                                             imageSize.Width,
                                             imageSize.Height);
                }
            }
        }
        protected virtual Size GetImageSize()
        {
            if (!string.IsNullOrEmpty(_Symbol))
                return _SymbolTextSize;
            if (_Image != null)
                return _Image.Size;
            return Size.Empty;
        }
        protected bool IsImageVisible
        {
            get
            {
                return _Image != null || !string.IsNullOrEmpty(_Symbol);
            }
        }
        /// <summary>
        /// Scales item in response to the scaling of the LayoutControl. Should never be called directly.
        /// </summary>
        /// <param name="factor"></param>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public virtual void ScaleItem(SizeF factor)
        {
            bool widthChanged = factor.Width != 1f;
            bool heightChanged = factor.Height != 1f;

            if (!_MinSize.IsEmpty && (widthChanged || heightChanged))
            {
                Size newMinSize = new Size();
                if (widthChanged)
                    newMinSize.Width = (int)(_MinSize.Width * factor.Width);
                else
                    newMinSize.Width = _MinSize.Width;
                if (heightChanged)
                    newMinSize.Height = (int)(_MinSize.Height * factor.Height);
                else
                    newMinSize.Height = _MinSize.Height;
                MinSize = newMinSize;
            }
            
            if (widthChanged && _WidthType == eLayoutSizeType.Absolute)
            {
                int newWidth = (int)Math.Round(_Width * factor.Width);

                if (_MinSize.Width > newWidth)
                    newWidth = _MinSize.Width;

                this.Width = newWidth;
            }
            if (heightChanged && _HeightType == eLayoutSizeType.Absolute)
            {
                int newHeight = (int)Math.Round(_Height * factor.Height);

                if (_MinSize.Height > newHeight)
                    newHeight = _MinSize.Height;

                this.Height = newHeight;
            }

            if (!_TextSize.IsEmpty && (widthChanged || heightChanged))
            {
                Size newTextSize = new Size();
                if (widthChanged)
                    newTextSize.Width = (int)(_TextSize.Width * factor.Width);
                else
                    newTextSize.Width = _TextSize.Width;
                if (heightChanged)
                    newTextSize.Height = (int)(_TextSize.Height * factor.Height);
                else
                    newTextSize.Height = _TextSize.Height;
                TextSize = newTextSize;
            }

            if (!Helpers.IsEmpty(_TextPadding) && (widthChanged || heightChanged))
            {
                System.Windows.Forms.Padding newTextPadding = _TextPadding;
                if (widthChanged)
                {
                    newTextPadding.Left = (int)(_TextPadding.Left * factor.Width);
                    newTextPadding.Right = (int)(_TextPadding.Right * factor.Width);
                }
                if (heightChanged)
                {
                    newTextPadding.Top = (int)(_TextPadding.Top * factor.Height);
                    newTextPadding.Bottom = (int)(_TextPadding.Bottom * factor.Height);
                }
                TextPadding = newTextPadding;
            }

            if (!Helpers.IsEmpty(_Padding) && (widthChanged || heightChanged))
            {
                System.Windows.Forms.Padding newPadding = _Padding;
                if (widthChanged)
                {
                    newPadding.Left = (int)(_Padding.Left * factor.Width);
                    newPadding.Right = (int)(_Padding.Right * factor.Width);
                }
                if (heightChanged)
                {
                    newPadding.Top = (int)(_Padding.Top * factor.Height);
                    newPadding.Bottom = (int)(_Padding.Bottom * factor.Height);
                }
                Padding = newPadding;
            }
        }

        /// <summary>
        /// Measures the size of the item text. Actual measurement is done in OnMeasureText method.
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        internal Size MeasureText(LayoutContext c)
        {
            return OnMeasureText(c);
        }

        protected virtual Font GetTextFont(Font defaultFont)
        {
            Font font = defaultFont;
            if (_Style.Font != null)
                font = _Style.Font;
            return font;
        }
        /// <summary>
        /// Returns the size of the items text.
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        protected virtual Size OnMeasureText(LayoutContext c)
        {
            if (!_TextVisible) return Size.Empty;

            if (_TextSize.Width > 0 && _TextSize.Height > 0)
                return _TextSize;

            Size size = Size.Empty;
            Graphics g = c.Graphics;

            Font font = GetTextFont(c.Font);

            if (_TextMarkup == null)
            { // Plain Text
                if (_TextSize.Width > 0)
                {
                    size = Size.Ceiling(g.MeasureString(_Text, font, _TextSize.Width));
                }
                else
                {
                    size = Size.Ceiling(g.MeasureString(_Text, font));
                }
            }
            else
            {
                // Text Markup
                Size availSize = new Size(_TextSize.Width > 0 ? _TextSize.Width : 1600, 1);
                TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, font, Color.Empty, false);
                _TextMarkup.InvalidateElementsSize();
                _TextMarkup.Measure(availSize, d);
                availSize = _TextMarkup.Bounds.Size;
                d.RightToLeft = c.RightToLeft;
                _TextMarkup.Arrange(new Rectangle(0, 0, availSize.Width, availSize.Height), d);

                size = _TextMarkup.Bounds.Size;
            }

            if (_TextSize.Height > 0)
                size.Height = _TextSize.Height;
            size.Width += _TextPadding.Horizontal;
            size.Height += _TextPadding.Vertical;
            _RealTextSize = size;
            _TextBaseline = c.FontBaseline;

            if (IsImageVisible)
            {
                if (!string.IsNullOrEmpty(_Symbol))
                {
                    Font symFont = Symbols.GetFontAwesome(_SymbolSize);

                    _SymbolTextSize = TextDrawing.MeasureString(g, _Symbol, symFont);

                    int descent = (int)Math.Ceiling((symFont.FontFamily.GetCellDescent(symFont.Style) *
                    symFont.Size / symFont.FontFamily.GetEmHeight(symFont.Style)));
                    _SymbolTextSize.Height -= descent;
                }
                else
                    _SymbolTextSize = Size.Empty;
                if (_ImagePosition == eLayoutPosition.Default || _ImagePosition == eLayoutPosition.Left || _ImagePosition == eLayoutPosition.Right)
                    size.Width += _ImageTextSpacing + GetImageSize().Width;
            }

            return size;
        }

        private Size _RealTextSize = Size.Empty;
         //<summary>
         // Returns the real text-size for the text label that is valid after MeasureText is called.
         //</summary>
        [Browsable(false)]
        public Size RealTextSize
        {
            get
            {
                return _RealTextSize;
            }
        }

        private int _StripTextBaseline = 0;
        /// <summary>
        /// Gets or sets the text-baseline that is used by whole strip.
        /// </summary>
        internal virtual int StripTextBaseline
        {
            get { return _StripTextBaseline; }
            set
            {
                _StripTextBaseline = value;
            }
        }

        private int _TextBaseline = 0;
        /// <summary>
        /// Returns the text base line.
        /// </summary>
        internal virtual int TextBaseline
        {
            get
            {
                return _TextBaseline;
            }
            set
            {
                _TextBaseline = value;
            }
        }

        private object _Tag = "";
        /// <summary>
        /// Gets or sets an object that contains additional data attached to the item.
        /// </summary>
        [Bindable(true), DefaultValue(""), Localizable(false), TypeConverter(typeof(StringConverter)), Description("Indicates an object that contains additional data attached to the item")]
        public object Tag
        {
            get { return _Tag; }
            set
            {
                if (value != _Tag)
                {
                    object oldValue = _Tag;
                    _Tag = value;
                    OnTagChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Tag property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTagChanged(object oldValue, object newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Tag"));
        }

        private string _Text = "";
        /// <summary>
        /// Indicates the item caption.
        /// </summary>
        [Bindable(true), Category("Text"), DefaultValue(""), Localizable(true), Description("Indicates the item caption.")]
        [Editor("DevComponents.DotNetBar.Layout.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Layout.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=7eb7c3a35b91de04", typeof(System.Drawing.Design.UITypeEditor))]
        public virtual string Text
        {
            get { return _Text; }
            set
            {
                if (value != _Text)
                {
                    string oldValue = _Text;
                    _Text = value;
                    OnTextChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Text property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextChanged(string oldValue, string newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Text"));
            MarkupTextChanged();
            InvalidateLayout();
        }

        private Size _TextSize = Size.Empty;
        /// <summary>
        /// Gets or sets the explicit size of the text part of item.
        /// </summary>
        [Category("Appearance"), Description("Indicates explicit size of text part of the item")]
        public Size TextSize
        {
            get { return _TextSize; }
            set
            {
                if (value != _TextSize)
                {
                    Size oldValue = _TextSize;
                    _TextSize = value;
                    OnTextSizeChanged(oldValue, value);
                }
            }
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeTextSize()
        {
            return !_TextSize.IsEmpty;
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetTextSize()
        {
            TextSize = Size.Empty;
        }
        /// <summary>
        /// Called when TextSize property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextSizeChanged(Size oldValue, Size newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("TextSize"));
            InvalidateLayout();
        }

        private Rectangle _ActualTextBounds = Rectangle.Empty;
        /// <summary>
        /// Gets actual text bounds.
        /// </summary>
        [Browsable(false)]
        public Rectangle ActualTextBounds
        {
            get
            {
                return _ActualTextBounds;
            }
            internal set
            {
                _ActualTextBounds = value;
            }
        }

        private Size _ActualTextSize = Size.Empty;
        /// <summary>
        /// Gets actual text-size as used by the layout item.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]
        public Size ActualTextSize
        {
            get { return _ActualTextSize; }
            internal set
            {
                if (value != _ActualTextSize)
                {
                    Size oldValue = _ActualTextSize;
                    _ActualTextSize = value;
                    OnActualTextSizeChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when ActualTextSize property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnActualTextSizeChanged(Size oldValue, Size newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("ActualTextSize"));
        }

        private System.Windows.Forms.Padding _TextPadding = new System.Windows.Forms.Padding(0, 0, 0, 0);
        /// <summary>
        /// Gets or sets text padding.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Gets or sets text padding.")]
        public System.Windows.Forms.Padding TextPadding
        {
            get { return _TextPadding; }
            set
            {
                System.Windows.Forms.Padding oldValue = value;
                _TextPadding = value;
                OnTextPaddingChanged(oldValue, value);
            }
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeTextPadding()
        {
            return _TextPadding.Bottom != 0 || _TextPadding.Top != 0 || _TextPadding.Left != 0 || _TextPadding.Right != 0;
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetTextPadding()
        {
            _TextPadding = new System.Windows.Forms.Padding(0, 0, 0, 0);
        }
        /// <summary>
        /// Called when TextPadding property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextPaddingChanged(System.Windows.Forms.Padding oldValue, System.Windows.Forms.Padding newValue)
        {
            this.InvalidateLayout();
            this.Invalidate();
            OnPropertyChanged(new PropertyChangedEventArgs("TextPadding"));
        }

        private bool _TextVisible = true;
        /// <summary>
        /// Indicates whether caption/text is visible.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether caption/text is visible."), Bindable(true)]
        public bool TextVisible
        {
            get { return _TextVisible; }
            set
            {
                if (value != _TextVisible)
                {
                    bool oldValue = _TextVisible;
                    _TextVisible = value;
                    OnTextVisibleChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TextVisible property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextVisibleChanged(bool oldValue, bool newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("TextVisible"));
            InvalidateLayout();
        }

        private eLayoutPosition _TextPosition = eLayoutPosition.Default;
        /// <summary>
        /// Gets or sets the text position in relation to the other parts of the layout item. Default is same as Left.
        /// </summary>
        [DefaultValue(eLayoutPosition.Default), Category("Appearance"), Description("Indicates text position in relation to the other parts of the layout item.")]
        public eLayoutPosition TextPosition
        {
            get { return _TextPosition; }
            set
            {
                if (value != _TextPosition)
                {
                    eLayoutPosition oldValue = _TextPosition;
                    _TextPosition = value;
                    OnTextPositionChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TextPosition property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextPositionChanged(eLayoutPosition oldValue, eLayoutPosition newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("TextPosition"));
            InvalidateLayout();
        }

        private int _Width = 0;
        /// <summary>
        /// Indicates the total width of the item. The value specified here depends on the WidthType property setting. When using WidthType=Percentage the value specified here indicates the percent of the available client size of group.
        /// For example setting of 20 indicates 20% of the available client width.
        /// </summary>
        [DefaultValue(0), Category("Appearance"), Description("Indicates the total width of the item. The value specified here depends on the WidthType property setting.")]
        public int Width
        {
            get { return _Width; }
            set
            {
                if (value != _Width)
                {
                    int oldValue = _Width;
                    _Width = value;
                    OnWidthChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Width property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnWidthChanged(int oldValue, int newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Width"));
            InvalidateLayout();
        }

        private eLayoutSizeType _WidthType = eLayoutSizeType.Absolute;
        /// <summary>
        /// Indicates width type used by the item.
        /// </summary>
        [DefaultValue(eLayoutSizeType.Absolute), Category("Appearance"), Description("Indicates width type used by the item.")]
        public eLayoutSizeType WidthType
        {
            get { return _WidthType; }
            set
            {
                if (value != _WidthType)
                {
                    eLayoutSizeType oldValue = _WidthType;
                    _WidthType = value;
                    OnWidthTypeChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when WidthType property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnWidthTypeChanged(eLayoutSizeType oldValue, eLayoutSizeType newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("WidthType"));
            InvalidateLayout();
        }

        /// <summary>
        /// Indicates whether width type is the fixed width type, different than eLayoutSizeType.Percent
        /// </summary>
        [Browsable(false)]
        public bool IsWidthFixed
        {
            get
            {
                return (_WidthType != eLayoutSizeType.Percent);
            }
        }

        private int _Height = 0;
        /// <summary>
        /// Indicates the total height of the item. The value specified here depends on the HeightType property setting. When using HeightType=Percentage the value specified here indicates the percent of the available client size of group.
        /// For example setting of 10 indicates 10% of the available client height.
        /// </summary>
        [DefaultValue(0), Category("Appearance"), Description("Indicates the total height of the item. The value specified here depends on the HeightType property setting.")]
        public int Height
        {
            get { return _Height; }
            set
            {
                if (value != _Height)
                {
                    int oldValue = _Height;
                    _Height = value;
                    OnHeightChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Height property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnHeightChanged(int oldValue, int newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Height"));
            InvalidateLayout();
        }

        private eLayoutSizeType _HeightType = eLayoutSizeType.Absolute;
        /// <summary>
        /// Indicates height type used by the item.
        /// </summary>
        [DefaultValue(eLayoutSizeType.Absolute), Category("Appearance"), Description("Indicates height type used by the item.")]
        public eLayoutSizeType HeightType
        {
            get { return _HeightType; }
            set
            {
                if (value != _HeightType)
                {
                    eLayoutSizeType oldValue = _HeightType;
                    _HeightType = value;
                    OnHeightTypeChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when HeightType property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnHeightTypeChanged(eLayoutSizeType oldValue, eLayoutSizeType newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("HeightType"));
            InvalidateLayout();
        }

        /// <summary>
        /// Indicates whether height type is the fixed height type, different than eLayoutSizeType.Percent
        /// </summary>
        [Browsable(false)]
        public bool IsHeightFixed
        {
            get
            {
                return (_HeightType != eLayoutSizeType.Percent);
            }
        }

        private Size _MinSize = Size.Empty;
        /// <summary>
        /// Indicates the minimum size of the item. Setting Width or Height to zero indicates unconstrained minimum size for given dimension.
        /// </summary>
        [Description("Indicates the minimum size of the item"), Category("Appearance")]
        public Size MinSize
        {
            get { return _MinSize; }
            set
            {
                if (value != _MinSize)
                {
                    Size oldValue = _MinSize;
                    _MinSize = value;
                    OnMinSizeChanged(oldValue, value);
                }
            }
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeMinSize()
        {
            return !_MinSize.IsEmpty;
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetMinSize()
        {
            MinSize = Size.Empty;
        }
        /// <summary>
        /// Called when MinSize property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnMinSizeChanged(Size oldValue, Size newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("MinSize"));
            InvalidateLayout();
        }

        private int _SuggestedGroupId = 0;
        /// <summary>
        /// When set to value greater than 0 it suggests to layout engine that items with same id that are in collection after each other should be kept on same line if possible.
        /// This is only suggestion to layout engine and engine will ignore it if there is insufficient client size available or other size constraints
        /// prevent it from keeping items in same line.
        /// </summary>
        [DefaultValue(0), Category("Behavior"), Description("When set to value greater than 0 it suggests to layout engine that items with same id that are in collection after each other should be kept on same line if possible.")]
        public int SuggestedGroupId
        {
            get { return _SuggestedGroupId; }
            set
            {
                if (value != _SuggestedGroupId)
                {
                    int oldValue = _SuggestedGroupId;
                    _SuggestedGroupId = value;
                    OnSuggestedGroupIdChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when SuggestedGroupId property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnSuggestedGroupIdChanged(int oldValue, int newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("SuggestedGroupId"));

        }

        private bool _MnemonicsEnabled = true;
        /// <summary>
        /// Indicates whether accelerator keys assigned to item Text property are processed by items which respond to them.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether accelerator keys assigned to item Text property are processed by items which respond to them.")]
        public bool MnemonicsEnabled
        {
            get { return _MnemonicsEnabled; }
            set
            {
                if (value != _MnemonicsEnabled)
                {
                    bool oldValue = _MnemonicsEnabled;
                    _MnemonicsEnabled = value;
                    OnMnemonicsEnabledChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when MnemonicsEnabled property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnMnemonicsEnabledChanged(bool oldValue, bool newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("MnemonicsEnabled"));

        }

        private SimpleStyle _Style;
        /// <summary>
        /// Gets the style for the background of the control.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Gets the style for the background of the item."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public SimpleStyle Style
        {
            get { return _Style; }
        }
        private void StylePropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            this.Invalidate();
            //throw new Exception("The method or operation is not implemented.");
        }
        private static readonly System.Windows.Forms.Padding DefaultPadding = new System.Windows.Forms.Padding(4);
        private System.Windows.Forms.Padding _Padding = DefaultPadding;
        /// <summary>
        /// Specifies the amount of padding inside of the item. Padding is the spacing between the edges of item and its content.
        /// </summary>
        [Category("Appearance"), Description("Specifies the amount of padding inside of the item.")]
        public System.Windows.Forms.Padding Padding
        {
            get { return _Padding; }
            set
            {
                if (value != _Padding)
                {
                    System.Windows.Forms.Padding oldValue = _Padding;
                    _Padding = value;
                    OnPaddingChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Padding property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnPaddingChanged(System.Windows.Forms.Padding oldValue, System.Windows.Forms.Padding newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Padding"));
            InvalidateLayout();
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializePadding()
        {
            return _Padding != DefaultPadding;
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetPadding()
        {
            Padding = DefaultPadding;
        }

        private int _AbsoluteIndex = -1;
        /// <summary>
        /// Indicates the absolute index of the item inside of the LayoutControl.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int AbsoluteIndex
        {
            get { return _AbsoluteIndex; }
            internal set
            {
                if (value != _AbsoluteIndex)
                {
                    int oldValue = _AbsoluteIndex;
                    _AbsoluteIndex = value;
                    OnAbsoluteIndexChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when AbsoluteIndex property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnAbsoluteIndexChanged(int oldValue, int newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("AbsoluteIndex"));
        }

        /// <summary>
        /// Returns the LayoutControl which hosts the item, if available.
        /// </summary>
        /// <returns>reference to LayoutControl or null.</returns>
        public LayoutControl GetLayoutControl()
        {
            if (_LayoutControl != null) return _LayoutControl;
            LayoutItemBase item = this.Parent;
            while (item != null)
            {
                if (item.LayoutControl != null) return item.LayoutControl;
                item = item.Parent;
            }
            return null;
        }

        /// <summary>
        /// Invalidates the paint region of the item.
        /// </summary>
        public void Invalidate()
        {
            LayoutControl control = GetLayoutControl();
            if (control != null)
                control.Invalidate(_Bounds);
        }

        /// <summary>
        /// Invalidates layout of the item and causes the LayoutControl to perform layout.
        /// </summary>
        public void InvalidateLayout()
        {
            LayoutControl control = GetLayoutControl();
            if (control != null)
            {
                if (this.DesignMode)
                    control.Invalidate(true);
                control.PerformLayout();
            }
        }

        private LayoutControl _LayoutControl = null;
        /// <summary>
        /// Gets the LayoutControl this group is directly attached too through RootGroup property.
        /// </summary>
        [Browsable(false)]
        internal LayoutControl LayoutControl
        {
            get
            {
                return _LayoutControl;
            }
            set
            {
                _LayoutControl = value;
            }
        }

        private LayoutItemBase _Parent = null;
        /// <summary>
        /// Gets the reference to parent item.
        /// </summary>
        [Browsable(false)]
        public LayoutItemBase Parent
        {
            get { return _Parent; }
            internal set
            {
                if (value != _Parent)
                {
                    if (value == this) throw new ArgumentException("Item cannot parent itself");
                    if (IsChildItem(value)) throw new ArgumentException("Cannot set as Parent item that is child of this item");
                    LayoutItemBase oldValue = _Parent;
                    _Parent = value;
                    OnParentChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Parent property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnParentChanged(LayoutItemBase oldValue, LayoutItemBase newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Parent"));

        }

        /// <summary>
        /// Returns whether item is contained as child item by this item or one of its children.
        /// </summary>
        /// <param name="value">Item to check.</param>
        /// <returns>true if item is contained otherwise false</returns>
        public virtual bool IsChildItem(LayoutItemBase value)
        {
            return false;
        }

        private bool _IsKeyboardFocusWithin = false;
        /// <summary>
        /// Gets whether keyboard focus is within the control which is assigned to the item.
        /// </summary>
        [Browsable(false)]
        public bool IsKeyboardFocusWithin
        {
            get
            {
                return _IsKeyboardFocusWithin;
            }
            internal set
            {
                if (value != _IsKeyboardFocusWithin)
                {
                    _IsKeyboardFocusWithin = value;
                    this.Invalidate();
                }
            }
        }

        private Image _Image = null;
        /// <summary>
        /// Indicates the image that is displayed next to the item text label.
        /// </summary>
        [DefaultValue(null), Category("Appearance"), Description("Indicates the image that is displayed next to the item text label.")]
        public Image Image
        {
            get { return _Image; }
            set
            {
                if (value != _Image)
                {
                    Image oldValue = _Image;
                    _Image = value;
                    OnImageChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Image property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnImageChanged(Image oldValue, Image newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Image"));
            this.InvalidateLayout();
        }

        private int _ImageTextSpacing = 4;
        /// <summary>
        /// Specifies the distance between image and text.
        /// </summary>
        [DefaultValue(4), Category("Appearance"), Description("Specifies the distance between image and text.")]
        public int ImageTextSpacing
        {
            get { return _ImageTextSpacing; }
            set
            {
                if (value != _ImageTextSpacing)
                {
                    int oldValue = _ImageTextSpacing;
                    _ImageTextSpacing = value;
                    OnImageTextSpacingChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when ImageTextSpacing property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnImageTextSpacingChanged(int oldValue, int newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("ImageTextSpacing"));
            this.InvalidateLayout();
        }

        private eLayoutPosition _ImagePosition = eLayoutPosition.Default;
        /// <summary>
        /// Indicates the position of the image in relation to the text label of item.
        /// </summary>
        [DefaultValue(eLayoutPosition.Default), Category("Appearance"), Description("Indicates the position of the image in relation to the text label of item.")]
        public eLayoutPosition ImagePosition
        {
            get { return _ImagePosition; }
            set
            {
                if (value != _ImagePosition)
                {
                    eLayoutPosition oldValue = _ImagePosition;
                    _ImagePosition = value;
                    OnImagePositionChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when ImagePosition property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnImagePositionChanged(eLayoutPosition oldValue, eLayoutPosition newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("ImagePosition"));
            this.InvalidateLayout();
        }

        private Rectangle _ActualImageBounds = Rectangle.Empty;
        /// <summary>
        /// Gets actual image bounds if visible or Rectangle.Empty if image is not visible.
        /// </summary>
        [Browsable(false)]
        public Rectangle ActualImageBounds
        {
            get { return _ActualImageBounds; }
            internal set { _ActualImageBounds = value; }
        }

        private Color _SymbolColor = Color.Empty;
        /// <summary>
        /// Gets or sets the color of the Symbol.
        /// </summary>
        [Category("Appearance"), Description("Indicates color of the Symbol.")]
        public Color SymbolColor
        {
            get { return _SymbolColor; }
            set { _SymbolColor = value; this.Invalidate(); }
        }
        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeSymbolColor()
        {
            return !_SymbolColor.IsEmpty;
        }
        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetSymbolColor()
        {
            this.SymbolColor = Color.Empty;
        }

        private Size _SymbolTextSize = Size.Empty;
        private string _Symbol = "";
        /// <summary>
        /// Indicates the symbol displayed on face of the item instead of the image. Setting the symbol overrides the image setting.
        /// </summary>
        [DefaultValue(""), Category("Appearance"), Description("Indicates the symbol displayed on face of the button instead of the image. Setting the symbol overrides the image setting.")]
        [Editor("DevComponents.DotNetBar.Layout.Design.SymbolTypeEditor, DevComponents.DotNetBar.Layout.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=7eb7c3a35b91de04", typeof(System.Drawing.Design.UITypeEditor))]
        public string Symbol
        {
            get { return _Symbol; }
            set
            {
                if (value != _Symbol)
                {
                    string oldValue = _Symbol;
                    _Symbol = value;
                    OnSymbolChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Symbol property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnSymbolChanged(string oldValue, string newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Symbol"));
            this.InvalidateLayout();
            this.Invalidate();
        }

        private float _SymbolSize = 0f;
        /// <summary>
        /// Indicates the size of the symbol in points.
        /// </summary>
        [DefaultValue(0f), Category("Appearance"), Description("Indicates the size of the symbol in points.")]
        public float SymbolSize
        {
            get { return _SymbolSize; }
            set
            {
                if (value != _SymbolSize)
                {
                    float oldValue = _SymbolSize;
                    _SymbolSize = value;
                    OnSymbolSizeChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when SymbolSize property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnSymbolSizeChanged(float oldValue, float newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("SymbolSize"));
            this.InvalidateLayout();
            this.Invalidate();
        }

        private bool _SharedTextSizeEnabled = true;
        /// <summary>
        /// Indicates whether uniform text-size is used for text label. When shared text-size is used it ensures that all text-labels in LayoutControl use same text-size which is determined as largest text label size.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether uniform text-size is used for text label. When shared text-size is used it ensures that all text-labels in LayoutControl use same text-size which is determined as largest text label size.")]
        public bool SharedTextSizeEnabled
        {
            get { return _SharedTextSizeEnabled; }
            set
            {
                if (value != _SharedTextSizeEnabled)
                {
                    bool oldValue = _SharedTextSizeEnabled;
                    _SharedTextSizeEnabled = value;
                    OnSharedTextSizeEnabledChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when SharedTextSizeEnabled property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnSharedTextSizeEnabledChanged(bool oldValue, bool newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("SharedTextSizeEnabled"));
            this.InvalidateLayout();
            this.Invalidate();
        }

        /// <summary>
        /// Brings item into view by scrolling the control if necessary.
        /// </summary>
        public virtual void BringIntoView()
        {
            LayoutControl lc = GetLayoutControl();
            if (lc != null)
                lc.ScrollItemIntoView(this);
        }
        #endregion

        #region IDisposable Members

        protected virtual void OnDispose()
        {
            EventHandler eh = Disposed;
            if (eh != null) eh(this, EventArgs.Empty);

            _Style.PropertyChanged -= StylePropertyChanged;
        }
        public void Dispose()
        {
            OnDispose();
        }

        #endregion

        #region IComponent Members
        /// <summary>
        /// Occurs when item is disposed.
        /// </summary>
        [Description("Occurs when item is disposed.")]
        public event EventHandler Disposed;

        private string _Name = "";
        /// <summary>
        /// Gets or sets the name of the item.
        /// </summary>
        [DefaultValue(""), Category("Design"), Description("Indicates name of the item.")]
        public string Name
        {
            get
            {
                if (_ComponentSite != null)
                    _Name = _ComponentSite.Name;
                return _Name;
            }
            set
            {
                if (_ComponentSite != null)
                    _ComponentSite.Name = value;
                if (value == null)
                    _Name = "";
                else
                    _Name = value;
            }
        }

        private ISite _ComponentSite = null;
        /// <summary>
        /// Gets or sets the Site associated with this component. Used by Windows forms designer.
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual System.ComponentModel.ISite Site
        {
            get
            {
                return _ComponentSite;
            }
            set
            {
                _ComponentSite = value;
            }
        }

        private bool _DesignMode = false;
        /// <summary>
        /// Returns whether item is in design mode.
        /// </summary>
        internal bool DesignMode
        {
            get
            {
                return _DesignMode || _ComponentSite != null && _ComponentSite.DesignMode;
            }
            set
            {
                _DesignMode = value;
            }
        }

        private bool _IsSelected = false;
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
        public bool IsSelected
        {
            get { return _IsSelected; }
            set
            {
                if (value != _IsSelected)
                {
                    bool oldValue = _IsSelected;
                    _IsSelected = value;
                    OnIsSelectedChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when IsSelected property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnIsSelectedChanged(bool oldValue, bool newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("IsSelected"));
            this.Invalidate();
        }

        public override string ToString()
        {
            return string.Format("Text:'{0}', Name:{1}, LayoutItemBase");

        }

        private eTextAlignment _TextAlignment = eTextAlignment.Default;
        /// <summary>
        /// Indicates the text alignment within the text bounds. Depending on layout item type not all alignments are available.
        /// </summary>
        [DefaultValue(eTextAlignment.Default), Category("Appearance"), Description("Indicates the text alignment within the text bounds.")]
        public eTextAlignment TextAlignment
        {
            get { return _TextAlignment; }
            set
            {
                if (value != _TextAlignment)
                {
                    eTextAlignment oldValue = _TextAlignment;
                    _TextAlignment = value;
                    OnTextAlignmentChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TextAlignment property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextAlignmentChanged(eTextAlignment oldValue, eTextAlignment newValue)
        {
            this.InvalidateLayout();
            this.Invalidate();
            OnPropertyChanged(new PropertyChangedEventArgs("TextAlignment"));
        }

        private eTextLineAlignment _TextLineAlignment = eTextLineAlignment.Default;
        /// <summary>
        /// Indicates text line alignment. Usually there is no need to change this property value since Default setting will use text-base line so text-box text and captions align.
        /// </summary>
        [DefaultValue(eTextLineAlignment.Default), Category("Appearance"), Description("Indicates text line alignment. Usually there is no need to change this property value since Default setting will use text-base line so text-box text and captions align.")]
        public eTextLineAlignment TextLineAlignment
        {
            get { return _TextLineAlignment; }
            set
            {
                if (value != _TextLineAlignment)
                {
                    eTextLineAlignment oldValue = _TextLineAlignment;
                    _TextLineAlignment = value;
                    OnTextLineAlignmentChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when TextLineAlignment property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnTextLineAlignmentChanged(eTextLineAlignment oldValue, eTextLineAlignment newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("TextLineAlignment"));
            this.Invalidate();
        }

        /// <summary>
        /// Gets whether this item text-size is shared with other items inside of its parent group.
        /// </summary>
        [Browsable(false)]
        public virtual bool IsTextSizeShared
        {
            get
            {
                return _SharedTextSizeEnabled;
            }
        }

        /// <summary>
        /// Gets whether this item's text-baseline is shared with other items inside of its parent group.
        /// </summary>
        [Browsable(false)]
        public virtual bool IsTextBaselineShared
        {
            get
            {
                return true;
            }
        }

        private bool _Visible = true;
        /// <summary>
        /// Indicates visibility of the item.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates visibility of the item.")]
        public bool Visible
        {
            get { return _Visible; }
            set
            {
                if (value !=_Visible)
                {
                    bool oldValue = _Visible;
                    _Visible = value;
                    OnVisibleChanged(oldValue, value);
                }
            }
        }
        /// <summary>
        /// Called when Visible property has changed.
        /// </summary>
        /// <param name="oldValue">Old property value</param>
        /// <param name="newValue">New property value</param>
        protected virtual void OnVisibleChanged(bool oldValue, bool newValue)
        {
            OnPropertyChanged(new PropertyChangedEventArgs("Visible"));
            InvalidateLayout();
        }
        #endregion

        #region TextMarkup
        /// <summary>
        /// Occurs when text markup link is clicked. Markup links can be created using "a" tag, for example:
        /// <a name="MyLink">Markup link</a>
        /// </summary>
        [Description("Occurs when text markup link is clicked. Markup links can be created using a tag.")]
        public event MarkupLinkClickEventHandler MarkupLinkClick;
        protected virtual void TextMarkupLinkClick(object sender, EventArgs e)
        {
            TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
            if (link != null)
                OnMarkupLinkClick(new MarkupLinkClickEventArgs(link.Name, link.HRef));

        }
        protected virtual void OnMarkupLinkClick(MarkupLinkClickEventArgs e)
        {
            if (this.MarkupLinkClick != null)
                MarkupLinkClick(this, e);
        }

        private TextMarkup.BodyElement _TextMarkup = null;

        private void MarkupTextChanged()
        {
            if (!IsMarkupSupported)
                return;

            if (_TextMarkup != null)
                _TextMarkup.HyperLinkClick -= this.TextMarkupLinkClick;

            _TextMarkup = null;

            if (!TextMarkup.MarkupParser.IsMarkup(ref _Text))
                return;

            _TextMarkup = TextMarkup.MarkupParser.Parse(_Text);

            if (_TextMarkup != null)
                _TextMarkup.HyperLinkClick += TextMarkupLinkClick;
        }

        /// <summary>
        /// Gets reference to parsed markup body element if text was markup otherwise returns null.
        /// </summary>
        internal TextMarkup.BodyElement TextMarkupBody
        {
            get { return _TextMarkup; }
        }

        private bool _TextMarkupEnabled = true;
        /// <summary>
        /// Gets or sets whether item supports and renders text markup. Default value is true.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Gets or sets whether item supports and renders text markup.")]
        public bool TextMarkupEnabled
        {
            get { return _TextMarkupEnabled; }
            set
            {
                if (_TextMarkupEnabled != value)
                {
                    _TextMarkupEnabled = value;
                    this.InvalidateLayout();
                    this.Invalidate();
                }
            }
        }

        /// <summary>
        /// Gets whether item supports text markup. Default is false.
        /// </summary>
        protected virtual bool IsMarkupSupported
        {
            get { return _TextMarkupEnabled; }
        }

        private bool _IsMouseOver = false;
        /// <summary>
        /// Gets whether mouse is over the item.
        /// </summary>
        [Browsable(false)]
        internal bool IsMouseOver
        {
            get { return _IsMouseOver; }
            set
            {
                _IsMouseOver = value;
            }
        }
        private bool _HostedItemMouseEntered = false;
        protected internal virtual void OnMouseEnter(object sender, EventArgs e)
        {
            IsMouseOver = true;
            LayoutControl lc = GetLayoutControl();
            ResetHover(lc);
        }
        protected internal virtual void OnMouseMove(object sender, MouseEventArgs e)
        {
            if (_TextMarkup != null)
                _TextMarkup.MouseMove(sender as Control, e);

            if (!IsMouseOver) HideToolTip();
        }
        protected internal virtual void OnMouseDown(object sender, MouseEventArgs e)
        {
            HideToolTip();

            if (_TextMarkup != null)
                _TextMarkup.MouseDown(sender as Control, e);
        }

        protected internal virtual void OnMouseUp(object sender, MouseEventArgs e)
        {
            if (_TextMarkup != null)
                _TextMarkup.MouseUp(sender as Control, e);
        }

        protected internal virtual void OnMouseLeave(object sender, EventArgs e)
        {
            HideToolTip();

            if (_TextMarkup != null)
                _TextMarkup.MouseLeave(sender as Control);

            IsMouseOver = false;
        }

        protected internal virtual void OnClick(object sender, EventArgs e)
        {
            if (_TextMarkup != null)
                _TextMarkup.Click(sender as Control);
        }

        protected internal virtual void OnMouseHover(object sender, EventArgs e)
        {
            if (System.Windows.Forms.Control.MouseButtons == System.Windows.Forms.MouseButtons.None)
                this.ShowToolTip();
        }
        #endregion

        #region Tooltip Support

        /// <summary>
        /// Occurs after Tooltip text has changed.
        /// </summary>
        protected virtual void OnTooltipChanged() { }
        private string _Tooltip = "";
        /// <summary>
        /// Gets/Sets informational text (tooltip) for the cell.
        /// </summary>
        [Browsable(true), DefaultValue(""), Category("Appearance"), Description("Indicates the text that is displayed when mouse hovers over the cell."), Localizable(true)]
        public string Tooltip
        {
            get
            {

                return _Tooltip;
            }
            set
            {
                if (_Tooltip == value)
                    return;
                if (value == null) value = "";
                _Tooltip = value;

                if (this.ToolTipVisible)
                {
                    if (string.IsNullOrEmpty(_Tooltip))
                        this.HideToolTip();
                    else
                    {
                        DevComponents.DotNetBar.ToolTip tooltipWindow = _ToolTipWnd;
                        tooltipWindow.Text = _Tooltip;
                        tooltipWindow.ShowToolTip();
                        tooltipWindow.Invalidate();
                    }
                }
                OnTooltipChanged();
            }
        }
        /// <summary>
        /// Gets whether tooltip is visible or not.
        /// </summary>
        internal protected bool ToolTipVisible
        {
            get
            {
                return (_ToolTipWnd != null);
            }
        }
        /// <summary>
        /// Called when tooltip is shown and hidden.
        /// </summary>
        /// <param name="isShown">true if tooltip is being shown otherwise false.</param>
        protected virtual void OnTooltip(bool isShown)
        {
        }
        private DevComponents.DotNetBar.ToolTip _ToolTipWnd = null;
        /// <summary>
        /// Shows tooltip for this item.
        /// </summary>
        public virtual void ShowToolTip()
        {
            if (this.DesignMode)
                return;

            LayoutControl lc = this.GetLayoutControl();
            if (lc != null && !lc.ShowToolTips || !this.ShowToolTips)
                return;
            OnTooltip(true);
            if (_Tooltip != "")
            {
                if (_ToolTipWnd == null)
                    _ToolTipWnd = new DevComponents.DotNetBar.ToolTip();
                _ToolTipWnd.Style = StyleManager.GetEffectiveStyle();
                _ToolTipWnd.Text = _Tooltip;
                _ToolTipWnd.ReferenceRectangle = ScreenRectangle;

                OnToolTipVisibleChanged(new EventArgs());
                _ToolTipWnd.ShowToolTip();
            }

        }
        /// <summary>
        /// Destroys tooltip window.
        /// </summary>
        internal protected void HideToolTip()
        {
            if (_ToolTipWnd != null)
            {
                System.Drawing.Rectangle tipRect = _ToolTipWnd.Bounds;
                tipRect.Width += 5;
                tipRect.Height += 6;

                OnTooltip(false);
                OnToolTipVisibleChanged(new EventArgs());
                try
                {
                    if (_ToolTipWnd != null)
                    {
                        _ToolTipWnd.Hide();
                        _ToolTipWnd.Dispose();
                        _ToolTipWnd = null;
                    }
                }
                catch { }
                LayoutControl lc = this.GetLayoutControl();
                if (lc != null)
                {
                    lc.Invalidate(lc.RectangleToClient(tipRect), false);
                }
            }
        }
        /// <summary>
        /// Resets Hoover timer.
        /// </summary>
        protected virtual void ResetHover(System.Windows.Forms.Control ctrl)
        {
            if (ctrl == null || ctrl.IsDisposed || !ctrl.IsHandleCreated)
                return;
            // We need to reset hover thing since it is fired only first time mouse hovers inside the window and we need it for each of our items
            WinApi.TRACKMOUSEEVENT tme = new WinApi.TRACKMOUSEEVENT();
            tme.dwFlags = WinApi.TME_QUERY;
            tme.hwndTrack = ctrl.Handle;
            tme.cbSize = System.Runtime.InteropServices.Marshal.SizeOf(tme);
            WinApi.TrackMouseEvent(ref tme);
            tme.dwFlags = tme.dwFlags | WinApi.TME_HOVER;
            WinApi.TrackMouseEvent(ref tme);
            ctrl = null;
        }
        /// <summary>
        /// Occurs when item's tooltip visibility has changed.
        /// </summary>
        [System.ComponentModel.Description("Occurs when item's tooltip visibility has changed.")]
        public event EventHandler ToolTipVisibleChanged;
        private void OnToolTipVisibleChanged(EventArgs eventArgs)
        {
            EventHandler h = ToolTipVisibleChanged;
            if (h != null)
                ToolTipVisibleChanged(this, eventArgs);
        }
        private Rectangle ScreenRectangle
        {
            get
            {
                LayoutControl lc = this.GetLayoutControl();
                if (lc == null) return Rectangle.Empty;
                return new Rectangle(lc.PointToScreen(this.Bounds.Location), this.Bounds.Size);
            }
        }

        private bool _ShowToolTips = true;
        /// <summary>
        /// Gets or sets whether tooltips are shown when mouse is over the item when Tooltip property is set.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether tooltips are shown when mouse is over the item when Tooltip property is set.")]
        public bool ShowToolTips
        {
            get { return _ShowToolTips; }
            set
            {
                _ShowToolTips = value;
            }
        }
        #endregion

        #region INotifyPropertyChanged Members

        /// <summary>
        /// Raises the PropertyChanged event.
        /// </summary>
        /// <param name="e">Provides event arguments.</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, e);
        }
        /// <summary>
        /// Occurs when property on object has changed.
        /// </summary>
        [Description("Occurs when property on object has changed.")]
        public event PropertyChangedEventHandler PropertyChanged;

        #endregion
    }


    /// <summary>
    /// Specifies how layout items elements should be sized relative to their container.
    /// </summary>
    public enum eLayoutSizeType
    {
        /// <summary>
        /// The item should be sized to an exact number of pixels.
        /// </summary>
        Absolute,
        /// <summary>
        /// The item should be sized as a percentage of the parent container.
        /// </summary>
        Percent,
    }

    /// <summary>
    /// Contains values that specify how a specific element is positioned relative to another element.
    /// </summary>
    public enum eLayoutPosition
    {
        /// <summary>
        /// Default location, i.e. left.
        /// </summary>
        Default = 0,
        /// <summary>
        /// Item is located at the left edge of another item.
        /// </summary>
        Left = 1,
        /// <summary>
        /// Item is located at the right edge of another item.
        /// </summary>
        Right = 2,
        /// <summary>
        /// Item is located at the top edge of another item.
        /// </summary>
        Top = 3,
        /// <summary>
        /// Item is located at the bottom edge of another item.
        /// </summary>
        Bottom = 4,
    }
    /// <summary>
    /// Specifies layout text alignment within the text bounds.
    /// </summary>
    public enum eTextAlignment
    {
        Default,
        Left,
        Right,
        Center
    }
    /// <summary>
    /// Specifies layout text line alignment within the text bounds.
    /// </summary>
    public enum eTextLineAlignment
    {
        Default,
        Top,
        Middle,
        Bottom
    }

    #region MarkupLinkClickEventArgs
    /// <summary>
    /// Provides more information about MarkupLinkClick event.
    /// </summary>
    public class MarkupLinkClickEventArgs : EventArgs
    {
        /// <summary>
        /// Gets the value of href attribute from the markup link that was clicked.
        /// </summary>
        public readonly string HRef = "";

        /// <summary>
        /// Gets the value of name attribute from the markup link that was clicked.
        /// </summary>
        public readonly string Name = "";

        /// <summary>
        /// Creates new instance of the object.
        /// </summary>
        /// <param name="name">Value of name attribute.</param>
        /// <param name="href">Value of href attribute.</param>
        public MarkupLinkClickEventArgs(string name, string href)
        {
            this.HRef = href;
            this.Name = name;
        }
    }

    /// <summary>
    /// Defines delegate for MarkupLinkClick event.
    /// </summary>
    public delegate void MarkupLinkClickEventHandler(object sender, MarkupLinkClickEventArgs e);
    #endregion
}