879 lines
27 KiB
C#
879 lines
27 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="WebPart.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls.WebParts {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Globalization;
|
|
using System.Web;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
using System.Web.Util;
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Adds several features to the Part class, including connections, personalization behavior,
|
|
/// and additional UI properties.
|
|
/// </devdoc>
|
|
[
|
|
Designer("System.Web.UI.Design.WebControls.WebParts.WebPartDesigner, " + AssemblyRef.SystemDesign)
|
|
]
|
|
public abstract class WebPart : Part, IWebPart, IWebActionable, IWebEditable {
|
|
|
|
private WebPartManager _webPartManager;
|
|
|
|
private string _zoneID;
|
|
private int _zoneIndex;
|
|
private WebPartZoneBase _zone;
|
|
|
|
private bool _allowClose;
|
|
private bool _allowConnect;
|
|
private bool _allowEdit;
|
|
private bool _allowHide;
|
|
private bool _allowMinimize;
|
|
private bool _allowZoneChange;
|
|
private string _authorizationFilter;
|
|
private string _catalogIconImageUrl;
|
|
private PartChromeState _chromeState;
|
|
private string _connectErrorMessage;
|
|
private WebPartExportMode _exportMode;
|
|
private WebPartHelpMode _helpMode;
|
|
private string _helpUrl;
|
|
private bool _hidden;
|
|
private string _importErrorMessage;
|
|
private string _titleIconImageUrl;
|
|
private string _titleUrl;
|
|
|
|
private bool _hasUserData;
|
|
private bool _hasSharedData;
|
|
private bool _isClosed;
|
|
private bool _isShared;
|
|
private bool _isStandalone;
|
|
private bool _isStatic;
|
|
|
|
// Counter to detect circular connections
|
|
private Dictionary<ProviderConnectionPoint, int> _trackerCounter;
|
|
|
|
internal const string WholePartIDPrefix = "WebPart_";
|
|
private const string titleBarIDPrefix = "WebPartTitle_";
|
|
|
|
protected WebPart() {
|
|
_allowClose = true;
|
|
_allowConnect = true;
|
|
_allowEdit = true;
|
|
_allowHide = true;
|
|
_allowMinimize = true;
|
|
_allowZoneChange = true;
|
|
_chromeState = PartChromeState.Normal;
|
|
_exportMode = WebPartExportMode.None;
|
|
_helpMode = WebPartHelpMode.Navigate;
|
|
_isStatic = true;
|
|
_isStandalone = true;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Whether the user is allowed to close the web part
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AllowClose),
|
|
]
|
|
public virtual bool AllowClose {
|
|
get {
|
|
return _allowClose;
|
|
}
|
|
set {
|
|
_allowClose = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(true),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AllowConnect),
|
|
]
|
|
public virtual bool AllowConnect {
|
|
get {
|
|
return _allowConnect;
|
|
}
|
|
set {
|
|
_allowConnect = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// If false, then LayoutEditorPart is the only visible EditorPart. Custom EditorParts
|
|
/// may choose to be visible as well.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AllowEdit),
|
|
]
|
|
public virtual bool AllowEdit {
|
|
get {
|
|
return _allowEdit;
|
|
}
|
|
set {
|
|
_allowEdit = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AllowHide),
|
|
]
|
|
public virtual bool AllowHide {
|
|
get {
|
|
return _allowHide;
|
|
}
|
|
set {
|
|
_allowHide = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Whether the user is allowed to minimize the web part
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AllowMinimize),
|
|
]
|
|
public virtual bool AllowMinimize {
|
|
get {
|
|
return _allowMinimize;
|
|
}
|
|
set {
|
|
_allowMinimize = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Whether the user is allowed move the web part around the page
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AllowZoneChange),
|
|
]
|
|
public virtual bool AllowZoneChange {
|
|
get {
|
|
return _allowZoneChange;
|
|
}
|
|
set {
|
|
_allowZoneChange = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(""),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_AuthorizationFilter),
|
|
]
|
|
public virtual string AuthorizationFilter {
|
|
get {
|
|
return (_authorizationFilter != null) ? _authorizationFilter : String.Empty;
|
|
}
|
|
set {
|
|
_authorizationFilter = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty(),
|
|
WebCategory("WebPartAppearance"),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
WebSysDescription(SR.WebPart_CatalogIconImageUrl),
|
|
]
|
|
public virtual string CatalogIconImageUrl {
|
|
get {
|
|
return (_catalogIconImageUrl != null) ? _catalogIconImageUrl : String.Empty;
|
|
}
|
|
set {
|
|
if (CrossSiteScriptingValidation.IsDangerousUrl(value)) {
|
|
throw new ArgumentException(SR.GetString(SR.WebPart_BadUrl, value), "value");
|
|
}
|
|
_catalogIconImageUrl = value;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
// PERF: Use a field instead of calling base.ChromeState, since the base implementation uses
|
|
// viewstate.
|
|
[
|
|
Personalizable
|
|
]
|
|
public override PartChromeState ChromeState {
|
|
get {
|
|
return _chromeState;
|
|
}
|
|
set {
|
|
if ((value < PartChromeState.Normal) || (value > PartChromeState.Minimized)) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
|
|
_chromeState = value;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
[
|
|
Personalizable
|
|
]
|
|
public override PartChromeType ChromeType {
|
|
get {
|
|
return base.ChromeType;
|
|
}
|
|
set {
|
|
base.ChromeType = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public string ConnectErrorMessage {
|
|
get {
|
|
return (_connectErrorMessage != null) ? _connectErrorMessage : String.Empty;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
[
|
|
Personalizable(PersonalizationScope.Shared),
|
|
]
|
|
public override string Description {
|
|
get {
|
|
return base.Description;
|
|
}
|
|
set {
|
|
base.Description = value;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
[
|
|
Personalizable
|
|
]
|
|
public override ContentDirection Direction {
|
|
get {
|
|
return base.Direction;
|
|
}
|
|
set {
|
|
base.Direction = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public string DisplayTitle {
|
|
get {
|
|
if (_webPartManager != null) {
|
|
return _webPartManager.GetDisplayTitle(this);
|
|
}
|
|
else {
|
|
// Needed for a WebPart in a DeclarativeCatalogPart, or any case where WebPartManager
|
|
// has not been set.
|
|
string displayTitle = Title;
|
|
if (String.IsNullOrEmpty(displayTitle)) {
|
|
displayTitle = SR.GetString(SR.Part_Untitled);
|
|
}
|
|
return displayTitle;
|
|
}
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(WebPartExportMode.None),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_ExportMode),
|
|
]
|
|
public virtual WebPartExportMode ExportMode {
|
|
get {
|
|
return _exportMode;
|
|
}
|
|
set {
|
|
if (ControlState >= ControlState.Loaded &&
|
|
(WebPartManager == null ||
|
|
(WebPartManager.Personalization.Scope == PersonalizationScope.User && IsShared))) {
|
|
throw new InvalidOperationException(SR.GetString(SR.WebPart_CantSetExportMode));
|
|
}
|
|
if (value < WebPartExportMode.None || value > WebPartExportMode.NonSensitiveData) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
_exportMode = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool HasUserData {
|
|
get {
|
|
return _hasUserData;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool HasSharedData {
|
|
get {
|
|
return _hasSharedData;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
[
|
|
Personalizable
|
|
]
|
|
public override Unit Height {
|
|
get {
|
|
return base.Height;
|
|
}
|
|
set {
|
|
base.Height = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The type of help UI used to display the help topic
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(WebPartHelpMode.Navigate),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_HelpMode),
|
|
]
|
|
public virtual WebPartHelpMode HelpMode {
|
|
get {
|
|
return _helpMode;
|
|
}
|
|
set {
|
|
if ((value < WebPartHelpMode.Modal) || (value > WebPartHelpMode.Navigate)) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
_helpMode = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The URL of the web part's associated help topic
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty(),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_HelpUrl),
|
|
]
|
|
public virtual string HelpUrl {
|
|
get {
|
|
return (_helpUrl != null) ? _helpUrl : String.Empty;
|
|
}
|
|
set {
|
|
if (CrossSiteScriptingValidation.IsDangerousUrl(value)) {
|
|
throw new ArgumentException(SR.GetString(SR.WebPart_BadUrl, value), "value");
|
|
}
|
|
_helpUrl = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Whether the web part is to be visually displayed or not.
|
|
/// A web part with Hidden set to true still participates in various
|
|
/// page lifecycle phases such as PreRender.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
Personalizable,
|
|
Themeable(false),
|
|
WebCategory("WebPartAppearance"),
|
|
WebSysDescription(SR.WebPart_Hidden),
|
|
]
|
|
public virtual bool Hidden {
|
|
get {
|
|
return _hidden;
|
|
}
|
|
set {
|
|
_hidden = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool IsClosed {
|
|
get {
|
|
return _isClosed;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// An "orphaned" part has no Zone, but has not been moved to the page catalog yet.
|
|
/// </devdoc>
|
|
internal bool IsOrphaned {
|
|
get {
|
|
return (Zone == null && !IsClosed);
|
|
}
|
|
}
|
|
|
|
[
|
|
Localizable(true),
|
|
WebCategory("WebPartAppearance"),
|
|
WebSysDefaultValue(SR.WebPart_DefaultImportErrorMessage),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
WebSysDescription(SR.WebPart_ImportErrorMessage),
|
|
]
|
|
public virtual string ImportErrorMessage {
|
|
get {
|
|
return (_importErrorMessage != null) ?
|
|
_importErrorMessage : SR.GetString(SR.WebPart_DefaultImportErrorMessage);
|
|
}
|
|
set {
|
|
_importErrorMessage = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool IsShared {
|
|
get {
|
|
return _isShared;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool IsStandalone {
|
|
get {
|
|
return _isStandalone;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public bool IsStatic {
|
|
get {
|
|
return _isStatic;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
Localizable(true),
|
|
]
|
|
public virtual string Subtitle {
|
|
get {
|
|
return String.Empty;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
[
|
|
Personalizable,
|
|
]
|
|
public override string Title {
|
|
get {
|
|
return base.Title;
|
|
}
|
|
set {
|
|
base.Title = value;
|
|
}
|
|
}
|
|
|
|
// ID rendered on the title bar of the WebPart, so a mouse listener can be attached
|
|
// for drag and drop.
|
|
internal string TitleBarID {
|
|
get {
|
|
return titleBarIDPrefix + ID;
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.ImageUrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty(),
|
|
WebCategory("WebPartAppearance"),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
WebSysDescription(SR.WebPart_TitleIconImageUrl),
|
|
]
|
|
public virtual string TitleIconImageUrl {
|
|
get {
|
|
return (_titleIconImageUrl != null) ? _titleIconImageUrl : String.Empty;
|
|
}
|
|
set {
|
|
if (CrossSiteScriptingValidation.IsDangerousUrl(value)) {
|
|
throw new ArgumentException(SR.GetString(SR.WebPart_BadUrl, value), "value");
|
|
}
|
|
_titleIconImageUrl = value;
|
|
}
|
|
}
|
|
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.UrlEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
UrlProperty(),
|
|
Personalizable(PersonalizationScope.Shared),
|
|
Themeable(false),
|
|
WebCategory("WebPartBehavior"),
|
|
WebSysDescription(SR.WebPart_TitleUrl),
|
|
]
|
|
public virtual string TitleUrl {
|
|
get {
|
|
return (_titleUrl != null) ? _titleUrl : String.Empty;
|
|
}
|
|
set {
|
|
if (CrossSiteScriptingValidation.IsDangerousUrl(value)) {
|
|
throw new ArgumentException(SR.GetString(SR.WebPart_BadUrl, value), "value");
|
|
}
|
|
_titleUrl = value;
|
|
}
|
|
}
|
|
|
|
internal Dictionary<ProviderConnectionPoint, int> TrackerCounter {
|
|
get {
|
|
if (_trackerCounter == null) {
|
|
_trackerCounter = new Dictionary<ProviderConnectionPoint, int>();
|
|
}
|
|
return _trackerCounter;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Overriden by subclasses to add Verbs for this WebPart.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public virtual WebPartVerbCollection Verbs {
|
|
get {
|
|
return WebPartVerbCollection.Empty;
|
|
}
|
|
}
|
|
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public virtual object WebBrowsableObject {
|
|
get {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
protected WebPartManager WebPartManager {
|
|
get {
|
|
return _webPartManager;
|
|
}
|
|
}
|
|
|
|
// ID rendered on the table containing the whole web part. We shouldn't render ClientID
|
|
// on the table, since it will be rendered by the WebPart on the container for the part
|
|
// contents. We shouldn't render ID either, since it may be the same as another control
|
|
// on the page, and it should be different than ID since it is being rendered by the Zone,
|
|
// not the WebPart.
|
|
internal string WholePartID {
|
|
get {
|
|
return WholePartIDPrefix + ID;
|
|
}
|
|
}
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// Overriden to mark as personalizable
|
|
/// </devdoc>
|
|
[
|
|
Personalizable
|
|
]
|
|
public override Unit Width {
|
|
get {
|
|
return base.Width;
|
|
}
|
|
set {
|
|
base.Width = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The WebPartZone that this WebPart is currently rendered within.
|
|
/// If the WebPart is closed, returns the WebPartZone that the WebPart
|
|
/// was last rendered within.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public WebPartZoneBase Zone {
|
|
get {
|
|
if (_zone == null) {
|
|
string zoneID = ZoneID;
|
|
if (!String.IsNullOrEmpty(zoneID) && WebPartManager != null) {
|
|
WebPartZoneCollection zones = WebPartManager.Zones;
|
|
if (zones != null) {
|
|
_zone = zones[zoneID];
|
|
}
|
|
}
|
|
}
|
|
|
|
return _zone;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The ID of the web part zone that this web part logically belongs to
|
|
/// </devdoc>
|
|
internal string ZoneID {
|
|
get {
|
|
return _zoneID;
|
|
}
|
|
set {
|
|
if (ZoneID != value) {
|
|
_zoneID = value;
|
|
// Invalidate cache
|
|
_zone = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The index of this web part within the web part zone it logically belongs to.
|
|
/// An index of -1 means the part is not currently in a zone.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
|
|
]
|
|
public int ZoneIndex {
|
|
get {
|
|
return _zoneIndex;
|
|
}
|
|
}
|
|
|
|
public virtual EditorPartCollection CreateEditorParts() {
|
|
return EditorPartCollection.Empty;
|
|
}
|
|
|
|
protected internal virtual void OnClosing(EventArgs e) {
|
|
}
|
|
|
|
protected internal virtual void OnConnectModeChanged(EventArgs e) {
|
|
}
|
|
|
|
protected internal virtual void OnDeleting(EventArgs e) {
|
|
}
|
|
|
|
protected internal virtual void OnEditModeChanged(EventArgs e) {
|
|
}
|
|
|
|
internal override void PreRenderRecursiveInternal() {
|
|
if (IsStandalone) {
|
|
if (Hidden) {
|
|
throw new InvalidOperationException(SR.GetString(SR.WebPart_NotStandalone, "Hidden", ID));
|
|
}
|
|
}
|
|
else {
|
|
if (!Visible) {
|
|
throw new InvalidOperationException(SR.GetString(SR.WebPart_OnlyStandalone, "Visible", ID));
|
|
}
|
|
}
|
|
base.PreRenderRecursiveInternal();
|
|
}
|
|
|
|
internal void SetConnectErrorMessage(string connectErrorMessage) {
|
|
// Only set the error message if it has not been set already. The first error message
|
|
// set should be displayed.
|
|
if (String.IsNullOrEmpty(_connectErrorMessage)) {
|
|
_connectErrorMessage = connectErrorMessage;
|
|
}
|
|
}
|
|
|
|
internal void SetHasUserData(bool hasUserData) {
|
|
_hasUserData = hasUserData;
|
|
}
|
|
|
|
internal void SetHasSharedData(bool hasSharedData) {
|
|
_hasSharedData = hasSharedData;
|
|
}
|
|
|
|
internal void SetIsClosed(bool isClosed) {
|
|
_isClosed = isClosed;
|
|
}
|
|
|
|
internal void SetIsShared(bool isShared) {
|
|
_isShared = isShared;
|
|
}
|
|
|
|
internal void SetIsStandalone(bool isStandalone) {
|
|
_isStandalone = isStandalone;
|
|
}
|
|
|
|
internal void SetIsStatic(bool isStatic) {
|
|
_isStatic = isStatic;
|
|
}
|
|
|
|
protected void SetPersonalizationDirty() {
|
|
if (WebPartManager == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.WebPartManagerRequired));
|
|
}
|
|
|
|
WebPartManager.Personalization.SetDirty(this);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// This method allows a non-WebPart control to mark its personalization as dirty.
|
|
/// </devdoc>
|
|
public static void SetPersonalizationDirty(Control control) {
|
|
if (control == null) {
|
|
throw new ArgumentNullException("control");
|
|
}
|
|
if (control.Page == null) {
|
|
throw new ArgumentException(SR.GetString(SR.PropertyCannotBeNull, "Page"), "control");
|
|
}
|
|
|
|
WebPartManager wpm = WebPartManager.GetCurrentWebPartManager(control.Page);
|
|
if (wpm == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.WebPartManagerRequired));
|
|
}
|
|
|
|
WebPart webPart = wpm.GetGenericWebPart(control);
|
|
if (webPart == null) {
|
|
throw new ArgumentException(SR.GetString(SR.WebPart_NonWebPart), "control");
|
|
}
|
|
|
|
webPart.SetPersonalizationDirty();
|
|
}
|
|
|
|
internal void SetWebPartManager(WebPartManager webPartManager) {
|
|
_webPartManager = webPartManager;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The index of this web part within the web part zone it logically belongs to.
|
|
/// </devdoc>
|
|
internal void SetZoneIndex(int zoneIndex) {
|
|
if (zoneIndex < 0) {
|
|
throw new ArgumentOutOfRangeException("zoneIndex");
|
|
}
|
|
_zoneIndex = zoneIndex;
|
|
}
|
|
|
|
// If this is a GenericWebPart, returns the ChildControl. Else, just returns a pointer to itself.
|
|
// Used when you need the Control to pass to methods on ConnectionPoint.
|
|
internal Control ToControl() {
|
|
GenericWebPart genericWebPart = this as GenericWebPart;
|
|
if (genericWebPart != null) {
|
|
Control control = genericWebPart.ChildControl;
|
|
if (control != null) {
|
|
return control;
|
|
} else {
|
|
throw new InvalidOperationException(SR.GetString(SR.GenericWebPart_ChildControlIsNull));
|
|
}
|
|
}
|
|
else {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
protected override void TrackViewState() {
|
|
if (WebPartManager != null) {
|
|
WebPartManager.Personalization.ApplyPersonalizationState(this);
|
|
}
|
|
|
|
base.TrackViewState();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// We need this to return nonzero for any two distinct WebParts on the page,
|
|
/// since we use SortedList in WebPartManager, and SortedList cannot contain
|
|
/// two keys where the IComparer returns zero. Two WebParts can have the same
|
|
/// ZoneIndex when we merge the Shared and User parts. We use the ID
|
|
/// to order the parts if ZoneIndex is the same.
|
|
/// </devdoc>
|
|
internal sealed class ZoneIndexComparer : IComparer {
|
|
public int Compare(object x, object y) {
|
|
WebPart p1 = (WebPart)x;
|
|
WebPart p2 = (WebPart)y;
|
|
|
|
int c = p1.ZoneIndex - p2.ZoneIndex;
|
|
if (c == 0) {
|
|
c = String.Compare(p1.ID, p2.ID, StringComparison.CurrentCulture);
|
|
}
|
|
return c;
|
|
}
|
|
}
|
|
}
|
|
}
|