private void Initialize(ConnectionInterfaceCollection existingConnectionInterfaces, ICollection connectionInterfaces)
{
if (existingConnectionInterfaces != null)
{
foreach (Type existingConnectionInterface in existingConnectionInterfaces)
{
// Don't need to check arg, since we know it is valid since it came
// from a ConnectionInterfaceCollection.
InnerList.Add(existingConnectionInterface);
}
}
if (connectionInterfaces != null)
{
foreach (object obj in connectionInterfaces)
{
if (obj == null)
{
throw new ArgumentException(SR.GetString(SR.Collection_CantAddNull), "connectionInterfaces");
}
if (!(obj is Type))
{
throw new ArgumentException(SR.GetString(SR.Collection_InvalidType, "Type"), "connectionInterfaces");
}
InnerList.Add(obj);
}
}
}
public ConnectionInterfaceCollection (ConnectionInterfaceCollection existingConnectionInterfaces,
ICollection connectionInterfaces)
: this()
{
InnerList.AddRange (existingConnectionInterfaces);
InnerList.AddRange (connectionInterfaces);
}
public ConnectionInterfaceCollection (ConnectionInterfaceCollection existingConnectionInterfaces,
ICollection connectionInterfaces)
: this()
{
InnerList.AddRange (existingConnectionInterfaces);
InnerList.AddRange (connectionInterfaces);
}
private void Initialize(ConnectionInterfaceCollection existingConnectionInterfaces, ICollection connectionInterfaces)
{
if (existingConnectionInterfaces != null)
{
foreach (Type type in existingConnectionInterfaces)
{
base.InnerList.Add(type);
}
}
if (connectionInterfaces != null)
{
foreach (object obj2 in connectionInterfaces)
{
if (obj2 == null)
{
throw new ArgumentException(System.Web.SR.GetString("Collection_CantAddNull"), "connectionInterfaces");
}
if (!(obj2 is Type))
{
throw new ArgumentException(System.Web.SR.GetString("Collection_InvalidType", new object[] { "Type" }), "connectionInterfaces");
}
base.InnerList.Add(obj2);
}
}
}
private void Initialize(ConnectionInterfaceCollection existingConnectionInterfaces, ICollection connectionInterfaces)
{
if (existingConnectionInterfaces != null)
{
foreach (Type type in existingConnectionInterfaces)
{
base.InnerList.Add(type);
}
}
if (connectionInterfaces != null)
{
foreach (object obj2 in connectionInterfaces)
{
if (obj2 == null)
{
throw new ArgumentException(System.Web.SR.GetString("Collection_CantAddNull"), "connectionInterfaces");
}
if (!(obj2 is Type))
{
throw new ArgumentException(System.Web.SR.GetString("Collection_InvalidType", new object[] { "Type" }), "connectionInterfaces");
}
base.InnerList.Add(obj2);
}
}
}
private void Initialize(ConnectionInterfaceCollection existingConnectionInterfaces, ICollection connectionInterfaces) {
if (existingConnectionInterfaces != null) {
foreach (Type existingConnectionInterface in existingConnectionInterfaces) {
// Don't need to check arg, since we know it is valid since it came
// from a ConnectionInterfaceCollection.
InnerList.Add(existingConnectionInterface);
}
}
if (connectionInterfaces != null) {
foreach (object obj in connectionInterfaces) {
if (obj == null) {
throw new ArgumentException(SR.GetString(SR.Collection_CantAddNull), "connectionInterfaces");
}
if (!(obj is Type)) {
throw new ArgumentException(SR.GetString(SR.Collection_InvalidType, "Type"), "connectionInterfaces");
}
InnerList.Add(obj);
}
}
}
public ConnectionInterfaceCollection(ConnectionInterfaceCollection existingConnectionInterfaces,
ICollection connectionInterfaces)
{
Initialize(existingConnectionInterfaces, connectionInterfaces);
}
public virtual new bool SupportsConnection(System.Web.UI.Control control, ConnectionInterfaceCollection secondaryInterfaces)
{
return(default(bool));
}
public virtual new bool SupportsConnection(System.Web.UI.Control control, ConnectionInterfaceCollection secondaryInterfaces)
{
return default(bool);
}
public ConnectionInterfaceCollection(ConnectionInterfaceCollection existingConnectionInterfaces,
ICollection connectionInterfaces) {
Initialize(existingConnectionInterfaces, connectionInterfaces);
}
/// <devdoc>
/// Base implementation returns true, can be overridden by subclasses to return
/// true or false conditionally based on the available secondary interfaces and the state
/// of the consumer WebPart passed in.
/// </devdoc>
public virtual bool SupportsConnection(Control control, ConnectionInterfaceCollection secondaryInterfaces) {
return true;
}
internal void Activate()
{
this.Transformers.SetReadOnly();
WebPart provider = this.Provider;
WebPart consumer = this.Consumer;
Control control = provider.ToControl();
Control control2 = consumer.ToControl();
System.Web.UI.WebControls.WebParts.ProviderConnectionPoint providerConnectionPoint = this.ProviderConnectionPoint;
if (!providerConnectionPoint.GetEnabled(control))
{
consumer.SetConnectErrorMessage(System.Web.SR.GetString("WebPartConnection_DisabledConnectionPoint", new object[] { providerConnectionPoint.DisplayName, provider.DisplayTitle }));
}
else
{
System.Web.UI.WebControls.WebParts.ConsumerConnectionPoint consumerConnectionPoint = this.ConsumerConnectionPoint;
if (!consumerConnectionPoint.GetEnabled(control2))
{
consumer.SetConnectErrorMessage(System.Web.SR.GetString("WebPartConnection_DisabledConnectionPoint", new object[] { consumerConnectionPoint.DisplayName, consumer.DisplayTitle }));
}
else if (!provider.IsClosed && !consumer.IsClosed)
{
WebPartTransformer transformer = this.Transformer;
if (transformer == null)
{
if (providerConnectionPoint.InterfaceType == consumerConnectionPoint.InterfaceType)
{
ConnectionInterfaceCollection secondaryInterfaces = providerConnectionPoint.GetSecondaryInterfaces(control);
if (consumerConnectionPoint.SupportsConnection(control2, secondaryInterfaces))
{
object data = providerConnectionPoint.GetObject(control);
consumerConnectionPoint.SetObject(control2, data);
this._isActive = true;
}
else
{
consumer.SetConnectErrorMessage(System.Web.SR.GetString("WebPartConnection_IncompatibleSecondaryInterfaces", new string[] { consumerConnectionPoint.DisplayName, consumer.DisplayTitle, providerConnectionPoint.DisplayName, provider.DisplayTitle }));
}
}
else
{
consumer.SetConnectErrorMessage(System.Web.SR.GetString("WebPartConnection_NoCommonInterface", new string[] { providerConnectionPoint.DisplayName, provider.DisplayTitle, consumerConnectionPoint.DisplayName, consumer.DisplayTitle }));
}
}
else
{
Type type = transformer.GetType();
if (!this._webPartManager.AvailableTransformers.Contains(type))
{
string str;
if ((this._webPartManager.Context != null) && this._webPartManager.Context.IsCustomErrorEnabled)
{
str = System.Web.SR.GetString("WebPartConnection_TransformerNotAvailable");
}
else
{
str = System.Web.SR.GetString("WebPartConnection_TransformerNotAvailableWithType", new object[] { type.FullName });
}
consumer.SetConnectErrorMessage(str);
}
Type consumerType = WebPartTransformerAttribute.GetConsumerType(type);
Type providerType = WebPartTransformerAttribute.GetProviderType(type);
if ((providerConnectionPoint.InterfaceType == consumerType) && (providerType == consumerConnectionPoint.InterfaceType))
{
if (consumerConnectionPoint.SupportsConnection(control2, ConnectionInterfaceCollection.Empty))
{
object providerData = providerConnectionPoint.GetObject(control);
object obj4 = transformer.Transform(providerData);
consumerConnectionPoint.SetObject(control2, obj4);
this._isActive = true;
}
else
{
consumer.SetConnectErrorMessage(System.Web.SR.GetString("WebPartConnection_ConsumerRequiresSecondaryInterfaces", new object[] { consumerConnectionPoint.DisplayName, consumer.DisplayTitle }));
}
}
else if (providerConnectionPoint.InterfaceType != consumerType)
{
string str2;
if ((this._webPartManager.Context != null) && this._webPartManager.Context.IsCustomErrorEnabled)
{
str2 = System.Web.SR.GetString("WebPartConnection_IncompatibleProviderTransformer", new object[] { providerConnectionPoint.DisplayName, provider.DisplayTitle });
}
else
{
str2 = System.Web.SR.GetString("WebPartConnection_IncompatibleProviderTransformerWithType", new object[] { providerConnectionPoint.DisplayName, provider.DisplayTitle, type.FullName });
}
consumer.SetConnectErrorMessage(str2);
}
else
{
string str3;
if ((this._webPartManager.Context != null) && this._webPartManager.Context.IsCustomErrorEnabled)
{
str3 = System.Web.SR.GetString("WebPartConnection_IncompatibleConsumerTransformer", new object[] { consumerConnectionPoint.DisplayName, consumer.DisplayTitle });
}
else
{
str3 = System.Web.SR.GetString("WebPartConnection_IncompatibleConsumerTransformerWithType", new object[] { type.FullName, consumerConnectionPoint.DisplayName, consumer.DisplayTitle });
}
consumer.SetConnectErrorMessage(str3);
}
}
}
}
}
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 virtual bool SupportsConnection(Control control, ConnectionInterfaceCollection secondaryInterfaces)
{
return(true);
}