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);
}
internal void SetTransformer(WebPartTransformer transformer)
{
if (this.Transformers.Count == 0)
{
this.Transformers.Add(transformer);
}
else
{
this.Transformers[0] = transformer;
}
}
public void Insert(int index, WebPartTransformer transformer)
{
}
public void SetTransformer(WebPartConnection connection, WebPartTransformer transformer)
{
}
private Control GetConfigurationControl(WebPartTransformer transformer)
{
Control control = transformer.CreateConfigurationControl();
if (control == null)
{
return null;
}
if (!(control is ITransformerConfigurationControl))
{
throw new InvalidOperationException(System.Web.SR.GetString("ConnectionsZone_MustImplementITransformerConfigurationControl"));
}
string assemblyQualifiedName = control.GetType().AssemblyQualifiedName;
if ((this._pendingTransformerConfigurationControlTypeName != null) && (this._pendingTransformerConfigurationControlTypeName != assemblyQualifiedName))
{
this.DisplayConnectionError();
return null;
}
this._pendingTransformerConfigurationControlTypeName = assemblyQualifiedName;
return control;
}
public bool Contains(WebPartTransformer transformer)
{
return default(bool);
}
private Control GetConfigurationControl(WebPartTransformer transformer) {
Control configurationControl = transformer.CreateConfigurationControl();
if (configurationControl == null) {
return null;
}
if (configurationControl is ITransformerConfigurationControl) {
string configControlTypeName = configurationControl.GetType().AssemblyQualifiedName;
if (_pendingTransformerConfigurationControlTypeName != null &&
_pendingTransformerConfigurationControlTypeName != configControlTypeName) {
DisplayConnectionError();
return null;
}
else {
_pendingTransformerConfigurationControlTypeName = configControlTypeName;
return configurationControl;
}
}
else {
throw new InvalidOperationException(SR.GetString(SR.ConnectionsZone_MustImplementITransformerConfigurationControl));
}
}
public int IndexOf(WebPartTransformer transformer)
{
return(default(int));
}
public void Remove(WebPartTransformer transformer)
{
base.List.Remove(transformer);
}
public void CopyTo(WebPartTransformer[] array, int index) {
List.CopyTo(array, index);
}
public int IndexOf(WebPartTransformer transformer)
{
return(base.List.IndexOf(transformer));
}
public void Insert(int index, WebPartTransformer transformer)
{
base.List.Insert(index, transformer);
}
public bool Contains(WebPartTransformer transformer)
{
return(base.List.Contains(transformer));
}
public int Add(WebPartTransformer transformer)
{
return(base.List.Add(transformer));
}
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 Object SaveConfigurationState(WebPartTransformer transformer)
{
return default(Object);
}
public object SaveConfigurationState(WebPartTransformer transformer)
{
return(transformer.SaveConfigurationState());
}
public int Add(WebPartTransformer transformer) {
return List.Add(transformer);
}
public void SetTransformer(WebPartConnection connection, WebPartTransformer transformer)
{
}
public void Insert(int index, WebPartTransformer transformer) {
List.Insert(index, transformer);
}
public virtual bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer)
{
return this.CanConnectWebPartsCore(provider, providerConnectionPoint, consumer, consumerConnectionPoint, transformer, false);
}
protected internal override void CreateChildControls() {
Controls.Clear();
_connectDropDownLists = new HybridDictionary();
_connectionPointInfo = new HybridDictionary();
_pendingTransformerConfigurationControl = null;
WebPart webPartToConnect = WebPartToConnect;
if (webPartToConnect != null && !webPartToConnect.IsClosed) {
WebPartManager webPartManager = WebPartManager;
Debug.Assert(webPartManager != null);
ProviderConnectionPointCollection providerConnectionPoints =
WebPartManager.GetEnabledProviderConnectionPoints(webPartToConnect);
foreach (ProviderConnectionPoint providerConnectionPoint in providerConnectionPoints) {
DropDownList list = new DropDownList();
list.ID = providerListIdPrefix + providerConnectionPoint.ID;
// Don't want to track changes to Items collection in ViewState
list.EnableViewState = false;
_connectDropDownLists[providerConnectionPoint] = list;
Controls.Add(list);
}
ConsumerConnectionPointCollection consumerConnectionPoints =
WebPartManager.GetEnabledConsumerConnectionPoints(webPartToConnect);
foreach (ConsumerConnectionPoint consumerConnectionPoint in consumerConnectionPoints) {
DropDownList list = new DropDownList();
list.ID = consumerListIdPrefix + consumerConnectionPoint.ID;
// Don't want to track changes to Items collection in ViewState
list.EnableViewState = false;
_connectDropDownLists[consumerConnectionPoint] = list;
Controls.Add(list);
}
SetDropDownProperties();
// Handle pending connection
if (_pendingConnectionType == ConnectionType.Consumer) {
if (EnsurePendingData()) {
Control pendingProviderControl = _pendingProvider.ToControl();
Control pendingConsumerControl = _pendingConsumer.ToControl();
if (_pendingSelectedValue != null) {
IDictionary providers = (IDictionary)_connectionPointInfo[_pendingConsumerConnectionPoint];
ProviderInfo providerInfo = (ProviderInfo)providers[_pendingSelectedValue];
Debug.Assert(providerInfo != null && providerInfo.TransformerType != null && providerInfo.TransformerType.IsSubclassOf(typeof(WebPartTransformer)));
_pendingTransformer = (WebPartTransformer)WebPartUtil.CreateObjectFromType(
providerInfo.TransformerType);
}
// Otherwise, we're updating an existing connection and _pendingTransformer has been set by EnsurePendingData.
_pendingTransformerConfigurationControl = GetConfigurationControl(_pendingTransformer);
if(_pendingTransformerConfigurationControl != null) {
((ITransformerConfigurationControl)_pendingTransformerConfigurationControl).Cancelled +=
new EventHandler(OnConfigurationControlCancelled);
((ITransformerConfigurationControl)_pendingTransformerConfigurationControl).Succeeded +=
new EventHandler(OnConfigurationControlSucceeded);
Controls.Add(_pendingTransformerConfigurationControl);
}
}
}
else if (_pendingConnectionType == ConnectionType.Provider) {
if (EnsurePendingData()) {
Control pendingProviderControl = _pendingProvider.ToControl();
Control pendingConsumerControl = _pendingConsumer.ToControl();
ConsumerInfo consumerInfo;
Debug.Assert(_pendingSelectedValue != null);
IDictionary consumers = (IDictionary)_connectionPointInfo[_pendingProviderConnectionPoint];
consumerInfo = (ConsumerInfo)consumers[_pendingSelectedValue];
Debug.Assert(consumerInfo != null && consumerInfo.TransformerType != null && consumerInfo.TransformerType.IsSubclassOf(typeof(WebPartTransformer)));
_pendingTransformer = (WebPartTransformer)WebPartUtil.CreateObjectFromType(
consumerInfo.TransformerType);
_pendingTransformerConfigurationControl = GetConfigurationControl(_pendingTransformer);
if (_pendingTransformerConfigurationControl != null) {
((ITransformerConfigurationControl)_pendingTransformerConfigurationControl).Cancelled +=
new EventHandler(OnConfigurationControlCancelled);
((ITransformerConfigurationControl)_pendingTransformerConfigurationControl).Succeeded +=
new EventHandler(OnConfigurationControlSucceeded);
Controls.Add(_pendingTransformerConfigurationControl);
}
}
}
SetTransformerConfigurationControlProperties();
}
}
public int Add(WebPartTransformer transformer)
{
return(default(int));
}
public Object SaveConfigurationState(WebPartTransformer transformer)
{
return(default(Object));
}
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);
}
}
}
}
}
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 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 int Add(WebPartTransformer transformer)
{
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 int IndexOf(WebPartTransformer transformer)
{
return default(int);
}
public bool Contains(WebPartTransformer transformer)
{
return(default(bool));
}
public void Remove(WebPartTransformer transformer)
{
}
public int IndexOf(WebPartTransformer transformer)
{
Contract.Ensures(Contract.Result <int>() >= -1);
return(default(int));
}
public void LoadConfigurationState(WebPartTransformer transformer, Object savedState)
{
}
public void Insert(int index, WebPartTransformer transformer)
{
}
internal void SetTransformer(WebPartTransformer transformer)
{
if (this.Transformers.Count == 0)
{
this.Transformers.Add(transformer);
}
else
{
this.Transformers[0] = transformer;
}
}
public void Remove(WebPartTransformer transformer)
{
}
public bool Contains(WebPartTransformer transformer) {
return List.Contains(transformer);
}
public virtual new WebPartConnection ConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer)
{
return default(WebPartConnection);
}
public int IndexOf(WebPartTransformer transformer) {
return List.IndexOf(transformer);
}
public void SetTransformer(WebPartConnection connection, WebPartTransformer transformer)
{
Contract.Requires(connection != null);
Contract.Ensures(((System.Array)connection.Transformers).Length >= 0);
}
public void Remove(WebPartTransformer transformer) {
List.Remove(transformer);
}
public void LoadConfigurationState(WebPartTransformer transformer, Object savedState)
{
Contract.Requires(transformer != null);
}
private bool HasConfigurationControl(WebPartTransformer transformer) {
return (transformer.CreateConfigurationControl() != null);
}
public Object SaveConfigurationState(WebPartTransformer transformer)
{
Contract.Requires(transformer != null);
return(default(Object));
}
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;
}
}
public object SaveConfigurationState(WebPartTransformer transformer) {
return transformer.SaveConfigurationState();
}
public void LoadConfigurationState(WebPartTransformer transformer, Object savedState)
{
}
protected internal override void CreateChildControls()
{
this.Controls.Clear();
this._connectDropDownLists = new HybridDictionary();
this._connectionPointInfo = new HybridDictionary();
this._pendingTransformerConfigurationControl = null;
WebPart webPartToConnect = this.WebPartToConnect;
if ((webPartToConnect != null) && !webPartToConnect.IsClosed)
{
WebPartManager webPartManager = base.WebPartManager;
foreach (ProviderConnectionPoint point in base.WebPartManager.GetEnabledProviderConnectionPoints(webPartToConnect))
{
DropDownList child = new DropDownList {
ID = "_providerlist_" + point.ID,
EnableViewState = false
};
this._connectDropDownLists[point] = child;
this.Controls.Add(child);
}
foreach (ConsumerConnectionPoint point2 in base.WebPartManager.GetEnabledConsumerConnectionPoints(webPartToConnect))
{
DropDownList list2 = new DropDownList {
ID = "_consumerlist_" + point2.ID,
EnableViewState = false
};
this._connectDropDownLists[point2] = list2;
this.Controls.Add(list2);
}
this.SetDropDownProperties();
if (this._pendingConnectionType == ConnectionType.Consumer)
{
if (this.EnsurePendingData())
{
this._pendingProvider.ToControl();
this._pendingConsumer.ToControl();
if (this._pendingSelectedValue != null)
{
IDictionary dictionary = (IDictionary) this._connectionPointInfo[this._pendingConsumerConnectionPoint];
ProviderInfo info = (ProviderInfo) dictionary[this._pendingSelectedValue];
this._pendingTransformer = (WebPartTransformer) WebPartUtil.CreateObjectFromType(info.TransformerType);
}
this._pendingTransformerConfigurationControl = this.GetConfigurationControl(this._pendingTransformer);
if (this._pendingTransformerConfigurationControl != null)
{
((ITransformerConfigurationControl) this._pendingTransformerConfigurationControl).Cancelled += new EventHandler(this.OnConfigurationControlCancelled);
((ITransformerConfigurationControl) this._pendingTransformerConfigurationControl).Succeeded += new EventHandler(this.OnConfigurationControlSucceeded);
this.Controls.Add(this._pendingTransformerConfigurationControl);
}
}
}
else if ((this._pendingConnectionType == ConnectionType.Provider) && this.EnsurePendingData())
{
this._pendingProvider.ToControl();
this._pendingConsumer.ToControl();
IDictionary dictionary2 = (IDictionary) this._connectionPointInfo[this._pendingProviderConnectionPoint];
ConsumerInfo info2 = (ConsumerInfo) dictionary2[this._pendingSelectedValue];
this._pendingTransformer = (WebPartTransformer) WebPartUtil.CreateObjectFromType(info2.TransformerType);
this._pendingTransformerConfigurationControl = this.GetConfigurationControl(this._pendingTransformer);
if (this._pendingTransformerConfigurationControl != null)
{
((ITransformerConfigurationControl) this._pendingTransformerConfigurationControl).Cancelled += new EventHandler(this.OnConfigurationControlCancelled);
((ITransformerConfigurationControl) this._pendingTransformerConfigurationControl).Succeeded += new EventHandler(this.OnConfigurationControlSucceeded);
this.Controls.Add(this._pendingTransformerConfigurationControl);
}
}
this.SetTransformerConfigurationControlProperties();
}
}
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;
}
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 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 virtual new bool CanConnectWebParts(WebPart provider, ProviderConnectionPoint providerConnectionPoint, WebPart consumer, ConsumerConnectionPoint consumerConnectionPoint, WebPartTransformer transformer)
{
return(default(bool));
}