public bool CanPerform(Type target, Operation restrictTo = Operation.All)
{
Operation oldAllowedOp = this.allowedOp;
this.allowedOp = oldAllowedOp & restrictTo;
// Convert ContentRef requests to their respective Resource-requests
target = ResTypeFromRefType(target);
if (this.checkedTypes.Contains(target))
{
this.allowedOp = oldAllowedOp;
return(false);
}
this.curComplexity++;
this.checkedTypes.Add(target);
bool result = false;
if (!result && this.data.GetDataPresent(target))
{
result = true;
}
if (!result && this.data.GetDataPresent(target.MakeArrayType()))
{
result = true;
}
if (!result && this.data.ContainsContentRefs(target))
{
result = true;
}
if (!result && this.data.ContainsComponentRefs(target))
{
result = true;
}
if (!result)
{
result = CorePluginRegistry.GetDataConverters(target).Any(s => !this.usedConverters.Contains(s) && s.CanConvertFrom(this));
}
if (result || this.allowedOp != oldAllowedOp)
{
this.checkedTypes.Remove(target);
}
this.maxComplexity = Math.Max(this.maxComplexity, this.curComplexity);
this.curComplexity--;
this.allowedOp = oldAllowedOp;
return(result);
}
public static bool IsImportFileExisting(string filePath)
{
string srcFilePath, targetName, targetDir;
PrepareImportFilePaths(filePath, out srcFilePath, out targetName, out targetDir);
// Does the source file already exist?
if (File.Exists(srcFilePath))
{
return(true);
}
// Find an importer and check if one of its output files already exist
IFileImporter importer = CorePluginRegistry.GetFileImporter(i => i.CanImportFile(srcFilePath));
return(importer != null && importer.GetOutputFiles(srcFilePath, targetName, targetDir).Any(File.Exists));
}
public static bool ImportFile(string filePath)
{
// Determine & check paths
string srcFilePath, targetName, targetDir;
PrepareImportFilePaths(filePath, out srcFilePath, out targetName, out targetDir);
// Find an importer to handle the file import
IFileImporter importer = CorePluginRegistry.GetFileImporter(i => i.CanImportFile(srcFilePath));
if (importer != null)
{
try
{
// Assure the directory exists
Directory.CreateDirectory(Path.GetDirectoryName(srcFilePath));
// Move file from data directory to source directory
if (File.Exists(srcFilePath))
{
File.Copy(filePath, srcFilePath, true);
File.Delete(filePath);
}
else
{
File.Move(filePath, srcFilePath);
}
} catch (Exception) { return(false); }
// Import it
importer.ImportFile(srcFilePath, targetName, targetDir);
GC.Collect();
GC.WaitForPendingFinalizers();
return(true);
}
else
{
return(false);
}
}
public static void GetPreview(IPreviewQuery query)
{
if (DualityApp.ExecContext == DualityApp.ExecutionContext.Terminated)
{
return;
}
if (query == null)
{
return;
}
//System.Diagnostics.Stopwatch w = new System.Diagnostics.Stopwatch();
//w.Restart();
var generators = (
from g in CorePluginRegistry.GetPreviewGenerators()
orderby query.SourceFits(g.ObjectType) descending, g.Priority descending
select g).ToArray();
foreach (IPreviewGenerator gen in generators)
{
if (!query.TransformSource(gen.ObjectType))
{
continue;
}
gen.Perform(query);
if (query.Result != null)
{
break;
}
}
//Log.Editor.Write("Generating preview for {0} / {1} took {2:F} ms", query.OriginalSource, query.GetType().Name, w.Elapsed.TotalMilliseconds);
}
public IEnumerable <object> Perform(Type target, Operation restrictTo = Operation.All)
{
Operation oldAllowedOp = this.allowedOp;
this.allowedOp = oldAllowedOp & restrictTo;
// Convert ContentRef requests to their respective Resource-requests
Type originalType = target;
target = ResTypeFromRefType(target);
//Log.Editor.Write("Convert to {0}", target.Name);
bool fittingDataFound = false;
// Check if there already is fitting data available
IEnumerable <object> fittingData = null;
if (fittingData == null)
{
// Single object
if (this.data.GetDataPresent(target))
{
fittingData = new[] { this.data.GetData(target) }
}
;
}
if (fittingData == null)
{
// Object array
Type arrType = target.MakeArrayType();
if (this.data.GetDataPresent(arrType))
{
fittingData = this.data.GetData(arrType) as IEnumerable <object>;
}
}
if (fittingData == null)
{
// ComponentRefs
if (this.data.ContainsComponentRefs(target))
{
fittingData = this.data.GetComponentRefs(target);
}
}
if (fittingData == null)
{
// ContentRefs
if (this.data.ContainsContentRefs(target))
{
fittingData = this.data.GetContentRefs(target).Res();
}
}
// If something fitting was found, directly add it to the operation results
if (fittingData != null)
{
fittingDataFound = true;
foreach (object obj in fittingData)
{
this.AddResult(obj);
}
}
// No result yet? Search suitable converters
if (!fittingDataFound)
{
var converterQuery = CorePluginRegistry.GetDataConverters(target);
List <ConvComplexityEntry> converters = new List <ConvComplexityEntry>();
foreach (var c in converterQuery)
{
this.maxComplexity = 0;
if (this.usedConverters.Contains(c))
{
continue;
}
if (!c.CanConvertFrom(this))
{
continue;
}
converters.Add(new ConvComplexityEntry(c, this.maxComplexity));
}
// Perform conversion
converters.StableSort((c1, c2) => (c2.Converter.Priority - c1.Converter.Priority) * 10000 + (c1.Complexity - c2.Complexity));
foreach (var c in converters)
{
//Log.Editor.Write("using {0}", s.GetType().Name);
//Log.Editor.PushIndent();
//Log.Editor.Write("before: {0}", this.Result.ToString(o => string.Format("{0} {1}", o.GetType().Name, o), ", "));
this.usedConverters.Add(c.Converter);
bool handled = c.Converter.Convert(this);
this.usedConverters.Remove(c.Converter);
//Log.Editor.Write("after: {0}", this.Result.ToString(o => string.Format("{0} {1}", o.GetType().Name, o), ", "));
//Log.Editor.PopIndent();
if (handled)
{
break;
}
}
}
IEnumerable <object> returnValue = this.result;
// Convert back to Resource requests
if (typeof(IContentRef).IsAssignableFrom(originalType))
{
returnValue = result.OfType <Resource>().Select(r => r.GetContentRef());
}
returnValue = returnValue ?? (IEnumerable <object>)Array.CreateInstance(originalType, 0);
returnValue = returnValue.Where(originalType.IsInstanceOfType);
this.allowedOp = oldAllowedOp;
return(returnValue);
}
public static void ReimportFile(string filePath)
{
// Find an importer to handle the file import
IFileImporter importer = CorePluginRegistry.GetFileImporter(i => i.CanImportFile(filePath));
if (importer == null)
{
return;
}
// Guess which Resources are affected and check them first
string fileBaseName = Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(filePath));
List <ContentRef <Resource> > checkContent = ContentProvider.GetAvailableContent <Resource>();
for (int i = 0; i < checkContent.Count; ++i)
{
ContentRef <Resource> resRef = checkContent[i];
if (resRef.Name == fileBaseName)
{
checkContent.RemoveAt(i);
checkContent.Insert(0, resRef);
}
}
// Iterate over all existing Resources to find out which one to ReImport.
List <Resource> touchedResources = null;
foreach (ContentRef <Resource> resRef in checkContent)
{
if (resRef.IsDefaultContent)
{
continue;
}
if (!importer.IsUsingSrcFile(resRef, filePath))
{
continue;
}
try
{
importer.ReimportFile(resRef, filePath);
if (resRef.IsLoaded)
{
if (touchedResources == null)
{
touchedResources = new List <Resource>();
}
touchedResources.Add(resRef.Res);
}
// Multiple Resources referring to a single source file shouldn't happen
// in the current implementation of FileImport and Resource system.
// Might change later.
break;
}
catch (Exception)
{
Log.Editor.WriteError("Can't re-import file '{0}'", filePath);
}
}
if (touchedResources != null)
{
DualityEditorApp.NotifyObjPropChanged(null, new ObjectSelection((IEnumerable <object>)touchedResources));
}
}
public static void NotifyFileRenamed(string filePathOld, string filePathNew)
{
if (string.IsNullOrEmpty(filePathOld))
{
return;
}
// Find an importer to handle the file rename
IFileImporter importer = CorePluginRegistry.GetFileImporter(i => i.CanImportFile(filePathOld));
if (importer == null)
{
return;
}
// Guess which Resources are affected and check them first
string fileBaseName = Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(filePathOld));
List <ContentRef <Resource> > checkContent = ContentProvider.GetAvailableContent <Resource>();
for (int i = 0; i < checkContent.Count; ++i)
{
ContentRef <Resource> resRef = checkContent[i];
if (resRef.Name == fileBaseName)
{
checkContent.RemoveAt(i);
checkContent.Insert(0, resRef);
}
}
// Iterate over all existing Resources to find out which one to modify.
List <Resource> touchedResources = null;
foreach (ContentRef <Resource> resRef in checkContent)
{
if (resRef.IsDefaultContent)
{
continue;
}
if (!importer.IsUsingSrcFile(resRef, filePathOld))
{
continue;
}
try
{
Resource res = resRef.Res;
if (res.SourcePath == filePathOld)
{
res.SourcePath = filePathNew;
if (touchedResources == null)
{
touchedResources = new List <Resource>();
}
touchedResources.Add(res);
// Multiple Resources referring to a single source file shouldn't happen
// in the current implementation of FileImport and Resource system.
// Might change later.
break;
}
}
catch (Exception)
{
Log.Editor.WriteError("There was an error internally renaming a source file '{0}' to '{1}'", filePathOld, filePathNew);
}
}
if (touchedResources != null)
{
DualityEditorApp.FlagResourceUnsaved(touchedResources);
}
}