using System;
using System.ComponentModel;

namespace DevComponents.DotNetBar.Charts.Style
{
    /// <summary>
    /// Defines set of default visual styles that are defined on the container control.
    /// </summary>
    [TypeConverter(typeof(VisualStylesConverter))]
    public class DefaultVisualStyles : IProcessSerialElement, INotifyPropertyChanged, IDisposable
    {
        #region Private variables

        // Multi state style definitions

        private ContainerVisualStyles _ContainerVisualStyles;

        private ChartLegendVisualStyles _ChartLegendVisualStyles;
        private ChartLegendItemVisualStyles _ChartLegendItemVisualStyles;

        private ChartSliceVisualStyles _SliceVisualStyles;
        private ChartSliceVisualStyles _OtherSliceVisualStyles;

        private ScrollBarVisualStyles _HScrollBarVisualStyles;
        private ScrollBarVisualStyles _VScrollBarVisualStyles;

        // Single state style definitions

        private ChartAxisVisualStyle _ChartXAxisVisualStyle;
        private ChartAxisVisualStyle _ChartYAxisVisualStyle;

        private ChartPanelVisualStyle _ChartPanelVisualStyle;
        private ChartSeriesVisualStyle _ChartSeriesVisualStyle;
        private ChartTickmarkVisualStyle _ChartTickmarkVisualStyle;
        private ChartTitleVisualStyle _ChartTitleVisualStyle;
        private ChartXyVisualStyle _ChartXyVisualStyle;
        private DataLabelVisualStyle _DataLabelVisualStyle;

        private CrosshairValueVisualStyle _CrosshairLabelVisualStyle;
        private CrosshairVisualStyle _CrosshairVisualStyle;

        private DividerLineVisualStyle _DividerLineVisualStyle;
        private PieGridLineVisualStyle _GridLineVisualStyle;
        private PieChartVisualStyle _PieChartVisualStyle;

        private ReferenceLineVisualStyle _ReferenceLineVisualStyle;
        private RegressionLineVisualStyle _RegressionLineVisualStyle;
        private TrendLineVisualStyle _TrendLineVisualStyle;

        private TickmarkLabelVisualStyle _TickmarkLabelVisualStyle;

        #endregion

        #region Public properties

        #region ChartLegendItemVisualStyles

