public void UpdateContext(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces)
{
var references = new List <MetadataReference>();
foreach (var assembly in assemblies.AllAssemblyNamesInContext)
{
System.Reflection.Assembly asm = null;
try
{
asm = System.Reflection.Assembly.Load(assembly);
}
catch (Exception)
{
//Console.WriteLine(ex.ToString());
}
if (asm != null)
{
if (File.Exists(asm.Location))
{
references.Add(MetadataReference.CreateFromFile(asm.Location));
}
}
}
baseAssemblies = references.ToArray();
usingNamespaces = string.Join("", importedNamespaces.ImportedNamespaces.Select(ns => "using " + ns + ";\n").ToArray());
}
void LoadNameSpace(List <NamespaceDeclaration> result)
{
if (null == this.context)
{
//Fx.Assert("EditingContext is null");
return;
}
AssemblyContextControlItem assemblyContext = this.context.Items.GetValue <AssemblyContextControlItem>();
if (null == assemblyContext)
{
//Fx.Assert("AssemblyContextControlItem not defined in EditingContext.Items");
return;
}
if (null != assemblyContext.LocalAssemblyName)
{
result.Add(GetEntry(assemblyContext.LocalAssemblyName));
}
if (null != assemblyContext.ReferencedAssemblyNames)
{
foreach (AssemblyName name in assemblyContext.ReferencedAssemblyNames)
{
result.Add(GetEntry(name));
}
}
}
//When assemblyContextItem is null, it means the assembly cannot be local assembly
IEnumerable <string> GetUniqueNamespacesInAssembly(Assembly assembly, AssemblyContextControlItem assemblyContextItem)
{
IEnumerable <Type> types = null;
//we should only display namespaces for public types except the local assembly
if ((assemblyContextItem != null) && (assemblyContextItem.LocalAssemblyName != null) && (assembly.FullName == assemblyContextItem.LocalAssemblyName.FullName))
{
types = assembly.GetTypes();
}
else
{
types = assembly.GetExportedTypes();
}
HashSet <string> namespaces = new HashSet <string>();
if (types != null)
{
foreach (Type type in types)
{
string ns = type.Namespace;
if (!namespaces.Contains(ns))
{
namespaces.Add(ns);
}
}
}
return(namespaces);
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Type expressionType, Size initialSize)
{
UpdateContext(assemblies, importedNamespaces);
var editor = new RoslynExpressionEditorInstance(initialSize);
editor.UpdateInstance(variables, text);
return(editor);
}
void GetAvailableNamespaces()
{
Fx.Assert(this.availableNamespaces != null, "available namespace table should have been set before calling this method");
AssemblyContextControlItem assemblyItem = this.Context.Items.GetValue <AssemblyContextControlItem>();
if (assemblyItem != null)
{
IMultiTargetingSupportService multiTargetingService = this.Context.Services.GetService <IMultiTargetingSupportService>();
////When ReferencedAssemblyNames is null, it's in rehost scenario. And we need to preload assemblies in
////TextExpression.ReferencesForImplementation/References if there is any. So that these assemblies will be returned
////by AssemblyContextControlItem.GetEnvironmentAssemblies and user can see namespaces defined in these assemlbies
////in the dropdown list of Import Designer.
if ((assemblyItem.ReferencedAssemblyNames == null) && (this.targetFramework.Is45OrHigher()))
{
ModelTreeManager modelTreeManager = this.Context.Services.GetService <ModelTreeManager>();
object root = modelTreeManager.Root.GetCurrentValue();
IList <AssemblyReference> references;
NamespaceHelper.GetTextExpressionNamespaces(root, out references);
foreach (AssemblyReference reference in references)
{
reference.LoadAssembly();
}
}
IEnumerable <Assembly> allAssemblies = assemblyItem.GetEnvironmentAssemblies(multiTargetingService);
if (assemblyItem.LocalAssemblyName != null)
{
allAssemblies = allAssemblies.Union <Assembly>(new Collection <Assembly> {
AssemblyContextControlItem.GetAssembly(assemblyItem.LocalAssemblyName, multiTargetingService)
});
}
foreach (Assembly assembly in allAssemblies)
{
try
{
if (assembly != null)
{
Fx.Assert(!assembly.IsDynamic, "there should not be any dynamic assemblies in reference list");
this.UpdateAvailableNamespaces(assembly, assemblyItem);
}
}
catch (ReflectionTypeLoadException)
{
}
catch (FileNotFoundException)
{
}
}
if (assemblyItem.LocalAssemblyName == null)
{
AppDomain.CurrentDomain.AssemblyLoad += this.proxy.OnAssemblyLoad;
}
}
}
/// <summary>
/// Creates an expression editor instance.
/// </summary>
/// <param name="assemblies">The accessible assemblies.</param>
/// <param name="importedNamespaces">The imported namespaces.</param>
/// <param name="variables">The variable list.</param>
/// <param name="text">The text.</param>
/// <returns>The <see cref="IExpressionEditorInstance"/> that was created.</returns>
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text)
{
var editor = new MyExpressionEditorInstance(designer, variables, language);
editor.Text = text;
editor.LostAggregateFocus += OnEditorLostFocus;
editors.Add(editor);
return(editor);
}
public static void SelectionChanged(AssemblyContextControlItem assemblyContext)
{
var nameSpace = assemblyContext.AllAssemblyNamesInContext;
while (nameSpace != null)
{
var name = string.Join(";", nameSpace);
}
}
private void UpdateExpressionEditors()
{
AssemblyContextControlItem assemblies = this.Context.Items.GetValue <AssemblyContextControlItem>();
IExpressionEditorService expressionEditorService = this.Context.Services.GetService <IExpressionEditorService>();
if (expressionEditorService != null)
{
expressionEditorService.UpdateContext(assemblies, this.importedNamespacesItem);
}
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Type expressionType, Size initialSize)
{
UpdateContext(assemblies, importedNamespaces);
var editor = new RoslynExpressionEditorInstance(initialSize);
editor.UpdateInstance(variables, text, importedNamespaces);
//生成命名空间树
editor.m_namespaceNodeRoot = AddNamespacesToAutoCompletionList(EditorUtil.autoCompletionTree, importedNamespaces);
return(editor);
}
internal void OnReferenceUpdated(AssemblyName updatedReference, bool isAdded)
{
if (this.availableNamespaces != null)
{
IMultiTargetingSupportService multiTargetingService = this.Context.Services.GetService <IMultiTargetingSupportService>();
Assembly assembly = AssemblyContextControlItem.GetAssembly(updatedReference, multiTargetingService);
Fx.Assert(assembly != null, "Assembly shouldn't be null here.");
// In normal case, assembly shouldn't be null. In case there's any situation we're overlooked, we should ignore instead of throwing exceptions.
if (assembly != null)
{
OnReferenceUpdated(assembly, isAdded);
}
}
}
private IExpressionEditorInstance CreateExpressionEditorPrivate(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, System.Collections.Generic.List <ModelItem> variables, string text, System.Type expressionType, System.Windows.Size initialSize)
{
EditorInstance editor = new EditorInstance
{
IntellisenseList = this.CreateUpdatedIntellisense(variables),
HighlightWords = this.EditorKeyWord,
ExpressionType = expressionType,
Guid = Guid.NewGuid(),
Text = text,
};
editor.LostAggregateFocus += LostFocus;
editorInstances.Add(editor.Guid.ToString(), editor);
return(editor);
}
/// <summary>
/// Creates a new expression editor using the specified assemblies, imported namespaces, variables, expression text, expression type, and the initial size.
/// </summary>
/// <returns>
/// A new instance of the <see cref="T:System.Activities.Presentation.View.IExpressionEditorInstance"/>.
/// </returns>
/// <param name="assemblies">The local and referenced assemblies in the environment.</param><param name="importedNamespaces">The imported namespaces used by the expression editor.</param><param name="variables">Local variables for the expression editor.</param><param name="text">A string used to populate the expression editor.</param><param name="expressionType">The type of the expression.</param><param name="initialSize">The initial height and width of the expression editor control.</param>
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Type expressionType, Size initialSize)
{
var instance = new EditorInstance
{
IntellisenseData = this.CreateUpdatedIntellisense(variables),
ImportedNamespaces = importedNamespaces.ImportedNamespaces.ToList(),
HighlightWords = vbKeywords,
ExpressionType = expressionType,
Guid = Guid.NewGuid(),
Text = text
};
instance.LostAggregateFocus += this.LostFocus;
this._editorInstances.Add(instance.Guid.ToString(), instance);
return(instance);
}
/// <summary>
/// Launch the user interface for developer to pick a contract type.
/// </summary>
/// <param name="localAssemblyName">The local assembly name.</param>
/// <param name="referencedAssemblies">The list of referenced assembly names.</param>
/// <param name="editingContext">The editing context.</param>
/// <returns>The contract type selected by user or null if user cancels.</returns>
public static Type SelectContractType(AssemblyName localAssemblyName, IList <AssemblyName> referencedAssemblies, EditingContext editingContext)
{
AssemblyContextControlItem assemblyContextControlItem = new AssemblyContextControlItem {
LocalAssemblyName = localAssemblyName, ReferencedAssemblyNames = referencedAssemblies
};
TypeBrowser typeBrowser = new TypeBrowser(assemblyContextControlItem, editingContext, FilterFunction);
bool? dialogResult = typeBrowser.ShowDialog(/* owner = */ null);
if (dialogResult.HasValue && dialogResult.Value)
{
return(typeBrowser.ConcreteType);
}
else
{
return(null);
}
}
public void UpdateContext(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces)
{
var references = new List <MetadataReference>();
foreach (var assembly in assemblies.AllAssemblyNamesInContext)
{
try
{
references.Add(MetadataReference.CreateFromFile(System.Reflection.Assembly.Load(assembly).Location));
}
catch { }
}
baseAssemblies = references.ToArray();
usingNamespaces = string.Join("", importedNamespaces.ImportedNamespaces.Select(ns => "using " + ns + ";\n").ToArray());
}
private IExpressionEditorInstance CreateExpressionEditorPrivate(AssemblyContextControlItem assemblies,
ImportedNamespaceContextItem importedNamespaces, IEnumerable <ModelItem> variables
, string text, System.Type expressionType, Size?initialSize)
{
var editor = new EditorInstance()
{
IntellisenceList = this.CreateUpdatedIntellisense(variables),
HighlightWords = this.EditorKeyWord,
ExpressionType = expressionType,
Guid = Guid.NewGuid(),
Text = text ?? ""
};
editor.LostAggregateFocus += LostFocus;
editorInstances.Add(editor.Guid.ToString(), editor);
return(editor);
}
public TypeBrowser(AssemblyContextControlItem assemblyContext, EditingContext context, Func <Type, bool> filter)
{
this.assemblyContext = assemblyContext;
this.Context = context;
this.filter = filter;
SetValue(GenericTypeMappingProperty, new ObservableCollection <TypeKeyValue>());
GenericTypeMapping.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(GenericTypeMappingCollectionChanged);
InitializeComponent();
this.typeEntryTextBox.Focus();
if (!size.IsEmpty)
{
this.Height = size.Height;
this.Width = size.Width;
}
this.SizeChanged += new SizeChangedEventHandler(TypeBrowser_SizeChanged);
this.HelpKeyword = HelpKeywords.TypeBrowser;
this.perfEventProvider = new DesignerPerfEventProvider();
}
//When assemblyContextItem is null, it means the assembly cannot be local assembly
private void UpdateAvailableNamespaces(Assembly assembly, AssemblyContextControlItem assemblyContextItem)
{
string assemblyName = assembly.GetName().Name;
IEnumerable <string> namespaces = this.GetUniqueNamespacesInAssembly(assembly, assemblyContextItem);
foreach (string ns in namespaces)
{
if (!string.IsNullOrEmpty(ns))
{
List <string> assemblyList;
if (!this.availableNamespaces.TryGetValue(ns, out assemblyList))
{
assemblyList = new List <string> {
assemblyName
};
this.availableNamespaces.Add(ns, assemblyList);
}
else if (!assemblyList.Contains(assemblyName))
{
assemblyList.Add(assemblyName);
}
}
}
}
private void AddDynamicAssembly(Assembly asm)
{
AssemblyContextControlItem acci = (AssemblyContextControlItem)(_WorkflowDesigner.Context.Items.GetValue(typeof(AssemblyContextControlItem)));
var root = GetRootElement();
var fullname = asm.FullName;
if (null == root)
{
return;
}
VisualBasicSettings vbs = VisualBasic.GetSettings(root) ?? new VisualBasicSettings();
var namespaces = (from type in asm.GetTypes() select type.Namespace).Distinct();
foreach (var name in namespaces)
{
var import = new VisualBasicImportReference()
{
Assembly = fullname, Import = name
};
vbs.ImportReferences.Add(import);
}
VisualBasic.SetSettings(root, vbs);
}
private void OnEditorLoaded(object sender, RoutedEventArgs e)
{
if (!IsEditorLoaded)
{
// If the service exists, create an expression editor and add it to the grid - else switch to the textbox data template
if (ExpressionEditorService1 != null)
{
Border border = (Border)sender;
// Get the references and variables in scope
AssemblyContextControlItem assemblies = (AssemblyContextControlItem)Context.Items.GetValue(typeof(AssemblyContextControlItem));
List <ModelItem> declaredVariables = CSharpExpressionHelper.GetVariablesInScope(OwnerActivity);
ImportedNamespaceContextItem importedNamespaces = Context.Items.GetValue <ImportedNamespaceContextItem>();
importedNamespaces.EnsureInitialized(Context);
//if the expression text is empty and the expression type is set, then we initialize the text to prompt text
if (string.Equals(Text, string.Empty, StringComparison.OrdinalIgnoreCase) && ExpressionType != null)
{
Text = TypeToPromptTextConverter.GetPromptText(ExpressionType);
}
//this is a hack
BlockWidth = Math.Max(ActualWidth - 8, 0); //8 is the margin
if (HasErrors)
{
BlockWidth = Math.Max(BlockWidth - 16, 0); //give 16 for error icon
}
try
{
if (ExpressionType != null)
{
ExpressionEditorInstance = ExpressionEditorService1.CreateExpressionEditor(assemblies, importedNamespaces, declaredVariables, Text, ExpressionType, new Size(BlockWidth, BlockHeight));
}
else
{
ExpressionEditorInstance = ExpressionEditorService1.CreateExpressionEditor(assemblies, importedNamespaces, declaredVariables, Text, new Size(BlockWidth, BlockHeight));
}
}
catch (Exception ex)
{
throw ex;
}
if (ExpressionEditorInstance != null)
{
try
{
ExpressionEditorInstance.VerticalScrollBarVisibility = VerticalScrollBarVisibility;
ExpressionEditorInstance.HorizontalScrollBarVisibility = HorizontalScrollBarVisibility;
ExpressionEditorInstance.AcceptsReturn = AcceptsReturn;
ExpressionEditorInstance.AcceptsTab = AcceptsTab;
// Add the expression editor to the text panel, at column 1
HostControl = ExpressionEditorInstance.HostControl;
// Subscribe to this event to change scrollbar visibility on the fly for auto, and to resize the hostable editor
// as necessary
ExpressionEditorInstance.LostAggregateFocus += new EventHandler(OnEditorLostAggregateFocus);
ExpressionEditorInstance.Closing += new EventHandler(OnEditorClosing);
// Set up Hostable Editor properties
ExpressionEditorInstance.MinLines = MinLines;
ExpressionEditorInstance.MaxLines = MaxLines;
ExpressionEditorInstance.HostControl.Style = (Style)FindResource("editorStyle");
border.Child = HostControl;
ExpressionEditorInstance.Focus();
}
catch (KeyNotFoundException ex)
{
new ApplicationException("Unable to find editor with the following editor name: " + EditorName);
}
}
}
IsEditorLoaded = true;
}
}
internal static void ConvertToVBSettings(IList <string> importedNamespaces, IList <AssemblyReference> references, EditingContext context, out VisualBasicSettings settings)
{
Dictionary <string, List <string> > visualBasicImports = new Dictionary <string, List <string> >();
foreach (string importedNamespace in importedNamespaces)
{
visualBasicImports.Add(importedNamespace, new List <string>());
}
Collection <Assembly> assemblies = new Collection <Assembly>();
IMultiTargetingSupportService multiTargetingService = context.Services.GetService <IMultiTargetingSupportService>();
foreach (AssemblyReference reference in references)
{
Assembly assembly;
if (multiTargetingService == null)
{
reference.LoadAssembly();
assembly = reference.Assembly;
}
else
{
assembly = AssemblyContextControlItem.GetAssembly(reference.AssemblyName, multiTargetingService);
}
if (assembly != null)
{
assemblies.Add(assembly);
}
}
AssemblyContextControlItem assemblyContextItem = context.Items.GetValue <AssemblyContextControlItem>();
AssemblyName localAssembly = null;
if (assemblyContextItem != null)
{
localAssembly = assemblyContextItem.LocalAssemblyName;
}
if (localAssembly != null)
{
Assembly assembly = AssemblyContextControlItem.GetAssembly(localAssembly, multiTargetingService);
if (assembly != null)
{
assemblies.Add(assembly);
}
}
foreach (Assembly assembly in assemblies)
{
foreach (Type type in assembly.GetTypes())
{
string ns = type.Namespace;
if ((ns != null) && visualBasicImports.ContainsKey(ns))
{
string assemblyName = assembly.GetName().Name;
visualBasicImports[ns].Add(assemblyName);
}
}
}
settings = new VisualBasicSettings();
foreach (KeyValuePair <string, List <string> > entries in visualBasicImports)
{
string importedNamespace = entries.Key;
foreach (string assemblyName in entries.Value)
{
settings.ImportReferences.Add(new VisualBasicImportReference
{
Import = importedNamespace,
Assembly = assemblyName
});
}
}
}
public void UpdateContext(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces)
{
// throw new NotImplementedException();
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Type expressionType, System.Windows.Size initialSize)
{
var instance = new ExpressionEditorInstance();
return(instance);
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Size initialSize)
{
return(CreateEditor(importedNamespaces, variables, text, null, initialSize));
}
/// <summary>
/// Creates a new expression editor.
/// </summary>
/// <returns>
/// Returns a<see cref="T:System.Activities.Presentation.View.IExpressionEditorInstance"/>.
/// </returns>
/// <param name="assemblies">Used to set the context for the editor session.</param><param name="importedNamespaces">The imported namespaces to be used by the expression editor.</param><param name="variables">Local variables for the expression editor.</param><param name="text">A string used to populate the expression editor.</param>
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text)
{
return(this.CreateExpressionEditor(assemblies, importedNamespaces, variables, text, null, new Size()));
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, System.Collections.Generic.List <ModelItem> variables, string text, System.Windows.Size initialSize)
{
return(CreateExpressionEditorPrivate(assemblies, importedNamespaces, variables, text, null, initialSize));
}
string GetLocalAssemblyName()
{
AssemblyContextControlItem assemblyItem = this.Context.Items.GetValue <AssemblyContextControlItem>();
return(assemblyItem != null && assemblyItem.LocalAssemblyName != null ? assemblyItem.LocalAssemblyName.Name : null);
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Type expressionType)
{
return(CreateEditor(importedNamespaces, variables, text, expressionType, Size.Empty));
}
protected override XamlType GetXamlType(string xamlNamespace, string name, params XamlType[] typeArguments)
{
if (!string.IsNullOrEmpty(this.localAssemblyNsPostfix) &&
IsClrNamespaceWithNoAssembly(xamlNamespace))
{
xamlNamespace = AddLocalAssembly(xamlNamespace);
}
var xamlType = base.GetXamlType(xamlNamespace, name, typeArguments);
if (xamlType == null && environmentAssembliesLoaded == false && editingContext != null)
{
// Failed to find the type, this might because the namespace is a custom namespace
// and the dependent assembly hasn't been loaded yet. Load all dependent assemblies
// and try to load the same xaml type again.
AssemblyContextControlItem assemblyItem = this.editingContext.Items.GetValue <AssemblyContextControlItem>();
var environmentAssemblies = assemblyItem.GetEnvironmentAssemblies(null);
if (assemblyItem.LocalAssemblyName != null)
{
AssemblyContextControlItem.GetAssembly(assemblyItem.LocalAssemblyName, null);
}
environmentAssembliesLoaded = true;
xamlType = base.GetXamlType(xamlNamespace, name, typeArguments);
}
if (xamlType == null || xamlType.UnderlyingType == null || this.editingContext == null)
{
return(xamlType);
}
MultiTargetingSupportService multiTargetingService = editingContext.Services.GetService <IMultiTargetingSupportService>() as MultiTargetingSupportService;
DesignerConfigurationService config = editingContext.Services.GetService <DesignerConfigurationService>();
if (multiTargetingService == null || config == null)
{
return(xamlType);
}
// do not filter out new types and new properties if targeting to current framework and it's a full SKU
if (config.TargetFrameworkName.Version == CurrentFramework.Version && config.TargetFrameworkName.IsFullProfile())
{
return(xamlType);
}
// Filter out new types and new properties
if (this.resolverCache == null)
{
this.resolverCache = new ResolverCache();
}
if (supportedTypes.Contains(xamlType.UnderlyingType))
{
return(xamlType);
}
// only check if conversion is needed when target framework is less than 4.5
if (config.TargetFrameworkName.Version < CurrentFramework.Version)
{
if (conversionRequiredTypes.Contains(xamlType.UnderlyingType))
{
this.ContainsConversionRequiredType = true;
return(xamlType);
}
}
ResolverResult resolverResult = this.resolverCache.Lookup(xamlType.UnderlyingType);
if (resolverResult == null)
{
resolverResult = MultiTargetingTypeResolver.Resolve(multiTargetingService, xamlType.UnderlyingType);
this.resolverCache.Update(xamlType.UnderlyingType, resolverResult);
}
return(MultiTargetingTypeResolver.GetXamlType(resolverResult, xamlType));
}
public void UpdateContext(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces)
{
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text)
{
var instance = new ExpressionEditorInstance();
return(instance);
}
