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);
}
}
}
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);
}
}
}
private static void MoveSourceMediaFile(ResourceRenamedEventArgs renameEvent, string[] oldMediaPaths)
{
if (renameEvent.IsResource)
{
string[] newMediaPaths = GetSourceMediaPaths(renameEvent.Content.Res);
for (int i = 0; i < oldMediaPaths.Length; i++)
{
string oldPath = oldMediaPaths[i];
string newPath = newMediaPaths.Length > i ? newMediaPaths[i] : oldPath;
// Move the media file to mirror the data files movement
if (!PathOp.ArePathsEqual(oldPath, newPath))
{
if (File.Exists(oldPath) && !File.Exists(newPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(newPath));
File.Move(oldPath, newPath);
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(oldPath), true);
}
}
}
}
else if (renameEvent.IsDirectory)
{
// Determine which source/media directory we're going to move
string oldMediaPath = Path.Combine(
EditorHelper.SourceMediaDirectory,
PathHelper.MakeFilePathRelative(renameEvent.OldPath, DualityApp.DataDirectory));
// Determine where that old source/media directory needs to be moved
string newMediaPath = Path.Combine(
EditorHelper.SourceMediaDirectory,
PathHelper.MakeFilePathRelative(renameEvent.Path, DualityApp.DataDirectory));
// Move the media directory to mirror the data directories movement
if (!PathOp.ArePathsEqual(newMediaPath, oldMediaPath))
{
if (Directory.Exists(oldMediaPath) && !Directory.Exists(newMediaPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(newMediaPath));
Directory.Move(oldMediaPath, newMediaPath);
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(oldMediaPath), true);
}
}
}
}
private static void MoveSourceMediaFile(ResourceRenamedEventArgs renameEvent)
{
// Determine which source/media path we're going to modify
string oldMediaPath = null;
string mediaPath = null;
if (renameEvent.IsResource)
{
Resource res = renameEvent.Content.Res;
if (res.SourcePath != null)
{
mediaPath = res.SourcePath;
}
if (!File.Exists(mediaPath))
{
mediaPath = FileImportProvider.SelectSourceFilePath(renameEvent.OldContent, Path.GetExtension(mediaPath));
}
if (!File.Exists(mediaPath))
{
return;
}
}
else if (renameEvent.IsDirectory)
{
mediaPath = Path.Combine(EditorHelper.SourceMediaDirectory, PathHelper.MakeFilePathRelative(renameEvent.OldPath, DualityApp.DataDirectory));
}
oldMediaPath = mediaPath;
// Ignore stuff changes without data to modify
if (mediaPath == null)
{
return;
}
// If media and data file were located in a similar folder structure, keep that structure
{
string relativeMediaPath = PathHelper.MakeFilePathRelative(mediaPath, EditorHelper.SourceMediaDirectory);
string relativeOldDataPath = PathHelper.MakeFilePathRelative(renameEvent.OldPath, DualityApp.DataDirectory);
string relativeMediaDir = Path.GetDirectoryName(relativeMediaPath);
string relativeOldDataDir = Path.GetDirectoryName(relativeOldDataPath);
if (PathHelper.ArePathsEqual(relativeMediaDir, relativeOldDataDir))
{
string relativeNewDataDir = Path.GetDirectoryName(PathHelper.MakeFilePathRelative(renameEvent.Path, DualityApp.DataDirectory));
string newMediaDir = Path.Combine(EditorHelper.SourceMediaDirectory, relativeNewDataDir);
mediaPath = Path.Combine(newMediaDir, Path.GetFileName(mediaPath));
}
}
// If media and data file were named similarly, keep that naming scheme
if (!PathHelper.ArePathsEqual(Path.GetFileName(renameEvent.OldPath), Path.GetFileName(renameEvent.Path)))
{
string mediaFileNameWithoutExt = Path.GetFileNameWithoutExtension(mediaPath);
string oldDataName = ContentProvider.GetNameFromPath(renameEvent.OldPath);
if (PathHelper.ArePathsEqual(mediaFileNameWithoutExt, oldDataName))
{
string newDataName = ContentProvider.GetNameFromPath(renameEvent.Path);
string newMediaFileName = newDataName + Path.GetExtension(mediaPath);
mediaPath = Path.Combine(Path.GetDirectoryName(mediaPath), newMediaFileName);
}
}
if (renameEvent.IsResource)
{
// Move the media file to mirror the data files movement
if (!PathHelper.ArePathsEqual(mediaPath, oldMediaPath))
{
if (File.Exists(oldMediaPath) && !File.Exists(mediaPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(mediaPath));
File.Move(oldMediaPath, mediaPath);
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(oldMediaPath), true);
}
}
}
else if (renameEvent.IsDirectory)
{
// Move the media directory to mirror the data files movement
if (!PathHelper.ArePathsEqual(mediaPath, oldMediaPath))
{
if (Directory.Exists(oldMediaPath) && !Directory.Exists(mediaPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(mediaPath));
Directory.Move(oldMediaPath, mediaPath);
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(oldMediaPath), true);
}
}
}
}
private static void MoveSourceMediaFile(FileEvent renameEvent, string[] oldMediaPaths)
{
if (!renameEvent.IsDirectory)
{
string[] newMediaPaths = AssetManager.GetAssetSourceFiles(new ContentRef <Resource>(renameEvent.Path));
for (int i = 0; i < oldMediaPaths.Length; i++)
{
string oldPath = oldMediaPaths[i];
string newPath = newMediaPaths.Length > i ? newMediaPaths[i] : oldPath;
// Move the media file to mirror the data files movement
if (!PathOp.ArePathsEqual(oldPath, newPath))
{
if (File.Exists(oldPath) && !File.Exists(newPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(newPath));
try
{
File.Move(oldPath, newPath);
}
catch (IOException exception)
{
Logs.Editor.WriteWarning(
"Unable to move source media file '{0}' to '{1}' ({2}). Copying the file instead.",
oldPath,
newPath,
exception.Message);
File.Copy(oldPath, newPath);
}
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(oldPath), true);
}
}
}
}
else
{
// Determine which source/media directory we're going to move
string oldMediaPath = Path.Combine(
EditorHelper.ImportDirectory,
PathHelper.MakeFilePathRelative(renameEvent.OldPath, DualityApp.DataDirectory));
// Determine where that old source/media directory needs to be moved
string newMediaPath = Path.Combine(
EditorHelper.ImportDirectory,
PathHelper.MakeFilePathRelative(renameEvent.Path, DualityApp.DataDirectory));
// Move the media directory to mirror the data directories movement
if (!PathOp.ArePathsEqual(newMediaPath, oldMediaPath))
{
if (Directory.Exists(oldMediaPath) && !Directory.Exists(newMediaPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(newMediaPath));
try
{
Directory.Move(oldMediaPath, newMediaPath);
}
catch (IOException exception)
{
Logs.Editor.WriteWarning(
"Unable to move source media directory '{0}' to '{1}' ({2}). Copying the directory instead.",
oldMediaPath,
newMediaPath,
exception.Message);
PathHelper.CopyDirectory(oldMediaPath, newMediaPath);
}
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(oldMediaPath), true);
}
}
}
}
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);
}
}
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);
});
}
}