private static void UpdateTypeArgument(ModelItem modelItem, Type value)
{
if (value != null)
{
Type oldModelItemType = modelItem.ItemType;
Fx.Assert(oldModelItemType.GetGenericArguments().Count() == 1, "we only support changing a single type parameter ?");
Type newModelItemType = oldModelItemType.GetGenericTypeDefinition().MakeGenericType(value);
Fx.Assert(newModelItemType != null, "New model item type needs to be non null or we cannot proceed further");
ModelItem newModelItem = ModelFactory.CreateItem(modelItem.GetEditingContext(), Activator.CreateInstance(newModelItemType));
MorphHelper.MorphObject(modelItem, newModelItem);
MorphHelper.MorphProperties(modelItem, newModelItem);
if (oldModelItemType.IsSubclassOf(typeof(Activity)) && newModelItemType.IsSubclassOf(typeof(Activity)))
{
if (string.Equals((string)modelItem.Properties["DisplayName"].ComputedValue, GetActivityDefaultName(oldModelItemType), StringComparison.Ordinal))
{
newModelItem.Properties["DisplayName"].SetValue(GetActivityDefaultName(newModelItemType));
}
}
DesignerView designerView = modelItem.GetEditingContext().Services.GetService<DesignerView>();
if (designerView != null)
{
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Render, (Action)(() =>
{
if (designerView.RootDesigner != null && ((WorkflowViewElement)designerView.RootDesigner).ModelItem == modelItem)
{
designerView.MakeRootDesigner(newModelItem, true);
}
Selection.SelectOnly(modelItem.GetEditingContext(), newModelItem);
}));
}
}
}
private static void UpdateTypeArgument(ModelItem modelItem, Type value)
{
if (value != null)
{
Type oldModelItemType = modelItem.ItemType;
Fx.Assert(oldModelItemType.GetGenericArguments().Count() == 1, "we only support changing a single type parameter ?");
Type newModelItemType = oldModelItemType.GetGenericTypeDefinition().MakeGenericType(value);
Fx.Assert(newModelItemType != null, "New model item type needs to be non null or we cannot proceed further");
ModelItem newModelItem = ModelFactory.CreateItem(modelItem.GetEditingContext(), Activator.CreateInstance(newModelItemType));
MorphHelper.MorphObject(modelItem, newModelItem);
MorphHelper.MorphProperties(modelItem, newModelItem);
if (oldModelItemType.IsSubclassOf(typeof(Activity)) && newModelItemType.IsSubclassOf(typeof(Activity)))
{
if (string.Equals((string)modelItem.Properties["DisplayName"].ComputedValue, GetActivityDefaultName(oldModelItemType), StringComparison.Ordinal))
{
newModelItem.Properties["DisplayName"].SetValue(GetActivityDefaultName(newModelItemType));
}
}
DesignerView designerView = modelItem.GetEditingContext().Services.GetService <DesignerView>();
if (designerView != null)
{
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Render, (Action)(() =>
{
if (designerView.RootDesigner != null && ((WorkflowViewElement)designerView.RootDesigner).ModelItem == modelItem)
{
designerView.MakeRootDesigner(newModelItem, true);
}
Selection.SelectOnly(modelItem.GetEditingContext(), newModelItem);
}));
}
}
}
public static object ActivityActionMorphHelper(ModelItem originalValue, ModelProperty newModelProperty)
{
Fx.Assert(newModelProperty.PropertyType.GetGenericArguments().Count() == 1, "This should only be applied for ActivityAction<T>");
Type activityActionTypeArgument = newModelProperty.PropertyType.GetGenericArguments()[0];
Type activityActionType = typeof(ActivityAction<>).MakeGenericType(activityActionTypeArgument);
object activityAction = Activator.CreateInstance(activityActionType);
ModelItem morphed = ModelFactory.CreateItem(originalValue.GetEditingContext(), activityAction);
ModelItem originalActivityActionArgument = originalValue.Properties[PropertyNames.ActionArgument].Value;
if (originalActivityActionArgument != null)
{
Type variableType = typeof(DelegateInArgument<>).MakeGenericType(activityActionTypeArgument);
DelegateInArgument iterationDelegateArgument = (DelegateInArgument)Activator.CreateInstance(variableType);
iterationDelegateArgument.Name = (string)originalActivityActionArgument.Properties[PropertyNames.NameProperty].Value.GetCurrentValue();
morphed.Properties[PropertyNames.ActionArgument].SetValue(iterationDelegateArgument);
}
ModelItem originalActivityActionHandler = originalValue.Properties[PropertyNames.ActionHandler].Value;
if (originalActivityActionHandler != null)
{
morphed.Properties[PropertyNames.ActionHandler].SetValue(originalActivityActionHandler);
originalValue.Properties[PropertyNames.ActionHandler].SetValue(null);
}
return morphed;
}
internal static Argument MorphArgument(ModelItem originalValue, Type targetType)
{
Argument morphed = null;
Argument original = (Argument)originalValue.GetCurrentValue();
ActivityWithResult originalExpression = original.Expression;
if (originalExpression != null)
{
Type expressionType = originalExpression.GetType();
Type expressionGenericType = expressionType.IsGenericType ? expressionType.GetGenericTypeDefinition() : null;
if (expressionGenericType != null)
{
bool isLocation = ExpressionHelper.IsGenericLocationExpressionType(originalExpression);
ActivityWithResult morphedExpression;
EditingContext context = originalValue.GetEditingContext();
morphed = Argument.Create(targetType, original.Direction);
if (ExpressionHelper.TryMorphExpression(originalExpression, isLocation, targetType,
context, out morphedExpression))
{
morphed.Expression = morphedExpression;
}
//[....]
}
}
return morphed;
}
/// <summary>
/// Clean key in modelitem's view state
/// </summary>
public static void ClearViewState(ModelItem model, string key)
{
Contract.Requires(model != null);
Contract.Requires(key != null);
ViewStateService vss = model.GetEditingContext().Services.GetService<ViewStateService>();
vss.RemoveViewState(model, key);
}
public bool Initialize(ModelItem modelItem)
{
this.baseModelItem = modelItem;
if (null != modelItem)
{
this.context = modelItem.GetEditingContext();
}
return (null != this.baseModelItem);
}
PropertyDescriptorCollection GetPropertyDescriptors()
{
PropertyDescriptorCollection propertyDescriptors = PropertyDescriptorCollection.Empty;
try
{
object instance = parent.GetCurrentValue();
if (instance != null)
{
if (!(instance is ICustomTypeDescriptor))
{
Type instanceType = instance.GetType();
if (instanceType.IsValueType)
{
propertyDescriptors = TypeDescriptor.GetProvider(instanceType).GetTypeDescriptor(instanceType).GetProperties();
}
else
{
propertyDescriptors = TypeDescriptor.GetProvider(instance).GetTypeDescriptor(instance).GetProperties();
}
}
else
{
propertyDescriptors = TypeDescriptor.GetProperties(instance);
}
}
// Add browsable attached properties
AttachedPropertiesService AttachedPropertiesService = this.parent.GetEditingContext().Services.GetService <AttachedPropertiesService>();
if (AttachedPropertiesService != null)
{
var browsableAttachedProperties = from attachedProperty in AttachedPropertiesService.GetAttachedProperties(this.parent.ItemType)
where (attachedProperty.IsBrowsable || attachedProperty.IsVisibleToModelItem)
select new AttachedPropertyDescriptor(attachedProperty, this.parent);
List <PropertyDescriptor> mergedProperties = new List <PropertyDescriptor>();
foreach (PropertyDescriptor propertyDescriptor in propertyDescriptors)
{
mergedProperties.Add(propertyDescriptor);
}
propertyDescriptors = new PropertyDescriptorCollection(mergedProperties.Concat(browsableAttachedProperties).ToArray(), true);
}
}
catch (FileNotFoundException e)
{
EditingContext context = parent.GetEditingContext();
if (context.Items.GetValue <ErrorItem>() == null)
{
context.Items.SetValue(new ErrorItem {
Message = e.Message, Details = e.ToString()
});
}
}
return(propertyDescriptors);
}
public static void OnAddAnnotationCommandExecuted(ExecutedRoutedEventArgs e, ModelItem modelItem)
{
ModelProperty property = modelItem.Properties.Find(Annotation.AnnotationTextPropertyName);
if (property != null)
{
using (ModelEditingScope editingScope = modelItem.BeginEdit(SR.AddAnnotationDescription))
{
property.SetValue(string.Empty);
ViewStateService viewStateService = modelItem.GetEditingContext().Services.GetService<ViewStateService>();
viewStateService.StoreViewStateWithUndo(modelItem, Annotation.IsAnnotationDockedViewStateName, false);
editingScope.Complete();
}
if (modelItem.View != null)
{
WorkflowViewElement element = modelItem.View as WorkflowViewElement;
if (element != null)
{
element.OnEditAnnotation();
}
}
}
e.Handled = true;
}
public static void OnDeleteAnnotationCommandExecuted(ExecutedRoutedEventArgs e, ModelItem modelItem)
{
using (ModelEditingScope editingScope = modelItem.BeginEdit(SR.DeleteAnnotationDescription))
{
modelItem.Properties[Annotation.AnnotationTextPropertyName].SetValue(null);
ViewStateService viewStateService = modelItem.GetEditingContext().Services.GetService<ViewStateService>();
viewStateService.StoreViewStateWithUndo(modelItem, Annotation.IsAnnotationDockedViewStateName, null);
editingScope.Complete();
}
e.Handled = true;
}
internal static List<ModelItem> GetVariablesInScope(ModelItem ownerActivity)
{
List<ModelItem> declaredVariables = new List<ModelItem>();
if (ownerActivity != null)
{
bool includeArguments = !(ownerActivity.GetCurrentValue() is ActivityBuilder);
FrameworkName targetFramework = WorkflowDesigner.GetTargetFramework(ownerActivity.GetEditingContext());
if ((targetFramework != null) && (targetFramework.IsLessThan45()))
{
declaredVariables.AddRange(VariableHelper.FindVariablesInScope(ownerActivity));
declaredVariables.AddRange(VariableHelper.FindActivityDelegateArgumentsInScope(ownerActivity));
if (includeArguments)
{
declaredVariables.AddRange(VisualBasicEditor.GetVariablesForArguments(ownerActivity.Root));
}
}
else
{
declaredVariables.AddRange(VisualBasicEditor.GetVariablesInScopeWithShadowing(ownerActivity, includeArguments));
}
}
return declaredVariables;
}
void GetPropertyData(PropertyEntry property, out ModelItem activityItem, out ModelItem propertyParentItem, out EditingContext context)
{
activityItem = (ModelItem)this.propertyEntryConverter.Convert(property, typeof(ModelItem), false, null);
propertyParentItem = (ModelItem)this.propertyEntryConverter.Convert(property, typeof(ModelItem), true, null);
context = activityItem.GetEditingContext();
}
public static object ActivityFuncMorphHelper(ModelItem originalValue, ModelProperty newModelProperty)
{
Fx.Assert(newModelProperty.PropertyType.GetGenericArguments().Count() == 2, "This should only be applied for ActivityFunc<TArgument, TResult>");
Type activityFuncArgumentType = newModelProperty.PropertyType.GetGenericArguments()[0];
Type activityFuncResultType = newModelProperty.PropertyType.GetGenericArguments()[1];
Type activityFuncType = typeof(ActivityFunc<,>).MakeGenericType(activityFuncArgumentType, activityFuncResultType);
object activityFunc = Activator.CreateInstance(activityFuncType);
ModelItem morphed = ModelFactory.CreateItem(originalValue.GetEditingContext(), activityFunc);
ModelItem originalActivityFuncArgument = originalValue.Properties[PropertyNames.ActionArgument].Value;
if (originalActivityFuncArgument != null)
{
Type argumentType = typeof(DelegateInArgument<>).MakeGenericType(activityFuncArgumentType);
DelegateInArgument newActivityActionArgument = (DelegateInArgument)Activator.CreateInstance(argumentType);
newActivityActionArgument.Name = (string)originalActivityFuncArgument.Properties[PropertyNames.NameProperty].Value.GetCurrentValue();
morphed.Properties[PropertyNames.ActionArgument].SetValue(newActivityActionArgument);
}
ModelItem originalActivityFuncResult = originalValue.Properties[PropertyNames.ResultProperty].Value;
if (originalActivityFuncResult != null)
{
Type resultType = typeof(DelegateOutArgument<>).MakeGenericType(activityFuncResultType);
DelegateOutArgument newActivityActionResult = (DelegateOutArgument)Activator.CreateInstance(resultType);
newActivityActionResult.Name = (string)originalActivityFuncResult.Properties[PropertyNames.NameProperty].Value.GetCurrentValue();
morphed.Properties[PropertyNames.ResultProperty].SetValue(newActivityActionResult);
}
ModelItem originalActivityActionHandler = originalValue.Properties[PropertyNames.ActionHandler].Value;
if (originalActivityActionHandler != null)
{
morphed.Properties[PropertyNames.ActionHandler].SetValue(originalActivityActionHandler);
originalValue.Properties[PropertyNames.ActionHandler].SetValue(null);
}
return morphed;
}
private static object GetViewState(ModelItem model, string key)
{
ViewStateService vss = model.GetEditingContext().Services.GetService<ViewStateService>();
return vss.RetrieveViewState(model, key);
}
/// <summary>
/// Replace modelitem by activity
/// </summary>
/// <param name="oldModelItem"></param>
public static ModelItem UpdateModelItem(ModelItem oldModelItem, object newItem)
{
Contract.Requires(oldModelItem != null);
Contract.Requires(newItem != null);
ModelItem newModelItem = WrapAsModelItem(oldModelItem.GetEditingContext(), newItem, oldModelItem.Parent);
try
{
foreach (ModelProperty modelProperty in oldModelItem.Sources.ToList())
{
modelProperty.SetValue(newModelItem);
}
var collectionParents = from parent in oldModelItem.Parents
where parent is ModelItemCollection
select (ModelItemCollection)parent;
foreach (ModelItemCollection collectionParent in collectionParents.ToList())
{
int index = collectionParent.IndexOf(oldModelItem);
collectionParent.Insert(index, newModelItem);
collectionParent.Remove(oldModelItem);
}
}
catch
{
throw new UserFacingException("Cannot make selected activity as a task.");
}
return newModelItem;
}
/// <summary>
/// Save key object in modelitem's view state
/// </summary>
public static void StoreViewState(ModelItem model, string key, object value)
{
Contract.Requires(model != null);
Contract.Requires(key != null);
Contract.Requires(value != null);
ViewStateService vss = model.GetEditingContext().Services.GetService<ViewStateService>();
vss.StoreViewState(model, key, value);
}