public WebPartConnectionsEventArgs(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartConnection connection) : this(provider, providerConnectionPoint, consumer, consumerConnectionPoint) { _connection = connection; }
public ProviderConnectionPointCollection(ICollection connectionPoints) { if (connectionPoints == null) { throw new ArgumentNullException("connectionPoints"); } this._ids = new HybridDictionary(connectionPoints.Count, true); foreach (object obj2 in connectionPoints) { if (obj2 == null) { throw new ArgumentException(System.Web.SR.GetString("Collection_CantAddNull"), "connectionPoints"); } ProviderConnectionPoint point = obj2 as ProviderConnectionPoint; if (point == null) { throw new ArgumentException(System.Web.SR.GetString("Collection_InvalidType", new object[] { "ProviderConnectionPoint" }), "connectionPoints"); } string iD = point.ID; if (this._ids.Contains(iD)) { throw new ArgumentException(System.Web.SR.GetString("WebPart_Collection_DuplicateID", new object[] { "ProviderConnectionPoint", iD }), "connectionPoints"); } base.InnerList.Add(point); this._ids.Add(iD, point); } }
public WebPartTracker(WebPart webPart, ProviderConnectionPoint providerConnectionPoint) { if (webPart == null) { throw new ArgumentNullException("webPart"); } if (providerConnectionPoint == null) { throw new ArgumentNullException("providerConnectionPoint"); } if (providerConnectionPoint.ControlType != webPart.GetType()) { throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidConnectionPoint), "providerConnectionPoint"); } _webPart = webPart; _providerConnectionPoint = providerConnectionPoint; if (++Count > 1) { webPart.SetConnectErrorMessage(SR.GetString(SR.WebPartTracker_CircularConnection, _providerConnectionPoint.DisplayName)); } }
public ProviderConnectionPointCollection(ICollection connectionPoints) { if (connectionPoints == null) { throw new ArgumentNullException("connectionPoints"); } _ids = new HybridDictionary(connectionPoints.Count, true /* caseInsensitive */); foreach (object obj in connectionPoints) { if (obj == null) { throw new ArgumentException(SR.GetString(SR.Collection_CantAddNull), "connectionPoints"); } ProviderConnectionPoint point = obj as ProviderConnectionPoint; if (point == null) { throw new ArgumentException(SR.GetString(SR.Collection_InvalidType, "ProviderConnectionPoint"), "connectionPoints"); } string id = point.ID; if (!_ids.Contains(id)) { InnerList.Add(point); _ids.Add(id, point); } else { throw new ArgumentException(SR.GetString(SR.WebPart_Collection_DuplicateID, "ProviderConnectionPoint", id), "connectionPoints"); } } }
public WebPartConnectionsEventArgs(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { // Arguments may be null, when deleting a connection because a part is no longer on the page _provider = provider; _providerConnectionPoint = providerConnectionPoint; _consumer = consumer; _consumerConnectionPoint = consumerConnectionPoint; }
public virtual new WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { Contract.Requires(provider != null); Contract.Requires(consumer != null); Contract.Requires(providerConnectionPoint != null); Contract.Requires(consumerConnectionPoint != null); return(default(WebPartConnection)); }
public WebPartConnectionsEventArgs(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { // Arguments may be null, when deleting a connection because a part is no longer on the page _provider = provider; _providerConnectionPoint = providerConnectionPoint; _consumer = consumer; _consumerConnectionPoint = consumerConnectionPoint; }
public virtual new WebPartConnection ConnectWebParts (WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { Contract.Requires (provider != null); Contract.Requires (consumer != null); Contract.Requires (providerConnectionPoint != null); Contract.Requires (consumerConnectionPoint != null); return default(WebPartConnection); }
private void ClearPendingConnection() { this._pendingConnectionType = ConnectionType.None; this._pendingConnectionPointID = string.Empty; this._pendingSelectedValue = null; this._pendingConsumerID = string.Empty; this._pendingConsumer = null; this._pendingConsumerConnectionPoint = null; this._pendingProvider = null; this._pendingProviderConnectionPoint = null; this._pendingTransformerConfigurationControlTypeName = null; this._pendingConnectionID = null; }
public WebPartTracker(WebPart webPart, ProviderConnectionPoint providerConnectionPoint) { if (webPart == null) { throw new ArgumentNullException("webPart"); } if (providerConnectionPoint == null) { throw new ArgumentNullException("providerConnectionPoint"); } if (providerConnectionPoint.ControlType != webPart.GetType()) { throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidConnectionPoint), "providerConnectionPoint"); } _webPart = webPart; _providerConnectionPoint = providerConnectionPoint; if (++Count > 1) { webPart.SetConnectErrorMessage(SR.GetString(SR.WebPartTracker_CircularConnection, _providerConnectionPoint.DisplayName)); } }
public WebPartTracker(WebPart webPart, ProviderConnectionPoint providerConnectionPoint) { if (webPart == null) { throw new ArgumentNullException("webPart"); } if (providerConnectionPoint == null) { throw new ArgumentNullException("providerConnectionPoint"); } if (providerConnectionPoint.ControlType != webPart.GetType()) { throw new ArgumentException(System.Web.SR.GetString("WebPartManager_InvalidConnectionPoint"), "providerConnectionPoint"); } this._webPart = webPart; this._providerConnectionPoint = providerConnectionPoint; if (++this.Count > 1) { webPart.SetConnectErrorMessage(System.Web.SR.GetString("WebPartTracker_CircularConnection", new object[] { this._providerConnectionPoint.DisplayName })); } }
public WebPartTracker(WebPart webPart, ProviderConnectionPoint providerConnectionPoint) { if (webPart == null) { throw new ArgumentNullException("webPart"); } if (providerConnectionPoint == null) { throw new ArgumentNullException("providerConnectionPoint"); } if (providerConnectionPoint.ControlType != webPart.GetType()) { throw new ArgumentException(System.Web.SR.GetString("WebPartManager_InvalidConnectionPoint"), "providerConnectionPoint"); } this._webPart = webPart; this._providerConnectionPoint = providerConnectionPoint; if (++this.Count > 1) { webPart.SetConnectErrorMessage(System.Web.SR.GetString("WebPartTracker_CircularConnection", new object[] { this._providerConnectionPoint.DisplayName })); } }
public int IndexOf (ProviderConnectionPoint connectionPoint) { Contract.Ensures (Contract.Result<int>() >= -1); return default(int); }
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; } }
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); } } } }
public WebPartConnectionsEventArgs (WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartConnection connection) { }
public ProviderInfo(WebPart webPart, ProviderConnectionPoint connectionPoint) : base(webPart) { _connectionPoint = connectionPoint; }
public WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { return default(WebPartConnection); }
private IDictionary GetValidConsumers(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPartCollection webParts) { HybridDictionary dictionary = new HybridDictionary(); if ((((providerConnectionPoint != null) && (provider != null)) && provider.AllowConnect) && (providerConnectionPoint.AllowsMultipleConnections || !base.WebPartManager.IsProviderConnected(provider, providerConnectionPoint))) { foreach (WebPart part in webParts) { if ((part.AllowConnect && (part != provider)) && !part.IsClosed) { foreach (ConsumerConnectionPoint point in base.WebPartManager.GetConsumerConnectionPoints(part)) { if (base.WebPartManager.CanConnectWebParts(provider, providerConnectionPoint, part, point)) { dictionary.Add(part.ID + '$' + point.ID, new ConsumerInfo(part, point)); } else { foreach (WebPartTransformer transformer in this.AvailableTransformers) { if (base.WebPartManager.CanConnectWebParts(provider, providerConnectionPoint, part, point, transformer)) { dictionary.Add(part.ID + '$' + point.ID, new ConsumerInfo(part, point, transformer.GetType())); break; } } } } } } } return dictionary; }
public bool Contains(ProviderConnectionPoint connectionPoint) { return(default(bool)); }
public bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { return default(bool); }
public int IndexOf(ProviderConnectionPoint connectionPoint) { return(base.InnerList.IndexOf(connectionPoint)); }
public bool Contains(ProviderConnectionPoint connectionPoint) { return(base.InnerList.Contains(connectionPoint)); }
public bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { return(default(bool)); }
public WebPartConnectionsEventArgs(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartConnection connection) { }
public WebPartTracker(WebPart webPart, ProviderConnectionPoint providerConnectionPoint) { }
public WebPartConnectionsEventArgs(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartConnection connection) : this(provider, providerConnectionPoint, consumer, consumerConnectionPoint) { _connection = connection; }
private bool CanConnectWebPartsCore(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer, bool throwOnError) { if (!Personalization.IsModifiable) { if (throwOnError) { // Will throw appropriate exception Personalization.EnsureEnabled(/* ensureModifiable */ true); } else { return false; } } if (provider == null) { throw new ArgumentNullException("provider"); } if (!Controls.Contains(provider)) { throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "provider"); } if (consumer == null) { throw new ArgumentNullException("consumer"); } if (!Controls.Contains(consumer)) { throw new ArgumentException(SR.GetString(SR.UnknownWebPart), "consumer"); } if (providerConnectionPoint == null) { throw new ArgumentNullException("providerConnectionPoint"); } if (consumerConnectionPoint == null) { throw new ArgumentNullException("consumerConnectionPoint"); } Control providerControl = provider.ToControl(); Control consumerControl = consumer.ToControl(); if (providerConnectionPoint.ControlType != providerControl.GetType()) { throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidConnectionPoint), "providerConnectionPoint"); } if (consumerConnectionPoint.ControlType != consumerControl.GetType()) { throw new ArgumentException(SR.GetString(SR.WebPartManager_InvalidConnectionPoint), "consumerConnectionPoint"); } if (provider == consumer) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectToSelf)); } else { return false; } } if (provider.IsClosed) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectClosed, provider.ID)); } else { return false; } } if (consumer.IsClosed) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartManager_CantConnectClosed, consumer.ID)); } else { return false; } } if (!providerConnectionPoint.GetEnabled(providerControl)) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, providerConnectionPoint.ID, provider.ID)); } else { return false; } } if (!consumerConnectionPoint.GetEnabled(consumerControl)) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, consumerConnectionPoint.ID, consumer.ID)); } else { return false; } } // Check AllowsMultipleConnections on each ConnectionPoint if (!providerConnectionPoint.AllowsMultipleConnections) { foreach (WebPartConnection c in Connections) { if (c.Provider == provider && c.ProviderConnectionPoint == providerConnectionPoint) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_Duplicate, providerConnectionPoint.ID, provider.ID)); } else { return false; } } } } if (!consumerConnectionPoint.AllowsMultipleConnections) { foreach (WebPartConnection c in Connections) { if (c.Consumer == consumer && c.ConsumerConnectionPoint == consumerConnectionPoint) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_Duplicate, consumerConnectionPoint.ID, consumer.ID)); } else { return false; } } } } if (transformer == null) { if (providerConnectionPoint.InterfaceType != consumerConnectionPoint.InterfaceType) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_NoCommonInterface, new string[] {providerConnectionPoint.DisplayName, provider.ID, consumerConnectionPoint.DisplayName, consumer.ID})); } else { return false; } } ConnectionInterfaceCollection secondaryInterfaces = providerConnectionPoint.GetSecondaryInterfaces(providerControl); if (!consumerConnectionPoint.SupportsConnection(consumerControl, secondaryInterfaces)) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_IncompatibleSecondaryInterfaces, new string[] { consumerConnectionPoint.DisplayName, consumer.ID, providerConnectionPoint.DisplayName, provider.ID})); } else { return false; } } } else { Type transformerType = transformer.GetType(); if (!AvailableTransformers.Contains(transformerType)) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_TransformerNotAvailable, transformerType.FullName)); } // Check matching interfaces on connection points and transformer attribute. // Note that we require the connection interfaces to match exactly. We do not match // a derived interface type. This is because we want to simplify the interface matching // algorithm when transformers are involved. If we allowed derived interfaces to match, // then we would to take into account the "closest" match if multiple transformers // have compatible interfaces. Type transformerConsumerType = WebPartTransformerAttribute.GetConsumerType(transformerType); Type transformerProviderType = WebPartTransformerAttribute.GetProviderType(transformerType); if (providerConnectionPoint.InterfaceType != transformerConsumerType) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_IncompatibleProviderTransformer, providerConnectionPoint.DisplayName, provider.ID, transformerType.FullName)); } else { return false; } } if (transformerProviderType != consumerConnectionPoint.InterfaceType) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_IncompatibleConsumerTransformer, transformerType.FullName, consumerConnectionPoint.DisplayName, consumer.ID)); } else { return false; } } // A transformer never provides any secondary interfaces if (!consumerConnectionPoint.SupportsConnection(consumerControl, ConnectionInterfaceCollection.Empty)) { if (throwOnError) { throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_ConsumerRequiresSecondaryInterfaces, consumerConnectionPoint.DisplayName, consumer.ID)); } else { return false; } } } return true; }
public virtual new WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { return default(WebPartConnection); }
public WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { return ConnectWebParts(provider, providerConnectionPoint, consumer, consumerConnectionPoint, 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; }
public virtual new bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { return(default(bool)); }
private static ICollection[] CreateConnectionPoints(Type type) { ArrayList connectionPoints = new ArrayList(); ArrayList list2 = new ArrayList(); foreach (MethodInfo info in type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)) { object[] customAttributes = info.GetCustomAttributes(typeof(ConnectionConsumerAttribute), true); if (customAttributes.Length == 1) { ConsumerConnectionPoint point; ParameterInfo[] parameters = info.GetParameters(); Type interfaceType = null; if (parameters.Length == 1) { interfaceType = parameters[0].ParameterType; } if ((!info.IsPublic || (info.ReturnType != typeof(void))) || (interfaceType == null)) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartManager_InvalidConsumerSignature", new object[] { info.Name, type.FullName })); } ConnectionConsumerAttribute attribute = customAttributes[0] as ConnectionConsumerAttribute; string displayName = attribute.DisplayName; string iD = attribute.ID; Type connectionPointType = attribute.ConnectionPointType; bool allowsMultipleConnections = attribute.AllowsMultipleConnections; if (connectionPointType == null) { point = new ConsumerConnectionPoint(info, interfaceType, type, displayName, iD, allowsMultipleConnections); } else { object[] args = new object[] { info, interfaceType, type, displayName, iD, allowsMultipleConnections }; point = (ConsumerConnectionPoint) Activator.CreateInstance(connectionPointType, args); } connectionPoints.Add(point); } object[] objArray3 = info.GetCustomAttributes(typeof(ConnectionProviderAttribute), true); if (objArray3.Length == 1) { ProviderConnectionPoint point2; Type returnType = info.ReturnType; if ((!info.IsPublic || (returnType == typeof(void))) || (info.GetParameters().Length != 0)) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartManager_InvalidProviderSignature", new object[] { info.Name, type.FullName })); } ConnectionProviderAttribute attribute2 = objArray3[0] as ConnectionProviderAttribute; string str3 = attribute2.DisplayName; string id = attribute2.ID; Type type5 = attribute2.ConnectionPointType; bool flag2 = attribute2.AllowsMultipleConnections; if (type5 == null) { point2 = new ProviderConnectionPoint(info, returnType, type, str3, id, flag2); } else { object[] objArray4 = new object[] { info, returnType, type, str3, id, flag2 }; point2 = (ProviderConnectionPoint) Activator.CreateInstance(type5, objArray4); } list2.Add(point2); } } return new ICollection[] { new ConsumerConnectionPointCollection(connectionPoints), new ProviderConnectionPointCollection(list2) }; }
internal bool IsProviderConnected(WebPart provider, ProviderConnectionPoint connectionPoint) { return (this.GetConnectionForProvider(provider, connectionPoint) != null); }
private IDictionary GetValidConsumers(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPartCollection webParts) { HybridDictionary validConsumers = new HybridDictionary(); // ConnectionsZone must check the AllowConnect property, since it only affects the UI // and is not checked by CanConnectWebParts() if (providerConnectionPoint == null || provider == null || !provider.AllowConnect) { return validConsumers; } // PERF: Skip if provider is already connected, and does not allow multiple connections if (!providerConnectionPoint.AllowsMultipleConnections && WebPartManager.IsProviderConnected(provider, providerConnectionPoint)) { return validConsumers; } foreach (WebPart consumer in webParts) { // ConnectionsZone must check the AllowConnect property, since it only affects the UI // and is not checked by CanConnectWebParts() if (!consumer.AllowConnect) { continue; } // PERF: Skip consumer if it equals provider or is closed if (consumer == provider || consumer.IsClosed) { continue; } foreach (ConsumerConnectionPoint consumerConnectionPoint in WebPartManager.GetConsumerConnectionPoints(consumer)) { if (WebPartManager.CanConnectWebParts(provider, providerConnectionPoint, consumer, consumerConnectionPoint)) { validConsumers.Add(consumer.ID + ID_SEPARATOR + consumerConnectionPoint.ID, new ConsumerInfo(consumer, consumerConnectionPoint)); } else { foreach (WebPartTransformer transformer in AvailableTransformers) { if (WebPartManager.CanConnectWebParts(provider, providerConnectionPoint, consumer, consumerConnectionPoint, transformer)) { validConsumers.Add(consumer.ID + ID_SEPARATOR + consumerConnectionPoint.ID, new ConsumerInfo(consumer, consumerConnectionPoint, transformer.GetType())); break; } } } } } return validConsumers; }
public virtual bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { return this.CanConnectWebPartsCore(provider, providerConnectionPoint, consumer, consumerConnectionPoint, transformer, false); }
public ProviderInfo(WebPart webPart, ProviderConnectionPoint connectionPoint, Type transformerType) : base(webPart, transformerType) { _connectionPoint = connectionPoint; }
public int IndexOf(ProviderConnectionPoint connectionPoint) { Contract.Ensures(Contract.Result <int>() >= -1); return(default(int)); }
public virtual WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { CanConnectWebPartsCore(provider, providerConnectionPoint, consumer, consumerConnectionPoint, transformer, /*throwOnError*/ true); if (DynamicConnections.IsReadOnly) { throw new InvalidOperationException(SR.GetString(SR.WebPartManager_ConnectTooLate)); } WebPartConnectionsCancelEventArgs ce = new WebPartConnectionsCancelEventArgs( provider, providerConnectionPoint, consumer, consumerConnectionPoint); OnWebPartsConnecting(ce); if (_allowEventCancellation && ce.Cancel) { return null; } Control providerControl = provider.ToControl(); Control consumerControl = consumer.ToControl(); WebPartConnection connection = new WebPartConnection(); connection.ID = CreateDynamicConnectionID(); connection.ProviderID = providerControl.ID; connection.ConsumerID = consumerControl.ID; connection.ProviderConnectionPointID = providerConnectionPoint.ID; connection.ConsumerConnectionPointID = consumerConnectionPoint.ID; if (transformer != null) { Internals.SetTransformer(connection, transformer); } Internals.SetIsShared(connection, Personalization.Scope == PersonalizationScope.Shared); Internals.SetIsStatic(connection, false); DynamicConnections.Add(connection); _hasDataChanged = true; OnWebPartsConnected(new WebPartConnectionsEventArgs(provider, providerConnectionPoint, consumer, consumerConnectionPoint, connection)); return connection; }
public WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { return(default(WebPartConnection)); }
public virtual WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer) { this.CanConnectWebPartsCore(provider, providerConnectionPoint, consumer, consumerConnectionPoint, transformer, true); if (this.DynamicConnections.IsReadOnly) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartManager_ConnectTooLate")); } WebPartConnectionsCancelEventArgs e = new WebPartConnectionsCancelEventArgs(provider, providerConnectionPoint, consumer, consumerConnectionPoint); this.OnWebPartsConnecting(e); if (this._allowEventCancellation && e.Cancel) { return null; } Control control = provider.ToControl(); Control control2 = consumer.ToControl(); WebPartConnection connection = new WebPartConnection { ID = this.CreateDynamicConnectionID(), ProviderID = control.ID, ConsumerID = control2.ID, ProviderConnectionPointID = providerConnectionPoint.ID, ConsumerConnectionPointID = consumerConnectionPoint.ID }; if (transformer != null) { this.Internals.SetTransformer(connection, transformer); } this.Internals.SetIsShared(connection, this.Personalization.Scope == PersonalizationScope.Shared); this.Internals.SetIsStatic(connection, false); this.DynamicConnections.Add(connection); this._hasDataChanged = true; this.OnWebPartsConnected(new WebPartConnectionsEventArgs(provider, providerConnectionPoint, consumer, consumerConnectionPoint, connection)); return connection; }
// Returns an array of ICollection objects. The first is the ConsumerConnectionPoints, the // second is the ProviderConnectionPoints. private static ICollection[] CreateConnectionPoints(Type type) { ArrayList consumerConnectionPoints = new ArrayList(); ArrayList providerConnectionPoints = new ArrayList(); MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach (MethodInfo method in methods) { // Create consumer connection points object[] consumerAttributes = method.GetCustomAttributes(typeof(ConnectionConsumerAttribute), true); // ConnectionConsumerAttribute.AllowMultiple is false Debug.Assert(consumerAttributes.Length == 0 || consumerAttributes.Length == 1); if (consumerAttributes.Length == 1) { // Consumer signature: method is public, return type is void, takes one parameter ParameterInfo[] parameters = method.GetParameters(); Type parameterType = null; if (parameters.Length == 1) { parameterType = parameters[0].ParameterType; } if (method.IsPublic && method.ReturnType == typeof(void) && parameterType != null) { ConnectionConsumerAttribute attribute = consumerAttributes[0] as ConnectionConsumerAttribute; String displayName = attribute.DisplayName; String id = attribute.ID; Type connectionPointType = attribute.ConnectionPointType; bool allowsMultipleConnections = attribute.AllowsMultipleConnections; ConsumerConnectionPoint connectionPoint; if (connectionPointType == null) { connectionPoint = new ConsumerConnectionPoint(method, parameterType, type, displayName, id, allowsMultipleConnections); } else { // The ConnectionPointType is validated in the attribute property getter Object[] args = new Object[] { method, parameterType, type, displayName, id, allowsMultipleConnections }; connectionPoint = (ConsumerConnectionPoint)Activator.CreateInstance(connectionPointType, args); } consumerConnectionPoints.Add(connectionPoint); } else { throw new InvalidOperationException(SR.GetString(SR.WebPartManager_InvalidConsumerSignature, method.Name, type.FullName)); } } // Create provider connection points object[] providerAttributes = method.GetCustomAttributes(typeof(ConnectionProviderAttribute), true); // ConnectionProviderAttribute.AllowMultiple is false Debug.Assert(providerAttributes.Length == 0 || providerAttributes.Length == 1); if (providerAttributes.Length == 1) { // Provider signature: method is public, return type is an object, and takes no parameters Type returnType = method.ReturnType; if (method.IsPublic && returnType != typeof(void) && method.GetParameters().Length == 0) { ConnectionProviderAttribute attribute = providerAttributes[0] as ConnectionProviderAttribute; String displayName = attribute.DisplayName; String id = attribute.ID; Type connectionPointType = attribute.ConnectionPointType; bool allowsMultipleConnections = attribute.AllowsMultipleConnections; ProviderConnectionPoint connectionPoint; if (connectionPointType == null) { connectionPoint = new ProviderConnectionPoint(method, returnType, type, displayName, id, allowsMultipleConnections); } else { // The ConnectionPointType is validated in the attribute property getter Object[] args = new Object[] { method, returnType, type, displayName, id, allowsMultipleConnections }; connectionPoint = (ProviderConnectionPoint)Activator.CreateInstance(connectionPointType, args); } providerConnectionPoints.Add(connectionPoint); } else { throw new InvalidOperationException(SR.GetString(SR.WebPartManager_InvalidProviderSignature, method.Name, type.FullName)); } } } return new ICollection[] { new ConsumerConnectionPointCollection(consumerConnectionPoints), new ProviderConnectionPointCollection(providerConnectionPoints) }; }
internal WebPartConnection GetConnectionForProvider(WebPart provider, ProviderConnectionPoint connectionPoint) { ProviderConnectionPoint providerConnectionPoint = connectionPoint; if (connectionPoint == null) { providerConnectionPoint = this.GetProviderConnectionPoint(provider, null); } foreach (WebPartConnection connection in this.StaticConnections) { if ((!this.Internals.ConnectionDeleted(connection) && (connection.Provider == provider)) && (this.GetProviderConnectionPoint(provider, connection.ProviderConnectionPointID) == providerConnectionPoint)) { return connection; } } foreach (WebPartConnection connection2 in this.DynamicConnections) { if ((!this.Internals.ConnectionDeleted(connection2) && (connection2.Provider == provider)) && (this.GetProviderConnectionPoint(provider, connection2.ProviderConnectionPointID) == providerConnectionPoint)) { return connection2; } } return null; }
/// <devdoc> /// If the WebPart is a provider on the given connection point, returns the corresponding connection. /// Else, returns null. /// </devdoc> internal WebPartConnection GetConnectionForProvider(WebPart provider, ProviderConnectionPoint connectionPoint) { ProviderConnectionPoint actualConnectionPoint = connectionPoint; if (connectionPoint == null) { actualConnectionPoint = GetProviderConnectionPoint(provider, null); } // PERF: Use the StaticConnections and DynamicConnections collections separately, instead // of using the Connections property which is created on every call. foreach (WebPartConnection connection in StaticConnections) { if (!Internals.ConnectionDeleted(connection) && connection.Provider == provider) { ProviderConnectionPoint c = GetProviderConnectionPoint(provider, connection.ProviderConnectionPointID); if (c == actualConnectionPoint) { return connection; } } } foreach (WebPartConnection connection in DynamicConnections) { if (!Internals.ConnectionDeleted(connection) && connection.Provider == provider) { ProviderConnectionPoint c = GetProviderConnectionPoint(provider, connection.ProviderConnectionPointID); if (c == actualConnectionPoint) { return connection; } } } return null; }
public bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint) { return this.CanConnectWebParts(provider, providerConnectionPoint, consumer, consumerConnectionPoint, null); }
public WebPartTracker (WebPart webPart, ProviderConnectionPoint providerConnectionPoint) { }
private bool CanConnectWebPartsCore(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer, bool throwOnError) { if (!this.Personalization.IsModifiable) { if (!throwOnError) { return false; } this.Personalization.EnsureEnabled(true); } if (provider == null) { throw new ArgumentNullException("provider"); } if (!this.Controls.Contains(provider)) { throw new ArgumentException(System.Web.SR.GetString("UnknownWebPart"), "provider"); } if (consumer == null) { throw new ArgumentNullException("consumer"); } if (!this.Controls.Contains(consumer)) { throw new ArgumentException(System.Web.SR.GetString("UnknownWebPart"), "consumer"); } if (providerConnectionPoint == null) { throw new ArgumentNullException("providerConnectionPoint"); } if (consumerConnectionPoint == null) { throw new ArgumentNullException("consumerConnectionPoint"); } Control control = provider.ToControl(); Control control2 = consumer.ToControl(); if (providerConnectionPoint.ControlType != control.GetType()) { throw new ArgumentException(System.Web.SR.GetString("WebPartManager_InvalidConnectionPoint"), "providerConnectionPoint"); } if (consumerConnectionPoint.ControlType != control2.GetType()) { throw new ArgumentException(System.Web.SR.GetString("WebPartManager_InvalidConnectionPoint"), "consumerConnectionPoint"); } if (provider == consumer) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartManager_CantConnectToSelf")); } return false; } if (provider.IsClosed) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartManager_CantConnectClosed", new object[] { provider.ID })); } return false; } if (consumer.IsClosed) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartManager_CantConnectClosed", new object[] { consumer.ID })); } return false; } if (!providerConnectionPoint.GetEnabled(control)) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_DisabledConnectionPoint", new object[] { providerConnectionPoint.ID, provider.ID })); } return false; } if (!consumerConnectionPoint.GetEnabled(control2)) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_DisabledConnectionPoint", new object[] { consumerConnectionPoint.ID, consumer.ID })); } return false; } if (!providerConnectionPoint.AllowsMultipleConnections) { foreach (WebPartConnection connection in this.Connections) { if ((connection.Provider == provider) && (connection.ProviderConnectionPoint == providerConnectionPoint)) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_Duplicate", new object[] { providerConnectionPoint.ID, provider.ID })); } return false; } } } if (!consumerConnectionPoint.AllowsMultipleConnections) { foreach (WebPartConnection connection2 in this.Connections) { if ((connection2.Consumer == consumer) && (connection2.ConsumerConnectionPoint == consumerConnectionPoint)) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_Duplicate", new object[] { consumerConnectionPoint.ID, consumer.ID })); } return false; } } } if (transformer == null) { if (providerConnectionPoint.InterfaceType != consumerConnectionPoint.InterfaceType) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_NoCommonInterface", new string[] { providerConnectionPoint.DisplayName, provider.ID, consumerConnectionPoint.DisplayName, consumer.ID })); } return false; } ConnectionInterfaceCollection secondaryInterfaces = providerConnectionPoint.GetSecondaryInterfaces(control); if (!consumerConnectionPoint.SupportsConnection(control2, secondaryInterfaces)) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_IncompatibleSecondaryInterfaces", new string[] { consumerConnectionPoint.DisplayName, consumer.ID, providerConnectionPoint.DisplayName, provider.ID })); } return false; } } else { Type type = transformer.GetType(); if (!this.AvailableTransformers.Contains(type)) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_TransformerNotAvailable", new object[] { type.FullName })); } Type consumerType = WebPartTransformerAttribute.GetConsumerType(type); Type providerType = WebPartTransformerAttribute.GetProviderType(type); if (providerConnectionPoint.InterfaceType != consumerType) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_IncompatibleProviderTransformer", new object[] { providerConnectionPoint.DisplayName, provider.ID, type.FullName })); } return false; } if (providerType != consumerConnectionPoint.InterfaceType) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_IncompatibleConsumerTransformer", new object[] { type.FullName, consumerConnectionPoint.DisplayName, consumer.ID })); } return false; } if (!consumerConnectionPoint.SupportsConnection(control2, ConnectionInterfaceCollection.Empty)) { if (throwOnError) { throw new InvalidOperationException(System.Web.SR.GetString("WebPartConnection_ConsumerRequiresSecondaryInterfaces", new object[] { consumerConnectionPoint.DisplayName, consumer.ID })); } return false; } } return true; }
public int IndexOf(ProviderConnectionPoint connectionPoint) { return(default(int)); }