void OnPopulateContainer(VirtualizedContainerService.VirtualizingContainer virtualContainer)
{
if (this.shouldAbort)
{
return;
}
//if this is virutal container, it might contain multiple other virtual containers - i need to find the one
//which either is a container for item i want to focus, or one which is parent designer for the item i'm looking for
//look for the container which contains or is a parent of container i look for
var target = virtualContainer
.ChildContainers
.FirstOrDefault(p => ModelItem.Equals(this.itemToFocus, p.ModelItem) || p.ModelItem.IsParentOf(this.itemToFocus));
//if one is found - populate it and bring it into view
if (null != target)
{
target.Populate();
target.BringIntoView();
}
}
// 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);
}
}
protected override void OnRender(DrawingContext drawingContext)
{
const int textCulture = 9;
ConnectionPoint trueConnectionPoint = null;
ConnectionPoint falseConnectionPoint = null;
if (this.connectionPoints.Contains(FlowchartDesigner.GetTrueConnectionPoint(this.AdornedElement)))
{
trueConnectionPoint = FlowchartDesigner.GetTrueConnectionPoint(this.AdornedElement);
}
if (this.connectionPoints.Contains(FlowchartDesigner.GetFalseConnectionPoint(this.AdornedElement)))
{
falseConnectionPoint = FlowchartDesigner.GetFalseConnectionPoint(this.AdornedElement);
}
Point actualPoint;
Point origin = FreeFormPanel.GetLocation(AdornedElement);
Thickness margin = ((FrameworkElement)AdornedElement).Margin;
origin.X += margin.Left;
origin.Y += margin.Top;
foreach (ConnectionPoint connPoint in this.connectionPoints)
{
actualPoint = new Point(connPoint.Location.X - origin.X, connPoint.Location.Y - origin.Y);
this.DrawConnectionPoint(connPoint, actualPoint, drawingContext);
}
if (trueConnectionPoint != null)
{
string trueLabelText = String.Empty;
VirtualizedContainerService.VirtualizingContainer virtualizingContainer = (VirtualizedContainerService.VirtualizingContainer)trueConnectionPoint.ParentDesigner;
if (virtualizingContainer != null && virtualizingContainer.ModelItem != null)
{
trueLabelText = (string)virtualizingContainer.ModelItem.Properties["TrueLabel"].ComputedValue;
}
actualPoint = new Point(trueConnectionPoint.Location.X - origin.X, trueConnectionPoint.Location.Y - origin.Y);
FormattedText trueMarkerFormattedText = new FormattedText(trueLabelText, new System.Globalization.CultureInfo(textCulture),
this.FlowDirection, FlowchartDesigner.FlowElementCaptionTypeface, FlowchartDesigner.FlowNodeCaptionFontSize,
new SolidColorBrush(WorkflowDesignerColors.WorkflowViewElementCaptionColor));
actualPoint.Y += ConnectionPoint.DrawingLargeSide / 2;
actualPoint.X -= trueMarkerFormattedText.WidthIncludingTrailingWhitespace;
DrawtWithTransform(
drawingContext,
this.isTextRightToLeft,
// Mirror the left side text to the right side by using this axis when RTL.
actualPoint.X,
() =>
{
drawingContext.DrawText(trueMarkerFormattedText, actualPoint);
});
}
if (falseConnectionPoint != null)
{
string falseLabelText = String.Empty;
VirtualizedContainerService.VirtualizingContainer virtualizingContainer = (VirtualizedContainerService.VirtualizingContainer)falseConnectionPoint.ParentDesigner;
if (virtualizingContainer != null && virtualizingContainer.ModelItem != null)
{
falseLabelText = (string)virtualizingContainer.ModelItem.Properties["FalseLabel"].ComputedValue;
}
actualPoint = new Point(falseConnectionPoint.Location.X - origin.X, falseConnectionPoint.Location.Y - origin.Y);
actualPoint.Y += ConnectionPoint.DrawingLargeSide / 2;
FormattedText falseMarkerFormattedText = new FormattedText(falseLabelText, new System.Globalization.CultureInfo(textCulture),
this.FlowDirection, FlowchartDesigner.FlowElementCaptionTypeface, FlowchartDesigner.FlowNodeCaptionFontSize,
new SolidColorBrush(WorkflowDesignerColors.WorkflowViewElementCaptionColor));
DrawtWithTransform(
drawingContext,
this.isTextRightToLeft,
// Mirror the left side text to the right side by using this axis when RTL.
actualPoint.X,
() =>
{
drawingContext.DrawText(falseMarkerFormattedText, actualPoint);
});
}
base.OnRender(drawingContext);
}
bool UpdateFlowChartObject(ConnectionPoint sourceConnPoint, ConnectionPoint destConnPoint, out string errorMessage, bool isLinkValidDueToLinkMove, IFlowSwitchLink caseKey)
{
//srcDesigner will be null for the case where source designer is StartSymbol.
VirtualizedContainerService.VirtualizingContainer srcDesigner = sourceConnPoint.ParentDesigner as VirtualizedContainerService.VirtualizingContainer;
VirtualizedContainerService.VirtualizingContainer destDesigner = destConnPoint.ParentDesigner as VirtualizedContainerService.VirtualizingContainer;
ModelItem linkSource;
ModelItem linkDest = destDesigner.ModelItem;
ModelItem destFlowElementMI = GetFlowElementMI(linkDest);
PointCollection connectorViewState = new PointCollection(ConnectorRouter.Route(this.panel, sourceConnPoint, destConnPoint));
errorMessage = string.Empty;
if (sourceConnPoint.ParentDesigner is StartSymbol)
{
linkSource = this.ModelItem;
if (linkSource.Properties["StartNode"].Value == null || isLinkValidDueToLinkMove)
{
this.StoreConnectorViewState(linkSource, connectorViewState, sourceConnPoint);
linkSource.Properties["StartNode"].SetValue(destFlowElementMI);
}
else
{
errorMessage = SR.FCNextLinkDefined;
}
}
else
{
linkSource = srcDesigner.ModelItem;
ModelItem srcFlowElementMI = GetFlowElementMI(linkSource);
if (typeof(FlowStep).IsAssignableFrom(srcFlowElementMI.ItemType))
{
if (srcFlowElementMI.Properties["Next"].Value == null || isLinkValidDueToLinkMove)
{
this.StoreConnectorViewState(srcFlowElementMI, connectorViewState, sourceConnPoint);
srcFlowElementMI.Properties["Next"].SetValue(destFlowElementMI);
}
else
{
errorMessage = SR.FCNextLinkDefined;
}
}
else if (typeof(FlowDecision).IsAssignableFrom(srcFlowElementMI.ItemType))
{
if (sourceConnPoint.Equals(FlowchartDesigner.GetTrueConnectionPoint(this.modelElement[linkSource])))
{
if (linkSource.Properties["True"].Value == null || isLinkValidDueToLinkMove)
{
this.StoreConnectorViewState(srcFlowElementMI, connectorViewState, sourceConnPoint);
linkSource.Properties["True"].SetValue(destFlowElementMI);
}
else
{
errorMessage = SR.FCTrueBranchExists;
}
}
else if (sourceConnPoint.Equals(FlowchartDesigner.GetFalseConnectionPoint(this.modelElement[linkSource])))
{
if (linkSource.Properties["False"].Value == null || isLinkValidDueToLinkMove)
{
this.StoreConnectorViewState(srcFlowElementMI, connectorViewState, sourceConnPoint);
linkSource.Properties["False"].SetValue(destFlowElementMI);
}
else
{
errorMessage = SR.FCFalseBranchExists;
}
}
else
{
errorMessage = SR.FCFlowConditionLinkError;
}
}
else //FlowSwitch
{
if (!CreateFlowSwitchLink(sourceConnPoint, srcFlowElementMI, destFlowElementMI, caseKey, connectorViewState, ref errorMessage))
{
return(false);
}
}
}
return(errorMessage.Equals(string.Empty));
}
