//------------------------------------------------------------------------------
// <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
    /////////////////////////////////////////////////////////////////////////
}