// referenceTransitionModelItem is used when a connector is re-linked. void CreateTransition(ConnectionPoint sourceConnPoint, ConnectionPoint destConnPoint, ModelItem referenceTransitionModelItem, bool isSourceMoved) { Debug.Assert(this.IsOutmostStateContainerEditor(), "Should only be called by the outmost editor."); WorkflowViewElement srcDesigner = sourceConnPoint.ParentDesigner as WorkflowViewElement; WorkflowViewElement destDesigner = destConnPoint.ParentDesigner as WorkflowViewElement; Debug.Assert(srcDesigner is StateDesigner && destDesigner is StateDesigner, "The source and destination designers should both be StateDesigner"); 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 { Transition newTransition = new Transition() { DisplayName = string.Empty }; 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) { PointCollection connectorViewState = new PointCollection(ConnectorRouter.Route(this.panel, sourceConnPoint, destConnPoint)); this.StoreConnectorLocationViewState(transitionModelItem, connectorViewState, true); } }
static void DrawConnectionPoint(ConnectionPoint connPoint, Point actualLocation, Brush renderBrush, Pen renderPen, DrawingContext drawingContext) { // actualLocation is the point on the Edge with respect to the coordinate system defined by the top left corner of the adorned element // We will need this transparent rectangle to make sure OnMouseOver event can be triggered, for hit test. drawingContext.DrawRectangle(Brushes.Transparent, new Pen(Brushes.Transparent, 0), new Rect(actualLocation + connPoint.HitTestOffset, connPoint.HitTestSize)); drawingContext.DrawRectangle(renderBrush, renderPen, new Rect(actualLocation + connPoint.DrawingOffset, connPoint.DrawingSize)); }
// referenceConnector is used when we are re-linking the connector. internal ConnectorCreationResult CreateConnectorGesture(ConnectionPoint sourceConnectionPoint, ConnectionPoint destConnectionPoint, Connector referenceConnector, bool isConnectorStartMoved) { Debug.Assert(this.IsOutmostStateContainerEditor(), "Should only be called by the outmost editor."); Debug.Assert(sourceConnectionPoint != null, "sourceConnectionPoint is null."); Debug.Assert(destConnectionPoint != null, "destConnectionPoint is null."); ConnectorCreationResult result = ConnectorCreationResult.OtherFailure; if (destConnectionPoint.PointType != ConnectionPointType.Outgoing && sourceConnectionPoint.PointType != ConnectionPointType.Incoming) { if (sourceConnectionPoint.ParentDesigner is StateDesigner) { bool sameDestination = false; ModelItem refTransitionModelItem = null; if(referenceConnector != null) { refTransitionModelItem = StateContainerEditor.GetConnectorModelItem(referenceConnector); ModelItem destStateModelItem = ((StateDesigner)destConnectionPoint.ParentDesigner).ModelItem; if (refTransitionModelItem != null && refTransitionModelItem.Properties[TransitionDesigner.ToPropertyName].Value == destStateModelItem) { sameDestination = true; } } // We do not allow transitions to composite states unless we don't change the transition destination // (e.g., we are moving the start of a connector). if (!sameDestination && !((StateDesigner)destConnectionPoint.ParentDesigner).IsSimpleState()) { result = ConnectorCreationResult.CannotCreateTransitionToCompositeState; } // We do not allow transitions from an ancestor to its descendant else if (StateContainerEditor.IsDescendantStateOf(((StateDesigner)destConnectionPoint.ParentDesigner).ModelItem, ((StateDesigner)sourceConnectionPoint.ParentDesigner).ModelItem)) { result = ConnectorCreationResult.CannotCreateTransitionFromAncestorToDescendant; } else { using (EditingScope es = (EditingScope)this.ModelItem.BeginEdit(SR.CreateTransition)) { if (refTransitionModelItem != null) { this.CreateTransition(sourceConnectionPoint, destConnectionPoint, refTransitionModelItem, isConnectorStartMoved); } else { this.CreateTransition(sourceConnectionPoint, destConnectionPoint, null, false); } result = ConnectorCreationResult.Success; es.Complete(); } } } else if (sourceConnectionPoint.ParentDesigner is InitialNode) { StateDesigner destDesigner = (StateDesigner)destConnectionPoint.ParentDesigner; // We only allow simple states to be set as the initial state if (!destDesigner.IsSimpleState()) { result = ConnectorCreationResult.CannotSetCompositeStateAsInitialState; } else if (destDesigner.IsFinalState()) { result = ConnectorCreationResult.CannotSetFinalStateAsInitialState; } else { ModelItem destModelItem = destDesigner.ModelItem; using (EditingScope es = (EditingScope)this.ModelItem.BeginEdit(SR.SetInitialState)) { this.StateMachineModelItem.Properties[StateMachineDesigner.InitialStatePropertyName].SetValue(destModelItem); PointCollection connectorViewState = new PointCollection(ConnectorRouter.Route(this.panel, sourceConnectionPoint, destConnectionPoint)); this.StoreConnectorLocationViewState(this.StateMachineModelItem, connectorViewState, true); result = ConnectorCreationResult.Success; es.Complete(); } } } } return result; }
public static void SetSourceConnectionPoint(DependencyObject obj, ConnectionPoint connectionPoint) { obj.SetValue(FreeFormPanel.SourceConnectionPointProperty, connectionPoint); }
static public Point GetLocationRelativeToOutmostPanel(ConnectionPoint connectionPoint) { FreeFormPanel parentPanel = StateContainerEditor.GetVisualAncestor <FreeFormPanel>(connectionPoint.ParentDesigner); return(parentPanel.GetLocationRelativeToOutmostPanel(connectionPoint.Location)); }
static public Point GetLocationRelativeToOutmostPanel(ConnectionPoint connectionPoint) { FreeFormPanel parentPanel = StateContainerEditor.GetVisualAncestor<FreeFormPanel>(connectionPoint.ParentDesigner); return parentPanel.GetLocationRelativeToOutmostPanel(connectionPoint.Location); }
void UpdateStateMachineOnConnectorMoved(ConnectionPoint knownConnectionPoint, Point newPoint, Connector movedConnector, bool isConnectorStartMoved) { HitTestResult hitTestResult = VisualTreeHelper.HitTest(this.panel, newPoint); if (hitTestResult == null) { return; } UIElement newViewElement = null; ConnectionPoint newConnectionPoint = null; //The case where the Connector is dropped on a ConnectionPoint. if (this.lastConnectionPointMouseUpElement != null) { newConnectionPoint = StateContainerEditor.ConnectionPointHitTest(this.lastConnectionPointMouseUpElement, newPoint); if (newConnectionPoint != null) { newViewElement = this.lastConnectionPointMouseUpElement; } this.lastConnectionPointMouseUpElement = null; } //The case where the link is dropped on a shape. if (newViewElement == null) { newViewElement = StateContainerEditor.GetVisualAncestor<WorkflowViewElement>(hitTestResult.VisualHit); } if (newViewElement != null) { if (this.panel.IsAncestorOf(newViewElement)) { using (EditingScope es = (EditingScope)this.ModelItem.BeginEdit(SR.MoveLink)) { // Remove the old connector ModelItem this.DeleteConnectorModelItem(movedConnector); // Create new connector ConnectorCreationResult result = ConnectorCreationResult.OtherFailure; if (!isConnectorStartMoved) { if (newConnectionPoint == null) { result = CreateConnectorGesture(knownConnectionPoint, newViewElement, movedConnector, false); } else { result = CreateConnectorGesture(knownConnectionPoint, newConnectionPoint, movedConnector, false); } } else { // Don't allow moving the start of the initial node connector to a state if (!(newViewElement is StateDesigner && StateContainerEditor.IsConnectorFromInitialNode(movedConnector))) { if (newConnectionPoint == null) { result = CreateConnectorGesture(newViewElement, knownConnectionPoint, movedConnector, true); } else { result = CreateConnectorGesture(newConnectionPoint, knownConnectionPoint, movedConnector, true); } } } if (result == ConnectorCreationResult.Success) { es.Complete(); } else { StateContainerEditor.ReportConnectorCreationError(result); es.Revert(); } } } } }
void OnConnectionPointMouseDown(object sender, MouseButtonEventArgs e) { UIElement srcElement = ((Adorner)sender).AdornedElement as UIElement; this.activeSrcConnectionPoint = ConnectionPointHitTest(srcElement, e.GetPosition(this.panel)); e.Handled = true; }
void OnConnectorStartDotMouseDown(object sender, MouseButtonEventArgs e) { DependencyObject startDot = (DependencyObject)sender; Connector connector = StateContainerEditor.GetVisualAncestor<Connector>(startDot); this.activeSrcConnectionPoint = FreeFormPanel.GetSourceConnectionPoint(connector); e.Handled = true; }
void OnConnectorStartDotMouseUp(object sender, MouseButtonEventArgs e) { this.activeSrcConnectionPoint = null; RemoveAdorner(this.panel, typeof(ConnectorCreationAdorner)); }
//widthFraction and heightFraction determine the location of the ConnectionPoint on the UIElement. ConnectionPoint CreateConnectionPoint(UIElement element, double widthFraction, double heightFraction, EdgeLocation location, ConnectionPointType type) { ConnectionPoint connectionPoint = new ConnectionPoint(); connectionPoint.EdgeLocation = location; connectionPoint.PointType = type; connectionPoint.ParentDesigner = element; BindingOperations.SetBinding(connectionPoint, ConnectionPoint.LocationProperty, GetConnectionPointBinding(element as FrameworkElement, widthFraction, heightFraction)); return connectionPoint; }
Connector CreateConnector(ConnectionPoint srcConnPoint, ConnectionPoint destConnPoint, PointCollection points, ModelItem connectorModelItem) { Debug.Assert(this.IsOutmostStateContainerEditor(), "Should only be called by the outmost editor."); Connector connector = new Connector(); connector.FocusVisualStyle = null; connector.Focusable = true; DesignerView.SetCommandMenuMode(connector, CommandMenuMode.NoCommandMenu); if (connectorModelItem != null && connectorModelItem.ItemType == typeof(Transition)) { SetConnectorLabel(connector, connectorModelItem); SetConnectorStartDotToolTip(connector.startDotGrid, connectorModelItem); connector.IsTransition = true; connector.ToolTip = SR.EditTransitionTooltip; connector.startDotGrid.MouseDown += new MouseButtonEventHandler(OnConnectorStartDotMouseDown); connector.startDotGrid.MouseUp += new MouseButtonEventHandler(OnConnectorStartDotMouseUp); } connector.GotKeyboardFocus += new KeyboardFocusChangedEventHandler(OnConnectorGotKeyboardFocus); connector.RequestBringIntoView += new RequestBringIntoViewEventHandler(OnConnectorRequestBringIntoView); connector.GotFocus += new RoutedEventHandler(OnConnectorGotFocus); connector.LostFocus += new RoutedEventHandler(OnConnectorLostFocus); connector.MouseDoubleClick += new MouseButtonEventHandler(OnConnectorMouseDoubleClick); connector.MouseDown += new MouseButtonEventHandler(OnConnectorMouseDown); connector.KeyDown += new KeyEventHandler(OnConnectorKeyDown); connector.ContextMenuOpening += new ContextMenuEventHandler(OnConnectorContextMenuOpening); SetConnectorSrcDestConnectionPoints(connector, srcConnPoint, destConnPoint); StateContainerEditor.SetConnectorModelItem(connector, connectorModelItem); connector.Unloaded += new RoutedEventHandler(OnConnectorUnloaded); connector.Points = points; return connector; }
void OnStateContainerGridPreviewMouseUp(object sender, MouseButtonEventArgs e) { if (!this.IsOutmostStateContainerEditor()) { return; } UIElement destElement = StateContainerEditor.GetVisualAncestor<WorkflowViewElement>(e.OriginalSource as DependencyObject); if (destElement != null && destElement is StateDesigner) { if (this.activeSrcConnectionPoint != null) { ConnectorCreationResult result = CreateConnectorGesture(this.activeSrcConnectionPoint, destElement, null, false); if (result != ConnectorCreationResult.Success) { StateContainerEditor.ReportConnectorCreationError(result); } } RemoveAdorner(destElement, typeof(ConnectionPointsAdorner)); } if (this.activeSrcConnectionPoint != null) { this.activeSrcConnectionPoint = null; RemoveAdorner(this.panel, typeof(ConnectorCreationAdorner)); } }
void OnStateContainerGridMouseLeave(object sender, MouseEventArgs e) { if (!this.IsOutmostStateContainerEditor()) { return; } bool endLinkCreation = !IsVisualHit(sender as UIElement, sender as UIElement, e.GetPosition(sender as IInputElement)); if (endLinkCreation) { RemoveAdorner(this.panel, typeof(ConnectorCreationAdorner)); this.activeSrcConnectionPoint = null; } }
internal ConnectorCreationResult CreateConnectorGesture(UIElement source, ConnectionPoint destConnectionPoint, Connector referenceConnector, bool isConnectorStartMoved) { ConnectionPoint sourceConnectionPoint = GetClosestSrcConnectionPoint(source, destConnectionPoint); if (sourceConnectionPoint != null) { return CreateConnectorGesture(sourceConnectionPoint, destConnectionPoint, referenceConnector, isConnectorStartMoved); } return ConnectorCreationResult.OtherFailure; }
static public List<Point> GetEdgeRelativeToOutmostPanel(ConnectionPoint connectionPoint) { FreeFormPanel parentPanel = StateContainerEditor.GetVisualAncestor<FreeFormPanel>(connectionPoint.ParentDesigner); List<Point> edge = new List<Point>(); foreach (Point point in connectionPoint.Edge) { edge.Add(parentPanel.GetLocationRelativeToOutmostPanel(point)); } return edge; }
void OnConnectionPointMouseUp(object sender, MouseButtonEventArgs e) { UIElement dest = ((Adorner)sender).AdornedElement as UIElement; if (this.activeSrcConnectionPoint != null) { ConnectionPoint destConnectionPoint = ConnectionPointHitTest(dest, e.GetPosition(this.panel)); if (destConnectionPoint != null && !this.activeSrcConnectionPoint.Equals(destConnectionPoint)) { ConnectorCreationResult result = CreateConnectorGesture(this.activeSrcConnectionPoint, destConnectionPoint, null, false); if (result != ConnectorCreationResult.Success) { StateContainerEditor.ReportConnectorCreationError(result); } } this.activeSrcConnectionPoint = null; RemoveAdorner(this.panel, typeof(ConnectorCreationAdorner)); } else { //This will cause the FreeFormPanel to handle the event and is useful while moving a connector end point. this.lastConnectionPointMouseUpElement = dest; dest.RaiseEvent(e); } RemoveAdorner(dest, typeof(ConnectionPointsAdorner)); }