413 lines
14 KiB
C#
413 lines
14 KiB
C#
//------------------------------------------------------------------------------
|
|
// <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];
|
|
}
|
|
}
|
|
}
|
|
}
|