Пример #1
0
        private static void DeleteSourceMediaFile(ResourceEventArgs deleteEvent)
        {
            if (deleteEvent.IsResource)
            {
                IList <string> mediaPaths = GetSourceMediaPaths(deleteEvent.Content.Res);
                for (int i = 0; i < mediaPaths.Count; i++)
                {
                    if (File.Exists(mediaPaths[i]))
                    {
                        RecycleBin.SendSilent(mediaPaths[i]);
                        PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(mediaPaths[i]), true);
                    }
                }
            }
            else if (deleteEvent.IsDirectory)
            {
                string mediaPath = Path.Combine(
                    EditorHelper.SourceMediaDirectory,
                    PathHelper.MakeFilePathRelative(deleteEvent.Path, DualityApp.DataDirectory));

                if (Directory.Exists(mediaPath))
                {
                    RecycleBin.SendSilent(mediaPath);
                    PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(mediaPath), true);
                }
            }
        }
Пример #2
0
        private static void DeleteSourceMediaFile(ResourceEventArgs deleteEvent)
        {
            // Determine which source/media path we're going to modify
            string mediaPath = null;

            if (deleteEvent.IsResource)
            {
                Resource res = deleteEvent.Content.Res;
                if (res != null && res.SourcePath != null)
                {
                    mediaPath = res.SourcePath;
                }
                if (!File.Exists(mediaPath))
                {
                    mediaPath = FileImportProvider.SelectSourceFilePath(deleteEvent.Content, Path.GetExtension(mediaPath));
                }
                if (!File.Exists(mediaPath))
                {
                    return;
                }
            }
            else if (deleteEvent.IsDirectory)
            {
                mediaPath = Path.Combine(EditorHelper.SourceMediaDirectory, PathHelper.MakeFilePathRelative(deleteEvent.Path, DualityApp.DataDirectory));
            }

            // Ignore stuff changes without data to modify
            if (mediaPath == null)
            {
                return;
            }

            // Remove now-unused media files
            if (deleteEvent.IsResource)
            {
                if (File.Exists(mediaPath))
                {
                    RecycleBin.SendSilent(mediaPath);
                    PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(mediaPath), true);
                }
            }
            else if (deleteEvent.IsDirectory)
            {
                if (Directory.Exists(mediaPath))
                {
                    RecycleBin.SendSilent(mediaPath);
                    PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(mediaPath), true);
                }
            }
        }
Пример #3
0
        private static void HandleDataDirEvents(FileEventQueue eventQueue)
        {
            // Gather a list of all externally modified resources that are currently loaded.
            // We'll use this to later tell the editor about the changes we've applied.
            List <Resource> modifiedLoadedResources = null;

            foreach (FileEvent fileEvent in eventQueue.Items)
            {
                if (fileEvent.IsDirectory)
                {
                    continue;
                }

                // We're only interested in the path where we would find the Resource right now,
                // because we need the instance for the change notification
                string contentPath            = (fileEvent.Type == FileEventType.Renamed) ? fileEvent.OldPath : fileEvent.Path;
                ContentRef <Resource> content = new ContentRef <Resource>(contentPath);

                // Some editor modules rely on change notifications to re-establish links to previously
                // removed Resources. In order to do that, we'll speculatively load newly arrived Resources
                // so we can put out a change notification for them.
                // Note: If ObjectSelection supported ContentRefs, we could improve and do that without the
                // speculative load, triggering a load only when someone was actually interested.
                if (content.IsLoaded || fileEvent.Type == FileEventType.Created)
                {
                    if (modifiedLoadedResources == null)
                    {
                        modifiedLoadedResources = new List <Resource>();
                    }
                    modifiedLoadedResources.Add(content.Res);
                }
            }

            // Handle each event according to its type
            List <FileEvent> renameEventBuffer         = null;
            HashSet <string> sourceMediaDeleteSchedule = null;

            foreach (FileEvent fileEvent in eventQueue.Items)
            {
                if (fileEvent.Type == FileEventType.Changed)
                {
                    HandleDataDirChangeEvent(fileEvent);
                }
                else if (fileEvent.Type == FileEventType.Deleted)
                {
                    HandleDataDirDeleteEvent(fileEvent, ref sourceMediaDeleteSchedule);
                }
                else if (fileEvent.Type == FileEventType.Renamed)
                {
                    HandleDataDirRenameEvent(fileEvent, ref renameEventBuffer);
                }
            }

            // If we scheduled source / media files for deletion, do it now at once
            if (sourceMediaDeleteSchedule != null)
            {
                // Gather a list of directories from which we're removing
                HashSet <string> affectedDirectories = new HashSet <string>();
                foreach (string file in sourceMediaDeleteSchedule)
                {
                    affectedDirectories.Add(Path.GetDirectoryName(file));
                }

                // Send all the files to the recycle bin
                RecycleBin.SendSilent(sourceMediaDeleteSchedule);

                // Remove directories that are now empty
                foreach (string dir in affectedDirectories)
                {
                    PathHelper.DeleteEmptyDirectory(dir, true);
                }
            }

            // If required, perform a global rename operation in all existing content
            if (renameEventBuffer != null)
            {
                // Don't do it now - schedule it for the main form event loop so we don't block here.
                DualityEditorApp.MainForm.BeginInvoke((Action) delegate() {
                    ProcessingBigTaskDialog taskDialog = new ProcessingBigTaskDialog(
                        Properties.GeneralRes.TaskRenameContentRefs_Caption,
                        Properties.GeneralRes.TaskRenameContentRefs_Desc,
                        async_RenameContentRefs, renameEventBuffer);
                    taskDialog.ShowDialog(DualityEditorApp.MainForm);
                });
            }

            // Notify the editor about externally modified resources
            if (modifiedLoadedResources != null)
            {
                DualityEditorApp.NotifyObjPropChanged(
                    null,
                    new ObjectSelection(modifiedLoadedResources),
                    false);
            }
        }
