private static System.Collections.IEnumerable PackageOperationThread(ProcessingBigTaskDialog.WorkerInterface workerInterface)
{
PackageOperationData data = workerInterface.Data as PackageOperationData;
workerInterface.Progress = -1.0f;
if (data.Package.Version != null)
{
workerInterface.StateDesc = string.Format("Package '{0}', Version {1}...", data.Package.Id, data.Package.Version);
}
else
{
workerInterface.StateDesc = string.Format("Package '{0}'...", data.Package.Id);
}
yield return(null);
try
{
data.Operation(data);
}
catch (Exception e)
{
Log.Editor.WriteError("An error occurred while processing Package '{0}', Version {1}: {2}",
data.Package.Id,
data.Package.Version,
Log.Exception(e));
}
yield break;
}
private static System.Collections.IEnumerable PackageUpdateAllThread(ProcessingBigTaskDialog.WorkerInterface workerInterface)
{
PackageManager manager = workerInterface.Data as PackageManager;
workerInterface.Progress = 0.0f;
workerInterface.StateDesc = string.Format("Preparing operation...");
yield return(null);
PackageInfo[] updatePackages = manager.GetSafeUpdateConfig(manager.LocalPackages).ToArray();
foreach (PackageInfo package in updatePackages)
{
workerInterface.Progress += 1.0f / updatePackages.Length;
workerInterface.StateDesc = string.Format("Package '{0}'...", package.Id);
yield return(null);
try
{
manager.UpdatePackage(package, package.Version);
}
catch (Exception e)
{
Log.Editor.WriteError("An error occurred while updating Package '{0}', Version {1}: {2}",
package.Id,
package.Version,
Log.Exception(e));
}
}
workerInterface.Progress = 1.0f;
yield break;
}
private System.Collections.IEnumerable async_PerformBatchAction(ProcessingBigTaskDialog.WorkerInterface state)
{
BatchActionTaskData data = state.Data as BatchActionTaskData;
// Retrieve files to perform action on
List <string> files = Resource.GetResourceFiles(data.FolderPath);
state.Progress += 0.05f; yield return(null);
// Perform action on files
foreach (string file in files)
{
state.StateDesc = file; yield return(null);
MetaFormatHelper.FilePerformAction(file, data.Action);
state.Progress += 0.9f / files.Count; yield return(null);
}
// Assure reloading the modified resources
if (PathHelper.IsPathLocatedIn(data.FolderPath, "."))
{
string dataPath = PathHelper.MakeFilePathRelative(data.FolderPath);
ContentProvider.RemoveContentTree(dataPath);
}
state.Progress += 0.05f;
}
private static IEnumerable SynchronizePackages(ProcessingBigTaskDialog.WorkerInterface workerInterface)
{
PackageManager manager = workerInterface.Data as PackageManager;
// Set the working state and yield, so the UI can update properly in case we're in the main thread
workerInterface.Progress = 0.0f;
workerInterface.StateDesc = GeneralRes.TaskPrepareInfo;
yield return(null);
// Retrieve all registered Duality packages and sort them so we don't accidentally install an old dependency
LocalPackage[] packagesToVerify = manager.LocalSetup.Packages.ToArray();
manager.OrderByDependencies(packagesToVerify);
yield return(null);
// Uninstall all "shadow" Duality packages that are installed, but not registered
Logs.Editor.Write("Removing unregistered packages...");
Logs.Editor.PushIndent();
manager.UninstallNonRegisteredPackages();
Logs.Editor.PopIndent();
yield return(null);
// Iterate over previously reigstered local packages and verify / install them.
Logs.Editor.Write("Verifying registered packages...");
Logs.Editor.PushIndent();
foreach (LocalPackage package in packagesToVerify)
{
// Update the task dialog's UI
if (package.Version != null)
{
workerInterface.StateDesc = string.Format("Package '{0}', Version {1}...", package.Id, package.Version);
}
else
{
workerInterface.StateDesc = string.Format("Package '{0}'...", package.Id);
}
workerInterface.Progress += 0.5f / packagesToVerify.Length;
yield return(null);
// Verify / Install the local package as needed
try
{
manager.VerifyPackage(package);
}
catch (Exception e)
{
Logs.Editor.WriteError("An error occurred verifying Package '{0}', Version {1}: {2}",
package.Id,
package.Version,
LogFormat.Exception(e));
}
workerInterface.Progress += 0.5f / packagesToVerify.Length;
yield return(null);
}
Logs.Editor.PopIndent();
yield break;
}
private static System.Collections.IEnumerable FirstTimeSetup(ProcessingBigTaskDialog.WorkerInterface workerInterface)
{
PackageManager manager = workerInterface.Data as PackageManager;
workerInterface.Progress = 0.0f;
workerInterface.StateDesc = GeneralRes.TaskPrepareInfo;
yield return(null);
LocalPackage[] packagesToVerify = manager.LocalPackages.ToArray();
manager.OrderByDependencies(packagesToVerify);
foreach (LocalPackage package in packagesToVerify)
{
if (package.Version != null)
{
workerInterface.StateDesc = string.Format("Package '{0}', Version {1}...", package.Id, package.Version);
}
else
{
workerInterface.StateDesc = string.Format("Package '{0}'...", package.Id);
}
workerInterface.Progress += 0.5f / packagesToVerify.Length;
yield return(null);
try
{
manager.VerifyPackage(package);
}
catch (Exception e)
{
Log.Editor.WriteError("An error occurred verifying Package '{0}', Version {1}: {2}",
package.Id,
package.Version,
Log.Exception(e));
}
workerInterface.Progress += 0.5f / packagesToVerify.Length;
yield return(null);
}
yield break;
}
private static System.Collections.IEnumerable PackageUpdateAllThread(ProcessingBigTaskDialog.WorkerInterface workerInterface)
{
PackageManager manager = workerInterface.Data as PackageManager;
workerInterface.Progress = 0.0f;
workerInterface.StateDesc = GeneralRes.TaskPrepareInfo;
yield return(null);
// Determine which packages need to be updated
PackageInfo[] updatePackages = manager.GetUpdatablePackages().ToArray();
// Sort packages by their dependencies so we don't accidentally install multiple versions
manager.OrderByDependencies(updatePackages);
// Start the updating process
foreach (PackageInfo package in updatePackages)
{
workerInterface.Progress += 1.0f / updatePackages.Length;
workerInterface.StateDesc = string.Format("Package '{0}'...", package.Id);
yield return(null);
try
{
manager.UpdatePackage(package.Name);
}
catch (Exception e)
{
Log.Editor.WriteError("An error occurred while updating Package '{0}', Version {1}: {2}",
package.Id,
package.Version,
Log.Exception(e));
workerInterface.Error = e;
}
}
workerInterface.Progress = 1.0f;
yield break;
}
private static System.Collections.IEnumerable async_RenameContentRefs(ProcessingBigTaskDialog.WorkerInterface state)
{
var renameData = state.Data as List <ResourceRenamedEventArgs>;
int totalCounter = 0;
int fileCounter = 0;
// Rename in static application data
state.StateDesc = "DualityApp Data"; yield return(null);
DualityApp.LoadAppData();
DualityApp.LoadUserData();
state.Progress += 0.04f; yield return(null);
totalCounter += async_RenameContentRefs_Perform(DualityApp.AppData, renameData);
totalCounter += async_RenameContentRefs_Perform(DualityApp.UserData, renameData);
state.Progress += 0.02f; yield return(null);
DualityApp.SaveAppData();
DualityApp.SaveUserData();
state.Progress += 0.04f; yield return(null);
// Special case: Current Scene in sandbox mode
if (Sandbox.IsActive)
{
// Because changes we'll do will be discarded when leaving the sandbox we'll need to
// do it the hard way - manually load an save the file.
state.StateDesc = "Current Scene"; yield return(null);
Scene curScene = Resource.Load <Scene>(Scene.CurrentPath, null, false);
fileCounter = async_RenameContentRefs_Perform(curScene, renameData);
totalCounter += fileCounter;
if (fileCounter > 0)
{
curScene.Save(Scene.CurrentPath, false);
}
}
// Special case: Current Scene NOT in sandbox mode, but still unsaved
else if (Scene.Current.IsRuntimeResource)
{
state.StateDesc = "Current Scene"; yield return(null);
fileCounter = async_RenameContentRefs_Perform(Scene.Current, renameData);
if (fileCounter > 0)
{
DualityEditorApp.NotifyObjPropChanged(null, new ObjectSelection(Scene.Current.AllObjects));
}
totalCounter += fileCounter;
}
// Rename in actual content
var targetResTypes = renameData.Any(e => e.IsDirectory) ? null : renameData.Select(e => e.ContentType).ToArray();
var loadedContent = ContentProvider.GetLoadedContent <Resource>();
var reloadContent = new List <IContentRef>();
List <string> resFiles = Resource.GetResourceFiles();
List <Resource> modifiedRes = new List <Resource>();
foreach (string file in resFiles)
{
// Early-out, if this kind of Resource isn't able to reference the renamed Resource
if (targetResTypes != null)
{
Type resType = Resource.GetTypeByFileName(file);
if (resType == null)
{
Log.Editor.WriteWarning("Could not determine Resource type for File '{0}' using file name only. Skipping it during rename.", file);
continue;
}
bool canReferenceRes = false;
foreach (Type targetType in targetResTypes)
{
if (ReflectionHelper.CanReferenceResource(resType, targetType))
{
canReferenceRes = true;
break;
}
}
if (!canReferenceRes)
{
state.Progress += 0.9f / resFiles.Count;
continue;
}
}
// Set displayed name
state.StateDesc = file; yield return(null);
// Wasn't loaded before? Unload it later to keep the memory footprint small.
bool wasLoaded = loadedContent.Any(r => r.Path == file);
// Keep in mind that this operation is performed while Duality content was
// in an inconsistent state. Loading Resources now may lead to wrong data.
// Because the ContentRefs might be wrong right now.
if (wasLoaded)
{
// Retrieve already loaded content
IContentRef cr = ContentProvider.RequestContent(file);
state.Progress += 0.45f / resFiles.Count; yield return(null);
// Perform rename and flag unsaved / modified
fileCounter = async_RenameContentRefs_Perform(cr.Res, renameData);
if (fileCounter > 0)
{
modifiedRes.Add(cr.Res);
}
}
else
{
// Load content without initializing it
Resource res = Resource.Load <Resource>(file, null, false);
state.Progress += 0.45f / resFiles.Count; yield return(null);
// Perform rename and save it without making it globally available
fileCounter = async_RenameContentRefs_Perform(res, renameData);
if (fileCounter > 0)
{
res.Save(null, false);
}
}
totalCounter += fileCounter;
state.Progress += 0.45f / resFiles.Count; yield return(null);
}
// Notify the editor about modified Resources
if (modifiedRes.Count > 0)
{
DualityEditorApp.NotifyObjPropChanged(null, new ObjectSelection(modifiedRes));
}
}