        /// <summary>
        /// Gets or sets the visual styles to be used for ChartLegendItem elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual styles to be used for ChartLegendI tem elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartLegendItemVisualStyles ChartLegendItemVisualStyles
        {
            get
            {
                if (_ChartLegendItemVisualStyles == null)
                {
                    _ChartLegendItemVisualStyles = new ChartLegendItemVisualStyles();

                    StyleChangeHandler(null, _ChartLegendItemVisualStyles);
                }

                return (_ChartLegendItemVisualStyles);
            }

            set
            {
                if (value != _ChartLegendItemVisualStyles)
                {
                    ChartLegendItemVisualStyles oldValue = _ChartLegendItemVisualStyles;
                    _ChartLegendItemVisualStyles = value;

                    OnStyleChanged("ChartLegendVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartLegendVisualStyles

        /// <summary>
        /// Gets or sets the visual styles to be used for ChartLegend elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual styles to be used for ChartLegend elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartLegendVisualStyles ChartLegendVisualStyles
        {
            get
            {
                if (_ChartLegendVisualStyles == null)
                {
                    _ChartLegendVisualStyles = new ChartLegendVisualStyles();

                    StyleChangeHandler(null, _ChartLegendVisualStyles);
                }

                return (_ChartLegendVisualStyles);
            }

            set
            {
                if (value != _ChartLegendVisualStyles)
                {
                    ChartLegendVisualStyles oldValue = _ChartLegendVisualStyles;
                    _ChartLegendVisualStyles = value;

                    OnStyleChanged("ChartLegendVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartPanelVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for ChartPanel elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for ChartPanel elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartPanelVisualStyle ChartPanelVisualStyle
        {
            get
            {
                if (_ChartPanelVisualStyle == null)
                {
                    _ChartPanelVisualStyle = new ChartPanelVisualStyle();

                    StyleChangeHandler(null, _ChartPanelVisualStyle);
                }

                return (_ChartPanelVisualStyle);
            }

            set
            {
                if (_ChartPanelVisualStyle != value)
                {
                    ChartPanelVisualStyle oldValue = _ChartPanelVisualStyle;
                    _ChartPanelVisualStyle = value;

                    OnStyleChanged("ChartPanelVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartSeriesVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for ChartSeries elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for ChartSeries elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartSeriesVisualStyle ChartSeriesVisualStyle
        {
            get
            {
                if (_ChartSeriesVisualStyle == null)
                {
                    _ChartSeriesVisualStyle = new ChartSeriesVisualStyle();

                    StyleChangeHandler(null, _ChartSeriesVisualStyle);
                }

                return (_ChartSeriesVisualStyle);
            }

            set
            {
                if (value != _ChartSeriesVisualStyle)
                {
                    ChartSeriesVisualStyle oldValue = _ChartSeriesVisualStyle;
                    _ChartSeriesVisualStyle = value;

                    OnStyleChanged("ChartSeriesVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartTickmarkVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for chart Tickmark elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for chart Tickmark elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartTickmarkVisualStyle ChartTickmarkVisualStyle
        {
            get
            {
                if (_ChartTickmarkVisualStyle == null)
                {
                    _ChartTickmarkVisualStyle = new ChartTickmarkVisualStyle();

                    StyleChangeHandler(null, _ChartTickmarkVisualStyle);
                }

                return (_ChartTickmarkVisualStyle);
            }

            set
            {
                if (_ChartTickmarkVisualStyle != value)
                {
                    ChartTickmarkVisualStyle oldValue = _ChartTickmarkVisualStyle;
                    _ChartTickmarkVisualStyle = value;

                    OnStyleChanged("ChartTickmarkVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartTitleVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for ChartTitle elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for ChartTitle elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartTitleVisualStyle ChartTitleVisualStyle
        {
            get
            {
                if (_ChartTitleVisualStyle == null)
                {
                    _ChartTitleVisualStyle = new ChartTitleVisualStyle();

                    StyleChangeHandler(null, _ChartTitleVisualStyle);
                }

                return (_ChartTitleVisualStyle);
            }

            set
            {
                if (_ChartTitleVisualStyle != value)
                {
                    ChartTitleVisualStyle oldValue = _ChartTitleVisualStyle;
                    _ChartTitleVisualStyle = value;

                    OnStyleChanged("ChartTitleVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartXAxisVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for X Axis elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for X Axis elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartAxisVisualStyle ChartXAxisVisualStyle
        {
            get
            {
                if (_ChartXAxisVisualStyle == null)
                {
                    _ChartXAxisVisualStyle = new ChartAxisVisualStyle();

                    StyleChangeHandler(null, _ChartXAxisVisualStyle);
                }

                return (_ChartXAxisVisualStyle);
            }

            set
            {
                if (_ChartXAxisVisualStyle != value)
                {
                    ChartAxisVisualStyle oldValue = _ChartXAxisVisualStyle;
                    _ChartXAxisVisualStyle = value;

                    OnStyleChanged("ChartXAxisVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartXyVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for XyChart elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for XyChart elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartXyVisualStyle ChartXyVisualStyle
        {
            get
            {
                if (_ChartXyVisualStyle == null)
                {
                    _ChartXyVisualStyle = new ChartXyVisualStyle();

                    StyleChangeHandler(null, _ChartXyVisualStyle);
                }

                return (_ChartXyVisualStyle);
            }

            set
            {
                if (_ChartXyVisualStyle != value)
                {
                    ChartXyVisualStyle oldValue = _ChartXyVisualStyle;
                    _ChartXyVisualStyle = value;

                    OnStyleChanged("ChartXyVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ChartYAxisVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for Y Axis elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for Y Axis elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartAxisVisualStyle ChartYAxisVisualStyle
        {
            get
            {
                if (_ChartYAxisVisualStyle == null)
                {
                    _ChartYAxisVisualStyle = new ChartAxisVisualStyle();

                    StyleChangeHandler(null, _ChartYAxisVisualStyle);
                }

                return (_ChartYAxisVisualStyle);
            }

            set
            {
                if (_ChartYAxisVisualStyle != value)
                {
                    ChartAxisVisualStyle oldValue = _ChartYAxisVisualStyle;
                    _ChartYAxisVisualStyle = value;

                    OnStyleChanged("ChartYAxisVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ContainerVisualStyles

        /// <summary>
        /// Gets or sets the visual stylse to be used for Chart Container elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual styles to be used for XyChart elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ContainerVisualStyles ContainerVisualStyles
        {
            get
            {
                if (_ContainerVisualStyles == null)
                {
                    _ContainerVisualStyles = new ContainerVisualStyles();

                    StyleChangeHandler(null, _ContainerVisualStyles);
                }

                return (_ContainerVisualStyles);
            }

            set
            {
                if (_ContainerVisualStyles != value)
                {
                    ContainerVisualStyles oldValue = _ContainerVisualStyles;
                    _ContainerVisualStyles = value;

                    OnStyleChanged("ContainerVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region CrosshairLabelVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for Crosshair label elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for Crosshair label elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public CrosshairValueVisualStyle CrosshairLabelVisualStyle
        {
            get
            {
                if (_CrosshairLabelVisualStyle == null)
                {
                    _CrosshairLabelVisualStyle = new CrosshairValueVisualStyle();

                    StyleChangeHandler(null, _CrosshairLabelVisualStyle);
                }

                return (_CrosshairLabelVisualStyle);
            }

            set
            {
                if (_CrosshairLabelVisualStyle != value)
                {
                    CrosshairValueVisualStyle oldValue = _CrosshairLabelVisualStyle;
                    _CrosshairLabelVisualStyle = value;

                    OnStyleChanged("CrosshairLabelVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region CrosshairVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for Crosshair elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for Crosshair elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public CrosshairVisualStyle CrosshairVisualStyle
        {
            get
            {
                if (_CrosshairVisualStyle == null)
                {
                    _CrosshairVisualStyle = new CrosshairVisualStyle();

                    StyleChangeHandler(null, _CrosshairVisualStyle);
                }

                return (_CrosshairVisualStyle);
            }

            set
            {
                if (_CrosshairVisualStyle != value)
                {
                    CrosshairVisualStyle oldValue = _CrosshairVisualStyle;
                    _CrosshairVisualStyle = value;

                    OnStyleChanged("CrosshairVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region DataLabelVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for DataLabel elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for DataLabel elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public DataLabelVisualStyle DataLabelVisualStyle
        {
            get
            {
                if (_DataLabelVisualStyle == null)
                {
                    _DataLabelVisualStyle = new DataLabelVisualStyle();

                    StyleChangeHandler(null, _DataLabelVisualStyle);
                }

                return (_DataLabelVisualStyle);
            }

            set
            {
                if (value != _DataLabelVisualStyle)
                {
                    DataLabelVisualStyle oldValue = _DataLabelVisualStyle;
                    _DataLabelVisualStyle = value;

                    OnStyleChanged("DataLabelVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region DividerLineVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for DividerLine elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for DividerLine elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public DividerLineVisualStyle DividerLineVisualStyle
        {
            get
            {
                if (_DividerLineVisualStyle == null)
                {
                    _DividerLineVisualStyle = new DividerLineVisualStyle();

                    StyleChangeHandler(null, _DividerLineVisualStyle);
                }

                return (_DividerLineVisualStyle);
            }

            set
            {
                if (_DividerLineVisualStyle != value)
                {
                    DividerLineVisualStyle oldValue = _DividerLineVisualStyle;
                    _DividerLineVisualStyle = value;

                    OnStyleChanged("DividerLineVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region GridLineVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for GridLine elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for GridLine elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public PieGridLineVisualStyle GridLineVisualStyle
        {
            get
            {
                if (_GridLineVisualStyle == null)
                {
                    _GridLineVisualStyle = new PieGridLineVisualStyle();

                    StyleChangeHandler(null, _GridLineVisualStyle);
                }

                return (_GridLineVisualStyle);
            }

            set
            {
                if (_GridLineVisualStyle != value)
                {
                    PieGridLineVisualStyle oldValue = _GridLineVisualStyle;
                    _GridLineVisualStyle = value;

                    OnStyleChanged("GridLinesVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region HScrollBarVisualStyles

        /// <summary>
        /// Gets or sets the visual styles to be used for Horizontal ScrollBar elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual styles to be used for Horizontal ScrollBar elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ScrollBarVisualStyles HScrollBarVisualStyles
        {
            get
            {
                if (_HScrollBarVisualStyles == null)
                {
                    _HScrollBarVisualStyles = new ScrollBarVisualStyles();

                    StyleChangeHandler(null, _HScrollBarVisualStyles);
                }

                return (_HScrollBarVisualStyles);
            }

            set
            {
                if (_HScrollBarVisualStyles != value)
                {
                    ScrollBarVisualStyles oldValue = _HScrollBarVisualStyles;
                    _HScrollBarVisualStyles = value;

                    OnStyleChanged("HScrollBarVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region OtherSliceVisualStyles

        /// <summary>
        /// Gets or sets the default visual style for the series 'Other' slice.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the default visual style for the series 'Other' slice.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartSliceVisualStyles OtherSliceVisualStyles
        {
            get
            {
                if (_OtherSliceVisualStyles == null)
                {
                    _OtherSliceVisualStyles = new ChartSliceVisualStyles();

                    StyleChangeHandler(null, _OtherSliceVisualStyles);
                }

                return (_OtherSliceVisualStyles);
            }

            set
            {
                if (_OtherSliceVisualStyles != value)
                {
                    ChartSliceVisualStyles oldValue = _OtherSliceVisualStyles;

                    _OtherSliceVisualStyles = value;

                    OnStyleChanged("OtherSliceVisualStyles", oldValue, value);

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

        #endregion

        #region PieChartVisualStyles

        /// <summary>
        /// Gets or sets the visual style to be used for PieChart elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for PieChart elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public PieChartVisualStyle PieChartVisualStyle
        {
            get
            {
                if (_PieChartVisualStyle == null)
                {
                    _PieChartVisualStyle = new PieChartVisualStyle();

                    StyleChangeHandler(null, _PieChartVisualStyle);
                }

                return (_PieChartVisualStyle);
            }

            set
            {
                if (_PieChartVisualStyle != value)
                {
                    PieChartVisualStyle oldValue = _PieChartVisualStyle;
                    _PieChartVisualStyle = value;

                    OnStyleChanged("PieChartVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region ReferenceLineVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for ReferenceLine elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for ReferenceLine elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ReferenceLineVisualStyle ReferenceLineVisualStyle
        {
            get
            {
                if (_ReferenceLineVisualStyle == null)
                {
                    _ReferenceLineVisualStyle = new ReferenceLineVisualStyle();

                    StyleChangeHandler(null, _ReferenceLineVisualStyle);
                }

                return (_ReferenceLineVisualStyle);
            }

            set
            {
                if (_ReferenceLineVisualStyle != value)
                {
                    ReferenceLineVisualStyle oldValue = _ReferenceLineVisualStyle;
                    _ReferenceLineVisualStyle = value;

                    OnStyleChanged("ReferenceLineVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region RegressionLineVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for RegressionIndicator elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for RegressionIndicator elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public RegressionLineVisualStyle RegressionLineVisualStyle
        {
            get
            {
                if (_RegressionLineVisualStyle == null)
                {
                    _RegressionLineVisualStyle = new RegressionLineVisualStyle();

                    StyleChangeHandler(null, _RegressionLineVisualStyle);
                }

                return (_RegressionLineVisualStyle);
            }

            set
            {
                if (_RegressionLineVisualStyle != value)
                {
                    RegressionLineVisualStyle oldValue = _RegressionLineVisualStyle;
                    _RegressionLineVisualStyle = value;

                    OnStyleChanged("RegressionLineVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region SliceVisualStyles

        /// <summary>
        /// Gets or sets the visual style to be used for Pie Slice elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for Pie Slice elements")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartSliceVisualStyles SliceVisualStyles
        {
            get
            {
                if (_SliceVisualStyles == null)
                {
                    _SliceVisualStyles = new ChartSliceVisualStyles();

                    StyleChangeHandler(null, _SliceVisualStyles);
                }

                return (_SliceVisualStyles);
            }

            set
            {
                if (value != _SliceVisualStyles)
                {
                    ChartSliceVisualStyles oldValue = _SliceVisualStyles;
                    _SliceVisualStyles = value;

                    OnStyleChanged("SliceVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region TickmarkLabelVisualStyle

        /// <summary>
        /// Gets or sets the visual styles to be used for Axis Lable 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual styles to be used for Axis Lable ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TickmarkLabelVisualStyle TickmarkLabelVisualStyle
        {
            get
            {
                if (_TickmarkLabelVisualStyle == null)
                {
                    _TickmarkLabelVisualStyle = new TickmarkLabelVisualStyle();

                    StyleChangeHandler(null, _TickmarkLabelVisualStyle);
                }

                return (_TickmarkLabelVisualStyle);
            }

            set
            {
                if (_TickmarkLabelVisualStyle != value)
                {
                    TickmarkLabelVisualStyle oldValue = _TickmarkLabelVisualStyle;
                    _TickmarkLabelVisualStyle = value;

                    OnStyleChanged("TickmarkLabelVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region TrendLineVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for TrendLine elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual style to be used for TrendLine elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TrendLineVisualStyle TrendLineVisualStyle
        {
            get
            {
                if (_TrendLineVisualStyle == null)
                {
                    _TrendLineVisualStyle = new TrendLineVisualStyle();

                    StyleChangeHandler(null, _TrendLineVisualStyle);
                }

                return (_TrendLineVisualStyle);
            }

            set
            {
                if (_TrendLineVisualStyle != value)
                {
                    TrendLineVisualStyle oldValue = _TrendLineVisualStyle;
                    _TrendLineVisualStyle = value;

                    OnStyleChanged("TrendLineVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region VScrollBarVisualStyles

        /// <summary>
        /// Gets or sets the visual styles to be used for Vertical ScrollBar elements 
        /// </summary>
        [Category("Style")]
        [Description("Indicates visual styles to be used for Vertical ScrollBar elements ")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ScrollBarVisualStyles VScrollBarVisualStyles
        {
            get
            {
                if (_VScrollBarVisualStyles == null)
                {
                    _VScrollBarVisualStyles = new ScrollBarVisualStyles();

                    StyleChangeHandler(null, _VScrollBarVisualStyles);
                }

                return (_VScrollBarVisualStyles);
            }

            set
            {
                if (_VScrollBarVisualStyles != value)
                {
                    ScrollBarVisualStyles oldValue = _VScrollBarVisualStyles;
                    _VScrollBarVisualStyles = value;

                    OnStyleChanged("VScrollBarVisualStyles", oldValue, value);
                }
            }
        }

        #endregion

        #region IsEmpty

        /// <summary>
        /// Gets whether the style collection is logically Empty.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Gets whether the style collection is logically Empty.")]
        public bool IsEmpty
        {
            get
            {
                if (_ChartLegendItemVisualStyles != null && _ChartLegendItemVisualStyles.IsEmpty == false)
                    return (false);

                if (_ChartLegendVisualStyles != null && _ChartLegendVisualStyles.IsEmpty == false)
                    return (false);

                if (_ChartPanelVisualStyle != null && _ChartPanelVisualStyle.IsEmpty == false)
                    return (false);

                if (_HScrollBarVisualStyles != null && _HScrollBarVisualStyles.IsEmpty == false)
                    return (false);

                if (_VScrollBarVisualStyles != null && _VScrollBarVisualStyles.IsEmpty == false)
                    return (false);

                if (_ChartSeriesVisualStyle != null && _ChartSeriesVisualStyle.IsEmpty == false)
                    return (false);

                if (_ChartTickmarkVisualStyle != null && _ChartTickmarkVisualStyle.IsEmpty == false)
                    return (false);

                if (_ChartTitleVisualStyle != null && _ChartTitleVisualStyle.IsEmpty == false)
                    return (false);

                if (_ChartXAxisVisualStyle != null && _ChartXAxisVisualStyle.IsEmpty == false)
                    return (false);

                if (_ChartXyVisualStyle != null && _ChartXyVisualStyle.IsEmpty == false)
                    return (false);

                if (_ChartYAxisVisualStyle != null && _ChartYAxisVisualStyle.IsEmpty == false)
                    return (false);

                if (_ContainerVisualStyles != null && _ContainerVisualStyles.IsEmpty == false)
                    return (false);

                if (_CrosshairLabelVisualStyle != null && _CrosshairLabelVisualStyle.IsEmpty == false)
                    return (false);

                if (_CrosshairVisualStyle != null && _CrosshairVisualStyle.IsEmpty == false)
                    return (false);

                if (_DataLabelVisualStyle != null && _DataLabelVisualStyle.IsEmpty == false)
                    return (false);

                if (_DividerLineVisualStyle != null && _DividerLineVisualStyle.IsEmpty == false)
                    return (false);

                if (_GridLineVisualStyle != null && _GridLineVisualStyle.IsEmpty == false)
                    return (false);

                if (_ReferenceLineVisualStyle != null && _ReferenceLineVisualStyle.IsEmpty == false)
                    return (false);

                if (_TickmarkLabelVisualStyle != null && _TickmarkLabelVisualStyle.IsEmpty == false)
                    return (false);

                if (_TrendLineVisualStyle != null && _TrendLineVisualStyle.IsEmpty == false)
                    return (false);

                return (true);
            }
        }

        #endregion

        #endregion

        #region OnStyleChanged

        private void OnStyleChanged(string property,
            INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
        {
            StyleChangeHandler(oldValue, newValue);

            OnPropertyChanged(new VisualPropertyChangedEventArgs(property));
        }

        #endregion

        #region StyleChangeHandler

        private void StyleChangeHandler(
            INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
        {
            if (oldValue != null)
                oldValue.PropertyChanged -= StyleChanged;

            if (newValue != null)
                newValue.PropertyChanged += StyleChanged;
        }

        #endregion

        #region StyleChanged

        /// <summary>
        /// Occurs when one of element visual styles has property changes.
        /// Default implementation invalidates visual appearance of element.
        /// </summary>
        /// <param name="sender">VisualStyle that changed.</param>
        /// <param name="e">Event arguments.</param>
        protected virtual void StyleChanged(object sender, PropertyChangedEventArgs e)
        {
            OnPropertyChanged(e);
        }

        #endregion

        #region Copy/CopyTo

        public DefaultVisualStyles Copy()
        {
            DefaultVisualStyles copy = new DefaultVisualStyles();

            CopyTo(copy);

            return (copy);
        }

        public void CopyTo(DefaultVisualStyles c)
        {
            for (int i = 0; i < ChartLegendItemVisualStyles.Styles.Length; i++)
            {
                if (ChartLegendItemVisualStyles.Styles[i] != null)
                    c.ChartLegendItemVisualStyles.Styles[i] = ChartLegendItemVisualStyles.Styles[i].Copy();
            }

            for (int i = 0; i < ChartLegendVisualStyles.Styles.Length; i++)
            {
                if (ChartLegendVisualStyles.Styles[i] != null)
                    c.ChartLegendVisualStyles.Styles[i] = ChartLegendVisualStyles.Styles[i].Copy();
            }

            ChartPanelVisualStyle.CopyTo(c.ChartPanelVisualStyle);
            ChartSeriesVisualStyle.CopyTo(c.ChartSeriesVisualStyle);
            ChartTickmarkVisualStyle.CopyTo(c.ChartTickmarkVisualStyle);
            ChartTitleVisualStyle.CopyTo(c.ChartTitleVisualStyle);
            ChartXAxisVisualStyle.CopyTo(c.ChartXAxisVisualStyle);
            ChartXyVisualStyle.CopyTo(c.ChartXyVisualStyle);
            ChartYAxisVisualStyle.CopyTo(c.ChartYAxisVisualStyle);

            for (int i = 0; i < ContainerVisualStyles.Styles.Length; i++)
            {
                if (ContainerVisualStyles.Styles[i] != null)
                    c.ContainerVisualStyles.Styles[i] = ContainerVisualStyles.Styles[i].Copy();
            }

            CrosshairLabelVisualStyle.CopyTo(c.CrosshairLabelVisualStyle);
            CrosshairVisualStyle.CopyTo(c.CrosshairVisualStyle);
            DataLabelVisualStyle.CopyTo(c.DataLabelVisualStyle);
            DividerLineVisualStyle.CopyTo(c.DividerLineVisualStyle);
            GridLineVisualStyle.CopyTo(c.GridLineVisualStyle);

            for (int i = 0; i < HScrollBarVisualStyles.Styles.Length; i++)
            {
                if (HScrollBarVisualStyles.Styles[i] != null)
                    c.HScrollBarVisualStyles.Styles[i] = HScrollBarVisualStyles.Styles[i].Copy();
            }

            for (int i = 0; i < OtherSliceVisualStyles.Styles.Length; i++)
            {
                if (OtherSliceVisualStyles.Styles[i] != null)
                    c.OtherSliceVisualStyles.Styles[i] = OtherSliceVisualStyles.Styles[i].Copy();
            }

            PieChartVisualStyle.CopyTo(c.PieChartVisualStyle);
            ReferenceLineVisualStyle.CopyTo(c.ReferenceLineVisualStyle);
            RegressionLineVisualStyle.CopyTo(c.RegressionLineVisualStyle);

            for (int i = 0; i < SliceVisualStyles.Styles.Length; i++)
            {
                if (SliceVisualStyles.Styles[i] != null)
                    c.SliceVisualStyles.Styles[i] = SliceVisualStyles.Styles[i].Copy();
            }

            TickmarkLabelVisualStyle.CopyTo(c.TickmarkLabelVisualStyle);
            TrendLineVisualStyle.CopyTo(c.TrendLineVisualStyle);

            for (int i = 0; i < VScrollBarVisualStyles.Styles.Length; i++)
            {
                if (VScrollBarVisualStyles.Styles[i] != null)
                    c.VScrollBarVisualStyles.Styles[i] = VScrollBarVisualStyles.Styles[i].Copy();
            }
        }

        #endregion

        #region GetSerialData

        internal SerialElementCollection GetSerialData()
        {
            return (GetSerialData(true));
        }

        internal SerialElementCollection GetSerialData(bool root)
        {
            SerialElementCollection sec = new SerialElementCollection();

            if (root == true)
                sec.AddStartElement("DefaultVisualStyles");

            if (_ChartLegendItemVisualStyles != null && _ChartLegendItemVisualStyles.IsEmpty == false)
                sec.AddElement(_ChartLegendItemVisualStyles.GetSerialData("ChartLegendItemVisualStyles"));

            if (_ChartLegendVisualStyles != null && _ChartLegendVisualStyles.IsEmpty == false)
                sec.AddElement(_ChartLegendVisualStyles.GetSerialData("ChartLegendVisualStyles"));

            sec.AddElement(_ChartPanelVisualStyle);
            sec.AddElement(_ChartSeriesVisualStyle);
            sec.AddElement(_ChartTickmarkVisualStyle);
            sec.AddElement(_ChartTitleVisualStyle);
            sec.AddElement(_ChartXAxisVisualStyle);
            sec.AddElement(_ChartXyVisualStyle);
            sec.AddElement(_ChartYAxisVisualStyle);

            if (_ContainerVisualStyles != null && _ContainerVisualStyles.IsEmpty == false)
                sec.AddElement(_ContainerVisualStyles.GetSerialData("ContainerVisualStyles"));

            sec.AddElement(_CrosshairLabelVisualStyle);
            sec.AddElement(_CrosshairVisualStyle);
            sec.AddElement(_DataLabelVisualStyle);
            sec.AddElement(_DividerLineVisualStyle);
            sec.AddElement(_GridLineVisualStyle);

            if (_HScrollBarVisualStyles != null && _HScrollBarVisualStyles.IsEmpty == false)
                sec.AddElement(_HScrollBarVisualStyles.GetSerialData("HScrollBarVisualStyles"));

            if (_OtherSliceVisualStyles != null && _OtherSliceVisualStyles.IsEmpty == false)
                sec.AddElement(_OtherSliceVisualStyles.GetSerialData("OtherSliceVisualStyles"));

            sec.AddElement(_PieChartVisualStyle);
            sec.AddElement(_ReferenceLineVisualStyle);
            sec.AddElement(_RegressionLineVisualStyle);

            if (_SliceVisualStyles != null && _SliceVisualStyles.IsEmpty == false)
                sec.AddElement(_SliceVisualStyles.GetSerialData("SliceVisualStyles"));

            sec.AddElement(_TickmarkLabelVisualStyle);
            sec.AddElement(_TrendLineVisualStyle);

            if (_VScrollBarVisualStyles != null && _VScrollBarVisualStyles.IsEmpty == false)
                sec.AddElement(_VScrollBarVisualStyles.GetSerialData("VScrollBarVisualStyles"));

            if (root == true)
                sec.AddEndElement("DefaultVisualStyles");

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessValue

        void IProcessSerialElement.ProcessValue(SerialElement se)
        {
            throw new Exception("Unknown Serial Value (" + se.Name + ")");
        }

        #endregion

        #region ProcessCollection

        void IProcessSerialElement.ProcessCollection(SerialElement se)
        {
            switch (se.Name)
            {
                case "ChartLegendItemVisualStyles":
                    se.Sec.PutSerialData(ChartLegendItemVisualStyles);
                    break;

                case "ChartLegendVisualStyles":
                    se.Sec.PutSerialData(ChartLegendVisualStyles);
                    break;

                case "ChartPanelVisualStyle":
                    se.Sec.PutSerialData(ChartPanelVisualStyle);
                    break;

                case "ChartSeriesVisualStyle":
                    se.Sec.PutSerialData(ChartSeriesVisualStyle);
                    break;

                case "ChartTickmarkVisualStyle":
                    se.Sec.PutSerialData(ChartTickmarkVisualStyle);
                    break;

                case "ChartTitleVisualStyle":
                    se.Sec.PutSerialData(ChartTitleVisualStyle);
                    break;

                case "ChartXAxisVisualStyle":
                    se.Sec.PutSerialData(ChartXAxisVisualStyle);
                    break;

                case "ChartXyVisualStyle":
                    se.Sec.PutSerialData(ChartXyVisualStyle);
                    break;

                case "ChartYAxisVisualStyle":
                    se.Sec.PutSerialData(ChartYAxisVisualStyle);
                    break;

                case "ContainerVisualStyles":
                    se.Sec.PutSerialData(ContainerVisualStyles);
                    break;

                case "CrosshairLabelVisualStyle":
                    se.Sec.PutSerialData(CrosshairLabelVisualStyle);
                    break;

                case "CrosshairVisualStyle":
                    se.Sec.PutSerialData(CrosshairVisualStyle);
                    break;

                case "DataLabelVisualStyle":
                    se.Sec.PutSerialData(DataLabelVisualStyle);
                    break;

                case "DividerLineVisualStyle":
                    se.Sec.PutSerialData(DividerLineVisualStyle);
                    break;

                case "GridLineVisualStyle":
                    se.Sec.PutSerialData(GridLineVisualStyle);
                    break;

                case "HScrollBarVisualStyles":
                    se.Sec.PutSerialData(HScrollBarVisualStyles);
                    break;

                case "OtherSliceVisualStyles":
                    se.Sec.PutSerialData(OtherSliceVisualStyles);
                    break;

                case "PieChartVisualStyle":
                    se.Sec.PutSerialData(PieChartVisualStyle);
                    break;

                case "ReferenceLineVisualStyle":
                    se.Sec.PutSerialData(ReferenceLineVisualStyle);
                    break;

                case "RegressionLineVisualStyle":
                    se.Sec.PutSerialData(RegressionLineVisualStyle);
                    break;

                case "SliceVisualStyles":
                    se.Sec.PutSerialData(SliceVisualStyles);
                    break;

                case "TickmarkLableVisualStyle":
                    se.Sec.PutSerialData(TickmarkLabelVisualStyle);
                    break;

                case "TrendLineVisualStyle":
                    se.Sec.PutSerialData(TrendLineVisualStyle);
                    break;

                case "VScrollBarVisualStyles":
                    se.Sec.PutSerialData(VScrollBarVisualStyles);
                    break;

                default:
                    throw new Exception("Unknown Serial Collection (" + se.Name + ")");
            }
        }

        #endregion

        #endregion

        #region INotifyPropertyChanged Members

        /// <summary>
        /// Occurs when property value has changed.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Raises the PropertyChanged event.
        /// </summary>
        /// <param name="e">Event arguments</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChangedEventHandler eh = PropertyChanged;

            if (eh != null)
                eh(this, e);
        }

        #endregion

        #region IDisposable

        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            ChartPanelVisualStyle = null;
            ChartTitleVisualStyle = null;

            ChartXAxisVisualStyle = null;
            ChartYAxisVisualStyle = null;
        }

        #endregion
    }
}