mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
1274 lines
45 KiB
C#
1274 lines
45 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="PropertyOverridesDialog.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.Design.MobileControls
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Globalization;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Reflection;
|
|
using System.Windows.Forms;
|
|
using System.Windows.Forms.Design;
|
|
|
|
using Control = System.Web.UI.Control;
|
|
|
|
using System.Web.UI.MobileControls;
|
|
using System.Web.UI.Design.MobileControls.Converters;
|
|
using System.Web.UI.Design.MobileControls.Util;
|
|
|
|
[
|
|
System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand,
|
|
Flags=System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)
|
|
]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal sealed class PropertyOverridesDialog :
|
|
DesignerForm, IRefreshableDeviceSpecificEditor, IDeviceSpecificDesigner
|
|
{
|
|
private bool _isDirty = true;
|
|
private IDeviceSpecificDesigner _designer;
|
|
private int _mergingContext;
|
|
private System.Windows.Forms.Control _header;
|
|
private String _currentDeviceSpecificID;
|
|
private IDictionary _cachedDeviceSpecifics =
|
|
new HybridDictionary(true /* make case-insensitive */);
|
|
private bool _ignoreSelectionChanged = true;
|
|
|
|
private System.Windows.Forms.Label _lblProperties;
|
|
private System.Windows.Forms.PropertyGrid _pgProperties;
|
|
private System.Windows.Forms.Button _btnEditFilters;
|
|
private System.Windows.Forms.ComboBox _cbChoices;
|
|
private System.Windows.Forms.Label _lblAppliedFilters;
|
|
private System.Windows.Forms.Button _cmdOK;
|
|
private System.Windows.Forms.Button _cmdCancel;
|
|
private System.Windows.Forms.Panel _pnlMain;
|
|
|
|
internal PropertyOverridesDialog(
|
|
IDeviceSpecificDesigner designer,
|
|
int mergingContext
|
|
) : base(designer.UnderlyingControl.Site) {
|
|
_designer = designer;
|
|
_mergingContext = mergingContext;
|
|
|
|
// Required for Win Form Designer support
|
|
InitializeComponent();
|
|
|
|
this._lblAppliedFilters.Text =
|
|
SR.GetString(SR.PropertyOverridesDialog_AppliedDeviceFilters);
|
|
this._btnEditFilters.Text = SR.GetString(SR.GenericDialog_Edit);
|
|
this._lblProperties.Text =
|
|
SR.GetString(SR.PropertyOverridesDialog_DeviceSpecificProperties);
|
|
this._cmdOK.Text = SR.GetString(SR.GenericDialog_OKBtnCaption);
|
|
this._cmdCancel.Text = SR.GetString(SR.GenericDialog_CancelBtnCaption);
|
|
|
|
int tabOffset = GenericUI.InitDialog(
|
|
this,
|
|
_designer,
|
|
_mergingContext
|
|
);
|
|
|
|
this.Text = _designer.UnderlyingControl.ID
|
|
+ " - " + SR.GetString(SR.PropertyOverridesDialog_Title);
|
|
SetTabIndexes(tabOffset);
|
|
_designer.SetDeviceSpecificEditor(this);
|
|
|
|
// Note that the following can cause an
|
|
// IDeviceSpecificDesigner.Refresh() to occur as a side-effect.
|
|
_designer.RefreshHeader(_mergingContext);
|
|
_ignoreSelectionChanged = false;
|
|
|
|
// NOTE: Calling CurrentDeviceSpecificID will cause a refresh to
|
|
// happen as a side effect.
|
|
_currentDeviceSpecificID = _designer.CurrentDeviceSpecificID;
|
|
if(_currentDeviceSpecificID != null)
|
|
{
|
|
_cbChoices.Items.Clear();
|
|
LoadChoices(_currentDeviceSpecificID);
|
|
if(!ValidateLoadedChoices())
|
|
{
|
|
// Throw to prevent dialog from opening. Caught and hidden
|
|
// by PropertyOverridesTypeEditor.cs
|
|
throw new InvalidChoiceException(
|
|
"Property overrides dialog can not open because there " +
|
|
"are invalid choices defined in the page."
|
|
);
|
|
}
|
|
}
|
|
|
|
// Register Event Handlers
|
|
_cbChoices.SelectedIndexChanged += new EventHandler(
|
|
OnFilterSelected
|
|
);
|
|
_btnEditFilters.Click += new EventHandler(OnEditFilters);
|
|
_cmdOK.Click += new EventHandler(OnOK);
|
|
_cmdCancel.Click += new EventHandler(OnCancel);
|
|
UpdateUI();
|
|
}
|
|
|
|
protected override string HelpTopic {
|
|
get {
|
|
return "net.Mobile.PropertyOverridesDialog";
|
|
}
|
|
}
|
|
|
|
internal void SetTabIndexes(int tabOffset)
|
|
{
|
|
this._pnlMain.TabIndex = ++tabOffset;
|
|
this._lblAppliedFilters.TabIndex = ++tabOffset;
|
|
this._cbChoices.TabIndex = ++tabOffset;
|
|
this._btnEditFilters.TabIndex = ++tabOffset;
|
|
this._lblProperties.TabIndex = ++tabOffset;
|
|
this._pgProperties.TabIndex = ++tabOffset;
|
|
this._cmdOK.TabIndex = ++tabOffset;
|
|
this._cmdCancel.TabIndex = ++tabOffset;
|
|
}
|
|
|
|
private void InitializeComponent()
|
|
{
|
|
this._cbChoices = new System.Windows.Forms.ComboBox();
|
|
this._cmdOK = new System.Windows.Forms.Button();
|
|
this._btnEditFilters = new System.Windows.Forms.Button();
|
|
this._pnlMain = new System.Windows.Forms.Panel();
|
|
this._pgProperties = new System.Windows.Forms.PropertyGrid();
|
|
this._lblProperties = new System.Windows.Forms.Label();
|
|
this._lblAppliedFilters = new System.Windows.Forms.Label();
|
|
this._cmdCancel = new System.Windows.Forms.Button();
|
|
this._cbChoices.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
|
|
this._cbChoices.DropDownWidth = 195;
|
|
this._cbChoices.Location = new System.Drawing.Point(0, 16);
|
|
this._cbChoices.Size = new System.Drawing.Size(195, 21);
|
|
this._cmdOK.Location = new System.Drawing.Point(120, 290);
|
|
this._cmdCancel.Location = new System.Drawing.Point(201, 290);
|
|
this._btnEditFilters.Location = new System.Drawing.Point(201, 15);
|
|
this._btnEditFilters.Size = new System.Drawing.Size(75, 23);
|
|
this._pnlMain.Anchor = (System.Windows.Forms.AnchorStyles.Bottom
|
|
| System.Windows.Forms.AnchorStyles.Left);
|
|
this._pnlMain.Controls.AddRange(new System.Windows.Forms.Control[] {
|
|
this._cmdCancel,
|
|
this._cmdOK,
|
|
this._lblProperties,
|
|
this._pgProperties,
|
|
this._btnEditFilters,
|
|
this._cbChoices,
|
|
this._lblAppliedFilters});
|
|
this._pnlMain.Location = new System.Drawing.Point(6, 5);
|
|
this._pnlMain.Size = new System.Drawing.Size(276, 313);
|
|
this._pgProperties.CommandsVisibleIfAvailable = false;
|
|
this._pgProperties.HelpVisible = false;
|
|
this._pgProperties.LargeButtons = false;
|
|
this._pgProperties.LineColor = System.Drawing.SystemColors.ScrollBar;
|
|
this._pgProperties.Location = new System.Drawing.Point(0, 64);
|
|
this._pgProperties.PropertySort = System.Windows.Forms.PropertySort.Alphabetical;
|
|
this._pgProperties.Size = new System.Drawing.Size(275, 220);
|
|
this._pgProperties.Text = "PropertyGrid";
|
|
this._pgProperties.ToolbarVisible = false;
|
|
this._pgProperties.ViewBackColor = System.Drawing.SystemColors.Window;
|
|
this._pgProperties.ViewForeColor = System.Drawing.SystemColors.WindowText;
|
|
this._pgProperties.PropertyValueChanged += new PropertyValueChangedEventHandler(this.OnPropertyValueChanged);
|
|
this._lblProperties.Location = new System.Drawing.Point(0, 48);
|
|
this._lblProperties.Size = new System.Drawing.Size(275, 16);
|
|
this._lblAppliedFilters.Size = new System.Drawing.Size(275, 16);
|
|
this.AcceptButton = _cmdOK;
|
|
this.CancelButton = _cmdCancel;
|
|
this.ClientSize = new System.Drawing.Size(285, 325);
|
|
this.Controls.AddRange(new System.Windows.Forms.Control[] {this._pnlMain});
|
|
}
|
|
|
|
private void CacheState(String deviceSpecificID)
|
|
{
|
|
_cachedDeviceSpecifics[deviceSpecificID] =
|
|
new PropertyOverridesCachedState(_cbChoices);
|
|
}
|
|
|
|
private void CacheCurrentState()
|
|
{
|
|
CacheState(_currentDeviceSpecificID);
|
|
}
|
|
|
|
private bool RestoreState(String deviceSpecificID)
|
|
{
|
|
if (null != deviceSpecificID)
|
|
{
|
|
_currentDeviceSpecificID = deviceSpecificID.ToLower(CultureInfo.InvariantCulture);
|
|
PropertyOverridesCachedState state =
|
|
(PropertyOverridesCachedState) _cachedDeviceSpecifics[
|
|
_currentDeviceSpecificID
|
|
];
|
|
if(state != null)
|
|
{
|
|
state.Restore(_cbChoices);
|
|
foreach(ChoiceTreeNode node in state.Choices)
|
|
{
|
|
node.Choice.Refresh();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_currentDeviceSpecificID = null;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[Conditional("DEBUG")]
|
|
private void debug_CheckChoicesForDuplicate(DeviceSpecificChoice runtimeChoice)
|
|
{
|
|
foreach(ChoiceTreeNode choiceNode in _cbChoices.Items)
|
|
{
|
|
if(choiceNode.Name == runtimeChoice.Filter
|
|
&& choiceNode.RuntimeChoice.Argument == runtimeChoice.Argument)
|
|
{
|
|
Debug.Fail("Loaded duplicate choice: " +
|
|
DesignerUtility.ChoiceToUniqueIdentifier(runtimeChoice));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadChoices(String deviceSpecificID)
|
|
{
|
|
DeviceSpecific ds;
|
|
_designer.GetDeviceSpecific(deviceSpecificID, out ds);
|
|
LoadChoices(ds);
|
|
}
|
|
|
|
private void LoadChoices(DeviceSpecific deviceSpecific)
|
|
{
|
|
if(deviceSpecific != null)
|
|
{
|
|
foreach(DeviceSpecificChoice runtimeChoice in deviceSpecific.Choices)
|
|
{
|
|
debug_CheckChoicesForDuplicate(runtimeChoice);
|
|
ChoiceTreeNode newChoiceNode = new ChoiceTreeNode(
|
|
null,
|
|
runtimeChoice,
|
|
_designer
|
|
);
|
|
newChoiceNode.IncludeArgument = true;
|
|
_cbChoices.Items.Add(newChoiceNode);
|
|
}
|
|
}
|
|
UpdateUI();
|
|
}
|
|
|
|
private bool ValidateLoadedChoices()
|
|
{
|
|
StringCollection duplicateChoices =
|
|
DesignerUtility.GetDuplicateChoiceTreeNodes(
|
|
_cbChoices.Items
|
|
);
|
|
|
|
if(duplicateChoices.Count > 0)
|
|
{
|
|
if (!_ignoreSelectionChanged)
|
|
{
|
|
GenericUI.ShowWarningMessage(
|
|
SR.GetString(SR.PropertyOverridesDialog_Title),
|
|
SR.GetString(SR.PropertyOverridesDialog_DuplicateChoices,
|
|
GenericUI.BuildCommaDelimitedList(duplicateChoices))
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void SaveChoices()
|
|
{
|
|
if(_currentDeviceSpecificID != null)
|
|
{
|
|
CacheCurrentState();
|
|
}
|
|
foreach (DictionaryEntry entry in _cachedDeviceSpecifics)
|
|
{
|
|
PropertyOverridesCachedState state =
|
|
(PropertyOverridesCachedState) entry.Value;
|
|
state.SaveChoicesFromComboBox(
|
|
_designer,
|
|
(String) entry.Key
|
|
);
|
|
}
|
|
}
|
|
|
|
private void UpdateUI()
|
|
{
|
|
if(_cbChoices.SelectedItem == null && _cbChoices.Items.Count > 0)
|
|
{
|
|
_cbChoices.SelectedItem = _cbChoices.Items[0];
|
|
}
|
|
|
|
ChoiceTreeNode choice = (ChoiceTreeNode) _cbChoices.SelectedItem;
|
|
bool isChoiceSelected = (choice != null);
|
|
if (isChoiceSelected)
|
|
{
|
|
_cbChoices.Text = choice.ToString();
|
|
_pgProperties.SelectedObject =
|
|
choice.Choice;
|
|
}
|
|
else
|
|
{
|
|
_cbChoices.Text = String.Empty;
|
|
_pgProperties.SelectedObject = null;
|
|
}
|
|
_cbChoices.Enabled = isChoiceSelected;
|
|
_pgProperties.Enabled = isChoiceSelected;
|
|
_btnEditFilters.Enabled = (_currentDeviceSpecificID != null);
|
|
}
|
|
|
|
private void SetDirty(bool dirty)
|
|
{
|
|
if (dirty)
|
|
{
|
|
if (false == _isDirty)
|
|
{
|
|
_isDirty = true;
|
|
_cmdCancel.Text = SR.GetString(SR.GenericDialog_CancelBtnCaption);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (true == _isDirty)
|
|
{
|
|
_isDirty = false;
|
|
_cmdCancel.Text = SR.GetString(SR.GenericDialog_CloseBtnCaption);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Begin Event Handling
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
private void OnEditFilters(Object sender, EventArgs e)
|
|
{
|
|
ISite componentSite = ((IComponent)(_designer.UnderlyingControl)).Site;
|
|
Debug.Assert(componentSite != null, "Expected the runtime control to be sited.");
|
|
|
|
IComponentChangeService changeService =
|
|
(IComponentChangeService)componentSite.GetService(typeof(IComponentChangeService));
|
|
|
|
IMobileWebFormServices wfServices =
|
|
(IMobileWebFormServices)componentSite.GetService(typeof(IMobileWebFormServices));
|
|
|
|
DialogResult result = DialogResult.Cancel;
|
|
try
|
|
{
|
|
AppliedDeviceFiltersDialog dialog = new
|
|
AppliedDeviceFiltersDialog(
|
|
this,
|
|
_mergingContext
|
|
);
|
|
|
|
result = dialog.ShowDialog();
|
|
}
|
|
finally
|
|
{
|
|
if (result != DialogResult.Cancel)
|
|
{
|
|
SaveChoices();
|
|
SetDirty(false);
|
|
|
|
if (changeService != null)
|
|
{
|
|
changeService.OnComponentChanged(_designer.UnderlyingControl, null, null, null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnFilterSelected(Object sender, EventArgs e)
|
|
{
|
|
UpdateUI();
|
|
}
|
|
|
|
private void OnOK(Object sender, EventArgs e)
|
|
{
|
|
SaveChoices();
|
|
Close();
|
|
DialogResult = DialogResult.OK;
|
|
}
|
|
|
|
private void OnCancel(Object sender, EventArgs e)
|
|
{
|
|
Close();
|
|
DialogResult = DialogResult.Cancel;
|
|
}
|
|
|
|
private void OnPropertyValueChanged(Object sender,
|
|
PropertyValueChangedEventArgs e)
|
|
{
|
|
SetDirty(true);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// End Event Handling
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Begin IRefreshableComponentEditor Implementation
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
bool IRefreshableDeviceSpecificEditor.RequestRefresh()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void IRefreshableDeviceSpecificEditor.Refresh(
|
|
String deviceSpecificID,
|
|
DeviceSpecific deviceSpecific
|
|
) {
|
|
if (_currentDeviceSpecificID != null)
|
|
{
|
|
CacheCurrentState();
|
|
}
|
|
_cbChoices.Items.Clear();
|
|
|
|
if (!RestoreState(deviceSpecificID))
|
|
{
|
|
LoadChoices(deviceSpecific);
|
|
if(!ValidateLoadedChoices())
|
|
{
|
|
_designer.RefreshHeader(
|
|
MobileControlDesigner.MergingContextProperties
|
|
);
|
|
}
|
|
}
|
|
UpdateUI();
|
|
}
|
|
|
|
void IRefreshableDeviceSpecificEditor.UnderlyingObjectsChanged()
|
|
{
|
|
SaveChoices();
|
|
SetDirty(false);
|
|
}
|
|
|
|
private bool InExternalCacheEditMode
|
|
{
|
|
get
|
|
{
|
|
return _cacheBuffer != null;
|
|
}
|
|
}
|
|
|
|
private IDictionary _cacheBuffer = null;
|
|
|
|
void IRefreshableDeviceSpecificEditor.BeginExternalDeviceSpecificEdit()
|
|
{
|
|
Debug.Assert(!InExternalCacheEditMode,
|
|
"Call to BeginExternalDeviceSpecificEdit() while already in external "
|
|
+ "cache edit mode.");
|
|
if(_currentDeviceSpecificID != null)
|
|
{
|
|
CacheCurrentState();
|
|
_currentDeviceSpecificID = null;
|
|
}
|
|
_cacheBuffer = new HybridDictionary(
|
|
true /* make case-insensitive*/ );
|
|
foreach(DictionaryEntry entry in _cachedDeviceSpecifics)
|
|
{
|
|
_cacheBuffer.Add(entry.Key, entry.Value);
|
|
}
|
|
}
|
|
|
|
void IRefreshableDeviceSpecificEditor.EndExternalDeviceSpecificEdit(
|
|
bool commitChanges)
|
|
{
|
|
Debug.Assert(InExternalCacheEditMode,
|
|
"Call to EndExternalDeviceSpecificEdit() while not in external "
|
|
+ "cache edit mode.");
|
|
if(commitChanges)
|
|
{
|
|
_cachedDeviceSpecifics = _cacheBuffer;
|
|
}
|
|
_cacheBuffer = null;
|
|
}
|
|
|
|
void IRefreshableDeviceSpecificEditor.DeviceSpecificRenamed(
|
|
String oldDeviceSpecificID, String newDeviceSpecificID)
|
|
{
|
|
Debug.Assert(InExternalCacheEditMode,
|
|
"Call to DeviceSpecificRenamed() while not in external "
|
|
+ "cache edit mode.");
|
|
Object value = _cacheBuffer[oldDeviceSpecificID];
|
|
if(value != null)
|
|
{
|
|
_cacheBuffer.Remove(oldDeviceSpecificID);
|
|
_cacheBuffer.Add(newDeviceSpecificID, value);
|
|
}
|
|
}
|
|
|
|
void IRefreshableDeviceSpecificEditor.DeviceSpecificDeleted(
|
|
String deviceSpecificID)
|
|
{
|
|
Debug.Assert(InExternalCacheEditMode,
|
|
"Call to DeviceSpecificDeleted() while not in external "
|
|
+ "cache edit mode.");
|
|
_cacheBuffer.Remove(deviceSpecificID);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// End IRefreshableComponentEditor Implementation
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Begin IDeviceSpecificDesigner Implementation
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
void IDeviceSpecificDesigner.SetDeviceSpecificEditor
|
|
(IRefreshableDeviceSpecificEditor editor)
|
|
{
|
|
}
|
|
|
|
String IDeviceSpecificDesigner.CurrentDeviceSpecificID
|
|
{
|
|
get
|
|
{
|
|
return _currentDeviceSpecificID;
|
|
}
|
|
}
|
|
|
|
System.Windows.Forms.Control IDeviceSpecificDesigner.Header
|
|
{
|
|
get
|
|
{
|
|
return _header;
|
|
}
|
|
}
|
|
|
|
System.Web.UI.Control IDeviceSpecificDesigner.UnderlyingControl
|
|
{
|
|
get
|
|
{
|
|
return _designer.UnderlyingControl;
|
|
}
|
|
}
|
|
|
|
Object IDeviceSpecificDesigner.UnderlyingObject
|
|
{
|
|
get
|
|
{
|
|
return _designer.UnderlyingObject;
|
|
}
|
|
}
|
|
|
|
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
|
|
{
|
|
Debug.Assert(deviceSpecificParentID == _currentDeviceSpecificID);
|
|
|
|
ds = null;
|
|
if (_cbChoices.Items.Count > 0)
|
|
{
|
|
ds = new DeviceSpecific();
|
|
foreach (ChoiceTreeNode choiceNode in _cbChoices.Items)
|
|
{
|
|
DeviceSpecificChoice choice = choiceNode.Choice.RuntimeChoice;
|
|
ds.Choices.Add(choice);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
|
|
{
|
|
Debug.Assert(_currentDeviceSpecificID != null);
|
|
_cbChoices.Items.Clear();
|
|
LoadChoices(ds);
|
|
UpdateUI();
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.InitHeader(int mergingContext)
|
|
{
|
|
HeaderPanel panel = new HeaderPanel();
|
|
HeaderLabel lblDescription = new HeaderLabel();
|
|
|
|
lblDescription.TabIndex = 0;
|
|
lblDescription.Text = SR.GetString(SR.MobileControl_SettingGenericChoiceDescription);
|
|
|
|
panel.Height = lblDescription.Height;
|
|
panel.Width = lblDescription.Width;
|
|
panel.Controls.Add(lblDescription);
|
|
_header = panel;
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.RefreshHeader(int mergingContext)
|
|
{
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.UseCurrentDeviceSpecificID()
|
|
{
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// End IDeviceSpecificDesigner Implementation
|
|
/////////////////////////////////////////////////////////////////////////
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Begin Internal Class
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
[
|
|
System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand,
|
|
Flags=System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)
|
|
]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class ChoicePropertyFilter :
|
|
ICustomTypeDescriptor, IDeviceSpecificChoiceDesigner, IComponent
|
|
{
|
|
private DeviceSpecificChoice _choice;
|
|
private Object _copyOfOriginalObject;
|
|
private Object _underlyingObject;
|
|
private IDeviceSpecificDesigner _designer;
|
|
private Hashtable _specialProp_buffer = new Hashtable();
|
|
private EventHandler _specialProp_delegate = null;
|
|
private ISite _site = null;
|
|
private EventHandlerList _events;
|
|
private static readonly Object _eventDisposed = new Object();
|
|
private static readonly String _alternateUrl = "AlternateUrl";
|
|
private static readonly String _navigateUrl = "NavigateUrl";
|
|
|
|
internal ChoicePropertyFilter(
|
|
DeviceSpecificChoice choice,
|
|
IDeviceSpecificDesigner designer,
|
|
ISite site
|
|
) {
|
|
_events = new EventHandlerList();
|
|
_choice = choice;
|
|
_site = site;
|
|
_designer = designer;
|
|
|
|
CreateLocalCopiesOfObjects();
|
|
}
|
|
|
|
private void CreateLocalCopiesOfObjects()
|
|
{
|
|
// We make this copy of the original to remove the object from
|
|
// the inheritance chain.
|
|
_copyOfOriginalObject = CloneTarget(_designer.UnderlyingObject);
|
|
_underlyingObject = CloneTarget(_designer.UnderlyingObject);
|
|
|
|
// We need to pop up editors when certain property values change
|
|
RegisterForPropertyChangeEvents();
|
|
|
|
// Copy properties set on DeviceSpecificChoice
|
|
ApplyChoiceToRuntimeControl();
|
|
}
|
|
|
|
internal void Refresh()
|
|
{
|
|
ApplyChangesToRuntimeChoice();
|
|
CreateLocalCopiesOfObjects();
|
|
}
|
|
|
|
private void RegisterForPropertyChangeEvents()
|
|
{
|
|
foreach(PropertyDescriptor property in TypeDescriptor.GetProperties(
|
|
_underlyingObject.GetType()
|
|
)) {
|
|
if(property.Converter is NavigateUrlConverter &&
|
|
(property.Name == _navigateUrl ||
|
|
property.Name == _alternateUrl))
|
|
{
|
|
//
|
|
|
|
if (property.Name == _navigateUrl)
|
|
{
|
|
_specialProp_delegate = new EventHandler(OnNavigateUrlChanged);
|
|
}
|
|
else
|
|
{
|
|
_specialProp_delegate = new EventHandler(OnAlternateUrlChanged);
|
|
}
|
|
_specialProp_buffer[property.Name] = property.GetValue(_underlyingObject);
|
|
property.AddValueChanged(
|
|
_underlyingObject,
|
|
_specialProp_delegate
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Object CloneTarget(Object target)
|
|
{
|
|
Object clone = Activator.CreateInstance(
|
|
target.GetType()
|
|
);
|
|
// We need to copy the Site over to the new object incase setting
|
|
// properties has a side effect that requires the component model
|
|
// to be intact. (e.g., Launching UrlPicker for NavigateUrl).
|
|
if(clone is IComponent)
|
|
{
|
|
((IComponent)clone).Site = ((IComponent)target).Site;
|
|
}
|
|
// We also need to copy the Page over in case runtime properties
|
|
// try to access the page.
|
|
if(clone is System.Web.UI.Control)
|
|
{
|
|
((Control)clone).Page = ((Control)target).Page;
|
|
}
|
|
CopyOverridableProperties(target, clone);
|
|
return clone;
|
|
}
|
|
|
|
private void CopyStyleProperties(Style source, Style dest)
|
|
{
|
|
// We copy the StateBag to duplicate the style properties without
|
|
// walking the inheritance.
|
|
dest.State.Clear();
|
|
foreach(String key in source.State.Keys)
|
|
{
|
|
dest.State[key] = source.State[key];
|
|
}
|
|
}
|
|
|
|
private void CopyOverridableProperties(Object source, Object dest)
|
|
{
|
|
MobileControl destControl = null;
|
|
|
|
// HACK: To avoid copying expandable property FontInfo. We will
|
|
// need to required that expandable properties implement
|
|
// ICloneable for our designer extensibility story.
|
|
if(source is Style)
|
|
{
|
|
CopyStyleProperties((Style)source, (Style)dest);
|
|
return;
|
|
}
|
|
|
|
if(source is MobileControl)
|
|
{
|
|
// If the control is a MobileControl, we copy the style's
|
|
// StateBag to get the non-inherited proprety values.
|
|
destControl = (MobileControl) dest;
|
|
MobileControl sourceControl = (MobileControl) source;
|
|
CopyStyleProperties(sourceControl.Style, destControl.Style);
|
|
}
|
|
|
|
// Copy remaining properties not contained in the style (or
|
|
// all properties if not a mobile control.)
|
|
PropertyDescriptorCollection properties =
|
|
TypeDescriptor.GetProperties(dest.GetType());
|
|
foreach(PropertyDescriptor property in properties)
|
|
{
|
|
if(IsDeviceOverridable(property)
|
|
&& (destControl == null
|
|
|| !PropertyExistsInStyle(property, destControl.Style)))
|
|
{
|
|
CopyProperty(property, source, dest);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CopyProperty(PropertyDescriptor property,
|
|
Object source,
|
|
Object dest)
|
|
{
|
|
Object value = property.GetValue(source);
|
|
|
|
if(property.Converter is ExpandableObjectConverter)
|
|
{
|
|
if(value is ICloneable)
|
|
{
|
|
value = ((ICloneable)value).Clone();
|
|
}
|
|
else
|
|
{
|
|
throw new Exception(
|
|
SR.GetString(
|
|
SR.PropertyOverridesDialog_NotICloneable,
|
|
property.Name,
|
|
property.PropertyType.FullName
|
|
)
|
|
);
|
|
}
|
|
}
|
|
property.SetValue(dest, value);
|
|
}
|
|
|
|
private bool PropertyExistsInStyle(
|
|
PropertyDescriptor property, Style style)
|
|
{
|
|
return style.GetType().GetProperty(property.Name) != null;
|
|
}
|
|
|
|
public event EventHandler Disposed
|
|
{
|
|
add
|
|
{
|
|
_events.AddHandler(_eventDisposed, value);
|
|
}
|
|
remove
|
|
{
|
|
_events.RemoveHandler(_eventDisposed, value);
|
|
}
|
|
}
|
|
|
|
public ISite Site
|
|
{
|
|
get
|
|
{
|
|
Debug.Assert(_site != null);
|
|
return _site;
|
|
}
|
|
|
|
set
|
|
{
|
|
_site = value;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_events != null)
|
|
{
|
|
EventHandler handler = (EventHandler)_events[_eventDisposed];
|
|
if (handler != null) handler(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
private void OnNavigateUrlChanged(Object sender, EventArgs e)
|
|
{
|
|
OnSpecialPropertyChanged(sender, true);
|
|
}
|
|
|
|
private void OnAlternateUrlChanged(Object sender, EventArgs e)
|
|
{
|
|
OnSpecialPropertyChanged(sender, false);
|
|
}
|
|
|
|
//
|
|
|
|
|
|
private void OnSpecialPropertyChanged(Object sender, bool navigateUrl)
|
|
{
|
|
IComponent component = (IComponent) sender;
|
|
PropertyDescriptor property
|
|
= TypeDescriptor.GetProperties(component)[navigateUrl ? _navigateUrl : _alternateUrl];
|
|
String newValue = (String) property.GetValue(component);
|
|
String oldValue = (String) _specialProp_buffer[navigateUrl ? _navigateUrl : _alternateUrl];
|
|
newValue = NavigateUrlConverter.GetUrl(
|
|
component,
|
|
newValue,
|
|
oldValue
|
|
);
|
|
property.RemoveValueChanged(
|
|
_underlyingObject,
|
|
_specialProp_delegate
|
|
);
|
|
property.SetValue(component, newValue);
|
|
property.AddValueChanged(
|
|
_underlyingObject,
|
|
_specialProp_delegate
|
|
);
|
|
}
|
|
|
|
private static bool IsDeviceOverridable(PropertyDescriptor property)
|
|
{
|
|
//
|
|
return (
|
|
property.IsBrowsable
|
|
&& ((!property.IsReadOnly)
|
|
|| (property.Converter is ExpandableObjectConverter))
|
|
&& !property.SerializationVisibility.Equals(
|
|
DesignerSerializationVisibility.Hidden)
|
|
&& property.Name != "ID"
|
|
);
|
|
}
|
|
|
|
private void ApplyChoiceToRuntimeControl()
|
|
{
|
|
PropertyDescriptorCollection properties =
|
|
TypeDescriptor.GetProperties(
|
|
_underlyingObject.GetType());
|
|
|
|
foreach(PropertyDescriptor property in properties)
|
|
{
|
|
if(IsDeviceOverridable(property))
|
|
{
|
|
ApplyChoiceToRuntimeControl_helper(
|
|
property,
|
|
_underlyingObject,
|
|
""
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyChoiceToRuntimeControl_helper(
|
|
PropertyDescriptor property,
|
|
Object target,
|
|
String prefix
|
|
) {
|
|
String propertyName = prefix + property.Name;
|
|
String value = ((IAttributeAccessor)_choice).GetAttribute(propertyName) as String;
|
|
|
|
if(property.Converter is ExpandableObjectConverter)
|
|
{
|
|
PropertyDescriptorCollection properties =
|
|
TypeDescriptor.GetProperties(
|
|
property.PropertyType
|
|
);
|
|
foreach(PropertyDescriptor embeddedProperty in properties)
|
|
{
|
|
if(IsDeviceOverridable(embeddedProperty))
|
|
{
|
|
ApplyChoiceToRuntimeControl_helper(
|
|
embeddedProperty,
|
|
property.GetValue(target),
|
|
propertyName + "-"
|
|
);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(value != null)
|
|
{
|
|
try
|
|
{
|
|
property.SetValue(
|
|
target,
|
|
property.Converter.ConvertFromString(value)
|
|
);
|
|
}
|
|
catch
|
|
{
|
|
GenericUI.ShowWarningMessage(
|
|
SR.GetString(SR.PropertyOverridesDialog_Title),
|
|
SR.GetString(
|
|
SR.PropertyOverridesDialog_InvalidPropertyValue,
|
|
value,
|
|
propertyName
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyChangesToRuntimeChoice()
|
|
{
|
|
PropertyDescriptorCollection properties =
|
|
TypeDescriptor.GetProperties(
|
|
_underlyingObject.GetType()
|
|
);
|
|
|
|
foreach(PropertyDescriptor property in properties)
|
|
{
|
|
if (IsDeviceOverridable(property))
|
|
{
|
|
ApplyChangesToRuntimeChoice_helper(
|
|
property,
|
|
_copyOfOriginalObject,
|
|
_underlyingObject,
|
|
"");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyChangesToRuntimeChoice_helper(
|
|
PropertyDescriptor property,
|
|
Object sourceTarget,
|
|
Object destTarget,
|
|
String prefix
|
|
) {
|
|
Object oldValue = property.GetValue(sourceTarget);
|
|
Object newValue = property.GetValue(destTarget);
|
|
|
|
String propertyName = prefix + property.Name;
|
|
|
|
if(property.Converter is ExpandableObjectConverter)
|
|
{
|
|
PropertyDescriptorCollection properties =
|
|
TypeDescriptor.GetProperties(
|
|
newValue.GetType()
|
|
);
|
|
foreach(PropertyDescriptor embeddedProperty in properties)
|
|
{
|
|
if(IsDeviceOverridable(embeddedProperty))
|
|
{
|
|
ApplyChangesToRuntimeChoice_helper(
|
|
embeddedProperty,
|
|
oldValue,
|
|
newValue,
|
|
propertyName + "-"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else if(IsDeviceOverridable(property))
|
|
{
|
|
IAttributeAccessor overrides = (IAttributeAccessor)_choice;
|
|
String oldValueString =
|
|
property.Converter.ConvertToInvariantString(
|
|
oldValue
|
|
);
|
|
String newValueString =
|
|
property.Converter.ConvertToInvariantString(
|
|
newValue
|
|
);
|
|
if(newValueString != oldValueString)
|
|
{
|
|
overrides.SetAttribute(propertyName, newValueString);
|
|
}
|
|
else
|
|
{
|
|
// Clear any previous values we might have loaded
|
|
overrides.SetAttribute(propertyName, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal DeviceSpecificChoice RuntimeChoice
|
|
{
|
|
get
|
|
{
|
|
ApplyChangesToRuntimeChoice();
|
|
return _choice;
|
|
}
|
|
}
|
|
|
|
internal IDeviceSpecificDesigner Designer
|
|
{
|
|
get
|
|
{
|
|
return _designer;
|
|
}
|
|
}
|
|
|
|
internal Object Owner
|
|
{
|
|
get
|
|
{
|
|
return _underlyingObject;
|
|
}
|
|
}
|
|
|
|
private PropertyDescriptorCollection PreFilterProperties(
|
|
PropertyDescriptorCollection originalProperties
|
|
) {
|
|
PropertyDescriptorCollection newProperties =
|
|
new PropertyDescriptorCollection(
|
|
new PropertyDescriptor[] {}
|
|
);
|
|
|
|
foreach(PropertyDescriptor property in originalProperties)
|
|
{
|
|
if (IsDeviceOverridable(property))
|
|
{
|
|
newProperties.Add(property);
|
|
}
|
|
}
|
|
|
|
PropertyDescriptor[] arpd = new PropertyDescriptor[newProperties.Count];
|
|
for(int i = 0; i < newProperties.Count; i++)
|
|
{
|
|
arpd[i] = newProperties[i];
|
|
}
|
|
newProperties = new PropertyDescriptorCollection(arpd);
|
|
|
|
return newProperties;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Begin ICustomTypeDescriptor Implementation
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
System.ComponentModel.AttributeCollection ICustomTypeDescriptor.GetAttributes()
|
|
{
|
|
return TypeDescriptor.GetAttributes(this.GetType());
|
|
}
|
|
|
|
String ICustomTypeDescriptor.GetClassName()
|
|
{
|
|
return TypeDescriptor.GetClassName(this.GetType());
|
|
}
|
|
|
|
String ICustomTypeDescriptor.GetComponentName()
|
|
{
|
|
return TypeDescriptor.GetComponentName(this.GetType());
|
|
}
|
|
|
|
TypeConverter ICustomTypeDescriptor.GetConverter()
|
|
{
|
|
return TypeDescriptor.GetConverter(this.GetType());
|
|
}
|
|
|
|
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
|
|
{
|
|
return TypeDescriptor.GetDefaultEvent(this.GetType());
|
|
}
|
|
|
|
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
|
|
{
|
|
return TypeDescriptor.GetDefaultProperty(this.GetType());
|
|
}
|
|
|
|
Object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
|
|
{
|
|
return TypeDescriptor.GetEditor(this.GetType(), editorBaseType);
|
|
}
|
|
|
|
EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
|
|
{
|
|
return TypeDescriptor.GetEvents(this.GetType());
|
|
}
|
|
|
|
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
|
|
{
|
|
return TypeDescriptor.GetEvents(this.GetType(), attributes);
|
|
}
|
|
|
|
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
|
|
{
|
|
PropertyDescriptorCollection collection =
|
|
TypeDescriptor.GetProperties(
|
|
_underlyingObject.GetType()
|
|
);
|
|
collection = PreFilterProperties(collection);
|
|
return collection;
|
|
}
|
|
|
|
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
|
|
{
|
|
PropertyDescriptorCollection collection =
|
|
TypeDescriptor.GetProperties(
|
|
_underlyingObject.GetType(),
|
|
attributes
|
|
);
|
|
collection = PreFilterProperties(collection);
|
|
return collection;
|
|
}
|
|
|
|
Object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor property)
|
|
{
|
|
return _underlyingObject;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// End ICustomTypeDescriptor Implementation
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// Begin IDeviceSpecificChoiceDesigner Implementation
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
Object IDeviceSpecificChoiceDesigner.UnderlyingObject
|
|
{
|
|
get
|
|
{
|
|
return _designer.UnderlyingObject;
|
|
}
|
|
}
|
|
|
|
Control IDeviceSpecificChoiceDesigner.UnderlyingControl
|
|
{
|
|
get
|
|
{
|
|
return _designer.UnderlyingControl;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// End IDeviceSpecificChoiceDesigner Implementation
|
|
///////////////////////////////////////////////////////////////////////
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// End Internal Class
|
|
////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// Begin Internal Class
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
[
|
|
System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand,
|
|
Flags=System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)
|
|
]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class PropertyOverridesCachedState : DeviceSpecificDialogCachedState
|
|
{
|
|
private ArrayList _cachedComboBox = null;
|
|
|
|
internal PropertyOverridesCachedState(
|
|
ComboBox comboBox
|
|
) {
|
|
_cachedComboBox = new ArrayList();
|
|
foreach(Object o in comboBox.Items)
|
|
{
|
|
_cachedComboBox.Add(o);
|
|
}
|
|
}
|
|
|
|
internal void Restore(
|
|
ComboBox comboBox
|
|
) {
|
|
Object selectedItem = comboBox.SelectedItem;
|
|
comboBox.Items.Clear();
|
|
comboBox.Items.AddRange(_cachedComboBox.ToArray());
|
|
if(selectedItem != null)
|
|
{
|
|
int index = comboBox.Items.IndexOf(selectedItem);
|
|
if(index >= 0)
|
|
{
|
|
comboBox.SelectedItem = comboBox.Items[index];
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool FilterExistsInComboBox(DeviceFilterNode filter)
|
|
{
|
|
foreach(DeviceFilterNode availableFilter in _cachedComboBox)
|
|
{
|
|
if(availableFilter.Name == filter.Name)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
internal void SaveChoicesFromComboBox(
|
|
IDeviceSpecificDesigner designer,
|
|
String deviceSpecificID
|
|
) {
|
|
SaveChoices(designer, deviceSpecificID, _cachedComboBox);
|
|
}
|
|
|
|
internal ArrayList Choices
|
|
{
|
|
get
|
|
{
|
|
return _cachedComboBox;
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// End Internal Class
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// Begin Internal Class
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class InvalidChoiceException : ApplicationException
|
|
{
|
|
internal InvalidChoiceException(String message) : base(message)
|
|
{
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// End Internal Class
|
|
/////////////////////////////////////////////////////////////////////////
|
|
}
|