UpdateChangedElements() public static method

public static UpdateChangedElements ( ) : void
return void
示例#1
0
        private static void MoveReferencedFile(TreeNode treeNodeMoving, TreeNode targetNode)
        {
            var response = GeneralResponse.SuccessfulResponse;

            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.IsFilesContainerNode() &&
                !targetNode.IsFolderInFilesContainerNode() &&
                !targetNode.IsFolderForGlobalContentFiles() &&
                !targetNode.IsNamedObjectNode() &&
                !targetNode.IsRootNamedObjectNode())
            {
                response.Fail(@"Can't drop this file here");
            }
            else if (!string.IsNullOrEmpty(referencedFileSave.SourceFile) ||
                     referencedFileSave.SourceFileCache.Count != 0)
            {
                response.Fail("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.");
            }

            if (response.Succeeded)
            {
                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.IsNamedObjectNode() &&
                         // dropping on an object in the same element
                         targetNode.GetContainingElementTreeNode() == treeNodeMoving.GetContainingElementTreeNode())
                {
                    response = HandleDroppingFileOnObjectInSameElement(targetNode, referencedFileSave);
                }

                //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())
                        {
                            response.Message = "Shared files cannot be added to subfolders, so it will be added directly to \"Files\"";
                        }

                        elementDroppingIn = elementTreeNodeDroppingIn.Tag as IElement;
                    }

                    if (container != elementDroppingIn)
                    {
                        // Make sure the target element is not named the same as the file itself.
                        // For example, dropping a file called Level1.tmx in a screen called Level1.
                        // This will not compile so we shouldn't allow it.

                        var areNamedTheSame = elementDroppingIn.GetStrippedName() == referencedFileSave.GetInstanceName();

                        if (areNamedTheSame)
                        {
                            response.Fail($"The file {referencedFileSave.GetInstanceName()} has the same name as the target screen. it will not be added since this is not allowed.");
                        }

                        if (response.Succeeded)
                        {
                            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);
                    }
                }
            }

            if (!string.IsNullOrEmpty(response.Message))
            {
                MessageBox.Show(response.Message);
            }
        }