static ConnectionPoint ConnectionPointHitTest(UIElement element, Point hitPoint) { FreeFormPanel panel = VisualTreeUtils.FindVisualAncestor <FreeFormPanel>(element); List <ConnectionPoint> connectionPoints = StateContainerEditor.GetConnectionPoints(element); return(FreeFormPanel.ConnectionPointHitTest(hitPoint, connectionPoints, panel)); }
internal static List <ConnectionPoint> GetEmptyConnectionPoints(UIElement designer) { List <ConnectionPoint> connectionPoints = StateContainerEditor.GetConnectionPoints(designer); if (connectionPoints != null) { return(new List <ConnectionPoint>(connectionPoints.Where <ConnectionPoint>( (p) => { return p.AttachedConnectors == null || p.AttachedConnectors.Count == 0; }))); } return(new List <ConnectionPoint>()); }
static ConnectionPoint GetConnectionPoint(UIElement element, Point location) { List <ConnectionPoint> connectionPoints = StateContainerEditor.GetConnectionPoints(element); foreach (ConnectionPoint connectionPoint in connectionPoints) { if (DesignerGeometryHelper.ManhattanDistanceBetweenPoints(location, connectionPoint.Location) <= ConnectorRouter.EndPointTolerance) { return(connectionPoint); } } return(null); }
// referenceTransitionModelItem is used when a connector is re-linked. void CreateTransition(ConnectionPoint sourceConnPoint, ConnectionPoint destConnPoint, ModelItem referenceTransitionModelItem, bool isSourceMoved) { VirtualizedContainerService.VirtualizingContainer srcDesigner = sourceConnPoint.ParentDesigner as VirtualizedContainerService.VirtualizingContainer; Fx.Assert(srcDesigner != null, "srcDesigner should not be null."); VirtualizedContainerService.VirtualizingContainer destDesigner = destConnPoint.ParentDesigner as VirtualizedContainerService.VirtualizingContainer; Fx.Assert(destDesigner != null, "destDesigner should not be null."); ModelItem srcModelItem = srcDesigner.ModelItem; ModelItem destModelItem = destDesigner.ModelItem; ModelItem transitionModelItem = null; // We are moving the connector. if (referenceTransitionModelItem != null && referenceTransitionModelItem.ItemType == typeof(Transition)) { transitionModelItem = referenceTransitionModelItem; // We are moving the start of the connector. We only preserve the trigger if it is not shared. if (isSourceMoved) { Transition referenceTransition = referenceTransitionModelItem.GetCurrentValue() as Transition; ModelItem stateModelItem = GetParentStateModelItemForTransition(referenceTransitionModelItem); State state = stateModelItem.GetCurrentValue() as State; bool isTriggerShared = false; foreach (Transition transition in state.Transitions) { if (transition != referenceTransition && transition.Trigger == referenceTransition.Trigger) { isTriggerShared = true; break; } } if (isTriggerShared) { transitionModelItem.Properties[TransitionDesigner.TriggerPropertyName].SetValue(null); } } transitionModelItem.Properties[TransitionDesigner.ToPropertyName].SetValue(destModelItem); srcModelItem.Properties[StateDesigner.TransitionsPropertyName].Collection.Add(transitionModelItem); } // We are creating a new connector. else { ModelItem stateMachineModelItem = GetStateMachineModelItem(srcModelItem); Transition newTransition = new Transition() { DisplayName = StateContainerEditor.GenerateTransitionName(stateMachineModelItem) }; newTransition.To = destModelItem.GetCurrentValue() as State; // Assign the shared trigger. if (sourceConnPoint.AttachedConnectors.Count > 0) { Connector connector = sourceConnPoint.AttachedConnectors[0]; Transition existingTransition = StateContainerEditor.GetConnectorModelItem(connector).GetCurrentValue() as Transition; newTransition.Trigger = existingTransition.Trigger; } transitionModelItem = srcModelItem.Properties[StateDesigner.TransitionsPropertyName].Collection.Add(newTransition); } if (transitionModelItem != null) { // if the transition connection is re-routed, the SrcConnPointIndex needs to be updated. PointCollection connectorViewState = new PointCollection(ConnectorRouter.Route(this.panel, sourceConnPoint, destConnPoint)); int srcConnectionPointIndex = StateContainerEditor.GetConnectionPoints(sourceConnPoint.ParentDesigner).IndexOf(sourceConnPoint); int destConnectionPointIndex = StateContainerEditor.GetConnectionPoints(destConnPoint.ParentDesigner).IndexOf(destConnPoint); this.StoreConnectorLocationViewState(transitionModelItem, connectorViewState, true); this.ViewStateService.StoreViewStateWithUndo(transitionModelItem, SrcConnectionPointIndexStateKey, srcConnectionPointIndex); this.ViewStateService.StoreViewStateWithUndo(transitionModelItem, DestConnectionPointIndexStateKey, destConnectionPointIndex); } }
//This returns the closest non-outgoing connectionPoint on dest. Return value will be different than sourceConnectionPoint. static ConnectionPoint GetClosestDestConnectionPoint(ConnectionPoint sourceConnectionPoint, UIElement dest) { ConnectionPoint destConnectionPoint = null; if (sourceConnectionPoint.PointType != ConnectionPointKind.Incoming) { destConnectionPoint = GetClosestConnectionPointNotOfType(sourceConnectionPoint, StateContainerEditor.GetConnectionPoints(dest), ConnectionPointKind.Outgoing); } return(destConnectionPoint); }
//This returns the closest non-incoming connectionPoint on source. Return value will be different than destConnectionPoint. static ConnectionPoint GetClosestSrcConnectionPoint(UIElement src, ConnectionPoint destConnectionPoint) { ConnectionPoint srcConnectionPoint = null; if (destConnectionPoint.PointType != ConnectionPointKind.Outgoing) { srcConnectionPoint = GetClosestConnectionPointNotOfType(destConnectionPoint, StateContainerEditor.GetConnectionPoints(src), ConnectionPointKind.Incoming); } return(srcConnectionPoint); }