public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
bool isDefaultCase = (bool)values[1];
if (isDefaultCase)
{
// Fx.Assert(values.Length == 3, "The multi-binding must have been constructed by FlowSwitchLink.");
// For default case, we should have got three bindings. Two binding is possible when the linkModelItem is replaced but the view is not completely re-constructed yet.
return(values.Length == 3 ? values[2] : null);
}
else
{
return(GenericFlowSwitchHelper.GetString(values[0], (Type)parameter));
}
}
void OnCasePropertyChanged(DependencyPropertyChangedEventArgs e)
{
bool isUndoRedoInProgress = this.IsUndoRedoInProgress();
if (!this.internalChange && !isUndoRedoInProgress)
{
T oldValue = (T)e.OldValue;
T newValue = (T)e.NewValue;
if (newValue is string && newValue != null)
{
newValue = (T)((object)((string)((object)newValue)).Trim());
}
string oldViewStateKey = string.Empty;
if (!this.ContainsKey(newValue))
{
using (EditingScope es = (EditingScope)this.flowSwitchModelItem.BeginEdit(SR.FlowSwitchCaseRenameEditingScopeDesc))
{
ModelItem flowElementMI = null;
flowElementMI = GenericFlowSwitchHelper.GetCaseModelItem(this.flowSwitchModelItem.Properties["Cases"], oldValue);
GenericFlowSwitchHelper.RemoveCase(this.flowSwitchModelItem.Properties["Cases"], oldValue);
oldViewStateKey = GenericFlowSwitchHelper.GetString(oldValue, typeof(T)) + CaseViewStateKeyAppendString;
//Add the new value
GenericFlowSwitchHelper.AddCase(this.flowSwitchModelItem.Properties["Cases"], newValue, flowElementMI.GetCurrentValue());
//Update the viewstate for the flowswitch.
this.UpdateViewState(oldViewStateKey, GenericFlowSwitchHelper.GetString(newValue, typeof(T)) + CaseViewStateKeyAppendString);
//Making sure the value for Case is always trimmed.
this.internalChange = true;
this.ModelItem.Properties["Case"].SetValue(newValue);
es.Complete();
}
}
else
{
this.internalChange = true;
this.CaseObject = oldValue;
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidFlowSwitchCaseMessage));
}
}
this.internalChange = false;
}
public static bool ValidateCaseKey(object obj, ModelProperty casesProp, Type genericType, out string reason)
{
reason = string.Empty;
string key = GenericFlowSwitchHelper.GetString(obj, genericType);
if (GenericFlowSwitchHelper.CheckEquality(obj, genericType))
{
if (GenericFlowSwitchHelper.ContainsCaseKey(casesProp, obj))
{
reason = string.Format(CultureInfo.CurrentCulture, SR.DuplicateCaseKey, key);
return(false);
}
return(true);
}
else
{
reason = string.Format(CultureInfo.CurrentUICulture, SR.EqualityError, genericType.Name);
return(false);
}
}
void OnIsDefaultPropertyChanged(DependencyPropertyChangedEventArgs e)
{
bool isUndoRedoInProgress = this.IsUndoRedoInProgress();
if (!this.internalDefaultCaseChange && !isUndoRedoInProgress)
{
bool value = (bool)e.NewValue;
bool oldValue = (bool)e.OldValue;
if (value)
{
if (object.Equals(this.flowSwitchModelItem.Properties["Default"].Value, null))
{
using (EditingScope es = (EditingScope)this.flowSwitchModelItem.BeginEdit(SR.FlowSwitchCaseRenameEditingScopeDesc))
{
ModelItem flowNodeMI = GenericFlowSwitchHelper.GetCaseModelItem(this.flowSwitchModelItem.Properties["Cases"], this.CaseObject);
GenericFlowSwitchHelper.RemoveCase(this.flowSwitchModelItem.Properties["Cases"], this.CaseObject);
this.flowSwitchModelItem.Properties["Default"].SetValue(flowNodeMI);
this.UpdateViewState(this.CaseName + CaseViewStateKeyAppendString, DefaultConnectorViewStateKey);
this.internalChange = true;
es.Complete();
}
}
else
{
this.internalDefaultCaseChange = true;
this.IsDefaultCase = oldValue;
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.DefaultCaseExists));
}
}
else
{
if (oldValue)
{
using (EditingScope es = (EditingScope)this.flowSwitchModelItem.BeginEdit(SR.FlowSwitchCaseRenameEditingScopeDesc))
{
ModelItem defaultCase = this.flowSwitchModelItem.Properties["Default"].Value;
object uniqueCase = null;
string errorMessage = string.Empty;
Type typeArgument = typeof(T);
if (GenericFlowSwitchHelper.CanBeGeneratedUniquely(typeArgument))
{
string caseName = GenericFlowSwitchHelper.GetCaseName(this.flowSwitchModelItem.Properties["Cases"], typeArgument, out errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
this.internalDefaultCaseChange = true;
this.IsDefaultCase = oldValue;
throw FxTrace.Exception.AsError(new InvalidOperationException(errorMessage));
}
uniqueCase = GenericFlowSwitchHelper.GetObject(caseName, typeArgument);
}
else
{
FlowSwitchCaseEditorDialog editor = new FlowSwitchCaseEditorDialog(this.flowSwitchModelItem, ((WorkflowViewElement)this.flowSwitchModelItem.View).Context, this.flowSwitchModelItem.View, SR.ChangeCaseValue, this.flowSwitchModelItem.ItemType.GetGenericArguments()[0]);
editor.WindowSizeToContent = SizeToContent.WidthAndHeight;
if (!editor.ShowOkCancel())
{
this.internalDefaultCaseChange = true;
this.IsDefaultCase = oldValue;
return;
}
uniqueCase = editor.Case;
if (GenericFlowSwitchHelper.ContainsCaseKey(this.flowSwitchModelItem.Properties["Cases"], uniqueCase))
{
this.internalDefaultCaseChange = true;
this.IsDefaultCase = oldValue;
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidFlowSwitchCaseMessage));
}
}
this.flowSwitchModelItem.Properties["Default"].SetValue(null);
this.flowSwitchModelItem.Properties[FlowSwitchLabelFeature.DefaultCaseDisplayNamePropertyName].SetValue(FlowSwitchLabelFeature.DefaultCaseDisplayNameDefaultValue);
this.internalChange = true;
if (typeof(string) != typeof(T))
{
this.ModelItem.Properties["Case"].SetValue(uniqueCase);
GenericFlowSwitchHelper.AddCase(this.flowSwitchModelItem.Properties["Cases"], uniqueCase, defaultCase.GetCurrentValue());
}
else
{
this.ModelItem.Properties["Case"].SetValue(uniqueCase);
GenericFlowSwitchHelper.AddCase(this.flowSwitchModelItem.Properties["Cases"], uniqueCase, defaultCase.GetCurrentValue());
}
this.UpdateViewState(DefaultConnectorViewStateKey, GenericFlowSwitchHelper.GetString(uniqueCase, typeof(T)) + CaseViewStateKeyAppendString);
es.Complete();
this.internalChange = false;
}
this.internalDefaultCaseChange = false;
}
}
}
this.internalDefaultCaseChange = false;
}
internal Connector GetLinkOnCanvas(ModelItem srcFlowElementModelItem, ModelItem destflowElementModelItem, string propertyName)
{
Connector linkOnCanvas = null;
ModelItem shapeModelItem = null;
List <Connector> outGoingConnectors = null;
if (!srcFlowElementModelItem.Equals(this.ModelItem))
{
shapeModelItem = this.GetCorrespondingElementOnCanvas(srcFlowElementModelItem);
outGoingConnectors = GetOutGoingConnectors(this.modelElement[shapeModelItem]);
}
else // Must be startNode
{
outGoingConnectors = GetOutGoingConnectors(this.StartSymbol);
}
foreach (Connector connector in outGoingConnectors)
{
ModelItem connectorDestModelItem = ((VirtualizedContainerService.VirtualizingContainer)FreeFormPanel.GetDestinationConnectionPoint(connector).ParentDesigner).ModelItem;
ModelItem connectorDestFlowElementMI = this.GetFlowElementMI(connectorDestModelItem);
//Following condition checks if the destination for current connector is equal to the destination passed in.
if (destflowElementModelItem != null && destflowElementModelItem.Equals(connectorDestFlowElementMI))
{
if (GenericFlowSwitchHelper.IsGenericFlowSwitch(srcFlowElementModelItem.ItemType))
{
ModelItem linkModelItem = FlowchartDesigner.GetLinkModelItem(connector);
if (linkModelItem.Properties["IsDefaultCase"].Value.GetCurrentValue().Equals(true) && propertyName.Equals("Default"))
{
linkOnCanvas = connector;
break;
}
else
{
ModelItem connectorCaseMI = linkModelItem.Properties["Case"].Value;
if (linkModelItem.Properties["IsDefaultCase"].Value.GetCurrentValue().Equals(false))
{
string caseName = connectorCaseMI == null ? null : GenericFlowSwitchHelper.GetString(connectorCaseMI.GetCurrentValue(), connectorCaseMI.ItemType);
if (connectorCaseMI != null && caseName.Equals(propertyName.Substring(GenericFlowSwitchHelper.FlowSwitchCasesKeyIdentifier.Length)))
{
linkOnCanvas = connector;
break;
}
else if (connectorCaseMI == null)
{
if (GenericFlowSwitchHelper.FlowSwitchNullCaseKeyIdentifier.Equals(propertyName.Substring(GenericFlowSwitchHelper.FlowSwitchCasesKeyIdentifier.Length)))
{
linkOnCanvas = connector;
break;
}
}
}
}
}
else if (typeof(FlowDecision).IsAssignableFrom(srcFlowElementModelItem.ItemType))
{
ConnectionPoint trueConnPoint = FlowchartDesigner.GetTrueConnectionPoint(this.modelElement[shapeModelItem]);
ConnectionPoint falseConnPoint = FlowchartDesigner.GetFalseConnectionPoint(this.modelElement[shapeModelItem]);
ConnectionPoint connectorSrcConnPoint = FreeFormPanel.GetSourceConnectionPoint(connector);
if ((propertyName.Equals("True") && connectorSrcConnPoint.Equals(trueConnPoint)) ||
(propertyName.Equals("False") && connectorSrcConnPoint.Equals(falseConnPoint)))
{
linkOnCanvas = connector;
break;
}
}
else //FlowStep case.
{
linkOnCanvas = connector;
break;
}
}
}
return(linkOnCanvas);
}
//For flowchart reacting to ModelItem changes we are concerned of the following scenarios:
//1. FlowElements being deleted from the Flowchart.Nodes collection or Flowswitch cases being deleted from ItemsCollection
//2. FlowElements being added to the Flowchart.Nodes collection or Flowswitch cases being added from ItemsCollection
//3. Properties being changed in FlowStep(Next), FlowDecision(True, false), FlowSwitch(Default) (Any of the flowelemnet should be present in the elements collection).
//4. Flowswitch cases being added/remove via Cases.Dicitionary
void ModelTreeManager_EditingScopeCompleted(object sender, EditingScopeEventArgs e)
{
Fx.Assert(this.panel != null, "This code should not be hit if panel is null");
foreach (Change change in e.EditingScope.Changes)
{
//Case 1, 2.
if (change is CollectionChange)
{
CollectionChange collectionChange = change as CollectionChange;
if (collectionChange.Collection.Equals(this.ModelItem.Properties["Nodes"].Collection))
{
if (collectionChange.Operation == CollectionChange.OperationType.Delete)
{
this.DeleteShapeVisual(this.flowNodeToUIElement[collectionChange.Item]);
}
else
{
this.AddFlowElementsToDesigner(new List <ModelItem> {
collectionChange.Item
});
//An editing scope change references the ModelItem.
//Hence in case of multiple changes to the same modelItem within the same EditingScope, we will see all the changes on the ModelItem for each change.
//Eg. Suppose following two changes are in the same editing scope: 1. Add ModelItem item1 to Collection, 2. Change a property on this MI, item1.Prop1
//In this case, EditingScope.Changes.Count will be 2.
//Since an EditingScope change keeps a reference to the ModelItem changed, when we process the first change, the second change would already be reflected on the ModelItem.
//Hence, while processing CollectionChange for item1, item1.Prop1 will already reflect the new value.
//Also there will be another change notifying the change in item1.Prop1.
//AddFlowElementsToDesigner() method, walks through the properties of a newly added item and creates any links if required.
//This is necessary for Paste scenario where we want to create links between Items added to the Nodes Collection.
//Because of this behavior of AddFlowElementsToDesigner(), before reacting to a property change for adding a link, we will always verify that the link does not already exists.
}
}
if (collectionChange.Collection.Parent != null && collectionChange.Collection.Parent.Parent != null &&
this.ModelItem.Properties["Nodes"].Collection.Contains(collectionChange.Collection.Parent.Parent) &&
collectionChange.Collection.Parent.Parent.ItemType.IsGenericType &&
collectionChange.Collection.Parent.Parent.ItemType.GetGenericTypeDefinition() == typeof(FlowSwitch <>))
{
ModelItem item = collectionChange.Item;
string caseName = GenericFlowSwitchHelper.GetString(item.Properties["Key"].ComputedValue, item.Properties["Key"].PropertyType);
Connector connector = this.GetLinkOnCanvas(collectionChange.Collection.Parent.Parent,
item.Properties["Value"].Value, GenericFlowSwitchHelper.FlowSwitchCasesKeyIdentifier + caseName);
if (collectionChange.Operation == CollectionChange.OperationType.Delete)
{
if (connector != null)
{
this.DeleteLinkVisual(connector);
}
}
else if (collectionChange.Operation == CollectionChange.OperationType.Insert)
{
if (connector == null)
{
//Prepending GenericFlowSwitchHelper.FlowSwitchCasesKeyIdentifier to differentiate between the FlowSwitch's Property Default and key Default.
connector = this.CreatePropertyLink(collectionChange.Collection.Parent.Parent,
item.Properties["Value"].Value,
GenericFlowSwitchHelper.FlowSwitchCasesKeyIdentifier + caseName);
Fx.Assert(connector != null, "Link not created");
this.panel.Children.Add(connector);
}
else
{
RefreshFlowSwitchLinkModelItem(/* flowSwitchModelItem = */ collectionChange.Collection.Parent.Parent, connector, false);
}
}
}
}
else if (change is DictionaryChange)
{
// case 4
DictionaryChange dictionaryChange = change as DictionaryChange;
if (dictionaryChange.Dictionary.Parent != null &&
this.ModelItem.Properties["Nodes"].Collection.Contains(dictionaryChange.Dictionary.Parent) &&
dictionaryChange.Dictionary.Parent.ItemType.IsGenericType &&
dictionaryChange.Dictionary.Parent.ItemType.GetGenericTypeDefinition() == typeof(FlowSwitch <>))
{
ModelItem flowSwitchModelItem = dictionaryChange.Dictionary.Parent;
ModelItem caseTargetModelItem = dictionaryChange.Value;
string caseName = GenericFlowSwitchHelper.GetString(dictionaryChange.Key == null ? null : dictionaryChange.Key.GetCurrentValue(), dictionaryChange.Key == null ? null : dictionaryChange.Key.ItemType);
string caseNameInModelItem = GenericFlowSwitchHelper.FlowSwitchCasesKeyIdentifier + caseName;
Connector connector = this.GetLinkOnCanvas(
flowSwitchModelItem,
caseTargetModelItem,
caseNameInModelItem);
if (dictionaryChange.Operation == DictionaryChange.OperationType.Delete)
{
if (connector != null)
{
this.DeleteLinkVisual(connector);
}
}
else if (dictionaryChange.Operation == DictionaryChange.OperationType.Insert)
{
if (connector == null)
{
connector = this.CreatePropertyLink(
flowSwitchModelItem,
caseTargetModelItem,
caseNameInModelItem);
this.panel.Children.Add(connector);
}
}
}
}
//Case 3.
else if (change is PropertyChange)
{
PropertyChange propertyChange = change as PropertyChange;
if (this.ModelItem.Properties["Nodes"].Collection.Contains(propertyChange.Owner) ||
(propertyChange.PropertyName == "StartNode" && propertyChange.Owner == this.ModelItem))
{
if (propertyChange.OldValue != null &&
IsFlowNode(propertyChange.OldValue))
{
Connector link = GetLinkOnCanvas(propertyChange.Owner, propertyChange.OldValue, propertyChange.PropertyName);
//Debug.Assert(link != null, "Link not found on designer");
if (link != null)
{
this.DeleteLinkVisual(link);
}
}
if (propertyChange.NewValue != null &&
IsFlowNode(propertyChange.NewValue))
{
Connector oldLink = GetLinkOnCanvas(propertyChange.Owner, propertyChange.NewValue, propertyChange.PropertyName);
//If this connector has already been added don't add again.
if (oldLink == null)
{
Connector link = CreatePropertyLink(propertyChange.Owner, propertyChange.NewValue, propertyChange.PropertyName);
Fx.Assert(link != null, "Link not created");
this.panel.Children.Add(link);
}
else
{
if (GenericFlowSwitchHelper.IsGenericFlowSwitch(propertyChange.Owner.ItemType))
{
this.RefreshFlowSwitchLinkModelItem(/* flowSwitchModelItem = */ propertyChange.Owner, oldLink, true);
}
}
}
//handling for the case where the FlowStep.Action changes:
//Explicitly adding a check for FlowStep, because other FlowNodes have properties of type Activity, which we don't want to react to.
//AddFlowElementsToDesigner() will add the links originating out of the shape that is changing.
//We have to take care of refreshing the links coming into the shape that is changing.
if (typeof(FlowStep).IsAssignableFrom(propertyChange.Owner.ItemType))
{
List <Connector> oldIncomingConnectors = new List <Connector>();
if (propertyChange.OldValue != null && IsFlowStepAction(propertyChange.OldValue))
{
UIElement oldShape = this.flowNodeToUIElement[propertyChange.Owner];
oldIncomingConnectors = this.GetInComingConnectors(oldShape);
this.DeleteShapeVisual(oldShape);
}
if (propertyChange.NewValue != null && IsFlowStepAction(propertyChange.NewValue))
{
this.AddFlowElementsToDesigner(new List <ModelItem> {
propertyChange.Owner
});
foreach (Connector oldConnector in oldIncomingConnectors)
{
Connector newConnector = CreateLink(FreeFormPanel.GetSourceConnectionPoint(oldConnector),
this.flowNodeToUIElement[propertyChange.Owner], FlowchartDesigner.GetLinkModelItem(oldConnector));
this.panel.Children.Add(newConnector);
}
}
}
}
}
}
}
public static string GenericGetCaseName <T>(ModelItemCollection collection, out string errorMessage)
{
int maxName = 100000;
Type type = typeof(T);
errorMessage = string.Empty;
if (typeof(string).IsAssignableFrom(type))
{
string caseName = "caseN";
for (int i = 1; i <= maxName; i++)
{
caseName = string.Format(CultureInfo.InvariantCulture, SR.CaseFormat, i);
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, caseName))
{
break;
}
}
return(caseName);
}
else if (GenericFlowSwitchHelper.IsIntegralType(type))
{
if (type == typeof(sbyte))
{
sbyte maxCount = (sbyte.MaxValue < maxName) ? sbyte.MaxValue : (sbyte)maxName;
for (sbyte i = 0; i <= maxCount; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(byte))
{
byte maxCount = (byte.MaxValue < maxName) ? byte.MaxValue : (byte)maxName;
for (byte i = 0; i <= maxCount; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(char))
{
char maxCount = unchecked ((char)maxName);
for (char i = (char)48; i <= maxCount; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(short))
{
short maxCount = (short)maxName;
for (short i = 0; i <= maxCount; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(ushort))
{
ushort maxCount = (ushort)maxName;
for (ushort i = 0; i <= maxCount; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(int))
{
for (int i = 0; i <= maxName; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(uint))
{
for (uint i = 0; i <= (uint)maxName; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(long))
{
for (long i = 0; i <= (long)maxName; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
else if (type == typeof(ulong))
{
for (ulong i = 0; i <= (ulong)maxName; i++)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, i))
{
return(GenericFlowSwitchHelper.GetString(i, type));
}
}
}
errorMessage = SR.InvalidFlowSwitchCaseMessage;
return(string.Empty);
}
else if (type.IsEnum)
{
Array array = type.GetEnumValues();
foreach (object value in array)
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, value))
{
return(GenericFlowSwitchHelper.GetString(value, type));
}
}
errorMessage = SR.InvalidFlowSwitchCaseMessage;
return(string.Empty);
}
else if (type == typeof(bool))
{
if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, true))
{
return(GenericFlowSwitchHelper.GetString(true, type));
}
else if (!GenericFlowSwitchHelper.ContainsCaseKey(collection, false))
{
return(GenericFlowSwitchHelper.GetString(false, type));
}
errorMessage = SR.InvalidFlowSwitchCaseMessage;
return(string.Empty);
}
return(string.Empty);
}
