Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebParts/WebPartConnection.cs

@@ -0,0 +1,415 @@
+//------------------------------------------------------------------------------
+// <copyright file="WebPartConnection.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls.WebParts {
+
+    using System;
+    using System.Collections;
+    using System.ComponentModel;
+    using System.Diagnostics;
+
+    [
+    TypeConverter(typeof(ExpandableObjectConverter)),
+    ParseChildren(true, "Transformers")
+    ]
+    public sealed class WebPartConnection {
+
+        private string _consumerConnectionPointID;
+        private string _consumerID;
+        private bool _deleted;
+        private string _id;
+        private bool _isActive;
+        private bool _isShared;
+        private bool _isStatic;
+        private string _providerConnectionPointID;
+        private string _providerID;
+        private WebPartTransformerCollection _transformers;
+        private WebPartManager _webPartManager;
+
+        public WebPartConnection() {
+            _isStatic = true;
+            _isShared = true;
+        }
+
+        // PERF: Consider caching
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public WebPart Consumer {
+            get {
+                string consumerID = ConsumerID;
+                if (consumerID.Length == 0) {
+                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_ConsumerIDNotSet));
+                }
+
+                if (_webPartManager != null) {
+                    return _webPartManager.WebParts[consumerID];
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+
+        // PERF: Consider caching
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public ConsumerConnectionPoint ConsumerConnectionPoint {
+            get {
+                WebPart consumer = Consumer;
+                if (consumer != null && _webPartManager != null) {
+                    return _webPartManager.GetConsumerConnectionPoint(consumer, ConsumerConnectionPointID);
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+
+        [
+        DefaultValue(ConnectionPoint.DefaultIDInternal)
+        ]
+        public string ConsumerConnectionPointID {
+            get {
+                // 
+                return (!String.IsNullOrEmpty(_consumerConnectionPointID)) ?
+                    _consumerConnectionPointID : ConnectionPoint.DefaultID;
+            }
+            set {
+                _consumerConnectionPointID = value;
+            }
+        }
+
+        [
+        DefaultValue("")
+        ]
+        public string ConsumerID {
+            get {
+                return (_consumerID != null) ? _consumerID : String.Empty;
+            }
+            set {
+                _consumerID = value;
+            }
+        }
+
+        // True if this connection has been disconnected, but can not actually be removed.
+        // Either a static or a shared connection.
+        internal bool Deleted {
+            get {
+                return _deleted;
+            }
+            set {
+                _deleted = value;
+            }
+        }
+
+        [
+        DefaultValue("")
+        ]
+        public string ID {
+            get {
+                return (_id != null) ? _id : String.Empty;
+            }
+            set {
+                _id = value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public bool IsActive {
+            get {
+                return _isActive;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public bool IsShared {
+            get {
+                return _isShared;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public bool IsStatic {
+            get {
+                return _isStatic;
+            }
+        }
+
+        // PERF: Consider caching
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public WebPart Provider {
+            get {
+                string providerID = ProviderID;
+                if (providerID.Length == 0) {
+                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_ProviderIDNotSet));
+                }
+
+                if (_webPartManager != null) {
+                    return _webPartManager.WebParts[providerID];
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+
+        // PERF: Consider caching
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public ProviderConnectionPoint ProviderConnectionPoint {
+            get {
+                WebPart provider = Provider;
+                if (provider != null && _webPartManager != null) {
+                    return _webPartManager.GetProviderConnectionPoint(provider, ProviderConnectionPointID);
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+
+        [
+        DefaultValue(ConnectionPoint.DefaultIDInternal)
+        ]
+        public string ProviderConnectionPointID {
+            get {
+                // 
+                return (!String.IsNullOrEmpty(_providerConnectionPointID)) ?
+                    _providerConnectionPointID : ConnectionPoint.DefaultID;
+            }
+            set {
+                _providerConnectionPointID = value;
+            }
+        }
+
+        [
+        DefaultValue("")
+        ]
+        public string ProviderID {
+            get {
+                return (_providerID != null) ? _providerID : String.Empty;
+            }
+            set {
+                _providerID = value;
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        ]
+        public WebPartTransformer Transformer {
+            get {
+                if (_transformers == null || _transformers.Count == 0) {
+                    return null;
+                }
+                else {
+                    return _transformers[0];
+                }
+            }
+        }
+
+        /// <internalonly/>
+        [
+        Browsable(false),
+        EditorBrowsable(EditorBrowsableState.Never),
+        PersistenceMode(PersistenceMode.InnerDefaultProperty),
+        ]
+        public WebPartTransformerCollection Transformers {
+            get {
+                if (_transformers == null) {
+                    _transformers = new WebPartTransformerCollection();
+                }
+
+                return _transformers;
+            }
+        }
+
+        internal void Activate() {
+            // This method should only be called on WebPartConnections in the WebPartManager, so
+            // _webPartManager should never be null.
+            Debug.Assert(_webPartManager != null);
+
+            Transformers.SetReadOnly();
+
+            WebPart providerWebPart = Provider;
+            // Cannot be null because Activate() is only called on valid Connections
+            Debug.Assert(providerWebPart != null);
+
+            WebPart consumerWebPart = Consumer;
+            // Cannot be null because Activate() is only called on valid Connections
+            Debug.Assert(consumerWebPart != null);
+
+            Control providerControl = providerWebPart.ToControl();
+            Control consumerControl = consumerWebPart.ToControl();
+
+            ProviderConnectionPoint providerConnectionPoint = ProviderConnectionPoint;
+            // Cannot be null because Activate() is only called on valid Connections
+            Debug.Assert(providerConnectionPoint != null);
+
+            if (!providerConnectionPoint.GetEnabled(providerControl)) {
+                consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle));
+                return;
+            }
+
+            ConsumerConnectionPoint consumerConnectionPoint = ConsumerConnectionPoint;
+            // Cannot be null because Activate() is only called on valid Connections
+            Debug.Assert(consumerConnectionPoint != null);
+
+            if (!consumerConnectionPoint.GetEnabled(consumerControl)) {
+                consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle));
+                return;
+            }
+
+            // Do not activate connections involving closed WebParts
+            if (!providerWebPart.IsClosed && !consumerWebPart.IsClosed) {
+                WebPartTransformer transformer = Transformer;
+                if (transformer == null) {
+                    if (providerConnectionPoint.InterfaceType == consumerConnectionPoint.InterfaceType) {
+                        ConnectionInterfaceCollection secondaryInterfaces = providerConnectionPoint.GetSecondaryInterfaces(providerControl);
+                        if (consumerConnectionPoint.SupportsConnection(consumerControl, secondaryInterfaces)) {
+                            object dataObject = providerConnectionPoint.GetObject(providerControl);
+                            consumerConnectionPoint.SetObject(consumerControl, dataObject);
+                            _isActive = true;
+                        }
+                        else {
+                            consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_IncompatibleSecondaryInterfaces, new string[] {
+                                    consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle,
+                                    providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle}));
+                        }
+                    }
+                    else {
+                        consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_NoCommonInterface, new string[] {
+                                providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle,
+                                consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle}));
+                    }
+                }
+                else {
+                    Type transformerType = transformer.GetType();
+
+                    if (!_webPartManager.AvailableTransformers.Contains(transformerType)) {
+                        string errorMessage;
+                        if (_webPartManager.Context != null && _webPartManager.Context.IsCustomErrorEnabled) {
+                            errorMessage = SR.GetString(SR.WebPartConnection_TransformerNotAvailable);
+                        }
+                        else {
+                            errorMessage = SR.GetString(SR.WebPartConnection_TransformerNotAvailableWithType, transformerType.FullName);
+                        }
+                        consumerWebPart.SetConnectErrorMessage(errorMessage);
+                        
+                        // 
+                    }
+
+                    // Check matching interfaces on connection points and transformer attribute
+                    Type transformerConsumerType = WebPartTransformerAttribute.GetConsumerType(transformerType);
+                    Type transformerProviderType = WebPartTransformerAttribute.GetProviderType(transformerType);
+
+                    if (providerConnectionPoint.InterfaceType == transformerConsumerType &&
+                        transformerProviderType == consumerConnectionPoint.InterfaceType) {
+
+                        // A transformer never provides any secondary interfaces
+                        if (consumerConnectionPoint.SupportsConnection(consumerControl, ConnectionInterfaceCollection.Empty)) {
+                            object dataObject = providerConnectionPoint.GetObject(providerControl);
+                            object transformedObject = transformer.Transform(dataObject);
+                            consumerConnectionPoint.SetObject(consumerControl, transformedObject);
+                            _isActive = true;
+                        }
+                        else {
+                            consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_ConsumerRequiresSecondaryInterfaces,
+                                consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle));
+                        }
+                    }
+                    else if (providerConnectionPoint.InterfaceType != transformerConsumerType) {
+                        string errorMessage;
+                        if (_webPartManager.Context != null && _webPartManager.Context.IsCustomErrorEnabled) {
+                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleProviderTransformer,
+                                providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle);
+                        }
+                        else {
+                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleProviderTransformerWithType,
+                                providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle, transformerType.FullName);
+
+                        }
+                        consumerWebPart.SetConnectErrorMessage(errorMessage);
+                    }
+                    else {
+                        string errorMessage;
+                        if (_webPartManager.Context != null && _webPartManager.Context.IsCustomErrorEnabled) {
+                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleConsumerTransformer,
+                                consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle);
+                        }
+                        else {
+                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleConsumerTransformerWithType,
+                                transformerType.FullName, consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle);
+                        }
+                        consumerWebPart.SetConnectErrorMessage(errorMessage);
+                    }
+                }
+            }
+        }
+
+        internal bool ConflictsWith(WebPartConnection otherConnection) {
+            return (ConflictsWithConsumer(otherConnection) || ConflictsWithProvider(otherConnection));
+        }
+
+        internal bool ConflictsWithConsumer(WebPartConnection otherConnection) {
+            return (!ConsumerConnectionPoint.AllowsMultipleConnections &&
+                    Consumer == otherConnection.Consumer &&
+                    ConsumerConnectionPoint == otherConnection.ConsumerConnectionPoint);
+        }
+
+        internal bool ConflictsWithProvider(WebPartConnection otherConnection) {
+            return (!ProviderConnectionPoint.AllowsMultipleConnections &&
+                    Provider == otherConnection.Provider &&
+                    ProviderConnectionPoint == otherConnection.ProviderConnectionPoint);
+        }
+
+        internal void SetIsShared(bool isShared) {
+            _isShared = isShared;
+        }
+
+        internal void SetIsStatic(bool isStatic) {
+            _isStatic = isStatic;
+        }
+
+        internal void SetTransformer(WebPartTransformer transformer) {
+            if (Transformers.Count == 0) {
+                Transformers.Add(transformer);
+            }
+            else {
+                Transformers[0] = transformer;
+            }
+        }
+
+        internal void SetWebPartManager(WebPartManager webPartManager) {
+            _webPartManager = webPartManager;
+        }
+
+        // Return the short typename, to improve the look of the collection editor in the designer
+        public override string ToString () {
+            return GetType().Name;
+        }
+    }
+}
+