Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebControls/MultiView.cs

@@ -0,0 +1,412 @@
+//------------------------------------------------------------------------------
+// <copyright file="MultiView.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls {
+
+    using System;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Web.UI;
+
+
+    /// <devdoc>
+    /// <para></para>
+    /// </devdoc>
+    [
+    ControlBuilder(typeof(MultiViewControlBuilder)),
+    Designer("System.Web.UI.Design.WebControls.MultiViewDesigner, " + AssemblyRef.SystemDesign),
+    DefaultEvent("ActiveViewChanged"),
+    ParseChildren(typeof(View))
+    ]
+    [ToolboxData("<{0}:MultiView runat=\"server\"></{0}:MultiView>")]
+    public class MultiView : Control {
+
+        private static readonly object _eventActiveViewChanged = new object();
+        private int _activeViewIndex = -1;
+        private int _cachedActiveViewIndex = -1;
+        private bool _ignoreBubbleEvents = false;
+        private bool _controlStateApplied;
+
+
+        /// <devdoc>
+        /// <para> Specifies the NextView command. This field is constant.</para>
+        /// </devdoc>
+        public static readonly string NextViewCommandName = "NextView";
+
+        /// <devdoc>
+        /// <para> Specifies the PrevView command. This field is constant.</para>
+        /// </devdoc>
+        public static readonly string PreviousViewCommandName = "PrevView";
+
+        /// <devdoc>
+        /// <para> Specifies the SwitchViewById command. This field is constant.</para>
+        /// </devdoc>
+        public static readonly string SwitchViewByIDCommandName = "SwitchViewByID";
+
+        /// <devdoc>
+        /// <para> Specifies the SwitchViewByIndex command. This field is constant.</para>
+        /// </devdoc>
+        public static readonly string SwitchViewByIndexCommandName = "SwitchViewByIndex";
+
+
+        /// <devdoc>
+        /// <para>Indicates the active <see cref='System.Web.UI.WebControls.View'/> inside the <see cref='System.Web.UI.WebControls.MultiView'/> control.</para>
+        /// </devdoc>
+        [
+        DefaultValue(-1),
+        WebCategory("Behavior"),
+        WebSysDescription(SR.MultiView_ActiveView)
+        ]
+        public virtual int ActiveViewIndex {
+            get {
+                if (_cachedActiveViewIndex > -1) {
+                    return _cachedActiveViewIndex;
+                }
+                return _activeViewIndex;
+            }
+            set {
+                if (value < -1) {
+                    throw new ArgumentOutOfRangeException("value",
+                        SR.GetString(SR.MultiView_ActiveViewIndex_less_than_minus_one, value));
+                }
+                if (Views.Count == 0 && ControlState < ControlState.FrameworkInitialized /* Whidbey 113333 */) {
+                    _cachedActiveViewIndex = value;
+                    return;
+                }
+                if (value >= Views.Count) {
+                    throw new ArgumentOutOfRangeException("value",
+                        SR.GetString(SR.MultiView_ActiveViewIndex_equal_or_greater_than_count, value, Views.Count));
+                }
+
+                // VSWhidbey 472054: If the cached index is not -1, that means we
+                // haven't activate any view, hence original index is set to -1.
+                int originalIndex = (_cachedActiveViewIndex != -1) ? -1 : _activeViewIndex;
+                _activeViewIndex = value;
+                _cachedActiveViewIndex = -1;
+                // Need to compare originalIndex to Views.Count in case originalIndex was set declaratively.
+                if (originalIndex != value && originalIndex != -1  && originalIndex < Views.Count) {
+                    Views[originalIndex].Active = false;
+                    if (ShouldTriggerViewEvent) {
+                        Views[originalIndex].OnDeactivate(EventArgs.Empty);
+                    }
+                }
+                if (originalIndex != value && Views.Count != 0 && value != -1) {
+                    Views[value].Active = true;
+                    if (ShouldTriggerViewEvent) {
+                        Views[value].OnActivate(EventArgs.Empty);
+                        OnActiveViewChanged(EventArgs.Empty);
+                    }
+                }
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>Gets and sets a value indicating whether theme is enabled.</para>
+        /// </devdoc>
+        [
+        Browsable(true)
+        ]
+        public override bool EnableTheming {
+            get {
+                return base.EnableTheming;
+            }
+            set {
+                base.EnableTheming = value;
+            }
+        }
+
+        private bool ShouldTriggerViewEvent {
+            get {
+                // We want to fire the View's event on the first request
+                return (_controlStateApplied || (Page != null && !Page.IsPostBack));
+            }
+        }
+
+        /// <devdoc>
+        /// <para>[To be supplied.]</para>
+        /// </devdoc>
+        [
+        Browsable(false),
+        WebSysDescription(SR.MultiView_Views),
+        PersistenceMode(PersistenceMode.InnerDefaultProperty)
+        ]
+        public virtual ViewCollection Views {
+            get {
+                return (ViewCollection)Controls;
+            }
+        }
+
+
+
+        /// <devdoc>
+        ///    <para>Occurs when the active view changed.</para>
+        /// </devdoc>
+        [
+        WebCategory("Action"),
+        WebSysDescription(SR.MultiView_ActiveViewChanged)
+        ]
+        public event EventHandler ActiveViewChanged {
+            add {
+                Events.AddHandler(_eventActiveViewChanged, value);
+            }
+            remove {
+                Events.RemoveHandler(_eventActiveViewChanged, value);
+            }
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        ///    Overridden to only allow View controls to be added.
+        /// </devdoc>
+        protected override void AddParsedSubObject(object obj) {
+            if (obj is View) {
+                Controls.Add((Control)obj);
+            }
+            else if (!(obj is LiteralControl))
+                throw new HttpException(SR.GetString(SR.MultiView_cannot_have_children_of_type, obj.GetType().Name));
+        }
+
+
+        /// <devdoc>
+        /// [To be supplied.]
+        /// </devdoc>
+        protected override ControlCollection CreateControlCollection() {
+            return new ViewCollection(this);
+        }
+
+
+        /// <devdoc>
+        /// <para>[To be supplied.]</para>
+        /// </devdoc>
+        public View GetActiveView() {
+            int activeViewIndex = ActiveViewIndex;
+            if (activeViewIndex >= Views.Count) {
+                throw new Exception(SR.GetString(SR.MultiView_ActiveViewIndex_out_of_range));
+            }
+            if (activeViewIndex < 0) {
+                return null;
+            }
+            View view = Views[activeViewIndex];
+            if (!view.Active) {
+                UpdateActiveView(activeViewIndex);
+            }
+            return view;
+        }
+
+        // Used to wizard to disable bubble events on MultiView.
+        internal void IgnoreBubbleEvents() {
+            _ignoreBubbleEvents = true;
+        }
+
+        private void UpdateActiveView(int activeViewIndex) {
+            for (int i=0; i<Views.Count; ++i) {
+                View view = Views[i];
+                if (i == activeViewIndex) {
+                    view.Active = true;
+                    if (ShouldTriggerViewEvent) {
+                        view.OnActivate(EventArgs.Empty);
+                    }
+                    continue;
+                }
+
+                if (view.Active) {
+                    // There will be at most one other active view
+                    view.Active = false;
+                    if (ShouldTriggerViewEvent) {
+                        view.OnDeactivate(EventArgs.Empty);
+                    }
+                }
+            }
+        }
+
+
+        /// <devdoc>
+        /// <para>Loads the control state.</para>
+        /// </devdoc>
+        protected internal override void LoadControlState(object state) {
+            Pair p = state as Pair;
+            if (p != null) {
+                base.LoadControlState(p.First);
+                ActiveViewIndex = (int) p.Second;
+            }
+
+            _controlStateApplied = true;
+        }
+
+
+        /// <devdoc>
+        /// <para>Raises the <see langword='ActiveViewChanged '/>event.</para>
+        /// </devdoc>
+        protected virtual void OnActiveViewChanged(EventArgs e) {
+            EventHandler handler = (EventHandler)Events[_eventActiveViewChanged];
+            if (handler != null) {
+                handler(this, e);
+            }
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        ///    Overridden to handle navigation between child views.
+        /// </devdoc>
+        protected override bool OnBubbleEvent(object source, EventArgs e) {
+            if (_ignoreBubbleEvents) {
+                return false;
+            }
+
+            if (e is CommandEventArgs) {
+                CommandEventArgs ce = (CommandEventArgs) e;
+                string cn = ce.CommandName;
+                if (cn ==  NextViewCommandName) {
+                    if (ActiveViewIndex < Views.Count - 1) {
+                       ActiveViewIndex = ActiveViewIndex + 1;
+                    }
+                    else {
+                        ActiveViewIndex = - 1;
+                    }
+                    return true;
+                }
+                else if (cn == PreviousViewCommandName) {
+                    if (ActiveViewIndex > -1 ) {
+                        ActiveViewIndex = ActiveViewIndex - 1;
+                    }
+                    return true;
+                }
+                else if (cn == SwitchViewByIDCommandName) {
+                    View view = FindControl((string)ce.CommandArgument) as View;
+                    if (view != null && view.Parent == this) {
+                        SetActiveView(view);
+                        return true;
+                    }
+                    else {
+                        throw new HttpException(SR.GetString(SR.MultiView_invalid_view_id, ID,
+                            (string)ce.CommandArgument, SwitchViewByIDCommandName));
+                    }
+                }
+                else if (cn == SwitchViewByIndexCommandName) {
+                    int index;
+                    try {
+                        index = Int32.Parse((string)ce.CommandArgument, CultureInfo.InvariantCulture);
+                    }
+                    catch (FormatException) {
+                        throw new FormatException(SR.GetString(SR.MultiView_invalid_view_index_format,
+                            (string)ce.CommandArgument, SwitchViewByIndexCommandName));
+                    }
+                    ActiveViewIndex = index;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        ///    Overridden to handle navigation between child views.
+        /// </devdoc>
+        protected internal override void OnInit(EventArgs e) {
+            base.OnInit(e);
+
+            Page.RegisterRequiresControlState(this);
+
+            if (_cachedActiveViewIndex > -1) {
+                ActiveViewIndex = _cachedActiveViewIndex;
+                _cachedActiveViewIndex = -1;
+                GetActiveView();
+            }
+        }
+
+
+        protected internal override void RemovedControl(Control ctl) {
+            if (((View)ctl).Active && ActiveViewIndex < Views.Count) {
+                GetActiveView();
+            }
+            base.RemovedControl(ctl);
+        }
+
+
+        protected internal override void Render(HtmlTextWriter writer) {
+            View activeView = GetActiveView();
+            if (activeView != null) {
+                activeView.RenderControl(writer);
+            }
+        }
+
+
+        /// <devdoc>
+        /// <para>Saves the control state.</para>
+        /// </devdoc>
+        protected internal override object SaveControlState() {
+            int avi = ActiveViewIndex;
+            object obj = base.SaveControlState();
+            if (obj != null || avi != -1) {
+                return new Pair(obj, avi);
+            }
+            return null;
+        }
+
+
+        /// <devdoc>
+        /// <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void SetActiveView(View view) {
+            int index = Views.IndexOf (view);
+            if (index < 0) {
+                throw new HttpException(SR.GetString(SR.MultiView_view_not_found, (view == null ? "null" : view.ID), this.ID));
+            }
+            ActiveViewIndex = index;
+        }
+    }
+
+
+    /// <devdoc> [To be supplied.] </devdoc>
+    public class MultiViewControlBuilder : ControlBuilder {
+
+        public override void AppendSubBuilder(ControlBuilder subBuilder) {
+            if (subBuilder is CodeBlockBuilder) {
+                throw new Exception(SR.GetString(SR.Multiview_rendering_block_not_allowed));
+            }
+            base.AppendSubBuilder(subBuilder);
+        }
+    }
+
+
+
+    /// <devdoc> [To be supplied.] </devdoc>
+    public class ViewCollection : ControlCollection {
+
+
+        /// <devdoc> [To be supplied.] </devdoc>
+        public ViewCollection (Control owner) : base (owner) {}
+
+
+        /// <devdoc> [To be supplied.] </devdoc>
+        public override void Add(Control v) {
+            if (!(v is View)) {
+                throw new ArgumentException(SR.GetString(SR.ViewCollection_must_contain_view));
+            }
+            base.Add(v);
+        }
+
+
+        /// <devdoc> [To be supplied.] </devdoc>
+        public override void AddAt(int index, Control v) {
+            if (!(v is View)) {
+                throw new ArgumentException(SR.GetString(SR.ViewCollection_must_contain_view));
+            }
+            base.AddAt(index, v);
+        }
+
+
+        /// <devdoc> [To be supplied.] </devdoc>
+        public new View this[int i] {
+            get {
+                return (View)base[i];
+            }
+        }
+    }
+}