private imTreeNode CreateAssetNode(string text)
{
imTreeNode assetNode = new imTreeNode("{All}" + text, "asset");
assetNode.Nodes.Add(CreateFileNode(text));
return(assetNode);
}
private imTreeNode CreateAssetNode(imTreeNode originalNode)
{
imTreeNode assetNode = new imTreeNode("{All}" + originalNode.Text, "asset");
assetNode.Nodes.Add(CreateFileNode(originalNode));
return(assetNode);
}
private ArrayList GetUniqueClassRoots(ArrayList nodes)
{
ArrayList uniqueRoots = new ArrayList();
if (nodes == null)
{
return(uniqueRoots);
}
foreach (imTreeNode tn in nodes)
{
imTreeNode root = tn;
while (root.Parent != null && nodes.Contains(root.Parent))
{
root = root.Parent as imTreeNode;
}
if (!uniqueRoots.Contains(root))
{
uniqueRoots.Add(root);
}
}
return(uniqueRoots);
}
private void tvTree_DoubleClick(object sender, System.EventArgs e)
{
imTreeNode clickedNode = this.tvTree.GetNodeAt(this.tvTree.PointToClient(Cursor.Position)) as imTreeNode;
if (clickedNode != null && clickedNode.IsDirectory)
{
LoadTree(this.loadedDir + "\\" + clickedNode.Text);
}
}
public void LoadProjectClasses(MOG_Project proj)
{
this.tvClasses.Nodes.Clear();
foreach (string rootClassName in proj.GetRootClassificationNames())
{
imTreeNode rootNode = LoadProjectClasses_Helper(proj, rootClassName);
this.tvClasses.Nodes.Add(rootNode);
rootNode.Expand();
}
}
private void InsertDirTreeAsClassTree(imTreeNode targetNode, imTreeNode draggedNode)
{
if (targetNode == null || draggedNode == null)
{
return;
}
imTreeNode classNode = CloneDirTreeAsClassTree(draggedNode);
targetNode.Nodes.Add(classNode);
targetNode.Expand();
}
private void tvTree_BeforeExpand(object sender, System.Windows.Forms.TreeViewCancelEventArgs e)
{
imTreeNode tn = e.Node as imTreeNode;
if (tn != null)
{
if (tn.IsDirectory && !tn.Populated)
{
PopulateDiskNode_Shallow(tn);
}
}
}
private void PopulateDiskNode_Shallow(imTreeNode tn)
{
if (!tn.Populated)
{
tn.Nodes.Clear(); // kill dummy node
foreach (imTreeNode subNode in LoadTree_Helper(tn.Path))
{
tn.Nodes.Add(subNode);
}
tn.Populated = true;
}
}
private void PopulateDiskNode_Complete(imTreeNode tn)
{
if (!tn.Populated)
{
PopulateDiskNode_Shallow(tn);
}
foreach (imTreeNode subNode in tn.Nodes)
{
if (subNode.IsDirectory)
{
PopulateDiskNode_Complete(subNode);
}
}
}
private void tvClasses_DragOver(object sender, System.Windows.Forms.DragEventArgs e)
{
imTreeNode targetNode = this.tvClasses.GetNodeAt(this.tvClasses.PointToClient(new Point(e.X, e.Y))) as imTreeNode;
if (targetNode == null)
{
e.Effect = DragDropEffects.None;
this.tvClasses.SelectedNodes.Clear();
}
else
{
e.Effect = e.AllowedEffect;
this.tvClasses.SelectedNodes.Clear();
this.tvClasses.SelectedNodes.Add(targetNode);
}
}
private void InsertPathAsClassTree(imTreeNode targetNode, string path)
{
imTreeNode classNode = CreateClassNode(Path.GetFileName(path));
foreach (string subdirpath in Directory.GetDirectories(path))
{
InsertPathAsClassTree(classNode, subdirpath);
}
foreach (string filename in Directory.GetFiles(path))
{
imTreeNode fileNode = CreateAssetNode(Path.GetFileName(filename));
classNode.Nodes.Add(fileNode);
}
targetNode.Nodes.Add(classNode);
}
private imTreeNode CloneDirTreeAsClassTree(imTreeNode dirNode)
{
imTreeNode classNode = CreateClassNode(dirNode);
foreach (imTreeNode subNode in dirNode.Nodes)
{
if (subNode.IsFile)
{
classNode.Nodes.Add(CreateAssetNode(subNode));
}
else if (subNode.IsDirectory)
{
classNode.Nodes.Add(CloneDirTreeAsClassTree(subNode));
}
}
return(classNode);
}
private void InsertPathList(ArrayList paths, imTreeNode targetNode)
{
foreach (string path in paths)
{
if (Directory.Exists(path))
{
// path is a directory, create classification
InsertPathAsClassTree(targetNode, path);
}
else if (File.Exists(path))
{
// path is a file, create asset
targetNode.Nodes.Add(CreateAssetNode(Path.GetFileName(path)));
}
}
targetNode.Expand();
}
private imTreeNode LoadProjectClasses_Helper(MOG_Project proj, string baseClass)
{
string baseClassName = baseClass;
if (baseClassName.IndexOf("~") != -1)
{
baseClassName = baseClass.Substring(baseClass.LastIndexOf("~") + 1);
}
imTreeNode node = new imTreeNode(baseClassName, "class");
foreach (string className in proj.GetSubClassificationNames(baseClass))
{
node.Nodes.Add(LoadProjectClasses_Helper(proj, baseClass + "~" + className));
}
return(node);
}
private void tvClasses_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
{
imTreeNode targetNode = this.tvClasses.GetNodeAt(this.tvClasses.PointToClient(new Point(e.X, e.Y))) as imTreeNode;
if (targetNode == null)
{
return;
}
if (e.Data.GetDataPresent(typeof(ArrayList)))
{
ArrayList nodes = (ArrayList)e.Data.GetData(typeof(ArrayList));
nodes = GetUniqueClassRoots(nodes);
InsertNodeList(nodes, targetNode);
}
else if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])e.Data.GetData("FileDrop", false);
InsertPathList(GetUniquePathRoots(new ArrayList(files)), targetNode);
}
}
private ArrayList LoadTree_Helper(string path)
{
ArrayList nodes = new ArrayList();
if (!Directory.Exists(path))
{
return(nodes);
}
foreach (string dirname in Directory.GetDirectories(path))
{
imTreeNode dirNode = new imTreeNode(Path.GetFileName(dirname), "dir");
dirNode.Path = dirname;
try
{
if (Directory.GetDirectories(dirname).Length > 0 || Directory.GetFiles(dirname).Length > 0)
{
dirNode.Nodes.Add(new imTreeNode("DUMMYNODE", "dummy"));
}
}
catch
{
dirNode.WindowsProtected = true;
dirNode.ForeColor = Color.Red;
}
nodes.Add(dirNode);
}
foreach (string filename in Directory.GetFiles(path))
{
imTreeNode fileNode = new imTreeNode(Path.GetFileName(filename), "file");
fileNode.Path = filename;
nodes.Add(fileNode);
}
return(nodes);
}
private void InsertNodeList(ArrayList nodes, imTreeNode targetNode)
{
foreach (imTreeNode draggedNode in nodes)
{
if (draggedNode.WindowsProtected)
{
continue; // skip windows-protected stuff
}
// make sure the node is fully populated (i.e., no dummy nodes)
PopulateDiskNode_Complete(draggedNode);
if (draggedNode.IsDirectory)
{
// create classification
InsertDirTreeAsClassTree(targetNode, draggedNode);
}
else if (draggedNode.IsFile)
{
// create asset
targetNode.Nodes.Add(CreateAssetNode(draggedNode));
targetNode.Expand();
}
}
}
private imTreeNode CreateClassNode(string text)
{
imTreeNode classNode = new imTreeNode(text, "class");
return(classNode);
}
private imTreeNode CreateClassNode(imTreeNode originalNode)
{
imTreeNode classNode = new imTreeNode(originalNode.Text, "class");
return(classNode);
}
private imTreeNode CreateFileNode(string text)
{
imTreeNode fileNode = new imTreeNode(text, "subasset");
return(fileNode);
}
private imTreeNode CreateFileNode(imTreeNode originalNode)
{
imTreeNode fileNode = new imTreeNode(originalNode.Text, "subasset");
return(fileNode);
}
