public System.Collections.IEnumerable GetChildren(TreePath treePath)
{
if (treePath.IsEmpty())
return _list;
else
return null;
}
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 System.Collections.IEnumerable GetChildren(Aga.Controls.Tree.TreePath treePath)
{
List <PiscesObject> items = new List <PiscesObject>();
if (treePath.IsEmpty())
{
PiscesObject[] roots = db.GetRootObjects();
foreach (PiscesObject o in roots)
{
items.Add(o);
}
}
else
{
PiscesObject s = treePath.LastNode as PiscesObject;
PiscesObject[] children = db.GetChildren(s);
foreach (PiscesObject si in children)
{
items.Add(si);
}
}
return(items);
}
public TreePathEventArgs(TreePath path)
{
if (path == null)
throw new ArgumentNullException();
_path = path;
}
public override bool IsLeaf(TreePath treePath)
{
if (Settings.Default.AreasViewAsList)
return true;
Area item = treePath.LastNode as Area;
return item != null && ((item.ChildAreas != null && item.ChildAreas.Count == 0) | (item.Equipments.Count == 0));
}
public System.Collections.IEnumerable GetChildren(TreePath treePath)
{
this.InitAssemblyCache();
List<BaseItem> items = new List<BaseItem>();
BaseItem parentItem = treePath.LastNode as BaseItem;
TypeItem parentTypeItem = parentItem as TypeItem;
NamespaceItem parentNamespaceItem = parentItem as NamespaceItem;
Type parentType = parentTypeItem != null ? parentTypeItem.TypeInfo : this.baseType;
string parentName = parentNamespaceItem != null ? parentNamespaceItem.Name : null;
if (this.showNamespaces && parentTypeItem == null)
{
foreach (string subName in this.GetSubNamespaces(parentName))
{
items.Add(new NamespaceItem(subName, parentItem));
}
}
if (!this.showNamespaces || parentName != null)
{
foreach (Assembly assembly in this.assemblies)
{
foreach (Type exportedType in assembly.GetExportedTypes())
{
if (this.showNamespaces && exportedType.Namespace != parentName) continue;
if (exportedType.BaseType != parentType && (!parentType.IsInterface || !exportedType.GetInterfaces().Contains(parentType))) continue;
if (this.filter != null && !this.filter(exportedType)) continue;
items.Add(new TypeItem(exportedType, parentItem));
}
}
}
return items;
}
public Node FindNode(TreePath path)
{
if (path.IsEmpty())
return this.Root;
return FindNode(this.Root, path, 0);
}
public bool IsLeaf(TreePath path)
{
if (path.LastNode != null && path.LastNode is Expression) {
return !((Expression)path.LastNode).HasChildren();
}
return true;
}
public override System.Collections.IEnumerable GetChildren(TreePath treePath)
{
Task t= treePath.LastNode as Task;
if(t==null)
return new List<Task>(this.projects);
return t.Tasks;
}
public override bool IsLeaf(TreePath treePath)
{
DataRowNode n = treePath.LastNode as DataRowNode;
if (n.Row["IsFolder"] == DBNull.Value)
return false;
return !Convert.ToBoolean(n.Row["IsFolder"]);
}
protected override void HandleModelChanged(object sender, ModelChangedArgs e) {
TreePath treePath = new TreePath(view.Tree.Root);
switch (e.Context) {
case EventContext.WorkitemPropertiesUpdatedFromView:
HandleWorkitemPropertiesUpdated(PropertyUpdateSource.WorkitemView);
break;
case EventContext.WorkitemPropertiesUpdatedFromPropertyView:
HandleWorkitemPropertiesUpdated(PropertyUpdateSource.WorkitemPropertyView);
break;
case EventContext.WorkitemsChanged:
treePath = view.Tree.GetPath(view.CurrentNode.Level == 2 ? view.CurrentNode.Parent : view.CurrentNode);
model.InvokeStructureChanged(treePath);
break;
case EventContext.VirtualWorkitemRemoved:
treePath = view.Tree.GetPath(view.CurrentNode.Parent??view.Tree.Root);
model.InvokeStructureChanged(treePath);
break;
case EventContext.ProjectSelected:
HandleModelChanged();
break;
case EventContext.WorkitemsRequested:
HandleModelChanged();
break;
case EventContext.WorkitemSaved:
treePath = view.Tree.GetPath(view.CurrentNode.Level == 2 ? view.CurrentNode.Parent : view.CurrentNode);
model.InvokeStructureChanged(treePath);
break;
case EventContext.WorkitemCacheInvalidated:
assetCache.Drop();
break;
default:
throw new NotSupportedException();
}
}
public override IEnumerable GetChildren(TreePath treePath)
{
List<TemplateTreeItem> dataItems = new List<TemplateTreeItem>();
if (treePath.IsEmpty())
{
var data = _dataSource.GroupBy(i => Regex.Matches(i.Description, @"\b[\w]*\b").Cast<Match>().First().Value);
dataItems.AddRange(data.Select(group => new TemplateTreeItem()
{
Description = group.Key, Id = Guid.NewGuid(), IsLeaf = !group.Any(), Tag = group
}).OrderBy(o=>o.Description));
}
else
{
IGrouping<string, EquipmentTemplate> items = ((TemplateTreeItem)treePath.LastNode).Tag as IGrouping<string, EquipmentTemplate>;
if (items==null)
throw new Exception("Error in tree");
dataItems.AddRange(items.Select(item => new TemplateTreeItem()
{
Description = item.Description,
Id = item.ElementId,
IsLeaf = true,
Tag = item
}).OrderBy(o => o.Description));
}
return dataItems;
}
public TreePath(TreePath parent, object node)
{
_path = new object[parent.FullPath.Length + 1];
for (int i = 0; i < _path.Length - 1; i++)
_path[i] = parent.FullPath[i];
_path[_path.Length - 1] = node;
}
public Node FindNode(TreePath path)
{
if (path.IsEmpty())
return _root;
else
return FindNode(_root, path, 0);
}
public System.Collections.IEnumerable GetChildren(TreePath treePath)
{
if (treePath.IsEmpty())
foreach (string str in Environment.GetLogicalDrives())
{
RootItem item = new RootItem(str);
yield return item;
}
else
{
List<BaseItem> items = new List<BaseItem>();
BaseItem parent = treePath.LastNode as BaseItem;
if (parent != null)
{
foreach (string str in Directory.GetDirectories(parent.ItemPath))
items.Add(new FolderItem(str, parent));
foreach (string str in Directory.GetFiles(parent.ItemPath))
items.Add(new FileItem(str, parent));
_itemsToRead.AddRange(items);
if (!_worker.IsBusy)
_worker.RunWorkerAsync();
foreach (BaseItem item in items)
yield return item;
}
else
yield break;
}
}
private void ReportRenamed(string oldReportName, string newReportName)
{
var treePath = new TreePath(new[] { projectRoot, reportsNode });
OnNodesRemoved(new TreeModelEventArgs(treePath, new[] { new ReportNode(oldReportName) }));
OnNodesInserted(new TreeModelEventArgs(treePath, new[] { 0 },
new[] { new ReportNode(newReportName) }));
}
public override IEnumerable GetChildren(TreePath treePath)
{
if (treePath.IsEmpty())
{
yield return new PluginDetailsNode("Component Handler Factory", componentDescriptor.ComponentHandlerFactory.ToString());
yield return new PluginDetailsNode("Component Properties", string.Empty);
yield return new PluginDetailsNode("Component Type Name", componentDescriptor.ComponentTypeName.FullName);
yield return new PluginDetailsNode("Disabled", componentDescriptor.IsDisabled.ToString());
yield return new PluginDetailsNode("Traits Properties", string.Empty);
}
else
{
var node = (PluginDetailsNode) treePath.LastNode;
if (node.Name == "Component Properties")
{
if (componentDescriptor.ComponentProperties != null)
foreach (var property in componentDescriptor.ComponentProperties)
yield return new PluginDetailsNode(property.Key, property.Value);
}
else if (node.Name == "Disabled" && componentDescriptor.IsDisabled)
{
yield return new PluginDetailsNode("Disabled Reason", componentDescriptor.DisabledReason);
}
else if (node.Name == "Traits Properties")
{
if (componentDescriptor.TraitsProperties != null)
foreach (var property in componentDescriptor.TraitsProperties)
yield return new PluginDetailsNode(property.Key, property.Value);
}
}
}
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 override IEnumerable GetChildren(TreePath treePath)
{
if (treePath.IsEmpty())
{
yield return new PluginDetailsNode("Assembly References", string.Empty);
yield return new PluginDetailsNode("Base Directory", pluginDescriptor.BaseDirectory.FullName);
yield return new PluginDetailsNode("Disabled", pluginDescriptor.IsDisabled.ToString());
yield return new PluginDetailsNode("Plugin Dependencies", string.Empty);
yield return
new PluginDetailsNode("Plugin Handler Factory", pluginDescriptor.PluginHandlerFactory.ToString())
;
yield return new PluginDetailsNode("Plugin Properties", string.Empty);
yield return new PluginDetailsNode("Plugin Type Name", pluginDescriptor.PluginTypeName.FullName);
yield return new PluginDetailsNode("Probing Paths", string.Empty);
yield return new PluginDetailsNode("Traits Properties", string.Empty);
}
else
{
var node = (PluginDetailsNode) treePath.LastNode;
if (node.Name == "Assembly References" && pluginDescriptor.AssemblyBindings != null)
{
foreach (var assemblyReference in pluginDescriptor.AssemblyBindings)
{
string codeBase = assemblyReference.CodeBase != null ?
assemblyReference.CodeBase.ToString() : "(unknown)";
yield return new PluginDetailsNode(assemblyReference.AssemblyName.ToString(),
codeBase);
}
}
else if (node.Name == "Disabled" && pluginDescriptor.IsDisabled)
{
yield return new PluginDetailsNode("Disabled Reason", pluginDescriptor.DisabledReason);
}
else
switch (node.Name)
{
case "Plugin Dependencies":
if (pluginDescriptor.PluginDependencies != null)
foreach (var pluginDependency in pluginDescriptor.PluginDependencies)
yield return new PluginDetailsNode(pluginDependency.PluginId, string.Empty);
break;
case "Plugin Properties":
if (pluginDescriptor.PluginProperties != null)
foreach (var pluginProperty in pluginDescriptor.PluginProperties)
yield return new PluginDetailsNode(pluginProperty.Key, pluginProperty.Value);
break;
case "Probing Paths":
if (pluginDescriptor.ProbingPaths != null)
foreach (var probingPath in pluginDescriptor.ProbingPaths)
yield return new PluginDetailsNode(probingPath, string.Empty);
break;
case "Traits Properties":
if (pluginDescriptor.TraitsProperties != null)
foreach (var traitsProperty in pluginDescriptor.TraitsProperties)
yield return new PluginDetailsNode(traitsProperty.Key, traitsProperty.Value);
break;
}
}
}
public override bool IsLeaf(TreePath treePath)
{
if (treePath.LastNode is FileNode)
return true;
return treePath.LastNode is PluginNode &&
((PluginNode)treePath.LastNode).Nodes.Count == 0;
}
public virtual bool IsLeaf(TreePath treePath)
{
Node node = FindNode(treePath);
if (node != null)
return node.IsLeaf;
else
throw new ArgumentException("treePath");
}
public override bool IsLeaf(TreePath treePath)
{
if (treePath.IsEmpty())
return false;
var node = (PluginDetailsNode)treePath.LastNode;
return node.Name != "Disabled" || !serviceDescriptor.IsDisabled;
}
/// <summary>Grabs the children of the passed path</summary>
/// <param name="treePath">Path to get the children of</param>
/// <returns>IEnumerable collection with the child items</returns>
public IEnumerable GetChildren(TreePath treePath)
{
List<BaseItem> items = new List<BaseItem>();
if (treePath.IsEmpty())
{
if (_tree.Cache.ContainsKey("ROOT"))
{
items = _tree.Cache["ROOT"];
}
else
{
items = new List<BaseItem>();
_tree.Cache.Add("ROOT", items);
}
}
else
{
ServerItem server = treePath.FirstNode as ServerItem;
BaseItem database = treePath.FullPath.FirstOrDefault(i => (i as BaseItem).Type == ItemType.Database) as BaseItem;
BaseItem parent = treePath.LastNode as BaseItem;
if (parent != null && server != null)
{
if (_tree.Cache.ContainsKey(parent.ItemPath))
{
items = _tree.Cache[parent.ItemPath];
}
else
{
//Populate the items based on the parent
switch (parent.Type)
{
case ItemType.Server:
items = GetDatabases(server);
break;
case ItemType.Database:
items = GetDatabaseChildren(parent);
break;
case ItemType.Folder:
if (database != null)
items = GetFolderChildren(parent, server, database.Name);
break;
case ItemType.Table:
case ItemType.View:
items = GetTableViewChildren(parent);
break;
default:
break;
}
_tree.Cache.Add(parent.ItemPath, items);
}
parent.IsLoaded = true;
}
}
return items;
}
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 IEnumerable GetChildren(TreePath treePath)
{
DetailTreeNode parent = treePath.LastNode as DetailTreeNode;
if (parent == null)
{
return node_.ChildNodes();
}
return parent.ChildNodes();
}
public System.Collections.IEnumerable GetChildren(TreePath treePath)
{
Node node = FindNode(treePath);
if (node != null)
foreach (Node n in node.Nodes)
yield return n;
else
yield break;
}
public NodeModule FindNode(TreePath path)
{
if (path.FullPath.Length == 0)
return null;
else if (path.FullPath.Length==1)
return _root;
else
return FindNode(_root, path, 1);
}
private Node GetNode(TreePath treePath) {
Node parent = root;
foreach (object obj in treePath.FullPath) {
Node node = obj as Node;
if (node == null || node.Parent != parent)
return null;
parent = node;
}
return parent;
}
public IEnumerable GetChildren(TreePath treePath) {
Node node = GetNode(treePath);
if (node != null) {
foreach (Node n in node.Nodes)
if (forceVisible || n.IsVisible)
yield return n;
} else {
yield break;
}
}
/// <summary>Trigger for the NodesChanged event</summary>
/// <param name="Tree">Path of the parent of the changed items</param>
/// <param name="Indices">Indices (0-based) where to add the children changed</param>
/// <param name="Children">Children objects to be changed under the Tree</param>
public void OnNodesChanged(TreePath Tree, int[] Indices, object[] Children)
{
if (NodesChanged != null && Children != null)
{
if (Indices == null)
{
Indices = BuildIndices(Children.Length);
}
NodesChanged(this, new TreeModelEventArgs(Tree, Indices, Children));
}
}
public TreeNodeAdv FindNode(TreePath path)
{
return(FindNode(path, false));
}
public override bool IsLeaf(Aga.Controls.Tree.TreePath treePath)
{
PiscesObject o = treePath.LastNode as PiscesObject;
return(!(o is PiscesFolder));
}
public override bool IsLeaf(TreePath treePath)
{
return(InnerModel.IsLeaf(treePath));
}
public bool IsLeaf(TreePath treePath)
{
return(true);
}
public abstract System.Collections.IEnumerable GetChildren(TreePath treePath);
/// <summary>
///
/// </summary>
/// <param name="parent">Path to a parent node</param>
/// <param name="children">Child nodes</param>
public TreeModelEventArgs(TreePath parent, object[] children)
: this(parent, null, children)
{
}
public override IEnumerable GetChildren(TreePath treePath)
{
return(_list);
}
public override bool IsLeaf(TreePath treePath)
{
return(true);
}
public abstract IEnumerable GetChildren(TreePath treePath);
public abstract bool IsLeaf(TreePath treePath);
