private static string GetTextureFormatTag(ReferencedFileSave rfs)
{
if (rfs.GetAssetTypeInfo() != null && rfs.GetAssetTypeInfo().RuntimeTypeName == "Texture2D")
{
return("ProcessorParameters_TextureFormat");
}
else
{
return("ProcessorParameters_TextureProcessorOutputFormat");
}
}
public static void ReactToUseContentPipelineChange(ReferencedFileSave rfs)
{
TaskManager.Self.AddSync(() =>
{
List <string> filesInModifiedRfs = new List <string>();
bool shouldRemoveAndAdd = false;
ProjectBase projectBase = ProjectManager.ContentProject;
if (projectBase == null)
{
projectBase = ProjectManager.ProjectBase;
}
AddOrRemoveIndividualRfs(rfs, filesInModifiedRfs, ref shouldRemoveAndAdd, projectBase);
if (shouldRemoveAndAdd)
{
List <ReferencedFileSave> rfses = new List <ReferencedFileSave>();
rfses.Add(rfs);
bool usesContentPipeline = rfs.UseContentPipeline || rfs.GetAssetTypeInfo() != null && rfs.GetAssetTypeInfo().MustBeAddedToContentPipeline;
AddAndRemoveModifiedRfsFiles(rfses, filesInModifiedRfs, projectBase, usesContentPipeline);
GlueCommands.Self.ProjectCommands.SaveProjects();
}
}, "Reacting to changing UseContentPipeline");
}
/// <summary>
/// Updates the presence of the RFS in the main project. If the RFS has project specific files, then those
/// files are updated in the appropriate synced project.
/// </summary>
/// <remarks>
/// This method does not update synced projects if the synced projects use the same file. The reason is because
/// this is taken care of when the projects are saved later on.
/// </remarks>
/// <param name="referencedFileSave">The RFS representing the file to update membership on.</param>
/// <returns>Whether anything was added to any projects.</returns>
public bool UpdateFileMembershipInProject(ReferencedFileSave referencedFileSave)
{
var assetTypeInfo = referencedFileSave.GetAssetTypeInfo();
bool shouldSkip = assetTypeInfo != null && assetTypeInfo.ExcludeFromContentProject;
bool wasAnythingAdded = false;
if (!shouldSkip)
{
bool useContentPipeline = referencedFileSave.UseContentPipeline || (assetTypeInfo != null && assetTypeInfo.MustBeAddedToContentPipeline);
wasAnythingAdded = UpdateFileMembershipInProject(GlueState.Self.CurrentMainProject, referencedFileSave.GetRelativePath(), useContentPipeline, false);
foreach (ProjectSpecificFile projectSpecificFile in referencedFileSave.ProjectSpecificFiles)
{
wasAnythingAdded |= UpdateFileMembershipInProject(ProjectManager.GetProjectByName(projectSpecificFile.ProjectName), projectSpecificFile.FilePath, useContentPipeline, true);
}
if (wasAnythingAdded)
{
int m = 3;
}
}
return(wasAnythingAdded);
}
private static GeneralResponse HandleDroppingFileOnObjectInSameElement(TreeNode targetNode, ReferencedFileSave referencedFileSave)
{
// Dropping the file on an object. If the object's type matches the named object's
// entire file, ask the user if they want to make the object come from the file...
var rfsAti = referencedFileSave.GetAssetTypeInfo();
var namedObject = ((NamedObjectSave)targetNode.Tag);
var namedObjectAti = namedObject.GetAssetTypeInfo();
var response = GeneralResponse.SuccessfulResponse;
var shouldAskAboutChangingObjectToBeFromFile =
rfsAti == namedObjectAti && rfsAti != null;
if (shouldAskAboutChangingObjectToBeFromFile)
{
var dialogResult = MessageBox.Show(
$"Would you like to set the object {namedObject.InstanceName} to be created from the file {referencedFileSave.Name}?",
$"Set {namedObject.InstanceName} to be from file?",
MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
namedObject.SourceType = SourceType.File;
namedObject.SourceFile = referencedFileSave.Name;
namedObject.SourceName = $"Entire File ({rfsAti.RuntimeTypeName})";
// This might be the case if the base is SetbyDerived.
if (namedObject.Instantiate == false)
{
// If an entire object is dropped on this, it's likely that the user wants to create (aka instantiate)
// the object using the entire file. The user may not realize that the object is set to not initialize,
// so let's ask them and offer to set Initialize to true
string message = $"The object {namedObject.InstanceName} has its 'Instantiate' variable set to 'false'. " +
$"This needs to be set to 'true' for the object to be created from the file. Set it to true?";
var setToTrueResponse = MessageBox.Show(message,
"Set Instantiate to true?",
MessageBoxButtons.YesNo);
if (setToTrueResponse == DialogResult.Yes)
{
namedObject.Instantiate = true;
}
}
GlueCommands.Self.GluxCommands.SaveGluxTask();
GlueCommands.Self.GenerateCodeCommands.GenerateCurrentElementCodeTask();
}
}
else
{
response.Fail(
$"The object {namedObject.InstanceName} cannot be entirely set from {referencedFileSave.Name}." +
$"To set this object from an object contained within the file, select the object and change its source values.");
}
return(response);
}
private static bool GetIfFileCanBeReloaded(ReferencedFileSave item)
{
var extension = FileManager.GetExtension(item.Name);
var assetTypeInfo = item.GetAssetTypeInfo();
return(item.IsCsvOrTreatedAsCsv ||
assetTypeInfo?.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Graphics.Animation.AnimationChainList");
}
public static void UpdateTextureFormatFor(ReferencedFileSave rfs)
{
string absoluteName = ProjectManager.MakeAbsolute(rfs.Name, true);
bool usesContentPipeline = rfs.UseContentPipeline || rfs.GetAssetTypeInfo() != null && rfs.GetAssetTypeInfo().MustBeAddedToContentPipeline;
string parameterTag = GetTextureFormatTag(rfs);
string valueToSet = rfs.TextureFormat.ToString();
SetParameterOnBuildItems(absoluteName, parameterTag, valueToSet);
}
public static void RenameReferencedFile(string oldName, string newName, ReferencedFileSave rfs, IElement container)
{
string oldDirectory = FileManager.GetDirectory(oldName);
string newDirectory = FileManager.GetDirectory(newName);
string newFileNameAbsolute = ProjectManager.MakeAbsolute(newName);
string instanceName = FileManager.RemovePath(FileManager.RemoveExtension(newName));
string whyIsntValid;
if (oldDirectory != newDirectory)
{
MessageBox.Show("The old file was located in \n" + oldDirectory + "\n" +
"The new file is located in \n" + newDirectory + "\n" +
"Currently Glue does not support changing directories.", "Warning");
rfs.SetNameNoCall(oldName);
}
else if (NameVerifier.IsReferencedFileNameValid(instanceName, rfs.GetAssetTypeInfo(), rfs, container, out whyIsntValid) == false)
{
MessageBox.Show(whyIsntValid);
rfs.SetNameNoCall(oldName);
}
else
{
bool shouldMove = true;
bool shouldContinue = true;
CheckForExistingFileOfSameName(oldName, rfs, newFileNameAbsolute, ref shouldMove, ref shouldContinue);
if (shouldContinue)
{
MoveFileIfNecessary(oldName, newName, shouldMove);
string rfsType = rfs.RuntimeType;
if (rfsType != null && rfsType.Contains("."))
{
// We dont want the fully qualified type.
rfsType = FileManager.GetExtension(rfsType);
}
UpdateObjectsUsingFile(container, oldName, rfs, rfsType);
RegenerateCodeAndUpdateUiAccordingToRfsRename(oldName, newName, rfs);
UpdateBuildItemsForRenamedRfs(oldName, newName);
AdjustDataFilesIfIsCsv(oldName, rfs);
GluxCommands.Self.SaveGlux();
ProjectManager.SaveProjects();
}
}
}
bool IsRfsOfUnqualifiedRuntimeType(ReferencedFileSave rfs, string unqualifiedRuntimeType)
{
AssetTypeInfo ati = rfs.GetAssetTypeInfo();
if (ati != null)
{
return(ati.RuntimeTypeName == unqualifiedRuntimeType);
}
else
{
return(false);
}
}
bool IsRfsOfType(ReferencedFileSave rfs, Type type)
{
AssetTypeInfo ati = rfs.GetAssetTypeInfo();
if (ati != null)
{
return(ati.QualifiedRuntimeTypeName.QualifiedType == type.FullName);
}
else
{
return(false);
}
}
private static bool AddOrRemoveIndividualRfs(ReferencedFileSave rfs, List <string> filesInModifiedRfs, ref bool shouldRemoveAndAdd, ProjectBase projectBase)
{
List <ProjectBase> projectsAlreadyModified = new List <ProjectBase>();
bool usesContentPipeline = rfs.UseContentPipeline || rfs.GetAssetTypeInfo() != null && rfs.GetAssetTypeInfo().MustBeAddedToContentPipeline;
if (rfs.GetAssetTypeInfo() != null && rfs.GetAssetTypeInfo().MustBeAddedToContentPipeline&& rfs.UseContentPipeline == false)
{
rfs.UseContentPipeline = true;
MessageBox.Show("The file " + rfs.Name + " must use the content pipeline");
}
else
{
string absoluteName = ProjectManager.MakeAbsolute(rfs.Name, true);
shouldRemoveAndAdd = usesContentPipeline && !projectBase.IsFilePartOfProject(absoluteName, BuildItemMembershipType.CompileOrContentPipeline) ||
!usesContentPipeline && !projectBase.IsFilePartOfProject(absoluteName, BuildItemMembershipType.CopyIfNewer);
if (shouldRemoveAndAdd)
{
projectBase.RemoveItem(absoluteName);
projectBase.AddContentBuildItem(absoluteName, SyncedProjectRelativeType.Contained, usesContentPipeline);
projectsAlreadyModified.Add(projectBase);
#region Loop through all synced projects and add or remove the file referenced by the RFS
foreach (ProjectBase syncedProject in ProjectManager.SyncedProjects)
{
ProjectBase syncedContentProjectBase = syncedProject;
if (syncedProject.ContentProject != null)
{
syncedContentProjectBase = syncedProject.ContentProject;
}
if (!projectsAlreadyModified.Contains(syncedContentProjectBase))
{
projectsAlreadyModified.Add(syncedContentProjectBase);
syncedContentProjectBase.RemoveItem(absoluteName);
if (syncedContentProjectBase.SaveAsAbsoluteSyncedProject)
{
syncedContentProjectBase.AddContentBuildItem(absoluteName, SyncedProjectRelativeType.Contained, usesContentPipeline);
}
else
{
syncedContentProjectBase.AddContentBuildItem(absoluteName, SyncedProjectRelativeType.Linked, usesContentPipeline);
}
}
}
#endregion
List <string> filesReferencedByAsset =
FileReferenceManager.Self.GetFilesReferencedBy(absoluteName, EditorObjects.Parsing.TopLevelOrRecursive.Recursive);
for (int i = 0; i < filesReferencedByAsset.Count; i++)
{
if (!filesInModifiedRfs.Contains(filesReferencedByAsset[i]))
{
filesInModifiedRfs.Add(filesReferencedByAsset[i]);
}
}
}
}
return(usesContentPipeline);
}
private static void MoveReferencedFile(TreeNode treeNodeMoving, TreeNode targetNode)
{
var response = GeneralResponse.SuccessfulResponse;
while (targetNode != null && targetNode.IsReferencedFile())
{
targetNode = targetNode.Parent;
}
// If the user drops a file on a Screen or Entity, let's allow them to
// complete the operation on the Files node
if (targetNode is BaseElementTreeNode)
{
targetNode = ((BaseElementTreeNode)targetNode).FilesTreeNode;
}
ReferencedFileSave referencedFileSave = treeNodeMoving.Tag as ReferencedFileSave;
if (!targetNode.IsFilesContainerNode() &&
!targetNode.IsFolderInFilesContainerNode() &&
!targetNode.IsFolderForGlobalContentFiles() &&
!targetNode.IsNamedObjectNode() &&
!targetNode.IsRootNamedObjectNode())
{
response.Fail(@"Can't drop this file here");
}
else if (!string.IsNullOrEmpty(referencedFileSave.SourceFile) ||
referencedFileSave.SourceFileCache.Count != 0)
{
response.Fail("Can't move the file\n\n" + referencedFileSave.Name + "\n\nbecause it has source-referencing files. These sources will be broken " +
"if the file is moved. You will need to manually move the file, modify the source references, remove this file, then add the newly-created file.");
}
if (response.Succeeded)
{
if (targetNode.IsGlobalContentContainerNode())
{
if (targetNode.GetContainingElementTreeNode() == null)
{
string targetDirectory = ProjectManager.MakeAbsolute(targetNode.GetRelativePath(), true);
MoveReferencedFileToDirectory(referencedFileSave, targetDirectory);
}
else
{
DragAddFileToGlobalContent(treeNodeMoving, referencedFileSave);
// This means the user wants to add the file
// to global content.
}
}
else if (targetNode.IsFolderForGlobalContentFiles())
{
string targetDirectory = ProjectManager.MakeAbsolute(targetNode.GetRelativePath(), true);
MoveReferencedFileToDirectory(referencedFileSave, targetDirectory);
}
else if (targetNode.IsRootNamedObjectNode())
{
AddObjectViewModel viewModel = new AddObjectViewModel();
viewModel.SourceType = SourceType.File;
viewModel.SourceFile = (treeNodeMoving.Tag as ReferencedFileSave).Name;
GlueCommands.Self.DialogCommands.ShowAddNewObjectDialog(viewModel);
}
else if (targetNode.IsNamedObjectNode() &&
// dropping on an object in the same element
targetNode.GetContainingElementTreeNode() == treeNodeMoving.GetContainingElementTreeNode())
{
response = HandleDroppingFileOnObjectInSameElement(targetNode, referencedFileSave);
}
//if (targetNode.IsFolderInFilesContainerNode() || targetNode.IsFilesContainerNode())
else
{
// See if we're moving the RFS from one Element to another
IElement container = ObjectFinder.Self.GetElementContaining(referencedFileSave);
TreeNode elementTreeNodeDroppingIn = targetNode.GetContainingElementTreeNode();
IElement elementDroppingIn = null;
if (elementTreeNodeDroppingIn != null)
{
// User didn't drop on an entity, but instead on a node within the entity.
// Let's check if it's a subfolder. If so, we need to tell the user that we
// can't add the file in a subfolder.
if (targetNode.IsFolderInFilesContainerNode())
{
response.Message = "Shared files cannot be added to subfolders, so it will be added directly to \"Files\"";
}
elementDroppingIn = elementTreeNodeDroppingIn.Tag as IElement;
}
if (container != elementDroppingIn)
{
// Make sure the target element is not named the same as the file itself.
// For example, dropping a file called Level1.tmx in a screen called Level1.
// This will not compile so we shouldn't allow it.
var areNamedTheSame = elementDroppingIn.GetStrippedName() == referencedFileSave.GetInstanceName();
if (areNamedTheSame)
{
response.Fail($"The file {referencedFileSave.GetInstanceName()} has the same name as the target screen. it will not be added since this is not allowed.");
}
if (response.Succeeded)
{
ElementViewWindow.SelectedNode = targetNode;
string absoluteFileName = ProjectManager.MakeAbsolute(referencedFileSave.Name, true);
string creationReport;
string errorMessage;
var newlyCreatedFile = ElementCommands.Self.CreateReferencedFileSaveForExistingFile(elementDroppingIn, null, absoluteFileName,
PromptHandleEnum.Prompt,
referencedFileSave.GetAssetTypeInfo(),
out creationReport,
out errorMessage);
ElementViewWindow.UpdateChangedElements();
if (!String.IsNullOrEmpty(errorMessage))
{
MessageBox.Show(errorMessage);
}
else if (newlyCreatedFile != null)
{
GlueCommands.Self.TreeNodeCommands.SelectTreeNode(newlyCreatedFile);
}
}
}
else
{
// Not moving into or out of an element
string targetDirectory = ProjectManager.MakeAbsolute(targetNode.GetRelativePath(), true);
MoveReferencedFileToDirectory(referencedFileSave, targetDirectory);
}
}
}
if (!string.IsNullOrEmpty(response.Message))
{
MessageBox.Show(response.Message);
}
}
private void UpdateIncludedAndExcluded(ReferencedFileSave instance)
{
ResetToDefault();
AssetTypeInfo ati = instance.GetAssetTypeInfo();
ExcludeMember(nameof(ReferencedFileSave.InvalidFileNameCharacters));
ExcludeMember(nameof(ReferencedFileSave.ToStringDelegate));
ExcludeMember(nameof(ReferencedFileSave.Properties));
ContainerType containerType = instance.GetContainerType();
if (containerType == ContainerType.Entity)
{
// We do this because this is set automatically if the Entity is unique
ExcludeMember(nameof(ReferencedFileSave.IsSharedStatic));
// We do this because whether the objects from a file are manually updated or not
// should be up to the entity, not the source file.
ExcludeMember(nameof(ReferencedFileSave.IsManuallyUpdated));
}
if (containerType == ContainerType.Entity || ati == null || ati.QualifiedRuntimeTypeName.QualifiedType != "Microsoft.Xna.Framework.Media.Song")
{
ExcludeMember(nameof(ReferencedFileSave.DestroyOnUnload));
}
#region Extension-based additions/removals
string extension = FileManager.GetExtension(instance.Name);
if (extension != "csv" && !instance.TreatAsCsv)
{
ExcludeMember(nameof(ReferencedFileSave.CreatesDictionary));
ExcludeMember(nameof(ReferencedFileSave.IsDatabaseForLocalizing));
ExcludeMember(nameof(ReferencedFileSave.UniformRowType));
}
else
{
IncludeMember(nameof(ReferencedFileSave.UniformRowType), typeof(ReferencedFileSave), new AvailablePrimitiveTypeArraysStringConverter());
}
if ((extension != "txt" && extension != "csv") ||
(extension == "txt" && instance.TreatAsCsv == false)
)
{
ExcludeMember(nameof(ReferencedFileSave.CsvDelimiter));
}
if (extension != "txt")
{
ExcludeMember(nameof(ReferencedFileSave.TreatAsCsv));
}
if (extension == "png")
{
Attribute[] fileDetailsCategoryAttribute = new Attribute[] {
new CategoryAttribute("File Details")
};
IncludeMember("ImageWidth", typeof(int), null, GetImageWidth, null, fileDetailsCategoryAttribute);
IncludeMember("ImageHeight", typeof(int), null, GetImageHeight, null, fileDetailsCategoryAttribute);
}
if (extension == "emix")
{
Attribute[] fileDetailsCategoryAttribute = new Attribute[] {
new CategoryAttribute("File Details")
};
IncludeMember("EquilibriumParticleCount", typeof(float), null, GetEquilibriumParticleCount, null, fileDetailsCategoryAttribute);
IncludeMember("BurstParticleCount", typeof(float), null, GetBurstParticleCount, null, fileDetailsCategoryAttribute);
}
#endregion
AddProjectSpecificFileMember();
if (!instance.LoadedAtRuntime)
{
ExcludeMember(nameof(ReferencedFileSave.IsSharedStatic));
ExcludeMember(nameof(ReferencedFileSave.IsManuallyUpdated));
ExcludeMember(nameof(ReferencedFileSave.LoadedOnlyWhenReferenced));
ExcludeMember(nameof(ReferencedFileSave.HasPublicProperty));
ExcludeMember("InstanceName");
ExcludeMember(nameof(ReferencedFileSave.IncludeDirectoryRelativeToContainer));
}
if (ati == null || string.IsNullOrEmpty(ati.MakeManuallyUpdatedMethod))
{
ExcludeMember(nameof(ReferencedFileSave.IsManuallyUpdated));
}
if (!instance.GetCanUseContentPipeline())
{
ExcludeMember(nameof(ReferencedFileSave.UseContentPipeline));
}
if (!instance.UseContentPipeline || ati.QualifiedRuntimeTypeName.QualifiedType != "Microsoft.Xna.Framework.Graphics.Texture2D")
{
ExcludeMember("TextureFormat");
}
IncludeMember("OpensWith", typeof(ReferencedFileSave), new AvailableApplicationsStringConverters());
bool shouldShowRuntimeType = instance.LoadedAtRuntime;
if (shouldShowRuntimeType)
{
IncludeMember("RuntimeType", typeof(ReferencedFileSave), new AvailableRuntimeTypeConverter()
{
ReferencedFileSave = instance
});
}
else
{
ExcludeMember(nameof(ReferencedFileSave.RuntimeType));
}
if (string.IsNullOrEmpty(instance.SourceFile))
{
ExcludeMember(nameof(ReferencedFileSave.SourceFile));
ExcludeMember(nameof(ReferencedFileSave.BuildTool));
ExcludeMember(nameof(ReferencedFileSave.AdditionalArguments));
ExcludeMember(nameof(ReferencedFileSave.ConditionalCompilationSymbols));
}
else
{
}
}
private string GetRawDialogTreeLoadCode(IElement element, NamedObjectSave namedObject, ReferencedFileSave referencedFile, string contentManager)
{
var fileName = ReferencedFileSaveCodeGenerator.GetFileToLoadForRfs(referencedFile, referencedFile.GetAssetTypeInfo());
return($"{referencedFile.GetInstanceName()} = DialogTreePlugin.SaveClasses.DialogTreeRaw.RootObject.FromJson(\"{fileName}\");");
}