public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
IAssemblyModel assemblyModel = parameter as IAssemblyModel;
if (assemblyModel == null)
{
// Node is a project?
IProject project = parameter as IProject;
if (project != null)
{
assemblyModel = project.AssemblyModel;
}
}
if (assemblyModel == null)
{
// Node is an assembly reference?
IAssemblyReferenceModel assemblyReference = parameter as IAssemblyReferenceModel;
if (assemblyReference != null)
{
// Model is an assembly reference
IAssemblyParserService assemblyParserService = SD.GetRequiredService <IAssemblyParserService>();
IEntityModelContext entityModelContext = assemblyReference.ParentAssemblyModel.Context;
CombinedAssemblySearcher searcher = new CombinedAssemblySearcher();
if ((entityModelContext != null) && (entityModelContext.Project != null))
{
searcher.AddSearcher(new ProjectAssemblyReferenceSearcher(entityModelContext.Project));
}
searcher.AddSearcher(new DefaultAssemblySearcher(assemblyReference.ParentAssemblyModel.Location));
var resolvedFile = searcher.FindAssembly(assemblyReference.AssemblyName);
if (resolvedFile != null)
{
assemblyModel = assemblyParserService.GetAssemblyModelSafe(resolvedFile);
}
else
{
// Assembly file not resolvable
SD.MessageService.ShowWarningFormatted("Could not resolve reference '{0}'.", assemblyReference.AssemblyName.ShortName);
}
}
}
if (assemblyModel != null)
{
// Try to remove AssemblyModel from list of UnpinnedAssemblies
classBrowser.UnpinnedAssemblies.Assemblies.RemoveAll(a => a.FullAssemblyName == assemblyModel.FullAssemblyName);
if (!classBrowser.MainAssemblyList.Assemblies.Contains(assemblyModel))
{
classBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
// Bring the node into view
classBrowser.GotoAssemblyModel(assemblyModel);
}
}
}
public TextTemplatingAssemblyPathResolver(
IProject project,
IAssemblyParserService assemblyParserService,
ITextTemplatingPathResolver pathResolver)
{
this.project = project;
this.assemblyParserService = assemblyParserService;
this.pathResolver = pathResolver;
}
public TextTemplatingAssemblyPathResolver(
IProject project,
IAssemblyParserService assemblyParserService,
ITextTemplatingPathResolver pathResolver)
{
this.project = project;
this.assemblyParserService = assemblyParserService;
this.pathResolver = pathResolver;
}
public bool GoToEntity(IEntity entity)
{
// Try to find assembly in workspace
var entityAssembly = entity.ParentAssembly;
if (entityAssembly != null)
{
ITypeDefinition entityType = null;
if (entity is ITypeDefinition)
{
entityType = (ITypeDefinition)entity;
}
else
{
entityType = entity.DeclaringTypeDefinition;
}
SharpTreeNodeCollection namespaceChildren = null;
var root = this.Root as WorkspaceTreeNode;
// Try to find assembly of passed entity among open projects in solution
var solutionTreeNode = this.Root.Children.OfType <SolutionTreeNode>().FirstOrDefault();
if (solutionTreeNode != null)
{
// Ensure that we have children
solutionTreeNode.EnsureLazyChildren();
var projectTreeNode = solutionTreeNode.Children.FirstOrDefault(
node => {
if (node is ProjectTreeNode)
{
var treeNode = (ProjectTreeNode)node;
if (node.Model is IProject)
{
var projectModel = (IProject)node.Model;
return(projectModel.AssemblyModel.FullAssemblyName == entityAssembly.FullAssemblyName);
}
}
return(false);
});
if (projectTreeNode != null)
{
projectTreeNode.EnsureLazyChildren();
namespaceChildren = projectTreeNode.Children;
}
}
if (namespaceChildren == null)
{
// Try to find assembly of passed entity among additional assemblies
var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName);
if (assemblyTreeNode != null)
{
assemblyTreeNode.EnsureLazyChildren();
namespaceChildren = assemblyTreeNode.Children;
}
}
if (namespaceChildren == null)
{
// Add assembly to workspace (unpinned), if not available in ClassBrowser
IAssemblyParserService assemblyParser = SD.GetService <IAssemblyParserService>();
IClassBrowser classBrowser = SD.GetService <IClassBrowser>();
if (assemblyParser != null && classBrowser != null)
{
IAssemblyModel unpinnedAssemblyModel = assemblyParser.GetAssemblyModel(new FileName(entityAssembly.UnresolvedAssembly.Location));
if (unpinnedAssemblyModel != null)
{
classBrowser.UnpinnedAssemblies.Assemblies.Add(unpinnedAssemblyModel);
var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName);
if (assemblyTreeNode != null)
{
assemblyTreeNode.EnsureLazyChildren();
namespaceChildren = assemblyTreeNode.Children;
}
}
}
}
if (namespaceChildren != null)
{
var nsTreeNode = namespaceChildren.FirstOrDefault(
node =>
(node is NamespaceTreeNode) &&
(((NamespaceTreeNode)node).Model is INamespaceModel) &&
(((INamespaceModel)((NamespaceTreeNode)node).Model).FullName == entityType.Namespace)
) as ModelCollectionTreeNode;
if (nsTreeNode != null)
{
// Ensure that we have children
nsTreeNode.EnsureLazyChildren();
SharpTreeNode entityTypeNode = null;
// Search in namespace node recursively
var foundEntityNode = nsTreeNode.FindChildNodeRecursively(
node => {
var treeNode = node as SharpTreeNode;
if (treeNode != null)
{
var treeNodeTypeModel = treeNode.Model as ITypeDefinitionModel;
if (treeNodeTypeModel != null)
{
var modelFullTypeName = treeNodeTypeModel.FullTypeName;
if (modelFullTypeName == entityType.FullTypeName)
{
// This is the TypeDefinitionModel of searched entity (the type itself or its member)
entityTypeNode = treeNode;
if (entity is ITypeDefinition)
{
// We are looking for the type itself
return(true);
}
}
}
if ((entity is IMember) && (treeNode.Model is IMemberModel))
{
// Compare parent types and member names
IMemberModel memberModel = (IMemberModel)treeNode.Model;
IMember member = (IMember)entity;
bool isSymbolOfTypeAndName =
(member.DeclaringType.FullName == memberModel.UnresolvedMember.DeclaringTypeDefinition.FullName) &&
(member.Name == memberModel.Name) &&
(member.SymbolKind == memberModel.SymbolKind);
if (isSymbolOfTypeAndName)
{
var parametrizedEntityMember = member as IParameterizedMember;
var parametrizedTreeNodeMember = memberModel.UnresolvedMember as IUnresolvedParameterizedMember;
if ((parametrizedEntityMember != null) && (parametrizedTreeNodeMember != null))
{
// For methods and constructors additionally check the parameters and their types to handle overloading properly
int treeNodeParamsCount = parametrizedTreeNodeMember.Parameters != null ? parametrizedTreeNodeMember.Parameters.Count : 0;
int entityParamsCount = parametrizedEntityMember.Parameters != null ? parametrizedEntityMember.Parameters.Count : 0;
if (treeNodeParamsCount == entityParamsCount)
{
for (int i = 0; i < entityParamsCount; i++)
{
// Compare full type names or at least only type names without namespace
// This is not precise, but sufficient in most cases.
var entityParamType = parametrizedEntityMember.Parameters[i].Type;
var treeNodeParamType = parametrizedTreeNodeMember.Parameters[i].Type.Resolve(
new SimpleTypeResolveContext(entityAssembly));
if ((entityParamType.FullName != treeNodeParamType.FullName) &&
(entityParamType.Name != treeNodeParamType.Name))
{
return(false);
}
}
// All parameters were equal
return(true);
}
}
else
{
return(true);
}
}
}
}
return(false);
});
// Special handling for default constructors: If not found, jump to type declaration instead
if ((foundEntityNode == null) && (entity.SymbolKind == SymbolKind.Constructor))
{
foundEntityNode = entityTypeNode;
}
if (foundEntityNode != null)
{
this.FocusNode(foundEntityNode);
this.SelectedItem = foundEntityNode;
return(true);
}
}
}
}
return(false);
}
