protected override bool CanConnect(ConnectionPoint source, ConnectionPoint target)
{
DesignerLayoutConnectionPoint point = source as DesignerLayoutConnectionPoint;
DesignerLayoutConnectionPoint point2 = target as DesignerLayoutConnectionPoint;
if (point == null)
{
if (!this.IsValidTargetConnectionPoint(source))
{
return false;
}
}
else if (point.DesignerLayout.ActivityDesigner is StateFinalizationDesigner)
{
return false;
}
if (point2 == null)
{
if (!this.IsValidTargetConnectionPoint(target))
{
return false;
}
}
else if (point2.DesignerLayout.ActivityDesigner is StateFinalizationDesigner)
{
return false;
}
return (((point == null) && (point2 != null)) || ((point != null) && (point2 == null)));
}
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
{
if (serializationManager == null)
{
throw new ArgumentNullException("serializationManager");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
Connector connector = null;
IReferenceService service = serializationManager.GetService(typeof(IReferenceService)) as IReferenceService;
FreeformActivityDesigner designer = serializationManager.Context[typeof(FreeformActivityDesigner)] as FreeformActivityDesigner;
if ((designer != null) && (service != null))
{
ConnectionPoint source = null;
ConnectionPoint target = null;
try
{
Dictionary<string, string> connectorConstructionArguments = this.GetConnectorConstructionArguments(serializationManager, type);
if ((connectorConstructionArguments.ContainsKey("SourceActivity") && connectorConstructionArguments.ContainsKey("SourceConnectionIndex")) && connectorConstructionArguments.ContainsKey("SourceConnectionEdge"))
{
ActivityDesigner associatedDesigner = ActivityDesigner.GetDesigner(service.GetReference(connectorConstructionArguments["SourceActivity"]) as Activity);
DesignerEdges designerEdge = (DesignerEdges) Enum.Parse(typeof(DesignerEdges), connectorConstructionArguments["SourceConnectionEdge"]);
int connectionIndex = Convert.ToInt32(connectorConstructionArguments["SourceConnectionIndex"], CultureInfo.InvariantCulture);
if (((associatedDesigner != null) && (designerEdge != DesignerEdges.None)) && (connectionIndex >= 0))
{
source = new ConnectionPoint(associatedDesigner, designerEdge, connectionIndex);
}
}
if ((connectorConstructionArguments.ContainsKey("TargetActivity") && connectorConstructionArguments.ContainsKey("TargetConnectionIndex")) && connectorConstructionArguments.ContainsKey("TargetConnectionEdge"))
{
ActivityDesigner designer3 = ActivityDesigner.GetDesigner(service.GetReference(connectorConstructionArguments["TargetActivity"]) as Activity);
DesignerEdges edges2 = (DesignerEdges) Enum.Parse(typeof(DesignerEdges), connectorConstructionArguments["TargetConnectionEdge"]);
int num2 = Convert.ToInt32(connectorConstructionArguments["TargetConnectionIndex"], CultureInfo.InvariantCulture);
if (((designer3 != null) && (edges2 != DesignerEdges.None)) && (num2 >= 0))
{
target = new ConnectionPoint(designer3, edges2, num2);
}
}
}
catch
{
}
if ((source != null) && (target != null))
{
connector = designer.AddConnector(source, target);
}
}
return connector;
}
public Connector(ConnectionPoint source, ConnectionPoint target)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (ConnectionManager.GetConnectorContainer(source.AssociatedDesigner) != ConnectionManager.GetConnectorContainer(target.AssociatedDesigner))
{
throw new ArgumentException(DR.GetString("Error_Connector1", new object[0]));
}
this.source = source;
this.target = target;
}
public Connector(ConnectionPoint source, ConnectionPoint target)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (ConnectionManager.GetConnectorContainer(source.AssociatedDesigner) != ConnectionManager.GetConnectorContainer(target.AssociatedDesigner))
{
throw new ArgumentException(DR.GetString("Error_Connector1", new object[0]));
}
this.source = source;
this.target = target;
}
private void ContinueEditing(Point editPoint)
{
if (this.EditingInProgress)
{
ConnectionPoint[] pointArray = null;
if (this.connectorEditor.EditedConectionPoint != null)
{
ConnectionPoint sourceConnectionPoint = (this.connectorEditor.EditedConnector.Source == this.connectorEditor.EditedConectionPoint) ? this.connectorEditor.EditedConnector.Target : this.connectorEditor.EditedConnector.Source;
pointArray = GetSnappableConnectionPoints(editPoint, sourceConnectionPoint, this.connectorEditor.EditedConectionPoint, base.MessageHitTestContext.AssociatedDesigner, out this.snappedConnectionPoint);
}
this.ConnectablePoints = pointArray;
if (this.SnappedConnectionPoint != null)
{
editPoint = this.SnappedConnectionPoint.Location;
}
this.connectorEditor.OnContinueEditing(editPoint);
}
}
public Connector AddConnector(ConnectionPoint source, ConnectionPoint target)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (source.AssociatedDesigner == null)
{
throw new ArgumentException("source", SR.GetString("Error_AssociatedDesignerMissing"));
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (target.AssociatedDesigner == null)
{
throw new ArgumentException("target", SR.GetString("Error_AssociatedDesignerMissing"));
}
FreeformActivityDesigner connectorContainer = ConnectionManager.GetConnectorContainer(source.AssociatedDesigner);
if (this != connectorContainer)
{
throw new InvalidOperationException(DR.GetString("Error_AddConnector1", new object[0]));
}
if (((base.Activity != source.AssociatedDesigner.Activity) && !Helpers.IsChildActivity(base.Activity as CompositeActivity, source.AssociatedDesigner.Activity)) || ((base.Activity != target.AssociatedDesigner.Activity) && !Helpers.IsChildActivity(base.Activity as CompositeActivity, target.AssociatedDesigner.Activity)))
{
throw new ArgumentException(DR.GetString("Error_AddConnector2", new object[0]));
}
Connector item = this.CreateConnector(source, target);
if (item != null)
{
if (this.connectors.Contains(item))
{
throw new InvalidOperationException(DR.GetString("Error_AddConnector3", new object[0]));
}
this.connectors.Add(item);
item.SetParent(this);
this.OnConnectorAdded(new ConnectorEventArgs(item));
}
base.PerformLayout();
return(item);
}
public Connector AddConnector(ConnectionPoint source, ConnectionPoint target)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (source.AssociatedDesigner == null)
{
throw new ArgumentException("source", SR.GetString("Error_AssociatedDesignerMissing"));
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (target.AssociatedDesigner == null)
{
throw new ArgumentException("target", SR.GetString("Error_AssociatedDesignerMissing"));
}
FreeformActivityDesigner connectorContainer = ConnectionManager.GetConnectorContainer(source.AssociatedDesigner);
if (this != connectorContainer)
{
throw new InvalidOperationException(DR.GetString("Error_AddConnector1", new object[0]));
}
if (((base.Activity != source.AssociatedDesigner.Activity) && !Helpers.IsChildActivity(base.Activity as CompositeActivity, source.AssociatedDesigner.Activity)) || ((base.Activity != target.AssociatedDesigner.Activity) && !Helpers.IsChildActivity(base.Activity as CompositeActivity, target.AssociatedDesigner.Activity)))
{
throw new ArgumentException(DR.GetString("Error_AddConnector2", new object[0]));
}
Connector item = this.CreateConnector(source, target);
if (item != null)
{
if (this.connectors.Contains(item))
{
throw new InvalidOperationException(DR.GetString("Error_AddConnector3", new object[0]));
}
this.connectors.Add(item);
item.SetParent(this);
this.OnConnectorAdded(new ConnectorEventArgs(item));
}
base.PerformLayout();
return item;
}
private void EndEditing(Nullable <Point> editPoint)
{
WorkflowView workflowView = ParentView;
if (workflowView == null)
{
return;
}
if (EditingInProgress)
{
if (editPoint != null)
{
ConnectionPoint[] snapableConnectionPoints = null;
if (this.connectorEditor.EditedConectionPoint != null)
{
ConnectionPoint sourceConnectionPoint = this.connectorEditor.EditedConnector.Source == this.connectorEditor.EditedConectionPoint ?
this.connectorEditor.EditedConnector.Target :
this.connectorEditor.EditedConnector.Source;
snapableConnectionPoints = GetSnappableConnectionPoints(editPoint.Value, sourceConnectionPoint, this.connectorEditor.EditedConectionPoint, MessageHitTestContext.AssociatedDesigner, out this.snappedConnectionPoint);
}
if (SnappedConnectionPoint != null)
{
editPoint = SnappedConnectionPoint.Location;
}
}
this.connectorEditor.OnEndEditing((editPoint != null) ? editPoint.Value : Point.Empty, (editPoint != null));
}
this.initialDragPoint = null;
this.dragPointHitInfo = null;
this.snappedConnectionPoint = null;
ConnectablePoints = null;
workflowView.Capture = false;
this.connectorEditor = null;
}
private static ConnectionPoint[] GetSnappableConnectionPoints(Point currentPoint, ConnectionPoint sourceConnectionPoint, ConnectionPoint activeConnectionPoint, ActivityDesigner activityDesigner, out ConnectionPoint snappedConnectionPoint)
{
snappedConnectionPoint = null;
List <ConnectionPoint> list = new List <ConnectionPoint>();
FreeformActivityDesigner connectorContainer = GetConnectorContainer(activeConnectionPoint.AssociatedDesigner);
if (connectorContainer != null)
{
FreeformActivityDesigner designer2 = activityDesigner as FreeformActivityDesigner;
List <ActivityDesigner> list2 = new List <ActivityDesigner> {
activityDesigner
};
if (designer2 != null)
{
list2.AddRange(designer2.ContainedDesigners);
}
double num = 20.0;
foreach (ActivityDesigner designer3 in list2)
{
if (GetConnectorContainer(designer3) == connectorContainer)
{
bool flag = false;
List <ConnectionPoint> collection = new List <ConnectionPoint>();
foreach (ConnectionPoint point in designer3.GetConnectionPoints(DesignerEdges.All))
{
if (!point.Equals(activeConnectionPoint) && connectorContainer.CanConnectContainedDesigners(sourceConnectionPoint, point))
{
collection.Add(point);
double num2 = DesignerGeometryHelper.DistanceFromPointToRectangle(currentPoint, point.Bounds);
if (num2 <= 20.0)
{
flag = true;
if (num2 < num)
{
snappedConnectionPoint = point;
num = num2;
}
}
}
}
if (flag)
{
list.AddRange(collection);
}
}
}
if (snappedConnectionPoint != null)
{
foreach (ConnectionPoint point2 in snappedConnectionPoint.AssociatedDesigner.GetConnectionPoints(DesignerEdges.All))
{
if (!list.Contains(point2))
{
list.Add(point2);
}
}
}
}
return(list.ToArray());
}
public EditPoint(ConnectorEditor owner, ConnectionPoint connectionPoint)
{
this.owner = owner;
this.editPointType = EditPointTypes.ConnectionEditPoint;
this.connectionPoint = connectionPoint;
this.point = connectionPoint.Location;
}
/// <summary>
/// Called to check if connection can be established between source and target designer
/// </summary>
/// <param name="source">Source connection point</param>
/// <param name="target">Target connection point</param>
/// <returns>True if connection can be established, false otherwise</returns>
protected virtual bool CanConnect(ConnectionPoint source, ConnectionPoint target)
{
return true;
}
bool IConnectableDesigner.CanConnect(ConnectionPoint source, ConnectionPoint target)
{
return CanConnect(source, target);
}
protected internal virtual void OnContainedDesignersConnected(ConnectionPoint source, ConnectionPoint target)
{
((IConnectableDesigner) source.AssociatedDesigner).OnConnected(source, target);
((IConnectableDesigner) target.AssociatedDesigner).OnConnected(source, target);
}
public void OnEndEditing(Point point, bool commitChanges)
{
if (this.activeEditPoint != null)
{
this.Invalidate();
if (commitChanges)
{
this.UpdateEditPoints(point);
EditPoint activeEditPoint = this.activeEditPoint;
this.activeEditPoint = null;
this.UpdateEditPoints(point);
bool flag = false;
if (activeEditPoint.Type == EditPoint.EditPointTypes.ConnectionEditPoint)
{
ConnectionManager service = this.GetService(typeof(ConnectionManager)) as ConnectionManager;
FreeformActivityDesigner connectorContainer = ConnectionManager.GetConnectorContainer(activeEditPoint.EditedConnectionPoint.AssociatedDesigner);
if (((service != null) && (service.SnappedConnectionPoint != null)) && (connectorContainer != null))
{
ConnectionPoint source = this.editedConnector.Source;
ConnectionPoint target = this.editedConnector.Target;
if (target.Equals(activeEditPoint.EditedConnectionPoint))
{
target = service.SnappedConnectionPoint;
}
else if (source.Equals(activeEditPoint.EditedConnectionPoint))
{
source = service.SnappedConnectionPoint;
}
if ((connectorContainer == ConnectionManager.GetConnectorContainer(target.AssociatedDesigner)) && connectorContainer.CanConnectContainedDesigners(source, target))
{
this.editedConnector.Source = source;
this.editedConnector.Target = target;
if (this.editedConnector.ParentDesigner == null)
{
this.editedConnector = connectorContainer.AddConnector(source, target);
WorkflowDesignerLoader loader = this.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (loader != null)
{
loader.SetModified(true);
}
}
connectorContainer.OnContainedDesignersConnected(source, target);
}
flag = true;
}
}
else
{
flag = true;
}
if (flag)
{
this.editedConnector.SetConnectorSegments(this.GetPointsFromEditPoints(this.editPoints));
if (this.editedConnector.ParentDesigner != null)
{
this.editedConnector.ParentDesigner.OnConnectorChanged(new ConnectorEventArgs(this.editedConnector));
WorkflowDesignerLoader loader2 = this.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (loader2 != null)
{
loader2.SetModified(true);
}
}
}
this.PerformLayout();
}
this.Invalidate();
}
}
protected override Connector CreateConnector(ConnectionPoint source, ConnectionPoint target)
{
return new StateDesignerConnector(source, target);
}
protected internal virtual Connector CreateConnector(ConnectionPoint source, ConnectionPoint target)
{
return new Connector(source, target);
}
/// <summary>
/// Adds connector to the designer
/// </summary>
/// <param name="connector">Connector to add</param>
public Connector AddConnector(ConnectionPoint source, ConnectionPoint target)
{
if (source == null)
throw new ArgumentNullException("source");
if (source.AssociatedDesigner == null)
throw new ArgumentException("source", SR.GetString(SR.Error_AssociatedDesignerMissing));
if (target == null)
throw new ArgumentNullException("target");
if (target.AssociatedDesigner == null)
throw new ArgumentException("target", SR.GetString(SR.Error_AssociatedDesignerMissing));
//This check can be eliminated if it slows down connections, this is just to ensure we are adding connectors
//to correct activity designer
FreeformActivityDesigner connectorContainer = ConnectionManager.GetConnectorContainer(source.AssociatedDesigner);
if (this != connectorContainer)
throw new InvalidOperationException(DR.GetString(DR.Error_AddConnector1));
if ((Activity != source.AssociatedDesigner.Activity && !Helpers.IsChildActivity(Activity as CompositeActivity, source.AssociatedDesigner.Activity)) ||
(Activity != target.AssociatedDesigner.Activity && !Helpers.IsChildActivity(Activity as CompositeActivity, target.AssociatedDesigner.Activity)))
throw new ArgumentException(DR.GetString(DR.Error_AddConnector2));
Connector connector = CreateConnector(source, target);
if (connector != null)
{
if (this.connectors.Contains(connector))
throw new InvalidOperationException(DR.GetString(DR.Error_AddConnector3));
this.connectors.Add(connector);
connector.SetParent(this);
OnConnectorAdded(new ConnectorEventArgs(connector));
}
PerformLayout();
return connector;
}
public static void GetRoutingObstacles(IServiceProvider serviceProvider, object source, object target, out List <Rectangle> rectanglesToExclude, out List <Point> linesToExclude, out List <Point> pointsToExclude)
{
AmbientTheme ambientTheme = WorkflowTheme.CurrentTheme.AmbientTheme;
ActivityDesigner safeRootDesigner = ActivityDesigner.GetSafeRootDesigner(serviceProvider);
ConnectionPoint point = source as ConnectionPoint;
Point point2 = (point != null) ? point.Location : ((Point)source);
ActivityDesigner designer = (point != null) ? point.AssociatedDesigner : safeRootDesigner.HitTest(point2).AssociatedDesigner;
ConnectionPoint point3 = target as ConnectionPoint;
Point point4 = (point3 != null) ? point3.Location : ((Point)target);
ActivityDesigner designer3 = (point3 != null) ? point3.AssociatedDesigner : safeRootDesigner.HitTest(point4).AssociatedDesigner;
Dictionary <int, ActivityDesigner> dictionary = new Dictionary <int, ActivityDesigner>();
if (designer != null)
{
for (CompositeActivityDesigner designer4 = designer.ParentDesigner; designer4 != null; designer4 = designer4.ParentDesigner)
{
if (dictionary.ContainsKey(designer4.GetHashCode()))
{
break;
}
dictionary.Add(designer4.GetHashCode(), designer4);
}
}
if (designer3 != null)
{
for (CompositeActivityDesigner designer5 = designer3.ParentDesigner; designer5 != null; designer5 = designer5.ParentDesigner)
{
if (dictionary.ContainsKey(designer5.GetHashCode()))
{
break;
}
dictionary.Add(designer5.GetHashCode(), designer5);
}
}
rectanglesToExclude = new List <Rectangle>();
pointsToExclude = new List <Point>();
foreach (CompositeActivityDesigner designer6 in dictionary.Values)
{
ReadOnlyCollection <ActivityDesigner> containedDesigners = designer6.ContainedDesigners;
for (int i = 0; i < containedDesigners.Count; i++)
{
ActivityDesigner designer7 = containedDesigners[i];
if ((designer7.IsVisible && !dictionary.ContainsKey(designer7.GetHashCode())) && ((designer7 != designer) && (designer7 != designer3)))
{
Rectangle bounds = designer7.Bounds;
bounds.Inflate(ambientTheme.Margin);
rectanglesToExclude.Add(bounds);
}
}
}
linesToExclude = new List <Point>();
if (((designer != null) && (designer == designer3)) && !designer.IsRootDesigner)
{
linesToExclude.AddRange(GetDesignerEscapeCover(designer, new object[] { source, target }));
}
else
{
if ((designer != null) && !designer.IsRootDesigner)
{
linesToExclude.AddRange(GetDesignerEscapeCover(designer, new object[] { source }));
}
if ((designer3 != null) && !designer3.IsRootDesigner)
{
bool flag = true;
for (CompositeActivityDesigner designer8 = (designer != null) ? designer.ParentDesigner : null; designer8 != null; designer8 = (designer != null) ? designer8.ParentDesigner : null)
{
if (designer3 == designer8)
{
flag = false;
break;
}
}
if (flag)
{
linesToExclude.AddRange(GetDesignerEscapeCover(designer3, new object[] { target }));
}
}
}
}
private static ConnectionPoint[] GetSnappableConnectionPoints(Point currentPoint, ConnectionPoint sourceConnectionPoint, ConnectionPoint activeConnectionPoint, ActivityDesigner activityDesigner, out ConnectionPoint snappedConnectionPoint)
{
snappedConnectionPoint = null;
List<ConnectionPoint> list = new List<ConnectionPoint>();
FreeformActivityDesigner connectorContainer = GetConnectorContainer(activeConnectionPoint.AssociatedDesigner);
if (connectorContainer != null)
{
FreeformActivityDesigner designer2 = activityDesigner as FreeformActivityDesigner;
List<ActivityDesigner> list2 = new List<ActivityDesigner> {
activityDesigner
};
if (designer2 != null)
{
list2.AddRange(designer2.ContainedDesigners);
}
double num = 20.0;
foreach (ActivityDesigner designer3 in list2)
{
if (GetConnectorContainer(designer3) == connectorContainer)
{
bool flag = false;
List<ConnectionPoint> collection = new List<ConnectionPoint>();
foreach (ConnectionPoint point in designer3.GetConnectionPoints(DesignerEdges.All))
{
if (!point.Equals(activeConnectionPoint) && connectorContainer.CanConnectContainedDesigners(sourceConnectionPoint, point))
{
collection.Add(point);
double num2 = DesignerGeometryHelper.DistanceFromPointToRectangle(currentPoint, point.Bounds);
if (num2 <= 20.0)
{
flag = true;
if (num2 < num)
{
snappedConnectionPoint = point;
num = num2;
}
}
}
}
if (flag)
{
list.AddRange(collection);
}
}
}
if (snappedConnectionPoint != null)
{
foreach (ConnectionPoint point2 in snappedConnectionPoint.AssociatedDesigner.GetConnectionPoints(DesignerEdges.All))
{
if (!list.Contains(point2))
{
list.Add(point2);
}
}
}
}
return list.ToArray();
}
private void EndEditing(Point? editPoint)
{
WorkflowView parentView = base.ParentView;
if (parentView != null)
{
if (this.EditingInProgress)
{
if (editPoint.HasValue)
{
if (this.connectorEditor.EditedConectionPoint != null)
{
ConnectionPoint sourceConnectionPoint = (this.connectorEditor.EditedConnector.Source == this.connectorEditor.EditedConectionPoint) ? this.connectorEditor.EditedConnector.Target : this.connectorEditor.EditedConnector.Source;
GetSnappableConnectionPoints(editPoint.Value, sourceConnectionPoint, this.connectorEditor.EditedConectionPoint, base.MessageHitTestContext.AssociatedDesigner, out this.snappedConnectionPoint);
}
if (this.SnappedConnectionPoint != null)
{
editPoint = new Point?(this.SnappedConnectionPoint.Location);
}
}
this.connectorEditor.OnEndEditing(editPoint.HasValue ? editPoint.Value : Point.Empty, editPoint.HasValue);
}
this.initialDragPoint = null;
this.dragPointHitInfo = null;
this.snappedConnectionPoint = null;
this.ConnectablePoints = null;
parentView.Capture = false;
this.connectorEditor = null;
}
}
internal ConnectionPointGlyph(ConnectionPoint connectionPoint)
{
this.connectionPoint = connectionPoint;
}
protected internal virtual void OnContainedDesignersConnected(ConnectionPoint source, ConnectionPoint target)
{
((IConnectableDesigner)source.AssociatedDesigner).OnConnected(source, target);
((IConnectableDesigner)target.AssociatedDesigner).OnConnected(source, target);
}
protected override bool CanConnect(ConnectionPoint source, ConnectionPoint target)
{
DesignerLayoutConnectionPoint sourceDesignerLayoutConnectionPoint = source as DesignerLayoutConnectionPoint;
DesignerLayoutConnectionPoint targetDesignerLayoutConnectionPoint = target as DesignerLayoutConnectionPoint;
if (sourceDesignerLayoutConnectionPoint == null)
{
if (!IsValidTargetConnectionPoint(source))
return false;
}
else
{
if (sourceDesignerLayoutConnectionPoint.DesignerLayout.ActivityDesigner is StateFinalizationDesigner)
return false;
}
if (targetDesignerLayoutConnectionPoint == null)
{
if (!IsValidTargetConnectionPoint(target))
return false;
}
else
{
if (targetDesignerLayoutConnectionPoint.DesignerLayout.ActivityDesigner is StateFinalizationDesigner)
return false;
}
bool canConnect =
(sourceDesignerLayoutConnectionPoint == null && targetDesignerLayoutConnectionPoint != null) ||
(sourceDesignerLayoutConnectionPoint != null && targetDesignerLayoutConnectionPoint == null);
return canConnect;
}
protected internal virtual bool CanConnectContainedDesigners(ConnectionPoint source, ConnectionPoint target)
{
return(((IConnectableDesigner)source.AssociatedDesigner).CanConnect(source, target) && ((IConnectableDesigner)target.AssociatedDesigner).CanConnect(source, target));
}
private bool IsValidTargetConnectionPoint(ConnectionPoint target)
{
StateDesigner stateDesigner = target.AssociatedDesigner as StateDesigner;
if (stateDesigner == null)
return false;
StateActivity state = (StateActivity)stateDesigner.Activity;
return StateMachineHelpers.IsLeafState(state);
}
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
{
if (serializationManager == null)
throw new ArgumentNullException("serializationManager");
if (type == null)
throw new ArgumentNullException("type");
StateDesignerConnector connector = null;
IReferenceService referenceService = serializationManager.GetService(typeof(IReferenceService)) as IReferenceService;
FreeformActivityDesigner freeformDesigner = serializationManager.Context[typeof(FreeformActivityDesigner)] as FreeformActivityDesigner;
if (freeformDesigner != null && referenceService != null)
{
StateDesigner.DesignerLayoutConnectionPoint sourceConnection = null;
ConnectionPoint targetConnection = null;
StateDesigner.TransitionInfo transitionInfo = null;
StateDesigner rootStateDesigner = null;
try
{
Dictionary<string, string> constructionArguments = GetConnectorConstructionArguments(serializationManager, type);
if (constructionArguments.ContainsKey("EventHandlerName") &&
constructionArguments.ContainsKey("SetStateName") &&
constructionArguments.ContainsKey("TargetStateName"))
{
CompositeActivity eventHandler = (CompositeActivity)referenceService.GetReference(constructionArguments["EventHandlerName"] as string);
SetStateActivity setState = (SetStateActivity)referenceService.GetReference(constructionArguments["SetStateName"] as string);
StateActivity targetState = (StateActivity)referenceService.GetReference(constructionArguments["TargetStateName"] as string);
transitionInfo = new StateDesigner.TransitionInfo(setState, eventHandler);
transitionInfo.TargetState = targetState;
}
if (constructionArguments.ContainsKey("SourceActivity") &&
constructionArguments.ContainsKey("SourceConnectionIndex") &&
constructionArguments.ContainsKey("SourceConnectionEdge") &&
constructionArguments.ContainsKey("EventHandlerName"))
{
StateDesigner sourceDesigner = (StateDesigner)StateDesigner.GetDesigner(referenceService.GetReference(constructionArguments["SourceActivity"] as string) as Activity);
CompositeActivity eventHandler = (CompositeActivity)referenceService.GetReference(constructionArguments["EventHandlerName"] as string);
rootStateDesigner = sourceDesigner.RootStateDesigner;
DesignerEdges sourceEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["SourceConnectionEdge"] as string);
int sourceIndex = Convert.ToInt32(constructionArguments["SourceConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
if (sourceDesigner != null && eventHandler != null && sourceEdge != DesignerEdges.None && sourceIndex >= 0)
sourceConnection = new StateDesigner.DesignerLayoutConnectionPoint(sourceDesigner, sourceIndex, eventHandler, sourceEdge);
}
if (constructionArguments.ContainsKey("TargetActivity") &&
constructionArguments.ContainsKey("TargetConnectionIndex") &&
constructionArguments.ContainsKey("TargetConnectionEdge"))
{
ActivityDesigner targetDesigner = StateDesigner.GetDesigner(referenceService.GetReference(constructionArguments["TargetActivity"] as string) as Activity);
DesignerEdges targetEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["TargetConnectionEdge"] as string);
int targetIndex = Convert.ToInt32(constructionArguments["TargetConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
if (targetDesigner != null && targetEdge != DesignerEdges.None && targetIndex >= 0)
targetConnection = new ConnectionPoint(targetDesigner, targetEdge, targetIndex);
}
}
catch
{
}
if (transitionInfo != null && sourceConnection != null && targetConnection != null)
{
connector = rootStateDesigner.FindConnector(transitionInfo);
if (connector == null)
{
rootStateDesigner.AddingSetState = false;
try
{
connector = freeformDesigner.AddConnector(sourceConnection, targetConnection) as StateDesignerConnector;
}
finally
{
rootStateDesigner.AddingSetState = true;
}
}
else
{
connector.Source = sourceConnection;
connector.Target = targetConnection;
connector.ClearConnectorSegments();
}
}
}
return connector;
}
private static ConnectionPoint[] GetSnappableConnectionPoints(Point currentPoint, ConnectionPoint sourceConnectionPoint, ConnectionPoint activeConnectionPoint, ActivityDesigner activityDesigner, out ConnectionPoint snappedConnectionPoint)
{
//If the activity designer is composite activity designer then we will go through its children else we will go through its connection points
snappedConnectionPoint = null;
List <ConnectionPoint> snappableConnectionPoints = new List <ConnectionPoint>();
FreeformActivityDesigner connectorContainer = ConnectionManager.GetConnectorContainer(activeConnectionPoint.AssociatedDesigner);
if (connectorContainer != null)
{
FreeformActivityDesigner freeFormDesigner = activityDesigner as FreeformActivityDesigner;
List <ActivityDesigner> designersToCheck = new List <ActivityDesigner>();
designersToCheck.Add(activityDesigner);
if (freeFormDesigner != null)
{
designersToCheck.AddRange(freeFormDesigner.ContainedDesigners);
}
double minimumDistance = ConnectionManager.SnapHighlightDistance;
foreach (ActivityDesigner designer in designersToCheck)
{
if (ConnectionManager.GetConnectorContainer(designer) == connectorContainer)
{
bool addValidSnapPoints = false;
List <ConnectionPoint> validSnapPoints = new List <ConnectionPoint>();
ReadOnlyCollection <ConnectionPoint> snapPoints = designer.GetConnectionPoints(DesignerEdges.All);
foreach (ConnectionPoint snapPoint in snapPoints)
{
if (!snapPoint.Equals(activeConnectionPoint) &&
connectorContainer.CanConnectContainedDesigners(sourceConnectionPoint, snapPoint))
{
validSnapPoints.Add(snapPoint);
double distanceToDesigner = DesignerGeometryHelper.DistanceFromPointToRectangle(currentPoint, snapPoint.Bounds);
if (distanceToDesigner <= ConnectionManager.SnapHighlightDistance)
{
addValidSnapPoints = true;
if (distanceToDesigner < minimumDistance)
{
snappedConnectionPoint = snapPoint;
minimumDistance = distanceToDesigner;
}
}
}
}
if (addValidSnapPoints)
{
snappableConnectionPoints.AddRange(validSnapPoints);
}
}
}
if (snappedConnectionPoint != null)
{
foreach (ConnectionPoint connectionPoint in snappedConnectionPoint.AssociatedDesigner.GetConnectionPoints(DesignerEdges.All))
{
if (!snappableConnectionPoints.Contains(connectionPoint))
{
snappableConnectionPoints.Add(connectionPoint);
}
}
}
}
return(snappableConnectionPoints.ToArray());
}
protected internal virtual bool CanConnectContainedDesigners(ConnectionPoint source, ConnectionPoint target)
{
return (((IConnectableDesigner) source.AssociatedDesigner).CanConnect(source, target) && ((IConnectableDesigner) target.AssociatedDesigner).CanConnect(source, target));
}
private static ConnectionPoint[] GetSnappableConnectionPoints(Point currentPoint, ConnectionPoint sourceConnectionPoint, ConnectionPoint activeConnectionPoint, ActivityDesigner activityDesigner, out ConnectionPoint snappedConnectionPoint)
{
//If the activity designer is composite activity designer then we will go through its children else we will go through its connection points
snappedConnectionPoint = null;
List<ConnectionPoint> snappableConnectionPoints = new List<ConnectionPoint>();
FreeformActivityDesigner connectorContainer = ConnectionManager.GetConnectorContainer(activeConnectionPoint.AssociatedDesigner);
if (connectorContainer != null)
{
FreeformActivityDesigner freeFormDesigner = activityDesigner as FreeformActivityDesigner;
List<ActivityDesigner> designersToCheck = new List<ActivityDesigner>();
designersToCheck.Add(activityDesigner);
if (freeFormDesigner != null)
designersToCheck.AddRange(freeFormDesigner.ContainedDesigners);
double minimumDistance = ConnectionManager.SnapHighlightDistance;
foreach (ActivityDesigner designer in designersToCheck)
{
if (ConnectionManager.GetConnectorContainer(designer) == connectorContainer)
{
bool addValidSnapPoints = false;
List<ConnectionPoint> validSnapPoints = new List<ConnectionPoint>();
ReadOnlyCollection<ConnectionPoint> snapPoints = designer.GetConnectionPoints(DesignerEdges.All);
foreach (ConnectionPoint snapPoint in snapPoints)
{
if (!snapPoint.Equals(activeConnectionPoint) &&
connectorContainer.CanConnectContainedDesigners(sourceConnectionPoint, snapPoint))
{
validSnapPoints.Add(snapPoint);
double distanceToDesigner = DesignerGeometryHelper.DistanceFromPointToRectangle(currentPoint, snapPoint.Bounds);
if (distanceToDesigner <= ConnectionManager.SnapHighlightDistance)
{
addValidSnapPoints = true;
if (distanceToDesigner < minimumDistance)
{
snappedConnectionPoint = snapPoint;
minimumDistance = distanceToDesigner;
}
}
}
}
if (addValidSnapPoints)
snappableConnectionPoints.AddRange(validSnapPoints);
}
}
if (snappedConnectionPoint != null)
{
foreach (ConnectionPoint connectionPoint in snappedConnectionPoint.AssociatedDesigner.GetConnectionPoints(DesignerEdges.All))
{
if (!snappableConnectionPoints.Contains(connectionPoint))
snappableConnectionPoints.Add(connectionPoint);
}
}
}
return snappableConnectionPoints.ToArray();
}
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
{
if (serializationManager == null)
{
throw new ArgumentNullException("serializationManager");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
Connector connector = null;
IReferenceService referenceService = serializationManager.GetService(typeof(IReferenceService)) as IReferenceService;
FreeformActivityDesigner freeformDesigner = serializationManager.Context[typeof(FreeformActivityDesigner)] as FreeformActivityDesigner;
if (freeformDesigner != null && referenceService != null)
{
ConnectionPoint sourceConnection = null;
ConnectionPoint targetConnection = null;
try
{
Dictionary <string, string> constructionArguments = GetConnectorConstructionArguments(serializationManager, type);
if (constructionArguments.ContainsKey("SourceActivity") &&
constructionArguments.ContainsKey("SourceConnectionIndex") &&
constructionArguments.ContainsKey("SourceConnectionEdge"))
{
ActivityDesigner sourceDesigner = ActivityDesigner.GetDesigner(referenceService.GetReference(constructionArguments["SourceActivity"] as string) as Activity);
DesignerEdges sourceEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["SourceConnectionEdge"] as string);
int sourceIndex = Convert.ToInt32(constructionArguments["SourceConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
if (sourceDesigner != null && sourceEdge != DesignerEdges.None && sourceIndex >= 0)
{
sourceConnection = new ConnectionPoint(sourceDesigner, sourceEdge, sourceIndex);
}
}
if (constructionArguments.ContainsKey("TargetActivity") &&
constructionArguments.ContainsKey("TargetConnectionIndex") &&
constructionArguments.ContainsKey("TargetConnectionEdge"))
{
ActivityDesigner targetDesigner = ActivityDesigner.GetDesigner(referenceService.GetReference(constructionArguments["TargetActivity"] as string) as Activity);
DesignerEdges targetEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["TargetConnectionEdge"] as string);
int targetIndex = Convert.ToInt32(constructionArguments["TargetConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
if (targetDesigner != null && targetEdge != DesignerEdges.None && targetIndex >= 0)
{
targetConnection = new ConnectionPoint(targetDesigner, targetEdge, targetIndex);
}
}
}
catch
{
}
if (sourceConnection != null && targetConnection != null)
{
connector = freeformDesigner.AddConnector(sourceConnection, targetConnection);
}
}
return(connector);
}
internal ConnectionPointGlyph(ConnectionPoint connectionPoint)
{
this.connectionPoint = connectionPoint;
}
/// <summary>
/// Called when connection is established between two connection points
/// </summary>
/// <param name="source">Source connection point</param>
/// <param name="target">Target connection point</param>
protected virtual void OnConnected(ConnectionPoint source, ConnectionPoint target)
{
}
protected internal virtual Connector CreateConnector(ConnectionPoint source, ConnectionPoint target)
{
return(new Connector(source, target));
}
void IConnectableDesigner.OnConnected(ConnectionPoint source, ConnectionPoint target)
{
OnConnected(source, target);
}
internal StateDesignerConnector(ConnectionPoint source, ConnectionPoint target)
: base(source, target)
{
}
private void EndEditing(Nullable<Point> editPoint)
{
WorkflowView workflowView = ParentView;
if (workflowView == null)
return;
if (EditingInProgress)
{
if (editPoint != null)
{
ConnectionPoint[] snapableConnectionPoints = null;
if (this.connectorEditor.EditedConectionPoint != null)
{
ConnectionPoint sourceConnectionPoint = this.connectorEditor.EditedConnector.Source == this.connectorEditor.EditedConectionPoint ?
this.connectorEditor.EditedConnector.Target :
this.connectorEditor.EditedConnector.Source;
snapableConnectionPoints = GetSnappableConnectionPoints(editPoint.Value, sourceConnectionPoint, this.connectorEditor.EditedConectionPoint, MessageHitTestContext.AssociatedDesigner, out this.snappedConnectionPoint);
}
if (SnappedConnectionPoint != null)
editPoint = SnappedConnectionPoint.Location;
}
this.connectorEditor.OnEndEditing((editPoint != null) ? editPoint.Value : Point.Empty, (editPoint != null));
}
this.initialDragPoint = null;
this.dragPointHitInfo = null;
this.snappedConnectionPoint = null;
ConnectablePoints = null;
workflowView.Capture = false;
this.connectorEditor = null;
}
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
{
if (serializationManager == null)
throw new ArgumentNullException("serializationManager");
if (type == null)
throw new ArgumentNullException("type");
Connector connector = null;
IReferenceService referenceService = serializationManager.GetService(typeof(IReferenceService)) as IReferenceService;
FreeformActivityDesigner freeformDesigner = serializationManager.Context[typeof(FreeformActivityDesigner)] as FreeformActivityDesigner;
if (freeformDesigner != null && referenceService != null)
{
ConnectionPoint sourceConnection = null;
ConnectionPoint targetConnection = null;
try
{
Dictionary<string, string> constructionArguments = GetConnectorConstructionArguments(serializationManager, type);
if (constructionArguments.ContainsKey("SourceActivity") &&
constructionArguments.ContainsKey("SourceConnectionIndex") &&
constructionArguments.ContainsKey("SourceConnectionEdge"))
{
ActivityDesigner sourceDesigner = ActivityDesigner.GetDesigner(referenceService.GetReference(constructionArguments["SourceActivity"] as string) as Activity);
DesignerEdges sourceEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["SourceConnectionEdge"] as string);
int sourceIndex = Convert.ToInt32(constructionArguments["SourceConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
if (sourceDesigner != null && sourceEdge != DesignerEdges.None && sourceIndex >= 0)
sourceConnection = new ConnectionPoint(sourceDesigner, sourceEdge, sourceIndex);
}
if (constructionArguments.ContainsKey("TargetActivity") &&
constructionArguments.ContainsKey("TargetConnectionIndex") &&
constructionArguments.ContainsKey("TargetConnectionEdge"))
{
ActivityDesigner targetDesigner = ActivityDesigner.GetDesigner(referenceService.GetReference(constructionArguments["TargetActivity"] as string) as Activity);
DesignerEdges targetEdge = (DesignerEdges)Enum.Parse(typeof(DesignerEdges), constructionArguments["TargetConnectionEdge"] as string);
int targetIndex = Convert.ToInt32(constructionArguments["TargetConnectionIndex"] as string, System.Globalization.CultureInfo.InvariantCulture);
if (targetDesigner != null && targetEdge != DesignerEdges.None && targetIndex >= 0)
targetConnection = new ConnectionPoint(targetDesigner, targetEdge, targetIndex);
}
}
catch
{
}
if (sourceConnection != null && targetConnection != null)
connector = freeformDesigner.AddConnector(sourceConnection, targetConnection);
}
return connector;
}