private static void DoCopy(List <ModelItem> modelItemsToCopy, EditingContext context)
{
if (modelItemsToCopy == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException("modelItemsToCopy"));
}
if (context == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException("context"));
}
// copy only works if we have DesignerView up and running so check and throw here
if (context.Services.GetService <DesignerView>() == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CutCopyRequiresDesignerView));
}
modelItemsToCopy.RemoveAll((modelItem) => { return(modelItem == null); });
try
{
CutCopyOperation(modelItemsToCopy, context, false);
}
catch (ExternalException e)
{
ErrorReporting.ShowErrorMessage(e.Message);
}
}
internal static ObservableCollection <DynamicArgumentWrapperObject> ModelItemToWrapperCollection(ModelItem model, out bool isDictionary, out Type underlyingArgumentType)
{
string errorMessage = string.Empty;
underlyingArgumentType = null;
isDictionary = false;
if (model is ModelItemCollection)
{
underlyingArgumentType = model.GetCurrentValue().GetType().GetGenericArguments()[0];
if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType))
{
errorMessage = SR.NonSupportedDynamicArgumentType;
}
}
else if (model is ModelItemDictionary)
{
Type underlyingKeyType = model.GetCurrentValue().GetType().GetGenericArguments()[0];
underlyingArgumentType = model.GetCurrentValue().GetType().GetGenericArguments()[1];
if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType))
{
errorMessage = SR.NonSupportedDynamicArgumentType;
}
if (underlyingKeyType != typeof(string))
{
errorMessage += SR.NonSupportedDynamicArgumentKeyType;
}
isDictionary = true;
}
else
{
errorMessage = SR.NonSupportedModelItemCollectionOrDictionary;
}
if (!string.IsNullOrEmpty(errorMessage))
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedModelItemCollectionOrDictionary);
return(null);
}
if (isDictionary)
{
ObservableCollection <DynamicArgumentWrapperObject> wrappers = new ObservableCollection <DynamicArgumentWrapperObject>();
foreach (ModelItem item in GetArgumentCollection(model))
{
wrappers.Add(new DynamicArgumentWrapperObject(item.Properties["Key"].ComputedValue as string, item.Properties["Value"].Value));
}
return(wrappers);
}
else
{
ObservableCollection <DynamicArgumentWrapperObject> wrappers = new ObservableCollection <DynamicArgumentWrapperObject>();
foreach (ModelItem item in GetArgumentCollection(model))
{
wrappers.Add(new DynamicArgumentWrapperObject(null, item));
}
return(wrappers);
}
}
internal void ValidateEntry(DynamicArgumentWrapperObject entry, DependencyPropertyChangedEventArgs e)
{
if (e.Property == DynamicArgumentWrapperObject.NameProperty)
{
if (this.IsDictionary.Value)
{
DataGridRow row = entry.Row;
string newName = e.NewValue as string;
bool duplicates =
this.DynamicArguments.Any <DynamicArgumentWrapperObject>(
p => string.Equals(p.Name, newName) && p != entry);
if (duplicates || string.IsNullOrEmpty(newName))
{
entry.Name = e.OldValue as string;
if (duplicates)
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, SR.DuplicateArgumentName, newName));
}
else
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, SR.EmptyArgumentName));
}
}
entry.IsValidating = false;
}
}
else
{
if (e.Property == DynamicArgumentWrapperObject.DirectionProperty)
{
entry.UseLocationExpression = (entry.Direction != ArgumentDirection.In);
}
if ((e.Property != DynamicArgumentWrapperObject.ExpressionProperty) && (entry.Expression != null))
{
ActivityWithResult expression = entry.Expression.GetCurrentValue() as ActivityWithResult;
if (expression != null)
{
ActivityWithResult newExpression;
if (ExpressionHelper.TryMorphExpression(expression, entry.UseLocationExpression, entry.Type, this.Context, out newExpression))
{
entry.Expression = (this.OwnerActivity as IModelTreeItem).ModelTreeManager.WrapAsModelItem(newExpression);
}
else
{
//Microsoft
entry.Expression = null;
}
}
}
entry.IsValidating = false;
}
}
static ModelItemCollection GetArgumentCollection(ModelItem data)
{
if (data is ModelItemCollection)
{
return(data as ModelItemCollection);
}
else if (data is ModelItemDictionary)
{
return((data as ModelItemDictionary).Properties["ItemsCollection"].Collection);
}
else
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedModelItemCollectionOrDictionary);
return(null);
}
}
internal bool OnOK()
{
if (!this.AllowDuplicate)
{
List <TypeWrapper> list = new List <TypeWrapper>();
foreach (TypeWrapper tw in this.wrapperCollection)
{
if (tw.Type != null && list.Any <TypeWrapper>(entry => Type.Equals(entry.Type, tw.Type)))
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, (string)this.FindResource("duplicateEntryErrorMessage"), TypeNameHelper.GetDisplayName(tw.Type, true)));
return(false);
}
list.Add(tw);
}
}
return(true);
}
public override void ShowDialog(PropertyValue propertyValue, IInputElement commandSource)
{
//get actual value editor
var editor = DesignObjectWrapperDynamicPropertyEditor.GetEditor(propertyValue);
Fx.Assert(editor is DialogPropertyValueEditor, "PropertyValueEditor is not assigned or is not derived from DialogPropertyValueEditor");
//if we are here, the editor must derive from DialogPropertyEditor, if it doesn't user provided wrong template
if (editor is DialogPropertyValueEditor)
{
try
{
((DialogPropertyValueEditor)editor).ShowDialog(propertyValue, commandSource);
}
catch (Exception err)
{
ErrorReporting.ShowErrorMessage(err.ToString());
}
}
}
//PutCallbackOnClipBoard - tries to put into private (this application only) clipboard a callback
//to a method. The method will be invoked when user retrieves clipboard content - i.e. by
//calling a paste command.
//the callback has to be:
//- static method
//- have return value (not void)
//- takes 2 input parameters:
// * 1 parameter is modelitem - this is a target modelitem upon which callback is to be executed
// * 2 parameter is user provided context - any object. Since this callback will be executed within
// this application only, there is no need for context to be serializable.
internal static void PutCallbackOnClipBoard(Func <ModelItem, object, object> callbackMethod, Type callbackResultType, object context)
{
if (null == callbackMethod || null == context)
{
throw FxTrace.Exception.AsError(new ArgumentNullException(null == callbackMethod ? "callbackMethod" : "context"));
}
ClipboardData clipboardData = new ClipboardData();
List <object> data = new List <object>();
data.Add(callbackResultType);
data.Add(callbackMethod);
clipboardData.Data = data;
clipboardData.Version = versionInfo;
CutCopyPasteHelper.workflowCallbackContext = context;
try
{
RetriableClipboard.SetDataObject(new DataObject(WorkflowCallbackClipboardFormat, clipboardData, false), false);
}
catch (ExternalException e)
{
ErrorReporting.ShowErrorMessage(e.Message);
}
}
internal static void DoCut(List <ModelItem> modelItemsToCut, EditingContext context)
{
if (modelItemsToCut == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException("modelItemsToCut"));
}
if (context == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException("context"));
}
modelItemsToCut.RemoveAll((modelItem) => { return(modelItem == null); });
if (modelItemsToCut.Count > 0)
{
using (EditingScope es = (EditingScope)modelItemsToCut[0].BeginEdit(SR.CutOperationEditingScopeDescription))
{
try
{
CutCopyOperation(modelItemsToCut, context, true);
}
catch (ExternalException e)
{
es.Revert();
ErrorReporting.ShowErrorMessage(e.Message);
return;
}
DesignerView view = context.Services.GetService <DesignerView>();
//Setting the selection to Breadcrumb root.
Fx.Assert(view != null, "DesignerView Cannot be null during cut");
WorkflowViewElement rootView = view.RootDesigner as WorkflowViewElement;
if (rootView != null)
{
Selection.SelectOnly(context, rootView.ModelItem);
}
es.Complete();
}
}
}
void StartDragging()
{
try
{
using (ModelEditingScope editingScope = this.ModelItem.BeginEdit(SR.MoveEditingScopeDescription, true))
{
HashSet <WorkflowViewElement> draggedViews = new HashSet <WorkflowViewElement>();
Dictionary <ModelItem, ICompositeView> sourceContainers = new Dictionary <ModelItem, ICompositeView>();
HashSet <ICompositeView> compViewSet = new HashSet <ICompositeView>();
Selection selection = this.Context.Items.GetValue <Selection>();
IEnumerable <ModelItem> selectedObjects = selection.SelectedObjects;
IEnumerable <ModelItem> modelItemsToDrag = DragDropHelper.GetModelItemsToDrag(selectedObjects);
// Save the source containers for the dragged items
foreach (ModelItem modelItem in modelItemsToDrag)
{
WorkflowViewElement view = (WorkflowViewElement)modelItem.View;
draggedViews.Add(view);
ICompositeView container = DragDropHelper.GetCompositeView(view) as ICompositeView;
sourceContainers.Add(modelItem, container);
// If Add returns true => the container is added the first time, which is always ok
// If Add returns false => the container is added more than once
// it must be a IMultipleDragEnabledCompositeView, otherwise, return, because
// we don't support dragging from ICompositeView.
if (!compViewSet.Add(container) && !(container is IMultipleDragEnabledCompositeView))
{
return;
}
}
// Calculate the anchor point for the dragged items
Point relativeLocation = GetRelativeLocation(draggedViews);
Point referencePoint = this.lastMouseDownPoint;
referencePoint.Offset(relativeLocation.X, relativeLocation.Y);
DataObject dataObject = DragDropHelper.DoDragMoveImpl(draggedViews, referencePoint);
IEnumerable <WorkflowViewElement> movedViewElements = DragDropHelper.GetDragDropMovedViewElements(dataObject);
// once drag drop is done make sure the CompositeView is notified of the change in data
if (movedViewElements != null)
{
Dictionary <ICompositeView, List <ModelItem> > containerMovedModelItemList = new Dictionary <ICompositeView, List <ModelItem> >();
// Create containerMovedModelItemList
foreach (WorkflowViewElement view in movedViewElements)
{
ICompositeView compView = DragDropHelper.GetCompositeView(view) as ICompositeView;
Fx.Assert(compView != null, "not an ICompositeView");
if (!containerMovedModelItemList.ContainsKey(compView))
{
containerMovedModelItemList.Add(compView, new List <ModelItem>());
}
containerMovedModelItemList[compView].Add(view.ModelItem);
}
// Call OnItemsMoved to notify the source container.
foreach (KeyValuePair <ICompositeView, List <ModelItem> > pair in containerMovedModelItemList)
{
if (pair.Key is IMultipleDragEnabledCompositeView)
{
((IMultipleDragEnabledCompositeView)pair.Key).OnItemsMoved(pair.Value);
}
else
{
if (pair.Value.Count >= 2)
{
throw FxTrace.Exception.AsError(
new InvalidOperationException(SR.Error_MovingMoreThanOneItemsFromICompositeView));
}
pair.Key.OnItemMoved(pair.Value[0]);
}
}
// animation
foreach (WorkflowViewElement view in movedViewElements)
{
BeginDropAnimation(view);
}
}
// the drop target is using old DragDropHelper API and did not set the moved view elements
else
{
DragDropEffects executedDragDropEffect = DragDropHelper.GetDragDropCompletedEffects(dataObject);
if (executedDragDropEffect == DragDropEffects.Move)
{
if (modelItemsToDrag.Count() == 1)
{
ModelItem movedItem = modelItemsToDrag.First <ModelItem>();
sourceContainers[movedItem].OnItemMoved(movedItem);
BeginDropAnimation((WorkflowViewElement)movedItem.View);
}
else
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.DraggingMulitpleItemsError));
}
}
}
editingScope.Complete();
bool dropHappened = movedViewElements != null ||
DragDropHelper.GetDragDropCompletedEffects(dataObject) == DragDropEffects.Move;
if (dropHappened)
{
// add the selected objects back into selection.
this.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, (Action)(() =>
{
foreach (ModelItem item in selectedObjects)
{
// We need only the first one
IInputElement viewToFocus = item == null ? null : item.View as IInputElement;
if (viewToFocus != null)
{
Keyboard.Focus(viewToFocus);
break;
}
}
this.Context.Items.SetValue(new Selection(selectedObjects));
}));
}
}
}
catch (Exception e)
{
ErrorReporting.ShowErrorMessage(e.Message);
}
}
static void CutCopyOperation(List <ModelItem> modelItemsToCutCopy, EditingContext context, bool isCutOperation)
{
List <object> objectsOnClipboard = null;
List <object> metaData = null;
if (modelItemsToCutCopy.Count > 0)
{
objectsOnClipboard = new List <object>(modelItemsToCutCopy.Count);
metaData = new List <object>();
Dictionary <ICompositeView, List <ModelItem> > notifyDictionary = new Dictionary <ICompositeView, List <ModelItem> >();
UIElement breadCrumbRootView = ((DesignerView)context.Services.GetService <DesignerView>()).RootDesigner;
foreach (ModelItem modelItem in modelItemsToCutCopy)
{
object currentElement = modelItem.GetCurrentValue();
if (typeof(Activity).IsAssignableFrom(currentElement.GetType()))
{
string fileName;
if (AttachablePropertyServices.TryGetProperty(currentElement, XamlDebuggerXmlReader.FileNameName, out fileName))
{
AttachablePropertyServices.RemoveProperty(currentElement, XamlDebuggerXmlReader.FileNameName);
}
}
if (modelItem.View != null)
{
//The case where the breadcrumbroot designer is Cut/Copied. We do not delete the root designer, we only copy it.
if (breadCrumbRootView.Equals(modelItem.View))
{
notifyDictionary.Clear();
objectsOnClipboard.Add(modelItem.GetCurrentValue());
break;
}
else
{
ICompositeView container = (ICompositeView)DragDropHelper.GetCompositeView((WorkflowViewElement)modelItem.View);
if (container != null)
{
//If the parent and some of its children are selected and cut/copied, we ignore the children.
//The entire parent will be cut/copied.
//HashSet parentModelItems contains all the model items in the parent chain of current modelItem.
//We use HashSet.IntersectWith operation to determine if one of the parents is set to be cut.
HashSet <ModelItem> parentModelItems = CutCopyPasteHelper.GetSelectableParentModelItems(modelItem);
parentModelItems.IntersectWith(modelItemsToCutCopy);
if (parentModelItems.Count == 0)
{
if (!notifyDictionary.ContainsKey(container))
{
notifyDictionary[container] = new List <ModelItem>();
}
notifyDictionary[container].Add(modelItem);
}
}
}
}
}
foreach (ICompositeView container in notifyDictionary.Keys)
{
object containerMetaData = false;
if (isCutOperation)
{
containerMetaData = container.OnItemsCut(notifyDictionary[container]);
}
else
{
containerMetaData = container.OnItemsCopied(notifyDictionary[container]);
}
if (containerMetaData != null)
{
metaData.Add(containerMetaData);
}
//Put the actual activities and not the modelItems in the clipboard.
foreach (ModelItem modelItem in notifyDictionary[container])
{
objectsOnClipboard.Add(modelItem.GetCurrentValue());
}
}
if (metaData.Count == 0)
{
metaData = null;
}
}
try
{
FrameworkName targetFramework = context.Services.GetService <DesignerConfigurationService>().TargetFrameworkName;
PutOnClipBoard(objectsOnClipboard, metaData, targetFramework);
}
catch (XamlObjectReaderException exception)
{
if (modelItemsToCutCopy.Count > 0 && ErrorActivity.GetHasErrorActivities(modelItemsToCutCopy[0].Root.GetCurrentValue()))
{
ErrorReporting.ShowErrorMessage(SR.CutCopyErrorActivityMessage);
}
else
{
ErrorReporting.ShowErrorMessage(exception.Message);
}
}
}
protected virtual void ReportError(string message, string details)
{
ErrorReporting.ShowErrorMessage(message, details);
}
internal static object GetDroppedObjectInstance(DependencyObject dropTarget, EditingContext context, Type type, IDataObject dataObject)
{
if (type != null)
{
//check if type is generic
if (type.IsGenericTypeDefinition)
{
type = ResolveGenericParameters(dropTarget, context, type);
}
}
object droppedObject = null;
if (null != type)
{
try
{
droppedObject = Activator.CreateInstance(type);
if (type.IsActivityTemplateFactory() && type.IsClass)
{
//find parent WorkflowViewElement - in case of mouse drop, current drop target most likely is ISourceContainer
if (!(dropTarget is WorkflowViewElement))
{
dropTarget = VisualTreeUtils.FindVisualAncestor <WorkflowViewElement>(dropTarget);
}
Type templateFactoryInterface2 = type.GetInterface(typeof(IActivityTemplateFactory <>).FullName);
if (templateFactoryInterface2 != null)
{
droppedObject = templateFactoryInterface2.InvokeMember("Create", BindingFlags.InvokeMethod, null, droppedObject, new object[] { dropTarget, dataObject }, CultureInfo.InvariantCulture);
}
else if (droppedObject is IActivityTemplateFactory)
{
droppedObject = ((IActivityTemplateFactory)droppedObject).Create(dropTarget);
}
}
// SQM: Log activity usage count
ActivityUsageCounter.ReportUsage(context.Services.GetService <IVSSqmService>(), type);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
string details = ex.Message;
if (ex is TargetInvocationException && ex.InnerException != null)
{
details = ex.InnerException.Message;
}
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentUICulture, SR.CannotCreateInstance, TypeNameHelper.GetDisplayName(type, false)), details);
}
}
return(droppedObject);
}
