private static void RemoveGlobalContentTreeNodesIfNecessary(TreeNode treeNode)
{
if (treeNode.IsDirectoryNode())
{
string directory = treeNode.GetRelativePath();
directory = ProjectManager.MakeAbsolute(directory, true);
if (!Directory.Exists(directory))
{
// The directory isn't here anymore, so kill it!
treeNode.Parent.Nodes.Remove(treeNode);
}
else
{
// The directory is valid, but let's check subdirectories
for (int i = treeNode.Nodes.Count - 1; i > -1; i--)
{
RemoveGlobalContentTreeNodesIfNecessary(treeNode.Nodes[i]);
}
}
}
else // assume content for now
{
ReferencedFileSave referencedFileSave = treeNode.Tag as ReferencedFileSave;
if (!ProjectManager.GlueProjectSave.GlobalFiles.Contains(referencedFileSave))
{
treeNode.Parent.Nodes.Remove(treeNode);
}
else
{
// The RFS may be contained, but see if the file names match
string rfsName = FileManager.Standardize(referencedFileSave.Name, null, false).ToLower();
string treeNodeFile = FileManager.Standardize(treeNode.GetRelativePath(), null, false).ToLower();
// We first need to make sure that the file is part of GlobalContentFiles.
// If it is, then we may have tree node in the wrong folder, so let's get rid
// of it. If it doesn't start with globalcontent/ then we shouldn't remove it here.
if (rfsName.StartsWith("globalcontent/") && rfsName != treeNodeFile)
{
treeNode.Parent.Nodes.Remove(treeNode);
}
}
}
}
public void AddDirectory(string folderName, TreeNode treeNodeToAddTo)
{
if (treeNodeToAddTo.IsGlobalContentContainerNode())
{
string rootDirectory = FileManager.RelativeDirectory;
if (ProjectManager.ContentProject != null)
{
rootDirectory = ProjectManager.ContentProject.Directory;
}
string directory = rootDirectory + "GlobalContent/" + folderName;
Directory.CreateDirectory(directory);
}
else if (treeNodeToAddTo.IsRootEntityNode())
{
string directory = FileManager.RelativeDirectory + "Entities/" +
folderName;
Directory.CreateDirectory(directory);
}
else if (treeNodeToAddTo.IsDirectoryNode())
{
// This used to use RelativeDirectory, but
// I think we want this to be content, so not
// sure why it uses RelativeDirectory...
//string directory = FileManager.RelativeDirectory +
// currentTreeNode.GetRelativePath() +
// tiw.Result;
// Update October 16, 2011
// An Enity has both folders
// in the code folder (represented
// by RelativeDirectory) as well as
// in the Content project. An Entity
// may not have files in the Content folder,
// but it must have code files. Therefore, we
// create folders in the code directory tree and
// we worry about content when NamedObjectSaves are
// added to a given Entity later.
//string directory = currentTreeNode.GetRelativePath() +
// tiw.Result;
// Update February 17, 2012
// But...when we add a new folder
// to an Entity, we want that folder
// to show up in the tree view in Glue.
// Glue only scans the content folder, so
// we want to make sure this folder exists
// so it shows up okay.
string directory = FileManager.RelativeDirectory +
treeNodeToAddTo.GetRelativePath() +
folderName;
directory = ProjectManager.MakeAbsolute(directory, true);
Directory.CreateDirectory(directory);
directory = ProjectManager.ContentDirectory +
treeNodeToAddTo.GetRelativePath() +
folderName;
directory = ProjectManager.MakeAbsolute(directory, true);
Directory.CreateDirectory(directory);
}
else if (treeNodeToAddTo.IsFilesContainerNode() || treeNodeToAddTo.IsFolderInFilesContainerNode())
{
string directory =
treeNodeToAddTo.GetRelativePath() + folderName;
Directory.CreateDirectory(ProjectManager.MakeAbsolute(directory, true));
if (EditorLogic.CurrentEntityTreeNode != null)
{
EditorLogic.CurrentEntityTreeNode.UpdateReferencedTreeNodes();
}
else if (EditorLogic.CurrentScreenTreeNode != null)
{
EditorLogic.CurrentScreenTreeNode.UpdateReferencedTreeNodes();
}
}
else if (treeNodeToAddTo.IsFolderInFilesContainerNode())
{
throw new NotImplementedException();
}
var containingElementNode = treeNodeToAddTo.GetContainingElementTreeNode();
IElement element = null;
if (containingElementNode != null)
{
element = containingElementNode.Tag as IElement;
}
if (containingElementNode == null)
{
GlueCommands.Self.RefreshCommands.RefreshGlobalContent();
}
else
{
GlueCommands.Self.RefreshCommands.RefreshUi(element);
}
GlueCommands.Self.RefreshCommands.RefreshDirectoryTreeNodes();
}
private static void MoveReferencedFile(TreeNode treeNodeMoving, TreeNode targetNode)
{
while (targetNode != null && targetNode.IsReferencedFile
())
{
targetNode = targetNode.Parent;
}
// If the user drops a file on a Screen or Entity, let's allow them to
// complete the operation on the Files node
if (targetNode is BaseElementTreeNode)
{
targetNode = ((BaseElementTreeNode)targetNode).FilesTreeNode;
}
ReferencedFileSave referencedFileSave = treeNodeMoving.Tag as ReferencedFileSave;
if (targetNode.IsGlobalContentContainerNode())
{
if (targetNode.GetContainingElementTreeNode() == null)
{
string targetDirectory = ProjectManager.MakeAbsolute(targetNode.GetRelativePath(), true);
MoveReferencedFileToDirectory(referencedFileSave, targetDirectory);
}
else
{
DragAddFileToGlobalContent(treeNodeMoving, referencedFileSave);
// This means the user wants to add the file
// to global content.
}
}
else if (targetNode.IsFolderForGlobalContentFiles())
{
string targetDirectory = ProjectManager.MakeAbsolute(targetNode.GetRelativePath(), true);
MoveReferencedFileToDirectory(referencedFileSave, targetDirectory);
}
else if (!targetNode.IsFilesContainerNode() &&
!targetNode.IsFolderInFilesContainerNode() &&
!targetNode.IsFolderForGlobalContentFiles())
{
MessageBox.Show(@"Can't drop this file here");
return;
}
else if (!string.IsNullOrEmpty(referencedFileSave.SourceFile) ||
referencedFileSave.SourceFileCache.Count != 0)
{
MessageBox.Show("Can't move the file\n\n" + referencedFileSave.Name + "\n\nbecause it has source-referencing files. These sources will be broken " +
"if the file is moved. You will need to manually move the file, modify the source references, remove this file, then add the newly-created file.");
return;
}
//if (targetNode.IsFolderInFilesContainerNode() || targetNode.IsFilesContainerNode())
else
{
// See if we're moving the RFS from one Element to another
IElement container = ObjectFinder.Self.GetElementContaining(referencedFileSave);
TreeNode elementTreeNodeDroppingIn = targetNode.GetContainingElementTreeNode();
IElement elementDroppingIn = null;
if (elementTreeNodeDroppingIn != null)
{
// User didn't drop on an entity, but instead on a node within the entity.
// Let's check if it's a subfolder. If so, we need to tell the user that we
// can't add the file in a subfolder.
if (targetNode.IsFolderInFilesContainerNode())
{
MessageBox.Show("Shared files cannot be added to subfolders, so it will be added directly to \"Files\"");
}
elementDroppingIn = elementTreeNodeDroppingIn.Tag as IElement;
}
if (container != elementDroppingIn)
{
ElementViewWindow.SelectedNode = targetNode;
string absoluteFileName = ProjectManager.MakeAbsolute(referencedFileSave.Name, true);
string creationReport;
string errorMessage;
var newlyCreatedFile = ElementCommands.Self.CreateReferencedFileSaveForExistingFile(elementDroppingIn, null, absoluteFileName,
PromptHandleEnum.Prompt,
referencedFileSave.GetAssetTypeInfo(),
out creationReport,
out errorMessage);
ElementViewWindow.UpdateChangedElements();
if (!String.IsNullOrEmpty(errorMessage))
{
MessageBox.Show(errorMessage);
}
else if(newlyCreatedFile != null)
{
GlueCommands.Self.TreeNodeCommands.SelectTreeNode(newlyCreatedFile);
}
}
else
{
// Not moving into or out of an element
string targetDirectory = ProjectManager.MakeAbsolute(targetNode.GetRelativePath(), true);
MoveReferencedFileToDirectory(referencedFileSave, targetDirectory);
}
}
}
static void MoveEntityToDirectory(EntityTreeNode treeNodeMoving, TreeNode targetNode)
{
bool succeeded = true;
// Things to do:
// 1 Move the TreeNode from one parent TreeNode to another
// 2 Move the .cs and .generated.cs file from one folder to another
// 3 Remove the BuildItems from the project and add them back in in the VisualStudio project
// 4 Change the EntitySave's name
// 5 Change namespaces
// 6 Find all NamedObjectSaves that are use this Entity and re-generate the Elements, and also see if anything uses it as a base
// 7 Save everything!
EntitySave entitySave = treeNodeMoving.EntitySave;
string targetDirectory = FileManager.RelativeDirectory + targetNode.GetRelativePath();
string oldName = entitySave.Name;
string newName = targetNode.GetRelativePath().Replace("/", "\\") + entitySave.ClassName;
succeeded = MoveEntityCodeFilesToDirectory(entitySave, targetDirectory);
if (succeeded)
{
// 1: Move it from one node to another
treeNodeMoving.Parent.Nodes.Remove(treeNodeMoving);
targetNode.Nodes.Add(treeNodeMoving);
// 2: Move the .cs files
// Also handled above.
treeNodeMoving.GeneratedCodeFile = newName + ".Generated.cs";
treeNodeMoving.CodeFile = newName + ".cs";
}
if(succeeded)
{
// 4: Change the Entity's name
entitySave.Name = newName;
treeNodeMoving.Text = FileManager.RemovePath(newName);
}
if (succeeded)
{
// Do this after changing the name of the Entity so
// namespaces come over properly
succeeded = UpdateNamespaceOnCodeFiles(entitySave);
}
if(succeeded)
{
// 5: Change namespaces
string newNamespace = ProjectManager.ProjectNamespace + "." + FileManager.MakeRelative(targetDirectory).Replace("/", ".");
newNamespace = newNamespace.Substring(0, newNamespace.Length - 1);
string customFileContents = FileManager.FromFileText(FileManager.RelativeDirectory + newName + ".cs");
customFileContents = CodeWriter.ReplaceNamespace(customFileContents, newNamespace);
FileManager.SaveText(customFileContents, FileManager.RelativeDirectory + newName + ".cs");
// Generated will automatically have its namespace changed when it is re-generated
// 6: Find all objects referending this NamedObjectSave and re-generate the code
if (entitySave.CreatedByOtherEntities)
{
// Vic says: I'm tired. For now just ignore the directory. Fix this when it becomes a problem.
FactoryCodeGenerator.UpdateFactoryClass(entitySave);
}
List<NamedObjectSave> namedObjects = ObjectFinder.Self.GetAllNamedObjectsThatUseEntity(oldName);
// Let's get all the TreeNodes to regenerate.
// We want to store them in a list so we only generate
// each tree node once.
List<BaseElementTreeNode> treeNodesForElementsToRegenerate = new List<BaseElementTreeNode>();
foreach (NamedObjectSave nos in namedObjects)
{
if (nos.SourceClassGenericType == oldName)
{
nos.SourceClassGenericType = newName;
}
if (nos.SourceClassType == oldName)
{
nos.SourceClassType = newName;
}
IElement element = nos.GetContainer();
BaseElementTreeNode treeNode = GlueState.Self.Find.ElementTreeNode(element);
if (!treeNodesForElementsToRegenerate.Contains(treeNode))
{
treeNodesForElementsToRegenerate.Add(treeNode);
}
}
foreach (EntitySave esToTestForInheritance in ProjectManager.GlueProjectSave.Entities)
{
if (esToTestForInheritance.BaseEntity == oldName)
{
esToTestForInheritance.BaseEntity = newName;
BaseElementTreeNode treeNode = GlueState.Self.Find.EntityTreeNode(esToTestForInheritance);
if (!treeNodesForElementsToRegenerate.Contains(treeNode))
{
treeNodesForElementsToRegenerate.Add(treeNode);
}
}
}
foreach (BaseElementTreeNode treeNode in treeNodesForElementsToRegenerate)
{
CodeWriter.GenerateCode(treeNode.SaveObjectAsElement);
}
// 7: Save it!
ProjectLoader.Self.MakeGeneratedItemsNested();
CodeWriter.GenerateCode(treeNodeMoving.SaveObjectAsElement);
GluxCommands.Self.SaveGlux();
ProjectManager.SaveProjects();
}
}
static void MoveEntityToDirectory(EntityTreeNode treeNodeMoving, TreeNode targetNode)
{
bool succeeded = true;
EntitySave entitySave = treeNodeMoving.EntitySave;
string newRelativeDirectory = targetNode.GetRelativePath();
string newName = newRelativeDirectory.Replace("/", "\\") + entitySave.ClassName;
// modify data and files
succeeded = GlueCommands.Self.GluxCommands.MoveEntityToDirectory(entitySave, newRelativeDirectory);
// adjust the UI
if (succeeded)
{
treeNodeMoving.Parent.Nodes.Remove(treeNodeMoving);
targetNode.Nodes.Add(treeNodeMoving);
treeNodeMoving.GeneratedCodeFile = newName + ".Generated.cs";
treeNodeMoving.CodeFile = newName + ".cs";
treeNodeMoving.Text = FileManager.RemovePath(newName);
}
// Generate and save
if (succeeded)
{
// 7: Save it!
ProjectLoader.Self.MakeGeneratedItemsNested();
CodeWriter.GenerateCode(entitySave);
GluxCommands.Self.SaveGlux();
ProjectManager.SaveProjects();
GlueState.Self.CurrentElement = entitySave;
}
}
private void AddDirectoryNodesRecursively(string currentDirectory, TreeNode treeNode)
{
if (System.IO.Directory.Exists(currentDirectory))
{
string[] directories = System.IO.Directory.GetDirectories(currentDirectory);
#region Add new nodes
foreach (string directory in directories)
{
if (!ElementViewWindow.DirectoriesToIgnore.Contains(FileManager.RemovePath(directory)))
{
bool alreadyHasNode = false;
// See if there is already a tree node with this name
string directoryRelativeToThisTreeNode = FileManager.MakeRelative(
directory, ProjectManager.MakeAbsolute(treeNode.GetRelativePath(), true)) + "/";
TreeNode existingTreeNode = GetNodeForDirectory(directoryRelativeToThisTreeNode, treeNode);
if (existingTreeNode == null)
{
TreeNode newNode = new TreeNode(FileManager.RemovePath(directory));
newNode.ForeColor = ElementViewWindow.FolderColor;
if (BaseElementTreeNode.UseIcons)
{
newNode.ImageKey = "folder.png";
newNode.SelectedImageKey = "folder.png";
}
treeNode.Nodes.Add(newNode);
}
}
}
#endregion
foreach (TreeNode subNode in treeNode.Nodes)
{
if (subNode.IsFolderInFilesContainerNode())
{
string subDirectory = subNode.GetRelativePath();
subDirectory = ProjectManager.MakeAbsolute(subDirectory, true);
AddDirectoryNodesRecursively(subDirectory, subNode);
}
}
}
}
private TreeNode GetNodeForDirectory(string directory, TreeNode currentNode)
{
if (string.IsNullOrEmpty(directory))
{
return currentNode;
}
if (currentNode.IsFilesContainerNode())
{
string currentNodeDirectory = FileManager.Standardize(currentNode.GetRelativePath(), null, false);
directory = FileManager.Standardize(directory, null, false);
if (directory.StartsWith(currentNodeDirectory))
{
directory = directory.Substring(currentNodeDirectory.Length);
}
}
int indexOfSlash = directory.IndexOf("/");
if (string.IsNullOrEmpty(directory))
{
return this;
}
else
{
string nameToSearchFor = directory.Substring(0, indexOfSlash);
for (int i = 0; i < currentNode.Nodes.Count; i++)
{
TreeNode subNode = currentNode.Nodes[i];
if (subNode.Text == nameToSearchFor && subNode.IsFolderInFilesContainerNode())
{
return GetNodeForDirectory(directory.Substring(indexOfSlash + 1), subNode);
}
}
return null;
}
}