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 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();
}
private IExpressionEditorInstance CreateEditor(ImportedNamespaceContextItem importedNamespaces, List <ModelItem> Variables, string text, Type expressionType, Size initialSize)
{
var namespaces = importedNamespaces.ImportedNamespaces;
if (namespaces == null)
{
namespaces = new System.Collections.ObjectModel.Collection <string>();
}
if (!namespaces.Contains("System.Collections"))
{
namespaces.Add("System.Collections");
}
if (!namespaces.Contains("System.Collections.Generic"))
{
namespaces.Add("System.Collections.Generic");
}
var variables = new Dictionary <string, Type>();
foreach (var variableModel in Variables)
{
var variable = variableModel.GetCurrentValue() as System.Activities.LocationReference;
variables.Add(variable.Name, variable.Type);
}
EditorInstance instance = new EditorInstance
{
Text = text,
expressionType = expressionType,
designer = designer,
Variables = variables,
Namespaces = namespaces.ToArray()
};
return(instance);
}
private IExpressionEditorInstance CreateEditor(ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text)
{
ExpressionNode data = AutoCompletionData;
data = AddVariablesToAutoCompletionList(data, variables);
data = AddNamespacesToAutoCompletionList(data, importedNamespaces);
EditorInstance instance = new EditorInstance
{
AutoCompletionList = data,
LanguageKeywords = LanguageKeywords,
Text = text
};
return(instance);
}
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 void UpdateInstance(List <ModelItem> variables, string text, ImportedNamespaceContextItem importedNamespaces)
{
textEditor.Text = text;
try
{
variableDeclarations = variables.Select(v =>
{
var c = v.GetCurrentValue() as System.Activities.Variable;
//此处c可能为NULL
return(c?.Name);
}).ToList();
}
catch (Exception err)
{
Logger.Debug(err, logger);
variableDeclarations = new List <string>();
}
this.ImportedNamespaces = importedNamespaces.ImportedNamespaces;
}
/// <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()));
}
/// <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);
}
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;
}
}
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);
}
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);
}
public void UpdateContext(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces)
{
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Type expressionType)
{
return(CreateEditor(importedNamespaces, variables, text, expressionType, Size.Empty));
}
/// <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 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)
{
var instance = new ExpressionEditorInstance();
return(instance);
}
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));
}
public IExpressionEditorInstance CreateExpressionEditor(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces, List <ModelItem> variables, string text, Size initialSize)
{
return(CreateEditor(importedNamespaces, variables, text, null, initialSize));
}
public void UpdateContext(AssemblyContextControlItem assemblies, ImportedNamespaceContextItem importedNamespaces)
{
// throw new NotImplementedException();
}
private ExpressionNode AddNamespacesToAutoCompletionList(ExpressionNode data, ImportedNamespaceContextItem importedNamespaces)
{
foreach (var ns in importedNamespaces.ImportedNamespaces)
{
var foundNodes = ExpressionNode.SearchForNode(data, ns, true, true);
foreach (var node in foundNodes.Nodes)
{
data.Add(node);
}
}
return(data);
}
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);
}
