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