public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
ClassData classData = dataObject as ClassData;
bool publicOnly = builder.Options ["PublicApiOnly"];
foreach (IClass innerClass in classData.Class.InnerClasses)
if (innerClass.IsPublic || !publicOnly)
builder.AddChild (innerClass);
foreach (IMethod method in classData.Class.Methods)
if (method.IsPublic || !publicOnly)
builder.AddChild (method);
foreach (IProperty property in classData.Class.Properties)
if (property.IsPublic || !publicOnly)
builder.AddChild (property);
foreach (IField field in classData.Class.Fields)
if (field.IsPublic || !publicOnly)
builder.AddChild (field);
foreach (IEvent e in classData.Class.Events)
if (e.IsPublic || !publicOnly)
builder.AddChild (e);
}
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 builder, object dataObject)
{
var compilationUnit = (AssemblyLoader)dataObject;
var references = new AssemblyReferenceFolder (compilationUnit.Assembly);
if (references.AssemblyReferences.Any () || references.ModuleReferences.Any ())
builder.AddChild (references);
var resources = new AssemblyResourceFolder (compilationUnit.Assembly);
if (resources.Resources.Any ())
builder.AddChild (resources);
var namespaces = new Dictionary<string, Namespace> ();
bool publicOnly = builder.Options ["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);
}
foreach (var ns in namespaces.Values) {
builder.AddChild (ns);
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
Project project = (Project) dataObject;
builder.AddChild (project.ProjectReferences);
builder.AddChild (new ResourceFolder (project));
base.BuildChildNodes (builder, dataObject);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
SolutionFolder folder = (SolutionFolder) dataObject;
foreach (SolutionFolderItem entry in folder.Items)
ctx.AddChild (entry);
foreach (FilePath file in folder.Files)
ctx.AddChild (new SolutionFolderFileNode (file, folder));
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
var property = (IUnresolvedProperty)dataObject;
if (property.CanGet)
ctx.AddChild (property.Getter);
if (property.CanSet)
ctx.AddChild (property.Setter);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var project = (DotNetProject) dataObject;
if (WebReferencesService.GetWebReferenceItemsWS (project).Any ())
treeBuilder.AddChild (new WebReferenceFolder (project, false));
if (WebReferencesService.GetWebReferenceItemsWCF (project).Any ())
treeBuilder.AddChild (new WebReferenceFolder (project, true));
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
HeapBuddyProfilingSnapshot snapshot = (HeapBuddyProfilingSnapshot)dataObject;
builder.AddChild (new HistoryNode (snapshot));
builder.AddChild (new TypesNode (snapshot));
builder.AddChild (new BacktracesNode (snapshot));
builder.Expanded = true;
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
DomCecilProperty property = (DomCecilProperty)dataObject;
if (property.HasGet && property.GetMethod != null)
ctx.AddChild (property.GetMethod);
if (property.HasSet && property.SetMethod != null)
ctx.AddChild (property.SetMethod);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
AddinData data = (AddinData) dataObject;
ProjectFile file = data.Project.GetProjectFile (data.AddinManifestFileName);
if (file != null)
builder.AddChild (file);
builder.AddChild (data.CachedAddinManifest.ExtensionPoints);
builder.AddChild (data.CachedAddinManifest.MainModule.Extensions);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
IEvent evt = (IEvent)dataObject;
if (evt.AddMethod != null)
ctx.AddChild (evt.AddMethod);
if (evt.RemoveMethod != null)
ctx.AddChild (evt.RemoveMethod);
if (evt.RaiseMethod != null)
ctx.AddChild (evt.RaiseMethod);
}
/// <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)
foreach (WebReferenceItem item in WebReferencesService.GetWebReferenceItemsWCF (folder.Project))
treeBuilder.AddChild(item);
else
foreach (WebReferenceItem item in WebReferencesService.GetWebReferenceItemsWS (folder.Project))
treeBuilder.AddChild(item);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
var evt = (IUnresolvedEvent)dataObject;
if (evt.CanAdd)
ctx.AddChild (evt.AddAccessor);
if (evt.CanRemove)
ctx.AddChild (evt.RemoveAccessor);
if (evt.CanInvoke)
ctx.AddChild (evt.InvokeAccessor);
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
ProjectReferenceCollection refs = (ProjectReferenceCollection) dataObject;
foreach (ProjectReference pref in refs)
ctx.AddChild (pref);
// For portable libraries, add node that represents all framework assemblies
var project = ctx.GetParentDataItem (typeof(DotNetProject), false) as PortableDotNetProject;
if (project != null)
ctx.AddChild (new PortableFrameworkSubset (project));
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
Solution sol = (Solution) dataObject;
SolutionAddinData data = sol.GetAddinData ();
if (data != null && data.Registry != null) {
foreach (var ad in data.Registry.GetAddinRoots ())
treeBuilder.AddChild (ad.Description);
foreach (var ad in data.Registry.GetAddins ())
treeBuilder.AddChild (ad.Description);
}
}
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));
foreach (GuiBuilderWindow fi in info.GuiBuilderProject.Windows)
builder.AddChild (fi);
foreach (Stetic.ActionGroupInfo group in info.GuiBuilderProject.SteticProject.ActionGroups)
builder.AddChild (group);
}
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
AddinCategoryGroup cat = (AddinCategoryGroup) dataObject;
foreach (var ad in cat.Registry.CachedRegistry.GetAddinRoots ()) {
if (ad.Description.Category == cat.Name)
treeBuilder.AddChild (ad.Description);
}
foreach (var ad in cat.Registry.CachedRegistry.GetAddins ()) {
if (ad.Description.Category == cat.Name)
treeBuilder.AddChild (ad.Description);
}
}
public static void BuildChildNodes(ITreeBuilder builder, ColumnsNode node)
{
if (node.Parent is TableSchema) {
foreach (ColumnSchema col in node.Provider.GetTableColumns ((TableSchema)node.Parent))
builder.AddChild (col);
} else if (node.Parent is ViewSchema) {
foreach (ColumnSchema col in node.Provider.GetViewColumns ((ViewSchema)node.Parent))
builder.AddChild (col);
} else if (node.Parent is ProcedureSchema) {
foreach (ColumnSchema col in node.Provider.GetProcedureColumns ((ProcedureSchema)node.Parent))
builder.AddChild (col);
}
}
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));
}
foreach (var asm in project.TargetRuntime.AssemblyContext.GetAssemblies (project.TargetFramework))
if (asm.Package.IsFrameworkPackage && asm.Name != "mscorlib")
treeBuilder.AddChild (new ImplicitFrameworkAssemblyReference (asm));
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var module = (IProtobuildModule)dataObject;
if (module.Packages != null) {
treeBuilder.AddChild (module.Packages);
}
foreach (var entry in module.Submodules) {
treeBuilder.AddChild (entry);
}
foreach (var entry in module.Definitions) {
treeBuilder.AddChild (entry);
}
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
var refs = dataObject as DProjectReferenceCollection;
refs.Update += ProjectReferences_CollectionChanged;
if (refs.HasReferences)
{
foreach (var incl in refs.Includes)
ctx.AddChild (new DProjectReference(refs.Owner, ReferenceType.Package, incl){ NameGetter = refs.GetIncludeName });
foreach(var p in refs.ReferencedProjectIds)
ctx.AddChild(new DProjectReference(refs.Owner, ReferenceType.Project, p));
}
}
public override void BuildChildNodes (ITreeBuilder treeBuilder,
object dataObject)
{
PythonClass pyClass = dataObject as PythonClass;
if (pyClass == null)
return;
foreach (PythonAttribute pyAttr in pyClass.Attributes)
treeBuilder.AddChild (pyAttr);
foreach (PythonFunction pyFunc in pyClass.Functions)
treeBuilder.AddChild (pyFunc);
}
public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
{
var addin = (Addin)dataObject;
if (addin.Description.OptionalModules.Count > 0) {
treeBuilder.AddChild (addin.Description.OptionalModules);
}
if (addin.Description.ExtensionPoints.Count > 0) {
treeBuilder.AddChild (addin.Description.ExtensionPoints);
}
base.BuildChildNodes (treeBuilder, addin.Description.MainModule);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
foreach(NestedContentProject contentProject in ((XnaProject)dataObject).NestedContentProjects)
builder.AddChild(contentProject.Project);
base.BuildChildNodes (builder, dataObject);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
var config = (NUnitAssemblyGroupProjectConfiguration) dataObject;
foreach (TestAssembly ta in config.Assemblies)
builder.AddChild (ta);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
NUnitAssemblyGroupProject project = dataObject as NUnitAssemblyGroupProject;
foreach (NUnitAssemblyGroupProjectConfiguration c in project.Configurations)
builder.AddChild (c);
}
public override void BuildChildNodes (ITreeBuilder builder, object dataObject)
{
PackagingProject project = dataObject as PackagingProject;
foreach (Package p in project.Packages)
builder.AddChild (p);
}
public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
{
var resourceFolder = (AssemblyResourceFolder)dataObject;
foreach (object resource in resourceFolder.Resources) {
ctx.AddChild (resource);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var node = (DependenciesFolderNode)dataObject;
foreach (FrameworkNode frameworkFolderNode in node.GetFrameworkFolderNodes ()) {
treeBuilder.AddChild (frameworkFolderNode);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var node = (DependencyNode)dataObject;
foreach (DependencyNode childNode in node.GetDependencies ()) {
treeBuilder.AddChild (childNode);
}
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
BaseTypeFolder baseTypeFolder = (BaseTypeFolder)dataObject;
if (baseTypeFolder.Type != null && baseTypeFolder.Type.BaseType != null)
{
ctx.AddChild(baseTypeFolder.Type.BaseType);
}
// Todo: show implemented interfaces.
/*foreach (IReturnType type in baseTypeFolder.Type.ImplementedInterfaces) {
* ctx.AddChild (type);
* }*/
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
CppProject p = dataObject as CppProject;
if (p == null)
{
return;
}
foreach (ProjectFilterItem filter in p.Filters)
{
builder.AddChild(filter);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
ProjectPackagesFolderNode packagesFolder = GetPackagesFolderNode(treeBuilder);
if (packagesFolder != null && packagesFolder.AnyPackageReferences())
{
var projectReferences = dataObject as ProjectReferenceCollection;
var folderNode = new ProjectReferencesFromPackagesFolderNode(packagesFolder, projectReferences);
if (folderNode.AnyReferencesFromPackages())
{
treeBuilder.AddChild(folderNode);
}
}
}
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 builder, object dataObject)
{
TranslationProject project = dataObject as TranslationProject;
if (project == null)
{
return;
}
foreach (Translation translation in project.Translations)
{
builder.AddChild(translation);
}
}
public override void BuildChildNodes(ITreeBuilder ctx, object dataObject)
{
NamespaceData ns = (NamespaceData)dataObject;
bool publicOnly = Widget.PublicApiOnly;
foreach (var type in ns.Types)
{
if (publicOnly && !type.isPublic)
{
continue;
}
ctx.AddChild(type.typeObject);
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
UnitTestGroup test = dataObject as UnitTestGroup;
if (test == null)
{
return;
}
foreach (UnitTest t in test.Tests)
{
builder.AddChild(t);
}
}
private void BuildChildNodesThreaded(object state)
{
ViewNode node = state as ViewNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
IDbFactory fac = node.ConnectionContext.DbFactory;
if (fac.IsActionSupported("ViewColumn", SchemaActions.Schema))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ColumnsNode(node.ConnectionContext, node.View));
builder.Expanded = true;
});
}
}
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));
}
}
private void BuildChildNodesThreaded(object state)
{
ViewNode node = state as ViewNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
ISchemaProvider provider = node.ConnectionContext.SchemaProvider;
if (provider.IsSchemaActionSupported(SchemaType.ViewColumn, SchemaActions.Schema))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ColumnsNode(node.ConnectionContext, node.View));
builder.Expanded = true;
});
}
}
private void BuildChildNodesThreaded(object state)
{
ProcedureNode node = state as ProcedureNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
ISchemaProvider provider = node.ConnectionContext.SchemaProvider;
if (provider.IsSchemaActionSupported(SchemaType.Constraint, SchemaActions.Schema))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ParametersNode(node.ConnectionContext, node.Procedure));
builder.Expanded = true;
});
}
}
private void BuildChildNodesThreaded(object state)
{
TableNode node = state as TableNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
IDbFactory fac = node.ConnectionContext.DbFactory;
if (fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.Columns))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ColumnsNode(node.ConnectionContext, node.Table));
});
}
if (fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.PrimaryKeyConstraint) ||
fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.ForeignKeyConstraint) ||
fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.CheckConstraint) ||
fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.UniqueConstraint)
)
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new ConstraintsNode(node.ConnectionContext, node.Table));
});
}
if (fac.IsCapabilitySupported("Table", SchemaActions.Schema, TableCapabilities.Trigger))
{
DispatchService.GuiDispatch(delegate {
builder.AddChild(new TriggersNode(node.ConnectionContext));
});
}
//TODO: rules
DispatchService.GuiDispatch(delegate {
builder.Expanded = true;
});
}
private void BuildChildNodesThreaded(object state)
{
BaseNode node = state as BaseNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
UserSchemaCollection users = node.ConnectionContext.SchemaProvider.GetUsers();
DispatchService.GuiDispatch(delegate {
foreach (UserSchema user in users)
{
builder.AddChild(new UserNode(node.ConnectionContext, user));
}
builder.Expanded = true;
});
}
public static void FillNamespaces(ITreeBuilder builder, Project project, INamespace ns)
{
var members = ns.Types;
//IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (project);
if (members.Any())
{
if (builder.Options ["ShowProjects"])
{
builder.AddChild(new ProjectNamespaceData(project, ns));
}
else
{
if (!builder.HasChild(ns.Name, typeof(NamespaceData)))
{
builder.AddChild(new ProjectNamespaceData(null, ns));
}
}
}
foreach (var nSpace in ns.ChildNamespaces)
{
FillNamespaces(builder, project, nSpace);
}
}
private void BuildChildNodesThreaded(object state)
{
ParametersNode node = state as ParametersNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
ParameterSchemaCollection parameters = node.ConnectionContext.SchemaProvider.GetProcedureParameters(node.Procedure);
DispatchService.GuiDispatch(delegate {
foreach (ParameterSchema parameter in parameters)
{
builder.AddChild(parameter);
}
builder.Expanded = true;
});
}
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 treeBuilder, object dataObject)
{
var module = (ModuleDescription)dataObject;
if (module.Dependencies.Count > 0)
{
treeBuilder.AddChild(module.Dependencies);
}
if (module.Extensions.Count > 0)
{
treeBuilder.AddChild(module.Extensions);
}
if (module.DataFiles.Count > 0)
{
treeBuilder.AddChild(new AddinFilesFolder(module));
}
if (module.Assemblies.Count > 0)
{
treeBuilder.AddChild(new AddinAssembliesFolder(module));
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var project = (DotNetProject)dataObject;
if (!project.IsDotNetCoreProject())
{
return;
}
var folderNode = new DependenciesNode(project);
treeBuilder.AddChild(folderNode);
folderNode.PackageDependencyCache.Refresh();
folderNode.FrameworkReferencesCache.Refresh();
}
public static void BuildChildNodes(ITreeBuilder builder, Project project)
{
if (project is DotNetProject)
{
builder.AddChild(((DotNetProject)project).References);
}
bool publicOnly = builder.Options ["PublicApiOnly"];
var dom = IdeApp.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)
.Where(t => !t.IsImplicitClass)
.Select(type => new ClassData(project, type)));
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
CProject p = treeBuilder.GetParentDataItem(typeof(CProject), false) as CProject;
if (p == null)
{
return;
}
ProjectInformation info = ProjectInformationManager.Instance.Get(p);
foreach (Macro m in info.Macros)
{
treeBuilder.AddChild(m);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var addin = (AddinReference)dataObject;
var registry = addin.Project.GetFlavor <AddinProjectFlavor> ().AddinRegistry;
var resolved = registry.GetAddin(addin.Include);
if (resolved != null)
{
foreach (var asm in resolved.Description.MainModule.Assemblies)
{
string asmPath = System.IO.Path.Combine(resolved.Description.BasePath, asm);
treeBuilder.AddChild(ProjectReference.CreateAssemblyFileReference(asmPath));
}
}
base.BuildChildNodes(treeBuilder, dataObject);
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
var flavor = GetProject(dataObject)?.GetFlavor <AddinProjectFlavor> ();
if (flavor == null)
{
return;
}
var isSdkStyleProject = flavor.Project.MSBuildProject.Sdk != null;
//bind either to deps node for sdk type, or to project for legacy
if (!(dataObject is DotNetProject) || !isSdkStyleProject)
{
treeBuilder.AddChild(flavor.AddinReferences);
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
SolutionFolder combine = (SolutionFolder)dataObject;
if (builder.Options ["ShowProjects"])
{
foreach (SolutionFolderItem entry in combine.Items)
{
builder.AddChild(entry);
}
}
else
{
AddClasses(builder, combine);
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
var type = (ITypeDefinition)dataObject;
if (type.DirectBaseTypes.Any())
{
builder.AddChild(new BaseTypeFolder(type));
}
bool publicOnly = Widget.PublicApiOnly;
// PERF: We can take advantage of the fact that AddChildren is faster than AddChild, due to not processing
// sorting of child nodes. Avoid creating additional collection, as TreeBuilder does not optimize for ICollection implementors,
// thus the overhead of creating a IEnumerable is not that big.
AddFilteredChildren(builder, type.Members, publicOnly);
AddFilteredChildren(builder, type.NestedTypes, publicOnly);
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
base.BuildChildNodes(treeBuilder, dataObject);
DotNetProject p = (DotNetProject)treeBuilder.GetParentDataItem(typeof(DotNetProject), false);
if (p != null)
{
AddinData data = AddinData.GetAddinData(p);
if (data != null)
{
foreach (Dependency adep in data.CachedAddinManifest.MainModule.Dependencies)
{
treeBuilder.AddChild(adep);
}
}
}
}
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));
}
}
}
void OnEntryAdded(object sender, SolutionItemChangeEventArgs e)
{
ITreeBuilder tb = Context.GetTreeBuilder(e.SolutionItem.ParentSolution);
if (tb != null)
{
if (e.Reloading)
{
// When reloading we ignore the removed event, and we do an UpdateAll here. This will
// replace the reloaded instance and will preserve the tree status
tb.UpdateAll();
}
else
{
tb.AddChild(e.SolutionItem, true);
tb.Expanded = true;
}
}
}
public static void FillNamespaces(ITreeBuilder builder, Project project, Microsoft.CodeAnalysis.INamespaceSymbol ns)
{
var members = ns.GetTypeMembers();
//IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (project);
if (members.Any())
{
var data = new NamespaceData(ns.Name);
foreach (var member in members)
{
data.Types.Add((member.DeclaredAccessibility == Microsoft.CodeAnalysis.Accessibility.Public, member));
}
builder.AddChild(data);
}
foreach (var nSpace in ns.GetNamespaceMembers())
{
FillNamespaces(builder, project, nSpace);
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
if (ShowingAllFiles(treeBuilder))
{
return;
}
if (!HasTemplateConfigDirectory(dataObject))
{
return;
}
var solution = (Solution)dataObject;
//if (solution.TemplateConfigDirectoryExistsInSolution ())
// return;
var folder = new SolutionTemplateConfigFolder(solution);
treeBuilder.AddChild(folder);
}
private void BuildChildNodesThreaded(object state)
{
BaseNode node = state as BaseNode;
ITreeBuilder builder = Context.GetTreeBuilder(state);
bool showSystemObjects = (bool)builder.Options["ShowSystemObjects"];
TableSchemaCollection tables = node.ConnectionContext.SchemaProvider.GetTables();
DispatchService.GuiDispatch(delegate {
foreach (TableSchema table in tables)
{
if (table.IsSystemTable && !showSystemObjects)
{
continue;
}
builder.AddChild(new TableNode(node.ConnectionContext, table));
}
builder.Expanded = true;
});
}
