public ConnectionsZone() : base(WebPartManager.ConnectDisplayMode)
 {
     this._mode = ConnectionsZoneMode.ExistingConnections;
     this._pendingConnectionPointID = string.Empty;
     this._pendingConnectionType = ConnectionType.None;
     this._pendingSelectedValue = null;
     this._pendingConsumerID = string.Empty;
 }
        private bool EnsurePendingData() {
            if (WebPartToConnect == null) {
                ClearPendingConnection();
                _mode = ConnectionsZoneMode.ExistingConnections;
                return false;
            }

            if ((_pendingConsumer != null) &&
                (_pendingConsumerConnectionPoint == null ||
                _pendingProvider == null ||
                _pendingProviderConnectionPoint == null)) {

                DisplayConnectionError();
                return false;
            }

            if (_pendingConnectionType == ConnectionType.Provider) {
                Debug.Assert(_pendingSelectedValue != null);

                _pendingProvider = WebPartToConnect;
                _pendingProviderConnectionPoint =
                    WebPartManager.GetProviderConnectionPoint(WebPartToConnect, _pendingConnectionPointID);

                if (_pendingProviderConnectionPoint == null) {
                    DisplayConnectionError();
                    return false;
                }

                IDictionary consumers = (IDictionary)_connectionPointInfo[_pendingProviderConnectionPoint];
                ConsumerInfo consumerInfo = null;
                if (consumers != null) {
                    consumerInfo = (ConsumerInfo)consumers[_pendingSelectedValue];
                }

                if (consumerInfo == null) {
                    DisplayConnectionError();
                    return false;
                }

                _pendingConsumer = consumerInfo.WebPart;
                _pendingConsumerConnectionPoint = consumerInfo.ConnectionPoint;

                return true;
            }

            string consumerID = _pendingConsumerID;
            if (_pendingConnectionType == ConnectionType.Consumer) {
                if (!String.IsNullOrEmpty(_pendingConnectionID)) {
                    // Editing an existing connection
                    WebPartConnection connection = WebPartManager.Connections[_pendingConnectionID];
                    if (connection != null) {
                        _pendingConnectionPointID = connection.ConsumerConnectionPointID;
                        _pendingConsumer = connection.Consumer;
                        _pendingConsumerConnectionPoint = connection.ConsumerConnectionPoint;
                        _pendingConsumerID = connection.Consumer.ID;
                        _pendingProvider = connection.Provider;
                        _pendingProviderConnectionPoint = connection.ProviderConnectionPoint;
                        _pendingTransformer = connection.Transformer;
                        _pendingSelectedValue = null;
                        _pendingConnectionType = ConnectionType.Consumer;
                        return true;
                    }
                    DisplayConnectionError();
                    return false;
                }
                if (String.IsNullOrEmpty(consumerID)) {
                    _pendingConsumer = WebPartToConnect;
                }
                else {
                    _pendingConsumer = WebPartManager.WebParts[consumerID];
                }

                _pendingConsumerConnectionPoint =
                    WebPartManager.GetConsumerConnectionPoint(_pendingConsumer, _pendingConnectionPointID);

                if (_pendingConsumerConnectionPoint == null) {
                    DisplayConnectionError();
                    return false;
                }

                // Get provider
                if (!String.IsNullOrEmpty(_pendingSelectedValue)) {
                    IDictionary providers = (IDictionary)_connectionPointInfo[_pendingConsumerConnectionPoint];
                    ProviderInfo providerInfo = null;
                    if (providers != null) {
                        providerInfo = (ProviderInfo)providers[_pendingSelectedValue];
                    }

                    if (providerInfo == null) {
                        DisplayConnectionError();
                        return false;
                    }

                    _pendingProvider = providerInfo.WebPart;
                    _pendingProviderConnectionPoint = providerInfo.ConnectionPoint;
                }

                return true;
            }
            else {
                // No pending connection
                Debug.Assert(_pendingConnectionType == ConnectionType.None);

                ClearPendingConnection();

                return false;
            }
        }
        private void ConnectProvider(string providerConnectionPointID) {
            // We don't need to check for AllowConnect on the parts because we're already checking
            // that the data was in the drop-downs in the first place, and these check for AllowConnect.
            WebPart provider = WebPartToConnect;

            if (provider == null || provider.IsClosed) {
                DisplayConnectionError();
                return;
            }

            ProviderConnectionPoint providerConnectionPoint =
                WebPartManager.GetProviderConnectionPoint(provider, providerConnectionPointID);

            if (providerConnectionPoint == null) {
                DisplayConnectionError();
                return;
            }

            EnsureChildControls();

            if (_connectDropDownLists == null ||
                !_connectDropDownLists.Contains(providerConnectionPoint) ||
                _connectionPointInfo == null ||
                !_connectionPointInfo.Contains(providerConnectionPoint)) {

                DisplayConnectionError();
                return;
            }

            DropDownList list = (DropDownList)_connectDropDownLists[providerConnectionPoint];
            // Using Request instead of the control's selected value because some concurrency
            // conditions exist under which the selected item does not exist any more in the list.
            // In this case, we want to display a connection error (VSWhidbey 368543)
            string selectedValue = Page.Request.Form[list.UniqueID];
            if (!String.IsNullOrEmpty(selectedValue)) {
                IDictionary consumers = (IDictionary)_connectionPointInfo[providerConnectionPoint];

                if (consumers == null || !consumers.Contains(selectedValue)) {
                    DisplayConnectionError();
                    return;
                }

                ConsumerInfo consumer = (ConsumerInfo)consumers[selectedValue];
                Type transformerType = consumer.TransformerType;
                if (transformerType != null) {
                    Debug.Assert(transformerType.IsSubclassOf(typeof(WebPartTransformer)));
                    WebPartTransformer transformer =
                        (WebPartTransformer)WebPartUtil.CreateObjectFromType(transformerType);
                    if (GetConfigurationControl(transformer) == null) {
                        if (WebPartManager.CanConnectWebParts(provider, providerConnectionPoint,
                                                                consumer.WebPart, consumer.ConnectionPoint, transformer)) {
                            WebPartManager.ConnectWebParts(provider, providerConnectionPoint,
                                                            consumer.WebPart, consumer.ConnectionPoint, transformer);
                        }
                        else {
                            DisplayConnectionError();
                        }
                        Reset();
                    }
                    else {
                        // Control will be created and added on next call to CreateChildControls
                        _pendingConnectionType = ConnectionType.Provider;
                        _pendingConnectionPointID = providerConnectionPointID;
                        _pendingSelectedValue = selectedValue;
                        _mode = ConnectionsZoneMode.ConfiguringTransformer;
                        ChildControlsCreated = false;
                    }
                }
                else {
                    if (WebPartManager.CanConnectWebParts(provider, providerConnectionPoint,
                                                            consumer.WebPart, consumer.ConnectionPoint)) {
                        WebPartManager.ConnectWebParts(provider, providerConnectionPoint,
                                                        consumer.WebPart, consumer.ConnectionPoint);
                    }
                    else {
                        DisplayConnectionError();
                    }
                    Reset();
                }
                // Reset the list to the blank selection
                list.SelectedValue = null;
            }
        }
        private void SetDropDownProperties() {
            bool anyRelevantControl = false;
            WebPart webPartToConnect = WebPartToConnect;
            if (webPartToConnect != null && !webPartToConnect.IsClosed) {
                Debug.Assert(WebPartManager != null);

                WebPartCollection webParts = WebPartManager.WebParts;

                ProviderConnectionPointCollection providerConnectionPoints =
                    WebPartManager.GetEnabledProviderConnectionPoints(webPartToConnect);
                foreach (ProviderConnectionPoint providerConnectionPoint in providerConnectionPoints) {
                    DropDownList list = (DropDownList)_connectDropDownLists[providerConnectionPoint];
                    if (list == null) {
                        continue;
                    }
                    list.Items.Clear();

                    // Set the selected index to 0, in case it was set by ControlState
                    list.SelectedIndex = 0;

                    IDictionary consumers = GetValidConsumers(webPartToConnect, providerConnectionPoint, webParts);
                    if (consumers.Count == 0) {
                        list.Enabled = false;
                        list.Items.Add(new ListItem(SR.GetString(SR.ConnectionsZone_NoConsumers), String.Empty));
                    }
                    else {
                        list.Enabled = true;
                        list.Items.Add(new ListItem());
                        _connectionPointInfo[providerConnectionPoint] = consumers;

                        // If the WebPart is currently connected on this provider point
                        // and does not support multiple connections,
                        // select the current provider and disable the dropdown.
                        WebPartConnection currentConnection = providerConnectionPoint.AllowsMultipleConnections ?
                            null :
                            WebPartManager.GetConnectionForProvider(webPartToConnect, providerConnectionPoint);
                        WebPart currentConsumerWebPart = null;
                        ConsumerConnectionPoint currentConsumerConnectionPoint = null;
                        if (currentConnection != null) {
                            currentConsumerWebPart = currentConnection.Consumer;
                            currentConsumerConnectionPoint = currentConnection.ConsumerConnectionPoint;
                            list.Enabled = false;
                        }
                        else {
                            anyRelevantControl = true;
                        }

                        foreach (DictionaryEntry consumerEntry in consumers) {
                            ConsumerInfo consumer = (ConsumerInfo)consumerEntry.Value;
                            ListItem item = new ListItem();
                            item.Text = GetDisplayTitle(consumer.WebPart, consumer.ConnectionPoint, true);
                            item.Value = (string)consumerEntry.Key;
                            if (currentConnection != null &&
                                consumer.WebPart == currentConsumerWebPart &&
                                consumer.ConnectionPoint == currentConsumerConnectionPoint) {

                                item.Selected = true;
                            }
                            list.Items.Add(item);
                        }
                    }
                }

                ConsumerConnectionPointCollection consumerConnectionPoints =
                    WebPartManager.GetEnabledConsumerConnectionPoints(webPartToConnect);
                foreach (ConsumerConnectionPoint consumerConnectionPoint in consumerConnectionPoints) {
                    DropDownList list = (DropDownList)_connectDropDownLists[consumerConnectionPoint];
                    if (list == null) {
                        continue;
                    }
                    list.Items.Clear();

                    // Set the selected index to 0, in case it was set by ControlState
                    list.SelectedIndex = 0;

                    IDictionary providers = GetValidProviders(webPartToConnect, consumerConnectionPoint, webParts);
                    if (providers.Count == 0) {
                        list.Enabled = false;
                        list.Items.Add(new ListItem(SR.GetString(SR.ConnectionsZone_NoProviders), String.Empty));
                    }
                    else {
                        list.Enabled = true;
                        list.Items.Add(new ListItem());
                        _connectionPointInfo[consumerConnectionPoint] = providers;

                        // If the WebPart is currently connected on this consumer point
                        // and does not support multiple connections,
                        // select the current provider and disable the dropdown.
                        WebPartConnection currentConnection = consumerConnectionPoint.AllowsMultipleConnections ?
                            null :
                            WebPartManager.GetConnectionForConsumer(webPartToConnect, consumerConnectionPoint);
                        WebPart currentProviderWebPart = null;
                        ProviderConnectionPoint currentProviderConnectionPoint = null;
                        if (currentConnection != null) {
                            currentProviderWebPart = currentConnection.Provider;
                            currentProviderConnectionPoint = currentConnection.ProviderConnectionPoint;
                            list.Enabled = false;
                        }
                        else {
                            anyRelevantControl = true;
                        }

                        foreach (DictionaryEntry providerEntry in providers) {
                            ProviderInfo provider = (ProviderInfo)providerEntry.Value;
                            ListItem item = new ListItem();
                            item.Text = GetDisplayTitle(provider.WebPart, provider.ConnectionPoint, false);
                            item.Value = (string)providerEntry.Key;
                            if (currentConnection != null &&
                                provider.WebPart == currentProviderWebPart &&
                                provider.ConnectionPoint == currentProviderConnectionPoint) {
                                item.Selected = true;
                            }
                            list.Items.Add(item);
                        }
                    }
                }

                if (_pendingConnectionType == ConnectionType.Consumer &&
                    _pendingSelectedValue != null &&
                    _pendingSelectedValue.Length > 0) {

                    EnsurePendingData();

                    if (_pendingConsumerConnectionPoint != null) {
                        // Display the pending connection in the appropriate DropDownList
                        Debug.Assert(_pendingSelectedValue != null);
                        DropDownList list = (DropDownList)_connectDropDownLists[_pendingConsumerConnectionPoint];
                        if (list == null) {
                            _mode = ConnectionsZoneMode.ExistingConnections;
                            return;
                        }
                        SelectValueInList(list, _pendingSelectedValue);
                    }
                    else {
                        _mode = ConnectionsZoneMode.ExistingConnections;
                        return;
                    }
                }
                else if (_pendingConnectionType == ConnectionType.Provider) {
                    EnsurePendingData();

                    if (_pendingProviderConnectionPoint != null) {
                        // Display the pending connection in the appropriate DropDownList
                        Debug.Assert(_pendingSelectedValue != null);
                        DropDownList list = (DropDownList)_connectDropDownLists[_pendingProviderConnectionPoint];
                        if (list == null) {
                            _mode = ConnectionsZoneMode.ExistingConnections;
                            return;
                        }
                        SelectValueInList(list, _pendingSelectedValue);
                    }
                    else {
                        _mode = ConnectionsZoneMode.ExistingConnections;
                        return;
                    }
                }

                if (!anyRelevantControl &&
                    (_mode == ConnectionsZoneMode.ConnectToConsumer ||
                    _mode == ConnectionsZoneMode.ConnectToProvider)) {

                    _mode = ConnectionsZoneMode.ExistingConnections;
                }
            }
        }
 private void Reset() {
     ClearPendingConnection();
     ChildControlsCreated = false;
     _mode = ConnectionsZoneMode.ExistingConnections;
 }
        protected override void RaisePostBackEvent(string eventArgument) {
            if (WebPartToConnect == null) {
                ClearPendingConnection();
                _mode = ConnectionsZoneMode.ExistingConnections;
                return;
            }
            string[] eventArguments = eventArgument.Split(ID_SEPARATOR);
            if (eventArguments.Length == 2 &&
                String.Equals(eventArguments[0], disconnectEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Disconnecting
                if (DisconnectVerb.Visible && DisconnectVerb.Enabled) {
                    string connectionID = eventArguments[1];

                    Disconnect(connectionID);

                    _mode = ConnectionsZoneMode.ExistingConnections;
                }
            }
            else if (eventArguments.Length == 3 &&
                String.Equals(eventArguments[0], connectEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Connecting
                if (ConnectVerb.Visible && ConnectVerb.Enabled) {
                    string connectionPointID = eventArguments[2];
                    if (String.Equals(eventArguments[1], providerEventArgument, StringComparison.OrdinalIgnoreCase)) {
                        ConnectProvider(connectionPointID);
                    }
                    else {
                        ConnectConsumer(connectionPointID);
                    }
                }
            }
            else if (eventArguments.Length == 2 &&
                String.Equals(eventArguments[0], configureEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Displaying transformer UI
                _pendingConnectionID = eventArguments[1];
                _pendingConnectionType = ConnectionType.Consumer;
                _mode = ConnectionsZoneMode.ConfiguringTransformer;
            }
            else if (String.Equals(eventArgument, connectConsumerEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Create connection to consumer
                _mode = ConnectionsZoneMode.ConnectToConsumer;
            }
            else if (String.Equals(eventArgument, connectProviderEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Create connection to provider
                _mode = ConnectionsZoneMode.ConnectToProvider;
            }
            else if (String.Equals(eventArgument, closeEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Closing the zone
                if (CloseVerb.Visible && CloseVerb.Enabled) {
                    Close();
                    _mode = ConnectionsZoneMode.ExistingConnections;
                }
            }
            else if (String.Equals(eventArgument, cancelEventArgument, StringComparison.OrdinalIgnoreCase)) {
                // Cancelling connection creation
                if (CancelVerb.Visible && CancelVerb.Enabled) {
                    _mode = ConnectionsZoneMode.ExistingConnections;
                }
            }
            else {
                base.RaisePostBackEvent(eventArgument);
            }
        }
        protected internal override void LoadControlState(object savedState) {
            if (savedState != null) {
                object[] state = (object[])savedState;
                if (state.Length != controlStateArrayLength) {
                    throw new ArgumentException(SR.GetString(SR.Invalid_ControlState));
                }

                base.LoadControlState(state[baseIndex]);

                if (state[modeIndex] != null) {
                    _mode = (ConnectionsZoneMode)state[modeIndex];
                }
                if (state[pendingConnectionPointIDIndex] != null) {
                    _pendingConnectionPointID = (string)state[pendingConnectionPointIDIndex];
                }
                if (state[pendingConnectionTypeIndex] != null) {
                    _pendingConnectionType = (ConnectionType)state[pendingConnectionTypeIndex];
                }
                if (state[pendingSelectedValueIndex] != null) {
                    _pendingSelectedValue = (string)state[pendingSelectedValueIndex];
                }
                if (state[pendingConsumerIDIndex] != null) {
                    _pendingConsumerID = (string)state[pendingConsumerIDIndex];
                }
                if (state[pendingTransformerTypeNameIndex] != null) {
                    _pendingTransformerConfigurationControlTypeName = (string)state[pendingTransformerTypeNameIndex];
                }
                if (state[pendingConnectionIDIndex] != null) {
                    _pendingConnectionID = (string)state[pendingConnectionIDIndex];
                }
            }
            else {
                base.LoadControlState(null);
            }
        }
 private void ConnectConsumer(string consumerConnectionPointID)
 {
     WebPart webPartToConnect = this.WebPartToConnect;
     if ((webPartToConnect == null) || webPartToConnect.IsClosed)
     {
         this.DisplayConnectionError();
     }
     else
     {
         ConsumerConnectionPoint consumerConnectionPoint = base.WebPartManager.GetConsumerConnectionPoint(webPartToConnect, consumerConnectionPointID);
         if (consumerConnectionPoint == null)
         {
             this.DisplayConnectionError();
         }
         else
         {
             this.EnsureChildControls();
             if (((this._connectDropDownLists == null) || !this._connectDropDownLists.Contains(consumerConnectionPoint)) || ((this._connectionPointInfo == null) || !this._connectionPointInfo.Contains(consumerConnectionPoint)))
             {
                 this.DisplayConnectionError();
             }
             else
             {
                 DropDownList list = (DropDownList) this._connectDropDownLists[consumerConnectionPoint];
                 string str = this.Page.Request.Form[list.UniqueID];
                 if (!string.IsNullOrEmpty(str))
                 {
                     IDictionary dictionary = (IDictionary) this._connectionPointInfo[consumerConnectionPoint];
                     if ((dictionary == null) || !dictionary.Contains(str))
                     {
                         this.DisplayConnectionError();
                     }
                     else
                     {
                         ProviderInfo info = (ProviderInfo) dictionary[str];
                         Type transformerType = info.TransformerType;
                         if (transformerType != null)
                         {
                             WebPartTransformer transformer = (WebPartTransformer) WebPartUtil.CreateObjectFromType(transformerType);
                             if (this.GetConfigurationControl(transformer) == null)
                             {
                                 if (base.WebPartManager.CanConnectWebParts(info.WebPart, info.ConnectionPoint, webPartToConnect, consumerConnectionPoint, transformer))
                                 {
                                     base.WebPartManager.ConnectWebParts(info.WebPart, info.ConnectionPoint, webPartToConnect, consumerConnectionPoint, transformer);
                                 }
                                 else
                                 {
                                     this.DisplayConnectionError();
                                 }
                                 this.Reset();
                             }
                             else
                             {
                                 this._pendingConnectionType = ConnectionType.Consumer;
                                 this._pendingConnectionPointID = consumerConnectionPointID;
                                 this._pendingSelectedValue = str;
                                 this._mode = ConnectionsZoneMode.ConfiguringTransformer;
                                 base.ChildControlsCreated = false;
                             }
                         }
                         else
                         {
                             if (base.WebPartManager.CanConnectWebParts(info.WebPart, info.ConnectionPoint, webPartToConnect, consumerConnectionPoint))
                             {
                                 base.WebPartManager.ConnectWebParts(info.WebPart, info.ConnectionPoint, webPartToConnect, consumerConnectionPoint);
                             }
                             else
                             {
                                 this.DisplayConnectionError();
                             }
                             this.Reset();
                         }
                         list.SelectedValue = null;
                     }
                 }
             }
         }
     }
 }
 protected override void RaisePostBackEvent(string eventArgument)
 {
     if (this.WebPartToConnect == null)
     {
         this.ClearPendingConnection();
         this._mode = ConnectionsZoneMode.ExistingConnections;
     }
     else
     {
         string[] strArray = eventArgument.Split(new char[] { '$' });
         if ((strArray.Length == 2) && string.Equals(strArray[0], "disconnect", StringComparison.OrdinalIgnoreCase))
         {
             if (this.DisconnectVerb.Visible && this.DisconnectVerb.Enabled)
             {
                 string connectionID = strArray[1];
                 this.Disconnect(connectionID);
                 this._mode = ConnectionsZoneMode.ExistingConnections;
             }
         }
         else if ((strArray.Length == 3) && string.Equals(strArray[0], "connect", StringComparison.OrdinalIgnoreCase))
         {
             if (this.ConnectVerb.Visible && this.ConnectVerb.Enabled)
             {
                 string providerConnectionPointID = strArray[2];
                 if (string.Equals(strArray[1], "provider", StringComparison.OrdinalIgnoreCase))
                 {
                     this.ConnectProvider(providerConnectionPointID);
                 }
                 else
                 {
                     this.ConnectConsumer(providerConnectionPointID);
                 }
             }
         }
         else if ((strArray.Length == 2) && string.Equals(strArray[0], "edit", StringComparison.OrdinalIgnoreCase))
         {
             this._pendingConnectionID = strArray[1];
             this._pendingConnectionType = ConnectionType.Consumer;
             this._mode = ConnectionsZoneMode.ConfiguringTransformer;
         }
         else if (string.Equals(eventArgument, "connectconsumer", StringComparison.OrdinalIgnoreCase))
         {
             this._mode = ConnectionsZoneMode.ConnectToConsumer;
         }
         else if (string.Equals(eventArgument, "connectprovider", StringComparison.OrdinalIgnoreCase))
         {
             this._mode = ConnectionsZoneMode.ConnectToProvider;
         }
         else if (string.Equals(eventArgument, "close", StringComparison.OrdinalIgnoreCase))
         {
             if (this.CloseVerb.Visible && this.CloseVerb.Enabled)
             {
                 this.Close();
                 this._mode = ConnectionsZoneMode.ExistingConnections;
             }
         }
         else if (string.Equals(eventArgument, "cancel", StringComparison.OrdinalIgnoreCase))
         {
             if (this.CancelVerb.Visible && this.CancelVerb.Enabled)
             {
                 this._mode = ConnectionsZoneMode.ExistingConnections;
             }
         }
         else
         {
             base.RaisePostBackEvent(eventArgument);
         }
     }
 }
 protected internal override void LoadControlState(object savedState)
 {
     if (savedState != null)
     {
         object[] objArray = (object[]) savedState;
         if (objArray.Length != 8)
         {
             throw new ArgumentException(System.Web.SR.GetString("Invalid_ControlState"));
         }
         base.LoadControlState(objArray[0]);
         if (objArray[1] != null)
         {
             this._mode = (ConnectionsZoneMode) objArray[1];
         }
         if (objArray[2] != null)
         {
             this._pendingConnectionPointID = (string) objArray[2];
         }
         if (objArray[3] != null)
         {
             this._pendingConnectionType = (ConnectionType) objArray[3];
         }
         if (objArray[4] != null)
         {
             this._pendingSelectedValue = (string) objArray[4];
         }
         if (objArray[5] != null)
         {
             this._pendingConsumerID = (string) objArray[5];
         }
         if (objArray[6] != null)
         {
             this._pendingTransformerConfigurationControlTypeName = (string) objArray[6];
         }
         if (objArray[7] != null)
         {
             this._pendingConnectionID = (string) objArray[7];
         }
     }
     else
     {
         base.LoadControlState(null);
     }
 }
 private bool EnsurePendingData()
 {
     if (this.WebPartToConnect == null)
     {
         this.ClearPendingConnection();
         this._mode = ConnectionsZoneMode.ExistingConnections;
         return false;
     }
     if ((this._pendingConsumer != null) && (((this._pendingConsumerConnectionPoint == null) || (this._pendingProvider == null)) || (this._pendingProviderConnectionPoint == null)))
     {
         this.DisplayConnectionError();
         return false;
     }
     if (this._pendingConnectionType == ConnectionType.Provider)
     {
         this._pendingProvider = this.WebPartToConnect;
         this._pendingProviderConnectionPoint = base.WebPartManager.GetProviderConnectionPoint(this.WebPartToConnect, this._pendingConnectionPointID);
         if (this._pendingProviderConnectionPoint == null)
         {
             this.DisplayConnectionError();
             return false;
         }
         IDictionary dictionary = (IDictionary) this._connectionPointInfo[this._pendingProviderConnectionPoint];
         ConsumerInfo info = null;
         if (dictionary != null)
         {
             info = (ConsumerInfo) dictionary[this._pendingSelectedValue];
         }
         if (info == null)
         {
             this.DisplayConnectionError();
             return false;
         }
         this._pendingConsumer = info.WebPart;
         this._pendingConsumerConnectionPoint = info.ConnectionPoint;
         return true;
     }
     string str = this._pendingConsumerID;
     if (this._pendingConnectionType == ConnectionType.Consumer)
     {
         if (!string.IsNullOrEmpty(this._pendingConnectionID))
         {
             WebPartConnection connection = base.WebPartManager.Connections[this._pendingConnectionID];
             if (connection != null)
             {
                 this._pendingConnectionPointID = connection.ConsumerConnectionPointID;
                 this._pendingConsumer = connection.Consumer;
                 this._pendingConsumerConnectionPoint = connection.ConsumerConnectionPoint;
                 this._pendingConsumerID = connection.Consumer.ID;
                 this._pendingProvider = connection.Provider;
                 this._pendingProviderConnectionPoint = connection.ProviderConnectionPoint;
                 this._pendingTransformer = connection.Transformer;
                 this._pendingSelectedValue = null;
                 this._pendingConnectionType = ConnectionType.Consumer;
                 return true;
             }
             this.DisplayConnectionError();
             return false;
         }
         if (string.IsNullOrEmpty(str))
         {
             this._pendingConsumer = this.WebPartToConnect;
         }
         else
         {
             this._pendingConsumer = base.WebPartManager.WebParts[str];
         }
         this._pendingConsumerConnectionPoint = base.WebPartManager.GetConsumerConnectionPoint(this._pendingConsumer, this._pendingConnectionPointID);
         if (this._pendingConsumerConnectionPoint == null)
         {
             this.DisplayConnectionError();
             return false;
         }
         if (!string.IsNullOrEmpty(this._pendingSelectedValue))
         {
             IDictionary dictionary2 = (IDictionary) this._connectionPointInfo[this._pendingConsumerConnectionPoint];
             ProviderInfo info2 = null;
             if (dictionary2 != null)
             {
                 info2 = (ProviderInfo) dictionary2[this._pendingSelectedValue];
             }
             if (info2 == null)
             {
                 this.DisplayConnectionError();
                 return false;
             }
             this._pendingProvider = info2.WebPart;
             this._pendingProviderConnectionPoint = info2.ConnectionPoint;
         }
         return true;
     }
     this.ClearPendingConnection();
     return false;
 }
 private void SetDropDownProperties()
 {
     bool flag = false;
     WebPart webPartToConnect = this.WebPartToConnect;
     if ((webPartToConnect != null) && !webPartToConnect.IsClosed)
     {
         WebPartCollection webParts = base.WebPartManager.WebParts;
         foreach (ProviderConnectionPoint point in base.WebPartManager.GetEnabledProviderConnectionPoints(webPartToConnect))
         {
             DropDownList list = (DropDownList) this._connectDropDownLists[point];
             if (list != null)
             {
                 list.Items.Clear();
                 list.SelectedIndex = 0;
                 IDictionary dictionary = this.GetValidConsumers(webPartToConnect, point, webParts);
                 if (dictionary.Count == 0)
                 {
                     list.Enabled = false;
                     list.Items.Add(new ListItem(System.Web.SR.GetString("ConnectionsZone_NoConsumers"), string.Empty));
                 }
                 else
                 {
                     list.Enabled = true;
                     list.Items.Add(new ListItem());
                     this._connectionPointInfo[point] = dictionary;
                     WebPartConnection connection = point.AllowsMultipleConnections ? null : base.WebPartManager.GetConnectionForProvider(webPartToConnect, point);
                     WebPart consumer = null;
                     ConsumerConnectionPoint consumerConnectionPoint = null;
                     if (connection != null)
                     {
                         consumer = connection.Consumer;
                         consumerConnectionPoint = connection.ConsumerConnectionPoint;
                         list.Enabled = false;
                     }
                     else
                     {
                         flag = true;
                     }
                     foreach (DictionaryEntry entry in dictionary)
                     {
                         ConsumerInfo info = (ConsumerInfo) entry.Value;
                         ListItem item = new ListItem {
                             Text = this.GetDisplayTitle(info.WebPart, info.ConnectionPoint, true),
                             Value = (string) entry.Key
                         };
                         if (((connection != null) && (info.WebPart == consumer)) && (info.ConnectionPoint == consumerConnectionPoint))
                         {
                             item.Selected = true;
                         }
                         list.Items.Add(item);
                     }
                 }
             }
         }
         foreach (ConsumerConnectionPoint point3 in base.WebPartManager.GetEnabledConsumerConnectionPoints(webPartToConnect))
         {
             DropDownList list2 = (DropDownList) this._connectDropDownLists[point3];
             if (list2 != null)
             {
                 list2.Items.Clear();
                 list2.SelectedIndex = 0;
                 IDictionary dictionary2 = this.GetValidProviders(webPartToConnect, point3, webParts);
                 if (dictionary2.Count == 0)
                 {
                     list2.Enabled = false;
                     list2.Items.Add(new ListItem(System.Web.SR.GetString("ConnectionsZone_NoProviders"), string.Empty));
                 }
                 else
                 {
                     list2.Enabled = true;
                     list2.Items.Add(new ListItem());
                     this._connectionPointInfo[point3] = dictionary2;
                     WebPartConnection connection2 = point3.AllowsMultipleConnections ? null : base.WebPartManager.GetConnectionForConsumer(webPartToConnect, point3);
                     WebPart provider = null;
                     ProviderConnectionPoint providerConnectionPoint = null;
                     if (connection2 != null)
                     {
                         provider = connection2.Provider;
                         providerConnectionPoint = connection2.ProviderConnectionPoint;
                         list2.Enabled = false;
                     }
                     else
                     {
                         flag = true;
                     }
                     foreach (DictionaryEntry entry2 in dictionary2)
                     {
                         ProviderInfo info2 = (ProviderInfo) entry2.Value;
                         ListItem item2 = new ListItem {
                             Text = this.GetDisplayTitle(info2.WebPart, info2.ConnectionPoint, false),
                             Value = (string) entry2.Key
                         };
                         if (((connection2 != null) && (info2.WebPart == provider)) && (info2.ConnectionPoint == providerConnectionPoint))
                         {
                             item2.Selected = true;
                         }
                         list2.Items.Add(item2);
                     }
                 }
             }
         }
         if (((this._pendingConnectionType == ConnectionType.Consumer) && (this._pendingSelectedValue != null)) && (this._pendingSelectedValue.Length > 0))
         {
             this.EnsurePendingData();
             if (this._pendingConsumerConnectionPoint == null)
             {
                 this._mode = ConnectionsZoneMode.ExistingConnections;
                 return;
             }
             DropDownList list3 = (DropDownList) this._connectDropDownLists[this._pendingConsumerConnectionPoint];
             if (list3 == null)
             {
                 this._mode = ConnectionsZoneMode.ExistingConnections;
                 return;
             }
             this.SelectValueInList(list3, this._pendingSelectedValue);
         }
         else if (this._pendingConnectionType == ConnectionType.Provider)
         {
             this.EnsurePendingData();
             if (this._pendingProviderConnectionPoint == null)
             {
                 this._mode = ConnectionsZoneMode.ExistingConnections;
                 return;
             }
             DropDownList list4 = (DropDownList) this._connectDropDownLists[this._pendingProviderConnectionPoint];
             if (list4 == null)
             {
                 this._mode = ConnectionsZoneMode.ExistingConnections;
                 return;
             }
             this.SelectValueInList(list4, this._pendingSelectedValue);
         }
         if (!flag && ((this._mode == ConnectionsZoneMode.ConnectToConsumer) || (this._mode == ConnectionsZoneMode.ConnectToProvider)))
         {
             this._mode = ConnectionsZoneMode.ExistingConnections;
         }
     }
 }
 private void Reset()
 {
     this.ClearPendingConnection();
     base.ChildControlsCreated = false;
     this._mode = ConnectionsZoneMode.ExistingConnections;
 }