linux-packaging-mono/mcs/class/referencesource/System.Web/UI/WebParts/TransformerConfigurationWizardBase.cs

//------------------------------------------------------------------------------
// <copyright file="TransformerConfigurationWizardBase.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls.WebParts {

    using System;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Web.UI.WebControls;

    internal abstract class TransformerConfigurationWizardBase : Wizard, ITransformerConfigurationControl {
        private string[] _oldProviderNames;
        private string[] _oldConsumerNames;

        private const int baseIndex = 0;
        private const int oldProviderNamesIndex = 1;
        private const int oldConsumerNamesIndex = 2;
        private const int controlStateArrayLength = 3;

        private static readonly object EventCancelled = new object();
        private static readonly object EventSucceeded = new object();

        protected abstract PropertyDescriptorCollection ConsumerSchema { get; }

        protected string[] OldConsumerNames {
            get {
                return _oldConsumerNames;
            }
            set {
                _oldConsumerNames = value;
            }
        }

        protected string[] OldProviderNames {
            get {
                return _oldProviderNames;
            }
            set {
                _oldProviderNames = value;
            }
        }

        protected abstract PropertyDescriptorCollection ProviderSchema { get; }

        public event EventHandler Cancelled {
            add {
                Events.AddHandler(EventCancelled, value);
            }
            remove {
                Events.RemoveHandler(EventCancelled, value);
            }
        }

        public event EventHandler Succeeded {
            add {
                Events.AddHandler(EventSucceeded, value);
            }
            remove {
                Events.RemoveHandler(EventSucceeded, value);
            }
        }

        protected abstract void CreateWizardSteps();

        protected internal override void LoadControlState(object savedState) {
            if (savedState == null) {
                // Create wizard steps before loading base ControlState.
                CreateWizardSteps();
                base.LoadControlState(null);
            }
            else {
                object[] myState = (object[])savedState;
                if (myState.Length != controlStateArrayLength) {
                    throw new ArgumentException(SR.GetString(SR.Invalid_ControlState));
                }

                if (myState[oldProviderNamesIndex] != null) {
                    OldProviderNames = (string[])myState[oldProviderNamesIndex];
                }
                if (myState[oldConsumerNamesIndex] != null) {
                    OldConsumerNames = (string[])myState[oldConsumerNamesIndex];
                }

                // Create wizard steps before loading base ControlState.
                CreateWizardSteps();
                base.LoadControlState(myState[baseIndex]);
            }
        }

        protected override void OnCancelButtonClick(EventArgs e) {
            OnCancelled(EventArgs.Empty);
            base.OnCancelButtonClick(e);
        }

        private void OnCancelled(EventArgs e) {
            EventHandler handler = (EventHandler)Events[EventCancelled];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected override void OnFinishButtonClick(WizardNavigationEventArgs e) {
            OnSucceeded(EventArgs.Empty);
            base.OnFinishButtonClick(e);
        }

        protected internal override void OnInit(EventArgs e) {
            DisplayCancelButton = true;
            DisplaySideBar = false;

            if (Page != null) {
                Page.RegisterRequiresControlState(this);
                Page.PreRenderComplete += new EventHandler(this.OnPagePreRenderComplete);
            }
            base.OnInit(e);
        }

        private void OnPagePreRenderComplete(object sender, EventArgs e) {
            // Copy current schemas into arrays
            string[] providerNames = ConvertSchemaToArray(ProviderSchema);
            string[] consumerNames = ConvertSchemaToArray(ConsumerSchema);

            // If current schemas are not the same as the old schemas, or if the WizardSteps have
            // not been created yet, update the old schemas and recreate the Wizard steps.
            if (StringArraysDifferent(providerNames, OldProviderNames) ||
                StringArraysDifferent(consumerNames, OldConsumerNames) || WizardSteps.Count == 0) {
                OldProviderNames = providerNames;
                OldConsumerNames = consumerNames;

                WizardSteps.Clear();
                ClearChildState();

                CreateWizardSteps();
                ActiveStepIndex = 0;
            }

            // We should always have at least 1 WizardStep before we Render
            Debug.Assert(WizardSteps.Count > 0);
        }

        private string[] ConvertSchemaToArray(PropertyDescriptorCollection schema) {
            string[] names = null;

            if (schema != null && schema.Count > 0) {
                names = new string[schema.Count * 2];
                for (int i=0; i < schema.Count; i++) {
                    PropertyDescriptor descriptor = schema[i];
                    if (descriptor != null) {
                        names[2*i] = descriptor.DisplayName;
                        names[2*i + 1] = descriptor.Name;
                    }
                }
            }

            return names;
        }

        private void OnSucceeded(EventArgs e) {
            EventHandler handler = (EventHandler)Events[EventSucceeded];
            if (handler != null) {
                handler(this, e);
            }
        }

        protected internal override object SaveControlState() {
            object[] myState = new object[controlStateArrayLength];

            myState[baseIndex] = base.SaveControlState();
            myState[oldProviderNamesIndex] = OldProviderNames;
            myState[oldConsumerNamesIndex] = OldConsumerNames;

            for (int i=0; i < controlStateArrayLength; i++) {
                if (myState[i] != null) {
                    return myState;
                }
            }

            // More performant to return null than an array of null values
            return null;
        }

        private bool StringArraysDifferent(string[] arrA, string[] arrB) {
            int lengthA = (arrA == null) ? 0 : arrA.Length;
            int lengthB = (arrB == null) ? 0 : arrB.Length;

            if (lengthA != lengthB) {
                return true;
            }
            else {
                for (int i=0; i < lengthB; i++) {
                    if (arrA[i] != arrB[i]) {
                        return true;
                    }
                }
            }

            return false;
        }
    }
}