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; }); }