public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
Solution solution = (Solution)dataObject;
ctx.AddChildren(solution.RootFolder.Items);
ctx.AddChildren(solution.RootFolder.Files.Select(f => new SolutionFolderFileNode(f, solution.RootFolder)));
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
SolutionFolder folder = (SolutionFolder)dataObject;
ctx.AddChildren(folder.Items);
ctx.AddChildren(folder.Files.Select(file => new SolutionFolderFileNode(file, folder)));
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
if (!builder.Options ["ShowAllFiles"])
{
return;
}
string path = GetFolderPath(dataObject);
if (Directory.Exists(path))
{
Project project = (Project)builder.GetParentDataItem(typeof(Project), true);
SolutionFolderFileCollection folderFiles = null;
if (dataObject is Solution)
{
folderFiles = ((Solution)dataObject).RootFolder.Files;
}
else if (dataObject is SolutionFolder)
{
folderFiles = ((SolutionFolder)dataObject).Files;
}
builder.AddChildren(Directory.EnumerateFiles(path)
.Where(file => (project == null || project.Files.GetFile(file) == null) && (folderFiles == null || !folderFiles.Contains(file)))
.Select(file => new SystemFile(file, project)));
builder.AddChildren(Directory.EnumerateDirectories(path)
.Where(folder => !builder.HasChild(Path.GetFileName(folder), typeof(ProjectFolder)))
.Select(folder => new ProjectFolder(folder, project)));
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
Project project = (Project)dataObject;
bool publicOnly = Widget.PublicApiOnly;
var dom = IdeApp.TypeSystemService.GetCompilationAsync(project).Result;
if (dom == null)
{
return;
}
var data = new List <NamespaceData> (32);
CollectNamespaces(data, dom.Assembly.GlobalNamespace.GetNamespaceMembers());
builder.AddChildren(data);
var types = dom.Assembly.GlobalNamespace.GetTypeMembers();
if (types.Length > 0)
{
var children = publicOnly
? types.Where(t => t.IsPublic())
: types;
builder.AddChildren(children);
}
}
/// <summary>Add entries for all the web references in the project to the tree builder.</summary>
/// <param name="treeBuilder">An ITreeBuilder containing all the data for the current DotNet project.</param>
/// <param name="dataObject">An object containing the data for the current node in the tree.</param>
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var folder = (WebReferenceFolder) dataObject;
if (folder.IsWCF)
treeBuilder.AddChildren (WebReferencesService.GetWebReferenceItemsWCF (folder.Project));
else
treeBuilder.AddChildren (WebReferencesService.GetWebReferenceItemsWS (folder.Project));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
Project p = ((WindowsFolder)dataObject).Project;
GtkDesignInfo info = GtkDesignInfo.FromProject (p);
if (!info.GuiBuilderProject.HasError) {
builder.AddChild (new StockIconsNode (p));
builder.AddChildren (info.GuiBuilderProject.Windows);
builder.AddChildren (info.GuiBuilderProject.SteticProject.ActionGroups);
}
}
void AddProjectContent(ITreeBuilder builder, Project p)
{
builder.AddChildren(namesp.GetNamespaceMembers()
.Where(ns => !builder.HasChild(ns.Name, typeof(NamespaceData)))
.Select(ns => new ProjectNamespaceData(project, ns)));
// bool nestedNs = builder.Options ["NestedNamespaces"];
bool publicOnly = builder.Options ["PublicApiOnly"];
builder.AddChildren(namesp.GetAllTypes()
.Where(type => !publicOnly || type.DeclaredAccessibility == Accessibility.Public)
.Select(type => new ClassData(project, type)));
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
Project p = ((WindowsFolder)dataObject).Project;
GtkDesignInfo info = GtkDesignInfo.FromProject(p);
if (!info.GuiBuilderProject.HasError)
{
builder.AddChild(new StockIconsNode(p));
builder.AddChildren(info.GuiBuilderProject.Windows);
builder.AddChildren(info.GuiBuilderProject.SteticProject.ActionGroups);
}
}
/// <summary>Add entries for all the web references in the project to the tree builder.</summary>
/// <param name="treeBuilder">An ITreeBuilder containing all the data for the current DotNet project.</param>
/// <param name="dataObject">An object containing the data for the current node in the tree.</param>
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var folder = (WebReferenceFolder)dataObject;
if (folder.IsWCF)
{
treeBuilder.AddChildren(WebReferencesService.GetWebReferenceItemsWCF(folder.Project));
}
else
{
treeBuilder.AddChildren(WebReferencesService.GetWebReferenceItemsWS(folder.Project));
}
}
void AddLoadedDependencyNodes(ITreeBuilder treeBuilder, SdkDependenciesNode dependenciesNode)
{
var frameworkNodes = GetTargetFrameworkNodes(dependenciesNode).ToList();
if (frameworkNodes.Count > 1)
{
treeBuilder.AddChildren(frameworkNodes);
}
else if (frameworkNodes.Any())
{
var frameworkNode = frameworkNodes.First();
treeBuilder.AddChildren(frameworkNode.GetDependencyNodes());
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
string path = GetFolderPath(dataObject);
if (Directory.Exists(path))
{
treeBuilder.AddChildren(Directory.EnumerateFiles(path)
.Where(file => !IsHidden(file))
.Select(file => new SystemFile(file, null, false)));
treeBuilder.AddChildren(Directory.EnumerateDirectories(path)
.Where(file => !IsHidden(file))
.Select(folder => new WorkspaceFolder(folder)));
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
var baseTypeFolder = (BaseTypeFolder)dataObject;
builder.AddChild(baseTypeFolder.Type.BaseType);
builder.AddChildren(baseTypeFolder.Type.Interfaces);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
Namespace ns = (Namespace)dataObject;
bool publicOnly = ctx.Options ["PublicApiOnly"];
if (ns.Types != null)
ctx.AddChildren (publicOnly ? ns.Types.Where (t => t.IsPublic) : ns.Types);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
string path = GetFolderPath (dataObject);
Project project = builder.GetParentDataItem (typeof(Project), true) as Project;
if (project == null)
return;
ProjectFileCollection files;
List<string> folders;
GetFolderContent (project, path, out files, out folders);
builder.AddChildren (files);
builder.AddChildren (folders.Select (f => new ProjectFolder (f, project, dataObject)));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
string path = GetFolderPath (dataObject);
Project project = builder.GetParentDataItem (typeof(Project), true) as Project;
if (project == null)
return;
ProjectFileCollection files;
List<string> folders;
GetFolderContent (project, path, out files, out folders);
builder.AddChildren (files);
builder.AddChildren (folders.Select (f => new ProjectFolder (f, project, dataObject)));
}
public static void BuildChildNodes(ITreeBuilder builder, Project project)
{
if (project is DotNetProject)
{
builder.AddChild(((DotNetProject)project).References);
}
bool publicOnly = builder.Options ["PublicApiOnly"];
var dom = TypeSystemService.GetCompilationAsync(project).Result;
if (dom == null)
{
return;
}
bool nestedNamespaces = builder.Options ["NestedNamespaces"];
HashSet <string> addedNames = new HashSet <string> ();
foreach (var ns in dom.Assembly.GlobalNamespace.GetNamespaceMembers())
{
if (nestedNamespaces)
{
if (!addedNames.Contains(ns.Name))
{
builder.AddChild(new ProjectNamespaceData(project, ns));
addedNames.Add(ns.Name);
}
}
else
{
FillNamespaces(builder, project, ns);
}
}
builder.AddChildren(dom.Assembly.GlobalNamespace.GetTypeMembers()
.Where(type => !publicOnly || type.DeclaredAccessibility == Accessibility.Public)
.Select(type => new ClassData(project, type)));
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
ClassData classData = dataObject as ClassData;
bool publicOnly = builder.Options ["PublicApiOnly"];
bool publicProtectedOnly = builder.Options ["PublicProtectedApiOnly"];
publicOnly |= publicProtectedOnly;
// Delegates have an Invoke method, which doesn't need to be shown.
if (classData.Class.TypeKind == TypeKind.Delegate)
{
return;
}
builder.AddChildren(classData.Class.GetTypeMembers()
.Where(innerClass => innerClass.DeclaredAccessibility == Accessibility.Public ||
(innerClass.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly)
.Where(c => !c.IsImplicitClass)
.Select(innerClass => new ClassData(classData.Project, innerClass)));
builder.AddChildren(classData.Class.GetMembers().OfType <IMethodSymbol> ().Where(m => m.MethodKind != MethodKind.PropertyGet && m.MethodKind != MethodKind.PropertySet)
.Where(method => method.DeclaredAccessibility == Accessibility.Public ||
(method.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly)
.Where(m => !m.IsImplicitlyDeclared));
builder.AddChildren(classData.Class.GetMembers().OfType <IPropertySymbol> ()
.Where(property => property.DeclaredAccessibility == Accessibility.Public ||
(property.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly)
.Where(m => !m.IsImplicitlyDeclared));
builder.AddChildren(classData.Class.GetMembers().OfType <IFieldSymbol> ()
.Where(field => field.DeclaredAccessibility == Accessibility.Public ||
(field.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly)
.Where(m => !m.IsImplicitlyDeclared));
builder.AddChildren(classData.Class.GetMembers().OfType <IEventSymbol> ()
.Where(e => e.DeclaredAccessibility == Accessibility.Public ||
(e.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly)
.Where(m => !m.IsImplicitlyDeclared));
}
void AddLoadedDependencyNodes(ITreeBuilder treeBuilder, PackageDependenciesNode dependenciesNode)
{
var frameworkNodes = GetTargetFrameworkNodes(dependenciesNode).ToList();
if (frameworkNodes.Count > 1)
{
treeBuilder.AddChildren(frameworkNodes);
}
else if (frameworkNodes.Any())
{
var frameworkNode = frameworkNodes.First();
treeBuilder.AddChildren(frameworkNode.GetDependencyNodes());
}
else
{
AddDependencyNodesFromPackageReferencesInProject(treeBuilder, dependenciesNode);
}
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
IType type = (IType)dataObject;
ctx.AddChild(new BaseTypeFolder(type));
bool publicOnly = ctx.Options ["PublicApiOnly"];
ctx.AddChildren(type.Members.Where(member => !(member.IsSpecialName && !(member is IMethod && ((IMethod)member).IsConstructor)) && !(publicOnly && !(member.IsPublic || member.IsProtected))));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
SolutionFolder combine = (SolutionFolder) dataObject;
if (builder.Options ["ShowProjects"]) {
builder.AddChildren (combine.Items);
} else {
AddClasses (builder, combine);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
base.BuildChildNodes(treeBuilder, dataObject);
ProjectFile file = (ProjectFile)dataObject;
if (file.HasChildren)
{
treeBuilder.AddChildren(file.DependentChildren);
}
else
{
var children = FileNestingService.GetChildren(file);
if ((children?.Count ?? 0) > 0)
{
treeBuilder.AddChildren(children);
}
}
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
Namespace ns = (Namespace)dataObject;
bool publicOnly = Widget.PublicApiOnly;
if (ns.Types != null)
{
ctx.AddChildren(publicOnly ? ns.Types.Where(t => t.IsPublic) : ns.Types);
}
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
ProjectReferenceCollection refs = (ProjectReferenceCollection) dataObject;
ctx.AddChildren (refs);
// For portable libraries, add node that represents all framework assemblies
var project = (DotNetProject) ctx.GetParentDataItem (typeof(DotNetProject), false);
if (project != null && project.IsPortableLibrary)
ctx.AddChild (new PortableFrameworkSubset (project));
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
base.BuildChildNodes(treeBuilder, dataObject);
ProjectFile file = (ProjectFile)dataObject;
if (file.HasChildren)
{
treeBuilder.AddChildren(file.DependentChildren);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var compilationUnit = (AssemblyLoader)dataObject;
if (compilationUnit.Error != null)
{
treeBuilder.AddChild(compilationUnit.Error);
return;
}
if (compilationUnit.Assembly == null)
{
return;
}
var references = new AssemblyReferenceFolder(compilationUnit.Assembly);
if (references.AssemblyReferences.Any() || references.ModuleReferences.Any())
{
treeBuilder.AddChild(references);
}
var resources = new AssemblyResourceFolder(compilationUnit.Assembly);
if (resources.Resources.Any())
{
treeBuilder.AddChild(resources);
}
var namespaces = new Dictionary <string, NamespaceData> ();
bool publicOnly = Widget.PublicApiOnly;
foreach (var type in compilationUnit.DecompilerTypeSystem.MainModule.TypeDefinitions)
{
string namespaceName = string.IsNullOrEmpty(type.Namespace) ? "" : type.Namespace;
if (!namespaces.ContainsKey(namespaceName))
{
namespaces [namespaceName] = new NamespaceData(namespaceName);
}
var ns = namespaces [namespaceName];
ns.Types.Add((type.IsPublic(), type));
}
treeBuilder.AddChildren(namespaces.Where(ns => ns.Key != "" && (!publicOnly || ns.Value.Types.Any(t => t.isPublic))).Select(n => n.Value));
if (namespaces.ContainsKey(""))
{
foreach (var child in namespaces[""].Types)
{
if (((INamedElement)child.typeObject).Name == "<Module>")
{
continue;
}
treeBuilder.AddChild(child);
}
}
}
void AddLoadedDependencyNodes(ITreeBuilder treeBuilder, SdkDependenciesNode dependenciesNode)
{
var frameworkNodes = GetTargetFrameworkNodes(dependenciesNode).ToList();
if (frameworkNodes.Count > 1)
{
treeBuilder.AddChildren(frameworkNodes);
}
else if (frameworkNodes.Any())
{
var frameworkNode = frameworkNodes.First();
treeBuilder.AddChildren(frameworkNode.GetDependencyNodes());
}
else
{
// Projects sometimes return no dependencies from MSBuild initially so
// add the default nodes until the dependencies are updated.
treeBuilder.AddChildren(dependenciesNode.GetDefaultNodes());
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
UnitTestGroup test = dataObject as UnitTestGroup;
if (test == null)
{
return;
}
builder.AddChildren(test.Tests);
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
TranslationProject project = dataObject as TranslationProject;
if (project == null)
{
return;
}
builder.AddChildren(project.Translations);
}
void BuildChildNodes(UnitTestGroup test, ITreeBuilder builder)
{
bool isSolution = test is SolutionFolderTestGroup;
if (!isSolution && ContainsSingleUnitTestGroup(test))
{
var unitTestGroup = test.Tests[0] as UnitTestGroup;
BuildChildNodes(unitTestGroup, builder);
return;
}
builder.AddChildren(test.Tests);
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
ITypeSymbol classData = dataObject as ITypeSymbol;
bool publicOnly = Widget.PublicApiOnly;
bool publicProtectedOnly = false;
publicOnly |= publicProtectedOnly;
// Delegates have an Invoke method, which doesn't need to be shown.
if (classData.TypeKind == TypeKind.Delegate)
{
return;
}
Func <ISymbol, bool> filter = symbol => !MethodPropertyFilter(symbol);
if (Widget.PublicApiOnly)
{
filter = symbol => symbol.IsPublic() && !MethodPropertyFilter(symbol);
}
var typeMembers = classData.GetTypeMembers();
if (typeMembers.Length > 0)
{
builder.AddChildren(Enumerable.Where(typeMembers, filter));
}
var members = classData.GetMembers();
if (members.Length > 0)
{
builder.AddChildren(members.Where(filter));
}
bool MethodPropertyFilter(ISymbol symbol)
{
return(symbol is IMethodSymbol method && (method.MethodKind == MethodKind.PropertyGet || method.MethodKind == MethodKind.PropertySet));
}
}
protected static void AddFilteredChildren <T> (ITreeBuilder builder, IReadOnlyCollection <T> collection, bool publicApiOnly) where T : IEntity
{
if (collection.Count == 0)
{
return;
}
var children = publicApiOnly
? collection.Where(x => x.IsPublic())
: collection;
builder.AddChildren(collection);
}
void BuildChildNodes(UnitTestGroup test, ITreeBuilder builder)
{
var combineTestNamespaces = builder.Options ["CombineTestNamespaces"];
bool isSolution = test is SolutionFolderTestGroup;
if (!isSolution && ContainsUnitTestCanMerge(test) && combineTestNamespaces)
{
var unitTestGroup = test.Tests[0] as UnitTestGroup;
BuildChildNodes(unitTestGroup, builder);
return;
}
builder.AddChildren(test.Tests);
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
SolutionFolder combine = (SolutionFolder)dataObject;
if (builder.Options ["ShowProjects"])
{
builder.AddChildren(combine.Items);
}
else
{
AddClasses(builder, combine);
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
ITypeSymbol classData = dataObject as ITypeSymbol;
bool publicOnly = Widget.PublicApiOnly;
bool publicProtectedOnly = false;
publicOnly |= publicProtectedOnly;
// Delegates have an Invoke method, which doesn't need to be shown.
if (classData.TypeKind == TypeKind.Delegate)
{
return;
}
builder.AddChildren(classData.GetTypeMembers()
.Where(innerClass => innerClass.DeclaredAccessibility == Accessibility.Public ||
(innerClass.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren(classData.GetMembers().OfType <IMethodSymbol> ().Where(m => m.MethodKind != MethodKind.PropertyGet && m.MethodKind != MethodKind.PropertySet)
.Where(method => method.DeclaredAccessibility == Accessibility.Public ||
(method.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren(classData.GetMembers().OfType <IPropertySymbol> ()
.Where(property => property.DeclaredAccessibility == Accessibility.Public ||
(property.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren(classData.GetMembers().OfType <IFieldSymbol> ()
.Where(field => field.DeclaredAccessibility == Accessibility.Public ||
(field.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren(classData.GetMembers().OfType <IEventSymbol> ()
.Where(e => e.DeclaredAccessibility == Accessibility.Public ||
(e.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
NamespaceData ns = (NamespaceData)dataObject;
IEnumerable <object> result = ns.Types;
if (Widget.PublicApiOnly)
{
result = result.Where(x => NamespaceData.IsPublic(x));
}
ctx.AddChildren(result);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var project = ((PortableFrameworkSubset) dataObject).Project;
if (!project.TargetRuntime.IsInstalled (project.TargetFramework)) {
string msg = GettextCatalog.GetString ("Framework not installed: {0}", project.TargetFramework.Id);
treeBuilder.AddChild (new TreeViewItem (msg, Stock.Warning));
}
treeBuilder.AddChildren (project.TargetRuntime.AssemblyContext.GetAssemblies (project.TargetFramework)
.Where (asm => asm.Package.IsFrameworkPackage && asm.Name != "mscorlib")
.Select (asm => new ImplicitFrameworkAssemblyReference (asm)));
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var dependenciesNode = (SdkDependenciesNode)dataObject;
if (dependenciesNode.LoadedDependencies)
{
AddLoadedDependencyNodes(treeBuilder, dependenciesNode);
}
else
{
treeBuilder.AddChildren(dependenciesNode.GetDefaultNodes());
}
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
ProjectReferenceCollection refs = (ProjectReferenceCollection) dataObject;
ctx.AddChildren (refs);
// For portable libraries, add node that represents all framework assemblies
var project = (DotNetProject) ctx.GetParentDataItem (typeof(DotNetProject), false);
if (project != null) {
var tfm = project.TargetFramework.Id;
if (tfm.Identifier == MonoDevelop.Core.Assemblies.TargetFrameworkMoniker.ID_PORTABLE && tfm.Version != "5.0") {
ctx.AddChild (new PortableFrameworkSubset (project));
}
}
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
var referenceFolder = (AssemblyReferenceFolder)dataObject;
var wrapper = (AssemblyLoader)ctx.GetParentDataItem (typeof (AssemblyLoader), false);
foreach (AssemblyNameReference assemblyNameReference in referenceFolder.AssemblyReferences) {
try {
string assemblyFile = wrapper.LookupAssembly (assemblyNameReference.FullName);
if (assemblyFile != null && System.IO.File.Exists (assemblyFile)) {
ctx.AddChild (assemblyNameReference);
} else {
ctx.AddChild (new Error (MonoDevelop.Core.GettextCatalog.GetString ("Can't load:") + assemblyNameReference.FullName));
}
} catch (Exception) {
// ctx.AddChild (new Error (MonoDevelop.Core.GettextCatalog.GetString ("Error while loading:") + assemblyNameReference.FullName + "/" + e.Message));
}
}
ctx.AddChildren (referenceFolder.ModuleReferences);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
Solution solution = (Solution) dataObject;
ctx.AddChildren (solution.RootFolder.Items);
ctx.AddChildren (solution.RootFolder.Files.Select (f => new SolutionFolderFileNode (f, solution.RootFolder)));
}
public static void BuildChildNodes (ITreeBuilder builder, Project project)
{
if (project is DotNetProject) {
builder.AddChild (((DotNetProject)project).References);
}
bool publicOnly = builder.Options ["PublicApiOnly"];
var dom = TypeSystemService.GetCompilationAsync (project).Result;
if (dom == null)
return;
bool nestedNamespaces = builder.Options ["NestedNamespaces"];
HashSet<string> addedNames = new HashSet<string> ();
foreach (var ns in dom.Assembly.GlobalNamespace.GetNamespaceMembers ()) {
if (nestedNamespaces) {
if (!addedNames.Contains (ns.Name)) {
builder.AddChild (new ProjectNamespaceData (project, ns));
addedNames.Add (ns.Name);
}
} else {
FillNamespaces (builder, project, ns);
}
}
builder.AddChildren (dom.Assembly.GlobalNamespace.GetTypeMembers ()
.Where (type => !publicOnly || type.DeclaredAccessibility == Accessibility.Public)
.Select (type => new ClassData (project, type)));
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var node = (AddinAssembliesFolder)dataObject;
treeBuilder.AddChildren (node.Module.Assemblies.OfType<string> ().Select (f => new AddinAssembly (node.Module, f)));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
GuiBuilderWindow win = (GuiBuilderWindow) dataObject;
builder.AddChildren (win.RootWidget.ActionGroups);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
base.BuildChildNodes (treeBuilder, dataObject);
ProjectFile file = (ProjectFile) dataObject;
if (file.HasChildren)
treeBuilder.AddChildren (file.DependentChildren);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var compilationUnit = (AssemblyLoader)dataObject;
if (compilationUnit.Assembly == null)
return;
var references = new AssemblyReferenceFolder (compilationUnit.Assembly);
if (references.AssemblyReferences.Any () || references.ModuleReferences.Any ())
treeBuilder.AddChild (references);
var resources = new AssemblyResourceFolder (compilationUnit.Assembly);
if (resources.Resources.Any ())
treeBuilder.AddChild (resources);
var namespaces = new Dictionary<string, Namespace> ();
bool publicOnly = Widget.PublicApiOnly;
foreach (var type in compilationUnit.UnresolvedAssembly.TopLevelTypeDefinitions) {
string namespaceName = string.IsNullOrEmpty (type.Namespace) ? "-" : type.Namespace;
if (!namespaces.ContainsKey (namespaceName))
namespaces [namespaceName] = new Namespace (namespaceName);
var ns = namespaces [namespaceName];
ns.Types.Add (type);
}
treeBuilder.AddChildren (namespaces.Values.Where (ns => !publicOnly || ns.Types.Any (t => t.IsPublic)));
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
SolutionFolder folder = (SolutionFolder) dataObject;
ctx.AddChildren (folder.Items);
ctx.AddChildren (folder.Files.Select (file => new SolutionFolderFileNode (file, folder)));
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
Workspace ws = (Workspace) dataObject;
ctx.AddChildren (ws.Items);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
var type = (IUnresolvedTypeDefinition)dataObject;
var list = new System.Collections.ArrayList ();
list.Add (new BaseTypeFolder (type));
bool publicOnly = builder.Options ["PublicApiOnly"];
foreach (var t in type.NestedTypes.Where (m => !m.IsSynthetic && !(publicOnly && m.IsPublic)))
list.Add (t);
foreach (var m in type.Members.Where (m => !m.IsSynthetic && !(publicOnly && !(m.IsPublic || m.IsInternal))))
list.Add (m);
builder.AddChildren (list);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var modules = (ModuleCollection)dataObject;
treeBuilder.AddChildren (modules);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
Solution solution = (Solution) dataObject;
ctx.AddChildren (solution.RootFolder.Items);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
var type = (IUnresolvedTypeDefinition)dataObject;
var list = new System.Collections.ArrayList ();
list.Add (new BaseTypeFolder (type));
bool publicOnly = Widget.PublicApiOnly;
foreach (var t in type.NestedTypes.Where (m => !m.IsSynthetic && (m.IsPublic || m.IsProtected || !publicOnly))) {
list.Add (t);
}
foreach (var m in type.Members.Where (m => !m.IsSynthetic && (m.IsPublic || m.IsProtected || !publicOnly)))
list.Add (m);
builder.AddChildren (list);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var extensions = (ExtensionCollection)dataObject;
treeBuilder.AddChildren (extensions);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
IType type = (IType)dataObject;
ctx.AddChild (new BaseTypeFolder (type));
bool publicOnly = ctx.Options ["PublicApiOnly"];
ctx.AddChildren (type.Members.Where (member => !(member.IsSpecialName && !(member is IMethod && ((IMethod)member).IsConstructor)) && !(publicOnly && !(member.IsPublic || member.IsProtected))));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
if (!builder.Options ["ShowAllFiles"])
return;
string path = GetFolderPath (dataObject);
if (Directory.Exists (path))
{
Project project = (Project) builder.GetParentDataItem (typeof(Project), true);
SolutionFolderFileCollection folderFiles = null;
if (dataObject is Solution)
folderFiles = ((Solution)dataObject).RootFolder.Files;
else if (dataObject is SolutionFolder)
folderFiles = ((SolutionFolder)dataObject).Files;
builder.AddChildren (Directory.EnumerateFiles (path)
.Where (file => (project == null || project.Files.GetFile (file) == null) && (folderFiles == null || !folderFiles.Contains (file)))
.Select (file => new SystemFile (file, project)));
builder.AddChildren (Directory.EnumerateDirectories (path)
.Where (folder => !builder.HasChild (Path.GetFileName (folder), typeof (ProjectFolder)))
.Select (folder => new ProjectFolder (folder, project)));
}
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
treeBuilder.AddChildren (GetReferencesFromPackages (dataObject));
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var dependencies = (DependencyCollection)dataObject;
treeBuilder.AddChildren (dependencies.OfType<AddinDependency> ());
}
void AddProjectContent (ITreeBuilder builder, Project p)
{
builder.AddChildren (namesp.GetNamespaceMembers ()
.Where (ns => !builder.HasChild (ns.Name, typeof (NamespaceData)))
.Select (ns => new ProjectNamespaceData (project, ns)));
// bool nestedNs = builder.Options ["NestedNamespaces"];
bool publicOnly = builder.Options ["PublicApiOnly"];
builder.AddChildren (namesp.GetAllTypes ()
.Where (type => !publicOnly || type.DeclaredAccessibility == Accessibility.Public)
.Select (type => new ClassData (project, type)));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
PackagingProject project = dataObject as PackagingProject;
builder.AddChildren (project.Packages);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
ClassData classData = dataObject as ClassData;
bool publicOnly = builder.Options ["PublicApiOnly"];
bool publicProtectedOnly = builder.Options ["PublicProtectedApiOnly"];
publicOnly |= publicProtectedOnly;
// Delegates have an Invoke method, which doesn't need to be shown.
if (classData.Class.TypeKind == TypeKind.Delegate)
return;
builder.AddChildren (classData.Class.GetTypeMembers ()
.Where (innerClass => innerClass.DeclaredAccessibility == Accessibility.Public ||
(innerClass.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly)
.Select (innerClass => new ClassData (classData.Project, innerClass)));
builder.AddChildren (classData.Class.GetMembers ().OfType<IMethodSymbol> ().Where (m => m.MethodKind != MethodKind.PropertyGet && m.MethodKind != MethodKind.PropertySet)
.Where (method => method.DeclaredAccessibility == Accessibility.Public ||
(method.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren (classData.Class.GetMembers ().OfType<IPropertySymbol> ()
.Where (property => property.DeclaredAccessibility == Accessibility.Public ||
(property.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren (classData.Class.GetMembers ().OfType<IFieldSymbol> ()
.Where (field => field.DeclaredAccessibility == Accessibility.Public ||
(field.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
builder.AddChildren (classData.Class.GetMembers ().OfType<IEventSymbol> ()
.Where (e => e.DeclaredAccessibility == Accessibility.Public ||
(e.DeclaredAccessibility == Accessibility.Protected && publicProtectedOnly) ||
!publicOnly));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
var baseTypeFolder = (BaseTypeFolder)dataObject;
builder.AddChildren (baseTypeFolder.Type.BaseTypes);
}
