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 mainForm_Activated(object sender, EventArgs e)
{
// Perform scheduled source file reimports
if (reimportSchedule.Count > 0)
{
// Hacky: Wait a little for the files to be accessable again (Might be used by another process)
System.Threading.Thread.Sleep(50);
foreach (string file in reimportSchedule)
{
if (!File.Exists(file))
{
continue;
}
FileImportProvider.ReimportFile(file);
}
reimportSchedule.Clear();
}
}
private static void ProcessSourceDirEvents()
{
// Process events
while (sourceDirEventBuffer.Count > 0)
{
FileSystemEventArgs e = FetchFileSystemEvent(sourceDirEventBuffer, sourceDirWatcher.Path);
if (e == null)
{
continue;
}
if (e.ChangeType == WatcherChangeTypes.Changed)
{
if (File.Exists(e.FullPath) && PathHelper.IsPathLocatedIn(e.FullPath, EditorHelper.SourceMediaDirectory))
{
reimportSchedule.Add(e.FullPath);
}
if (SrcFileModified != null)
{
SrcFileModified(null, e);
}
}
else if (e.ChangeType == WatcherChangeTypes.Created)
{
}
else if (e.ChangeType == WatcherChangeTypes.Deleted)
{
if (SrcFileDeleted != null)
{
SrcFileDeleted(null, e);
}
}
else if (e.ChangeType == WatcherChangeTypes.Renamed)
{
RenamedEventArgs rename = e as RenamedEventArgs;
FileImportProvider.NotifyFileRenamed(rename.OldFullPath, rename.FullPath);
if (SrcFileRenamed != null)
{
SrcFileRenamed(null, e);
}
}
}
}
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 ProcessDataDirEvents()
{
List <ResourceRenamedEventArgs> renameEventBuffer = 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));
}
}
// Import non-Resource file
else
{
bool abort = false;
if (FileImportProvider.DoesImportOverwriteData(e.FullPath))
{
DialogResult result = MessageBox.Show(
String.Format(Properties.GeneralRes.Msg_ImportConfirmOverwrite_Text, e.FullPath),
Properties.GeneralRes.Msg_ImportConfirmOverwrite_Caption,
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning);
abort = result == DialogResult.No;
}
if (!abort)
{
bool importedSuccessfully = FileImportProvider.ImportFile(e.FullPath);
if (!importedSuccessfully)
{
MessageBox.Show(
String.Format(Properties.GeneralRes.Msg_CantImport_Text, e.FullPath),
Properties.GeneralRes.Msg_CantImport_Caption,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
abort = !importedSuccessfully;
}
}
}
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);
// Organize the Source/Media directory accordingly
DeleteSourceMediaFile(args);
// 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)
{
// 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);
}
}
}
}
// 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);
});
}
}