Пример #4
0
        private static void ProcessDataDirEvents()
        {
            List <ResourceRenamedEventArgs> renameEventBuffer = null;
            HashSet <string> sourceMediaDeleteSchedule        = null;

            // Process events
            while (dataDirEventBuffer.Count > 0)
            {
                FileSystemEventArgs e = FetchFileSystemEvent(dataDirEventBuffer, DualityApp.DataDirectory);
                if (e == null)
                {
                    continue;
                }

                // Determine whether we're dealing with a directory
                bool isDirectory = Directory.Exists(e.FullPath);
                {
                    // If this is a deletion, nothing exists anymore, rely on metadata instead.
                    DeletedEventArgsExt de = e as DeletedEventArgsExt;
                    if (de != null && de.IsDirectory)
                    {
                        isDirectory = true;
                    }
                }

                if (e.ChangeType == WatcherChangeTypes.Changed)
                {
                    // Ignore stuff saved by the editor itself
                    if (IsPathEditorModified(e.FullPath))
                    {
                        continue;
                    }

                    if (Resource.IsResourceFile(e.FullPath) || isDirectory)
                    {
                        ContentRef <Resource> resRef = new ContentRef <Resource>(null, e.FullPath);

                        // Unregister outdated resources, if modified outside the editor
                        if (!isDirectory && ContentProvider.HasContent(e.FullPath))
                        {
                            bool isCurrentScene = resRef.Is <Scene>() && Scene.Current == resRef.Res;
                            if (isCurrentScene || DualityEditorApp.IsResourceUnsaved(e.FullPath))
                            {
                                DialogResult result = MessageBox.Show(
                                    String.Format(Properties.GeneralRes.Msg_ConfirmReloadResource_Text, e.FullPath),
                                    Properties.GeneralRes.Msg_ConfirmReloadResource_Caption,
                                    MessageBoxButtons.YesNo,
                                    MessageBoxIcon.Exclamation);
                                if (result == DialogResult.Yes)
                                {
                                    string curScenePath = Scene.CurrentPath;
                                    ContentProvider.RemoveContent(e.FullPath);
                                    if (isCurrentScene)
                                    {
                                        Scene.SwitchTo(ContentProvider.RequestContent <Scene>(curScenePath), true);
                                    }
                                }
                            }
                            else
                            {
                                ContentProvider.RemoveContent(e.FullPath);
                            }
                        }

                        if (ResourceModified != null)
                        {
                            ResourceModified(null, new ResourceEventArgs(e.FullPath, isDirectory));
                        }
                    }
                }
                else if (e.ChangeType == WatcherChangeTypes.Created)
                {
                    if (File.Exists(e.FullPath))
                    {
                        // Register newly detected Resource file
                        if (Resource.IsResourceFile(e.FullPath))
                        {
                            if (ResourceCreated != null)
                            {
                                ResourceCreated(null, new ResourceEventArgs(e.FullPath, false));
                            }
                        }
                    }
                    else if (Directory.Exists(e.FullPath))
                    {
                        // Register newly detected Resource directory
                        if (ResourceCreated != null)
                        {
                            ResourceCreated(null, new ResourceEventArgs(e.FullPath, true));
                        }
                    }
                }
                else if (e.ChangeType == WatcherChangeTypes.Deleted)
                {
                    // Is it a Resource file or just something else?
                    if (Resource.IsResourceFile(e.FullPath) || isDirectory)
                    {
                        ResourceEventArgs args = new ResourceEventArgs(e.FullPath, isDirectory);

                        // Schedule Source/Media file deletion to keep it organized / synced with Resource Data
                        if (sourceMediaDeleteSchedule == null)
                        {
                            sourceMediaDeleteSchedule = new HashSet <string>();
                        }
                        GetDeleteSourceMediaFilePaths(args, sourceMediaDeleteSchedule);

                        // Unregister no-more existing resources
                        if (isDirectory)
                        {
                            ContentProvider.RemoveContentTree(args.Path);
                        }
                        else
                        {
                            ContentProvider.RemoveContent(args.Path);
                        }

                        if (ResourceDeleted != null)
                        {
                            ResourceDeleted(null, args);
                        }
                    }
                }
                else if (e.ChangeType == WatcherChangeTypes.Renamed)
                {
                    // Is it a Resource file or just something else?
                    RenamedEventArgs         re   = e as RenamedEventArgs;
                    ResourceRenamedEventArgs args = new ResourceRenamedEventArgs(re.FullPath, re.OldFullPath, isDirectory);
                    if (Resource.IsResourceFile(e.FullPath) || isDirectory)
                    {
                        // Determine which Source / Media files would belong to this Resource - before moving it
                        string[] oldMediaPaths = PreMoveSourceMediaFile(args);;

                        // Rename content registerations
                        if (isDirectory)
                        {
                            ContentProvider.RenameContentTree(args.OldPath, args.Path);
                        }
                        else
                        {
                            ContentProvider.RenameContent(args.OldPath, args.Path);
                        }

                        // Query skipped paths
                        bool isEmptyDir    = isDirectory && !Directory.EnumerateFileSystemEntries(args.Path).Any();
                        bool isSkippedPath = isEmptyDir;
                        if (!isSkippedPath && BeginGlobalRename != null)
                        {
                            BeginGlobalRenameEventArgs beginGlobalRenameArgs = new BeginGlobalRenameEventArgs(args.Path, args.OldPath, isDirectory);
                            BeginGlobalRename(null, beginGlobalRenameArgs);
                            isSkippedPath = beginGlobalRenameArgs.Cancel;
                        }

                        if (!isSkippedPath)
                        {
                            // Buffer rename event to perform the global rename for all at once.
                            if (renameEventBuffer == null)
                            {
                                renameEventBuffer = new List <ResourceRenamedEventArgs>();
                            }
                            renameEventBuffer.Add(args);
                        }

                        if (ResourceRenamed != null)
                        {
                            ResourceRenamed(null, args);
                        }

                        if (!isSkippedPath)
                        {
                            // Organize the Source/Media directory accordingly
                            MoveSourceMediaFile(args, oldMediaPaths);
                        }
                    }
                }
            }

            // If we scheduled source / media files for deletion, do it now at once
            if (sourceMediaDeleteSchedule != null)
            {
                // Gather a list of directories from which we're removing
                HashSet <string> affectedDirectories = new HashSet <string>();
                foreach (string file in sourceMediaDeleteSchedule)
                {
                    affectedDirectories.Add(Path.GetDirectoryName(file));
                }

                // Send all the files to the recycle bin
                RecycleBin.SendSilent(sourceMediaDeleteSchedule);

                // Remove directories that are now empty
                foreach (string dir in affectedDirectories)
                {
                    PathHelper.DeleteEmptyDirectory(dir, true);
                }
            }

            // If required, perform a global rename operation in all existing content
            if (renameEventBuffer != null)
            {
                // Don't do it now - schedule it for the main form event loop so we don't block here.
                DualityEditorApp.MainForm.BeginInvoke((Action) delegate() {
                    ProcessingBigTaskDialog taskDialog = new ProcessingBigTaskDialog(
                        Properties.GeneralRes.TaskRenameContentRefs_Caption,
                        Properties.GeneralRes.TaskRenameContentRefs_Desc,
                        async_RenameContentRefs, renameEventBuffer);
                    taskDialog.ShowDialog(DualityEditorApp.MainForm);
                });
            }
        }