void OnContextChanged()
{
this.targetFramework = WorkflowDesigner.GetTargetFramework(this.Context);
AttachedPropertiesService attachedPropertyService = this.Context.Services.GetService <AttachedPropertiesService>();
Fx.Assert(attachedPropertyService != null, "AttachedPropertiesService shouldn't be null in EditingContext.");
attachedPropertyService.AddProperty(CreateAttachedPropertyForNamespace <string>(ErrorMessagePropertyName));
attachedPropertyService.AddProperty(CreateAttachedPropertyForNamespace <bool>(IsInvalidPropertyName));
//clear any defaults because it's meant to be set by host and not serialized to XAML
VisualBasicSettings.Default.ImportReferences.Clear();
ModelService modelService = this.Context.Services.GetService <ModelService>();
Fx.Assert(modelService != null, "ModelService shouldn't be null in EditingContext.");
Fx.Assert(modelService.Root != null, "model must have a root");
this.importsModelItem = modelService.Root.Properties[NamespaceListPropertyDescriptor.ImportCollectionPropertyName].Collection;
Fx.Assert(this.importsModelItem != null, "root must have imports");
this.importsModelItem.CollectionChanged += this.OnImportsModelItemCollectionChanged;
this.importedNamespacesItem = this.Context.Items.GetValue <ImportedNamespaceContextItem>();
this.importedNamespacesItem.EnsureInitialized(this.Context);
if (this.availableNamespaces == null)
{
//change to available namespace should not be a model change so we access the dictionary directly
this.availableNamespaces = this.importsModelItem.Properties[NamespaceListPropertyDescriptor.AvailableNamespacesPropertyName].ComputedValue as Dictionary <string, List <string> >;
Fx.Assert(this.availableNamespaces != null, "Available namespace dictionary is not in right format");
}
RefreshNamespaces();
}
public override void Initialize(EditingContext context)
{
this.context = context;
AttachedPropertiesService propertiesService = this.context.Services.GetService <AttachedPropertiesService>();
helpService = this.context.Services.GetService <IIntegratedHelpService>();
oldSelection = this.context.Items.GetValue <Selection>();
isPrimarySelectionProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => (this.context.Items.GetValue <Selection>().PrimarySelection == modelItem),
Name = "IsPrimarySelection",
OwnerType = typeof(Object)
};
isSelectionProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => (((IList)this.context.Items.GetValue <Selection>().SelectedObjects).Contains(modelItem)),
Name = "IsSelection",
OwnerType = typeof(Object)
};
propertiesService.AddProperty(isPrimarySelectionProperty);
propertiesService.AddProperty(isSelectionProperty);
if (this.context.Services.GetService <ViewService>() == null)
{
view = new System.Activities.Presentation.View.DesignerView(this.context);
WorkflowViewService viewService = new WorkflowViewService(context);
WorkflowViewStateService viewStateService = new WorkflowViewStateService(context);
this.context.Services.Publish <ViewService>(viewService);
this.context.Services.Publish <VirtualizedContainerService>(new VirtualizedContainerService(this.context));
this.context.Services.Publish <ViewStateService>(viewStateService);
this.context.Services.Publish <DesignerView>(view);
WorkflowAnnotationAdornerService annotationService = new WorkflowAnnotationAdornerService();
annotationService.Initialize(this.context, view.scrollViewer);
this.context.Services.Publish <AnnotationAdornerService>(annotationService);
this.context.Services.Subscribe <ModelService>(delegate(ModelService modelService)
{
this.modelService = modelService;
if (modelService.Root != null)
{
view.MakeRootDesigner(modelService.Root);
}
view.RestoreDesignerStates();
this.context.Items.Subscribe <Selection>(new SubscribeContextCallback <Selection>(OnItemSelected));
});
}
if (helpService != null)
{
helpService.AddContextAttribute(string.Empty, KeywordForWorkflowDesignerHomePage, HelpKeywordType.F1Keyword);
}
}
private static void ExposeArgumentTypeForUpdate(ModelItem modelItem, AttachedPropertiesService service, int argIndex, int argsLength)
{
service.AddProperty(new AttachedProperty <Type>
{
Name = argsLength > 1
? TypeArgumentPropertyName + (argIndex + 1)
: TypeArgumentPropertyName,
OwnerType = modelItem.ItemType,
Getter = (mItem) => GetTypeArgument(mItem, argIndex),
Setter = (mItem, argType) => UpdateTypeArgument(mItem, argType, argIndex),
IsBrowsable = true
});
}
internal void Initialize(EditingContext editingContext, ScrollViewer scrollViewer)
{
this.scrollViewer = scrollViewer;
this.enabled = editingContext.Services.GetService <DesignerConfigurationService>().AnnotationEnabled;
if (!this.enabled)
{
return;
}
AttachedPropertiesService attachedPropertiesService = editingContext.Services.GetService <AttachedPropertiesService>();
AttachedProperty <string> attachedProperty = new AttachedProperty <string>
{
IsBrowsable = false,
IsVisibleToModelItem = true,
Name = Annotation.AnnotationTextPropertyName,
OwnerType = typeof(object),
Getter = (modelItem) =>
{
string annotation = null;
AttachablePropertyServices.TryGetProperty <string>(modelItem.GetCurrentValue(), Annotation.AnnotationTextProperty, out annotation);
return(annotation);
},
Setter = (modelItem, value) =>
{
string oldValue = null;
AttachablePropertyServices.TryGetProperty <string>(modelItem.GetCurrentValue(), Annotation.AnnotationTextProperty, out oldValue);
if (oldValue == value)
{
return;
}
ModelTreeManager treeManager = modelItem.GetEditingContext().Services.GetService <ModelTreeManager>();
AttachablePropertyChange change = new AttachablePropertyChange()
{
Owner = modelItem,
AttachablePropertyIdentifier = Annotation.AnnotationTextProperty,
OldValue = oldValue,
NewValue = value,
PropertyName = Annotation.AnnotationTextPropertyName
};
treeManager.AddToCurrentEditingScope(change);
}
};
attachedPropertiesService.AddProperty(attachedProperty);
}
public static void Attach(ModelItem modelItem, Int32 maximumUpdatableTypes)
{
Type[] genericArguments = modelItem.ItemType.GetGenericArguments();
if (genericArguments.Any() == false)
{
return;
}
Int32 argumentCount = genericArguments.Length;
Int32 updatableArgumentCount = Math.Min(argumentCount, maximumUpdatableTypes);
EditingContext context = modelItem.GetEditingContext();
AttachedPropertiesService attachedPropertiesService = context.Services.GetService <AttachedPropertiesService>();
for (Int32 index = 0; index < updatableArgumentCount; index++)
{
AttachUpdatableArgumentType(modelItem, attachedPropertiesService, index, updatableArgumentCount);
}
}
private void RegisterDisplayNameProperty()
{
AttachedPropertiesService attachedPropertiesService =
this.Context.Services.GetService <AttachedPropertiesService>();
if (attachedPropertiesService == null)
{
return;
}
IEnumerable <AttachedProperty> properties = attachedPropertiesService.GetAttachedProperties(typeof(ActivityBuilder <>));
if (properties != null && properties.Contains(displayNameProperty))
{
return;
}
attachedPropertiesService.AddProperty(displayNameProperty);
}
void OnAttachedPropertiesServiceAvailable(AttachedPropertiesService attachedPropertiesService)
{
this.isBreakpointEnabledProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => IsBreakpointOfType(modelItem, BreakpointTypes.Enabled),
Name = "IsBreakpointEnabled",
OwnerType = typeof(object)
};
this.isBreakpointBoundedProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => IsBreakpointOfType(modelItem, BreakpointTypes.Bounded),
Name = "IsBreakpointBounded",
OwnerType = typeof(object)
};
this.isBreakpointConditionalProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => IsBreakpointOfType(modelItem, BreakpointTypes.Conditional),
Name = "IsBreakpointConditional",
OwnerType = typeof(object)
};
this.isCurrentLocationProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => IsCurrentLocation(modelItem),
Name = "IsCurrentLocation",
OwnerType = typeof(object)
};
this.isCurrentContextProperty = new AttachedProperty <bool>()
{
Getter = (modelItem) => IsCurrentContext(modelItem),
Name = "IsCurrentContext",
OwnerType = typeof(object)
};
attachedPropertiesService.AddProperty(isBreakpointEnabledProperty);
attachedPropertiesService.AddProperty(isBreakpointBoundedProperty);
attachedPropertiesService.AddProperty(isBreakpointConditionalProperty);
attachedPropertiesService.AddProperty(isCurrentLocationProperty);
attachedPropertiesService.AddProperty(isCurrentContextProperty);
}
void OnAttachedPropertiesServiceAvailable(AttachedPropertiesService attachedPropertiesService)
{
this.validationStateProperty = new AttachedProperty <ValidationState>()
{
Getter = (modelItem) => GetValidationState(modelItem),
Name = "ValidationState",
OwnerType = typeof(object)
};
attachedPropertiesService.AddProperty(this.validationStateProperty);
this.validationMessageProperty = new AttachedProperty <string>()
{
Getter = (modelItem) => GetValidationMessage(modelItem),
Name = "ValidationMessage",
OwnerType = typeof(object)
};
attachedPropertiesService.AddProperty(this.validationMessageProperty);
}
public DisplayNameUpdater(EditingContext context)
{
activityBuilderDisplayNameProperty = new AttachedProperty <string>
{
Name = "DisplayName",
OwnerType = typeof(ActivityBuilder),
Getter = (modelItem) => ViewUtilities.GetActivityBuilderDisplayName(modelItem)
};
activityTemplateFactoryBuilderDisplayNameProperty = new AttachedProperty <string>
{
Name = "DisplayName",
OwnerType = typeof(ActivityTemplateFactoryBuilder),
Getter = (modelItem) => ViewUtilities.GetActivityBuilderDisplayName(modelItem)
};
AttachedPropertiesService attachedPropertiesService = context.Services.GetService <AttachedPropertiesService>();
attachedPropertiesService.AddProperty(activityBuilderDisplayNameProperty);
attachedPropertiesService.AddProperty(activityTemplateFactoryBuilderDisplayNameProperty);
context.Services.GetService <ModelService>().ModelChanged += new EventHandler <ModelChangedEventArgs>(ModelChanged);
}
private static void AttachUpdatableArgumentType(
ModelItem modelItem, AttachedPropertiesService attachedPropertiesService, Int32 argumentIndex, Int32 argumentCount)
{
String propertyName = "ArgumentType";
if (argumentCount > 1)
{
propertyName += argumentIndex + 1;
}
AttachedProperty <Type> attachedProperty = new AttachedProperty <Type>
{
Name = propertyName,
OwnerType = modelItem.ItemType,
IsBrowsable = true
};
attachedProperty.Getter = (ModelItem arg) => GetTypeArgument(arg, argumentIndex);
attachedProperty.Setter = (ModelItem arg, Type newType) => UpdateTypeArgument(arg, argumentIndex, newType);
attachedPropertiesService.AddProperty(attachedProperty);
}
public sealed override void Initialize(EditingContext context, Type modelType)
{
this.modelType = modelType;
context.Services.Subscribe <ViewStateService>(delegate(ViewStateService viewStateService)
{
this.viewStateService = viewStateService;
viewStateService.ViewStateChanged += this.OnViewStateChanged;
if (this.attachedPropertiesService != null)
{
RegisterAttachedProperties();
}
});
context.Services.Subscribe <AttachedPropertiesService>(delegate(AttachedPropertiesService attachedPropertiesService)
{
this.attachedPropertiesService = attachedPropertiesService;
if (this.viewStateService != null)
{
RegisterAttachedProperties();
}
});
}
void AttachDisplayName()
{
AttachedPropertiesService attachedPropertiesService = this.Context.Services.GetService <AttachedPropertiesService>();
Fx.Assert(attachedPropertiesService != null, "AttachedPropertiesService is not available.");
Type modelItemType = this.ModelItem.ItemType;
foreach (AttachedProperty property in attachedPropertiesService.GetAttachedProperties(modelItemType))
{
if (property.Name == "DisplayName" && property.OwnerType == modelItemType)
{
return;
}
}
AttachedProperty <string> displayNameProperty = new AttachedProperty <string>
{
Name = "DisplayName",
OwnerType = modelItemType,
Getter = (modelItem) => { return("Case"); }
};
attachedPropertiesService.AddProperty(displayNameProperty);
}
public WorkflowDesigner()
{
// create our perf trace provider first
this.perfEventProvider = new DesignerPerfEventProvider();
this.idManager = new ViewStateIdManager();
this.context = new EditingContext();
this.ModelSearchService = new ModelSearchServiceImpl(this);
this.context.Items.SetValue(new ReadOnlyState {
IsReadOnly = false
});
this.view = new Grid();
this.view.Focusable = false;
//add the resource dictionary to application resource so every component could reference it
if (Application.Current == null)
{
//create an application if it doesn't exist, make sure it will not shutdown after windows being shut down
Application app = new Application();
app.ShutdownMode = ShutdownMode.OnExplicitShutdown;
}
Fx.Assert(Application.Current != null, "Application and resources must be there");
Application.Current.Resources.MergedDictionaries.Add(WorkflowDesignerColors.FontAndColorResources);
Application.Current.Resources.MergedDictionaries.Add(WorkflowDesignerIcons.IconResourceDictionary);
AttachedPropertiesService propertiesService = new AttachedPropertiesService();
this.context.Services.Publish(typeof(AttachedPropertiesService), propertiesService);
undoEngine = new UndoEngine(context);
this.context.Services.Publish(typeof(UndoEngine), undoEngine);
undoEngine.UndoCompleted += new EventHandler <UndoUnitEventArgs>(OnUndoCompleted);
this.context.Services.Publish <ValidationService>(this.ValidationService);
this.context.Services.Publish <ObjectReferenceService>(this.ObjectReferenceService);
this.context.Services.Publish <DesignerPerfEventProvider>(this.perfEventProvider);
this.context.Services.Publish <FeatureManager>(new FeatureManager(this.context));
this.context.Services.Publish <DesignerConfigurationService>(new DesignerConfigurationService());
if (!LocalAppContextSwitches.UseLegacyAccessibilityFeatures)
{
// Keeps track of a dictionary of session objects on current Workflow Designer.
// The initial purpose is to pass the focused VisualBasicEditor from NetFx to VS.
this.context.Services.Publish <Dictionary <string, object> >(new Dictionary <string, object>());
}
this.context.Services.Subscribe <ICommandService>((s) =>
{
const string addinTypeName = "Microsoft.VisualStudio.Activities.AddIn.WorkflowDesignerAddIn";
if (s != null && s.GetType().FullName.Equals(addinTypeName))
{
DesignerConfigurationService service = this.context.Services.GetService <DesignerConfigurationService>();
if (service != null)
{
service.WorkflowDesignerHostId = WorkflowDesignerHostId.Dev10;
}
}
});
this.context.Services.Subscribe <IVSSqmService>((service) =>
{
const string serviceTypeName = "Microsoft.VisualStudio.Activities.AddIn.VSSqmService";
if (service != null && service.GetType().FullName.Equals(serviceTypeName))
{
DesignerConfigurationService configurationService = this.context.Services.GetService <DesignerConfigurationService>();
if (configurationService != null)
{
configurationService.WorkflowDesignerHostId = WorkflowDesignerHostId.Dev11;
}
}
});
this.Context.Items.Subscribe <ErrorItem>(delegate(ErrorItem errorItem)
{
ErrorView errorView = new ErrorView();
errorView.Message = errorItem.Message;
errorView.Details = errorItem.Details;
errorView.Context = this.Context;
// Clear views
this.view.Children.Clear();
this.view.Children.Add(errorView);
if (this.outlineView != null)
{
this.outlineView.Children.Clear();
}
}
);
this.context.Items.Subscribe <ReadOnlyState>(new SubscribeContextCallback <ReadOnlyState>(OnReadonlyStateChanged));
this.context.Services.Subscribe <IXamlLoadErrorService>(s => this.xamlLoadErrorService = s);
this.PreviewLoad += NamespaceSettingsHandler.PreviewLoadRoot;
this.view.Loaded += (s, e) =>
{
//when view is loaded, check if user did provide his own WindowHelperService - if not, provide a default one
if (!this.context.Services.Contains <WindowHelperService>())
{
IntPtr hWND = IntPtr.Zero;
Window ownerWindow = Window.GetWindow(this.view);
if (null != ownerWindow)
{
WindowInteropHelper helper = new WindowInteropHelper(ownerWindow);
hWND = helper.Handle;
}
this.Context.Services.Publish <WindowHelperService>(new WindowHelperService(hWND));
}
WindowHelperService whs = this.context.Services.GetService <WindowHelperService>();
whs.View = this.view;
//check if workflow command extension item is available - if not, provide default one
if (!this.context.Items.Contains <WorkflowCommandExtensionItem>())
{
WorkflowCommandExtensionItem item = new WorkflowCommandExtensionItem(new DefaultCommandExtensionCallback());
this.context.Items.SetValue(item);
}
ComponentDispatcher.EnterThreadModal += new EventHandler(ComponentDispatcher_EnterThreadModal);
ComponentDispatcher.LeaveThreadModal += new EventHandler(ComponentDispatcher_LeaveThreadModal);
};
this.view.Unloaded += (s, e) =>
{
ComponentDispatcher.EnterThreadModal -= new EventHandler(ComponentDispatcher_EnterThreadModal);
ComponentDispatcher.LeaveThreadModal -= new EventHandler(ComponentDispatcher_LeaveThreadModal);
};
this.view.IsKeyboardFocusWithinChanged += (s, e) =>
{
// The ModelTreeManager is null when there is an active ErrorItem.
// We have nothing to write to text in this case.
if (this.modelTreeManager != null && (bool)e.NewValue == false)
{
if ((FocusManager.GetFocusedElement(this.view) as TextBox) != null)
{
FocusManager.SetFocusedElement(this.view, null);
this.NotifyModelChanged();
}
}
};
}
