public static CompileProject GetCompileProject(WorkflowEditorViewModel focusedWorkflowItem)
{
Contract.Requires(focusedWorkflowItem != null);
Contract.Requires(focusedWorkflowItem.WorkflowDesigner != null);
return GetCompileProject(focusedWorkflowItem.WorkflowDesigner);
}
public ProjectExplorerViewModel(WorkflowEditorViewModel paramEditor)
{
if (paramEditor != null)
{
this.WorkflowEditor = paramEditor;
this.WorkflowEditor.PropertyChanged += this.WorkflowDesignerChanged;
this.Designer.Context.Items.Subscribe<Selection>(ActivityFocusedChanged);
}
else
throw new Exception("Argument WorkflowEditor is null.");
this.RefreshProjectExplorer();
}
public DesignerAddIn()
{
CreateIntellisense(cancellationToken);
AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly;
new DesignerMetadata().Register();
WorkflowEditorVM = new WorkflowEditorViewModel(cancellationToken);
WorkflowEditorVM.PropertyChanged += this.WorkflowEditorVM_PropertyChanged;
WorkflowEditorVM.PrintStateChanged += new EventHandler(this.OnPrintStateChanged);
WorkflowEditorVM.DesignerChanged += new EventHandler(this.WorkflowDesignerChanged);
WorkflowEditorVM.GetTaskLastVersionChanged += new GetTaskLastVersionEventHandler(this.OnGetTaskLastVersion);
Task.Factory.StartNew(() => { PrincipalService.Init(); }, cancellationToken.Token);
Current = this;
}
private ModelItem GetSelectdModelItem(WorkflowEditorViewModel workItem)
{
return workItem.IfNotNull(dataContext => dataContext.WorkflowDesigner)
.IfNotNull(workflowDesigner => workflowDesigner.Context)
.Items.GetValue<Selection>().PrimarySelection;
}
private void ConfigureWorkItem(WorkflowEditorViewModel workflowItem)
{
workflowItem.WorkflowDesignerChanged += OnWorkflowDesignerChanged;
workflowItem.DesignerChanged += OnDesignerChanged;
}
/// <summary>
/// Every time we get a new WorkflowDesigner, make sure it has a "Make Steps" context menu
/// and recompute steps
/// </summary>
/// <param name="workflowDesigner"></param>
private void ConfigureWorkflowDesigner(WorkflowEditorViewModel workflowItem, bool isTask)
{
ContextMenu menu = null;
if (workflowItem.WorkflowDesigner != null)
menu = workflowItem.WorkflowDesigner.ContextMenu;
// There may be a better way of attaching MenuItems to each templated
// child of a template, but for now we are checking menu item headers
// to attach a "Make Step" menu item once and only once to a given
// WorkflowDesigner
if (menu != null)
{
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, MakeStepOnHead)))
{
menu.Items.Insert(0, new MenuItem
{
Header = MakeStepOnHead,
Command = MakeStepCommand
});
}
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, UpdateAllOthersOnHead)))
{
menu.Items.Insert(1, new MenuItem
{
Header = UpdateAllOthersOnHead,
Command = UpdateCommand
});
}
if (!isTask)
{
menu.Items.Insert(2, new Separator());
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, AssignOnHead)))
{
menu.Items.Insert(3, new MenuItem
{
Header = AssignOnHead,
Command = AssignCommand
});
}
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, MergeOnHead)))
{
menu.Items.Insert(4, new MenuItem
{
Header = MergeOnHead,
Command = MergeCommand,
});
}
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, MergeAllOnHead)))
{
menu.Items.Insert(5, new MenuItem
{
Header = MergeAllOnHead,
Command = MergeAllCommand,
});
}
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, UnassignOnHead)))
{
menu.Items.Insert(6, new MenuItem
{
Header = UnassignOnHead,
Command = UnassignCommand
});
}
if (!menu.Items.OfType<MenuItem>().Any(menuItem =>
object.ReferenceEquals(menuItem.Header, UnassignAllOnHead)))
{
menu.Items.Insert(7, new MenuItem
{
Header = UnassignAllOnHead,
Command = UnassignAllCommand
});
}
menu.Items.Insert(8, new Separator());
RegisterActivityFocusedChanged();
}
}
}
private static bool Load(FrameworkElement element)
{
workflowItem = LoadWorkflowItem(element);
designerView = LoadDeignerView(element);
AdornerDecorator decorator = LoadAdornerDecorator(element);
workflowView = LoadWorkflowView(decorator);
RegisterWorkflowViewEvents(workflowView);
scrollViewer = LoadScrollViewer(decorator);
RegisterScrollViewChanged(scrollViewer);
workflowViewMask = CreateWorkflowViewMask(workflowView);
closeButton = CreateCloseButton(workflowView);
rootActivityDesigner = LoadRootActivityDesigner(workflowView);
if (rootActivityDesigner == null)
{
AddInMessageBoxService.PrintNoneActivityMessage();
ExitPrint();
return false;
}
return true;
}
public static void GetAllLastVersion(IEnumerable<ModelItem> tasks, WorkflowEditorViewModel workflowItem)
{
Contract.Requires(workflowItem != null);
Contract.Requires(workflowItem.WorkflowDesigner != null);
UpdateTaskItem(tasks, workflowItem);
}
private static void UpdateTaskItem(IEnumerable<ModelItem> source, WorkflowEditorViewModel workflowItem)
{
var taskModelItem = GetLastVersionActivity(source, workflowItem);
MergeAllTaskArgmentToParent(
taskModelItem,
workflowItem.WorkflowDesigner.GetRoot());
CompositeService.UpdateModelItem(taskModelItem.ToDictionary(
t => t.Key,
t => t.Key.GetTaskActivity().CreateTaskActivity(t.Value) as Activity));
}
private static void UpdateTaskItem(ModelItem source, WorkflowEditorViewModel workflowItem)
{
ModelItem taskModelItem = GetLastVersionActivity(source, workflowItem);
MergeTaskArgmentToParent(taskModelItem, workflowItem.WorkflowDesigner.GetRoot(), source);
CompositeService.UpdateModelItem(source, source.GetTaskActivity().CreateTaskActivity(taskModelItem));
}
private static IDictionary<ModelItem, ModelItem> GetLastVersionActivity(IEnumerable<ModelItem> tasks, WorkflowEditorViewModel workflowItem)
{
var result = TaskService.GetLastVersionTaskActivityDC(tasks.Select(t => t.GetTaskActivity().TaskId).ToArray());
workflowItem.DownloadTaskDependency(result);
return (from t in tasks
from r in result
let ta = t.GetTaskActivity()
where ta.TaskId == r.Guid
select new
{
Key = t,
Value = CompositeService.CreateActivity(r.Activity.Xaml),
}).ToDictionary(d => d.Key, d => d.Value);
}
private static ModelItem GetLastVersionActivity(ModelItem source, WorkflowEditorViewModel workflowItem)
{
TaskActivity task = source.GetTaskActivity();
var result = TaskService.GetLastVersionTaskActivityDC(task.TaskId);
workflowItem.DownloadTaskDependency(result);
return CompositeService.CreateActivity(result.Activity.Xaml);
}
public static void GetLastVersion(ModelItem source, WorkflowEditorViewModel workflowItem)
{
Contract.Requires(source != null);
Contract.Requires(workflowItem != null);
UpdateTaskItem(source, workflowItem);
}
// should never be called by anyone except WorkflowItem
public ErrorService(WorkflowEditorViewModel owner)
{
this.owner = owner;
xamlErrors.CollectionChanged += xamlErrors_CollectionChanged;
validationErrors.CollectionChanged += validationErrors_CollectionChanged;
}
