1273 lines
59 KiB
C#
1273 lines
59 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="BlobPersonalizationState.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.Specialized;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Web;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
internal sealed class BlobPersonalizationState : PersonalizationState {
|
|
|
|
private const int PersonalizationVersion = (int)PersonalizationVersions.WhidbeyRTM;
|
|
private const string WebPartManagerPersonalizationID = "__wpm";
|
|
|
|
private bool _isPostRequest;
|
|
private IDictionary _personalizedControls;
|
|
|
|
private IDictionary _sharedState;
|
|
private IDictionary _userState;
|
|
private byte[] _rawUserData;
|
|
|
|
private IDictionary _extractedState;
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public BlobPersonalizationState(WebPartManager webPartManager) : base(webPartManager) {
|
|
//
|
|
|
|
|
|
// Note that we don't use the IsPostBack property of Page because that
|
|
// is based on the presence of view state, which could be on the query string
|
|
// in a non-POST request as well. Instead we use the actual verb associated
|
|
// with the request.
|
|
// Note that there are other types of HttpVerb besides GET and POST. We only
|
|
// save personalization data for POST requests. (VSWhidbey 423433)
|
|
_isPostRequest = (webPartManager.Page.Request.HttpVerb == HttpVerb.POST);
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override bool IsEmpty {
|
|
get {
|
|
return ((_extractedState == null) || (_extractedState.Count == 0));
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
private bool IsPostRequest {
|
|
get {
|
|
return _isPostRequest;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
private PersonalizationScope PersonalizationScope {
|
|
get {
|
|
return WebPartManager.Personalization.Scope;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// This is for symmetry with the UserState property.
|
|
/// </devdoc>
|
|
private IDictionary SharedState {
|
|
get {
|
|
return _sharedState;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// User state is always loaded even if the WebPartManager is in shared
|
|
/// scope. So we on-demand deserialize the bytes.
|
|
/// </devdoc>
|
|
private IDictionary UserState {
|
|
get {
|
|
if (_rawUserData != null) {
|
|
_userState = DeserializeData(_rawUserData);
|
|
_rawUserData = null;
|
|
}
|
|
|
|
if (_userState == null) {
|
|
_userState = new HybridDictionary(/* caseInsensitive */ false);
|
|
}
|
|
|
|
return _userState;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Does the work of applying personalization data into a control
|
|
/// </devdoc>
|
|
private void ApplyPersonalization(Control control, string personalizationID, bool isWebPartManager,
|
|
PersonalizationScope extractScope, GenericWebPart genericWebPart) {
|
|
Debug.Assert(control != null);
|
|
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
|
|
|
|
if (_personalizedControls == null) {
|
|
_personalizedControls = new HybridDictionary(/* caseInsensitive */ false);
|
|
}
|
|
else {
|
|
// We shouldn't be applying personalization to the same control more than once
|
|
if (_personalizedControls.Contains(personalizationID)) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_CantApply, personalizationID));
|
|
}
|
|
}
|
|
|
|
IDictionary personalizableProperties =
|
|
PersonalizableAttribute.GetPersonalizablePropertyEntries(control.GetType());
|
|
|
|
if (SharedState == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
|
|
}
|
|
|
|
PersonalizationInfo sharedInfo = (PersonalizationInfo)SharedState[personalizationID];
|
|
PersonalizationInfo userInfo = null;
|
|
IDictionary defaultProperties = null;
|
|
IDictionary initialProperties = null;
|
|
PersonalizationDictionary customInitialProperties = null;
|
|
|
|
// WebPart.SetPersonalizationDirty() should only mark a control as dirty in the following circumstances:
|
|
// 1. During its IPersonalizable.Load() method
|
|
// 2. During its IVersioningPersonalizable.Load() method
|
|
// 3. During or after its ITrackingPersonalizable.EndLoad() method
|
|
// By exclusion, WebPart.SetPersonalizationDirty() should be a no-op in the following circumstances:
|
|
// 1. Before its IPersonalizable.Load() method
|
|
// 2. While we are setting the values of its [Personalizable] properties
|
|
// (VSWhidbey 392533)
|
|
ControlInfo ci = new ControlInfo();
|
|
ci._allowSetDirty = false;
|
|
_personalizedControls[personalizationID] = ci;
|
|
|
|
if (sharedInfo != null && sharedInfo._isStatic && !sharedInfo.IsMatchingControlType(control)) {
|
|
// Mismatch in saved data, so ignore it
|
|
sharedInfo = null;
|
|
if (PersonalizationScope == PersonalizationScope.Shared) {
|
|
SetControlDirty(control, personalizationID, isWebPartManager, true);
|
|
}
|
|
}
|
|
|
|
IPersonalizable customPersonalizable = control as IPersonalizable;
|
|
ITrackingPersonalizable trackingPersonalizable = control as ITrackingPersonalizable;
|
|
|
|
// The WebPart on which to set HasSharedData and HasUserData
|
|
WebPart hasDataWebPart = null;
|
|
if (!isWebPartManager) {
|
|
if (genericWebPart != null) {
|
|
hasDataWebPart = genericWebPart;
|
|
}
|
|
else {
|
|
Debug.Assert(control is WebPart);
|
|
hasDataWebPart = (WebPart)control;
|
|
}
|
|
}
|
|
|
|
try {
|
|
if (trackingPersonalizable != null) {
|
|
trackingPersonalizable.BeginLoad();
|
|
}
|
|
|
|
if (PersonalizationScope == PersonalizationScope.User) {
|
|
if (UserState == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
|
|
}
|
|
|
|
userInfo = (PersonalizationInfo)UserState[personalizationID];
|
|
|
|
if (userInfo != null && userInfo._isStatic && !userInfo.IsMatchingControlType(control)) {
|
|
// Mismatch in saved data, so ignore it
|
|
userInfo = null;
|
|
SetControlDirty(control, personalizationID, isWebPartManager, true);
|
|
}
|
|
|
|
if (customPersonalizable != null) {
|
|
PersonalizationDictionary customProperties = MergeCustomProperties(
|
|
sharedInfo, userInfo, isWebPartManager, hasDataWebPart, ref customInitialProperties);
|
|
if (customProperties != null) {
|
|
ci._allowSetDirty = true;
|
|
customPersonalizable.Load(customProperties);
|
|
ci._allowSetDirty = false;
|
|
}
|
|
}
|
|
|
|
if (!isWebPartManager) {
|
|
// Properties do not apply to the WebPartManager
|
|
|
|
IDictionary unusedSharedProperties = null;
|
|
IDictionary unusedUserProperties = null;
|
|
|
|
// To compute default properties in user scope, we must first
|
|
// apply the shared properties. Only differences detected from
|
|
// shared scope are to be persisted.
|
|
if (sharedInfo != null) {
|
|
IDictionary properties = sharedInfo._properties;
|
|
|
|
if ((properties != null) && (properties.Count != 0)) {
|
|
hasDataWebPart.SetHasSharedData(true);
|
|
unusedSharedProperties = SetPersonalizedProperties(control, personalizableProperties,
|
|
properties, PersonalizationScope.Shared);
|
|
}
|
|
}
|
|
defaultProperties = GetPersonalizedProperties(control, personalizableProperties, null, null,
|
|
extractScope);
|
|
|
|
// Now apply the user properties and hang on to the initial values
|
|
if (userInfo != null) {
|
|
IDictionary properties = userInfo._properties;
|
|
|
|
if ((properties != null) && (properties.Count != 0)) {
|
|
hasDataWebPart.SetHasUserData(true);
|
|
// We pass the extractScope as the PersonalizationScope in which to set the properties. For
|
|
// a shared WebPart, we want to only apply the user values to user properties, and not to
|
|
// shared properties. However, for an unshared WebPart, we want to apply the user values
|
|
// to both user and shared properties, since there is effectively no difference for an
|
|
// unshared WebPart. (VSWhidbey 349356)
|
|
unusedUserProperties = SetPersonalizedProperties(control, personalizableProperties,
|
|
properties, extractScope);
|
|
}
|
|
|
|
if ((trackingPersonalizable == null) || (trackingPersonalizable.TracksChanges == false)) {
|
|
initialProperties = properties;
|
|
}
|
|
}
|
|
|
|
bool hasUnusedProperties = ((unusedSharedProperties != null) || (unusedUserProperties != null));
|
|
if (hasUnusedProperties) {
|
|
IVersioningPersonalizable versioningPersonalizable = control as IVersioningPersonalizable;
|
|
if (versioningPersonalizable != null) {
|
|
IDictionary unusedProperties = null;
|
|
|
|
// Merge any unused properties, so they can be handed off to the
|
|
// control via IVersioningPersonalizable
|
|
if (unusedSharedProperties != null) {
|
|
unusedProperties = unusedSharedProperties;
|
|
if (unusedUserProperties != null) {
|
|
foreach (DictionaryEntry entry in unusedUserProperties) {
|
|
unusedProperties[entry.Key] = entry.Value;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
unusedProperties = unusedUserProperties;
|
|
}
|
|
|
|
ci._allowSetDirty = true;
|
|
versioningPersonalizable.Load(unusedProperties);
|
|
ci._allowSetDirty = false;
|
|
}
|
|
else {
|
|
// There were some unused properties, and they couldn't be loaded.
|
|
// Mark this control as dirty, so we clean up its personalization
|
|
// state later...
|
|
SetControlDirty(control, personalizationID, isWebPartManager, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// Shared Personalization Scope
|
|
|
|
if (customPersonalizable != null) {
|
|
PersonalizationDictionary customProperties = MergeCustomProperties(
|
|
sharedInfo, userInfo, isWebPartManager, hasDataWebPart, ref customInitialProperties);
|
|
if (customProperties != null) {
|
|
ci._allowSetDirty = true;
|
|
customPersonalizable.Load(customProperties);
|
|
ci._allowSetDirty = false;
|
|
}
|
|
}
|
|
|
|
if (!isWebPartManager) {
|
|
IDictionary unusedProperties = null;
|
|
|
|
// Compute default properties. These are basically what was persisted
|
|
// in the markup
|
|
defaultProperties = GetPersonalizedProperties(control, personalizableProperties, null, null,
|
|
extractScope);
|
|
|
|
// Now apply shared properties and hang on to the initial values
|
|
if (sharedInfo != null) {
|
|
IDictionary properties = sharedInfo._properties;
|
|
|
|
if ((properties != null) && (properties.Count != 0)) {
|
|
hasDataWebPart.SetHasSharedData(true);
|
|
unusedProperties = SetPersonalizedProperties(control, personalizableProperties,
|
|
properties, PersonalizationScope.Shared);
|
|
}
|
|
|
|
if ((trackingPersonalizable == null) ||
|
|
(trackingPersonalizable.TracksChanges == false)) {
|
|
initialProperties = properties;
|
|
}
|
|
}
|
|
|
|
if (unusedProperties != null) {
|
|
IVersioningPersonalizable versioningPersonalizable = control as IVersioningPersonalizable;
|
|
if (versioningPersonalizable != null) {
|
|
ci._allowSetDirty = true;
|
|
versioningPersonalizable.Load(unusedProperties);
|
|
ci._allowSetDirty = false;
|
|
}
|
|
else {
|
|
// There were some unused properties, and they couldn't be loaded.
|
|
// Mark this control as dirty, so we clean up its personalization
|
|
// state later...
|
|
SetControlDirty(control, personalizationID, isWebPartManager, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
ci._allowSetDirty = true;
|
|
if (trackingPersonalizable != null) {
|
|
trackingPersonalizable.EndLoad();
|
|
}
|
|
}
|
|
|
|
// Track this as one of the personalized controls
|
|
ci._control = control;
|
|
ci._personalizableProperties = personalizableProperties;
|
|
ci._defaultProperties = defaultProperties;
|
|
ci._initialProperties = initialProperties;
|
|
ci._customInitialProperties = customInitialProperties;
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override void ApplyWebPartPersonalization(WebPart webPart) {
|
|
ValidateWebPart(webPart);
|
|
|
|
// Do not apply personalization to the UnauthorizedWebPart. It is never rendered
|
|
// in the page, so there is no point to applying the personalization to it.
|
|
// The personalization data from the original WebPart will be round-tripped in
|
|
// ExtractWebPartPersonalization(). We do apply personalization to the ErrorWebPart,
|
|
// because we want it to render with many of the personalized property values of the
|
|
// original WebPart.
|
|
if (webPart is UnauthorizedWebPart) {
|
|
return;
|
|
}
|
|
|
|
string personalizationID = CreatePersonalizationID(webPart, null);
|
|
|
|
// In ApplyPersonalization(), we need to extract the default properites in the same scope we will
|
|
// extract the properties in ExtractPersonalization().
|
|
PersonalizationScope extractScope = PersonalizationScope;
|
|
if ((extractScope == PersonalizationScope.User) && (!webPart.IsShared)) {
|
|
// This implies a user owned WebPart in User mode, so extract all
|
|
// the properties
|
|
extractScope = PersonalizationScope.Shared;
|
|
}
|
|
|
|
ApplyPersonalization(webPart, personalizationID, /* isWebPartManager */ false, extractScope,
|
|
/* genericWebPart */ null);
|
|
|
|
GenericWebPart genericWebPart = webPart as GenericWebPart;
|
|
if (genericWebPart != null) {
|
|
Control containedControl = genericWebPart.ChildControl;
|
|
personalizationID = CreatePersonalizationID(containedControl, genericWebPart);
|
|
|
|
ApplyPersonalization(containedControl, personalizationID, /* isWebPartManager */ false, extractScope,
|
|
genericWebPart);
|
|
}
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override void ApplyWebPartManagerPersonalization() {
|
|
ApplyPersonalization(WebPartManager, WebPartManagerPersonalizationID, /* isWebPartManager */ true,
|
|
PersonalizationScope, /* genericWebPart */ null);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns false if the set of new properties are the same as old ones; true if there
|
|
/// are differences.
|
|
/// </devdoc>
|
|
private bool CompareProperties(IDictionary newProperties, IDictionary oldProperties) {
|
|
int newCount = 0;
|
|
int oldCount = 0;
|
|
|
|
if (newProperties != null) {
|
|
newCount = newProperties.Count;
|
|
}
|
|
if (oldProperties != null) {
|
|
oldCount = oldProperties.Count;
|
|
}
|
|
|
|
if (newCount != oldCount) {
|
|
return true;
|
|
}
|
|
|
|
if (newCount != 0) {
|
|
foreach (DictionaryEntry entry in newProperties) {
|
|
object name = entry.Key;
|
|
object newValue = entry.Value;
|
|
|
|
if (oldProperties.Contains(name)) {
|
|
object oldValue = oldProperties[name];
|
|
|
|
if (Object.Equals(newValue, oldValue) == false) {
|
|
return true;
|
|
}
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private string CreatePersonalizationID(string ID, string genericWebPartID) {
|
|
Debug.Assert(!String.IsNullOrEmpty(ID));
|
|
if (!String.IsNullOrEmpty(genericWebPartID)) {
|
|
return ID + Control.ID_SEPARATOR + genericWebPartID;
|
|
}
|
|
else {
|
|
return ID;
|
|
}
|
|
}
|
|
|
|
private string CreatePersonalizationID(Control control, WebPart associatedGenericWebPart) {
|
|
if (associatedGenericWebPart != null) {
|
|
return CreatePersonalizationID(control.ID, associatedGenericWebPart.ID);
|
|
}
|
|
|
|
return CreatePersonalizationID(control.ID, null);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Deserializes personalization data packed as a blob of binary data
|
|
/// into a dictionary with personalization IDs mapped to
|
|
/// PersonalizationInfo objects.
|
|
/// </devdoc>
|
|
private static IDictionary DeserializeData(byte[] data) {
|
|
IDictionary deserializedData = null;
|
|
|
|
if ((data != null) && (data.Length > 0)) {
|
|
Exception deserializationException = null;
|
|
int version = -1;
|
|
|
|
object[] items = null;
|
|
int offset = 0;
|
|
|
|
// Deserialize the data
|
|
try {
|
|
ObjectStateFormatter formatter =
|
|
new ObjectStateFormatter(null /* Page(used to determine encryption mode) */, false /*throwOnErrorDeserializing*/);
|
|
|
|
if (!HttpRuntime.DisableProcessRequestInApplicationTrust) {
|
|
// This is more of a consistency and defense-in-depth fix. Currently we believe
|
|
// only user code or code with restricted permissions will be running on the stack.
|
|
// However, to mirror the fix for Session State, and also to hedge against future
|
|
// scenarios where our current assumptions may change, we should restrict the running
|
|
// thread to only the permission set currently defined for the app domain.
|
|
// VSWhidbey 427533
|
|
if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) {
|
|
HttpRuntime.NamedPermissionSet.PermitOnly();
|
|
}
|
|
}
|
|
|
|
items = (object[])formatter.DeserializeWithAssert(new MemoryStream(data));
|
|
if (items != null && items.Length != 0) {
|
|
version = (int)items[offset++];
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
deserializationException = e;
|
|
}
|
|
|
|
if (version == (int)PersonalizationVersions.WhidbeyBeta2 || version == (int)PersonalizationVersions.WhidbeyRTM) {
|
|
try {
|
|
// Build up the dictionary of PersonalizationInfo objects
|
|
int infoListCount = (int)items[offset++];
|
|
|
|
if (infoListCount > 0) {
|
|
deserializedData = new HybridDictionary(infoListCount, /* caseInsensitive */ false);
|
|
}
|
|
|
|
for (int i = 0; i < infoListCount; i++) {
|
|
string controlID;
|
|
bool isStatic;
|
|
Type controlType = null;
|
|
VirtualPath controlVPath = null;
|
|
|
|
// If this is a dynamic WebPart or control, the Type is not saved in personalization,
|
|
// so the first item is the controlID. If this is a static WebPart or control, the
|
|
// first item is the control Type.
|
|
object item = items[offset++];
|
|
if (item is string) {
|
|
controlID = (string)item;
|
|
isStatic = false;
|
|
}
|
|
else {
|
|
controlType = (Type)item;
|
|
if (controlType == typeof(UserControl)) {
|
|
controlVPath = VirtualPath.CreateNonRelativeAllowNull((string)items[offset++]);
|
|
}
|
|
controlID = (string)items[offset++];
|
|
isStatic = true;
|
|
}
|
|
|
|
IDictionary properties = null;
|
|
int propertyCount = (int)items[offset++];
|
|
if (propertyCount > 0) {
|
|
properties = new HybridDictionary(propertyCount, /* caseInsensitive */ false);
|
|
for (int j = 0; j < propertyCount; j++) {
|
|
string propertyName = ((IndexedString)items[offset++]).Value;
|
|
object propertyValue = items[offset++];
|
|
|
|
properties[propertyName] = propertyValue;
|
|
}
|
|
}
|
|
|
|
PersonalizationDictionary customProperties = null;
|
|
int customPropertyCount = (int)items[offset++];
|
|
if (customPropertyCount > 0) {
|
|
customProperties = new PersonalizationDictionary(customPropertyCount);
|
|
for (int j = 0; j < customPropertyCount; j++) {
|
|
string propertyName = ((IndexedString)items[offset++]).Value;
|
|
object propertyValue = items[offset++];
|
|
PersonalizationScope propertyScope =
|
|
(bool)items[offset++] ? PersonalizationScope.Shared : PersonalizationScope.User;
|
|
bool isSensitive = false;
|
|
if (version == (int)PersonalizationVersions.WhidbeyRTM) {
|
|
isSensitive = (bool)items[offset++];
|
|
}
|
|
|
|
customProperties[propertyName] =
|
|
new PersonalizationEntry(propertyValue, propertyScope, isSensitive);
|
|
}
|
|
}
|
|
|
|
PersonalizationInfo info = new PersonalizationInfo();
|
|
info._controlID = controlID;
|
|
info._controlType = controlType;
|
|
info._controlVPath = controlVPath;
|
|
info._isStatic = isStatic;
|
|
info._properties = properties;
|
|
info._customProperties = customProperties;
|
|
|
|
deserializedData[controlID] = info;
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
deserializationException = e;
|
|
}
|
|
}
|
|
|
|
// Check that there was no deserialization error, and that
|
|
// the data conforms to our known version
|
|
if ((deserializationException != null) ||
|
|
(version != (int)PersonalizationVersions.WhidbeyBeta2 && version != (int)PersonalizationVersions.WhidbeyRTM)) {
|
|
throw new ArgumentException(SR.GetString(SR.BlobPersonalizationState_DeserializeError),
|
|
"data", deserializationException);
|
|
}
|
|
}
|
|
|
|
if (deserializedData == null) {
|
|
deserializedData = new HybridDictionary(/* caseInsensitive */ false);
|
|
}
|
|
|
|
return deserializedData;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Does the actual work of extracting personalizated data from a control
|
|
/// </devdoc>
|
|
private void ExtractPersonalization(Control control, string personalizationID, bool isWebPartManager,
|
|
PersonalizationScope scope, bool isStatic, GenericWebPart genericWebPart) {
|
|
Debug.Assert(control != null);
|
|
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
|
|
|
|
if (_extractedState == null) {
|
|
_extractedState = new HybridDictionary(/* caseInsensitive */ false);
|
|
}
|
|
|
|
if (_personalizedControls == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotApplied));
|
|
}
|
|
|
|
ControlInfo ci = (ControlInfo)_personalizedControls[personalizationID];
|
|
// The ControlInfo should always have been already created in ApplyPersonalization().
|
|
// However, it will be null if the Control's ID has changed since we loaded personalization data.
|
|
// This is not supported, but we should throw a helpful exception. (VSWhidbey 372354)
|
|
if (ci == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_CantExtract, personalizationID));
|
|
}
|
|
|
|
ITrackingPersonalizable trackingPersonalizable = control as ITrackingPersonalizable;
|
|
IPersonalizable customPersonalizable = control as IPersonalizable;
|
|
|
|
IDictionary properties = ci._initialProperties;
|
|
PersonalizationDictionary customProperties = ci._customInitialProperties;
|
|
bool changed = false;
|
|
|
|
try {
|
|
if (trackingPersonalizable != null) {
|
|
trackingPersonalizable.BeginSave();
|
|
}
|
|
|
|
if (!IsPostRequest) {
|
|
// In non-POST requests, we only save those WebParts that indicated explicitely that
|
|
// they have changed. For other WebParts, we just round-trip the initial state
|
|
// that was loaded.
|
|
if (ci._dirty) {
|
|
// Always save IPersonalizable data if the WebPart has indicated that it is dirty
|
|
if (customPersonalizable != null) {
|
|
PersonalizationDictionary tempCustomProperties = new PersonalizationDictionary();
|
|
|
|
customPersonalizable.Save(tempCustomProperties);
|
|
if ((tempCustomProperties.Count != 0) ||
|
|
((customProperties != null) && (customProperties.Count != 0))) {
|
|
if (scope == PersonalizationScope.User) {
|
|
tempCustomProperties.RemoveSharedProperties();
|
|
}
|
|
customProperties = tempCustomProperties;
|
|
}
|
|
}
|
|
|
|
if (!isWebPartManager) {
|
|
// WebPartManager does not have personalizable properties
|
|
properties =
|
|
GetPersonalizedProperties(control, ci._personalizableProperties,
|
|
ci._defaultProperties, ci._initialProperties, scope);
|
|
}
|
|
changed = true;
|
|
}
|
|
}
|
|
else {
|
|
bool extractProperties = true;
|
|
bool diffWithInitialProperties = true;
|
|
|
|
if (ci._dirty) {
|
|
// WebPart is indicating that it is dirty, so there is no need
|
|
// for us to perform a diff
|
|
diffWithInitialProperties = false;
|
|
}
|
|
else if ((trackingPersonalizable != null) &&
|
|
(trackingPersonalizable.TracksChanges) &&
|
|
(ci._dirty == false)) {
|
|
// WebPart is indicating that it is not dirty, and since it
|
|
// tracks dirty-ness, theres no need to do additional work.
|
|
extractProperties = false;
|
|
}
|
|
|
|
if (extractProperties) {
|
|
// Always save IPersonalizable data if the WebPart has indicated that it is dirty
|
|
if (customPersonalizable != null && (ci._dirty || customPersonalizable.IsDirty)) {
|
|
PersonalizationDictionary tempCustomProperties = new PersonalizationDictionary();
|
|
customPersonalizable.Save(tempCustomProperties);
|
|
|
|
// The new custom properties should be used either if they are
|
|
// non-empty, or they are, but the original ones weren't, since
|
|
// that implies a change as well.
|
|
if ((tempCustomProperties.Count != 0) ||
|
|
((customProperties != null) && (customProperties.Count != 0))) {
|
|
if (tempCustomProperties.Count != 0) {
|
|
if (scope == PersonalizationScope.User) {
|
|
tempCustomProperties.RemoveSharedProperties();
|
|
}
|
|
customProperties = tempCustomProperties;
|
|
}
|
|
else {
|
|
customProperties = null;
|
|
}
|
|
|
|
// No point doing the diff, since we've already determined that the
|
|
// custom properties are dirty.
|
|
diffWithInitialProperties = false;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (!isWebPartManager) {
|
|
// WebPartManager does not have personalizable properties
|
|
|
|
IDictionary newProperties =
|
|
GetPersonalizedProperties(control, ci._personalizableProperties,
|
|
ci._defaultProperties, ci._initialProperties, scope);
|
|
|
|
if (diffWithInitialProperties) {
|
|
bool different = CompareProperties(newProperties, ci._initialProperties);
|
|
if (different == false) {
|
|
extractProperties = false;
|
|
}
|
|
}
|
|
|
|
if (extractProperties) {
|
|
properties = newProperties;
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
if (trackingPersonalizable != null) {
|
|
trackingPersonalizable.EndSave();
|
|
}
|
|
}
|
|
|
|
PersonalizationInfo extractedInfo = new PersonalizationInfo();
|
|
extractedInfo._controlID = personalizationID;
|
|
if (isStatic) {
|
|
UserControl uc = control as UserControl;
|
|
if (uc != null) {
|
|
extractedInfo._controlType = typeof(UserControl);
|
|
extractedInfo._controlVPath = uc.TemplateControlVirtualPath;
|
|
}
|
|
else {
|
|
extractedInfo._controlType = control.GetType();
|
|
}
|
|
}
|
|
extractedInfo._isStatic = isStatic;
|
|
extractedInfo._properties = properties;
|
|
extractedInfo._customProperties = customProperties;
|
|
_extractedState[personalizationID] = extractedInfo;
|
|
|
|
if (changed) {
|
|
SetDirty();
|
|
}
|
|
|
|
if ((properties != null && properties.Count > 0) ||
|
|
(customProperties != null && customProperties.Count > 0)) {
|
|
|
|
// The WebPart on which to set HasSharedData and HasUserData
|
|
WebPart hasDataWebPart = null;
|
|
if (!isWebPartManager) {
|
|
if (genericWebPart != null) {
|
|
hasDataWebPart = genericWebPart;
|
|
}
|
|
else {
|
|
Debug.Assert(control is WebPart);
|
|
hasDataWebPart = (WebPart)control;
|
|
}
|
|
}
|
|
|
|
if (hasDataWebPart != null) {
|
|
if (PersonalizationScope == PersonalizationScope.Shared) {
|
|
hasDataWebPart.SetHasSharedData(true);
|
|
}
|
|
else {
|
|
hasDataWebPart.SetHasUserData(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override void ExtractWebPartPersonalization(WebPart webPart) {
|
|
ValidateWebPart(webPart);
|
|
|
|
// Round-trip the personalization data for a ProxyWebPart
|
|
ProxyWebPart proxyWebPart = webPart as ProxyWebPart;
|
|
if (proxyWebPart != null) {
|
|
RoundTripWebPartPersonalization(proxyWebPart.OriginalID, proxyWebPart.GenericWebPartID);
|
|
return;
|
|
}
|
|
|
|
PersonalizationScope extractScope = PersonalizationScope;
|
|
if ((extractScope == PersonalizationScope.User) && (!webPart.IsShared)) {
|
|
// This implies a user owned WebPart in User mode, so save all
|
|
// the properties
|
|
extractScope = PersonalizationScope.Shared;
|
|
}
|
|
|
|
bool isStatic = webPart.IsStatic;
|
|
string personalizationID = CreatePersonalizationID(webPart, null);
|
|
ExtractPersonalization(webPart, personalizationID, /* isWebPartManager */ false, extractScope, isStatic,
|
|
/* genericWebPart */ null);
|
|
|
|
GenericWebPart genericWebPart = webPart as GenericWebPart;
|
|
if (genericWebPart != null) {
|
|
Control containedControl = genericWebPart.ChildControl;
|
|
personalizationID = CreatePersonalizationID(containedControl, genericWebPart);
|
|
ExtractPersonalization(containedControl, personalizationID, /* isWebPartManager */ false,
|
|
extractScope, isStatic, genericWebPart);
|
|
}
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override void ExtractWebPartManagerPersonalization() {
|
|
ExtractPersonalization(WebPartManager, WebPartManagerPersonalizationID, /* isWebPartManager */ true,
|
|
PersonalizationScope, /* isStatic */ true, /* genericWebPart */ null);
|
|
}
|
|
|
|
// Returns the AuthorizationFilter string for a WebPart before it is instantiated.
|
|
// Returns null if there is no personalized value for AuthorizationFilter, or if the
|
|
// personalized value has a type other than string.
|
|
public override string GetAuthorizationFilter(string webPartID) {
|
|
if (String.IsNullOrEmpty(webPartID)) {
|
|
throw ExceptionUtil.ParameterNullOrEmpty("webPartID");
|
|
}
|
|
|
|
return GetPersonalizedValue(webPartID, "AuthorizationFilter") as string;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
internal static IDictionary GetPersonalizedProperties(Control control, PersonalizationScope scope) {
|
|
IDictionary personalizableProperties =
|
|
PersonalizableAttribute.GetPersonalizablePropertyEntries(control.GetType());
|
|
|
|
return GetPersonalizedProperties(control, personalizableProperties, null, null, scope);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Does the work of retrieving personalized properties. If the scope is User, the shared
|
|
/// personalizable properties are not retrieved. If a non-null defaultPropertyState is
|
|
/// handed in, only the properties that are different from the default values are retrieved.
|
|
/// </devdoc>
|
|
private static IDictionary GetPersonalizedProperties(Control control,
|
|
IDictionary personalizableProperties,
|
|
IDictionary defaultPropertyState,
|
|
IDictionary initialPropertyState,
|
|
PersonalizationScope scope) {
|
|
Debug.Assert(control != null);
|
|
|
|
if (personalizableProperties.Count == 0) {
|
|
return null;
|
|
}
|
|
|
|
bool ignoreSharedProperties = (scope == PersonalizationScope.User);
|
|
IDictionary properties = null;
|
|
|
|
foreach (DictionaryEntry entry in personalizableProperties) {
|
|
PersonalizablePropertyEntry property = (PersonalizablePropertyEntry)entry.Value;
|
|
|
|
if (ignoreSharedProperties && (property.Scope == PersonalizationScope.Shared)) {
|
|
continue;
|
|
}
|
|
|
|
PropertyInfo pi = property.PropertyInfo;
|
|
Debug.Assert(pi != null);
|
|
|
|
//
|
|
string name = (string)entry.Key;
|
|
object value = FastPropertyAccessor.GetProperty(control, name, control.DesignMode);
|
|
bool saveProperty = true;
|
|
|
|
// Only compare to default value if there is no initial value.
|
|
if ((initialPropertyState == null || !initialPropertyState.Contains(name)) && defaultPropertyState != null) {
|
|
object defaultValue = defaultPropertyState[name];
|
|
if (Object.Equals(value, defaultValue)) {
|
|
saveProperty = false;
|
|
}
|
|
}
|
|
|
|
if (saveProperty) {
|
|
if (properties == null) {
|
|
properties = new HybridDictionary(personalizableProperties.Count, /* caseInsensitive */ false);
|
|
}
|
|
|
|
properties[name] = value;
|
|
}
|
|
}
|
|
|
|
return properties;
|
|
}
|
|
|
|
// Returns the value of a personalized property on a control
|
|
// Returns null if there is no personalized value for the property
|
|
private object GetPersonalizedValue(string personalizationID, string propertyName) {
|
|
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
|
|
Debug.Assert(!String.IsNullOrEmpty(propertyName));
|
|
|
|
if (SharedState == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
|
|
}
|
|
|
|
PersonalizationInfo sharedInfo = (PersonalizationInfo)SharedState[personalizationID];
|
|
|
|
IDictionary sharedProperties = (sharedInfo != null) ? sharedInfo._properties : null;
|
|
if (PersonalizationScope == PersonalizationScope.Shared) {
|
|
if (sharedProperties != null) {
|
|
return sharedProperties[propertyName];
|
|
}
|
|
}
|
|
else {
|
|
if (UserState == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
|
|
}
|
|
|
|
PersonalizationInfo userInfo = (PersonalizationInfo)UserState[personalizationID];
|
|
IDictionary userProperties = (userInfo != null) ? userInfo._properties : null;
|
|
if (userProperties != null && userProperties.Contains(propertyName)) {
|
|
return userProperties[propertyName];
|
|
}
|
|
else if (sharedProperties != null) {
|
|
return sharedProperties[propertyName];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public void LoadDataBlobs(byte[] sharedData, byte[] userData) {
|
|
_sharedState = DeserializeData(sharedData);
|
|
_rawUserData = userData;
|
|
}
|
|
|
|
// Returns a PersonalizationDictionary containing a merged view of the custom properties
|
|
// in both the sharedInfo and the userInfo.
|
|
private PersonalizationDictionary MergeCustomProperties(PersonalizationInfo sharedInfo,
|
|
PersonalizationInfo userInfo,
|
|
bool isWebPartManager, WebPart hasDataWebPart,
|
|
ref PersonalizationDictionary customInitialProperties) {
|
|
PersonalizationDictionary customProperties = null;
|
|
|
|
bool hasSharedCustomProperties = (sharedInfo != null && sharedInfo._customProperties != null);
|
|
bool hasUserCustomProperties = (userInfo != null && userInfo._customProperties != null);
|
|
|
|
// Fill or set the customProperties dictionary
|
|
if (hasSharedCustomProperties && hasUserCustomProperties) {
|
|
customProperties = new PersonalizationDictionary();
|
|
foreach (DictionaryEntry entry in sharedInfo._customProperties) {
|
|
customProperties[(string)entry.Key] = (PersonalizationEntry)entry.Value;
|
|
}
|
|
foreach (DictionaryEntry entry in userInfo._customProperties) {
|
|
customProperties[(string)entry.Key] = (PersonalizationEntry)entry.Value;
|
|
}
|
|
}
|
|
else if (hasSharedCustomProperties) {
|
|
customProperties = sharedInfo._customProperties;
|
|
}
|
|
else if (hasUserCustomProperties) {
|
|
customProperties = userInfo._customProperties;
|
|
}
|
|
|
|
// Set the customInitialProperties dictionary
|
|
if (PersonalizationScope == PersonalizationScope.Shared && hasSharedCustomProperties) {
|
|
customInitialProperties = sharedInfo._customProperties;
|
|
}
|
|
else if (PersonalizationScope == PersonalizationScope.User && hasUserCustomProperties) {
|
|
customInitialProperties = userInfo._customProperties;
|
|
}
|
|
|
|
// Set the HasSharedData and HasUserData flags
|
|
if (hasSharedCustomProperties && !isWebPartManager) {
|
|
hasDataWebPart.SetHasSharedData(true);
|
|
}
|
|
if (hasUserCustomProperties && !isWebPartManager) {
|
|
hasDataWebPart.SetHasUserData(true);
|
|
}
|
|
|
|
return customProperties;
|
|
}
|
|
|
|
|
|
private void RoundTripWebPartPersonalization(string ID, string genericWebPartID) {
|
|
if (String.IsNullOrEmpty(ID)) {
|
|
throw ExceptionUtil.ParameterNullOrEmpty("ID");
|
|
}
|
|
|
|
// Round-trip personalization for control/WebPart
|
|
string personalizationID = CreatePersonalizationID(ID, genericWebPartID);
|
|
RoundTripWebPartPersonalization(personalizationID);
|
|
|
|
// Round-trip personalization for GenericWebPart, if necessary
|
|
if (!String.IsNullOrEmpty(genericWebPartID)) {
|
|
string genericPersonalizationID = CreatePersonalizationID(genericWebPartID, null);
|
|
RoundTripWebPartPersonalization(genericPersonalizationID);
|
|
}
|
|
}
|
|
|
|
private void RoundTripWebPartPersonalization(string personalizationID) {
|
|
Debug.Assert(personalizationID != null);
|
|
// Can't check that personalizationID is valid, since there may be no data
|
|
// for even a valid ID.
|
|
|
|
if (PersonalizationScope == PersonalizationScope.Shared) {
|
|
if (SharedState == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
|
|
}
|
|
if (SharedState.Contains(personalizationID)) {
|
|
_extractedState[personalizationID] = (PersonalizationInfo)SharedState[personalizationID];
|
|
}
|
|
}
|
|
else {
|
|
if (UserState == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
|
|
}
|
|
if (UserState.Contains(personalizationID)) {
|
|
_extractedState[personalizationID] = (PersonalizationInfo)UserState[personalizationID];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public byte[] SaveDataBlob() {
|
|
return SerializeData(_extractedState);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Serializes a dictionary of IDs mapped to PersonalizationInfo
|
|
/// objects into a binary blob.
|
|
/// </devdoc>
|
|
private static byte[] SerializeData(IDictionary data) {
|
|
byte[] serializedData = null;
|
|
|
|
if ((data == null) || (data.Count == 0)) {
|
|
return serializedData;
|
|
}
|
|
|
|
ArrayList infoList = new ArrayList();
|
|
foreach (DictionaryEntry entry in data) {
|
|
PersonalizationInfo info = (PersonalizationInfo)entry.Value;
|
|
|
|
if (((info._properties != null) && (info._properties.Count != 0)) ||
|
|
((info._customProperties != null) && (info._customProperties.Count != 0))){
|
|
infoList.Add(info);
|
|
}
|
|
}
|
|
|
|
if (infoList.Count != 0) {
|
|
ArrayList items = new ArrayList();
|
|
|
|
items.Add(PersonalizationVersion);
|
|
items.Add(infoList.Count);
|
|
|
|
foreach (PersonalizationInfo info in infoList) {
|
|
// Only need to save the type information for static WebParts
|
|
if (info._isStatic) {
|
|
items.Add(info._controlType);
|
|
if (info._controlVPath != null) {
|
|
items.Add(info._controlVPath.AppRelativeVirtualPathString);
|
|
}
|
|
}
|
|
|
|
items.Add(info._controlID);
|
|
|
|
int propertyCount = 0;
|
|
if (info._properties != null) {
|
|
propertyCount = info._properties.Count;
|
|
}
|
|
items.Add(propertyCount);
|
|
if (propertyCount != 0) {
|
|
foreach (DictionaryEntry propertyEntry in info._properties) {
|
|
items.Add(new IndexedString((string)propertyEntry.Key));
|
|
items.Add(propertyEntry.Value);
|
|
}
|
|
}
|
|
|
|
int customPropertyCount = 0;
|
|
if (info._customProperties != null) {
|
|
customPropertyCount = info._customProperties.Count;
|
|
}
|
|
items.Add(customPropertyCount);
|
|
if (customPropertyCount != 0) {
|
|
foreach (DictionaryEntry customPropertyEntry in info._customProperties) {
|
|
items.Add(new IndexedString((string)customPropertyEntry.Key));
|
|
PersonalizationEntry personalizationEntry = (PersonalizationEntry)customPropertyEntry.Value;
|
|
items.Add(personalizationEntry.Value);
|
|
// PERF: Add a boolean instead of the Enum value
|
|
items.Add(personalizationEntry.Scope == PersonalizationScope.Shared);
|
|
// The IsSensitive property was added between Whidbey Beta2 and Whidbey RTM.
|
|
// VSWhidbey 502554 and 536907
|
|
items.Add(personalizationEntry.IsSensitive);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (items.Count != 0) {
|
|
ObjectStateFormatter formatter = new ObjectStateFormatter(null, false);
|
|
MemoryStream ms = new MemoryStream(1024);
|
|
object[] state = items.ToArray();
|
|
|
|
if (!HttpRuntime.DisableProcessRequestInApplicationTrust){
|
|
// This is more of a consistency and defense-in-depth fix. Currently we believe
|
|
// only user code or code with restricted permissions will be running on the stack.
|
|
// However, to mirror the fix for Session State, and also to hedge against future
|
|
// scenarios where our current assumptions may change, we should restrict the running
|
|
// thread to only the permission set currently defined for the app domain.
|
|
// VSWhidbey 491449
|
|
if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) {
|
|
HttpRuntime.NamedPermissionSet.PermitOnly();
|
|
}
|
|
}
|
|
|
|
formatter.SerializeWithAssert(ms, state);
|
|
|
|
serializedData = ms.ToArray();
|
|
}
|
|
}
|
|
|
|
return serializedData;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Only actually sets the control as dirty if we have already started applying personalization
|
|
/// data (info != null), and we are forcing the control to be dirty (forceSetDirty), or the control
|
|
/// has called SetPersonalizationDirty() at the right time (info._allowSetDirty).
|
|
/// </devdoc>
|
|
private void SetControlDirty(Control control, string personalizationID, bool isWebPartManager,
|
|
bool forceSetDirty) {
|
|
Debug.Assert(control != null);
|
|
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
|
|
|
|
if (_personalizedControls == null) {
|
|
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotApplied));
|
|
}
|
|
|
|
ControlInfo info = (ControlInfo)_personalizedControls[personalizationID];
|
|
if (info != null && (forceSetDirty || info._allowSetDirty)) {
|
|
info._dirty = true;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Called by WebPartPersonalization to copy the personalized values from one control
|
|
/// to another.
|
|
/// </devdoc>
|
|
internal static IDictionary SetPersonalizedProperties(Control control, IDictionary propertyState) {
|
|
IDictionary personalizableProperties =
|
|
PersonalizableAttribute.GetPersonalizablePropertyEntries(control.GetType());
|
|
|
|
// We pass PersonalizationScope.Shared, since we want to apply all values to their properties.
|
|
return SetPersonalizedProperties(control, personalizableProperties, propertyState, PersonalizationScope.Shared);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Does the work of setting personalized properties
|
|
/// </devdoc>
|
|
private static IDictionary SetPersonalizedProperties(Control control, IDictionary personalizableProperties,
|
|
IDictionary propertyState, PersonalizationScope scope) {
|
|
if (personalizableProperties.Count == 0) {
|
|
// all properties were not used
|
|
return propertyState;
|
|
}
|
|
|
|
if ((propertyState == null) || (propertyState.Count == 0)) {
|
|
return null;
|
|
}
|
|
|
|
IDictionary unusedProperties = null;
|
|
|
|
foreach (DictionaryEntry entry in propertyState) {
|
|
string name = (string)entry.Key;
|
|
object value = entry.Value;
|
|
|
|
PersonalizablePropertyEntry property = (PersonalizablePropertyEntry)personalizableProperties[name];
|
|
bool propertySet = false;
|
|
|
|
// Do not apply a user value to a shared property. This scenario can happen if there
|
|
// is already User data for a property, then the property is changed from Personalizable(User)
|
|
// to Personalizable(Shared). (VSWhidbey 349456)
|
|
if (property != null &&
|
|
(scope == PersonalizationScope.Shared || property.Scope == PersonalizationScope.User)) {
|
|
|
|
PropertyInfo pi = property.PropertyInfo;
|
|
Debug.Assert(pi != null);
|
|
|
|
// If SetProperty() throws an exception, the property will be added to the unusedProperties collection
|
|
try {
|
|
FastPropertyAccessor.SetProperty(control, name, value, control.DesignMode);
|
|
propertySet = true;
|
|
}
|
|
catch {
|
|
}
|
|
}
|
|
|
|
if (!propertySet) {
|
|
if (unusedProperties == null) {
|
|
unusedProperties = new HybridDictionary(propertyState.Count, /* caseInsensitive */ false);
|
|
}
|
|
|
|
unusedProperties[name] = value;
|
|
}
|
|
}
|
|
|
|
return unusedProperties;
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override void SetWebPartDirty(WebPart webPart) {
|
|
ValidateWebPart(webPart);
|
|
|
|
string personalizationID;
|
|
|
|
personalizationID = CreatePersonalizationID(webPart, null);
|
|
SetControlDirty(webPart, personalizationID, /* isWebPartManager */ false, /* forceSetDirty */ false);
|
|
|
|
GenericWebPart genericWebPart = webPart as GenericWebPart;
|
|
if (genericWebPart != null) {
|
|
Control containedControl = genericWebPart.ChildControl;
|
|
personalizationID = CreatePersonalizationID(containedControl, genericWebPart);
|
|
|
|
SetControlDirty(containedControl, personalizationID, /* isWebPartManager */ false, /* forceSetDirty */ false);
|
|
}
|
|
}
|
|
|
|
/// <internalonly />
|
|
public override void SetWebPartManagerDirty() {
|
|
SetControlDirty(WebPartManager, WebPartManagerPersonalizationID, /* isWebPartManager */ true,
|
|
/* forceSetDirty */ false);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Used to track personalization information, i.e. the data,
|
|
/// and the associated object type and ID.
|
|
/// </devdoc>
|
|
private sealed class PersonalizationInfo {
|
|
public Type _controlType;
|
|
public VirtualPath _controlVPath;
|
|
public string _controlID;
|
|
public bool _isStatic;
|
|
|
|
public IDictionary _properties;
|
|
public PersonalizationDictionary _customProperties;
|
|
|
|
public bool IsMatchingControlType(Control c) {
|
|
if (c is ProxyWebPart) {
|
|
// This code path is currently never hit, since we only load personalization data
|
|
// for ErrorWebPart, and we only replace dynamic WebParts with the ErrorWebPart,
|
|
// and we only check IsMatchingControlType() for static WebParts. However, if this
|
|
// ever changes in the future, we will want to return true for ProxyWebParts.
|
|
return true;
|
|
}
|
|
else if (_controlType == null) {
|
|
// _controlType will be null if there is no longer a Type on the system with the
|
|
// saved type name.
|
|
return false;
|
|
}
|
|
else if (_controlType == typeof(UserControl)) {
|
|
UserControl uc = c as UserControl;
|
|
if (uc != null) {
|
|
return uc.TemplateControlVirtualPath == _controlVPath;
|
|
}
|
|
return false;
|
|
}
|
|
else {
|
|
return _controlType.IsAssignableFrom(c.GetType());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Used to track personalization information for a Control instance.
|
|
/// </devdoc>
|
|
private sealed class ControlInfo {
|
|
public Control _control;
|
|
public IDictionary _personalizableProperties;
|
|
public bool _dirty;
|
|
public bool _allowSetDirty;
|
|
|
|
public IDictionary _defaultProperties;
|
|
public IDictionary _initialProperties;
|
|
public PersonalizationDictionary _customInitialProperties;
|
|
}
|
|
|
|
private enum PersonalizationVersions {
|
|
WhidbeyBeta2 = 1,
|
|
WhidbeyRTM = 2,
|
|
}
|
|
}
|
|
}
|