using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace DevComponents.DotNetBar.Charts.Style
{
    ///<summary>
    /// ContainerVisualStyles
    ///</summary>
    [TypeConverter(typeof(VisualStylesConverter))]
    public class ContainerVisualStyles : VisualStyles<ContainerVisualStyle>
    {
        #region Copy

        /// <summary>
        /// Returns the copy of the style.
        /// </summary>
        /// <returns>Copy of the style.</returns>
        public ContainerVisualStyles Copy()
        {
            ContainerVisualStyles styles = new ContainerVisualStyles();

            for (int i = 0; i < Styles.Length; i++)
            {
                ContainerVisualStyle vstyle = Styles[i];

                if (vstyle != null)
                    styles.Styles[i] = vstyle.Copy();
            }

            return (styles);
        }

        #endregion
    }

    /// <summary>
    /// Represents the visual style of a container item.
    /// </summary>
    [ToolboxItem(false), DesignTimeVisible(false)]
    [TypeConverter(typeof(BlankExpandableObjectConverter))]
    public class ContainerVisualStyle : VisualStyle
    {
        #region Private variables

        private Tbool _AllowWrap = Tbool.NotSet;
        private Alignment _Alignment = Alignment.NotSet;

        private Image _Image;
        private int _ImageIndex = -1;
        private ImageList _ImageList;

        private Padding _ImagePadding;

        private Alignment _ImageAlignment = Alignment.NotSet;
        private ImageOverlay _ImageOverlay = ImageOverlay.NotSet;
        private ImageSizeMode _ImageSizeMode = ImageSizeMode.NotSet;

        private Tbool _EnableImageScroll = Tbool.NotSet;

        private DropShadowVisualStyle _DropShadow;

        private SymbolDef _SymbolDef;

        #endregion

        #region Public properties

        #region Alignment

        /// <summary>
        /// Gets or sets the alignment of the text
        /// </summary>
        [DefaultValue(Alignment.NotSet), Category("Appearance")]
        [Description("Indicates the alignment of the text.")]
        public Alignment Alignment
        {
            get { return (_Alignment); }

            set
            {
                if (_Alignment != value)
                {
                    _Alignment = value;

                    OnPropertyChangedEx("Alignment", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region AllowWrap

        /// <summary>
        /// Gets or sets whether text wrapping is permitted
        /// </summary>
        [DefaultValue(Tbool.NotSet), Category("Appearance")]
        [Description("Indicates whether text wrapping is permitted.")]
        public Tbool AllowWrap
        {
            get { return (_AllowWrap); }

            set
            {
                if (_AllowWrap != value)
                {
                    _AllowWrap = value;

                    OnPropertyChangedEx("AllowWrap", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region DropShadow

        /// <summary>
        /// Gets or sets the visual style for the DropShadow.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual style for the DropShadow.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public DropShadowVisualStyle DropShadow
        {
            get
            {
                if (_DropShadow == null)
                {
                    _DropShadow = new DropShadowVisualStyle();

                    UpdateChangeHandler(null, _DropShadow);
                }

                return (_DropShadow);
            }

            set
            {
                if (_DropShadow != value)
                {
                    DropShadowVisualStyle oldValue = _DropShadow;

                    _DropShadow = value;

                    OnStyleChanged("DropShadow", oldValue, value);

                    if (oldValue != null)
                        oldValue.Dispose();
                }
            }
        }

        #endregion

        #region EnableImageScroll

        /// <summary>
        /// Gets or sets whether the image scrolls or is fixed with the container content.
        /// </summary>
        [DefaultValue(Tbool.NotSet)]
        [Category("Appearance"), Description("Indicates whether the image scrolls or is fixed with the container content.")]
        public Tbool EnableImageScroll
        {
            get { return (_EnableImageScroll); }

            set
            {
                if (value != _EnableImageScroll)
                {
                    _EnableImageScroll = value;

                    OnPropertyChangedEx("EnableImageScroll", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region Image

        /// <summary>
        /// Gets or sets the element Image
        /// </summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates the element image")]
        public Image Image
        {
            get { return (_Image); }

            set
            {
                if (_Image != value)
                {
                    _Image = value;

                    OnPropertyChangedEx("Image", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ImageAlignment

        /// <summary>
        /// Gets or sets the alignment of the Image
        /// </summary>
        [DefaultValue(Alignment.NotSet), Category("Appearance")]
        [Description("Indicates the alignment of the Image.")]
        public Alignment ImageAlignment
        {
            get { return (_ImageAlignment); }

            set
            {
                if (_ImageAlignment != value)
                {
                    _ImageAlignment = value;

                    OnPropertyChangedEx("ImageAlignment", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ImageIndex

        /// <summary>
        /// Gets or sets the image index
        /// </summary>
        [DefaultValue(-1)]
        [Category("Appearance"), Description("Indicates the image index")]
        [Editor("DevComponents.SuperGrid.Design.ImageIndexEditor, DevComponents.SuperGrid.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
        [TypeConverter(typeof(ImageIndexConverter))]
        public int ImageIndex
        {
            get { return (_ImageIndex); }

            set
            {
                if (_ImageIndex != value)
                {
                    _ImageIndex = value;

                    OnPropertyChangedEx("ImageIndex", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ImageList

        /// <summary>
        /// Gets or sets the ImageList.
        /// </summary>
        [Browsable(true), Category("Appearance"), DefaultValue(null)]
        [Description("Indicates the ImageList.")]
        public ImageList ImageList
        {
            get { return (_ImageList); }

            set
            {
                if (_ImageList != value)
                {
                    _ImageList = value;

                    OnPropertyChangedEx("ImageList", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ImageOverlay

        /// <summary>
        /// Gets or sets how to overlay the cell image with respect to cell content
        /// </summary>
        [DefaultValue(ImageOverlay.NotSet), Category("Appearance")]
        [Description("Indicates how to overlay the cell image with respect to cell content.")]
        public ImageOverlay ImageOverlay
        {
            get { return (_ImageOverlay); }

            set
            {
                if (_ImageOverlay != value)
                {
                    _ImageOverlay = value;

                    OnPropertyChangedEx("ImageOverlay", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ImagePadding

        /// <summary>
        /// Gets or sets the spacing between content and edges of the Image
        /// </summary>
        [Description("Indicates the spacing between content and edges of the Image")]
        public Padding ImagePadding
        {
            get
            {
                if (_ImagePadding == null)
                {
                    _ImagePadding = Padding.Empty;

                    UpdateChangeHandler(null, _ImagePadding);
                }

                return (_ImagePadding);
            }

            set
            {
                if (_ImagePadding != value)
                {
                    UpdateChangeHandler(_ImagePadding, value);

                    _ImagePadding = value;

                    OnPropertyChangedEx("ImagePadding", VisualChangeType.Layout);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeImagePadding()
        {
            return (_ImagePadding != null && _ImagePadding.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetImagePadding()
        {
            ImagePadding = null;
        }

        #endregion

        #region ImageSizeMode

        /// <summary>
        /// Gets or sets the 'mode' used to display the image.
        /// </summary>
        [DefaultValue(ImageSizeMode.NotSet), Category("Appearance")]
        [Description("Indicates the 'mode' used to display the image.")]
        public ImageSizeMode ImageSizeMode
        {
            get { return (_ImageSizeMode); }

            set
            {
                if (value!= _ImageSizeMode)
                {
                    _ImageSizeMode = value;

                    OnPropertyChangedEx("ImageSizeMode", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region SymbolDef

        /// <summary>
        /// Gets or sets the element Symbol Definition. Note that Symbol definition
        /// takes precedence over Image definition. Also note that the supporting Image
        /// properties (such as ImageAlignment, ImageOverlay, etc) apply to a set
        /// Symbol as well as to a set Image.
        /// </summary>
        [DefaultValue(null), Category("Appearance")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Description("Indicates the element Symbol Definition. Note that Symbol definition takes precedence over Image definition. Also note that the supporting Image properties (such as ImageAlignment, ImageOverlay, etc) apply to a set Symbol as well as to a set Image.")]
        public SymbolDef SymbolDef
        {
            get
            {
                if (_SymbolDef == null)
                {
                    _SymbolDef = new SymbolDef();

                    UpdateChangeHandler(null, _SymbolDef);
                }

                return (_SymbolDef);
            }

            set
            {
                if (_SymbolDef != value)
                {
                    UpdateChangeHandler(_SymbolDef, value);

                    _SymbolDef = value;

                    OnPropertyChangedEx("SymbolDef", VisualChangeType.Layout);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeSymbolDef()
        {
            return (_SymbolDef != null && _SymbolDef.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetSymbolDef()
        {
            SymbolDef = null;
        }

        #endregion

        #region IsEmpty

        /// <summary>
        /// Gets whether the style is logically Empty.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Gets whether the style is logically Empty.")]
        public override bool IsEmpty
        {
            get
            {
                return ((_Alignment == Alignment.NotSet) &&
                    (_AllowWrap == Tbool.NotSet) &&
                    (_DropShadow == null || _DropShadow.IsEmpty) &&
                    (_Image == null) &&
                    (_ImageAlignment == Alignment.NotSet) &&
                    (_ImageIndex == -1) &&
                    (_ImageList == null) &&
                    (_ImageOverlay == ImageOverlay.NotSet) &&
                    (_ImagePadding == null || _ImagePadding.IsEmpty == true) &&
                    (_ImageSizeMode == Style.ImageSizeMode.NotSet) &&
                    (_SymbolDef == null || _SymbolDef.IsEmpty == true) &&
                    (base.IsEmpty == true));
            }
        }

        #endregion

        #endregion

        #region Internal properties

        #region IsOverlayImage

        internal bool IsOverlayImage
        {
            get
            {
                return (_ImageOverlay == ImageOverlay.Top ||
                    _ImageOverlay == ImageOverlay.Middle ||
                    _ImageOverlay == ImageOverlay.Bottom);
            }
        }

        #endregion

        #region IsValidFigure

        internal bool IsValidFigure
        {
            get
            {
                if (IsSymbolFigure == true)
                    return (true);

                return (GetImage() != null);
            }
        }

        #endregion

        #region IsSymbolFigure

        internal bool IsSymbolFigure
        {
            get { return (_SymbolDef != null &&  _SymbolDef.IsValidSymbol == true); }
        }

        #endregion

        #endregion

        #region GetFigure

        internal object GetFigure()
        {
            if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
                return (_SymbolDef);

            return (GetImage());
        }

        #region GetImage

        internal Image GetImage()
        {
            if (_Image != null)
                return (_Image);

            if (_ImageIndex >= 0)
            {
                ImageList imageList = ImageList;

                if (imageList != null && _ImageIndex < imageList.Images.Count)
                    return (imageList.Images[_ImageIndex]);
            }

            return (null);
        }

        #endregion

        #region GetSymbol

        internal string GetSymbol()
        {
            if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
                return (_SymbolDef.SymbolRealized);

            return (null);
        }

        #endregion

        #endregion

        #region GetFigureSize

        internal Size GetFigureSize(Graphics g)
        {
            Size size = Size.Empty;

            if (IsSymbolFigure == true)
                size = _SymbolDef.GetSymbolSize(g);

            else
            {
                Image image = GetImage();

                if (image != null)
                    size = Dpi.Size(image.Size);
            }

            if (size.IsEmpty == false)
            {
                size.Width += Dpi.Width(ImagePadding.Horizontal);
                size.Height += Dpi.Height(ImagePadding.Vertical);
            }

            return (size);
        }

        #endregion

        #region GetFigureBounds

        internal Rectangle GetFigureBounds(Graphics g, Rectangle r)
        {
            if (IsSymbolFigure == true)
                return (GetSymbolBounds(g, r));

            return (GetImageBounds(g, r));
        }

        #region GetImageBounds

        internal Rectangle GetImageBounds(Graphics g, Rectangle r)
        {
            Image image = GetImage();

            return (GetImageBounds(g, r, image));
        }

        private Rectangle GetImageBounds(Graphics g, Rectangle r, Image image)
        {
            if (image != null)
                return (GetSizeBounds(r, Dpi.Size(image.Size)));

            return (Rectangle.Empty);
        }

        #endregion

        #region GetSymbolBounds

        internal Rectangle GetSymbolBounds(Graphics g, Rectangle r)
        {
            if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
            {
                Size size = _SymbolDef.GetSymbolSize(g);

                return (GetSizeBounds(r, size));
            }

            return (Rectangle.Empty);
        }

        #endregion

        #region GetSizeBounds

        internal Rectangle GetSizeBounds(Rectangle r, Size size)
        {
            switch (ImageAlignment)
            {
                case Alignment.NotSet:
                case Alignment.MiddleLeft:
                    r.Y += (r.Height - size.Height) / 2;

                    r.X += Dpi.Width(ImagePadding.Left);
                    r.Y += Dpi.Height(ImagePadding.Top - ImagePadding.Bottom);
                    break;

                case Alignment.TopLeft:
                    r.X += Dpi.Width(ImagePadding.Left);
                    r.Y += Dpi.Height(ImagePadding.Top);
                    break;

                case Alignment.BottomLeft:
                    r.Y = r.Bottom - size.Height;

                    r.X += Dpi.Width(ImagePadding.Left);
                    r.Y -= Dpi.Height(ImagePadding.Bottom);
                    break;

                case Alignment.TopCenter:
                    r.X += (r.Width - size.Width) / 2;

                    r.X += Dpi.Width(ImagePadding.Left - ImagePadding.Right);
                    r.Y += Dpi.Height(ImagePadding.Top);
                    break;

                case Alignment.MiddleCenter:
                    r.X += (r.Width - size.Width) / 2;
                    r.Y += (r.Height - size.Height) / 2;

                    r.X += Dpi.Width(ImagePadding.Left - ImagePadding.Right);
                    r.Y += Dpi.Height(ImagePadding.Top - ImagePadding.Bottom);
                    break;

                case Alignment.BottomCenter:
                    r.X += (r.Width - size.Width) / 2;
                    r.Y = r.Bottom - size.Height;

                    r.X += Dpi.Width(ImagePadding.Left - ImagePadding.Right);
                    r.Y -= Dpi.Height(ImagePadding.Bottom);
                    break;

                case Alignment.TopRight:
                    r.X = r.Right - size.Width;

                    r.X -= Dpi.Width(ImagePadding.Right);
                    r.Y += Dpi.Height(ImagePadding.Top);
                    break;

                case Alignment.MiddleRight:
                    r.X = r.Right - size.Width;
                    r.Y += (r.Height - size.Height) / 2;

                    r.X -= Dpi.Width(ImagePadding.Right);
                    r.Y += Dpi.Height(ImagePadding.Top - ImagePadding.Bottom);
                    break;

                case Alignment.BottomRight:
                    r.X = r.Right - size.Width;
                    r.Y = r.Bottom - size.Height;

                    r.X -= Dpi.Width(ImagePadding.Right);
                    r.Y -= Dpi.Height(ImagePadding.Bottom);
                    break;
            }

            r.Size = size;

            return (r);
        }

        #endregion

        #endregion

        #region RenderBackgroundFigure

        internal void RenderBackgroundFigure(Graphics g, Rectangle bounds)
        {
            RenderBackgroundFigure(g, bounds, bounds);
        }

        internal void RenderBackgroundFigure(Graphics g, Rectangle bounds, Rectangle clipBounds)
        {
            if (IsSymbolFigure == true)
            {
                RenderBackgroundSymbol(g, bounds, clipBounds);
            }
            else
            {
                Image image = GetImage();

                if (image != null)
                    RenderBackgroundImage(g, bounds, clipBounds);
            }
        }

        #region RenderBackgroundImage

        internal void RenderBackgroundImage(Graphics g, Rectangle bounds, Rectangle clipBounds)
        {
            Image image = GetImage();

            if (image != null)
            {
                Region clip = g.Clip;

                if (ImageSizeMode == ImageSizeMode.NotSet ||
                    ImageSizeMode == ImageSizeMode.Normal)
                {
                    Rectangle dbounds = GetImageBounds(g, clipBounds, image);

                    g.SetClip(Rectangle.Intersect(bounds, dbounds));

                    g.DrawImage(image, dbounds,
                        new Rectangle(Point.Empty, image.Size), GraphicsUnit.Pixel);
                }
                else
                {
                    Rectangle r = GetAdjustedBounds(clipBounds, ImagePadding);

                    g.SetClip(r, CombineMode.Intersect);

                    switch (ImageSizeMode)
                    {
                        case ImageSizeMode.Stretch:
                            g.DrawImage(image, r);
                            break;

                        case ImageSizeMode.Tile:
                            RenderImageTiled(g, image, r);
                            break;

                        case ImageSizeMode.Zoom:
                            RenderImageZoomed(g, image, r);
                            break;
                    }
                }

                g.Clip = clip;
            }
        }

        #region GetAdjustedBounds

        private Rectangle GetAdjustedBounds(Rectangle bounds, Thickness padding)
        {
            if (padding.IsEmpty == false)
            {
                if (bounds.Height > padding.Vertical)
                {
                    bounds.Y += padding.Top;
                    bounds.Height -= padding.Vertical;
                }

                if (bounds.Width > padding.Horizontal)
                {
                    bounds.X += padding.Left;
                    bounds.Width -= padding.Horizontal;
                }
            }

            return (bounds);
        }

        #endregion

        #region RenderImageTiled

        private void RenderImageTiled(Graphics g, Image image, Rectangle bounds)
        {
            Rectangle sr = new Rectangle(Point.Empty, image.Size);
            Rectangle dr = new Rectangle(bounds.Location, image.Size);

            while (dr.Top < bounds.Bottom)
            {
                while (dr.Left < bounds.Right)
                {
                    g.DrawImage(image, dr, sr, GraphicsUnit.Pixel);

                    dr.X += image.Size.Width;
                }

                dr.X = bounds.X;
                dr.Y += image.Size.Height;
            }
        }

        #endregion

        #region RenderImageZoomed

        private void RenderImageZoomed(
            Graphics g, Image image, Rectangle r)
        {
            SizeF size = new SizeF(image.Width / image.HorizontalResolution,
                image.Height / image.VerticalResolution);

            float scale = Math.Min(r.Width / size.Width, r.Height / size.Height);

            size.Width *= scale;
            size.Height *= scale;

            Point pt = r.Location;

            if (Math.Abs(r.Width - size.Width) > 2)
            {
                switch (ImageAlignment)
                {
                    case Alignment.TopCenter:
                    case Alignment.MiddleCenter:
                    case Alignment.BottomCenter:
                        pt.X += (int)((r.Width - size.Width) / 2);
                        break;

                    case Alignment.TopRight:
                    case Alignment.MiddleRight:
                    case Alignment.BottomRight:
                        pt.X = (int)(r.Right - size.Width);
                        break;
                }
            }
            else
            {
                switch (ImageAlignment)
                {
                    case Alignment.MiddleLeft:
                    case Alignment.MiddleCenter:
                    case Alignment.MiddleRight:
                        pt.Y += (int)((r.Height - size.Height) / 2);
                        break;

                    case Alignment.BottomLeft:
                    case Alignment.BottomCenter:
                    case Alignment.BottomRight:
                        pt.Y = (int)(r.Bottom - size.Height);
                        break;
                }
            }

            g.DrawImage(image,
                pt.X, pt.Y, size.Width, size.Height);
        }

        #endregion

        #endregion

        #region RenderBackgroundSymbol

        internal void RenderBackgroundSymbol(Graphics g, Rectangle bounds, Rectangle clipBounds)
        {
            string symbol = GetSymbol();

            if (symbol != null)
            {
                Region clip = g.Clip;

                if (ImageSizeMode != ImageSizeMode.Tile)
                {
                    Rectangle dbounds = GetSymbolBounds(g, clipBounds);

                    g.SetClip(Rectangle.Intersect(bounds, dbounds));

                    using (Brush br = new SolidBrush(_SymbolDef.SymbolColor))
                        g.DrawString(symbol, _SymbolDef.SymbolFont, br, dbounds);
                }
                else
                {
                    Rectangle r = GetAdjustedBounds(clipBounds, ImagePadding);

                    g.SetClip(r, CombineMode.Intersect);

                    RenderSymbolTiled(g, symbol, r);
                }

                g.Clip = clip;
            }
        }

        #region RenderSymbolTiled

        private void RenderSymbolTiled(Graphics g, string symbol, Rectangle bounds)
        {
            Font font = _SymbolDef.SymbolFont;
            Color color = _SymbolDef.SymbolColor;

            Size size = _SymbolDef.GetSymbolSize(g);
            Rectangle dr = new Rectangle(bounds.Location, size);

            while (dr.Top < bounds.Bottom)
            {
                while (dr.Left < bounds.Right)
                {
                    TextDrawing.DrawString(g, symbol, font, color, dr, eTextFormat.Default);

                    dr.X += size.Width;
                }

                dr.X = bounds.X;
                dr.Y += size.Height;
            }
        }

        #endregion

        #endregion

        #endregion

        #region GetStringFormatFlags

        internal void GetStringFormatFlags(StringFormat sf)
        {
            if (AllowWrap == Tbool.False)
                sf.FormatFlags |= StringFormatFlags.NoWrap;

            switch (Alignment)
            {
                case Alignment.TopCenter:
                    sf.LineAlignment = StringAlignment.Near;
                    sf.Alignment = StringAlignment.Center;
                    break;

                case Alignment.TopRight:
                    sf.LineAlignment = StringAlignment.Near;
                    sf.Alignment = StringAlignment.Far;
                    break;

                case Alignment.MiddleLeft:
                    sf.LineAlignment = StringAlignment.Center;
                    sf.Alignment = StringAlignment.Near;
                    break;

                case Alignment.MiddleCenter:
                    sf.LineAlignment = StringAlignment.Center;
                    sf.Alignment = StringAlignment.Center;
                    break;

                case Alignment.MiddleRight:
                    sf.LineAlignment = StringAlignment.Center;
                    sf.Alignment = StringAlignment.Far;
                    break;

                case Alignment.BottomLeft:
                    sf.LineAlignment = StringAlignment.Far;
                    sf.Alignment = StringAlignment.Near;
                    break;

                case Alignment.BottomCenter:
                    sf.LineAlignment = StringAlignment.Far;
                    sf.Alignment = StringAlignment.Center;
                    break;

                case Alignment.BottomRight:
                    sf.LineAlignment = StringAlignment.Far;
                    sf.Alignment = StringAlignment.Far;
                    break;
            }
        }

        #endregion

        #region GetTextFormatFlags

        internal eTextFormat GetTextFormatFlags()
        {
            eTextFormat tf = eTextFormat.WordEllipsis |
                eTextFormat.NoPadding | eTextFormat.NoPrefix;

            if (AllowWrap == Tbool.True)
                tf |= eTextFormat.WordBreak;

            switch (Alignment)
            {
                case Alignment.TopCenter:
                    tf |= eTextFormat.HorizontalCenter;
                    break;

                case Alignment.TopRight:
                    tf |= eTextFormat.Right;
                    break;

                case Alignment.MiddleLeft:
                    tf |= eTextFormat.VerticalCenter;
                    break;

                case Alignment.NotSet:
                case Alignment.MiddleCenter:
                    tf |= eTextFormat.HorizontalCenter;
                    tf |= eTextFormat.VerticalCenter;
                    break;

                case Alignment.MiddleRight:
                    tf |= eTextFormat.Right;
                    tf |= eTextFormat.VerticalCenter;
                    break;

                case Alignment.BottomLeft:
                    tf |= eTextFormat.Bottom;
                    break;

                case Alignment.BottomCenter:
                    tf |= eTextFormat.Bottom;
                    tf |= eTextFormat.HorizontalCenter;
                    break;

                case Alignment.BottomRight:
                    tf |= eTextFormat.Bottom;
                    tf |= eTextFormat.Right;
                    break;
            }

            return (tf);
        }

        #endregion

        #region ApplyStyle

        /// <summary>
        /// Applies the style to instance of this style.
        /// </summary>
        /// <param name="style">Style to apply.</param>
        public void ApplyStyle(ContainerVisualStyle style)
        {
            base.ApplyStyle(style);

            if (style != null)
            {
                if (style.Alignment != Alignment.NotSet)
                    Alignment = style.Alignment;

                if (style.AllowWrap != Tbool.NotSet)
                    AllowWrap = style.AllowWrap;

                if (style._DropShadow != null && style.DropShadow.IsEmpty == false)
                    DropShadow.ApplyStyle(style.DropShadow);

                if (style.EnableImageScroll != Tbool.NotSet)
                    EnableImageScroll = style.EnableImageScroll;

                if (style.ImageIndex >= 0)
                {
                    Image = null;
                    ImageIndex = style.ImageIndex;
                }

                if (style.Image != null)
                {
                    Image = style.Image;
                    ImageIndex = -1;
                }

                if (style.ImageAlignment != Alignment.NotSet)
                    ImageAlignment = style.ImageAlignment;

                if (style.ImageList != null)
                    ImageList = style.ImageList;

                if (style._ImagePadding != null && style._ImagePadding.IsEmpty == false)
                    ImagePadding = style._ImagePadding.Copy();

                if (style.ImageOverlay != ImageOverlay.NotSet)
                    ImageOverlay = style.ImageOverlay;

                if (style.ImageSizeMode != ImageSizeMode.NotSet)
                    ImageSizeMode = style.ImageSizeMode;

                if (style._SymbolDef != null && style._SymbolDef.IsEmpty == false)
                    SymbolDef = style._SymbolDef.Copy();
            }
        }

        #endregion

        #region ApplyDefaults

        public override void ApplyDefaults()
        {
            base.ApplyDefaults();

            if (_SymbolDef != null && _SymbolDef.IsValidSymbol == true)
            {
                if (_SymbolDef.SymbolSize == 0)
                {
                    if (Font != null)
                        _SymbolDef.SymbolSize = Font.SizeInPoints;
                }

                if (_SymbolDef.SymbolColor.IsEmpty == true)
                {
                    _SymbolDef.SymbolColor = 
                        (TextColor.IsEmpty == false) ? TextColor : Color.Black;
                }
            }
        }

        #endregion

        #region Copy

        /// <summary>
        /// Returns the copy of the style.
        /// </summary>
        /// <returns>Copy of the style.</returns>
        public new ContainerVisualStyle Copy()
        {
            ContainerVisualStyle style = new ContainerVisualStyle();

            CopyTo(style);

            return (style);
        }

        #endregion

        #region CopyTo

        /// <summary>
        /// Returns the copy of the style.
        /// </summary>
        /// <returns>Copy of the style.</returns>
        public void CopyTo(ContainerVisualStyle style)
        {
            base.CopyTo(style);

            style.Alignment = _Alignment;
            style.AllowWrap = _AllowWrap;
            style.DropShadow = (_DropShadow != null) ? DropShadow.Copy() : null;
            style.EnableImageScroll = _EnableImageScroll;

            style.Image = _Image;
            style.ImageAlignment = _ImageAlignment;
            style.ImageIndex = _ImageIndex;
            style.ImageList = _ImageList;
            style.ImageOverlay = _ImageOverlay;
            style.ImagePadding = (_ImagePadding != null) ? _ImagePadding.Copy() : null;
            style.ImageSizeMode = _ImageSizeMode;

            style.SymbolDef = (_SymbolDef != null) ? _SymbolDef.Copy() : null;
        }

        #endregion

        #region GetSerialData

        internal override SerialElementCollection GetSerialData(string serialName)
        {
            SerialElementCollection sec = new SerialElementCollection();

            if (serialName != null)
            {
                if (serialName.Equals("") == true)
                    serialName = "ContainerVisualStyle";

                sec.AddStartElement(serialName);
            }

            sec.AddValue("Alignment", Alignment, Alignment.NotSet);
            sec.AddValue("AllowWrap", AllowWrap, Tbool.NotSet);

            if (_DropShadow != null && _DropShadow.IsEmpty == false)
                sec.AddElement(_DropShadow.GetSerialData("DropShadow"));

            sec.AddValue("EnableImageScroll", EnableImageScroll, Tbool.NotSet);
            sec.AddValue("Image", Image);
            sec.AddValue("ImageAlignment", ImageAlignment, Alignment.NotSet);
            sec.AddValue("ImageIndex", ImageIndex, -1);

            if (_ImageList != null)
                sec.AddValue("ImageList", XmlSerializableImageList.ConvertToString(ImageList));

            sec.AddValue("ImageOverlay", ImageOverlay, ImageOverlay.NotSet);

            if (_ImagePadding != null && _ImagePadding.IsEmpty == false)
                sec.AddElement(_ImagePadding.GetSerialData("ImagePadding"));

            sec.AddValue("ImageSizeMode", ImageSizeMode, ImageSizeMode.NotSet);

            if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
                sec.AddElement(_SymbolDef.GetSerialData("SymbolDef"));

            sec.AddElement(base.GetSerialData(null));

            if (serialName != null)
                sec.AddEndElement("ContainerVisualStyle");

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessValue

        internal override void ProcessValue(SerialElement se)
        {
            switch (se.Name)
            {
                case "Alignment":
                    Alignment = (Alignment)se.GetValueEnum(typeof(Alignment));
                    break;

                case "AllowWrap":
                    AllowWrap = (Tbool)se.GetValueEnum(typeof(Tbool));
                    break;

                case "EnableImageScroll":
                    EnableImageScroll = (Tbool)se.GetValueEnum(typeof(Tbool));
                    break;

                case "Image":
                    Image = se.GetValueImage();
                    break;

                case "ImageAlignment":
                    ImageAlignment = (Alignment)se.GetValueEnum(typeof(Alignment));
                    break;

                case "ImageIndex":
                    ImageIndex = int.Parse(se.StringValue);
                    break;

                case "ImageList":
                    ImageList = XmlSerializableImageList.ConvertFromString(se.StringValue);
                    break;

                case "ImageOverlay":
                    ImageOverlay = (ImageOverlay)se.GetValueEnum(typeof(ImageOverlay));
                    break;

                case "ImageSizeMode":
                    ImageSizeMode = (ImageSizeMode)se.GetValueEnum(typeof(ImageSizeMode));
                    break;

                default:
                    base.ProcessValue(se);
                    break;
            }
        }

        #endregion

        #region ProcessCollection

        internal override void ProcessCollection(SerialElement se)
        {
            SerialElementCollection sec = se.Sec;

            switch (se.Name)
            {
                case "DropShadow":
                    sec.PutSerialData(DropShadow);
                    break;

                case "ImagePadding":
                    sec.PutSerialData(ImagePadding);
                    break;

                case "SymbolDef":
                    sec.PutSerialData(SymbolDef);
                    break;

                default:
                    base.ProcessCollection(se);
                    break;
            }
        }

        #endregion

        #endregion

        #region IDisposable

        /// <summary>
        /// Dispose
        /// </summary>
        public override void Dispose()
        {
            DropShadow = null;
            ImagePadding = null;
            SymbolDef = null;

            base.Dispose();
        }

        #endregion
    }

    #region ImageOverlay

    ///<summary>
    /// How to Overlay the Image with
    /// respect to the content
    ///</summary>
    public enum ImageOverlay
    {
        ///<summary>
        /// Not set
        ///</summary>
        NotSet = -1,

        ///<summary>
        /// None - Overlaying of the image will be avioded (when possible)
        ///</summary>
        None,

        ///<summary>
        /// Top
        ///</summary>
        Top,

        ///<summary>
        /// Middle
        ///</summary>
        Middle,

        ///<summary>
        /// Bottom
        ///</summary>
        Bottom,
    }

    #endregion

    #region ImageSizeMode

    ///<summary>
    /// ImageSizeMode
    ///</summary>
    public enum ImageSizeMode
    {
        ///<summary>
        /// Not set
        ///</summary>
        NotSet = -1,

        ///<summary>
        /// The image is placed according to the specified 
        /// Alignment, and is clipped if needed to fit.
        ///</summary>
        Normal,

        ///<summary>
        /// The image is stretched or shrunk to fit.
        ///</summary>
        Stretch,

        ///<summary>
        /// The image is tiled to fill the area.
        ///</summary>
        Tile,

        ///<summary>
        /// The size of the image is increased or decreased to fit the
        /// area, maintaining the image size ratio.
        ///</summary>
        Zoom,
    }

    #endregion
}