public override System.Collections.IEnumerable GetChildren(TreePath treePath) { if (_showingCollections) { if (treePath.IsEmpty()) { return(DAL.GetCollectionsInfo()); } var n = (SeriesEpisodesShortInfo)treePath.LastNode; return(DAL.GetElementsInCollection(n.Id, n.SectionType)); //changed to another root (Collection) } else { if (treePath.IsEmpty()) { return(DAL.GetSeriesInfo()); } var n = (SeriesEpisodesShortInfo)treePath.LastNode; return (string.IsNullOrEmpty(n.Season) ? DAL.GetSeasonsForSeries(n.Id) //changed to another root (Series) : DAL.GetEpisodesInSeason(n.SeriesId, n.Season)); } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { if (!treePath.IsEmpty() && !(treePath.LastNode is RevisionBrowserBaseItem)) { return(null); } List <RevisionBrowserBaseItem> items = new List <RevisionBrowserBaseItem>(); if (treePath.IsEmpty()) { items.Add(new RevisionBrowserTypeItem(RevisionType.Version, this)); items.Add(new RevisionBrowserTypeItem(RevisionType.Commit, this)); } else { if (treePath.LastNode is RevisionBrowserTypeItem parent && Data?.Revisions != null && Data.Revisions.TryGetValue(parent.Type, out IEnumerable <object> objects)) { IEnumerable <object> filteredObjects = sortAndFilter(objects); int iItem = filteredObjects.Count(); foreach (object item in filteredObjects) { getItemProperties(iItem, item, out string fullSha, out string name, out DateTime timestamp, out string tooltipText); bool isReviewed = _data.ReviewedRevisions.Contains(fullSha); items.Add(new RevisionBrowserItem(name, timestamp, fullSha, parent, this, tooltipText, isReviewed, iItem)); --iItem; } } } return(items); }
public IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { yield return(root); } else { Node node = treePath.LastNode as Node; if (node != null) { if (0 != node.Childs.Count) { foreach (Node n in node.Childs) { if (forceVisible || n.IsVisible) { yield return(n); } } } else { // yield break; } } else { yield break; } } }
public IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { List <BaseItem> items = new List <BaseItem>(); int index = 0; foreach (var data in pathList) { BaseItem item = new FileItem(data, null, index); items.Add(item); _nodeMap.Add(item.ItemPath, item); ++index; } // foreach _itemsToRead.AddRange(items); RunWorkerAsync(); foreach (BaseItem item in items) { yield return(item); } // end foreach } else { yield break; } // end if }
public override System.Collections.IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { if (_tileSet != null) { if (_tileSet.SupportsCustomFiniteDisplayScalesUnconditionally) { yield return(new ScaleItem(Strings.FiniteDisplayScales, new List <double>(_tileSet.FiniteDisplayScale))); } foreach (var grp in _tileSet.BaseMapLayerGroups) { yield return(new BaseLayerGroupItem(grp)); } } } else { var grp = treePath.LastNode as BaseLayerGroupItem; if (grp != null) { if (_tileSet != null) { foreach (var layer in _tileSet.GetLayersForGroup(grp.Tag.Name)) { yield return(new BaseLayerItem(layer, grp.Tag)); } } } } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { //get folders } else { List <BaseItem> items = new List <BaseItem>(); BaseItem parent = treePath.LastNode as BaseItem; if (parent != null) { var folder = parent.ItemPath; //get all users //foreach (string str in Directory.GetDirectories()) // items.Add(new FolderItem(str, parent)); //_itemsToRead.AddRange(items); //foreach (BaseItem item in items) // yield return item; yield return(null); } } }
public IEnumerable GetChildren(TreePath treePath) { if (UpdateLocks > 0) { throw new InvalidOperationException("Tree enumeration attempted while update in progress"); } List <TabularNamedObject> items = new List <TabularNamedObject>(); if (treePath.IsEmpty()) { // If no root was specified, use the entire model if (Options.HasFlag(LogicalTreeOptions.ShowRoot)) { items.Add(Model); } else { return(GetChildren(Model)); } } else { return(GetChildren(treePath.LastNode as ITabularObjectContainer)); } return(items); }
public IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { if (effectiveRules != null) { yield return(effectiveRules); } foreach (var externalRules in analyzer.ExternalRuleCollections) { yield return(externalRules); } if (analyzer.ModelRules != null) { yield return(analyzer.ModelRules); } if (analyzer.LocalUserRules != null) { yield return(analyzer.LocalUserRules); } if (analyzer.LocalMachineRules != null) { yield return(analyzer.LocalMachineRules); } } }
public bool IsLeaf(TreePath treePath) { if (treePath.IsEmpty()) { var relations = _dataService.GetRelations(null); return(relations == null || !relations.Any()); } if (treePath.LastNode is DbItem) { var item = treePath.LastNode as DbItem; var relations = _dataService.GetRelations(item.Id); return(relations == null || !relations.Any()); } else if (treePath.LastNode is DbRelation) { var relation = treePath.LastNode as DbRelation; if (relation.ToId != null) { var item = _dataService.GetItem(relation.ToId.Value); return(item == null); } } return(true); }
public override System.Collections.IEnumerable GetChildren(TreePath treePath) { List <DataRowNode> items = new List <DataRowNode>(); if (treePath.IsEmpty()) { items.Add(m_root); } else { DataRowNode n = treePath.LastNode as DataRowNode; DataRow row = n.Row; int id = Convert.ToInt32(row[m_IDColumnName]); DataRow[] rows = m_table.Select("ParentID = " + id + " and " + m_IDColumnName + " <> " + id); foreach (DataRow r in rows) { DataRowNode node = new DataRowNode(r, r["Name"].ToString()); node.Row = r; //SampleApp.Properties.Resources.ResourceManager. //node.Icon = new Bitmap(SampleApp.Properties.Resources.Records,new Size(15,15)); items.Add(node); } } return(items); }
public override IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { foreach (var plugin in registry.Plugins) { yield return(new PluginNode(plugin.PluginId)); } } else if (treePath.LastNode is PluginNode) { var pluginNode = (PluginNode)treePath.LastNode; foreach (var service in registry.Services) { if (service.Plugin.PluginId == pluginNode.Text) { yield return(new ServiceNode(service.ServiceId)); } } } else if (treePath.LastNode is ServiceNode) { var serviceNode = (ServiceNode)treePath.LastNode; foreach (var component in registry.Components) { if (component.Service.ServiceId == serviceNode.Text) { yield return(new ComponentNode(component.ComponentId)); } } } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { var categories = new List <Category>(); foreach (var c in _queuedExports) { var cat = categories.Find(q => q.Label == c.Category); if (cat == null) { cat = new Category { Label = c.Category, Enabled = CheckState.Checked }; categories.Add(cat); } cat._items.Add(new Item { Attached = c }); } return(categories); } else { // find all of the items in the given category var cat = treePath.LastNode as Category; if (cat != null) { return(cat._items); } } return(null); }
public override IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { yield return(root); } else if (treePath.LastNode == root) { foreach (var pluginDescriptor in PluginDescriptors) { var pluginNode = new PluginNode(pluginDescriptor); root.Nodes.Add(pluginNode); foreach (var file in pluginDescriptor.FilePaths) { var fullPath = Path.Combine(pluginDescriptor.BaseDirectory.FullName, file); var exists = fileSystem.FileExists(fullPath); pluginNode.Nodes.Add(new FileNode(file, exists)); } yield return(pluginNode); } } else if (treePath.LastNode is PluginNode) { var pluginNode = (PluginNode)treePath.LastNode; foreach (var child in pluginNode.Nodes) { yield return(child); } } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { List <BaseItem> items = null; if (treePath.IsEmpty()) { if (_cache.ContainsKey("ROOT")) { items = _cache["ROOT"]; } else { items = new List <BaseItem>(); _cache.Add("ROOT", items); foreach (string str in Environment.GetLogicalDrives()) { items.Add(new RootItem(str, this)); } } } else { BaseItem parent = treePath.LastNode as BaseItem; if (parent != null) { if (_cache.ContainsKey(parent.ItemPath)) { items = _cache[parent.ItemPath]; } else { items = new List <BaseItem>(); try { foreach (string str in Directory.GetDirectories(parent.ItemPath)) { items.Add(new FolderItem(str, parent, this)); } foreach (string str in Directory.GetFiles(parent.ItemPath)) { FileItem item = new FileItem(str, parent, this); items.Add(item); } } catch (IOException) { return(null); } _cache.Add(parent.ItemPath, items); _itemsToRead.AddRange(items); if (!_worker.IsBusy) { _worker.RunWorkerAsync(); } } } } return(items); }
public bool IsLeaf(TreePath treePath) { if (treePath.IsEmpty()) { return(false); } return((treePath.LastNode as Change).IsLeaf); }
public PlaylistTreeNodeBase FindNode(TreePath path) { if (path.IsEmpty()) { return(Root); } return(FindNode(Root, path, 0)); }
/// <summary> /// Returns a node list of all child nodes of a given parent node /// </summary> /// <param name="treePath">The path of the parent node</param> /// <returns>The list of child nodes for the given parent path node</returns> public override System.Collections.IEnumerable GetChildren(TreePath treePath) { NodeIdWrapper parentNodeId; bool settingTopNode = false; if (treePath.IsEmpty()) { settingTopNode = true; parentNodeId = model.get_root(); } else { GrtTreeNode parent = treePath.LastNode as GrtTreeNode; if (parent != null) { parentNodeId = parent.NodeId; } else { parentNodeId = null; } } if (parentNodeId != null) { // The backend has child nodes on a node not before it was expanded. int childCount = model.count_children(parentNodeId); if (childCount == 0) { // But expand only if we don't have any children yet. Otherwise // get many unnecessary refresh calls. model.expand_node(parentNodeId); childCount = model.count_children(parentNodeId); } for (int i = 0; i < childCount; i++) { NodeIdWrapper nodeId = model.get_child(parentNodeId, i); GrtTreeNode node; string caption; model.get_field(nodeId, columns[0].index, out caption); node = new GrtTreeNode(caption, nodeId, null, this); if (settingTopNode) { topNode = node; } //items.Add(node); yield return(node); } } //return items; }
public override IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { return(nodes); } IssueNode n = treePath.LastNode as IssueNode; return(n != null ? n.SubtaskNodes : null); }
public IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { foreach (AssemblyGroup grp in _ac.Groups) { yield return(new AssemblyGroupTreeItem(grp)); } } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { foreach (var item in _menu.Items) { if (item.Function == UIItemFunctionType.Command) { var ci = (ICommandItem)item; var cmd = _wl.GetCommandByName(ci.Command); Debug.Assert(cmd != null); yield return(new CommandItem(ci, CommandIconCache.GetStandardCommandIcon(cmd.ImageURL))); } else if (item.Function == UIItemFunctionType.Flyout) { yield return(new FlyoutItem((IFlyoutItem)item)); } else { yield return(new SeparatorItem((ISeparatorItem)item)); } } } else { var flyout = treePath.LastNode as FlyoutItem; if (flyout != null) { foreach (var item in flyout.SubItem) { if (item.Function == UIItemFunctionType.Command) { var ci = (ICommandItem)item; var cmd = _wl.GetCommandByName(ci.Command); Debug.Assert(cmd != null); yield return(new CommandItem(ci, CommandIconCache.GetStandardCommandIcon(cmd.ImageURL))); } else if (item.Function == UIItemFunctionType.Flyout) { yield return(new FlyoutItem((IFlyoutItem)item)); } else { yield return(new SeparatorItem((ISeparatorItem)item)); } } } else { yield break; } } }
public override bool IsLeaf(TreePath treePath) { if (treePath.IsEmpty()) { return(false); } var node = (PluginDetailsNode)treePath.LastNode; return(node.Name != "Disabled" || !serviceDescriptor.IsDisabled); }
public IEnumerable <object> GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { return(Root.Children); } else { return(((INode)treePath.LastNode).Children); } }
public Node FindNode(TreePath path) { if (path.IsEmpty()) { return(_root); } else { return(FindNode(_root, path, 0)); } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { if (string.IsNullOrEmpty(this.basePath) && treePath.IsEmpty()) { foreach (string str in Environment.GetLogicalDrives()) { LogicalDriveItem item = new LogicalDriveItem(str); yield return(item); } } else { List <BaseItem> items = new List <BaseItem>(); BaseItem parent = treePath.LastNode as BaseItem; string path = parent != null ? parent.ItemPath : this.basePath; if (!string.IsNullOrEmpty(path) && Directory.Exists(path)) { try { IEnumerable <string> dirQuery = Directory.GetDirectories(path); IEnumerable <string> fileQuery = Directory.GetFiles(path); if (this.filter != null) { dirQuery = dirQuery.Where(s => this.filter(s)); fileQuery = fileQuery.Where(s => this.filter(s)); } foreach (string str in dirQuery) { items.Add(new FolderItem(str, parent)); } foreach (string str in fileQuery) { items.Add(new FileItem(str, parent)); } } catch (UnauthorizedAccessException) {} this.itemsToRead.AddRange(items); if (!this.itemLoader.IsBusy) { this.itemLoader.RunWorkerAsync(); } foreach (BaseItem item in items) { yield return(item); } } else { yield break; } } }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { using (var session = m_data.OpenSession(m_snapshot.Id)) using (var tx = session.BeginTransaction()) { if (treePath.IsEmpty()) { //top level queries var calls = session.CreateQuery(kTopLevelQuery) .SetMaxResults(100) .List <Call>(); foreach (var c in calls) { var item = new FunctionItem(); item.Id = c.ParentId; item.Thread = c.Thread.Id; item.Name = FunctionInfo.GetFullSignature(c.Parent); item.Time = Math.Round(c.Time, 3); yield return(item); } } else { var parentNode = treePath.LastNode as FunctionItem; session.EnableFilter("Thread").SetParameter("threadId", parentNode.Thread); var data = session.CreateQuery(kChildQuery) .SetInt32("childId", parentNode.Id) .List <object[]>(); foreach (var row in data) { Call c = row[0] as Call; var parentTime = Convert.ToDouble(row[1]); var item = new FunctionItem(); item.Thread = parentNode.Thread; item.Id = c.ParentId; item.Name = FunctionInfo.GetFullSignature(c.Parent); item.Time = Math.Round(c.Time, 3); if (parentTime == 0) { item.PercentTime = 0; } else { item.PercentTime = Math.Round(100 * c.Time / parentTime, 3); } yield return(item); } } tx.Commit(); yield break; } }
/// <summary> /// Returns a node list of all child nodes of a given parent node /// </summary> /// <param name="treePath">The path of the parent node</param> /// <returns>The list of child nodes for the given parent path node</returns> public override System.Collections.IEnumerable GetChildren(TreePath treePath) { List <GrtTreeNode> items = null; NodeIdWrapper parentNodeId; bool settingTopNode = false; if (treePath.IsEmpty()) { settingTopNode = true; parentNodeId = model.get_root(); } else { GrtTreeNode parent = treePath.LastNode as GrtTreeNode; if (parent != null) { parentNodeId = parent.NodeId; } else { parentNodeId = null; } } if (parentNodeId != null) { int childCount = model.count_children(parentNodeId); items = new List <GrtTreeNode>(); for (int i = 0; i < childCount; i++) { NodeIdWrapper nodeId = model.get_child(parentNodeId, i); GrtTreeNode node; string caption; model.get_field(nodeId, columns[0].index, out caption); if (disabledNames.Contains(caption)) { continue; } node = new GrtTreeNode(caption, nodeId, null, this); if (settingTopNode) { topNode = node; } items.Add(node); } } return(items); }
public IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { return(TableChanges.Keys.OrderBy(k => k.Description)); } else { return(TableChanges[(treePath.LastNode as Change)]); } }
public IEnumerable GetChildren(TreePath treePath) { if (this.RootSection == null) { return(null); } SectionEntry ed = treePath.IsEmpty() ? this.RootSection : ((SectionEntry)treePath.LastNode); List <Entry> ret = new List <Entry>(ed.Entries); ret.Add(null);//a null entry, which will be the button for adding new entries return(ret); }
public override System.Collections.IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { List <LuaWatchVariable> variables = new List <LuaWatchVariable>(watchVariables); variables.Add(newWatchVariable); return(variables); } else { return(base.GetChildren(treePath)); } }
public override System.Collections.IEnumerable GetChildren(TreePath treePath) { if (treePath.IsEmpty()) { foreach (var layer in _map.MapLayer) { yield return(new LayerItem(layer)); } } else { yield break; } }