//------------------------------------------------------------------------------
// <copyright file="Wizard.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Drawing.Design;
    using System.Globalization;
    using System.Linq;
    using System.Security.Permissions;
    using System.Web;
    using System.Web.UI;
    using System.Web.Util;

    [
    Bindable(false),
    DefaultEvent("FinishButtonClick"),
    Designer("System.Web.UI.Design.WebControls.WizardDesigner, " + AssemblyRef.SystemDesign),
    ToolboxData("<{0}:Wizard runat=\"server\"> <WizardSteps> <asp:WizardStep title=\"Step 1\" runat=\"server\"></asp:WizardStep> <asp:WizardStep title=\"Step 2\" runat=\"server\"></asp:WizardStep> </WizardSteps> </{0}:Wizard>")
    ]

    public class Wizard : CompositeControl {

        private ITemplate _finishNavigationTemplate;
        private ITemplate _headerTemplate;
        private ITemplate _layoutTemplate;
        private ITemplate _startNavigationTemplate;
        private ITemplate _stepNavigationTemplate;
        private ITemplate _sideBarTemplate;

        private MultiView _multiView;

        private static readonly object _eventActiveStepChanged = new object();
        private static readonly object _eventFinishButtonClick = new object();
        private static readonly object _eventNextButtonClick = new object();
        private static readonly object _eventPreviousButtonClick = new object();
        private static readonly object _eventSideBarButtonClick = new object();
        private static readonly object _eventCancelButtonClick = new object();

        // 
        public static readonly string HeaderPlaceholderId = "headerPlaceholder";
        public static readonly string NavigationPlaceholderId = "navigationPlaceholder";
        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "SideBar", Justification = "The casing has already been established in the context of Wizard")]
        public static readonly string SideBarPlaceholderId = "sideBarPlaceholder";
        public static readonly string WizardStepPlaceholderId = "wizardStepPlaceholder";

        public static readonly string CancelCommandName = "Cancel";
        public static readonly string MoveNextCommandName = "MoveNext";
        public static readonly string MovePreviousCommandName = "MovePrevious";
        public static readonly string MoveToCommandName = "Move";
        public static readonly string MoveCompleteCommandName = "MoveComplete";

        protected static readonly string CancelButtonID = "CancelButton";
        protected static readonly string StartNextButtonID = "StartNextButton";
        protected static readonly string StepPreviousButtonID = "StepPreviousButton";
        protected static readonly string StepNextButtonID = "StepNextButton";
        protected static readonly string FinishButtonID = "FinishButton";
        protected static readonly string FinishPreviousButtonID = "FinishPreviousButton";
        protected static readonly string CustomPreviousButtonID = "CustomPreviousButton";
        protected static readonly string CustomNextButtonID = "CustomNextButton";
        protected static readonly string CustomFinishButtonID = "CustomFinishButton";
        protected static readonly string DataListID = "SideBarList";
        protected static readonly string SideBarButtonID = "SideBarButton";

        internal const string _customNavigationControls = "CustomNavigationControls";

        private const string _templatedStepsID = "TemplatedWizardSteps";
        private const string _multiViewID = "WizardMultiView";

        private const string _customNavigationContainerIdPrefix = "__CustomNav";

        private TableCell _sideBarTableCell;

        private IWizardSideBarListControl _sideBarList;

        private IButtonControl _commandSender;
        private Dictionary<WizardStepBase, BaseNavigationTemplateContainer> _customNavigationContainers;
        private IDictionary _designModeState;
        private Stack<int> _historyStack;
        private List<TemplatedWizardStep> _templatedSteps;
        private WizardStepCollection _wizardStepCollection;

        private WizardRenderingBase _rendering;

        private bool _activeStepIndexSet;
        private bool _displaySideBarDefault;
        private bool _displaySideBar;
        private bool? _isMacIE;
        private bool _renderSideBarDataList;

        private Style _cancelButtonStyle;
        private Style _finishCompleteButtonStyle;
        private Style _finishPreviousButtonStyle;
        private Style _navigationButtonStyle;
        private Style _sideBarButtonStyle;
        private Style _startNextButtonStyle;
        private Style _stepNextButtonStyle;
        private Style _stepPreviousButtonStyle;

        private TableItemStyle _headerStyle;
        private TableItemStyle _navigationStyle;
        private TableItemStyle _sideBarStyle;
        private TableItemStyle _stepStyle;

        private const bool _displaySideBarDefaultValue = true; /* default to true */
        private const int _viewStateArrayLength = 15;

        public Wizard()
            : this(_displaySideBarDefaultValue) {
        }


        internal Wizard(bool displaySideBarDefault) {
            _displaySideBarDefault = displaySideBarDefault;
            _displaySideBar = displaySideBarDefault;
        }

        #region Public Properties

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        WebSysDescription(SR.Wizard_ActiveStep)
        ]
        public WizardStepBase ActiveStep {
            get {
                if (ActiveStepIndex < -1 || ActiveStepIndex >= WizardSteps.Count) {
                    throw new InvalidOperationException(SR.GetString(SR.Wizard_ActiveStepIndex_out_of_range));
                }

                return MultiView.GetActiveView() as WizardStepBase;
            }
        }


        [
        DefaultValue(-1),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Wizard_ActiveStepIndex),
        ]
        public virtual int ActiveStepIndex {
            get {
                return MultiView.ActiveViewIndex;
            }
            set {
                if (value < -1 ||
                    (value >= WizardSteps.Count && ControlState >= ControlState.FrameworkInitialized)) {
                    throw new ArgumentOutOfRangeException("value",
                        SR.GetString(SR.Wizard_ActiveStepIndex_out_of_range));
                }

                if (MultiView.ActiveViewIndex != value) {
                    MultiView.ActiveViewIndex = value;
                    _activeStepIndexSet = true;

                    // Need to rebind the DataList control if the active step is changed.
                    // This is necessary since custom sidebar template might have different
                    // itemtemplates defined.
                    if (_sideBarList != null && SideBarTemplate != null) {
                        _sideBarList.SelectedIndex = ActiveStepIndex;
                        _sideBarList.DataBind();
                    }
                }
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL of an image to be displayed for the cancel button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_CancelButtonImageUrl),
        UrlProperty(),
        ]
        public virtual string CancelButtonImageUrl {
            get {
                object obj = ViewState["CancelButtonImageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["CancelButtonImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the cancel buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_CancelButtonStyle)
        ]
        public Style CancelButtonStyle {
            get {
                if (_cancelButtonStyle == null) {
                    _cancelButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_cancelButtonStyle).TrackViewState();
                    }
                }
                return _cancelButtonStyle;
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_CancelButtonText),
        WebSysDescription(SR.Wizard_CancelButtonText)
        ]
        public virtual String CancelButtonText {
            get {
                string s = ViewState["CancelButtonText"] as String;
                return s == null ? SR.GetString(SR.Wizard_Default_CancelButtonText) : s;
            }
            set {
                if (value != CancelButtonText) {
                    ViewState["CancelButtonText"] = value;
                }
            }
        }


        [
        DefaultValue(ButtonType.Button),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_CancelButtonType)
        ]
        public virtual ButtonType CancelButtonType {
            get {
                object obj = ViewState["CancelButtonType"];
                return (obj == null) ? ButtonType.Button : (ButtonType)obj;
            }
            set {
                ValidateButtonType(value);
                ViewState["CancelButtonType"] = value;
            }
        }


        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Wizard_CancelDestinationPageUrl),
        UrlProperty(),
        ]
        public virtual String CancelDestinationPageUrl {
            get {
                string s = ViewState["CancelDestinationPageUrl"] as String;
                return s == null ? String.Empty : s;
            }
            set {
                ViewState["CancelDestinationPageUrl"] = value;
            }
        }


        [
        WebCategory("Layout"),
        DefaultValue(0),
        WebSysDescription(SR.Wizard_CellPadding)
        ]
        public virtual int CellPadding {
            get {
                if (ControlStyleCreated == false) {
                    return 0;
                }
                return ((TableStyle)ControlStyle).CellPadding;
            }
            set {
                ((TableStyle)ControlStyle).CellPadding = value;
            }
        }


        [
        WebCategory("Layout"),
        DefaultValue(0),
        WebSysDescription(SR.Wizard_CellSpacing)
        ]
        public virtual int CellSpacing {
            get {
                if (ControlStyleCreated == false) {
                    return 0;
                }
                return ((TableStyle)ControlStyle).CellSpacing;
            }
            set {
                ((TableStyle)ControlStyle).CellSpacing = value;
            }
        }


        [
        DefaultValue(false),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Wizard_DisplayCancelButton),
        ]
        public virtual bool DisplayCancelButton {
            get {
                object o = ViewState["DisplayCancelButton"];
                return o == null ? false : (bool)o;
            }
            set {
                ViewState["DisplayCancelButton"] = value;
            }
        }


        [
        DefaultValue(true),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Wizard_DisplaySideBar),
        ]
        public virtual bool DisplaySideBar {
            get {
                return _displaySideBar;
            }
            set {
                if (value != _displaySideBar) {
                    _displaySideBar = value;
                    _sideBarTableCell = null;
                    RequiresControlsRecreation();
                }
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL of an image to be displayed for the finish button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_FinishCompleteButtonImageUrl),
        UrlProperty(),
        ]
        public virtual string FinishCompleteButtonImageUrl {
            get {
                object obj = ViewState["FinishCompleteButtonImageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["FinishCompleteButtonImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the finishStep buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_FinishCompleteButtonStyle)
        ]
        public Style FinishCompleteButtonStyle {
            get {
                if (_finishCompleteButtonStyle == null) {
                    _finishCompleteButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_finishCompleteButtonStyle).TrackViewState();
                    }
                }
                return _finishCompleteButtonStyle;
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_FinishButtonText),
        WebSysDescription(SR.Wizard_FinishCompleteButtonText)
        ]
        public virtual String FinishCompleteButtonText {
            get {
                string s = ViewState["FinishCompleteButtonText"] as String;
                return s == null ? SR.GetString(SR.Wizard_Default_FinishButtonText) : s;
            }
            set {
                ViewState["FinishCompleteButtonText"] = value;
            }
        }


        [
        WebCategory("Appearance"),
        DefaultValue(ButtonType.Button),
        WebSysDescription(SR.Wizard_FinishCompleteButtonType)
        ]
        public virtual ButtonType FinishCompleteButtonType {
            get {
                object obj = ViewState["FinishCompleteButtonType"];
                return (obj == null) ? ButtonType.Button : (ButtonType)obj;
            }
            set {
                ValidateButtonType(value);
                ViewState["FinishCompleteButtonType"] = value;
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL for the continue button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        Themeable(false),
        WebCategory("Behavior"),
        WebSysDescription(SR.Wizard_FinishDestinationPageUrl),
        UrlProperty(),
        ]
        public virtual string FinishDestinationPageUrl {
            get {
                object obj = ViewState["FinishDestinationPageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["FinishDestinationPageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL of an image to be displayed for the finish step's previous button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_FinishPreviousButtonImageUrl),
        UrlProperty(),
        ]
        public virtual string FinishPreviousButtonImageUrl {
            get {
                object obj = ViewState["FinishPreviousButtonImageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["FinishPreviousButtonImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the navigation buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_FinishPreviousButtonStyle)
        ]
        public Style FinishPreviousButtonStyle {
            get {
                if (_finishPreviousButtonStyle == null) {
                    _finishPreviousButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_finishPreviousButtonStyle).TrackViewState();
                    }
                }
                return _finishPreviousButtonStyle;
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_StepPreviousButtonText),
        WebSysDescription(SR.Wizard_FinishPreviousButtonText)
        ]
        public virtual String FinishPreviousButtonText {
            get {
                string s = ViewState["FinishPreviousButtonText"] as String;
                return s == null ? SR.GetString(SR.Wizard_Default_StepPreviousButtonText) : s;
            }
            set {
                ViewState["FinishPreviousButtonText"] = value;
            }
        }


        [
        WebCategory("Appearance"),
        DefaultValue(ButtonType.Button),
        WebSysDescription(SR.Wizard_FinishPreviousButtonType)
        ]
        public virtual ButtonType FinishPreviousButtonType {
            get {
                object obj = ViewState["FinishPreviousButtonType"];
                return (obj == null) ? ButtonType.Button : (ButtonType)obj;
            }
            set {
                ValidateButtonType(value);
                ViewState["FinishPreviousButtonType"] = value;
            }
        }


        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(Wizard)),
        WebSysDescription(SR.Wizard_FinishNavigationTemplate)
        ]
        public virtual ITemplate FinishNavigationTemplate {
            get {
                return _finishNavigationTemplate;
            }
            set {
                _finishNavigationTemplate = value;
                RequiresControlsRecreation();
            }
        }


        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.WebControl_HeaderStyle)
        ]
        public TableItemStyle HeaderStyle {
            get {
                if (_headerStyle == null) {
                    _headerStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_headerStyle).TrackViewState();
                }
                return _headerStyle;
            }
        }


        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(Wizard)),
        WebSysDescription(SR.WebControl_HeaderTemplate)
        ]
        public virtual ITemplate HeaderTemplate {
            get {
                return _headerTemplate;
            }
            set {
                _headerTemplate = value;
                RequiresControlsRecreation();
            }
        }


        [
        DefaultValue(""),
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_HeaderText)
        ]
        public virtual string HeaderText {
            get {
                string s = ViewState["HeaderText"] as String;
                return s == null ? String.Empty : s;
            }
            set {
                ViewState["HeaderText"] = value;
            }
        }


        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(Wizard)),
        WebSysDescription(SR.Wizard_LayoutTemplate)
        ]
        public virtual ITemplate LayoutTemplate {
            get {
                return _layoutTemplate;
            }
            set {
                _layoutTemplate = value;
                RequiresControlsRecreation();
            }
        }


        /// <devdoc>
        ///     Gets the style of the navigation buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_NavigationButtonStyle)
        ]
        public Style NavigationButtonStyle {
            get {
                if (_navigationButtonStyle == null) {
                    _navigationButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_navigationButtonStyle).TrackViewState();
                    }
                }
                return _navigationButtonStyle;
            }
        }


        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_NavigationStyle)
        ]
        public TableItemStyle NavigationStyle {
            get {
                if (_navigationStyle == null) {
                    _navigationStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_navigationStyle).TrackViewState();
                }
                return _navigationStyle;
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL of an image to be displayed for the finish step's previous button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_StartNextButtonImageUrl),
        UrlProperty(),
        ]
        public virtual string StartNextButtonImageUrl {
            get {
                object obj = ViewState["StartNextButtonImageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["StartNextButtonImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the navigation buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_StartNextButtonStyle)
        ]
        public Style StartNextButtonStyle {
            get {
                if (_startNextButtonStyle == null) {
                    _startNextButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_startNextButtonStyle).TrackViewState();
                    }
                }
                return _startNextButtonStyle;
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_StepNextButtonText),
        WebSysDescription(SR.Wizard_StartNextButtonText)
        ]
        public virtual String StartNextButtonText {
            get {
                string s = ViewState["StartNextButtonText"] as String;
                return s == null ? SR.GetString(SR.Wizard_Default_StepNextButtonText) : s;
            }
            set {
                ViewState["StartNextButtonText"] = value;
            }
        }


        [
        WebCategory("Appearance"),
        DefaultValue(ButtonType.Button),
        WebSysDescription(SR.Wizard_StartNextButtonType)
        ]
        public virtual ButtonType StartNextButtonType {
            get {
                object obj = ViewState["StartNextButtonType"];
                return (obj == null) ? ButtonType.Button : (ButtonType)obj;
            }
            set {
                ValidateButtonType(value);
                ViewState["StartNextButtonType"] = value;
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL of an image to be displayed for the next button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_StepNextButtonImageUrl),
        UrlProperty(),
        ]
        public virtual string StepNextButtonImageUrl {
            get {
                object obj = ViewState["StepNextButtonImageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["StepNextButtonImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the navigation buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_StepNextButtonStyle)
        ]
        public Style StepNextButtonStyle {
            get {
                if (_stepNextButtonStyle == null) {
                    _stepNextButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_stepNextButtonStyle).TrackViewState();
                    }
                }
                return _stepNextButtonStyle;
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_StepNextButtonText),
        WebSysDescription(SR.Wizard_StepNextButtonText)
        ]
        public virtual String StepNextButtonText {
            get {
                string s = ViewState["StepNextButtonText"] as String;
                return s == null ? SR.GetString(SR.Wizard_Default_StepNextButtonText) : s;
            }
            set {
                ViewState["StepNextButtonText"] = value;
            }
        }


        [
        WebCategory("Appearance"),
        DefaultValue(ButtonType.Button),
        WebSysDescription(SR.Wizard_StepNextButtonType)
        ]
        public virtual ButtonType StepNextButtonType {
            get {
                object obj = ViewState["StepNextButtonType"];
                return (obj == null) ? ButtonType.Button : (ButtonType)obj;
            }
            set {
                ValidateButtonType(value);
                ViewState["StepNextButtonType"] = value;
            }
        }


        /// <devdoc>
        ///     Gets or sets the URL of an image to be displayed for the previous button.
        /// </devdoc>
        [
        DefaultValue(""),
        Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        WebCategory("Appearance"),
        WebSysDescription(SR.Wizard_StepPreviousButtonImageUrl),
        UrlProperty(),
        ]
        public virtual string StepPreviousButtonImageUrl {
            get {
                object obj = ViewState["StepPreviousButtonImageUrl"];
                return (obj == null) ? String.Empty : (string)obj;
            }
            set {
                ViewState["StepPreviousButtonImageUrl"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the navigation buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_StepPreviousButtonStyle)
        ]
        public Style StepPreviousButtonStyle {
            get {
                if (_stepPreviousButtonStyle == null) {
                    _stepPreviousButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_stepPreviousButtonStyle).TrackViewState();
                    }
                }
                return _stepPreviousButtonStyle;
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_StepPreviousButtonText),
        WebSysDescription(SR.Wizard_StepPreviousButtonText)
        ]
        public virtual String StepPreviousButtonText {
            get {
                string s = ViewState["StepPreviousButtonText"] as String;
                return s == null ? SR.GetString(SR.Wizard_Default_StepPreviousButtonText) : s;
            }
            set {
                ViewState["StepPreviousButtonText"] = value;
            }
        }


        [
        WebCategory("Appearance"),
        DefaultValue(ButtonType.Button),
        WebSysDescription(SR.Wizard_StepPreviousButtonType)
        ]
        public virtual ButtonType StepPreviousButtonType {
            get {
                object obj = ViewState["StepPreviousButtonType"];
                return (obj == null) ? ButtonType.Button : (ButtonType)obj;
            }
            set {
                ValidateButtonType(value);
                ViewState["StepPreviousButtonType"] = value;
            }
        }


        /// <devdoc>
        ///     Gets the style of the side bar buttons.
        /// </devdoc>
        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_SideBarButtonStyle)
        ]
        public Style SideBarButtonStyle {
            get {
                if (_sideBarButtonStyle == null) {
                    _sideBarButtonStyle = new Style();
                    if (IsTrackingViewState) {
                        ((IStateManager)_sideBarButtonStyle).TrackViewState();
                    }
                }
                return _sideBarButtonStyle;
            }
        }


        [
        WebCategory("Styles"),
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebSysDescription(SR.Wizard_SideBarStyle)
        ]
        public TableItemStyle SideBarStyle {
            get {
                if (_sideBarStyle == null) {
                    _sideBarStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_sideBarStyle).TrackViewState();
                }
                return _sideBarStyle;
            }
        }


        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(Wizard)),
        WebSysDescription(SR.Wizard_SideBarTemplate)
        ]
        public virtual ITemplate SideBarTemplate {
            get {
                return _sideBarTemplate;
            }
            set {
                _sideBarTemplate = value;
                _sideBarTableCell = null;
                RequiresControlsRecreation();
            }
        }


        [
        Localizable(true),
        WebCategory("Appearance"),
        WebSysDefaultValue(SR.Wizard_Default_SkipToContentText),
        WebSysDescription(SR.WebControl_SkipLinkText)
        ]
        public virtual String SkipLinkText {
            get {
                string s = SkipLinkTextInternal;
                return s == null ? SR.GetString(SR.Wizard_Default_SkipToContentText) : s;
            }
            set {
                ViewState["SkipLinkText"] = value;
            }
        }


        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(Wizard)),
        WebSysDescription(SR.Wizard_StartNavigationTemplate)
        ]
        public virtual ITemplate StartNavigationTemplate {
            get {
                return _startNavigationTemplate;
            }
            set {
                _startNavigationTemplate = value;
                RequiresControlsRecreation();
            }
        }


        [
        Browsable(false),
        DefaultValue(null),
        PersistenceMode(PersistenceMode.InnerProperty),
        TemplateContainer(typeof(Wizard)),
        WebSysDescription(SR.Wizard_StepNavigationTemplate)
        ]
        public virtual ITemplate StepNavigationTemplate {
            get {
                return _stepNavigationTemplate;
            }
            set {
                _stepNavigationTemplate = value;
                RequiresControlsRecreation();
            }
        }


        [
        DefaultValue(null),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        NotifyParentProperty(true),
        PersistenceMode(PersistenceMode.InnerProperty),
        WebCategory("Styles"),
        WebSysDescription(SR.Wizard_StepStyle)
        ]
        public TableItemStyle StepStyle {
            get {
                if (_stepStyle == null) {
                    _stepStyle = new TableItemStyle();
                    if (IsTrackingViewState)
                        ((IStateManager)_stepStyle).TrackViewState();
                }
                return _stepStyle;
            }
        }


        // 
        protected override HtmlTextWriterTag TagKey {
            get {
                return HtmlTextWriterTag.Table;
            }
        }


        [
        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
        Editor("System.Web.UI.Design.WebControls.WizardStepCollectionEditor," + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
        PersistenceMode(PersistenceMode.InnerProperty),
        Themeable(false),
        WebSysDescription(SR.Wizard_WizardSteps),
        ]
        public virtual WizardStepCollection WizardSteps {
            get {
                if (_wizardStepCollection == null) {
                    _wizardStepCollection = new WizardStepCollection(this);
                }

                return _wizardStepCollection;
            }
        }

        #endregion

        #region Public Events

        [
        WebCategory("Action"),
        WebSysDescription(SR.Wizard_ActiveStepChanged)
        ]
        public event EventHandler ActiveStepChanged {
            add {
                Events.AddHandler(_eventActiveStepChanged, value);
            }
            remove {
                Events.RemoveHandler(_eventActiveStepChanged, value);
            }
        }


        [
        WebCategory("Action"),
        WebSysDescription(SR.Wizard_CancelButtonClick)
        ]
        public event EventHandler CancelButtonClick {
            add {
                Events.AddHandler(_eventCancelButtonClick, value);
            }
            remove {

                Events.RemoveHandler(_eventCancelButtonClick, value);
            }
        }


        [
        WebCategory("Action"),
        WebSysDescription(SR.Wizard_FinishButtonClick)
        ]
        public event WizardNavigationEventHandler FinishButtonClick {
            add {
                Events.AddHandler(_eventFinishButtonClick, value);
            }
            remove {
                Events.RemoveHandler(_eventFinishButtonClick, value);
            }
        }


        [
        WebCategory("Action"),
        WebSysDescription(SR.Wizard_NextButtonClick)
        ]
        public event WizardNavigationEventHandler NextButtonClick {
            add {
                Events.AddHandler(_eventNextButtonClick, value);
            }
            remove {

                Events.RemoveHandler(_eventNextButtonClick, value);
            }
        }


        [
        WebCategory("Action"),
        WebSysDescription(SR.Wizard_PreviousButtonClick)
        ]
        public event WizardNavigationEventHandler PreviousButtonClick {
            add {
                Events.AddHandler(_eventPreviousButtonClick, value);
            }
            remove {
                Events.RemoveHandler(_eventPreviousButtonClick, value);
            }
        }


        [
        WebCategory("Action"),
        WebSysDescription(SR.Wizard_SideBarButtonClick)
        ]
        public virtual event WizardNavigationEventHandler SideBarButtonClick {
            add {
                Events.AddHandler(_eventSideBarButtonClick, value);
            }
            remove {
                Events.RemoveHandler(_eventSideBarButtonClick, value);
            }
        }

        #endregion

        #region Internal Properties

        internal Dictionary<WizardStepBase, BaseNavigationTemplateContainer> CustomNavigationContainers {
            get {
                if (_customNavigationContainers == null) {
                    _customNavigationContainers = new Dictionary<WizardStepBase, BaseNavigationTemplateContainer>();
                }
                return _customNavigationContainers;
            }
        }


        private ITemplate CustomNavigationTemplate {
            get {
                var templatedActiveStep = ActiveStep as TemplatedWizardStep;
                return templatedActiveStep == null ? null : templatedActiveStep.CustomNavigationTemplate;
            }
        }


        private Stack<int> History {
            get {
                if (_historyStack == null)
                    _historyStack = new Stack<int>();

                return _historyStack;
            }
        }

        private bool IsMacIE5 {
            get {
                if (!_isMacIE.HasValue && !DesignMode) {
                    HttpBrowserCapabilities browser = null;
                    if (Page != null) {
                        browser = Page.Request.Browser;
                    } else {
                        HttpContext context = HttpContext.Current;
                        // Context could be null if this control is created by the parser at designtime
                        if (context != null) {
                            browser = context.Request.Browser;
                        }
                    }

                    _isMacIE = (browser != null && browser.Type == "IE5" && browser.Platform == "MacPPC");
                }

                return _isMacIE.Value;
            }
        }


        internal MultiView MultiView {
            get {
                if (_multiView == null) {
                    _multiView = new MultiView();
                    _multiView.EnableTheming = true;
                    _multiView.ID = _multiViewID;
                    _multiView.ActiveViewChanged += new EventHandler(this.MultiViewActiveViewChanged);
                    _multiView.IgnoreBubbleEvents();
                }

                return _multiView;
            }
        }


        internal virtual bool ShowCustomNavigationTemplate {
            get {
                return CustomNavigationTemplate != null;
            }
        }


        internal bool ShouldRenderChildControl {
            get {
                if (!DesignMode) {
                    return true;
                }

                if (_designModeState == null) {
                    return true;
                }

                object o = _designModeState["ShouldRenderWizardSteps"];
                return o == null ? true : (bool)o;
            }
        }


        private IWizardSideBarListControl SideBarList {
            get { return _sideBarList; }
        }


        private bool SideBarEnabled {
            get {
                return _sideBarList != null && DisplaySideBar;
            }
        }


        internal string SkipLinkTextInternal {
            get {
                return ViewState["SkipLinkText"] as String;
            }
        }


        internal List<TemplatedWizardStep> TemplatedSteps {
            get {
                if (_templatedSteps == null) {
                    _templatedSteps = new List<TemplatedWizardStep>();
                }
                return _templatedSteps;
            }
        }

        #endregion

        private void MultiViewActiveViewChanged(object source, EventArgs e) {
            OnActiveStepChanged(this, EventArgs.Empty);
        }


        private void ApplyControlProperties() {
            _rendering.ApplyControlProperties();
        }


        internal BaseNavigationTemplateContainer CreateBaseNavigationTemplateContainer(string id) {
            return new BaseNavigationTemplateContainer(this) {
                ID = id
            };
        }


        /// <internalonly />
        protected internal override void CreateChildControls() {
            using (new WizardControlCollectionModifier(this)) {
                Controls.Clear();
                _customNavigationContainers = null;
            }

            if (LayoutTemplate == null) {
                _rendering = CreateTableRendering();
            }
            else {
                _rendering = CreateLayoutTemplateRendering();
            }

            CreateControlHierarchy();
            ClearChildViewState();
        }

        internal virtual TableWizardRendering CreateTableRendering() {
            return new TableWizardRendering(this);
        }

        internal virtual LayoutTemplateWizardRendering CreateLayoutTemplateRendering() {
            return new LayoutTemplateWizardRendering(this);
        }


        protected override ControlCollection CreateControlCollection() {
            return new WizardControlCollection(this);
        }


        protected virtual void CreateControlHierarchy() {
            _rendering.CreateControlHierarchy();
        }


        private void SetStepsAndDataBindSideBarList(IWizardSideBarListControl sideBarList) {
            if (sideBarList != null) {
                sideBarList.DataSource = WizardSteps;
                sideBarList.SelectedIndex = ActiveStepIndex;
                sideBarList.DataBind();
            }
        }


        internal virtual ITemplate CreateDefaultSideBarTemplate() {
            return new DefaultSideBarTemplate(this);
        }

        internal virtual ITemplate CreateDefaultDataListItemTemplate() {
            return new DataListItemTemplate(this);
        }


        /// <internalonly/>
        /// <devdoc>
        ///    <para>A protected method. Creates a table control style.</para>
        /// </devdoc>
        protected override Style CreateControlStyle() {
            TableStyle controlStyle = new TableStyle();

            // initialize defaults that are different from TableStyle
            controlStyle.CellSpacing = 0;
            controlStyle.CellPadding = 0;

            return controlStyle;
        }

        internal virtual void CreateCustomNavigationTemplates() {
            for (int i = 0; i < WizardSteps.Count; ++i) {
                TemplatedWizardStep step = WizardSteps[i] as TemplatedWizardStep;
                if (step != null) {
                    RegisterCustomNavigationContainers(step);
                }
            }
        }

        internal void RegisterCustomNavigationContainers(TemplatedWizardStep step) {
            // Instantiate the step's ContentTemplate
            InstantiateStepContentTemplate(step);

            if (!CustomNavigationContainers.ContainsKey(step)) {
                BaseNavigationTemplateContainer container = null;
                string id = GetCustomContainerID(WizardSteps.IndexOf(step));
                if (step.CustomNavigationTemplate != null) {
                    container = CreateBaseNavigationTemplateContainer(id);
                    step.CustomNavigationTemplate.InstantiateIn(container);
                    step.CustomNavigationTemplateContainer = container;
                    container.RegisterButtonCommandEvents();
                } else {
                    container = CreateBaseNavigationTemplateContainer(id);
                    container.RegisterButtonCommandEvents();
                }
                CustomNavigationContainers[step] = container;
            }
        }


        internal virtual void DataListItemDataBound(object sender, WizardSideBarListControlItemEventArgs e) {
            var dataListItem = e.Item;

            // Ignore the item that is not created from DataSource
            if (dataListItem.ItemType != ListItemType.Item &&
                dataListItem.ItemType != ListItemType.AlternatingItem &&
                dataListItem.ItemType != ListItemType.SelectedItem &&
                dataListItem.ItemType != ListItemType.EditItem) {
                return;
            }

            IButtonControl button = dataListItem.FindControl(SideBarButtonID) as IButtonControl;
            if (button == null) {
                if (!DesignMode) {
                    throw new InvalidOperationException(
                        SR.GetString(SR.Wizard_SideBar_Button_Not_Found, DataListID, SideBarButtonID));
                }

                return;
            }

            var ctrlButton = button as Button;
            if (ctrlButton != null) {
                // Use javascript submit to use the postdata instead, this is necessarily since the buttons could be recreated during DataBind(). Previously
                // registered buttons will lose their parents and events won't bubble up. VSWhidbey 120640.
                // For devices that do not support Javascript, fall back to sumit behavior VSWhidbey 154576
                ctrlButton.UseSubmitBehavior = false;
            }

            WebControl webCtrlButton = button as WebControl;
            if (webCtrlButton != null) {
                webCtrlButton.TabIndex = this.TabIndex;
            }

            int index = 0;

            // Render wizardstep title on the button control.
            WizardStepBase step = dataListItem.DataItem as WizardStepBase;
            if (step != null) {
                // Disable the button if it's a Complete step.
                if (GetStepType(step) == WizardStepType.Complete &&
                    webCtrlButton != null) {
                    webCtrlButton.Enabled = false;
                }

                // Need to render the sidebar tablecell.
                RegisterSideBarDataListForRender();

                // Use the step title if defined, otherwise use ID
                if (step.Title.Length > 0) {
                    button.Text = step.Title;
                } else {
                    button.Text = step.ID;
                }

                index = WizardSteps.IndexOf(step);

                button.CommandName = MoveToCommandName;
                button.CommandArgument = index.ToString(NumberFormatInfo.InvariantInfo);

                RegisterCommandEvents(button);
            }
        }

        internal void RegisterSideBarDataListForRender() {
            _renderSideBarDataList = true;
        }

        private void DataListItemCommand(object sender, CommandEventArgs e) {
            if (!MoveToCommandName.Equals(e.CommandName, StringComparison.OrdinalIgnoreCase)) {
                return;
            }

            int oldIndex = ActiveStepIndex;
            int newIndex = Int32.Parse((String)e.CommandArgument, CultureInfo.InvariantCulture);

            WizardNavigationEventArgs args = new WizardNavigationEventArgs(oldIndex, newIndex);

            // Never cancel the item command at design time.
            if (_commandSender != null && !DesignMode && Page != null && !Page.IsValid) {
                args.Cancel = true;
            }

            _activeStepIndexSet = false;
            OnSideBarButtonClick(args);

            if (!args.Cancel) {
                // Honor user's change if activeStepIndex is set explicitely;
                if (!_activeStepIndexSet) {
                    if (AllowNavigationToStep(newIndex)) {
                        ActiveStepIndex = newIndex;
                    }
                }
            } else {
                // revert active step if it's cancelled.
                ActiveStepIndex = oldIndex;
            }
        }

        internal static string GetCustomContainerID(int index) {
            return _customNavigationContainerIdPrefix + index;
        }


        /// <internalonly/>
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        protected override IDictionary GetDesignModeState() {
            IDictionary dictionary = base.GetDesignModeState();
            Debug.Assert(dictionary != null && DesignMode);

            _designModeState = dictionary;
            int oldIndex = ActiveStepIndex;

            // Set the activestepindex to 0 in designmode if it's -1.
            try {
                if (oldIndex == -1 && WizardSteps.Count > 0) {
                    ActiveStepIndex = 0;
                }

                RequiresControlsRecreation();
                EnsureChildControls();
                ApplyControlProperties();

                _rendering.SetDesignModeState(dictionary);

                if (ShowCustomNavigationTemplate) {
                    BaseNavigationTemplateContainer customContainer = CustomNavigationContainers[ActiveStep];
                    dictionary[CustomNextButtonID] = customContainer.NextButton;
                    dictionary[CustomPreviousButtonID] = customContainer.PreviousButton;
                    dictionary[CustomFinishButtonID] = customContainer.FinishButton;
                    dictionary[CancelButtonID] = customContainer.CancelButton;
                    dictionary[_customNavigationControls] = customContainer.Controls;
                }

                // VSWhidbey 456506. Reset the ItemTemplate so it can be persisted correctly 
                // based on current SideBarButtonStyle
                if (SideBarTemplate == null && _sideBarList != null) {
                    _sideBarList.ItemTemplate = CreateDefaultDataListItemTemplate();
                }

                dictionary[DataListID] = _sideBarList;
                dictionary[_templatedStepsID] = TemplatedSteps;
            } finally {
                ActiveStepIndex = oldIndex;
            }

            return dictionary;
        }


        public ICollection GetHistory() {
            ArrayList list = new ArrayList();
            foreach (int index in History) {
                list.Add(WizardSteps[index]);
            }
            return list;
        }

        internal int GetPreviousStepIndex(bool popStack) {
            int previousIndex = -1;
            int index = ActiveStepIndex;

            if (_historyStack == null || _historyStack.Count == 0) {
                return previousIndex;
            }

            if (popStack) {
                previousIndex = _historyStack.Pop();

                // Ignore the current step, the current step index is already in the historyStack.
                if (previousIndex == index && _historyStack.Count > 0) {
                    previousIndex = _historyStack.Pop();
                }
            } else {
                previousIndex = _historyStack.Peek();

                // Ignore the current step, the current step index is already in the historyStack.
                if (previousIndex == index && _historyStack.Count > 1) {
                    int originalIndex = _historyStack.Pop();
                    previousIndex = _historyStack.Peek();
                    _historyStack.Push(originalIndex);
                }
            }

            // Return -1 if the current step is same as previous step
            if (previousIndex == index) {
                return -1;
            }

            return previousIndex;
        }

        private WizardStepType GetStepType(int index) {
            Debug.Assert(index > -1 && index < WizardSteps.Count);
            WizardStepBase step = WizardSteps[index] as WizardStepBase;
            return GetStepType(step, index);
        }

        private WizardStepType GetStepType(WizardStepBase step) {
            int index = WizardSteps.IndexOf(step);
            return GetStepType(step, index);
        }


        public WizardStepType GetStepType(WizardStepBase wizardStep, int index) {
            if (wizardStep.StepType == WizardStepType.Auto) {

                // If it's the only step or a Complete step is after current step, then make it Finish step
                if (WizardSteps.Count == 1 ||
                    (index < WizardSteps.Count - 1 &&
                    WizardSteps[index + 1].StepType == WizardStepType.Complete)) {
                    return WizardStepType.Finish;
                }

                // First one is the start step
                if (index == 0) {
                    return WizardStepType.Start;
                }

                // Last one is the finish step
                if (index == WizardSteps.Count - 1) {
                    return WizardStepType.Finish;
                }

                return WizardStepType.Step;
            }

            return wizardStep.StepType;
        }

        /// <devdoc>
        ///     Instantiates all the content templates for each TemplatedWizardStep
        /// </devdoc>
        internal virtual void InstantiateStepContentTemplates() {
            TemplatedSteps.ForEach(step => InstantiateStepContentTemplate(step));
        }

        internal void InstantiateStepContentTemplate(TemplatedWizardStep step) {
            step.Controls.Clear();

            BaseContentTemplateContainer container = new BaseContentTemplateContainer(this, true);
            ITemplate contentTemplate = step.ContentTemplate;

            if (contentTemplate != null) {
                container.SetEnableTheming();
                contentTemplate.InstantiateIn(container.InnerCell);
            }

            step.ContentTemplateContainer = container;
            step.Controls.Add(container);
        }

        /// <devdoc>
        /// <para>Loads the control state.</para>
        /// </devdoc>
        protected internal override void LoadControlState(object state) {
            Triplet t = state as Triplet;
            if (t != null) {
                base.LoadControlState(t.First);

                Array collection = t.Second as Array;
                if (collection != null) {
                    Array.Reverse(collection);
                    _historyStack = new Stack<int>(collection.Cast<int>());
                }

                ActiveStepIndex = (int)t.Third;
            }
        }


        protected override void LoadViewState(object savedState) {
            if (savedState == null) {
                base.LoadViewState(null);
            } else {
                object[] myState = (object[])savedState;
                if (myState.Length != _viewStateArrayLength) {
                    throw new ArgumentException(SR.GetString(SR.ViewState_InvalidViewState));
                }

                base.LoadViewState(myState[0]);

                if (myState[1] != null)
                    ((IStateManager)NavigationButtonStyle).LoadViewState(myState[1]);

                if (myState[2] != null)
                    ((IStateManager)SideBarButtonStyle).LoadViewState(myState[2]);

                if (myState[3] != null)
                    ((IStateManager)HeaderStyle).LoadViewState(myState[3]);

                if (myState[4] != null)
                    ((IStateManager)NavigationStyle).LoadViewState(myState[4]);

                if (myState[5] != null)
                    ((IStateManager)SideBarStyle).LoadViewState(myState[5]);

                if (myState[6] != null)
                    ((IStateManager)StepStyle).LoadViewState(myState[6]);

                if (myState[7] != null)
                    ((IStateManager)StartNextButtonStyle).LoadViewState(myState[7]);

                if (myState[8] != null)
                    ((IStateManager)StepNextButtonStyle).LoadViewState(myState[8]);

                if (myState[9] != null)
                    ((IStateManager)StepPreviousButtonStyle).LoadViewState(myState[9]);

                if (myState[10] != null)
                    ((IStateManager)FinishPreviousButtonStyle).LoadViewState(myState[10]);

                if (myState[11] != null)
                    ((IStateManager)FinishCompleteButtonStyle).LoadViewState(myState[11]);

                if (myState[12] != null)
                    ((IStateManager)CancelButtonStyle).LoadViewState(myState[12]);

                if (myState[13] != null)
                    ((IStateManager)ControlStyle).LoadViewState(myState[13]);

                if (myState[14] != null)
                    DisplaySideBar = (bool)myState[14];
            }
        }


        public void MoveTo(WizardStepBase wizardStep) {
            if (wizardStep == null)
                throw new ArgumentNullException("wizardStep");

            int index = WizardSteps.IndexOf(wizardStep);
            if (index == -1) {
                throw new ArgumentException(SR.GetString(SR.Wizard_Step_Not_In_Wizard));
            }

            ActiveStepIndex = index;
        }


        protected virtual void OnActiveStepChanged(object source, EventArgs e) {
            EventHandler handler = (EventHandler)Events[_eventActiveStepChanged];
            if (handler != null) handler(this, e);
        }


        protected override bool OnBubbleEvent(object source, EventArgs e) {
            bool handled = false;

            CommandEventArgs ce = e as CommandEventArgs;
            if (ce != null) {
                if (String.Equals(CancelCommandName, ce.CommandName, StringComparison.OrdinalIgnoreCase)) {
                    OnCancelButtonClick(EventArgs.Empty);
                    return true;
                }

                int oldIndex = ActiveStepIndex;
                int newIndex = oldIndex;

                // Check if we need to validate the bubble commands VSWhidbey 312445
                bool verifyEvent = true;

                WizardStepType stepType = WizardStepType.Auto;
                WizardStepBase step = WizardSteps[oldIndex];

                // Don't validate commands if it's a templated wizard step
                if (step is TemplatedWizardStep) {
                    verifyEvent = false;
                } else {
                    stepType = GetStepType(step);
                }

                WizardNavigationEventArgs args = new WizardNavigationEventArgs(oldIndex, newIndex);

                // Do not navigate away from current view if view is not valid.
                if (_commandSender != null && Page != null && !Page.IsValid) {
                    args.Cancel = true;
                }

                bool previousButtonCommand = false;
                _activeStepIndexSet = false;

                if (String.Equals(MoveNextCommandName, ce.CommandName, StringComparison.OrdinalIgnoreCase)) {
                    if (verifyEvent) {
                        if (stepType != WizardStepType.Start && stepType != WizardStepType.Step) {
                            throw new InvalidOperationException(SR.GetString(SR.Wizard_InvalidBubbleEvent, MoveNextCommandName));
                        }
                    }

                    if (oldIndex < WizardSteps.Count - 1) {
                        args.SetNextStepIndex(oldIndex + 1);
                    }

                    OnNextButtonClick(args);
                    handled = true;
                } else if (String.Equals(MovePreviousCommandName, ce.CommandName, StringComparison.OrdinalIgnoreCase)) {
                    if (verifyEvent) {
                        if (stepType != WizardStepType.Step && stepType != WizardStepType.Finish) {
                            throw new InvalidOperationException(SR.GetString(SR.Wizard_InvalidBubbleEvent, MovePreviousCommandName));
                        }
                    }

                    previousButtonCommand = true;

                    int previousIndex = GetPreviousStepIndex(false);
                    if (previousIndex != -1) {
                        args.SetNextStepIndex(previousIndex);
                    }

                    OnPreviousButtonClick(args);
                    handled = true;
                } else if (String.Equals(MoveCompleteCommandName, ce.CommandName, StringComparison.OrdinalIgnoreCase)) {
                    if (verifyEvent) {
                        if (stepType != WizardStepType.Finish) {
                            throw new InvalidOperationException(SR.GetString(SR.Wizard_InvalidBubbleEvent, MoveCompleteCommandName));
                        }
                    }

                    if (oldIndex < WizardSteps.Count - 1) {
                        args.SetNextStepIndex(oldIndex + 1);
                    }

                    OnFinishButtonClick(args);
                    handled = true;
                } else if (String.Equals(MoveToCommandName, ce.CommandName, StringComparison.OrdinalIgnoreCase)) {
                    newIndex = Int32.Parse((String)ce.CommandArgument, CultureInfo.InvariantCulture);
                    args.SetNextStepIndex(newIndex);

                    handled = true;
                }

                if (handled) {
                    if (!args.Cancel) {
                        // Honor user's change if activeStepIndex is set explicitely;
                        if (!_activeStepIndexSet) {
                            // Make sure the next step is valid to navigate to
                            if (AllowNavigationToStep(args.NextStepIndex)) {
                                if (previousButtonCommand) {
                                    GetPreviousStepIndex(true);
                                }

                                ActiveStepIndex = args.NextStepIndex;
                            }
                        }
                    } else {
                        // revert active step if it's cancelled.
                        ActiveStepIndex = oldIndex;
                    }
                }
            }

            return handled;
        }

        internal void OnWizardStepsChanged() {
            SetStepsAndDataBindSideBarList(_sideBarList);
        }


        protected virtual bool AllowNavigationToStep(int index) {
            if (_historyStack != null && _historyStack.Contains(index)) {
                return WizardSteps[index].AllowReturn;
            }
            return true;
        }


        protected virtual void OnCancelButtonClick(EventArgs e) {
            EventHandler handler = (EventHandler)Events[_eventCancelButtonClick];
            if (handler != null) {
                handler(this, e);
            }

            string cancelDestinationUrl = CancelDestinationPageUrl;
            if (!String.IsNullOrEmpty(cancelDestinationUrl)) {
                Page.Response.Redirect(ResolveClientUrl(cancelDestinationUrl), false);
            }
        }


        private void OnCommand(object sender, CommandEventArgs e) {
            Debug.Assert(_commandSender == null);
            _commandSender = sender as IButtonControl;
        }


        protected virtual void OnFinishButtonClick(WizardNavigationEventArgs e) {
            WizardNavigationEventHandler handler = (WizardNavigationEventHandler)Events[_eventFinishButtonClick];
            if (handler != null) handler(this, e);

            string finishPageUrl = FinishDestinationPageUrl;
            if (!String.IsNullOrEmpty(finishPageUrl)) {
                // Microsoft suggested that we should not terminate execution of current page, to give
                // page a chance to cleanup its resources.  This may be less performant though.
                // Microsoft suggested that we need to call ResolveClientUrl before redirecting.
                // Example is this control inside user control, want redirect relative to user control dir.
                Page.Response.Redirect(ResolveClientUrl(finishPageUrl), false);
            }
        }


        protected internal override void OnInit(EventArgs e) {
            base.OnInit(e);

            // Always set the current step to the first step if not specified.
            if (ActiveStepIndex == -1 && WizardSteps.Count > 0 && !DesignMode) {
                ActiveStepIndex = 0;
            }

            // Add default control layout during OnInit to track WizardStep viewstate properly.
            EnsureChildControls();

            if (Page != null) {
                Page.RegisterRequiresControlState(this);
            }
        }


        protected virtual void OnNextButtonClick(WizardNavigationEventArgs e) {
            WizardNavigationEventHandler handler = (WizardNavigationEventHandler)Events[_eventNextButtonClick];
            if (handler != null) handler(this, e);
        }


        protected virtual void OnPreviousButtonClick(WizardNavigationEventArgs e) {
            WizardNavigationEventHandler handler = (WizardNavigationEventHandler)Events[_eventPreviousButtonClick];
            if (handler != null) handler(this, e);
        }


        protected virtual void OnSideBarButtonClick(WizardNavigationEventArgs e) {
            WizardNavigationEventHandler handler = (WizardNavigationEventHandler)Events[_eventSideBarButtonClick];
            if (handler != null) handler(this, e);
        }

        internal void RequiresControlsRecreation() {
            if (ChildControlsCreated) {
                using (new WizardControlCollectionModifier(this)) {
                    base.ChildControlsCreated = false;
                }
                _rendering = null;
            }
        }


        protected internal void RegisterCommandEvents(IButtonControl button) {
            if (button != null && button.CausesValidation) {
                button.Command += new CommandEventHandler(this.OnCommand);
            }
        }


        protected internal override void Render(HtmlTextWriter writer) {

            // Make sure we're in runat=server form.
            if (Page != null) {
                Page.VerifyRenderingInServerForm(this);
            }

            EnsureChildControls();
            ApplyControlProperties();

            // Nothing to do if the Wizard is empty;
            if (ActiveStepIndex == -1 || WizardSteps.Count == 0) {
                return;
            }

            RenderContents(writer);
        }

        protected internal override object SaveControlState() {
            int activeStepIndex = ActiveStepIndex;

            // Save the ActiveStepIndex here so steps dynamically added
            // before or during OnPagePreRenderComplete will be tracked
            // properly. See VSWhidbey 395312
            if (_historyStack == null || _historyStack.Count == 0 ||
                _historyStack.Peek() != activeStepIndex) {
                // Remember the active step.
                History.Push(ActiveStepIndex);
            }

            object obj = base.SaveControlState();

            bool containsHistory = _historyStack != null && _historyStack.Count > 0;

            if (obj != null || containsHistory || activeStepIndex != -1) {
                object array = containsHistory ? _historyStack.ToArray() : null;
                return new Triplet(obj, array, activeStepIndex);
            }

            return null;
        }


        protected override object SaveViewState() {
            object[] myState = new object[_viewStateArrayLength];

            Debug.Assert(_viewStateArrayLength == 15, "Forgot to change array length when adding new item to view state?");

            myState[0] = base.SaveViewState();
            myState[1] = (_navigationButtonStyle != null) ? ((IStateManager)_navigationButtonStyle).SaveViewState() : null;
            myState[2] = (_sideBarButtonStyle != null) ? ((IStateManager)_sideBarButtonStyle).SaveViewState() : null;
            myState[3] = (_headerStyle != null) ? ((IStateManager)_headerStyle).SaveViewState() : null;
            myState[4] = (_navigationStyle != null) ? ((IStateManager)_navigationStyle).SaveViewState() : null;
            myState[5] = (_sideBarStyle != null) ? ((IStateManager)_sideBarStyle).SaveViewState() : null;
            myState[6] = (_stepStyle != null) ? ((IStateManager)_stepStyle).SaveViewState() : null;
            myState[7] = (_startNextButtonStyle != null) ? ((IStateManager)_startNextButtonStyle).SaveViewState() : null;
            myState[8] = (_stepNextButtonStyle != null) ? ((IStateManager)_stepNextButtonStyle).SaveViewState() : null;
            myState[9] = (_stepPreviousButtonStyle != null) ? ((IStateManager)_stepPreviousButtonStyle).SaveViewState() : null;
            myState[10] = (_finishPreviousButtonStyle != null) ? ((IStateManager)_finishPreviousButtonStyle).SaveViewState() : null;
            myState[11] = (_finishCompleteButtonStyle != null) ? ((IStateManager)_finishCompleteButtonStyle).SaveViewState() : null;
            myState[12] = (_cancelButtonStyle != null) ? ((IStateManager)_cancelButtonStyle).SaveViewState() : null;
            myState[13] = ControlStyleCreated ? ((IStateManager)ControlStyle).SaveViewState() : null;
            if (DisplaySideBar != _displaySideBarDefault) {
                myState[14] = DisplaySideBar;
            }

            for (int i = 0; i < _viewStateArrayLength; i++) {
                if (myState[i] != null) {
                    return myState;
                }
            }

            // More performant to return null than an array of null values
            return null;
        }


        private void SetCancelButtonVisibility(BaseNavigationTemplateContainer container) {
            // Make the parent TD invisible if possible.
            Control c = container.CancelButton as Control;

            if (c != null) {
                Control parent = c.Parent;
                if (parent != null) {
                    Debug.Assert(parent is TableCell);
                    parent.Visible = DisplayCancelButton;
                }

                c.Visible = DisplayCancelButton;
            }
        }


        protected override void TrackViewState() {
            base.TrackViewState();

            if (_navigationButtonStyle != null)
                ((IStateManager)_navigationButtonStyle).TrackViewState();

            if (_sideBarButtonStyle != null)
                ((IStateManager)_sideBarButtonStyle).TrackViewState();

            if (_headerStyle != null)
                ((IStateManager)_headerStyle).TrackViewState();

            if (_navigationStyle != null)
                ((IStateManager)_navigationStyle).TrackViewState();

            if (_sideBarStyle != null)
                ((IStateManager)_sideBarStyle).TrackViewState();

            if (_stepStyle != null)
                ((IStateManager)_stepStyle).TrackViewState();

            if (_startNextButtonStyle != null)
                ((IStateManager)_startNextButtonStyle).TrackViewState();

            if (_stepPreviousButtonStyle != null)
                ((IStateManager)_stepPreviousButtonStyle).TrackViewState();

            if (_stepNextButtonStyle != null)
                ((IStateManager)_stepNextButtonStyle).TrackViewState();

            if (_finishPreviousButtonStyle != null)
                ((IStateManager)_finishPreviousButtonStyle).TrackViewState();

            if (_finishCompleteButtonStyle != null)
                ((IStateManager)_finishCompleteButtonStyle).TrackViewState();

            if (_cancelButtonStyle != null)
                ((IStateManager)_cancelButtonStyle).TrackViewState();

            if (ControlStyleCreated) {
                ((IStateManager)ControlStyle).TrackViewState();
            }
        }

        private static void ValidateButtonType(ButtonType value) {
            if (value < ButtonType.Button || value > ButtonType.Link) {
                throw new ArgumentOutOfRangeException("value");
            }
        }

        #region Rendering Abstractions

        internal abstract class WizardRenderingBase {
            private const string _startNavigationTemplateContainerID = "StartNavigationTemplateContainerID";
            private const string _stepNavigationTemplateContainerID = "StepNavigationTemplateContainerID";
            private const string _finishNavigationTemplateContainerID = "FinishNavigationTemplateContainerID";

            private NavigationTemplate _defaultStartNavigationTemplate;
            private NavigationTemplate _defaultStepNavigationTemplate;
            private NavigationTemplate _defaultFinishNavigationTemplate;

            protected BaseNavigationTemplateContainer _finishNavigationTemplateContainer;
            protected BaseNavigationTemplateContainer _startNavigationTemplateContainer;
            protected BaseNavigationTemplateContainer _stepNavigationTemplateContainer;

            protected Wizard Owner { get; private set; }

            protected WizardRenderingBase(Wizard wizard) {
                Owner = wizard;
            }

            public abstract void ApplyControlProperties();

            public abstract void CreateControlHierarchy();

            public virtual void SetDesignModeState(IDictionary dictionary) {
                if (_startNavigationTemplateContainer != null) {
                    dictionary[StartNextButtonID] = _startNavigationTemplateContainer.NextButton;
                    dictionary[CancelButtonID] = _startNavigationTemplateContainer.CancelButton;
                }

                if (_stepNavigationTemplateContainer != null) {
                    dictionary[StepNextButtonID] = _stepNavigationTemplateContainer.NextButton;
                    dictionary[StepPreviousButtonID] = _stepNavigationTemplateContainer.PreviousButton;
                    dictionary[CancelButtonID] = _stepNavigationTemplateContainer.CancelButton;
                }

                if (_finishNavigationTemplateContainer != null) {
                    dictionary[FinishPreviousButtonID] = _finishNavigationTemplateContainer.PreviousButton;
                    dictionary[FinishButtonID] = _finishNavigationTemplateContainer.FinishButton;
                    dictionary[CancelButtonID] = _finishNavigationTemplateContainer.CancelButton;
                }
            }


            protected void ApplyControlProperties_Sidebar() {
                if (Owner.SideBarEnabled) {
                    Owner.SetStepsAndDataBindSideBarList(Owner._sideBarList);

                    // Only apply the styles to the sidebar or sidebar buttons if custom template is not used.
                    if (Owner.SideBarTemplate == null) {
                        foreach (Control item in Owner._sideBarList.Items) {
                            WebControl button = item.FindControl(SideBarButtonID) as WebControl;
                            if (button != null) {
                                button.MergeStyle(Owner._sideBarButtonStyle);
                            }
                        }
                    }
                }
            }


            protected void ApplyNavigationTemplateProperties() {
                // Do not apply any template properties if the containers are null
                // This happens when GetDesignModeState is called before child controls are created.
                if (_finishNavigationTemplateContainer == null ||
                    _startNavigationTemplateContainer == null ||
                    _stepNavigationTemplateContainer == null) {
                    return;
                }

                WizardStepType renderType = WizardStepType.Start;
                // Set the active templates based on ActiveStep
                // Make sure the activestepindex is valid. // VSWhidbey 376438
                if (Owner.ActiveStepIndex >= Owner.WizardSteps.Count || Owner.ActiveStepIndex < 0) {
                    return;
                }

                renderType = SetActiveTemplates();

                bool requiresFinishPreviousButton =
                    renderType != WizardStepType.Finish || Owner.ActiveStepIndex != 0 || Owner.ActiveStep.StepType != WizardStepType.Auto;

                ApplyDefaultStartNavigationTemplateProperties();

                bool showPrevious = true;
                int prevStepIndex = Owner.GetPreviousStepIndex(false);
                if (prevStepIndex >= 0) {
                    showPrevious = Owner.WizardSteps[prevStepIndex].AllowReturn;
                }

                ApplyDefaultFinishNavigationTemplateProperties(showPrevious);
                ApplyDefaultStepNavigationTemplateProperties(showPrevious);

                // if the first step using auto type is assigned to a finish step, do not render the previous button's container.
                if (!requiresFinishPreviousButton) {
                    Control ctrl = _finishNavigationTemplateContainer.PreviousButton as Control;
                    if (ctrl != null) {
                        if (Owner.FinishNavigationTemplate == null) {
                            ctrl.Parent.Visible = false;
                        } else {
                            ctrl.Visible = false;
                        }
                    }
                }
            }

            private void ApplyDefaultStepNavigationTemplateProperties(bool previousImageButtonVisible) {
                // Only apply properties to the default template (if a custom template has not been specified)
                if (Owner.StepNavigationTemplate != null) {
                    return;
                }

                var navContainer = _stepNavigationTemplateContainer;
                NavigationTemplate defaultTemplate = _defaultStepNavigationTemplate;

                if (Owner.DesignMode) {
                    defaultTemplate.ResetButtonsVisibility();
                }

                navContainer.PreviousButton = defaultTemplate.FirstButton;
                ((Control)navContainer.PreviousButton).Visible = true;

                navContainer.NextButton = defaultTemplate.SecondButton;
                ((Control)navContainer.NextButton).Visible = true;

                navContainer.CancelButton = defaultTemplate.CancelButton;

                ApplyButtonProperties(navContainer.NextButton, Owner.StepNextButtonText, Owner.StepNextButtonImageUrl);

                ApplyButtonProperties(navContainer.PreviousButton, Owner.StepPreviousButtonText, Owner.StepPreviousButtonImageUrl, previousImageButtonVisible);

                ApplyButtonProperties(navContainer.CancelButton, Owner.CancelButtonText, Owner.CancelButtonImageUrl);

                int previousStepIndex = Owner.GetPreviousStepIndex(false);
                if (previousStepIndex != -1 && !Owner.WizardSteps[previousStepIndex].AllowReturn) {
                    ((Control)navContainer.PreviousButton).Visible = false;
                }

                Owner.SetCancelButtonVisibility(navContainer);
                navContainer.ApplyButtonStyle(Owner.FinishCompleteButtonStyle, Owner.StepPreviousButtonStyle, Owner.StepNextButtonStyle, Owner.CancelButtonStyle);
            }

            private void ApplyDefaultFinishNavigationTemplateProperties(bool previousImageButtonVisible) {
                // Only apply properties to the default template (if a custom template has not been specified)
                if (Owner.FinishNavigationTemplate != null) {
                    return;
                }

                var finishContainer = _finishNavigationTemplateContainer;
                NavigationTemplate defaultTemplate = _defaultFinishNavigationTemplate;

                if (Owner.DesignMode) {
                    defaultTemplate.ResetButtonsVisibility();
                }

                finishContainer.PreviousButton = defaultTemplate.FirstButton;
                ((Control)finishContainer.PreviousButton).Visible = true;

                finishContainer.FinishButton = defaultTemplate.SecondButton;
                ((Control)finishContainer.FinishButton).Visible = true;

                finishContainer.CancelButton = defaultTemplate.CancelButton;

                finishContainer.FinishButton.CommandName = MoveCompleteCommandName;

                ApplyButtonProperties(finishContainer.FinishButton, Owner.FinishCompleteButtonText, Owner.FinishCompleteButtonImageUrl);

                ApplyButtonProperties(finishContainer.PreviousButton, Owner.FinishPreviousButtonText, Owner.FinishPreviousButtonImageUrl, previousImageButtonVisible);

                ApplyButtonProperties(finishContainer.CancelButton, Owner.CancelButtonText, Owner.CancelButtonImageUrl);

                int previousStepIndex = Owner.GetPreviousStepIndex(false);
                if (previousStepIndex != -1 && !Owner.WizardSteps[previousStepIndex].AllowReturn) {
                    ((Control)finishContainer.PreviousButton).Visible = false;
                }

                Owner.SetCancelButtonVisibility(finishContainer);
                finishContainer.ApplyButtonStyle(Owner.FinishCompleteButtonStyle, Owner.FinishPreviousButtonStyle, Owner.StepNextButtonStyle, Owner.CancelButtonStyle);
            }

            private void ApplyDefaultStartNavigationTemplateProperties() {
                // Only apply properties to the default template (if a custom template has not been specified)
                if (Owner.StartNavigationTemplate != null) {
                    return;
                }

                var startContainer = _startNavigationTemplateContainer;
                NavigationTemplate defaultStartTemplate = _defaultStartNavigationTemplate;

                if (Owner.DesignMode) {
                    defaultStartTemplate.ResetButtonsVisibility();
                }

                startContainer.NextButton = defaultStartTemplate.SecondButton;
                ((Control)startContainer.NextButton).Visible = true;

                startContainer.CancelButton = defaultStartTemplate.CancelButton;

                ApplyButtonProperties(startContainer.NextButton, Owner.StartNextButtonText, Owner.StartNextButtonImageUrl);

                ApplyButtonProperties(startContainer.CancelButton, Owner.CancelButtonText, Owner.CancelButtonImageUrl);

                Owner.SetCancelButtonVisibility(startContainer);
                startContainer.ApplyButtonStyle(Owner.FinishCompleteButtonStyle, Owner.StepPreviousButtonStyle, Owner.StartNextButtonStyle, Owner.CancelButtonStyle);
            }


            protected virtual WizardStepType SetActiveTemplates() {
                WizardStepType type = Owner.GetStepType(Owner.ActiveStepIndex);

                _startNavigationTemplateContainer.Visible = (type == WizardStepType.Start);
                _stepNavigationTemplateContainer.Visible = (type == WizardStepType.Step);
                _finishNavigationTemplateContainer.Visible = (type == WizardStepType.Finish);

                // Do not render header or sidebarlist in complete steps;
                if (type == WizardStepType.Complete) {
                    OnlyShowCompleteStep();
                }

                return type;
            }

            private static void ApplyButtonProperties(IButtonControl button, string text, string imageUrl) {
                ApplyButtonProperties(button, text, imageUrl, true);
            }

            private static void ApplyButtonProperties(IButtonControl button, string text, string imageUrl, bool imageButtonVisible) {
                if (button == null) {
                    return;
                }

                ImageButton imageButton = button as ImageButton;
                if (imageButton != null) {
                    imageButton.ImageUrl = imageUrl;
                    imageButton.AlternateText = text;
                    imageButton.Visible = imageButtonVisible;
                } else {
                    button.Text = text;
                }
            }

            public abstract void OnlyShowCompleteStep();

            protected void ApplyCustomNavigationTemplateProperties() {
                // Make all custom navigation containers invisible
                foreach (BaseNavigationTemplateContainer c in Owner.CustomNavigationContainers.Values) {
                    c.Visible = false;
                }

                // If we are going to show a custom navigation template, make that one visible
                if (Owner.ShowCustomNavigationTemplate) {
                    BaseNavigationTemplateContainer container = Owner._customNavigationContainers[Owner.ActiveStep];
                    container.Visible = true;
                    _startNavigationTemplateContainer.Visible = false;
                    _stepNavigationTemplateContainer.Visible = false;
                    _finishNavigationTemplateContainer.Visible = false;
                }
            }


            protected void CreateControlHierarchy_CleanUpOldSideBarList(IWizardSideBarListControl sideBarList) {
                // Remove obsolete events from sideBarDataList
                if (sideBarList != null) {
                    sideBarList.ItemCommand -= new CommandEventHandler(Owner.DataListItemCommand);
                    sideBarList.ItemDataBound -= new EventHandler<WizardSideBarListControlItemEventArgs>(Owner.DataListItemDataBound);
                }
            }

            protected IWizardSideBarListControl CreateControlHierarchy_SetUpSideBarList(Control sideBarContainer) {
                var sideBarList = sideBarContainer.FindControl(DataListID) as IWizardSideBarListControl;
                if (sideBarList != null) {
                    sideBarList.ItemCommand += new CommandEventHandler(Owner.DataListItemCommand);
                    sideBarList.ItemDataBound += new EventHandler<WizardSideBarListControlItemEventArgs>(Owner.DataListItemDataBound);
                    if (Owner.DesignMode) {
                        // This line is necessary for ListView to databind correctly to the list of steps when
                        // viewing the control on the design surface. ListView will not databind automatically when
                        // it is not a top-level control (as is the case here) unless the flag has a value.
                        ((IControlDesignerAccessor)sideBarList).GetDesignModeState()["EnableDesignTimeDataBinding"] = true;
                    }
                    Owner.SetStepsAndDataBindSideBarList(sideBarList);
                } else {
                    // Do not throw at designmode otherwise template will not be persisted correctly.
                    if (!Owner.DesignMode) {
                        throw new InvalidOperationException(
                            SR.GetString(SR.Wizard_DataList_Not_Found, DataListID));
                    }
                }

                return sideBarList;
            }


            // Helper method to create navigation templates.
            protected void CreateNavigationControlHierarchy(Control container) {
                container.Controls.Clear();
                Owner.CustomNavigationContainers.Clear();
                Owner.CreateCustomNavigationTemplates();

                foreach (BaseNavigationTemplateContainer c in Owner.CustomNavigationContainers.Values) {
                    container.Controls.Add(c);
                }

                CreateStartNavigationTemplate(container);
                CreateFinishNavigationTemplate(container);
                CreateStepNavigationTemplate(container);
            }


            private void CreateStartNavigationTemplate(Control container) {
                // Start navigation template
                ITemplate startNavigationTemplate = Owner.StartNavigationTemplate;
                _startNavigationTemplateContainer = new StartNavigationTemplateContainer(Owner);
                _startNavigationTemplateContainer.ID = _startNavigationTemplateContainerID;

                // Use the default template
                if (startNavigationTemplate == null) {
                    _startNavigationTemplateContainer.EnableViewState = false;
                    _defaultStartNavigationTemplate = NavigationTemplate.GetDefaultStartNavigationTemplate(Owner);
                    startNavigationTemplate = _defaultStartNavigationTemplate;
                } else {
                    // Custom template is used here.
                    _startNavigationTemplateContainer.SetEnableTheming();
                }

                startNavigationTemplate.InstantiateIn(_startNavigationTemplateContainer);
                container.Controls.Add(_startNavigationTemplateContainer);
            }

            private void CreateStepNavigationTemplate(Control container) {
                // step navigation template
                ITemplate stepNavigationTemplate = Owner.StepNavigationTemplate;
                _stepNavigationTemplateContainer = new StepNavigationTemplateContainer(Owner);
                _stepNavigationTemplateContainer.ID = _stepNavigationTemplateContainerID;

                if (stepNavigationTemplate == null) {
                    _stepNavigationTemplateContainer.EnableViewState = false;
                    _defaultStepNavigationTemplate = NavigationTemplate.GetDefaultStepNavigationTemplate(Owner);
                    stepNavigationTemplate = _defaultStepNavigationTemplate;
                } else {
                    _stepNavigationTemplateContainer.SetEnableTheming();
                }

                stepNavigationTemplate.InstantiateIn(_stepNavigationTemplateContainer);
                container.Controls.Add(_stepNavigationTemplateContainer);
            }

            private void CreateFinishNavigationTemplate(Control container) {
                // finish navigation template
                ITemplate finishNavigationTemplate = Owner.FinishNavigationTemplate;
                _finishNavigationTemplateContainer = new FinishNavigationTemplateContainer(Owner);
                _finishNavigationTemplateContainer.ID = _finishNavigationTemplateContainerID;

                if (finishNavigationTemplate == null) {
                    _finishNavigationTemplateContainer.EnableViewState = false;
                    _defaultFinishNavigationTemplate = NavigationTemplate.GetDefaultFinishNavigationTemplate(Owner);
                    finishNavigationTemplate = _defaultFinishNavigationTemplate;
                } else {
                    _finishNavigationTemplateContainer.SetEnableTheming();
                }

                finishNavigationTemplate.InstantiateIn(_finishNavigationTemplateContainer);
                container.Controls.Add(_finishNavigationTemplateContainer);
            }
        }

        internal class LayoutTemplateWizardRendering : WizardRenderingBase {

            private Literal _headerLiteral;
            private WizardContainer _layoutContainer;

            public LayoutTemplateWizardRendering(Wizard wizard)
                : base(wizard) {
            }

            public override void ApplyControlProperties() {
                ApplyControlProperties_Header();
                ApplyControlProperties_Sidebar();
                // nothing interesting to apply to the wizard steps
                ApplyControlProperties_Navigation();
            }

            private void ApplyControlProperties_Navigation() {
                ApplyNavigationTemplateProperties();
                ApplyCustomNavigationTemplateProperties();
            }

            private void ApplyControlProperties_Header() {
                if (Owner.HeaderTemplate != null) {
                    // nothing to apply if there is a header template
                    return;
                }

                if (_headerLiteral != null) {
                    // not necessary to set the literal to not visible if the text is empty because a
                    // literal with empty text does not render anything
                    _headerLiteral.Text = Owner.HeaderText;
                } else if (!String.IsNullOrEmpty(Owner.HeaderText)) {
                    // only throw if the headertext is set and there is no headerLiteral. This means
                    // that the layout template did not contain a header placeholder.

                    throw new InvalidOperationException(SR.GetString(SR.Wizard_Header_Placeholder_Must_Be_Specified_For_HeaderText, Owner.ID, HeaderPlaceholderId));
                }
            }


            public override void OnlyShowCompleteStep() {
                _layoutContainer.ControlToRender = Owner.MultiView;
            }


            public override void CreateControlHierarchy() {
                _layoutContainer = new WizardContainer();
                Owner.LayoutTemplate.InstantiateIn(_layoutContainer);

                using (new WizardControlCollectionModifier(Owner)) {
                    Owner.Controls.Add(_layoutContainer);
                }

                CreateControlHierarchy_Header(_layoutContainer);
                CreateControlHierarchy_SideBar(_layoutContainer);
                CreateControlHierarchy_WizardStep(_layoutContainer);
                CreateControlHierarchy_Navigation(_layoutContainer);
            }

            private void CreateControlHierarchy_Navigation(Control layoutContainer) {
                var placeholder = layoutContainer.FindControl(NavigationPlaceholderId);
                if (placeholder == null) {
                    throw new InvalidOperationException(SR.GetString(SR.Wizard_Navigation_Placeholder_Must_Be_Specified, Owner.ID, NavigationPlaceholderId));
                }

                Control navigationContainer = new Control();

                ReplacePlaceholderWithControl(layoutContainer, placeholder, navigationContainer);
                CreateNavigationControlHierarchy(navigationContainer);
            }

            private void CreateControlHierarchy_Header(Control layoutContainer) {
                var placeholder = layoutContainer.FindControl(HeaderPlaceholderId);

                if (Owner.HeaderTemplate != null) {
                    if (placeholder == null) {
                        throw new InvalidOperationException(SR.GetString(SR.Wizard_Header_Placeholder_Must_Be_Specified_For_HeaderTemplate, Owner.ID, HeaderPlaceholderId));
                    } else {
                        // just replace the placeholder with the template
                        ReplacePlaceholderWithTemplateInstance(layoutContainer, placeholder, Owner.HeaderTemplate);
                    }
                } else if (placeholder != null) {
                    // only create a header literal if the template contains a placeholder
                    // if the template does not contain a placeholder an exception will be thrown from
                    // ApplyControlProperties
                    _headerLiteral = new Literal();
                    ReplacePlaceholderWithControl(layoutContainer, placeholder, _headerLiteral);
                }
            }

            private void CreateControlHierarchy_SideBar(Control layoutContainer) {
                if (!Owner.DisplaySideBar) {
                    // it's ok to exit here since changing the DisplaySideBar value would
                    // force a recreation of the control tree.
                    return;
                }

                var placeholder = layoutContainer.FindControl(SideBarPlaceholderId);

                if (placeholder == null) {
                    // 
                    throw new InvalidOperationException(SR.GetString(SR.Wizard_Sidebar_Placeholder_Must_Be_Specified, Owner.ID, SideBarPlaceholderId));
                }

                ITemplate sideBarTemplate = Owner.SideBarTemplate ?? Owner.CreateDefaultSideBarTemplate();

                ReplacePlaceholderWithTemplateInstance(layoutContainer, placeholder, sideBarTemplate);

                CreateControlHierarchy_CleanUpOldSideBarList(Owner.SideBarList);
                Owner._sideBarList = CreateControlHierarchy_SetUpSideBarList(layoutContainer);
            }

            private void CreateControlHierarchy_WizardStep(Control layoutContainer) {
                var placeholder = layoutContainer.FindControl(WizardStepPlaceholderId);

                if (placeholder == null) {
                    throw new InvalidOperationException(SR.GetString(SR.Wizard_Step_Placeholder_Must_Be_Specified, Owner.ID, WizardStepPlaceholderId));
                }

                ReplacePlaceholderWithControl(layoutContainer, placeholder, Owner.MultiView);
            }

            private static void ReplacePlaceholderWithTemplateInstance(Control targetContainer, Control placeholder, ITemplate template) {
                var templateContainer = new Control();
                template.InstantiateIn(templateContainer);

                ReplacePlaceholderWithControl(targetContainer, placeholder, templateContainer);
            }

            private static void ReplacePlaceholderWithControl(Control targetContainer, Control placeholder, Control replacement) {
                var placeholderIndex = targetContainer.Controls.IndexOf(placeholder);
                targetContainer.Controls.RemoveAt(placeholderIndex);

                targetContainer.Controls.AddAt(placeholderIndex, replacement);
            }

            internal class WizardContainer : WebControl {
                internal Control ControlToRender { get; set; }

                protected internal override void Render(HtmlTextWriter writer) {
                    if (ControlToRender == null) {
                        RenderChildren(writer);
                    } else {
                        ControlToRender.Render(writer);
                    }
                }
            }
        }

        internal class TableWizardRendering : WizardRenderingBase {
            private const string _headerCellID = "HeaderContainer";
            private const string _sideBarCellID = "SideBarContainer";
            private const string _stepTableCellID = "StepTableCell";

            private TableCell _headerTableCell;
            private TableRow _headerTableRow;
            private TableRow _navigationRow;
            private TableCell _navigationTableCell;
            private Table _renderTable;
            private TableCell _stepTableCell;

            private LiteralControl _titleLiteral;

            public TableWizardRendering(Wizard wizard)
                : base(wizard) {
            }

            // Returns the cell which the navigation template container should be added to
            private TableCell NavigationTableCell {
                get {
                    if (_navigationTableCell == null) {
                        _navigationTableCell = new TableCell();
                    }
                    return _navigationTableCell;
                }
            }

            public override void ApplyControlProperties() {
                // Nothing to do if the Wizard is empty;
                // Apply the control properties at designtime so that controls inside templates are styled properly.
                if (!Owner.DesignMode &&
                    (Owner.ActiveStepIndex < 0 || Owner.ActiveStepIndex >= Owner.WizardSteps.Count || Owner.WizardSteps.Count == 0)) {
                    return;
                }

                if (Owner.SideBarEnabled && Owner._sideBarStyle != null) {
                    // Apply Sidebar style on the table cell VSWhidbey 377064
                    Owner._sideBarTableCell.ApplyStyle(Owner._sideBarStyle);
                }

                ApplyControlProperties_Header();

                ApplyControlProperties_WizardSteps();

                ApplyControlProperties_Navigation();

                ApplyControlProperties_Sidebar();

                if (_renderTable != null) {
                    // Clear out the accesskey/tab index so it doesn't get applied to the tables in the container
                    Util.CopyBaseAttributesToInnerControl(Owner, _renderTable);

                    if (Owner.ControlStyleCreated) {
                        _renderTable.ApplyStyle(Owner.ControlStyle);
                    } else {
                        // initialize defaults that are different from TableStyle
                        _renderTable.CellSpacing = 0;
                        _renderTable.CellPadding = 0;
                    }

                    // On Mac IE, if height is not set, render height:1px, so the table sizes to contents.
                    // Otherwise, Mac IE may give the table an arbitrary height (equal to the width of its contents).
                    if (!Owner.DesignMode && Owner.IsMacIE5 &&
                        (!Owner.ControlStyleCreated || Owner.ControlStyle.Height == Unit.Empty)) {
                        _renderTable.ControlStyle.Height = Unit.Pixel(1);
                    }
                }

                // On Mac IE, render height:1px of the inner table cell, so the table sizes to contents.
                // Otherwise, Mac IE may give the table an arbitrary height (equal to the width of its contents).
                if (!Owner.DesignMode && _navigationTableCell != null && Owner.IsMacIE5) {
                    _navigationTableCell.ControlStyle.Height = Unit.Pixel(1);
                }
            }


            private void ApplyControlProperties_Navigation() {
                ApplyNavigationTemplateProperties();
                ApplyCustomNavigationTemplateProperties();

                if (_navigationTableCell != null) {
                    NavigationTableCell.HorizontalAlign = HorizontalAlign.Right;
                    // Copy the styles from the StepStyle property if defined.
                    if (Owner._navigationStyle != null) {
                        if (!Owner.DesignMode && Owner.IsMacIE5 && Owner._navigationStyle.Height == Unit.Empty) {
                            Owner._navigationStyle.Height = Unit.Pixel(1);
                        }

                        _navigationTableCell.ApplyStyle(Owner._navigationStyle);
                    }
                }

                if (Owner.ShowCustomNavigationTemplate) {
                    // Make sure the navigation row is visible
                    _navigationRow.Visible = true;
                }
            }

            private void ApplyControlProperties_WizardSteps() {
                // Apply the WizardSteps style
                if (_stepTableCell != null) {
                    // Copy the styles from the StepStyle property if defined.
                    if (Owner._stepStyle != null) {
                        if (!Owner.DesignMode && Owner.IsMacIE5 && Owner._stepStyle.Height == Unit.Empty) {
                            Owner._stepStyle.Height = Unit.Pixel(1);
                        }

                        _stepTableCell.ApplyStyle(Owner._stepStyle);
                    }
                }
            }

            private void ApplyControlProperties_Header() {
                if (_headerTableRow != null) {
                    // If headerTemplate is not defined and headertext is empty, do not render the
                    // empty table row.
                    if ((Owner.HeaderTemplate == null) && String.IsNullOrEmpty(Owner.HeaderText)) {
                        _headerTableRow.Visible = false;
                    } else {
                        _headerTableCell.ApplyStyle(Owner._headerStyle);

                        // if HeaderTemplate is defined.
                        if (Owner.HeaderTemplate != null) {
                            if (_titleLiteral != null) {
                                _titleLiteral.Visible = false;
                            }
                        }
                            // Otherwise HeaderText is defined.
                        else {
                            Debug.Assert(Owner.HeaderText != null && Owner.HeaderText.Length > 0);
                            if (_titleLiteral != null) {
                                _titleLiteral.Text = Owner.HeaderText;
                            }
                        }
                    }
                }
            }


            protected override WizardStepType SetActiveTemplates() {
                WizardStepType type = base.SetActiveTemplates();

                if (type != WizardStepType.Complete) {
                    // Only render sidebartablecell if necessary
                    if (Owner._sideBarTableCell != null) {
                        Owner._sideBarTableCell.Visible = Owner.SideBarEnabled && Owner._renderSideBarDataList;
                    }
                }

                return type;
            }

            public override void OnlyShowCompleteStep() {
                // Do not render header or sidebarlist in complete steps;
                if (_headerTableRow != null) {
                    _headerTableRow.Visible = false;
                }

                if (Owner._sideBarTableCell != null) {
                    Owner._sideBarTableCell.Visible = false;
                }

                _navigationRow.Visible = false;
            }


            public override void CreateControlHierarchy() {
                // Use the inner table to render header template, step and navigation template
                Table mainContentTable = null;

                if (Owner.DisplaySideBar) {
                    mainContentTable = CreateControlHierarchy_CreateLayoutWithSideBar();
                } else {
                    mainContentTable = CreateControlHierarchy_CreateLayoutWithoutSideBar();
                }

                CreateControlHierarchy_CreateHeaderArea(mainContentTable);

                CreateControlHierarchy_CreateStepArea(mainContentTable);

                CreateControlHierarchy_CreateNavigationArea(mainContentTable);
            }


            private void CreateControlHierarchy_CreateNavigationArea(Table mainContentTable) {
                _navigationRow = new TableRow();
                mainContentTable.Controls.Add(_navigationRow);
                _navigationRow.Controls.Add(NavigationTableCell);

                CreateNavigationControlHierarchy(NavigationTableCell);
            }

            private void CreateControlHierarchy_CreateStepArea(Table mainContentTable) {
                TableRow stepRow = new TableRow() {
                    // The step row needs to use the most of the table size.
                    Height = Unit.Percentage(100)
                };
                mainContentTable.Controls.Add(stepRow);
                _stepTableCell = new TableCell();

                stepRow.Controls.Add(_stepTableCell);

                _stepTableCell.Controls.Add(Owner.MultiView);

                Owner.InstantiateStepContentTemplates();
            }

            private void CreateControlHierarchy_CreateHeaderArea(Table mainContentTable) {
                _headerTableRow = new TableRow();
                mainContentTable.Controls.Add(_headerTableRow);
                _headerTableCell = new InternalTableCell(Owner) {
                    ID = _headerCellID
                };

                if (Owner.HeaderTemplate != null) {
                    _headerTableCell.EnableTheming = Owner.EnableTheming;
                    Owner.HeaderTemplate.InstantiateIn(_headerTableCell);
                } else {
                    // Render the title property if HeaderTemplate is not defined.
                    _titleLiteral = new LiteralControl();
                    _headerTableCell.Controls.Add(_titleLiteral);
                }

                _headerTableRow.Controls.Add(_headerTableCell);
            }

            private Table CreateControlHierarchy_CreateLayoutWithoutSideBar() {
                // if sidebar is disabled, add mainContentTable directly into the Wizard control.
                var mainContentTable = new WizardChildTable(Owner) {
                    EnableTheming = false
                };
                using (new WizardControlCollectionModifier(Owner)) {
                    Owner.Controls.Add(mainContentTable);
                }
                _renderTable = mainContentTable;
                return mainContentTable;
            }

            private Table CreateControlHierarchy_CreateLayoutWithSideBar() {
                // Create an outer table and make all child controls into the right cell.
                // Use the left cell to render the side bar.

                Table outerTable = new WizardChildTable(Owner) {
                    EnableTheming = false
                };

                TableRow outerRow = new TableRow();
                outerTable.Controls.Add(outerRow);

                // Use the existing sideBarTableCell if possible.
                TableCell outerLeftCell = Owner._sideBarTableCell ?? CreateControlHierarchy_CreateSideBarTableCell();
                outerRow.Controls.Add(outerLeftCell);

                Owner._sideBarTableCell = outerLeftCell;
                Owner._renderSideBarDataList = false;

                // Right cell is used for header, step and navigation areas.
                TableCell outerRightCell = new TableCell() {
                    // Maximize the inner default table Whidbey 143409.
                    Height = Unit.Percentage(100)
                };

                outerRow.Controls.Add(outerRightCell);

                var mainContentTable = new WizardDefaultInnerTable() {
                    CellSpacing = 0,
                    Height = Unit.Percentage(100),
                    Width = Unit.Percentage(100)
                };

                outerRightCell.Controls.Add(mainContentTable);

                // On Mac IE, render height:1px of the inner table cell, so the table sizes to contents.
                // Otherwise, Mac IE may give the table an arbitrary height (equal to the width of its contents).
                if (!Owner.DesignMode && Owner.IsMacIE5) {
                    outerRightCell.Height = Unit.Pixel(1);
                }

                // Add the table into the Wizard control
                using (new WizardControlCollectionModifier(Owner)) {
                    Owner.Controls.Add(outerTable);
                }

                CreateControlHierarchy_CleanUpOldSideBarList(Owner.SideBarList);
                Owner._sideBarList = CreateControlHierarchy_SetUpSideBarList(Owner._sideBarTableCell);

                _renderTable = outerTable;
                return mainContentTable;
            }

            private TableCell CreateControlHierarchy_CreateSideBarTableCell() {
                // Left cell is used for SideBar
                TableCell outerLeftCell = new AccessibleTableCell(Owner) {
                    ID = _sideBarCellID,
                    // Left cell should expand to all height if sidebar is displayed.
                    Height = Unit.Percentage(100)
                };

                ITemplate sideBarTemplate = Owner.SideBarTemplate;

                if (sideBarTemplate == null) {
                    outerLeftCell.EnableViewState = false;
                    sideBarTemplate = Owner.CreateDefaultSideBarTemplate();
                } else {
                    outerLeftCell.EnableTheming = Owner.EnableTheming;
                }
                sideBarTemplate.InstantiateIn(outerLeftCell);

                return outerLeftCell;
            }


            public override void SetDesignModeState(IDictionary dictionary) {
                base.SetDesignModeState(dictionary);
                dictionary[_stepTableCellID] = _stepTableCell;

            }
        }

        #endregion

        private class WizardControlCollection : ControlCollection {
            public WizardControlCollection(Wizard wizard)
                : base(wizard) {
                if (!wizard.DesignMode)
                    SetCollectionReadOnly(SR.Wizard_Cannot_Modify_ControlCollection);
            }
        }

        private class WizardControlCollectionModifier : IDisposable {
            Wizard _wizard;
            ControlCollection _controls;
            String _originalError;

            public WizardControlCollectionModifier(Wizard wizard) {
                _wizard = wizard;
                if (!_wizard.DesignMode) {
                    // Remember the ControlCollection so we don't need to access the
                    // Controls property by GC during Dispose. Accessing this property has the
                    // side-effect of creating the entire child controls on CompositeControl.
                    _controls = _wizard.Controls;
                    _originalError = _controls.SetCollectionReadOnly(null);
                }
            }

            void IDisposable.Dispose() {
                if (!_wizard.DesignMode) {
                    _controls.SetCollectionReadOnly(_originalError);
                }
            }
        }

        [SupportsEventValidation]
        private class WizardChildTable : ChildTable {
            private Wizard _owner;

            internal WizardChildTable(Wizard owner) {
                _owner = owner;
            }

            protected override bool OnBubbleEvent(object source, EventArgs args) {
                return _owner.OnBubbleEvent(source, args);
            }
        }

        private enum WizardTemplateType {
            StartNavigationTemplate = 0,
            StepNavigationTemplate = 1,
            FinishNavigationTemplate = 2,
        }

        private sealed class NavigationTemplate : ITemplate {

            private Wizard _wizard;
            private WizardTemplateType _templateType;
            private String _button1ID;
            private String _button2ID;
            private String _button3ID;

            private const string _startNextButtonID = "StartNext";
            private const string _stepNextButtonID = "StepNext";
            private const string _stepPreviousButtonID = "StepPrevious";
            private const string _finishPreviousButtonID = "FinishPrevious";
            private const string _finishButtonID = "Finish";
            private const string _cancelButtonID = "Cancel";

            private TableRow _row;

            private IButtonControl[][] _buttons;

            private bool _button1CausesValidation;

            internal static NavigationTemplate GetDefaultStartNavigationTemplate(Wizard wizard) {
                return new NavigationTemplate(wizard, WizardTemplateType.StartNavigationTemplate,
                    true, null, _startNextButtonID, _cancelButtonID);
            }

            internal static NavigationTemplate GetDefaultStepNavigationTemplate(Wizard wizard) {
                return new NavigationTemplate(wizard, WizardTemplateType.StepNavigationTemplate,
                    false, _stepPreviousButtonID, _stepNextButtonID, _cancelButtonID);
            }

            internal static NavigationTemplate GetDefaultFinishNavigationTemplate(Wizard wizard) {
                return new NavigationTemplate(wizard, WizardTemplateType.FinishNavigationTemplate,
                    false, _finishPreviousButtonID, _finishButtonID, _cancelButtonID);
            }

            internal void ResetButtonsVisibility() {
                Debug.Assert(_wizard.DesignMode);

                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {
                        Control c = _buttons[i][j] as Control;
                        if (c != null) c.Visible = false;
                    }
                }
            }

            private NavigationTemplate(Wizard wizard, WizardTemplateType templateType, bool button1CausesValidation,
                String label1ID, String label2ID, String label3ID) {

                _wizard = wizard;
                _button1ID = label1ID;
                _button2ID = label2ID;
                _button3ID = label3ID;

                _templateType = templateType;

                _buttons = new IButtonControl[3][];
                _buttons[0] = new IButtonControl[3];
                _buttons[1] = new IButtonControl[3];
                _buttons[2] = new IButtonControl[3];

                _button1CausesValidation = button1CausesValidation;
            }

            void ITemplate.InstantiateIn(Control container) {
                Table table = new WizardDefaultInnerTable();

                // Increase the default space and padding so the layout
                // of the buttons look good. Also, to make custom border
                // visible. VSWhidbey 377069
                table.CellSpacing = 5;
                table.CellPadding = 5;
                container.Controls.Add(table);

                _row = new TableRow();
                table.Rows.Add(_row);

                if (_button1ID != null) {
                    CreateButtonControl(_buttons[0], _button1ID, _button1CausesValidation,
                        MovePreviousCommandName);
                }

                if (_button2ID != null) {
                    CreateButtonControl(_buttons[1], _button2ID, true /* causesValidation */,
                        _templateType == WizardTemplateType.FinishNavigationTemplate ? MoveCompleteCommandName : MoveNextCommandName);
                }

                CreateButtonControl(_buttons[2], _button3ID, false /* causesValidation */, CancelCommandName);
            }

            private void OnPreRender(object source, EventArgs e) {
                ((ImageButton)source).Visible = false;
            }

            private void CreateButtonControl(IButtonControl[] buttons, String id, bool causesValidation, string commandName) {
                LinkButton linkButton = new LinkButton();
                linkButton.CausesValidation = causesValidation;
                linkButton.ID = id + "LinkButton";
                linkButton.Visible = false;
                linkButton.CommandName = commandName;
                linkButton.TabIndex = _wizard.TabIndex;
                _wizard.RegisterCommandEvents(linkButton);
                buttons[0] = linkButton;

                ImageButton imageButton = new ImageButton();
                imageButton.CausesValidation = causesValidation;
                imageButton.ID = id + "ImageButton";
                imageButton.Visible = true;
                imageButton.CommandName = commandName;
                imageButton.TabIndex = _wizard.TabIndex;
                _wizard.RegisterCommandEvents(imageButton);
                imageButton.PreRender += new EventHandler(OnPreRender);
                buttons[1] = imageButton;

                Button button = new Button();
                button.CausesValidation = causesValidation;
                button.ID = id + "Button";
                button.Visible = false;
                button.CommandName = commandName;
                button.TabIndex = _wizard.TabIndex;
                _wizard.RegisterCommandEvents(button);
                buttons[2] = button;

                TableCell tableCell = new TableCell();
                tableCell.HorizontalAlign = HorizontalAlign.Right;
                _row.Cells.Add(tableCell);

                tableCell.Controls.Add(linkButton);
                tableCell.Controls.Add(imageButton);
                tableCell.Controls.Add(button);
            }

            internal IButtonControl FirstButton {
                get {
                    ButtonType buttonType = ButtonType.Button;
                    switch (_templateType) {
                        case WizardTemplateType.StartNavigationTemplate:
                            Debug.Fail("Invalid template/button type");
                            break;

                        case WizardTemplateType.StepNavigationTemplate:
                            buttonType = _wizard.StepPreviousButtonType;
                            break;

                        case WizardTemplateType.FinishNavigationTemplate:
                        default:
                            buttonType = _wizard.FinishPreviousButtonType;
                            break;
                    }

                    return GetButtonBasedOnType(0, buttonType);
                }
            }

            internal IButtonControl SecondButton {
                get {
                    ButtonType buttonType = ButtonType.Button;
                    switch (_templateType) {
                        case WizardTemplateType.StartNavigationTemplate:
                            buttonType = _wizard.StartNextButtonType;
                            break;

                        case WizardTemplateType.StepNavigationTemplate:
                            buttonType = _wizard.StepNextButtonType;
                            break;

                        case WizardTemplateType.FinishNavigationTemplate:
                        default:
                            buttonType = _wizard.FinishCompleteButtonType;
                            break;
                    }

                    return GetButtonBasedOnType(1, buttonType);
                }
            }

            internal IButtonControl CancelButton {
                get {
                    ButtonType buttonType = _wizard.CancelButtonType;
                    return GetButtonBasedOnType(2, buttonType);
                }
            }

            private IButtonControl GetButtonBasedOnType(int pos, ButtonType type) {
                switch (type) {
                    case ButtonType.Button:
                        return _buttons[pos][2];

                    case ButtonType.Image:
                        return _buttons[pos][1];

                    case ButtonType.Link:
                        return _buttons[pos][0];
                }

                return null;
            }
        }

        private class DataListItemTemplate : ITemplate {
            Wizard _owner;

            internal DataListItemTemplate(Wizard owner) {
                _owner = owner;
            }

            public void InstantiateIn(Control container) {
                LinkButton linkButton = new LinkButton();
                container.Controls.Add(linkButton);
                linkButton.ID = SideBarButtonID;

                if (_owner.DesignMode) {
                    linkButton.MergeStyle(_owner.SideBarButtonStyle);
                }
            }
        }

        private class DefaultSideBarTemplate : ITemplate {
            private Wizard _owner;

            internal DefaultSideBarTemplate(Wizard owner) {
                _owner = owner;
            }

            public void InstantiateIn(Control container) {
                Control sideBarListControl = null;

                if (_owner.SideBarList == null) {
                    var dataList = new DataList();
                    dataList.ID = Wizard.DataListID;

                    dataList.SelectedItemStyle.Font.Bold = true;
                    dataList.ItemTemplate = _owner.CreateDefaultDataListItemTemplate();

                    sideBarListControl = dataList;
                } else {
                    sideBarListControl = (Control)_owner.SideBarList;
                }

                container.Controls.Add(sideBarListControl);
            }
        }

        // Internally use an empty table (with a row and a cell) to render the content.
        internal abstract class BlockControl : WebControl, INamingContainer, INonBindingContainer {
            private Table _table;
            internal TableCell _cell;
            internal Wizard _owner;

            internal BlockControl(Wizard owner) {
                Debug.Assert(owner != null);
                _owner = owner;

                _table = new WizardDefaultInnerTable();
                _table.EnableTheming = false;

                Controls.Add(_table);

                TableRow row = new TableRow();
                _table.Controls.Add(row);

                _cell = new TableCell();
                _cell.Height = Unit.Percentage(100);
                _cell.Width = Unit.Percentage(100);
                row.Controls.Add(_cell);

                HandleMacIECellHeight();
                PreventAutoID();
            }

            protected Table Table {
                get { return _table; }
            }

            internal TableCell InnerCell {
                get { return _cell; }
            }

            protected override Style CreateControlStyle() {
                return new TableItemStyle(ViewState);
            }

            public override void Focus() {
                throw new NotSupportedException(SR.GetString(SR.NoFocusSupport, this.GetType().Name));
            }

            internal void HandleMacIECellHeight() {
                // On Mac IE, render height:1px of the inner table cell, so the table sizes to contents.
                // Otherwise, Mac IE may give the table an arbitrary height (equal to the width of its contents).
                if (!_owner.DesignMode && _owner.IsMacIE5) {
                    _cell.Height = Unit.Pixel(1);
                }
            }

            // Renders the inner control only
            protected internal override void Render(HtmlTextWriter writer) {
                RenderContents(writer);
            }

            internal void SetEnableTheming() {
                _cell.EnableTheming = _owner.EnableTheming;
            }
        }

        private class InternalTableCell : TableCell, INamingContainer, INonBindingContainer {
            protected Wizard _owner;

            internal InternalTableCell(Wizard owner) {
                _owner = owner;
            }

            // Do not render any attributes other than Style on this cell.
            protected override void AddAttributesToRender(HtmlTextWriter writer) {
                if (ControlStyleCreated && !ControlStyle.IsEmpty) {
                    // let the style add attributes
                    ControlStyle.AddAttributesToRender(writer, this);
                }
            }
        }

        private class AccessibleTableCell : InternalTableCell {
            internal AccessibleTableCell(Wizard owner)
                : base(owner) {
            }

            protected internal override void RenderChildren(HtmlTextWriter writer) {
                ControlRenderingHelper.WriteSkipLinkStart(writer, RenderingCompatibility, _owner.DesignMode, _owner.SkipLinkText, SpacerImageUrl, _owner.ClientID);

                base.RenderChildren(writer);

                ControlRenderingHelper.WriteSkipLinkEnd(writer, _owner.DesignMode, _owner.SkipLinkText, _owner.ClientID);
            }
        }

        internal class BaseContentTemplateContainer : BlockControl {
            private bool _useInnerTable;
            internal BaseContentTemplateContainer(Wizard owner,  bool useInnerTable)
                : base(owner) {
                _useInnerTable = useInnerTable;
                if (useInnerTable) {
                    // Set the table width to 100% so the table within each
                    // row will have the same width. VSWhidbey 377182
                    Table.Width = Unit.Percentage(100);
                    Table.Height = Unit.Percentage(100);
                }
                else {
                    // remove nested table from Control tree
                    Controls.Clear();
                }
            }

            internal void AddChildControl(Control c) {
                Container.Controls.Add(c);
            }

            internal Control Container {
                get {
                    return _useInnerTable ? InnerCell : (Control)this;
                }
            }
        }

        #region Navigation Template Containers

        internal class BaseNavigationTemplateContainer : WebControl, INamingContainer, INonBindingContainer {
            private IButtonControl _finishButton;
            private IButtonControl _previousButton;
            private IButtonControl _nextButton;
            private IButtonControl _cancelButton;
            private Wizard _owner;

            internal BaseNavigationTemplateContainer(Wizard owner) {
                _owner = owner;
            }

            internal Wizard Owner {
                get {
                    return _owner;
                }
            }

            internal void ApplyButtonStyle(Style finishStyle, Style prevStyle, Style nextStyle, Style cancelStyle) {
                if (FinishButton != null) ApplyButtonStyleInternal(FinishButton, finishStyle);
                if (PreviousButton != null) ApplyButtonStyleInternal(PreviousButton, prevStyle);
                if (NextButton != null) ApplyButtonStyleInternal(NextButton, nextStyle);
                if (CancelButton != null) ApplyButtonStyleInternal(CancelButton, cancelStyle);
            }

            protected void ApplyButtonStyleInternal(IButtonControl control, Style buttonStyle) {
                WebControl webCtrl = control as WebControl;
                if (webCtrl != null) {
                    webCtrl.ApplyStyle(buttonStyle);
                    webCtrl.ControlStyle.MergeWith(Owner.NavigationButtonStyle);
                }
            }

            public override void Focus() {
                throw new NotSupportedException(SR.GetString(SR.NoFocusSupport, this.GetType().Name));
            }

            internal void RegisterButtonCommandEvents() {
                Owner.RegisterCommandEvents(NextButton);
                Owner.RegisterCommandEvents(FinishButton);
                Owner.RegisterCommandEvents(PreviousButton);
                Owner.RegisterCommandEvents(CancelButton);
            }

            internal IButtonControl CancelButton {
                get {
                    if (_cancelButton != null) {
                        return _cancelButton;
                    }

                    _cancelButton = FindControl(Wizard.CancelButtonID) as IButtonControl;
                    return _cancelButton;
                }

                set {
                    _cancelButton = value;
                }
            }

            internal virtual IButtonControl NextButton {
                get {
                    if (_nextButton != null) {
                        return _nextButton;
                    }

                    _nextButton = FindControl(Wizard.StepNextButtonID) as IButtonControl;
                    return _nextButton;
                }

                set {
                    _nextButton = value;
                }
            }

            internal virtual IButtonControl PreviousButton {
                get {
                    if (_previousButton != null) {
                        return _previousButton;
                    }

                    _previousButton = FindControl(Wizard.StepPreviousButtonID) as IButtonControl;
                    return _previousButton;
                }

                set {
                    _previousButton = value;
                }
            }

            internal IButtonControl FinishButton {
                get {
                    if (_finishButton != null) {
                        return _finishButton;
                    }

                    _finishButton = FindControl(Wizard.FinishButtonID) as IButtonControl;
                    return _finishButton;
                }

                set {
                    _finishButton = value;
                }
            }

            internal void SetEnableTheming() {
                this.EnableTheming = _owner.EnableTheming;
            }

            // Renders the inner control only
            protected internal override void Render(HtmlTextWriter writer) {
                RenderContents(writer);
            }
        }

        private class FinishNavigationTemplateContainer : BaseNavigationTemplateContainer {
            private IButtonControl _previousButton;

            internal FinishNavigationTemplateContainer(Wizard owner)
                : base(owner) {
            }

            internal override IButtonControl PreviousButton {
                get {
                    if (_previousButton != null) {
                        return _previousButton;
                    }

                    _previousButton = FindControl(Wizard.FinishPreviousButtonID) as IButtonControl;
                    return _previousButton;
                }

                set {
                    _previousButton = value;
                }
            }
        }

        private class StartNavigationTemplateContainer : BaseNavigationTemplateContainer {
            private IButtonControl _nextButton;

            internal StartNavigationTemplateContainer(Wizard owner)
                : base(owner) {
            }

            internal override IButtonControl NextButton {
                get {
                    if (_nextButton != null) {
                        return _nextButton;
                    }

                    _nextButton = FindControl(Wizard.StartNextButtonID) as IButtonControl;

                    return _nextButton;
                }

                set {
                    _nextButton = value;
                }
            }
        }

        private class StepNavigationTemplateContainer : BaseNavigationTemplateContainer {

            internal StepNavigationTemplateContainer(Wizard owner)
                : base(owner) {
            }
        }

        #endregion
    }

    public sealed class WizardStepCollection : IList {
        private Wizard _wizard;


        internal WizardStepCollection(Wizard wizard) {
            this._wizard = wizard;
            wizard.TemplatedSteps.Clear();
        }


        public int Count {
            get {
                return Views.Count;
            }
        }


        public bool IsReadOnly {
            get {
                return Views.IsReadOnly;
            }
        }


        public bool IsSynchronized {
            get {
                return false;
            }
        }


        public object SyncRoot {
            get {
                return this;
            }
        }

        private ViewCollection Views {
            get {
                return _wizard.MultiView.Views;
            }
        }


        public WizardStepBase this[int index] {
            get {
                return (WizardStepBase)Views[index];
            }
        }


        public void Add(WizardStepBase wizardStep) {
            // 
            if (wizardStep == null) {
                throw new ArgumentNullException("wizardStep");
            }

            wizardStep.PreventAutoID();
            RemoveIfAlreadyExistsInWizard(wizardStep);

            wizardStep.Owner = _wizard;
            Views.Add(wizardStep);
            AddTemplatedWizardStep(wizardStep);

            NotifyWizardStepsChanged();
        }


        public void AddAt(int index, WizardStepBase wizardStep) {
            if (wizardStep == null) {
                throw new ArgumentNullException("wizardStep");
            }

            RemoveIfAlreadyExistsInWizard(wizardStep);

            wizardStep.PreventAutoID();
            wizardStep.Owner = _wizard;
            Views.AddAt(index, wizardStep);
            AddTemplatedWizardStep(wizardStep);

            NotifyWizardStepsChanged();
        }


        private void AddTemplatedWizardStep(WizardStepBase wizardStep) {
            var templatedWizardStep = wizardStep as TemplatedWizardStep;
            if (templatedWizardStep != null) {
                _wizard.TemplatedSteps.Add(templatedWizardStep);
                _wizard.RegisterCustomNavigationContainers(templatedWizardStep);
            }
        }


        public void Clear() {
            Views.Clear();
            _wizard.TemplatedSteps.Clear();

            NotifyWizardStepsChanged();
        }


        public bool Contains(WizardStepBase wizardStep) {
            if (wizardStep == null) {
                throw new ArgumentNullException("wizardStep");
            }

            return Views.Contains(wizardStep);
        }


        public void CopyTo(WizardStepBase[] array, int index) {
            Views.CopyTo(array, index);
        }


        public IEnumerator GetEnumerator() {
            return Views.GetEnumerator();
        }


        public int IndexOf(WizardStepBase wizardStep) {
            if (wizardStep == null) {
                throw new ArgumentNullException("wizardStep");
            }

            return Views.IndexOf(wizardStep);
        }


        public void Insert(int index, WizardStepBase wizardStep) {
            AddAt(index, wizardStep);
        }

        internal void NotifyWizardStepsChanged() {
            _wizard.OnWizardStepsChanged();
        }


        public void Remove(WizardStepBase wizardStep) {
            if (wizardStep == null) {
                throw new ArgumentNullException("wizardStep");
            }

            Views.Remove(wizardStep);
            wizardStep.Owner = null;
            var templatedWizardStep = wizardStep as TemplatedWizardStep;
            if (templatedWizardStep != null) {
                _wizard.TemplatedSteps.Remove(templatedWizardStep);
            }

            NotifyWizardStepsChanged();
        }


        public void RemoveAt(int index) {
            WizardStepBase wizardStep = Views[index] as WizardStepBase;
            if (wizardStep != null) {
                wizardStep.Owner = null;
                var templatedWizardStep = wizardStep as TemplatedWizardStep;
                if (templatedWizardStep != null) {
                    _wizard.TemplatedSteps.Remove(templatedWizardStep);
                }
            }
            Views.RemoveAt(index);

            NotifyWizardStepsChanged();
        }

        private static void RemoveIfAlreadyExistsInWizard(WizardStepBase wizardStep) {
            if (wizardStep.Owner != null) {
                wizardStep.Owner.WizardSteps.Remove(wizardStep);
            }
        }

        private static WizardStepBase GetStepAndVerify(object value) {
            WizardStepBase step = value as WizardStepBase;
            if (step == null)
                throw new ArgumentException(SR.GetString(SR.Wizard_WizardStepOnly));

            return step;
        }

        #region ICollection implementation


        /// <internalonly/>
        void ICollection.CopyTo(Array array, int index) {
            Views.CopyTo(array, index);
        }
        #endregion //ICollection implementation

        #region IList implementation


        /// <internalonly/>
        bool IList.IsFixedSize {
            get {
                return false;
            }
        }


        /// <internalonly/>
        object IList.this[int index] {
            get {
                return Views[index];
            }
            set {
                RemoveAt(index);
                AddAt(index, GetStepAndVerify(value));
            }
        }


        /// <internalonly/>
        int IList.Add(object value) {
            WizardStepBase step = GetStepAndVerify(value);
            step.PreventAutoID();
            Add(step);
            return IndexOf(step);
        }


        /// <internalonly/>
        bool IList.Contains(object value) {
            return Contains(GetStepAndVerify(value));
        }


        /// <internalonly/>
        int IList.IndexOf(object value) {
            return IndexOf(GetStepAndVerify(value));
        }


        /// <internalonly/>
        void IList.Insert(int index, object value) {
            AddAt(index, GetStepAndVerify(value));
        }


        /// <internalonly/>
        void IList.Remove(object value) {
            Remove(GetStepAndVerify(value));
        }
        #endregion // IList implementation
    }

    [SupportsEventValidation]
    internal class WizardDefaultInnerTable : Table {
        internal WizardDefaultInnerTable() {
            PreventAutoID();

            // cell padding and spacing should be 0 since these tables are for internal layout only.
            CellPadding = 0;
            CellSpacing = 0;
        }
    }


    public class WizardNavigationEventArgs : EventArgs {

        private int _currentStepIndex;
        private int _nextStepIndex;
        private bool _cancel;


        public WizardNavigationEventArgs(int currentStepIndex, int nextStepIndex) {
            _currentStepIndex = currentStepIndex;
            _nextStepIndex = nextStepIndex;
        }


        public bool Cancel {
            get {
                return _cancel;
            }
            set {
                _cancel = value;
            }
        }


        public int CurrentStepIndex {
            get {
                return _currentStepIndex;
            }
        }


        public int NextStepIndex {
            get {
                return _nextStepIndex;
            }
        }

        internal void SetNextStepIndex(int nextStepIndex) {
            _nextStepIndex = nextStepIndex;
        }
    }


    public delegate void WizardNavigationEventHandler(object sender, WizardNavigationEventArgs e);
}