mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
222e5f55e18e935cf154b677923d47da5e3577dd
linux-packaging-mono/mcs/class/referencesource/System.Web/UI/WebParts/WebPartZoneBase.cs
Xamarin Public Jenkins (auto-signing) 536cd135cc Imported Upstream version 5.4.0.167 
Former-commit-id: 5624ac747d633e885131e8349322922b6a59baaa
2017-08-21 15:34:15 +00:00

1740 lines
66 KiB
C#
Raw Blame History

//------------------------------------------------------------------------------
// <copyright file="WebPartZoneBase.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI.WebControls.WebParts {
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Web.Security;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Util;
/// <devdoc>
/// Base class for all zone classes that host WebPart controls. Inherits from Zone, adding client-side
/// dragging, verbs, and additional styles. Zones that are database driven should inherit from
/// this class.
/// </devdoc>
[
Designer("System.Web.UI.Design.WebControls.WebParts.WebPartZoneBaseDesigner, " + AssemblyRef.SystemDesign),
]
public abstract class WebPartZoneBase : WebZone, IPostBackEventHandler, IWebPartMenuUser {
private static readonly object CreateVerbsEvent = new object();
internal const string EventArgumentSeparator = ":";
private const char eventArgumentSeparatorChar = ':';
private const string dragEventArgument = "Drag";
private const string partVerbEventArgument = "partverb";
private const string zoneVerbEventArgument = "zoneverb";
private const string closeEventArgument = "close";
private const string connectEventArgument = "connect";
private const string deleteEventArgument = "delete";
private const string editEventArgument = "edit";
private const string minimizeEventArgument = "minimize";
private const string restoreEventArgument = "restore";
// PERF: concat the event arg with the separator at compile-time
private const string partVerbEventArgumentWithSeparator = partVerbEventArgument + EventArgumentSeparator;
private const string zoneVerbEventArgumentWithSeparator = zoneVerbEventArgument + EventArgumentSeparator;
private const string connectEventArgumentWithSeparator = connectEventArgument + EventArgumentSeparator;
private const string editEventArgumentWithSeparator = editEventArgument + EventArgumentSeparator;
private const string minimizeEventArgumentWithSeparator = minimizeEventArgument + EventArgumentSeparator;
private const string restoreEventArgumentWithSeparator = restoreEventArgument + EventArgumentSeparator;
private const string closeEventArgumentWithSeparator = closeEventArgument + EventArgumentSeparator;
private const string deleteEventArgumentWithSeparator = deleteEventArgument + EventArgumentSeparator;
// Indexes into the ViewState array
private const int baseIndex = 0;
private const int selectedPartChromeStyleIndex = 1;
private const int closeVerbIndex = 2;
private const int connectVerbIndex = 3;
private const int deleteVerbIndex = 4;
private const int editVerbIndex = 5;
private const int helpVerbIndex = 6;
private const int minimizeVerbIndex = 7;
private const int restoreVerbIndex = 8;
private const int exportVerbIndex = 9;
private const int menuPopupStyleIndex = 10;
private const int menuLabelStyleIndex = 11;
private const int menuLabelHoverStyleIndex = 12;
private const int menuCheckImageStyleIndex = 13;
private const int menuVerbStyleIndex = 14;
private const int menuVerbHoverStyleIndex = 15;
private const int controlStyleIndex = 16;
private const int titleBarVerbStyleIndex = 17;
private const int viewStateArrayLength = 18;
private Style _selectedPartChromeStyle;
private WebPartVerb _closeVerb;
private WebPartVerb _connectVerb;
private WebPartVerb _deleteVerb;
private WebPartVerb _editVerb;
private WebPartVerb _exportVerb;
private WebPartVerb _helpVerb;
private WebPartVerb _minimizeVerb;
private WebPartVerb _restoreVerb;
private WebPartVerbCollection _verbs;
private WebPartMenuStyle _menuPopupStyle;
private Style _menuLabelStyle;
private Style _menuLabelHoverStyle;
private Style _menuCheckImageStyle;
private Style _menuVerbHoverStyle;
private Style _menuVerbStyle;
private Style _titleBarVerbStyle;
private Color _borderColor;
private BorderStyle _borderStyle;
private Unit _borderWidth;
private WebPartChrome _webPartChrome;
private WebPartMenu _menu;
[
DefaultValue(true),
Themeable(false),
WebCategory("Behavior"),
WebSysDescription(SR.WebPartZoneBase_AllowLayoutChange),
]
public virtual bool AllowLayoutChange {
get {
object b = ViewState["AllowLayoutChange"];
return (b != null) ? (bool)b : true;
}
set {
ViewState["AllowLayoutChange"] = value;
}
}
/// <devdoc>
/// Overridden to change default value.
/// </devdoc>
[
DefaultValue(typeof(Color), "Gray"),
]
public override Color BorderColor {
get {
if (ControlStyleCreated == false) {
return Color.Gray;
}
return base.BorderColor;
}
set {
base.BorderColor = value;
}
}
/// <devdoc>
/// Overridden to change default value.
/// </devdoc>
[
DefaultValue(BorderStyle.Solid)
]
public override BorderStyle BorderStyle {
get {
if (ControlStyleCreated == false) {
return BorderStyle.Solid;
}
return base.BorderStyle;
}
set {
base.BorderStyle = value;
}
}
/// <devdoc>
/// Overridden to change default value.
/// </devdoc>
[
DefaultValue(typeof(Unit), "1")
]
public override Unit BorderWidth {
get {
if (ControlStyleCreated == false) {
return 1;
}
return base.BorderWidth;
}
set {
base.BorderWidth = value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_CloseVerb),
]
public virtual WebPartVerb CloseVerb {
get {
if (_closeVerb == null) {
_closeVerb = new WebPartCloseVerb();
if (IsTrackingViewState) {
((IStateManager)_closeVerb).TrackViewState();
}
}
return _closeVerb;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_ConnectVerb),
]
public virtual WebPartVerb ConnectVerb {
get {
if (_connectVerb == null) {
_connectVerb = new WebPartConnectVerb();
if (IsTrackingViewState) {
((IStateManager)_connectVerb).TrackViewState();
}
}
return _connectVerb;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_DeleteVerb),
]
public virtual WebPartVerb DeleteVerb {
get {
if (_deleteVerb == null) {
_deleteVerb = new WebPartDeleteVerb();
if (IsTrackingViewState) {
((IStateManager)_deleteVerb).TrackViewState();
}
}
return _deleteVerb;
}
}
/// <devdoc>
/// The string displayed to identify the zone.
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public virtual string DisplayTitle {
get {
string title = HeaderText;
if (!String.IsNullOrEmpty(title)) {
return title;
}
string id = ID;
if (!String.IsNullOrEmpty(id)) {
return id;
}
// ID is required to be set by WebPartManager.RegisterZone but this is still a good fallback.
int index = 1;
if (WebPartManager != null) {
index = WebPartManager.Zones.IndexOf(this) + 1;
}
return SR.GetString(SR.WebPartZoneBase_DisplayTitleFallback,
index.ToString(CultureInfo.CurrentCulture));
}
}
protected internal bool DragDropEnabled {
get {
return (!DesignMode &&
RenderClientScript &&
AllowLayoutChange &&
WebPartManager != null &&
WebPartManager.DisplayMode.AllowPageDesign);
}
}
[
DefaultValue(typeof(Color), "Blue"),
TypeConverterAttribute(typeof(WebColorConverter)),
WebCategory("Appearance"),
WebSysDescription(SR.WebPartZoneBase_DragHighlightColor),
]
public virtual Color DragHighlightColor {
get {
object o = ViewState["DragHighlightColor"];
if (o != null) {
Color c = (Color)o;
if (c.IsEmpty == false) {
return c;
}
}
return Color.Blue;
}
set {
ViewState["DragHighlightColor"] = value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_EditVerb),
]
public virtual WebPartVerb EditVerb {
get {
if (_editVerb == null) {
_editVerb = new WebPartEditVerb();
if (IsTrackingViewState) {
((IStateManager)_editVerb).TrackViewState();
}
}
return _editVerb;
}
}
[
WebSysDefaultValue(SR.WebPartZoneBase_DefaultEmptyZoneText)
]
public override string EmptyZoneText {
// Must look at viewstate directly instead of the property in the base class,
// so we can distinguish between an unset property and a property set to String.Empty.
get {
string s = (string)ViewState["EmptyZoneText"];
return((s == null) ? SR.GetString(SR.WebPartZoneBase_DefaultEmptyZoneText) : s);
}
set {
ViewState["EmptyZoneText"] = value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_ExportVerb),
]
public virtual WebPartVerb ExportVerb {
get {
if (_exportVerb == null) {
_exportVerb = new WebPartExportVerb();
if (IsTrackingViewState) {
((IStateManager)_exportVerb).TrackViewState();
}
}
return _exportVerb;
}
}
protected override bool HasFooter {
get {
return false;
}
}
protected override bool HasHeader {
get {
bool hasHeader = false;
if (DesignMode) {
hasHeader = true;
}
else if (WebPartManager != null) {
hasHeader = WebPartManager.DisplayMode.AllowPageDesign;
}
return hasHeader;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_HelpVerb),
]
public virtual WebPartVerb HelpVerb {
get {
if (_helpVerb == null) {
_helpVerb = new WebPartHelpVerb();
if (IsTrackingViewState) {
((IStateManager)_helpVerb).TrackViewState();
}
}
return _helpVerb;
}
}
internal WebPartMenu Menu {
get {
if (_menu == null) {
_menu = new WebPartMenu(this);
}
return _menu;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_MenuCheckImageStyle)
]
public Style MenuCheckImageStyle {
get {
if (_menuCheckImageStyle == null) {
_menuCheckImageStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_menuCheckImageStyle).TrackViewState();
}
}
return _menuCheckImageStyle;
}
}
/// <devdoc>
/// </devdoc>
[
DefaultValue(""),
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
UrlProperty(),
WebCategory("Appearance"),
WebSysDescription(SR.WebPartZoneBase_MenuCheckImageUrl)
]
public virtual string MenuCheckImageUrl {
get {
string s = (string)ViewState["MenuCheckImageUrl"];
return ((s == null) ? String.Empty : s);
}
set {
ViewState["MenuCheckImageUrl"] = value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_MenuLabelHoverStyle)
]
public Style MenuLabelHoverStyle {
get {
if (_menuLabelHoverStyle == null) {
_menuLabelHoverStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_menuLabelHoverStyle).TrackViewState();
}
}
return _menuLabelHoverStyle;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_MenuLabelStyle)
]
public Style MenuLabelStyle {
get {
if (_menuLabelStyle == null) {
_menuLabelStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_menuLabelStyle).TrackViewState();
}
}
return _menuLabelStyle;
}
}
[
DefaultValue(""),
Localizable(true),
WebCategory("Appearance"),
WebSysDescription(SR.WebPartZoneBase_MenuLabelText)
]
public virtual string MenuLabelText {
get {
string s = (string)ViewState["MenuLabelText"];
return ((s == null) ? String.Empty : s);
}
set {
ViewState["MenuLabelText"] = value;
}
}
/// <devdoc>
/// </devdoc>
[
DefaultValue(""),
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
UrlProperty(),
WebCategory("Appearance"),
WebSysDescription(SR.WebPartZoneBase_MenuPopupImageUrl)
]
public virtual string MenuPopupImageUrl {
get {
string s = (string)ViewState["MenuPopupImageUrl"];
return ((s == null) ? String.Empty : s);
}
set {
ViewState["MenuPopupImageUrl"] = value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_MenuPopupStyle)
]
public WebPartMenuStyle MenuPopupStyle {
get {
if (_menuPopupStyle == null) {
_menuPopupStyle = new WebPartMenuStyle();
if (IsTrackingViewState) {
((IStateManager)_menuPopupStyle).TrackViewState();
}
}
return _menuPopupStyle;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_MenuVerbHoverStyle)
]
public Style MenuVerbHoverStyle {
get {
if (_menuVerbHoverStyle == null) {
_menuVerbHoverStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_menuVerbHoverStyle).TrackViewState();
}
}
return _menuVerbHoverStyle;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_MenuVerbStyle)
]
public Style MenuVerbStyle {
get {
if (_menuVerbStyle == null) {
_menuVerbStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_menuVerbStyle).TrackViewState();
}
}
return _menuVerbStyle;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_MinimizeVerb),
]
public virtual WebPartVerb MinimizeVerb {
get {
if (_minimizeVerb == null) {
_minimizeVerb = new WebPartMinimizeVerb();
if (IsTrackingViewState) {
((IStateManager)_minimizeVerb).TrackViewState();
}
}
return _minimizeVerb;
}
}
/// <devdoc>
/// The direction in which contained web parts are rendered.
/// </devdoc>
[
DefaultValue(Orientation.Vertical),
WebCategory("Layout"),
WebSysDescription(SR.WebPartZoneBase_LayoutOrientation),
]
public virtual Orientation LayoutOrientation {
get {
object o = ViewState["LayoutOrientation"];
return (o != null) ? (Orientation)(int)o : Orientation.Vertical;
}
set {
if ((value < Orientation.Horizontal) || (value > Orientation.Vertical)) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["LayoutOrientation"] = (int)value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Verbs"),
WebSysDescription(SR.WebPartZoneBase_RestoreVerb),
]
public virtual WebPartVerb RestoreVerb {
get {
if (_restoreVerb == null) {
_restoreVerb = new WebPartRestoreVerb();
if (IsTrackingViewState) {
((IStateManager)_restoreVerb).TrackViewState();
}
}
return _restoreVerb;
}
}
[
DefaultValue(null),
NotifyParentProperty(true),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("WebPart"),
WebSysDescription(SR.WebPartZoneBase_SelectedPartChromeStyle),
]
public Style SelectedPartChromeStyle {
get {
if (_selectedPartChromeStyle == null) {
_selectedPartChromeStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_selectedPartChromeStyle).TrackViewState();
}
}
return _selectedPartChromeStyle;
}
}
/// <devdoc>
/// Shows the icon image in the title bar of a part, if the TitleIconImageUrl is specified for a part.
/// </devdoc>
[
DefaultValue(true),
WebCategory("WebPart"),
WebSysDescription(SR.WebPartZoneBase_ShowTitleIcons),
]
public virtual bool ShowTitleIcons {
get {
object b = ViewState["ShowTitleIcons"];
return (b != null) ? (bool)b : true;
}
set {
ViewState["ShowTitleIcons"] = value;
}
}
[
DefaultValue(ButtonType.Image),
WebCategory("Appearance"),
WebSysDescription(SR.WebPartZoneBase_TitleBarVerbButtonType),
]
public virtual ButtonType TitleBarVerbButtonType {
get {
object obj = ViewState["TitleBarVerbButtonType"];
return (obj == null) ? ButtonType.Image : (ButtonType)obj;
}
set {
if (value < ButtonType.Button || value > ButtonType.Link) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["TitleBarVerbButtonType"] = value;
}
}
[
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
NotifyParentProperty(true),
PersistenceMode(PersistenceMode.InnerProperty),
WebCategory("Styles"),
WebSysDescription(SR.WebPartZoneBase_TitleBarVerbStyle)
]
public Style TitleBarVerbStyle {
get {
if (_titleBarVerbStyle == null) {
_titleBarVerbStyle = new Style();
if (IsTrackingViewState) {
((IStateManager)_titleBarVerbStyle).TrackViewState();
}
}
return _titleBarVerbStyle;
}
}
[
Browsable(false),
EditorBrowsable(EditorBrowsableState.Never),
Themeable(false)
]
public override ButtonType VerbButtonType {
get {
return base.VerbButtonType;
}
set {
base.VerbButtonType = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public WebPartChrome WebPartChrome {
get {
if (_webPartChrome == null) {
_webPartChrome = CreateWebPartChrome();
}
return _webPartChrome;
}
}
//
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public WebPartCollection WebParts {
get {
WebPartCollection webParts;
if (DesignMode) {
WebPart[] parts = new WebPart[Controls.Count];
Controls.CopyTo(parts, 0);
return new WebPartCollection(parts);
}
else {
if (WebPartManager != null) {
webParts = WebPartManager.GetWebPartsForZone(this);
}
else {
webParts = new WebPartCollection();
}
}
return webParts;
}
}
[
DefaultValue(WebPartVerbRenderMode.Menu),
WebCategory("WebPart"),
WebSysDescription(SR.WebPartZoneBase_WebPartVerbRenderMode)
]
public virtual WebPartVerbRenderMode WebPartVerbRenderMode {
get {
object o = ViewState["WebPartVerbRenderMode"];
return (o != null) ? (WebPartVerbRenderMode)(int)o : WebPartVerbRenderMode.Menu;
}
set {
if ((value < WebPartVerbRenderMode.Menu) || (value > WebPartVerbRenderMode.TitleBar)) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["WebPartVerbRenderMode"] = (int)value;
}
}
[
WebCategory("Action"),
WebSysDescription(SR.WebPartZoneBase_CreateVerbs)
]
public event WebPartVerbsEventHandler CreateVerbs {
add {
Events.AddHandler(CreateVerbsEvent, value);
}
remove {
Events.RemoveHandler(CreateVerbsEvent, value);
}
}
protected virtual void CloseWebPart(WebPart webPart) {
if (webPart == null) {
throw new ArgumentNullException("webPart");
}
if (WebPartManager != null && webPart.AllowClose && AllowLayoutChange) {
WebPartManager.CloseWebPart(webPart);
}
}
protected virtual void ConnectWebPart(WebPart webPart) {
if (webPart == null) {
throw new ArgumentNullException("webPart");
}
if (WebPartManager != null &&
WebPartManager.DisplayMode == WebPartManager.ConnectDisplayMode &&
webPart != WebPartManager.SelectedWebPart &&
webPart.AllowConnect) {
WebPartManager.BeginWebPartConnecting(webPart);
}
}
//
protected internal override void CreateChildControls() {
if (DesignMode) {
Controls.Clear();
WebPartCollection webParts = GetInitialWebParts();
foreach (WebPart part in webParts) {
Controls.Add(part);
}
}
}
/// <internalonly/>
protected override ControlCollection CreateControlCollection() {
if (DesignMode) {
return new ControlCollection(this);
}
else {
return new EmptyControlCollection(this);
}
}
protected override Style CreateControlStyle() {
// We need the ControlStyle to use its own StateBag, since we do not want the
// default values we set here to be saved in ViewState.
Style style = new Style();
style.BorderColor = Color.Gray;
style.BorderStyle = BorderStyle.Solid;
style.BorderWidth = 1;
return style;
}
/// <devdoc>
/// Overridden by subclasses to use a different chrome when rendering the WebParts.
/// </devdoc>
protected virtual WebPartChrome CreateWebPartChrome() {
return new WebPartChrome(this, WebPartManager);
}
protected virtual void DeleteWebPart(WebPart webPart) {
if (webPart == null) {
throw new ArgumentNullException("webPart");
}
if (WebPartManager != null && AllowLayoutChange) {
WebPartManager.DeleteWebPart(webPart);
}
}
protected virtual void EditWebPart(WebPart webPart) {
if (webPart == null) {
throw new ArgumentNullException("webPart");
}
if (WebPartManager != null &&
WebPartManager.DisplayMode == WebPartManager.EditDisplayMode &&
webPart != WebPartManager.SelectedWebPart) {
WebPartManager.BeginWebPartEditing(webPart);
}
}
/// <devdoc>
/// The effective frame type of a part, taking into consideration the PartChromeType
/// of the zone and the DisplayMode of the page.
/// </devdoc>
public override PartChromeType GetEffectiveChromeType(Part part) {
PartChromeType chromeType = base.GetEffectiveChromeType(part);
// Add title to chromeType if we are in page design mode. We always want
// to render a title bar when in page design mode. (VSWhidbey 77730)
if ((WebPartManager != null) && (WebPartManager.DisplayMode.AllowPageDesign)) {
if (chromeType == PartChromeType.None) {
chromeType = PartChromeType.TitleOnly;
}
else if (chromeType == PartChromeType.BorderOnly) {
chromeType = PartChromeType.TitleAndBorder;
}
}
return chromeType;
}
/// <devdoc>
/// Loads the initial web parts from a template, persistence medium, or some other way.
/// These parts may be in a different zone when rendered, since control personalization
/// may change their zone.
/// </devdoc>
protected internal abstract WebPartCollection GetInitialWebParts();
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[baseIndex]);
if (myState[selectedPartChromeStyleIndex] != null) {
((IStateManager) SelectedPartChromeStyle).LoadViewState(myState[selectedPartChromeStyleIndex]);
}
if (myState[closeVerbIndex] != null) {
((IStateManager) CloseVerb).LoadViewState(myState[closeVerbIndex]);
}
if (myState[connectVerbIndex] != null) {
((IStateManager) ConnectVerb).LoadViewState(myState[connectVerbIndex]);
}
if (myState[deleteVerbIndex] != null) {
((IStateManager) DeleteVerb).LoadViewState(myState[deleteVerbIndex]);
}
if (myState[editVerbIndex] != null) {
((IStateManager) EditVerb).LoadViewState(myState[editVerbIndex]);
}
if (myState[helpVerbIndex] != null) {
((IStateManager) HelpVerb).LoadViewState(myState[helpVerbIndex]);
}
if (myState[minimizeVerbIndex] != null) {
((IStateManager) MinimizeVerb).LoadViewState(myState[minimizeVerbIndex]);
}
if (myState[restoreVerbIndex] != null) {
((IStateManager) RestoreVerb).LoadViewState(myState[restoreVerbIndex]);
}
if (myState[exportVerbIndex] != null) {
((IStateManager) ExportVerb).LoadViewState(myState[exportVerbIndex]);
}
if (myState[menuPopupStyleIndex] != null) {
((IStateManager) MenuPopupStyle).LoadViewState(myState[menuPopupStyleIndex]);
}
if (myState[menuLabelStyleIndex] != null) {
((IStateManager) MenuLabelStyle).LoadViewState(myState[menuLabelStyleIndex]);
}
if (myState[menuLabelHoverStyleIndex] != null) {
((IStateManager) MenuLabelHoverStyle).LoadViewState(myState[menuLabelHoverStyleIndex]);
}
if (myState[menuCheckImageStyleIndex] != null) {
((IStateManager) MenuCheckImageStyle).LoadViewState(myState[menuCheckImageStyleIndex]);
}
if (myState[menuVerbStyleIndex] != null) {
((IStateManager) MenuVerbStyle).LoadViewState(myState[menuVerbStyleIndex]);
}
if (myState[menuVerbHoverStyleIndex] != null) {
((IStateManager) MenuVerbHoverStyle).LoadViewState(myState[menuVerbHoverStyleIndex]);
}
if (myState[controlStyleIndex] != null) {
((IStateManager) ControlStyle).LoadViewState(myState[controlStyleIndex]);
}
if (myState[titleBarVerbStyleIndex] != null) {
((IStateManager) TitleBarVerbStyle).LoadViewState(myState[titleBarVerbStyleIndex]);
}
}
}
/// <devdoc>
/// Load the verbs defined by the page developer or zone subclass.
/// </devdoc>
private void CreateZoneVerbs() {
WebPartVerbsEventArgs args = new WebPartVerbsEventArgs();
OnCreateVerbs(args);
_verbs = args.Verbs;
}
private bool IsDefaultVerbEvent(string[] eventArguments) {
return (eventArguments.Length == 2);
}
private bool IsDragEvent(string[] eventArguments) {
return (eventArguments.Length == 3 &&
String.Equals(eventArguments[0], dragEventArgument, StringComparison.OrdinalIgnoreCase));
}
private bool IsPartVerbEvent(string[] eventArguments) {
return (eventArguments.Length == 3 &&
String.Equals(eventArguments[0], partVerbEventArgument, StringComparison.OrdinalIgnoreCase));
}
private bool IsZoneVerbEvent(string[] eventArguments) {
return (eventArguments.Length == 3 &&
String.Equals(eventArguments[0], zoneVerbEventArgument, StringComparison.OrdinalIgnoreCase));
}
protected virtual void MinimizeWebPart(WebPart webPart) {
if (webPart == null) {
throw new ArgumentNullException("webPart");
}
if (webPart.ChromeState == PartChromeState.Normal &&
webPart.AllowMinimize &&
AllowLayoutChange) {
webPart.ChromeState = PartChromeState.Minimized;
}
}
protected virtual void OnCreateVerbs(WebPartVerbsEventArgs e) {
WebPartVerbsEventHandler handler = (WebPartVerbsEventHandler)Events[CreateVerbsEvent];
if (handler != null) {
handler(this, e);
}
}
protected internal override void OnPreRender(EventArgs e) {
base.OnPreRender(e);
// The zone verbs may have been loaded in RaisePostBackEvent, but we must load
// them again in case the page developer wants to change the verbs at this time.
CreateZoneVerbs();
WebPartChrome.PerformPreRender();
//
}
protected virtual void RaisePostBackEvent(string eventArgument) {
if (String.IsNullOrEmpty(eventArgument)) {
return;
}
string[] eventArguments = eventArgument.Split(eventArgumentSeparatorChar);
// We do not register all the possible combinations of drag/drop events because there are
// too many combinations. So we must not validate them either. VSWhidbey 492706
if (!IsDragEvent(eventArguments)) {
ValidateEvent(UniqueID, eventArgument);
}
if (WebPartManager == null) {
return;
}
// Look in collection of all WebParts instead of WebParts for this zone, since
// an admin may have moved the part to a different Zone between postbacks.
WebPartCollection allWebParts = WebPartManager.WebParts;
if (IsDefaultVerbEvent(eventArguments)) {
// Postback from a default verb
string verbEventArgument = eventArguments[0];
string partID = eventArguments[1];
WebPart part = allWebParts[partID];
// Part will be null or closed if the part was present on the previous request,
// but is missing or closed now. It may have been deleted or closed by the admin
// or filtered by roles.
if (part != null && !part.IsClosed) {
if (String.Equals(verbEventArgument, closeEventArgument, StringComparison.OrdinalIgnoreCase)) {
if (CloseVerb.Visible && CloseVerb.Enabled) {
CloseWebPart(part);
}
}
else if (String.Equals(verbEventArgument, connectEventArgument, StringComparison.OrdinalIgnoreCase)) {
if (ConnectVerb.Visible && ConnectVerb.Enabled) {
ConnectWebPart(part);
}
}
else if (String.Equals(verbEventArgument, deleteEventArgument, StringComparison.OrdinalIgnoreCase)) {
if (DeleteVerb.Visible && DeleteVerb.Enabled) {
DeleteWebPart(part);
}
}
else if (String.Equals(verbEventArgument, editEventArgument, StringComparison.OrdinalIgnoreCase)) {
if (EditVerb.Visible && EditVerb.Enabled) {
EditWebPart(part);
}
}
else if (String.Equals(verbEventArgument, minimizeEventArgument, StringComparison.OrdinalIgnoreCase)) {
if (MinimizeVerb.Visible && MinimizeVerb.Enabled) {
MinimizeWebPart(part);
}
}
else if (String.Equals(verbEventArgument, restoreEventArgument, StringComparison.OrdinalIgnoreCase)) {
if (RestoreVerb.Visible && RestoreVerb.Enabled) {
RestoreWebPart(part);
}
}
}
}
else if (IsDragEvent(eventArguments)) {
// Postback from a drop event
// The eventArgument contains the WholePartID instead of just ID, since we
// render WholePartID on the table containing the whole part.
string wholePartID = eventArguments[1];
string partID = null;
if (wholePartID.StartsWith(WebPart.WholePartIDPrefix, StringComparison.Ordinal)) {
partID = wholePartID.Substring(WebPart.WholePartIDPrefix.Length);
}
int dropPartIndex = Int32.Parse(eventArguments[2], CultureInfo.InvariantCulture);
WebPart actionPart = allWebParts[partID];
// Part will be null or closed if the part was present on the previous request,
// but is missing or closed now. It may have been deleted or closed by the admin
// or filtered by roles.
if (actionPart != null && !actionPart.IsClosed) {
// If dragged part to larger index in its current zone, correct drop index
// by subtracting 1. Otherwise the part will move 1 position farther than desired.
if (WebParts.Contains(actionPart) && (actionPart.ZoneIndex < dropPartIndex)) {
dropPartIndex--;
}
WebPartZoneBase fromZone = actionPart.Zone;
if (AllowLayoutChange &&
WebPartManager.DisplayMode.AllowPageDesign &&
fromZone != null &&
fromZone.AllowLayoutChange &&
(actionPart.AllowZoneChange || (fromZone == this))) {
WebPartManager.MoveWebPart(actionPart, this, dropPartIndex);
}
}
}
else if (IsPartVerbEvent(eventArguments)) {
// Postback from a part verb
string verbID = eventArguments[1];
string partID = eventArguments[2];
WebPart part = allWebParts[partID];
// Part will be null or closed if the part was present on the previous request,
// but is missing or closed now. It may have been deleted or closed by the admin
// or filtered by roles.
if (part != null && !part.IsClosed) {
WebPartVerb verb = part.Verbs[verbID];
if (verb != null && verb.Visible && verb.Enabled) {
verb.ServerClickHandler(verb, new WebPartEventArgs(part));
}
}
}
else if (IsZoneVerbEvent(eventArguments)) {
// Postback from a zone verb
CreateZoneVerbs();
string verbID = eventArguments[1];
string partID = eventArguments[2];
WebPart part = allWebParts[partID];
// Part will be null or closed if the part was present on the previous request,
// but is missing or closed now. It may have been deleted or closed by the admin
// or filtered by roles.
if (part != null && !part.IsClosed) {
WebPartVerb verb = _verbs[verbID];
if (verb != null && verb.Visible && verb.Enabled) {
verb.ServerClickHandler(verb, new WebPartEventArgs(part));
}
}
}
}
protected internal override void Render(HtmlTextWriter writer) {
if (Page != null) {
Page.VerifyRenderingInServerForm(this);
}
_borderColor = BorderColor;
_borderStyle = BorderStyle;
_borderWidth = BorderWidth;
// PERF: If the control style has not been created, we don't need to set these values,
// since no style properties will be rendered
if (ControlStyleCreated) {
BorderColor = Color.Empty;
BorderStyle = BorderStyle.NotSet;
BorderWidth = Unit.Empty;
}
base.Render(writer);
if (ControlStyleCreated) {
BorderColor = _borderColor;
BorderStyle = _borderStyle;
BorderWidth = _borderWidth;
}
}
protected override void RenderBody(HtmlTextWriter writer) {
Orientation orientation = LayoutOrientation;
if (DesignMode || (WebPartManager != null && (WebPartManager.DisplayMode.AllowPageDesign))) {
if (_borderColor != Color.Empty || _borderStyle != BorderStyle.NotSet || _borderWidth != Unit.Empty) {
Style s = new Style();
s.BorderColor = _borderColor;
s.BorderStyle = _borderStyle;
s.BorderWidth = _borderWidth;
s.AddAttributesToRender(writer, this);
}
}
RenderBodyTableBeginTag(writer);
if (DesignMode) {
RenderDesignerRegionBeginTag(writer, orientation);
}
if (orientation == Orientation.Horizontal) {
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
}
bool dragDropEnabled = DragDropEnabled;
if (dragDropEnabled) {
RenderDropCue(writer);
}
WebPartCollection webParts = WebParts;
if (webParts == null || webParts.Count == 0) {
RenderEmptyZoneBody(writer);
}
else {
WebPartChrome chrome = WebPartChrome;
foreach (WebPart webPart in webParts) {
// Don't render anything visible for a minimized part if its effective frame
// type dictates that a title bar will not be rendered. (VSWhidbey 77730)
if (webPart.ChromeState == PartChromeState.Minimized) {
PartChromeType chromeType = GetEffectiveChromeType(webPart);
if (chromeType == PartChromeType.None || chromeType == PartChromeType.BorderOnly) {
writer.AddStyleAttribute(HtmlTextWriterStyle.Display, "none");
}
}
if (orientation == Orientation.Vertical) {
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
}
else {
// Mac IE needs height=100% set on <td> instead of <tr>
writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");
writer.AddAttribute(HtmlTextWriterAttribute.Valign, "top");
}
writer.RenderBeginTag(HtmlTextWriterTag.Td);
chrome.RenderWebPart(writer, webPart);
writer.RenderEndTag(); // Td
if (orientation == Orientation.Vertical) {
writer.RenderEndTag(); // Tr
}
if (dragDropEnabled) {
RenderDropCue(writer);
}
}
if (orientation == Orientation.Vertical) {
// Add an extra row with height of 100%, to Microsoft up any extra space
// if the height of the zone is larger than its contents
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
// Mozilla renders padding on an empty TD without this attribute
writer.AddStyleAttribute(HtmlTextWriterStyle.Padding, "0");
// Mac IE needs height=100% set on <td> instead of <tr>
writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");
writer.RenderBeginTag(HtmlTextWriterTag.Td);
writer.RenderEndTag(); // Td
writer.RenderEndTag(); // Tr
}
else {
// Add an extra cell with width of 100%, to Microsoft up any extra space
// if the width of the zone is larger than its contents.
writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");
// Mozilla renders padding on an empty TD without this attribute
writer.AddStyleAttribute(HtmlTextWriterStyle.Padding, "0");
writer.RenderBeginTag(HtmlTextWriterTag.Td);
writer.RenderEndTag(); // Td
}
}
if (orientation == Orientation.Horizontal) {
writer.RenderEndTag(); // Tr
}
if (DesignMode) {
RenderDesignerRegionEndTag(writer);
}
RenderBodyTableEndTag(writer);
}
protected virtual void RenderDropCue(HtmlTextWriter writer) {
if (LayoutOrientation == Orientation.Vertical) {
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
writer.AddStyleAttribute(HtmlTextWriterStyle.PaddingTop, "1");
writer.AddStyleAttribute(HtmlTextWriterStyle.PaddingBottom, "1");
writer.RenderBeginTag(HtmlTextWriterTag.Td);
RenderDropCueIBar(writer, Orientation.Horizontal);
writer.RenderEndTag(); // Td
writer.RenderEndTag(); // Tr
}
else {
writer.AddStyleAttribute(HtmlTextWriterStyle.PaddingLeft, "1");
writer.AddStyleAttribute(HtmlTextWriterStyle.PaddingRight, "1");
writer.RenderBeginTag(HtmlTextWriterTag.Td);
RenderDropCueIBar(writer, Orientation.Vertical);
writer.RenderEndTag(); // Td
}
}
private void RenderDropCueIBar(HtmlTextWriter writer, Orientation orientation) {
// 10px is the total margin and border width that we have to substract
// (2*2px for the margin, 2*3px for the border)
// Places to touch if we want to change the rendering of the cues:
// WebParts.js (Zone_ToggleDropCues)
// WebPartZoneBase.RenderDropCueIBar
string color = ColorTranslator.ToHtml(DragHighlightColor);
string border = "solid 3px " + color;
writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
writer.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
writer.AddAttribute(HtmlTextWriterAttribute.Border, "0");
if (orientation == Orientation.Horizontal) {
writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");
writer.AddStyleAttribute("border-left", border);
writer.AddStyleAttribute("border-right", border);
}
else {
writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");
writer.AddStyleAttribute("border-top", border);
writer.AddStyleAttribute("border-bottom", border);
}
writer.AddStyleAttribute(HtmlTextWriterStyle.Visibility, "hidden");
writer.RenderBeginTag(HtmlTextWriterTag.Table);
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
if (orientation == Orientation.Vertical) {
writer.AddAttribute(HtmlTextWriterAttribute.Align, "center");
}
writer.AddStyleAttribute(HtmlTextWriterStyle.FontSize, "0px");
writer.RenderBeginTag(HtmlTextWriterTag.Td);
if (orientation == Orientation.Horizontal) {
writer.AddStyleAttribute(HtmlTextWriterStyle.Margin, "2px 0px 2px 0px");
writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "2px");
writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");
}
else {
writer.AddStyleAttribute(HtmlTextWriterStyle.Margin, "0px 2px 0px 2px");
writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "2px");
writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");
}
writer.AddStyleAttribute(HtmlTextWriterStyle.BackgroundColor, color);
writer.RenderBeginTag(HtmlTextWriterTag.Div);
writer.RenderEndTag(); // Div
writer.RenderEndTag(); // Td
writer.RenderEndTag(); // Tr
writer.RenderEndTag(); // Table
}
private void RenderEmptyZoneBody(HtmlTextWriter writer) {
bool vertical = (LayoutOrientation == Orientation.Vertical);
bool horizontal = !vertical;
string emptyZoneText = EmptyZoneText;
bool renderText = (!DesignMode && AllowLayoutChange && WebPartManager != null &&
WebPartManager.DisplayMode.AllowPageDesign && !String.IsNullOrEmpty(emptyZoneText));
if (vertical) {
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
}
if (renderText) {
writer.AddAttribute(HtmlTextWriterAttribute.Valign, "top");
}
if (horizontal) {
// Want drop zone to shrink to size, so take up all width in zone
writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");
}
else {
// Want drop zone to shrink to size, so take up all height in zone
// Mac IE needs height=100% set on <td> instead of <tr>
writer.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");
}
writer.RenderBeginTag(HtmlTextWriterTag.Td);
if (renderText) {
Style emptyZoneTextStyle = EmptyZoneTextStyle;
if (!emptyZoneTextStyle.IsEmpty) {
emptyZoneTextStyle.AddAttributesToRender(writer, this);
}
writer.RenderBeginTag(HtmlTextWriterTag.Div);
writer.Write(emptyZoneText);
writer.RenderEndTag(); // Div
}
writer.RenderEndTag(); // Td
if (vertical) {
writer.RenderEndTag(); // Tr
}
if (renderText) {
if (DragDropEnabled) {
// This drop cue will never be activated since there are no web parts, but it
// reserves space below the text equal to the real drop cue above the text
RenderDropCue(writer);
}
}
}
protected override void RenderHeader(HtmlTextWriter writer) {
//
// Render title bar
writer.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
writer.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "2");
writer.AddAttribute(HtmlTextWriterAttribute.Border, "0");
writer.AddStyleAttribute(HtmlTextWriterStyle.Width, "100%");
TitleStyle headerStyle = HeaderStyle;
if (!headerStyle.IsEmpty) {
// Apply font and forecolor from HeaderStyle to inner table
Style style = new Style();
if (!headerStyle.ForeColor.IsEmpty) {
style.ForeColor = headerStyle.ForeColor;
}
style.Font.CopyFrom(headerStyle.Font);
if (!headerStyle.Font.Size.IsEmpty) {
// If the font size is specified on the HeaderStyle, force the font size to 100%,
// so it inherits the font size from its parent in IE compatibility mode. I would
// think that "1em" would work here as well, but "1em" doesn't work when you change
// the font size in the browser.
style.Font.Size = new FontUnit(new Unit(100, UnitType.Percentage));
}
if (!style.IsEmpty) {
style.AddAttributesToRender(writer, this);
}
}
writer.RenderBeginTag(HtmlTextWriterTag.Table);
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
// Copied from Panel.cs
//
HorizontalAlign hAlign = headerStyle.HorizontalAlign;
if (hAlign != HorizontalAlign.NotSet) {
TypeConverter hac = TypeDescriptor.GetConverter(typeof(HorizontalAlign));
writer.AddAttribute(HtmlTextWriterAttribute.Align, hac.ConvertToString(hAlign));
}
writer.AddStyleAttribute(HtmlTextWriterStyle.WhiteSpace, "nowrap");
writer.RenderBeginTag(HtmlTextWriterTag.Td);
writer.Write(DisplayTitle);
writer.RenderEndTag(); // Td
writer.RenderEndTag(); // Tr
writer.RenderEndTag(); // Table
}
protected virtual void RestoreWebPart(WebPart webPart) {
if (webPart == null) {
throw new ArgumentNullException("webPart");
}
if ((webPart.ChromeState == PartChromeState.Minimized) && AllowLayoutChange) {
webPart.ChromeState = PartChromeState.Normal;
}
}
protected override object SaveViewState() {
object[] myState = new object[viewStateArrayLength];
myState[baseIndex] = base.SaveViewState();
myState[selectedPartChromeStyleIndex] = (_selectedPartChromeStyle != null) ? ((IStateManager)_selectedPartChromeStyle).SaveViewState() : null;
myState[closeVerbIndex] = (_closeVerb != null) ? ((IStateManager)_closeVerb).SaveViewState() : null;
myState[connectVerbIndex] = (_connectVerb != null) ? ((IStateManager)_connectVerb).SaveViewState() : null;
myState[deleteVerbIndex] = (_deleteVerb != null) ? ((IStateManager)_deleteVerb).SaveViewState() : null;
myState[editVerbIndex] = (_editVerb != null) ? ((IStateManager)_editVerb).SaveViewState() : null;
myState[helpVerbIndex] = (_helpVerb != null) ? ((IStateManager)_helpVerb).SaveViewState() : null;
myState[minimizeVerbIndex] = (_minimizeVerb != null) ? ((IStateManager)_minimizeVerb).SaveViewState() : null;
myState[restoreVerbIndex] = (_restoreVerb != null) ? ((IStateManager)_restoreVerb).SaveViewState() : null;
myState[exportVerbIndex] = (_exportVerb != null) ? ((IStateManager)_exportVerb).SaveViewState() : null;
myState[menuPopupStyleIndex] = (_menuPopupStyle != null) ? ((IStateManager)_menuPopupStyle).SaveViewState() : null;
myState[menuLabelStyleIndex] = (_menuLabelStyle != null) ? ((IStateManager)_menuLabelStyle).SaveViewState() : null;
myState[menuLabelHoverStyleIndex] = (_menuLabelHoverStyle != null) ? ((IStateManager)_menuLabelHoverStyle).SaveViewState() : null;
myState[menuCheckImageStyleIndex] = (_menuCheckImageStyle != null) ? ((IStateManager)_menuCheckImageStyle).SaveViewState() : null;
myState[menuVerbStyleIndex] = (_menuVerbStyle != null) ? ((IStateManager)_menuVerbStyle).SaveViewState() : null;
myState[menuVerbHoverStyleIndex] = (_menuVerbHoverStyle != null) ? ((IStateManager)_menuVerbHoverStyle).SaveViewState() : null;
myState[controlStyleIndex] = ControlStyleCreated ? ((IStateManager)ControlStyle).SaveViewState() : null;
myState[titleBarVerbStyleIndex] = (_titleBarVerbStyle != null) ? ((IStateManager)_titleBarVerbStyle).SaveViewState() : null;
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;
}
protected override void TrackViewState() {
base.TrackViewState();
if (_selectedPartChromeStyle != null) {
((IStateManager) _selectedPartChromeStyle).TrackViewState();
}
if (_closeVerb != null) {
((IStateManager) _closeVerb).TrackViewState();
}
if (_connectVerb != null) {
((IStateManager) _connectVerb).TrackViewState();
}
if (_deleteVerb != null) {
((IStateManager) _deleteVerb).TrackViewState();
}
if (_editVerb != null) {
((IStateManager) _editVerb).TrackViewState();
}
if (_helpVerb != null) {
((IStateManager) _helpVerb).TrackViewState();
}
if (_minimizeVerb != null) {
((IStateManager) _minimizeVerb).TrackViewState();
}
if (_restoreVerb != null) {
((IStateManager) _restoreVerb).TrackViewState();
}
if (_exportVerb != null) {
((IStateManager) _exportVerb).TrackViewState();
}
if (_menuPopupStyle != null) {
((IStateManager) _menuPopupStyle).TrackViewState();
}
if (_menuLabelStyle != null) {
((IStateManager) _menuLabelStyle).TrackViewState();
}
if (_menuLabelHoverStyle != null) {
((IStateManager) _menuLabelHoverStyle).TrackViewState();
}
if (_menuCheckImageStyle != null) {
((IStateManager) _menuCheckImageStyle).TrackViewState();
}
if (_menuVerbStyle != null) {
((IStateManager) _menuVerbStyle).TrackViewState();
}
if (_menuVerbHoverStyle != null) {
((IStateManager)_menuVerbHoverStyle).TrackViewState();
}
if (ControlStyleCreated) {
((IStateManager) ControlStyle).TrackViewState();
}
if (_titleBarVerbStyle != null) {
((IStateManager)_titleBarVerbStyle).TrackViewState();
}
}
// Called from WebPartChrome and DesignerWebPartChrome. Can't be passed as argument to
// RenderWebPart, since the WebPartZoneDesigner calls RenderWebPart as well.
internal WebPartVerbCollection VerbsForWebPart(WebPart webPart) {
WebPartVerbCollection verbs = new WebPartVerbCollection();
WebPartVerbCollection partVerbs = webPart.Verbs;
if (partVerbs != null) {
foreach (WebPartVerb verb in partVerbs) {
if (verb.ServerClickHandler != null) {
verb.SetEventArgumentPrefix(partVerbEventArgumentWithSeparator);
}
verbs.Add(verb);
}
}
if (_verbs != null) {
foreach (WebPartVerb verb in _verbs) {
if (verb.ServerClickHandler != null) {
verb.SetEventArgumentPrefix(zoneVerbEventArgumentWithSeparator);
}
verbs.Add(verb);
}
}
WebPartVerb minimizeVerb = MinimizeVerb;
minimizeVerb.SetEventArgumentPrefix(minimizeEventArgumentWithSeparator);
verbs.Add(minimizeVerb);
WebPartVerb restoreVerb = RestoreVerb;
restoreVerb.SetEventArgumentPrefix(restoreEventArgumentWithSeparator);
verbs.Add(restoreVerb);
WebPartVerb closeVerb = CloseVerb;
closeVerb.SetEventArgumentPrefix(closeEventArgumentWithSeparator);
verbs.Add(closeVerb);
WebPartVerb deleteVerb = DeleteVerb;
deleteVerb.SetEventArgumentPrefix(deleteEventArgumentWithSeparator);
verbs.Add(deleteVerb);
WebPartVerb editVerb = EditVerb;
editVerb.SetEventArgumentPrefix(editEventArgumentWithSeparator);
verbs.Add(editVerb);
WebPartVerb connectVerb = ConnectVerb;
connectVerb.SetEventArgumentPrefix(connectEventArgumentWithSeparator);
verbs.Add(connectVerb);
// Export does not post back
verbs.Add(ExportVerb);
// Help verb does not post back
verbs.Add(HelpVerb);
return verbs;
}
#region Implementation of IPostBackEventHandler
/// <internalonly/>
void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) {
RaisePostBackEvent(eventArgument);
}
#endregion
#region Implementation of IWebPartMenuUser
Style IWebPartMenuUser.CheckImageStyle {
get {
return _menuCheckImageStyle;
}
}
string IWebPartMenuUser.CheckImageUrl {
get {
string s = MenuCheckImageUrl;
if (!String.IsNullOrEmpty(s)) {
s = ResolveClientUrl(s);
}
return s;
}
}
string IWebPartMenuUser.ClientID {
get {
return ClientID;
}
}
string IWebPartMenuUser.PopupImageUrl {
get {
string s = MenuPopupImageUrl;
if (!String.IsNullOrEmpty(s)) {
s = ResolveClientUrl(s);
}
return s;
}
}
Style IWebPartMenuUser.ItemHoverStyle {
get {
return _menuVerbHoverStyle;
}
}
Style IWebPartMenuUser.ItemStyle {
get {
return _menuVerbStyle;
}
}
Style IWebPartMenuUser.LabelHoverStyle {
get {
return _menuLabelHoverStyle;
}
}
string IWebPartMenuUser.LabelImageUrl {
get {
return null;
}
}
Style IWebPartMenuUser.LabelStyle {
get {
return MenuLabelStyle;
}
}
string IWebPartMenuUser.LabelText {
get {
return MenuLabelText;
}
}
WebPartMenuStyle IWebPartMenuUser.MenuPopupStyle {
get {
return _menuPopupStyle;
}
}
Page IWebPartMenuUser.Page {
get {
return Page;
}
}
string IWebPartMenuUser.PostBackTarget {
get {
return UniqueID;
}
}
IUrlResolutionService IWebPartMenuUser.UrlResolver {
get {
return this;
}
}
void IWebPartMenuUser.OnBeginRender(HtmlTextWriter writer) {
}
void IWebPartMenuUser.OnEndRender(HtmlTextWriter writer) {
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink