public override void LoadPanelContents()
{
SetupFromXmlResource("ProjectImports.xfrm");
InitializeHelper();
Get <Button>("addImport").Click += new EventHandler(addImportButton_Click);
Get <Button>("removeImport").Click += new EventHandler(removeImportButton_Click);
Get <ComboBox>("namespaces").TextChanged += new EventHandler(namespacesComboBox_TextCanged);
Get <ListBox>("imports").SelectedIndexChanged += new EventHandler(importsListBox_SelectedIndexChanged);
Get <ComboBox>("namespaces").Items.Clear();
Get <ComboBox>("namespaces").AutoCompleteSource = AutoCompleteSource.ListItems;
Get <ComboBox>("namespaces").AutoCompleteMode = AutoCompleteMode.Suggest;
foreach (ProjectItem item in project.Items)
{
if (item.ItemType == ItemType.Import)
{
Get <ListBox>("imports").Items.Add(item.Include);
}
}
IProjectContent projectContent = ParserService.GetProjectContent(project);
foreach (IProjectContent refProjectContent in projectContent.ThreadSafeGetReferencedContents())
{
AddNamespaces(refProjectContent);
}
AddNamespaces(projectContent);
namespacesComboBox_TextCanged(null, EventArgs.Empty);
importsListBox_SelectedIndexChanged(null, EventArgs.Empty);
}
/// <summary>
/// Loads the assembly represented by the project content. Returns null on failure.
/// </summary>
public Assembly LoadAssembly(IProjectContent pc)
{
WorkbenchSingleton.AssertMainThread();
// prevent StackOverflow when project contents have cyclic dependencies
// Very popular example of cyclic dependency: System <-> System.Xml
if (!projectContentsCurrentlyLoadingAssembly.Add(pc))
{
return(null);
}
Assembly sdAssembly;
if (IsSharpDevelopAssembly(pc, out sdAssembly))
{
return(sdAssembly);
}
try {
// load dependencies of current assembly
foreach (IProjectContent rpc in pc.ThreadSafeGetReferencedContents())
{
if (rpc is ParseProjectContent)
{
LoadAssembly(rpc);
}
else if (rpc is ReflectionProjectContent)
{
ReflectionProjectContent rrpc = (ReflectionProjectContent)rpc;
if (!rrpc.IsGacAssembly)
{
LoadAssembly(rpc);
}
}
}
} finally {
projectContentsCurrentlyLoadingAssembly.Remove(pc);
}
if (pc.Project != null)
{
return(LoadAssembly(((IProject)pc.Project).OutputAssemblyFullPath));
}
else if (pc is ReflectionProjectContent)
{
ReflectionProjectContent rpc = (ReflectionProjectContent)pc;
if (rpc.IsGacAssembly)
{
return(LoadAssembly(new AssemblyName(rpc.AssemblyFullName), false));
}
else
{
return(LoadAssembly(rpc.AssemblyLocation));
}
}
else
{
return(null);
}
}
Assembly FindAssemblyInProjectReferences(IProjectContent pc, string name)
{
foreach (IProjectContent referencedProjectContent in pc.ThreadSafeGetReferencedContents()) {
if (name == referencedProjectContent.AssemblyName) {
return this.typeResolutionService.LoadAssembly(referencedProjectContent);
}
}
return null;
}
public string Search(UnknownIdentifierResolveResult rr, IProjectContent pc, List <IClass> results)
{
SearchAttributesWithName(results, pc, rr.Identifier);
foreach (IProjectContent content in pc.ThreadSafeGetReferencedContents())
{
SearchAttributesWithName(results, content, rr.Identifier);
}
return(rr.Identifier);
}
public bool PartialNamespaceExistsInProjectReferences(string name)
{
foreach (IProjectContent referencedContent in projectContent.ThreadSafeGetReferencedContents())
{
if (PartialNamespaceExists(referencedContent, name))
{
return(true);
}
}
return(false);
}
Assembly FindAssemblyInProjectReferences(IProjectContent pc, string name)
{
foreach (IProjectContent referencedProjectContent in pc.ThreadSafeGetReferencedContents())
{
if (name == referencedProjectContent.AssemblyName)
{
return(this.typeResolutionService.LoadAssembly(referencedProjectContent));
}
}
return(null);
}
public static IReturnType FindType(IProjectContent pc, string xmlNamespace, string className)
{
if (pc == null)
throw new ArgumentNullException("pc");
if (xmlNamespace == null || className == null)
return null;
if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase)) {
return CreateClrNamespaceType(pc, xmlNamespace, className);
}
else {
IReturnType type = FindTypeInAssembly(pc, xmlNamespace, className);
if (type != null)
return type;
foreach (IProjectContent p in pc.ThreadSafeGetReferencedContents()) {
type = FindTypeInAssembly(p, xmlNamespace, className);
if (type != null)
return type;
}
return null;
}
}
protected override void Initialize()
{
ProjectItems = new ObservableCollection <string>();
NameSpaceItems = new ObservableCollection <string> ();
foreach (ProjectItem item in base.Project.Items)
{
if (item.ItemType == ItemType.Import)
{
ProjectItems.Add(item.Include);
}
}
IProjectContent projectContent = ParserService.GetProjectContent(base.Project);
foreach (IProjectContent refProjectContent in projectContent.ThreadSafeGetReferencedContents())
{
AddNamespaces(refProjectContent);
}
AddNamespaces(projectContent);
}
IEnumerable <IContextAction> GetAddUsingExtensionMethodActions(EditorContext context)
{
UnknownMethodResolveResult rr = context.CurrentSymbol as UnknownMethodResolveResult;
if (rr == null)
{
yield break;
}
List <IClass> results = new List <IClass>();
IProjectContent pc = context.ProjectContent;
SearchAllExtensionMethodsWithName(results, pc, rr.CallName);
foreach (IProjectContent content in pc.ThreadSafeGetReferencedContents())
{
SearchAllExtensionMethodsWithName(results, content, rr.CallName);
}
foreach (IClass c in results)
{
yield return(new RefactoringService.AddUsingAction(context.CurrentParseInformation.CompilationUnit, context.Editor, c.Namespace));
}
}
public MenuItem Create(RefactoringMenuContext context)
{
// TODO : [Test] above method is in Default context?
// if (context.ExpressionResult.Context != ExpressionContext.Attribute)
// return null;
if (!(context.ResolveResult is UnknownIdentifierResolveResult || context.ResolveResult is UnknownMethodResolveResult))
{
return(null);
}
List <IClass> results = new List <IClass>();
ParseInformation info = ParserService.GetParseInformation(context.Editor.FileName);
if (info == null || info.CompilationUnit == null || info.CompilationUnit.ProjectContent == null)
{
return(null);
}
ICompilationUnit unit = info.CompilationUnit;
IProjectContent pc = info.CompilationUnit.ProjectContent;
string name = null;
if (context.ResolveResult is UnknownMethodResolveResult)
{
var rr = context.ResolveResult as UnknownMethodResolveResult;
SearchAttributesWithName(results, pc, rr.CallName);
foreach (IProjectContent content in pc.ThreadSafeGetReferencedContents())
{
SearchAttributesWithName(results, content, rr.CallName);
}
name = rr.CallName;
}
if (context.ResolveResult is UnknownIdentifierResolveResult)
{
var rr = context.ResolveResult as UnknownIdentifierResolveResult;
SearchAttributesWithName(results, pc, rr.Identifier);
foreach (IProjectContent content in pc.ThreadSafeGetReferencedContents())
{
SearchAttributesWithName(results, content, rr.Identifier);
}
name = rr.Identifier;
}
if (!results.Any())
{
return(null);
}
MenuItem item = new MenuItem()
{
Header = string.Format(StringParser.Parse("${res:AddIns.SharpRefactoring.ResolveAttribute}"), name),
Icon = ClassBrowserIconService.GotoArrow.CreateImage()
};
foreach (IClass c in results)
{
string newNamespace = c.Namespace;
MenuItem subItem = new MenuItem();
subItem.Header = "using " + newNamespace;
subItem.Icon = ClassBrowserIconService.Namespace.CreateImage();
item.Items.Add(subItem);
subItem.Click += delegate {
NamespaceRefactoringService.AddUsingDeclaration(unit, context.Editor.Document, newNamespace, true);
ParserService.BeginParse(context.Editor.FileName, context.Editor.Document);
};
}
return(item);
}
public static IEnumerable<IClass> GetNamespaceMembers(IProjectContent pc, string xmlNamespace)
{
if (pc == null)
throw new ArgumentNullException("pc");
if (!string.IsNullOrEmpty(xmlNamespace)) {
if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase))
return pc.GetNamespaceContents(GetNamespaceNameFromClrNamespace(xmlNamespace)).OfType<IClass>();
else {
var list = new List<ICompletionEntry>();
AddNamespaceMembersInAssembly(pc, xmlNamespace, list);
foreach (IProjectContent p in pc.ThreadSafeGetReferencedContents()) {
AddNamespaceMembersInAssembly(p, xmlNamespace, list);
}
return list.OfType<IClass>();
}
}
return Enumerable.Empty<IClass>();
}
/// <summary>
/// Loads the assembly represented by the project content. Returns null on failure.
/// </summary>
public Assembly LoadAssembly(IProjectContent pc)
{
WorkbenchSingleton.AssertMainThread();
// prevent StackOverflow when project contents have cyclic dependencies
// Very popular example of cyclic dependency: System <-> System.Xml
if (!projectContentsCurrentlyLoadingAssembly.Add(pc))
return null;
Assembly sdAssembly;
if (IsSharpDevelopAssembly(pc, out sdAssembly))
return sdAssembly;
try {
// load dependencies of current assembly
foreach (IProjectContent rpc in pc.ThreadSafeGetReferencedContents()) {
if (rpc is ParseProjectContent) {
LoadAssembly(rpc);
} else if (rpc is ReflectionProjectContent) {
ReflectionProjectContent rrpc = (ReflectionProjectContent)rpc;
if (!rrpc.IsGacAssembly) {
LoadAssembly(rpc);
}
}
}
} finally {
projectContentsCurrentlyLoadingAssembly.Remove(pc);
}
if (pc.Project != null) {
return LoadAssembly(((IProject)pc.Project).OutputAssemblyFullPath);
} else if (pc is ReflectionProjectContent) {
ReflectionProjectContent rpc = (ReflectionProjectContent)pc;
if (rpc.IsGacAssembly)
return LoadAssembly(new AssemblyName(rpc.AssemblyFullName), false);
else
return LoadAssembly(rpc.AssemblyLocation);
} else {
return null;
}
}
public static IEnumerable<ICompletionItem> CreateListForXmlnsCompletion(IProjectContent projectContent)
{
List<XmlnsCompletionItem> list = new List<XmlnsCompletionItem>();
foreach (IProjectContent content in projectContent.ThreadSafeGetReferencedContents()) {
foreach (IAttribute att in content.GetAssemblyAttributes()) {
if (att.PositionalArguments.Count == 2
&& att.AttributeType.FullyQualifiedName == "System.Windows.Markup.XmlnsDefinitionAttribute") {
list.Add(new XmlnsCompletionItem(att.PositionalArguments[0] as string, true));
}
}
foreach (string @namespace in content.NamespaceNames) {
if (!string.IsNullOrEmpty(@namespace))
list.Add(new XmlnsCompletionItem(@namespace, content.AssemblyName));
}
}
foreach (string @namespace in projectContent.NamespaceNames) {
if (!string.IsNullOrEmpty(@namespace))
list.Add(new XmlnsCompletionItem(@namespace, false));
}
list.Add(new XmlnsCompletionItem(MarkupCompatibilityNamespace, true));
return list
.Distinct(new XmlnsEqualityComparer())
.OrderBy(item => item, new XmlnsComparer());
}
public string Search(UnknownIdentifierResolveResult rr, IProjectContent pc, List<IClass> results)
{
SearchAttributesWithName(results, pc, rr.Identifier);
foreach (IProjectContent content in pc.ThreadSafeGetReferencedContents())
SearchAttributesWithName(results, content, rr.Identifier);
return rr.Identifier;
}
