private AssetTreeNode ConvertDiskNode(AssetTreeNode tn)
{
AssetTreeNode newNode = new AssetTreeNode(tn.Text);
newNode.InSelectedTree = true;
newNode.ForeColor = Color.Red;
newNode.IsAFile = tn.IsAFile;
newNode.IsAFolder = tn.IsAFolder;
newNode.IsAnAssetFilename = tn.IsAnAssetFilename;
newNode.MasterNode = tn.MasterNode;
newNode.DiskNode = tn.DiskNode;
newNode.SelectedNode = tn.SelectedNode;
newNode.FileFullPath = tn.FileFullPath;
newNode.RelativePath = tn.RelativePath;
if (newNode.IsAFolder)
{
newNode.ImageIndex = CLOSEDFOLDER_INDEX;
newNode.SelectedImageIndex = CLOSEDFOLDER_INDEX;
}
else
{
newNode.ImageIndex = QUESTION_INDEX;
newNode.SelectedImageIndex = QUESTION_INDEX;
}
// link everything together
newNode.DiskNode = tn;
newNode.MasterNode = tn.MasterNode;
tn.SelectedNode = newNode;
return(newNode);
}
private AssetTreeNode CreateTreeFromDisk(string rootPath, string path, BackgroundWorker worker)
{
if (Directory.Exists(path))
{
// Show the relative path so we have more real estate in the progress dialog
string relativePath = DosUtils.PathMakeRelativePath(rootPath, path);
worker.ReportProgress(0, "Loading:\n" + relativePath);
AssetTreeNode node = CreateFolderNode(path);
//Add subdirectories
foreach (string subdir in Directory.GetDirectories(path))
{
node.Nodes.Add(CreateTreeFromDisk(rootPath, subdir, worker));
}
//Add files
foreach (string file in Directory.GetFiles(path))
{
node.Nodes.Add(CreateFileNode(file, path));
}
return(node);
}
return(null);
}
private void SelectedTreeView_DragDrop(object sender, DragEventArgs args)
{
AssetTreePlacerDragObject dragObj = args.Data.GetData(typeof(AssetTreePlacerDragObject)) as AssetTreePlacerDragObject;
if (dragObj == null)
{
return;
}
Cursor.Current = Cursors.WaitCursor;
if (dragObj.source == AssetTreePlacerDragObject.DragObjectSource.DISKTREEVIEW)
{
// place nodes in selected tree
ArrayList roots = AssetTreeNode.GetUniqueRootNodes(dragObj.nodeList);
foreach (TreeNode root in roots)
{
if (!root.Checked)
{
root.Checked = true;
}
}
}
}
private classTreeNode EncodeTree(AssetTreeNode tn, MOG_Properties props, int dialogId)
{
classTreeNode classNode = new classTreeNode(tn.Text);
classNode.ImageIndex = BLUEDOT_INDEX;
classNode.SelectedImageIndex = BLUEDOT_INDEX;
// Get a local handle for our progress dialog
MOG_Progress.ProgressUpdate(dialogId, tn.FullPath);
// if this is an asset filename node?
if (tn.IsAnAssetFilename)
{
classNode.Text = classNode.Text;
classNode.ForeColor = Color.Blue;
classNode.ImageIndex = ARROW_INDEX;
classNode.SelectedImageIndex = ARROW_INDEX;
classNode.IsAssetFilenameNode = true;
// Inherit Properties from parent
// 'props' needs to be cloned or else all of these children assets will share the same Properties!!!
classNode.props = props;
// Make list o' children
foreach (AssetTreeNode fileNode in tn.fileNodes)
{
if (fileNode.IsAFile)
{
classNode.importFiles.Add(fileNode.FileFullPath);
}
}
// setup gamedatapath
string assetDirectoryPath = MOG.CONTROLLER.CONTROLLERASSET.MOG_ControllerAsset.GetCommonDirectoryPath(this.projectRootPath, classNode.importFiles);
string relativePath = "";
if (assetDirectoryPath.Length > this.projectRootPath.Length)
{
relativePath = assetDirectoryPath.Substring(this.projectRootPath.Length + 1);
}
classNode.props.SyncTargetPath = relativePath;
// add it to the list of asset filename nodes for later processing
this.assetFilenameNodes.Add(classNode);
return(classNode); // don't do children of an asset filename node
}
// Use our properties to pass along to our children
props = MOG_ControllerProject.GetClassificationProperties(tn.FullPath.Replace(tn.TreeView.PathSeparator, "~"));
props.SetImmeadiateMode(true);
classNode.props = props;
// Loop through all of our children nodes sending them our Properties
foreach (AssetTreeNode subNode in tn.Nodes)
{
classNode.Nodes.Add(EncodeTree(subNode, props, dialogId));
}
return(classNode);
}
public void AddTreeFromDisk(string path)
{
if (Directory.Exists(path))
{
// Removed because this double progress dialog was crashing us...besides, reporting path to user is progress enough for now
// ProgressDialog progress = new ProgressDialog("Counting Subdirectories", "Calculating...", CountSubdirs_Worker, path, false);
// if (progress.ShowDialog(this) == DialogResult.OK)
// {
// int subdirs = (int)progress.WorkerResult;
List <object> args = new List <object>();
args.Add(path);
// args.Add(subdirs);
ProgressDialog progress = new ProgressDialog("Loading Folders", "Please wait while MOG loads the directory tree", CreateTreeFromDisk_Worker, args, true);
if (progress.ShowDialog(this) == DialogResult.OK)
{
// Build the list of children nodes under the root directory
AssetTreeNode parentnode = progress.WorkerResult as AssetTreeNode;
// Bring in all of the children nodes so the root directory node won't confuse the user
foreach (AssetTreeNode node in parentnode.Nodes)
{
Nodes.Add(node);
}
}
// }
}
}
void Add(Asset resource, TreeNodeCollection nodes, Action <double> progressUpdateCallback, double percentOffset, double percentPart)
{
if (progressUpdateCallback != null)
{
progressUpdateCallback(percentOffset);
}
TreeNode node = new AssetTreeNode(resource);
nodes.Add(node);
if (resource is FolderAsset)
{
if (resource.Children.Count == 1)
{
node.Expand();
}
double childPercentOffset = 0, childPercentPart = percentPart / resource.Children.Count;
foreach (Asset child in resource.Children)
{
Add(child, node.Nodes, progressUpdateCallback, percentOffset + childPercentOffset, percentPart);
childPercentOffset += childPercentPart;
}
}
}
private void PropagateCheckStateDown(AssetTreeNode tn)
{
foreach (AssetTreeNode subNode in tn.Nodes)
{
subNode.Checked = tn.Checked;
PropagateCheckStateDown(subNode);
}
}
private classTreeNode EncodeNode(AssetTreeNode atn, MOG_Properties props)
{
classTreeNode classNode = new classTreeNode(atn.Text);
classNode.ImageIndex = BLUEDOT_INDEX;
classNode.SelectedImageIndex = BLUEDOT_INDEX;
classNode.props = null;
// if this is an asset filename node?
if (atn.IsAnAssetFilename)
{
classNode.Text = classNode.Text;
classNode.ForeColor = Color.Blue;
classNode.ImageIndex = ARROW_INDEX;
classNode.SelectedImageIndex = ARROW_INDEX;
classNode.IsAssetFilenameNode = true;
// Make list o' children
foreach (AssetTreeNode fileNode in atn.fileNodes)
{
if (fileNode.IsAFile)
{
classNode.importFiles.Add(fileNode.FileFullPath);
}
}
// Check if we have a props?
if (classNode.props != null)
{
// Setup SyncTargetPath Property
string relativePath = "";
string assetDirectoryPath = MOG.CONTROLLER.CONTROLLERASSET.MOG_ControllerAsset.GetCommonDirectoryPath(this.projectRootPath, classNode.importFiles);
if (assetDirectoryPath.Length > this.projectRootPath.Length)
{
relativePath = assetDirectoryPath.Substring(this.projectRootPath.Length + 1);
}
// Set our SyncTargetPath
classNode.props.SyncTargetPath = relativePath;
}
// add it to the list of asset filename nodes for later processing
this.assetFilenameNodes.Add(classNode);
return(classNode); // don't do children of an asset filename node
}
classNode.FilledIn = false;
classNode.assetTreeNode = atn;
// add a dummy child node if necessary
if (atn.Nodes.Count > 0)
{
classNode.Nodes.Add(new classTreeNode("DUMMY_NODE"));
}
return(classNode);
}
private void DeleteAssetNodes(AssetTreeNode tn)
{
DeleteAssetNodes(tn.Nodes);
if (tn.IsAFile && tn.AssetNode != null)
{
((AssetTreeView)tn.AssetNode.TreeView).RemoveNode(tn.AssetNode);
}
}
private AssetTreeNode CreateFolderNode(string path)
{
AssetTreeNode node = new AssetTreeNode(Path.GetFileName(path), CLOSEDFOLDER_INDEX, Color.DarkGoldenrod);
node.FileFullPath = path;
node.InDiskTree = true;
node.IsAFolder = true;
return(node);
}
private void miExpandToRed_Click(object sender, EventArgs args)
{
AssetTreeNode targetNode = GetNodeAt(PointToClient(new Point(Cursor.Position.X, Cursor.Position.Y))) as AssetTreeNode;
ShowUnplaced(targetNode);
if (targetNode != null)
{
targetNode.EnsureVisible();
}
}
private AssetTreeNode CreateFileNode(string path, string basePath)
{
AssetTreeNode node = new AssetTreeNode(Path.GetFileName(path), FILE_INDEX, Color.DarkMagenta);
node.InDiskTree = true;
node.FileFullPath = path;
node.RelativePath = path.ToLower().Replace(basePath.ToLower(), "").Trim("\\".ToCharArray());
node.IsAFile = true;
return(node);
}
public void PropagateCheckStateUp(AssetTreeNode tn)
{
AssetTreeNode parentNode = tn.Parent as AssetTreeNode;
while (parentNode != null)
{
parentNode.Checked = tn.Checked;
parentNode = parentNode.Parent as AssetTreeNode;
}
}
private void DeleteNode(AssetTreeNode selectNode)
{
if (selectNode == null)
{
return;
}
// recurse first
foreach (AssetTreeNode tn in selectNode.Nodes)
{
DeleteNode(tn);
}
try
{
// now do me
if (selectNode.AssetNode != null)
{
// deal with the asset node
if (selectNode.AssetNode.IsAFile)
{
selectNode.AssetNode.AssetFilenameNode.fileNodes.Remove(selectNode.AssetNode);
if (this.assetTreeView != null)
{
this.assetTreeView.RebuildSubStructure(selectNode.AssetNode.AssetFilenameNode);
}
if (selectNode.AssetNode.AssetFilenameNode.fileNodes.Count == 0 && selectNode.AssetNode.AssetFilenameNode.TreeView != null)
{
selectNode.AssetNode.AssetFilenameNode.Remove();
}
}
else if (selectNode.AssetNode.IsAnAssetFilename && selectNode.AssetNode.fileNodes.Count == 0 && selectNode.AssetNode.TreeView != null)
{
selectNode.AssetNode.Remove();
}
else if (selectNode.AssetNode.IsAClassification && selectNode.AssetNode.Nodes.Count == 0 && selectNode.AssetNode.AutoGenerated && selectNode.AssetNode.TreeView != null)
{
selectNode.AssetNode.Remove();
}
}
selectNode.DiskNode.SelectedNode = null;
}
catch (Exception e)
{
MOG_Prompt.PromptResponse("Error", e.Message, e.StackTrace, MOGPromptButtons.OK, MOG_ALERT_LEVEL.CRITICAL);
}
}
private ArrayList GetSelectedRoots()
{
ArrayList selectedRoots = new ArrayList();
foreach (AssetTreeNode tn in this.SelectedNodes)
{
AssetTreeNode selectedRoot = FindSelectedRoot(tn);
if (!selectedRoots.Contains(selectedRoot))
{
selectedRoots.Add(selectedRoot);
}
}
return(selectedRoots);
}
private void tvDisk_AfterCollapse(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
if (!this.diskSelectedMirroringEnabled)
{
return;
}
AssetTreeNode tn = e.Node as AssetTreeNode;
if (tn != null && tn.SelectedNode != null)
{
tn.SelectedNode.EnsureVisible();
tn.SelectedNode.Collapse();
}
}
private AssetTreeNode FindSelectedRoot(AssetTreeNode tn)
{
if (!this.SelectedNodes.Contains(tn))
{
return(null);
}
AssetTreeNode selectedParent = tn;
while (selectedParent.Parent != null && selectedParent.Parent.IsSelected)
{
selectedParent = selectedParent.Parent as AssetTreeNode;
}
return(selectedParent);
}
private int CalculateRootInsertionIndex(AssetTreeNode diskRootNode, AssetTreeNode selectedRootNode)
{
DiskTreeView diskTV = diskRootNode.TreeView as DiskTreeView;
foreach (AssetTreeNode selNode in this.Nodes)
{
if (selNode.DiskNode != null)
{
if (diskRootNode.Index < selNode.DiskNode.Index)
{
return(selNode.Index);
}
}
}
return(-1);
}
public void RefreshTree(TreeNodeCollection nodes)
{
if (nodes != null)
{
this.Nodes.Clear();
foreach (AssetTreeNode tn in nodes)
{
AssetTreeNode newNode = EncodeDiskNodeToSelected(tn);
if (newNode != null)
{
this.Nodes.Add(newNode);
}
}
ExpandAll();
}
}
void Add(Asset resource, TreeNodeCollection nodes, Action<double> progressUpdateCallback, double percentOffset, double percentPart)
{
if (progressUpdateCallback != null)
progressUpdateCallback(percentOffset);
TreeNode node = new AssetTreeNode(resource);
nodes.Add(node);
if (resource is FolderAsset) {
if (resource.Children.Count == 1)
node.Expand();
double childPercentOffset = 0, childPercentPart = percentPart / resource.Children.Count;
foreach (Asset child in resource.Children) {
Add(child, node.Nodes, progressUpdateCallback, percentOffset + childPercentOffset, percentPart);
childPercentOffset += childPercentPart;
}
}
}
private void ShowUnplaced(AssetTreeNode targetNode)
{
// assume global unless instructed otherwise
TreeNodeCollection nodes = this.Nodes;
if (targetNode != null)
{
nodes = targetNode.Nodes;
}
foreach (AssetTreeNode tn in nodes)
{
if (tn.ForeColor == Color.Red)
{
tn.EnsureVisible();
}
// recurse
ShowUnplaced(tn);
}
}
public void RefreshColorStatusAboveNode(AssetTreeNode tn)
{
// unselect
if (this.SelectedNodes.Contains(tn))
{
this.SelectedNodes.Remove(tn);
}
// Check if we have a parent?
if (tn.Parent != null)
{
// Default the desired color to our node's color
Color desiredColor = tn.ForeColor;
// Check if we are not red?
if (desiredColor != Color.Red)
{
// Check if anybody is red?
foreach (AssetTreeNode subNode in tn.Nodes)
{
if (subNode.ForeColor == Color.Red)
{
// Indicate our new desired color is Red
desiredColor = Color.Red;
break;
}
}
}
// Check if our Parent needs a color change?
if (tn.Parent.ForeColor != desiredColor)
{
// Force our Parent to match our color
tn.Parent.ForeColor = desiredColor;
// Have our parent check their parent
RefreshColorStatusAboveNode(tn.Parent as AssetTreeNode);
}
}
}
private AssetTreeNode EncodeDiskNodeToSelected(AssetTreeNode tn)
{
if (!tn.Checked)
{
return(null);
}
AssetTreeNode newNode = new AssetTreeNode(tn.Text);
newNode.InSelectedTree = true;
newNode.ForeColor = Color.Red;
if (newNode.IsAFolder)
{
newNode.ImageIndex = CLOSEDFOLDER_INDEX;
newNode.SelectedImageIndex = CLOSEDFOLDER_INDEX;
}
else
{
newNode.ImageIndex = QUESTION_INDEX;
newNode.SelectedImageIndex = QUESTION_INDEX;
}
foreach (AssetTreeNode subNode in tn.Nodes)
{
TreeNode newSubNode = EncodeDiskNodeToSelected(subNode);
if (newSubNode != null)
{
newNode.Nodes.Add(newSubNode);
}
}
newNode.DiskNode = tn;
newNode.MasterNode = tn.MasterNode;
tn.SelectedNode = newNode;
return(newNode);
}
internal void RemoveNode(AssetTreeNode tn)
{
if (tn == null || tn.SelectedNode == null)
{
return;
}
AssetTreeNode selectedNode = tn.SelectedNode;
DeleteNode(selectedNode);
if (selectedNode.TreeView != null)
{
selectedNode.Remove();
}
// if (tn.SelectedNode != null && tn.SelectedNode.TreeView != null)
// {
// DeleteAssetNodes(tn);
// tn.SelectedNode.Remove();
// tn.SetSelectedNode_Recursive(null);
// }
}
private void tvDisk_AfterExpand(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
if (!this.diskSelectedMirroringEnabled)
{
return;
}
AssetTreeNode tn = e.Node as AssetTreeNode;
if (tn != null && tn.SelectedNode != null)
{
// JohnRen - Removed because this was seriously slowing down the importation of larger 100k+ file projects
// this.tvDisk.BeginUpdate();
// this.tvSelected.BeginUpdate();
Cursor.Current = Cursors.WaitCursor;
Application.DoEvents();
tn.SelectedNode.EnsureVisible();
tn.SelectedNode.Expand();
// Check if we are checked?
// JohnRen - Removed because this was seriously slowing down the importation of larger projects
// if (tn.Checked)
// {
// // Propagate the check down to this node's children
// foreach (AssetTreeNode subNode in tn.Nodes)
// {
// subNode.Checked = tn.Checked;
// }
// }
Cursor.Current = Cursors.Default;
// JohnRen - Removed because this was seriously slowing down the importation of larger 100k+ file projects
// this.tvDisk.EndUpdate();
// this.tvSelected.EndUpdate();
}
}
private AssetTreeNode EncodeDirectoryTree(string path)
{
if (Directory.Exists(path))
{
AssetTreeNode tn = new AssetTreeNode(Path.GetFileName(path));
tn.IsAFolder = true;
foreach (string subdirPath in Directory.GetDirectories(path))
{
tn.Nodes.Add(EncodeDirectoryTree(subdirPath));
}
foreach (string filePath in Directory.GetFiles(path))
{
AssetTreeNode fileNode = new AssetTreeNode(Path.GetFileName(filePath));
fileNode.IsAFile = true;
tn.Nodes.Add(fileNode);
}
return(tn);
}
return(null);
}
private void RefreshRedStatus(AssetTreeNode tn)
{
// unselect
if (this.SelectedNodes.Contains(tn))
{
this.SelectedNodes.Remove(tn);
}
foreach (AssetTreeNode subNode in tn.Nodes)
{
RefreshRedStatus(subNode);
}
if (tn.IsAFolder)
{
bool allGreen = true;
foreach (AssetTreeNode subNode in tn.Nodes)
{
if (subNode.ForeColor != Color.Green)
{
allGreen = false;
break;
}
}
if (allGreen)
{
tn.ForeColor = Color.Green;
}
else
{
tn.ForeColor = Color.Red;
}
}
}
private void FillInSubTree(AssetTreeNode selectNode)
{
AssetTreeNode diskNode = selectNode.DiskNode;
if (diskNode != null)
{
foreach (AssetTreeNode subDiskNode in diskNode.Nodes)
{
selectNode.Nodes.Add(ConvertDiskNode(subDiskNode));
}
foreach (AssetTreeNode subSelectNode in selectNode.Nodes)
{
FillInSubTree(subSelectNode);
}
if (diskNode.IsExpanded)
{
selectNode.Expand();
}
// else
// selectNode.Collapse();
}
}
public string FindCommonSyncTarget(AssetTreeNode classification)
{
bool bAssetFilenameExists = false;
bool bCommonSyncTargetExists = false;
string commonSyncTarget = "";
//Find out if we have at least one asset filename node in this tree
foreach (AssetTreeNode assetnode in classification.Nodes)
{
if (assetnode.IsAnAssetFilename)
{
bAssetFilenameExists = true;
break;
}
}
if (bAssetFilenameExists)
{
//There is at least one asset filename node, so let's see if they all share a sync target
commonSyncTarget = null;
bCommonSyncTargetExists = true;
foreach (AssetTreeNode assetnode in classification.Nodes)
{
if (!bCommonSyncTargetExists)
{
//There is no hope of findong a common sync target
break;
}
if (assetnode.IsAnAssetFilename)
{
//Check all the file nodes in the asset node
foreach (AssetTreeNode filenode in assetnode.fileNodes)
{
try
{
string testSyncTarget = Path.GetDirectoryName(filenode.FileFullPath);
if (commonSyncTarget != null)
{
if (String.Compare(testSyncTarget, commonSyncTarget, true) != 0)
{
//The sync target is different, no commonality, no fun, let's go
bCommonSyncTargetExists = false;
break;
}
}
commonSyncTarget = testSyncTarget;
}
catch
{
bCommonSyncTargetExists = false;
break;
}
}
}
}
}
if (bCommonSyncTargetExists)
{
//we got a common sync target!
return(commonSyncTarget);
}
else
{
//"" means there is nothing common
return("");
}
}
internal void NewNode(AssetTreeNode tn)
{
if (tn == null || tn.SelectedNode != null)
{
return;
}
AssetTreeNode newNode = ConvertDiskNode(tn);
AssetTreeNode parentNode = tn.Parent as AssetTreeNode;
AssetTreeNode curNode = newNode;
while (parentNode != null)
{
// if parentNode has a corresponding selected node in this treeview already
if (parentNode.SelectedNode != null)
{
// add curNode tree to it
parentNode.SelectedNode.Nodes.Add(curNode);
if (parentNode.IsExpanded)
{
parentNode.SelectedNode.Expand();
}
// else
// {
// parentNode.SelectedNode.Collapse();
// }
break;
}
else
{
// make new and chain up
parentNode.SelectedNode = ConvertDiskNode(parentNode);
parentNode.SelectedNode.Nodes.Add(curNode);
if (parentNode.IsExpanded)
{
parentNode.SelectedNode.Expand();
}
// else
// parentNode.SelectedNode.Collapse();
curNode = parentNode.SelectedNode;
parentNode = parentNode.Parent as AssetTreeNode;
}
}
// no parent node? just add it to the tree view itself
if (parentNode == null)
{
// insert it in the right place
int index = CalculateRootInsertionIndex(Utils.GetRootNode(tn) as AssetTreeNode, curNode);
if (index == -1)
{
this.Nodes.Add(curNode);
}
else
{
this.Nodes.Insert(index, curNode);
}
}
//FillInSubTree(newNode);
}
