public override void Execute(object parameter)
{
IAssemblyReferencesModel assemblyReferencesModel = parameter as IAssemblyReferencesModel;
if (assemblyReferencesModel != null)
{
IAssemblyModel assemblyModel = assemblyReferencesModel.ParentAssemblyModel;
if ((assemblyModel != null) && (assemblyModel.Context != null))
{
IProject project = (parameter != null) ? assemblyModel.Context.Project : ProjectService.CurrentProject;
if (project == null)
{
return;
}
using (SelectReferenceDialog selDialog = new SelectReferenceDialog(project)) {
if (selDialog.ShowDialog(SD.WinForms.MainWin32Window) == System.Windows.Forms.DialogResult.OK)
{
foreach (ReferenceProjectItem reference in selDialog.ReferenceInformations)
{
ProjectService.AddProjectItem(project, reference);
}
project.Save();
}
}
}
}
}
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 bool GotoAssemblyModel(IAssemblyModel assemblyModel)
{
// Activate the pad
this.BringToFront();
// Look for assembly node in tree
return(treeView.GotoAssemblyModel(assemblyModel));
}
public bool GotoAssemblyModel(IAssemblyModel assemblyModel)
{
var pad = SD.Workbench.GetPad(typeof(ClassBrowserPad));
pad.BringPadToFront();
var content = (ClassBrowserPad)pad.PadContent;
return content.GotoAssemblyModel(assemblyModel);
}
public override void Execute(object parameter)
{
IAssemblyReferenceModel assemblyReferenceModel = parameter as IAssemblyReferenceModel;
if (assemblyReferenceModel != null)
{
IAssemblyModel assemblyModel = assemblyReferenceModel.ParentAssemblyModel;
if ((assemblyModel != null) && (assemblyModel.Context != null))
{
IProject project = (parameter != null) ? assemblyModel.Context.Project : ProjectService.CurrentProject;
if (project == null)
{
return;
}
ProjectItem referenceProjectItem =
project.Items.FirstOrDefault(
item => {
if (item.ItemType == ItemType.COMReference)
{
// Special handling for COM references: Their assembly names are prefixed with "Interop."
return(assemblyReferenceModel.AssemblyName.ShortName == "Interop." + item.Include);
}
return((item.Include == assemblyReferenceModel.AssemblyName.ShortName) && ItemType.ReferenceItemTypes.Contains(item.ItemType));
});
if (referenceProjectItem != null)
{
ProjectService.RemoveProjectItem(referenceProjectItem.Project, referenceProjectItem);
project.Save();
}
}
}
}
public AssemblyReferencesModel(IAssemblyModel parentAssemblyModel)
{
if (parentAssemblyModel == null)
throw new ArgumentNullException("parentAssemblyModel");
assemblyNames = new NullSafeSimpleModelCollection<IAssemblyReferenceModel>();
this.parentAssemblyModel = parentAssemblyModel;
}
public AssemblyTreeNode(IAssemblyModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
}
public bool GotoAssemblyModel(IAssemblyModel assemblyModel)
{
var pad = SD.Workbench.GetPad(typeof(ClassBrowserPad));
pad.BringPadToFront();
var content = (ClassBrowserPad)pad.PadContent;
return(content.GotoAssemblyModel(assemblyModel));
}
public AssemblyReferencesTreeNode(IAssemblyModel assemblyModel)
{
if (assemblyModel == null)
throw new ArgumentNullException("assemblyModel");
this.assemblyModel = assemblyModel;
this.text = SD.ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.ProjectBrowser.ReferencesNodeText");
references = new SimpleModelCollection<IAssemblyModel>();
UpdateReferences();
}
public DebuggerModuleModel(Module module)
{
if (module == null)
{
throw new ArgumentNullException("module");
}
this.module = module;
this.assemblyModel = CreateAssemblyModel(module);
}
void AppendAssemblyFileToList(string assemblyFile)
{
IAssemblyModel assemblyModel = SafelyCreateAssemblyModelFromFile(assemblyFile);
if (assemblyModel != null)
{
SD.ClassBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
}
public override void Execute(object parameter)
{
IAssemblyModel assemblyModel = (IAssemblyModel)parameter;
// Start debugger with given assembly
SD.Debugger.Start(new ProcessStartInfo {
FileName = assemblyModel.Context.Location,
WorkingDirectory = Path.GetDirectoryName(assemblyModel.Context.Location)
});
}
public AssemblyReferenceModel(IAssemblyModel parentAssemblyModel, DomAssemblyName assemblyName)
{
if (parentAssemblyModel == null)
throw new ArgumentNullException("parentAssemblyModel");
if (assemblyName == null)
throw new ArgumentNullException("assemblyName");
this.parentAssemblyModel = parentAssemblyModel;
this.assemblyName = assemblyName;
}
public AssemblyReferencesModel(IAssemblyModel parentAssemblyModel)
{
if (parentAssemblyModel == null)
{
throw new ArgumentNullException("parentAssemblyModel");
}
assemblyNames = new NullSafeSimpleModelCollection <IAssemblyReferenceModel>();
this.parentAssemblyModel = parentAssemblyModel;
}
public bool GotoAssemblyModel(IAssemblyModel assemblyModel)
{
if (assemblyModel == null)
throw new ArgumentNullException("assemblyModel");
SharpTreeNode assemblyTreeNode = FindAssemblyTreeNode(assemblyModel.FullAssemblyName);
if (assemblyTreeNode != null) {
this.FocusNode(assemblyTreeNode);
return true;
}
return false;
}
public AssemblyReferenceModel(IAssemblyModel parentAssemblyModel, DomAssemblyName assemblyName)
{
if (parentAssemblyModel == null)
{
throw new ArgumentNullException("parentAssemblyModel");
}
if (assemblyName == null)
{
throw new ArgumentNullException("assemblyName");
}
this.parentAssemblyModel = parentAssemblyModel;
this.assemblyName = assemblyName;
}
public override bool CanExecute(object parameter)
{
var assemblyReferenceModel = parameter as IAssemblyReferenceModel;
if (assemblyReferenceModel != null)
{
IAssemblyModel assemblyModel = assemblyReferenceModel.ParentAssemblyModel;
if ((assemblyModel != null) && (assemblyModel.Context != null))
{
return(assemblyModel.Context.Project != null);
}
}
return(false);
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
IAssemblyModel assemblyModel = (IAssemblyModel)parameter;
// Create a new copy of this assembly model
IAssemblyModel newAssemblyModel = SD.AssemblyParserService.GetAssemblyModelSafe(new ICSharpCode.Core.FileName(assemblyModel.Context.Location), true);
if (newAssemblyModel != null)
{
classBrowser.MainAssemblyList.Assemblies.Add(newAssemblyModel);
}
}
}
ITypeDefinitionModel GetTypeDefinitionModel(ITypeDefinition mainTypeDefinition, ITypeDefinition derivedTypeDefinition)
{
ITypeDefinitionModel resolveTypeDefModel = null;
var assemblyFileName = mainTypeDefinition.ParentAssembly.GetRuntimeAssemblyLocation();
IAssemblyModel assemblyModel = null;
try {
// Try to get AssemblyModel from project list
IProjectService projectService = SD.GetRequiredService <IProjectService>();
if (projectService.CurrentSolution != null)
{
var projectOfAssembly = projectService.CurrentSolution.Projects.FirstOrDefault(p => p.AssemblyModel.Location == assemblyFileName);
if (projectOfAssembly != null)
{
// We automatically have an AssemblyModel from project
assemblyModel = projectOfAssembly.AssemblyModel;
}
}
if (assemblyModel == null)
{
// Nothing in projects, load from assembly file
var assemblyParserService = SD.GetService <IAssemblyParserService>();
if (assemblyParserService != null)
{
if (assemblyFileName != null)
{
assemblyModel = assemblyParserService.GetAssemblyModel(assemblyFileName);
}
}
}
if (assemblyModel != null)
{
// Look in found AssemblyModel
resolveTypeDefModel = assemblyModel.TopLevelTypeDefinitions[derivedTypeDefinition.FullTypeName];
if (resolveTypeDefModel != null)
{
return(resolveTypeDefModel);
}
}
} catch (Exception) {
// TODO Can't load the type, what to do?
}
return(resolveTypeDefModel);
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
IAssemblyModel assemblyModel = (IAssemblyModel)parameter;
if (assemblyModel.IsUnpinned())
{
classBrowser.UnpinnedAssemblies.Assemblies.Remove(assemblyModel);
}
else
{
classBrowser.MainAssemblyList.Assemblies.Remove(assemblyModel);
}
}
}
public bool GotoAssemblyModel(IAssemblyModel assemblyModel)
{
if (assemblyModel == null)
{
throw new ArgumentNullException("assemblyModel");
}
SharpTreeNode assemblyTreeNode = FindAssemblyTreeNode(assemblyModel.FullAssemblyName);
if (assemblyTreeNode != null)
{
this.FocusNode(assemblyTreeNode);
return(true);
}
return(false);
}
/// <summary>
/// Checks if an assembly model is added to the unpinned (temporary) list of ClassBrowser service.
/// </summary>
/// <param name="model">Assembly model to check.</param>
/// <returns>True if in unpinned list, false otherwise.</returns>
public static bool IsUnpinned(this IAssemblyModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
// Look in unpinned list
return(classBrowser.UnpinnedAssemblies.Assemblies.Any(m => m.Location == model.Location));
}
return(false);
}
/// <summary>
/// Retrieves the model instance for the given type definition.
/// May return null if there is no model for the specified type definition.
/// </summary>
public static ITypeDefinitionModel GetModel(this ITypeDefinition typeDefinition)
{
if (typeDefinition == null)
{
throw new ArgumentNullException("typeDefinition");
}
IAssemblyModel assembly = typeDefinition.ParentAssembly.GetModel();
if (assembly != null)
{
return(assembly.TopLevelTypeDefinitions[typeDefinition.FullTypeName]);
}
else
{
return(null);
}
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
var modelFactory = SD.GetService <IModelFactory>();
if ((classBrowser != null) && (modelFactory != null))
{
OpenFromGacDialog gacDialog = new OpenFromGacDialog();
if (gacDialog.ShowDialog() ?? false)
{
foreach (string assemblyFile in gacDialog.SelectedFileNames)
{
IAssemblyModel assemblyModel = SD.AssemblyParserService.GetAssemblyModelSafe(new ICSharpCode.Core.FileName(assemblyFile), true);
if (assemblyModel != null)
{
classBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
}
}
}
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
var modelFactory = SD.GetService <IModelFactory>();
if ((classBrowser != null) && (modelFactory != null))
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Assembly files (*.exe, *.dll)|*.exe;*.dll";
openFileDialog.CheckFileExists = true;
openFileDialog.CheckPathExists = true;
if (openFileDialog.ShowDialog() ?? false)
{
IAssemblyModel assemblyModel = SD.AssemblyParserService.GetAssemblyModelSafe(new ICSharpCode.Core.FileName(openFileDialog.FileName), true);
if (assemblyModel != null)
{
classBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
}
}
}
public void SetAssemblyModel(IAssemblyModel assemblyModel)
{
this.assemblyModel = assemblyModel;
}
public void SetAssemblyModel(IAssemblyModel assemblyModel)
{
this.assemblyModel = assemblyModel;
}
public override bool CanExecute(object parameter)
{
IAssemblyModel assemblyModel = parameter as IAssemblyModel;
return(((assemblyModel != null) && assemblyModel.Context.IsValid) || (parameter is IProject) || (parameter is IAssemblyReferenceModel));
}
public bool GotoAssemblyModel(IAssemblyModel assemblyModel)
{
// Activate the pad
this.BringToFront();
// Look for assembly node in tree
return treeView.GotoAssemblyModel(assemblyModel);
}
public AssemblyTreeNode(IAssemblyModel model)
{
if (model == null)
throw new ArgumentNullException("model");
this.model = model;
}
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);
}
public DebuggerModuleModel(Module module)
{
if (module == null)
throw new ArgumentNullException("module");
this.module = module;
this.assemblyModel = CreateAssemblyModel(module);
}
public override bool CanExecute(object parameter)
{
IAssemblyModel assemblyModel = parameter as IAssemblyModel;
return((assemblyModel != null) && assemblyModel.Context.IsValid);
}
