public static TreeNode MoveEntityOn(EntityTreeNode treeNodeMoving, TreeNode targetNode)
{
TreeNode newTreeNode = null;
#region Moving the Entity into (or out of) a directory
if (targetNode.IsDirectoryNode() || targetNode.IsRootEntityNode())
{
MoveEntityToDirectory(treeNodeMoving, targetNode);
}
#endregion
#region Moving an Entity onto another element to create an instance
else if (targetNode.IsEntityNode() || targetNode.IsScreenNode() || targetNode.IsRootNamedObjectNode())
{
bool isValidDrop = true;
// Make sure that we don't drop an Entity into its own Objects
if (targetNode.IsRootNamedObjectNode())
{
if(treeNodeMoving == targetNode.GetContainingElementTreeNode())
{
isValidDrop = false;
}
}
if (isValidDrop)
{
newTreeNode = MoveEntityOntoElement(treeNodeMoving, targetNode, newTreeNode);
}
}
#endregion
#region Moving an Entity onto a NamedObject (currently supports only Lists)
else if (targetNode.IsNamedObjectNode())
{
// Allow drop only if it's a list or Layer
NamedObjectSave targetNamedObjectSave = targetNode.Tag as NamedObjectSave;
if (!targetNamedObjectSave.IsList && !targetNamedObjectSave.IsLayer)
{
MessageBox.Show("The target is not a List or Layer so we can't add an Object to it.", "Target not valid");
}
if (targetNamedObjectSave.IsLayer)
{
TreeNode parent = targetNode.Parent;
newTreeNode = MoveEntityOn(treeNodeMoving, parent);
// this created a new NamedObjectSave. Let's put that on the Layer
MoveNamedObject(newTreeNode, targetNode);
}
else
{
// Make sure that the two types match
string listType = targetNamedObjectSave.SourceClassGenericType;
if (listType != treeNodeMoving.EntitySave.Name)
{
MessageBox.Show("The target list type is of type\n\n" +
listType +
"\n\nBut the Entity is of type\n\n" +
treeNodeMoving.EntitySave.Name +
"\n\nCould not add an instance to the list", "Could not add instance");
}
else
{
NamedObjectSave namedObject = new NamedObjectSave();
namedObject.InstanceName =
FileManager.RemovePath(listType) + "1";
StringFunctions.MakeNameUnique<NamedObjectSave>(
namedObject, targetNamedObjectSave.ContainedObjects);
// Not sure if we need to set this or not, but I think
// any instance added to a list will not be defined by base
namedObject.DefinedByBase = false;
NamedObjectSaveExtensionMethodsGlue.AddNamedObjectToCurrentNamedObjectList(namedObject);
ElementViewWindow.GenerateSelectedElementCode();
// Don't save the Glux, the caller of this method will take care of it
// GluxCommands.Self.SaveGlux();
}
}
}
#endregion
else if (targetNode.IsGlobalContentContainerNode())
{
AskAndAddAllContainedRfsToGlobalContent(treeNodeMoving.SaveObjectAsElement);
}
return newTreeNode;
}
private static void MoveNamedObject(TreeNode treeNodeMoving, TreeNode targetNode)
{
if (targetNode != null)
{
NamedObjectSave targetNos = targetNode.Tag as NamedObjectSave;
NamedObjectSave movingNos = treeNodeMoving.Tag as NamedObjectSave;
bool succeeded = false;
if (targetNode == null)
{
// Didn't move on to anything
}
else if (targetNode.IsRootNamedObjectNode())
{
succeeded = MoveObjectOnObjectsRoot(treeNodeMoving, targetNode, movingNos, succeeded);
}
else if (targetNode.IsRootCustomVariablesNode())
{
MoveObjectOnRootCustomVariablesNode(treeNodeMoving, targetNode);
}
else if (targetNode.Tag is IElement)
{
succeeded = DragDropNosIntoElement(movingNos, targetNode.Tag as IElement);
}
else if (targetNode.IsRootEventsNode())
{
succeeded = DragDropNosOnRootEventsNode(treeNodeMoving, targetNode);
}
else if (targetNos != null && targetNos.SourceType == SourceType.FlatRedBallType)
{
string targetClassType = targetNos.SourceClassType;
#region Failure cases
if (string.IsNullOrEmpty(targetClassType))
{
MessageBox.Show("The target Object does not have a defined type. This operation is not valid");
}
#endregion
#region Moving on to a Layer
else if (targetClassType == "Layer")
{
// Only allow this if the NOS's are on the same object
if (ObjectFinder.Self.GetElementContaining(movingNos) ==
ObjectFinder.Self.GetElementContaining(targetNos))
{
succeeded = true;
movingNos.LayerOn = targetNos.InstanceName;
MainGlueWindow.Self.PropertyGrid.Refresh();
}
}
#endregion
#region Moving on to a PositionedObjectList
else if (targetClassType == "PositionedObjectList<T>")
{
succeeded = HandleDropOnList(treeNodeMoving, targetNode, targetNos, movingNos);
}
#endregion
}
else
{
MessageBox.Show("Invalid movement");
}
if (succeeded)
{
if (EditorLogic.CurrentElement != null)
{
ElementViewWindow.GenerateSelectedElementCode();
}
else
{
ContentLoadWriter.UpdateLoadGlobalContentCode();
}
ProjectManager.SaveProjects();
GluxCommands.Self.SaveGlux();
}
}
}
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.IsRootNamedObjectNode())
{
AddObjectViewModel viewModel = new AddObjectViewModel();
viewModel.SourceType = SourceType.File;
viewModel.SourceFile = (treeNodeMoving.Tag as ReferencedFileSave).Name;
GlueCommands.Self.DialogCommands.ShowAddNewObjectDialog(viewModel);
}
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);
}
}
}
private static TreeNode MoveEntityOntoElement(EntityTreeNode treeNodeMoving, TreeNode targetNode, TreeNode newTreeNode)
{
EntitySave entitySaveMoved = treeNodeMoving.EntitySave;
#region Get the IElement elementToCreateIn
IElement elementToCreateIn = null;
if (targetNode.IsRootNamedObjectNode())
{
BaseElementTreeNode baseElementTreeNode = targetNode.Parent as BaseElementTreeNode;
elementToCreateIn = baseElementTreeNode.SaveObjectAsElement;
}
else
{
elementToCreateIn = ((BaseElementTreeNode)targetNode).SaveObjectAsElement;
}
#endregion
DialogResult result =
MessageBox.Show("Create a new Object in\n\n" + elementToCreateIn.Name + "\n\nusing\n\n\t" + entitySaveMoved.Name + "?", "Create new Object?", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
NamedObjectSave newNamedObject = CreateNewNamedObjectInElement(elementToCreateIn, entitySaveMoved);
newTreeNode = GlueState.Self.Find.NamedObjectTreeNode(newNamedObject);
}
return newTreeNode;
}
private static TreeNode MoveEntityOntoElement(EntityTreeNode treeNodeMoving, TreeNode targetNode, TreeNode newTreeNode)
{
EntitySave entitySaveMoved = treeNodeMoving.EntitySave;
#region Get the IElement elementToCreateIn
IElement elementToCreateIn = null;
if (targetNode.IsRootNamedObjectNode())
{
BaseElementTreeNode baseElementTreeNode = targetNode.Parent as BaseElementTreeNode;
elementToCreateIn = baseElementTreeNode.SaveObjectAsElement;
}
else
{
elementToCreateIn = ((BaseElementTreeNode)targetNode).SaveObjectAsElement;
}
#endregion
// We used to ask the user if they're sure, but this isn't a destructive action so just do it:
//DialogResult result =
// MessageBox.Show("Create a new Object in\n\n" + elementToCreateIn.Name + "\n\nusing\n\n\t" + entitySaveMoved.Name + "?", "Create new Object?", MessageBoxButtons.YesNo);
NamedObjectSave newNamedObject = CreateNewNamedObjectInElement(elementToCreateIn, entitySaveMoved);
newTreeNode = GlueState.Self.Find.NamedObjectTreeNode(newNamedObject);
return newTreeNode;
}
