private void SaveSourceFile(SortableBindingList <DataItem> data) { if (!data.Any()) { MessageBox.Show("Отсутствуют данные для сохранения.", "XDataConv", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } if (!String.IsNullOrEmpty(_openSourceFileDialog.FileName)) { _saveSourceFileDialog.InitialDirectory = Path.GetDirectoryName(_openSourceFileDialog.FileName); } if (_saveSourceFileDialog.ShowDialog() != DialogResult.OK) { return; } try { var fileManager = new CsvFileManager(_logger); fileManager.WriteToFile(_saveSourceFileDialog.FileName, data); MessageBox.Show($"Данные сохранены в файл {_saveSourceFileDialog.FileName}.", "XDataConv", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { _logger.Error($"Error writing file {_saveSourceFileDialog.FileName}", ex); MessageBox.Show($"Ошибка сохранения файла {_saveSourceFileDialog.FileName}.{Environment.NewLine}{ex.Message}", "XDataConv", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
internal static List <string> GetMemberNamesFrom(ReferencedFileSave rfs) { List <string> toReturn = new List <string>(); string fileName = rfs.Name; fileName = ProjectManager.MakeAbsolute(fileName); RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime( fileName); for (int i = 0; i < rcr.Headers.Length; i++) { string memberName = rcr.Headers[i].Name; if (memberName.Trim().StartsWith("//")) { continue; } memberName = StringFunctions.RemoveWhitespace(memberName); if (memberName.Contains("(")) { memberName = memberName.Substring(0, memberName.IndexOfAny(new char[] { '(' })); } toReturn.Add(memberName); } return(toReturn); }
public bool AddAssetTypes(string fullFileName, List <AssetTypeInfo> listToFill, bool tolerateFailure = false) { bool succeeded = true; List <AssetTypeInfo> newTypes = new List <AssetTypeInfo>(); try { CsvFileManager.CsvDeserializeList(typeof(AssetTypeInfo), fullFileName, newTypes); } catch (Exception e) { succeeded = false; if (tolerateFailure) { #if GLUE // let's report it: PluginManager.ReceiveError("Error loading CSV: " + fullFileName + "\n" + e.ToString()); #endif } else { throw e; } } if (succeeded) { #if GLUE PluginManager.ReceiveOutput("Loading content types from " + fullFileName + " and found " + newTypes.Count + " types"); #endif listToFill.AddRange(newTypes); } return(succeeded); }
private void SetLocalizationDb(string filePath) { GlueCommands.Self.TryMultipleTimes(() => { LocalizationDb = CsvFileManager.CsvDeserializeToRuntime(filePath); }, 5); }
public static void LoadAvaliableProjectFromCsv() { var fileName = "Content/EmptyTemplates.csv"; var absoluteFile = FileManager.RelativeDirectory + fileName; if (!File.Exists(absoluteFile)) { MessageBox.Show($"{Resources.LoadProjectTip1}{absoluteFile}{Resources.LoadProjectTip2}"); } else { EmptyProjects.Clear(); CsvFileManager.CsvDeserializeList(typeof(PlatformProjectInfo), fileName, EmptyProjects); } fileName = "Content/StarterProjects.csv"; absoluteFile = FileManager.RelativeDirectory + fileName; if (!File.Exists(absoluteFile)) { MessageBox.Show($"{Resources.LoadProjectTip3}{absoluteFile}{Resources.LoadProjectTip4}"); } else { StarterProjects.Clear(); CsvFileManager.CsvDeserializeList(typeof(PlatformProjectInfo), fileName, StarterProjects); } }
public static void LoadAvailableProjectsFromCsv() { string fileName = "Content/EmptyTemplates.csv"; string absoluteFile = FileManager.RelativeDirectory + fileName; if (!File.Exists(absoluteFile)) { MessageBox.Show("The New Project Creator is missing a critical file called EmptyTemplates.csv. Full path is\n\n" + absoluteFile + "\n\nThis file is needed to get the list of available projects that the New Project Creator can create"); } else { CsvFileManager.CsvDeserializeList(typeof(PlatformProjectInfo), fileName, emptyProjects); } fileName = "Content/StarterProjects.csv"; absoluteFile = FileManager.RelativeDirectory + fileName; if (!File.Exists(absoluteFile)) { MessageBox.Show("The New Project Creator is missing a critical file called StarterProjects.csv. Full path is\n\n" + absoluteFile + "\n\nThis file is needed to get the list of available projects that the New Project Creator can create"); } else { CsvFileManager.CsvDeserializeList(typeof(PlatformProjectInfo), fileName, starterProjects); } }
public void LoadExternalBuildToolsFromCsv(string csvFileName) { List <BuildToolAssociation> externals = new List <BuildToolAssociation>(); CsvFileManager.CsvDeserializeList(typeof(BuildToolAssociation), csvFileName, externals); BuildToolAssociations.AddExternalRange(externals); }
public static BuildToolAssociationList FromFileCsv(string fileName) { BuildToolAssociationList toReturn = new BuildToolAssociationList(); CsvFileManager.CsvDeserializeList(typeof(BuildToolAssociation), fileName, toReturn.BuildToolList); return(toReturn); }
void CustomPreGlobalContentInitialize() { GlobalContent.SpreadsheetToReplace = new Dictionary <string, DataTypes.SpreadsheetToReplace>(); CsvFileManager.CsvDeserializeDictionary <string, DataTypes.SpreadsheetToReplace>( "content/globalcontent/replacewiththis.csv", GlobalContent.SpreadsheetToReplace ); }
public static void LoadStaticContent(string contentManagerName) { if (string.IsNullOrEmpty(contentManagerName)) { throw new ArgumentException("contentManagerName cannot be empty or null"); } ContentManagerName = contentManagerName; #if DEBUG if (contentManagerName == FlatRedBallServices.GlobalContentManager) { HasBeenLoadedWithGlobalContentManager = true; } else if (HasBeenLoadedWithGlobalContentManager) { throw new Exception("This type has been loaded with a Global content manager, then loaded with a non-global. This can lead to a lot of bugs"); } #endif bool registerUnload = false; if (LoadedContentManagers.Contains(contentManagerName) == false) { LoadedContentManagers.Add(contentManagerName); lock (mLockObject) { if (!mRegisteredUnloads.Contains(ContentManagerName) && ContentManagerName != FlatRedBallServices.GlobalContentManager) { FlatRedBallServices.GetContentManagerByName(ContentManagerName).AddUnloadMethod("PlatformerCharacterBaseStaticUnload", UnloadStaticContent); mRegisteredUnloads.Add(ContentManagerName); } } if (MovementValues == null) { { // We put the { and } to limit the scope of oldDelimiter char oldDelimiter = CsvFileManager.Delimiter; CsvFileManager.Delimiter = ','; Dictionary <string, MovementValues> temporaryCsvObject = new Dictionary <string, MovementValues>(); CsvFileManager.CsvDeserializeDictionary <string, MovementValues>("content/entities/platformercharacterbase/movementvalues.csv", temporaryCsvObject); CsvFileManager.Delimiter = oldDelimiter; MovementValues = temporaryCsvObject; } } } if (registerUnload && ContentManagerName != FlatRedBallServices.GlobalContentManager) { lock (mLockObject) { if (!mRegisteredUnloads.Contains(ContentManagerName) && ContentManagerName != FlatRedBallServices.GlobalContentManager) { FlatRedBallServices.GetContentManagerByName(ContentManagerName).AddUnloadMethod("PlatformerCharacterBaseStaticUnload", UnloadStaticContent); mRegisteredUnloads.Add(ContentManagerName); } } } CustomLoadStaticContent(contentManagerName); }
private static void AddAvailableValuesFromFileToList(string absoluteFile, List <string> stringsToReturn, bool shouldAppendFileName) { if (System.IO.File.Exists(absoluteFile)) { try { string toAppend = ""; if (shouldAppendFileName) { // Eventually we want to make this relative to the container, not just the folename toAppend = " in " + FileManager.RemovePath(absoluteFile); } RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime(absoluteFile); rcr.RemoveHeaderWhitespaceAndDetermineIfRequired(); int requiredIndex = -1; for (int i = 0; i < rcr.Headers.Length; i++) { if (rcr.Headers[i].IsRequired) { requiredIndex = i; break; } } if (requiredIndex != -1) { foreach (string[] record in rcr.Records) { string possibleValue = record[requiredIndex]; if (!string.IsNullOrEmpty(possibleValue)) { if (shouldAppendFileName) { stringsToReturn.Add(possibleValue + toAppend); } else { stringsToReturn.Add(possibleValue); } } } } } catch (Exception e) { // do nothing for now... } } }
public static void GetDictionaryTypes(ReferencedFileSave referencedFileSave, out string keyType, out string valueType) { valueType = referencedFileSave.GetTypeForCsvFile(); // To know the value type, we gotta pop this bad boy open and find the first requied type keyType = null; char oldDelimiter = CsvFileManager.Delimiter; switch (referencedFileSave.CsvDelimiter) { case AvailableDelimiters.Comma: CsvFileManager.Delimiter = ','; break; case AvailableDelimiters.Tab: CsvFileManager.Delimiter = '\t'; break; case AvailableDelimiters.Pipe: CsvFileManager.Delimiter = '|'; break; } string absoluteFileName = ProjectManager.MakeAbsolute(referencedFileSave.Name); // If the file doesn't exist this will generate bad code. But this isn't // considered a silent failure because Glue will raise flags about missing // files earlier (like when it first starts up). We don't want to crash the // entire application in this case. if (System.IO.File.Exists(absoluteFileName)) { RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime(absoluteFileName); // See if any of the headers are required foreach (CsvHeader header in rcr.Headers) { int indexOfOpeningParen = header.Name.IndexOf("("); if (indexOfOpeningParen != -1) { if (header.Name.IndexOf("required", indexOfOpeningParen) != -1) { keyType = CsvHeader.GetClassNameFromHeader(header.Name); break; } } } } CsvFileManager.Delimiter = oldDelimiter; }
public void TestSerialization() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[4]; rcr.Headers[0] = new CsvHeader("Header1"); rcr.Headers[1] = new CsvHeader("Header2"); rcr.Headers[2] = new CsvHeader("Newline Test1"); rcr.Headers[3] = new CsvHeader("Something"); rcr.Headers[3].IsRequired = true; rcr.Records = new List <string[]>(); rcr.Records.Add(new string[4]); rcr.Records[0][0] = "NoQuotes \"Quotes\" NoQuotes"; rcr.Records[0][1] = "Value = \"Something\""; rcr.Records[0][2] = string.Concat("Line 1", Environment.NewLine, "Line 2"); rcr.Records[0][3] = ""; string result = rcr.GenerateCsvString(); if (!result.Contains("NoQuotes \"\"Quotes\"\" NoQuotes")) { throw new Exception("rcr.GenerateCsvString is not properly adding double quotes for quotes"); } if (!result.Contains("\"Value = \"\"Something\"\"\"")) { throw new Exception("rcr.GenerateCsvString is not properly wrapping text in quotes when it should"); } if (!result.Contains(string.Concat("\"", rcr.Records[0][2], "\""))) { throw new Exception("rcr.GenerateCsvString is not properly wrapping newlined text in quotes"); } FileManager.SaveText(result, "SavedCsv.csv"); RuntimeCsvRepresentation loaded = CsvFileManager.CsvDeserializeToRuntime("SavedCsv.csv"); for (int i = 0; i < loaded.Records.Count; i++) { for (int j = 0; j < loaded.Records[i].Length; j++) { var loadedAtIandJ = loaded.Records[i][j]; var rcrAtIandJ = rcr.Records[i][j]; if (loadedAtIandJ != rcrAtIandJ) { throw new Exception("Loaded RCR doesn't equal what was saved"); } } } }
public void Initialize(string contentTypesFileLocation, string startupPath) { mStartupPath = startupPath; mCoreTypesFileLocation = contentTypesFileLocation; if (!File.Exists(contentTypesFileLocation)) { throw new Exception("Could not find the file " + contentTypesFileLocation + " when trying to initialize the AvailableAssetTypes"); } try { // We create a temporary // list to deserialize to // so that we can take the contents // and insert them at the front of the // list. This makes the default implementations // show up first in the list so they can be found // first if searching by runtime type name. //List<AssetTypeInfo> tempList = new List<AssetTypeInfo>(); // Update: We now have a core asset types list CsvFileManager.CsvDeserializeList(typeof(AssetTypeInfo), contentTypesFileLocation, mCoreAssetTypes); } catch (Exception e) { string message = "Could not load the AssetTypes from\n" + contentTypesFileLocation + "\nThis probably means your ContentTypes.csv is corrupt (the file was found). You should re-install Glue."; throw new Exception(message, e); } if (Directory.Exists(GlobalCustomContentTypesFolder)) { List <string> extraCsvs = FileManager.GetAllFilesInDirectory(GlobalCustomContentTypesFolder, "csv", 0); foreach (string file in extraCsvs) { try { AddAssetTypes(file); } catch (Exception e) { MessageBox.Show("Failed to add additional asset types from file " + file + "\n\nError info:\n" + e); } } } }
public static void Initialize() { string fileToLoad = FlatRedBall.IO.FileManager.MakeAbsolute( @"Content/BuiltInEvents.csv"); try { CsvFileManager.CsvDeserializeDictionary <string, EventSave>(fileToLoad, mAllEvents); } catch (Exception e) { System.Windows.Forms.MessageBox.Show("Could not initialize event manager. Check to make sure " + "the following file exists and is not corrupt: " + fileToLoad); } }
private static string GetClassInfo(string fileName, RuntimeCsvRepresentation rcr, CustomClassSave customClass, out List <TypedMemberBase> members, out Dictionary <string, string> untypedMembers) { bool usesCustomClass = customClass != null; List <RuntimeCsvRepresentation> rcrsForClass = new List <RuntimeCsvRepresentation>(); if (usesCustomClass) { foreach (string name in customClass.CsvFilesUsingThis) { ReferencedFileSave foundRfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(name); if (foundRfs == null) { int m = 3; } else { fileName = foundRfs.Name; fileName = ProjectManager.MakeAbsolute(fileName); RuntimeCsvRepresentation runtimeToAdd = null; try { runtimeToAdd = CsvFileManager.CsvDeserializeToRuntime(fileName); } catch (Exception e) { MessageBox.Show("Error trying to parse CSV:\n" + e.ToString()); } if (runtimeToAdd != null) { rcrsForClass.Add(runtimeToAdd); } } } } else if (rcr != null) { rcrsForClass.Add(rcr); } GetClassInfoFromCsv(rcrsForClass, customClass, out members, out untypedMembers); return(fileName); }
public IActionResult Upload(IFormFile file) { if (file != null && file.Length > 0) { try { var fileManager = new CsvFileManager(); return(View("Index", fileManager.ParseFileData(file))); } catch { return(RedirectToAction("Error")); } } return(RedirectToAction("Index")); }
internal void CreateAdditionalCsvFile(string name, GlobalOrProjectSpecific globalOrProjectSpecific) { // We're going to load the full // AvailableAssetTypes just to get // the headers. Then we'll // create a new RCR, copy over the headers // then save off the RCR using the argument // fileName. The new one will be empty except // for the headers. RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime( mCoreTypesFileLocation); rcr.Records = new List <string[]>(); string desiredFullPath = null; if (globalOrProjectSpecific == GlobalOrProjectSpecific.Global) { desiredFullPath = GlobalCustomContentTypesFolder + name + ".csv"; } else // project-specific { desiredFullPath = ProjectSpecificContentTypesFolder + name + ".csv"; } if (File.Exists(desiredFullPath)) { MessageBox.Show("The CSV " + desiredFullPath + " already exists."); } else { try { CsvFileManager.Serialize(rcr, desiredFullPath); } catch (UnauthorizedAccessException) { MessageBox.Show("Unable to save the CSV file. You need to run Glue as an administrator"); } catch (Exception e) { MessageBox.Show("Unknown error attempting to create the CSV:\n\n" + e.ToString()); } } }
/// <summary> /// Verifies that the CSV is properly set up - this code doesn't generate anything because uniform type CSVs don't actually make /// a new class. They'll instead deserialize to something like string[] /// </summary> /// <param name="rfs">The file reference to the CSV.</param> /// <param name="fileName">The filename of the CSV</param> /// <param name="oldDelimiter">The old CSV delimiter - what to set the CSV delimiter back to after deserializing this CSV.</param> private static void CheckUniformTypeValidity(ReferencedFileSave rfs, string fileName, char oldDelimiter) { string duplicateHeader; RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime( fileName); CsvFileManager.Delimiter = oldDelimiter; duplicateHeader = rcr.GetFirstDuplicateHeader; if (rfs.CreatesDictionary) { string duplicateRequiredField = rcr.FirstDuplicateRequiredField; if (!string.IsNullOrEmpty(duplicateRequiredField)) { System.Windows.Forms.MessageBox.Show("The CSV file " + fileName + "\n\nhas a duplicate required field:" + duplicateRequiredField); } } }
private static void DeserializeToRcr(AvailableDelimiters delimiter, string fileName, out RuntimeCsvRepresentation rcr, out bool succeeded) { rcr = null; succeeded = true; try { // Let's load this bad boy and get info about the class we need to make rcr = CsvFileManager.CsvDeserializeToRuntime(fileName); } catch (Exception e) { GlueGui.ShowMessageBox("Error parsing CSV\n\n" + fileName + "\nAttempted to use " + delimiter + " as the delimiter. If this is not the delimiter of the file, try changing the delimiter in Glue after the file is added"); FlatRedBall.Glue.Plugins.PluginManager.ReceiveError(e.ToString()); succeeded = false; } }
private static Dictionary <string, TopDownValues> GetCsvValues(EntitySave currentEntitySave) { var csvValues = new Dictionary <string, TopDownValues>(); var filePath = CsvGenerator.Self.CsvFileFor(currentEntitySave); bool doesFileExist = filePath.Exists(); if (doesFileExist) { try { CsvFileManager.CsvDeserializeDictionary <string, TopDownValues>(filePath.FullPath, csvValues); } catch (Exception e) { PluginManager.ReceiveError("Error trying to load top down csv:\n" + e.ToString()); } } return(csvValues); }
private static Dictionary <string, PlatformerValues> GetCsvValues(EntitySave currentEntitySave) { Dictionary <string, PlatformerValues> csvValues = new Dictionary <string, PlatformerValues>(); string absoluteFileName = CsvGenerator.Self.CsvFileFor(currentEntitySave); bool doesFileExist = System.IO.File.Exists(absoluteFileName); if (doesFileExist) { try { CsvFileManager.CsvDeserializeDictionary <string, PlatformerValues>(absoluteFileName, csvValues); } catch (Exception e) { PluginManager.ReceiveError("Error trying to load platformer csv:\n" + e.ToString()); } } return(csvValues); }
public static void AddDatabase(string fileName, char delimiter) { RuntimeCsvRepresentation rcr; char oldDelimiter = CsvFileManager.Delimiter; CsvFileManager.Delimiter = delimiter; Dictionary <string, string[]> entryDictionary = new Dictionary <string, string[]>(); CsvFileManager.CsvDeserializeDictionary <string, string[]>(fileName, entryDictionary, out rcr); CsvFileManager.Delimiter = oldDelimiter; List <string> headerList = new List <string>(); foreach (CsvHeader header in rcr.Headers) { headerList.Add(header.Name); } AddDatabase(entryDictionary, headerList); }
private void OpenSourceFile() { if (_openSourceFileDialog.ShowDialog() != DialogResult.OK) { return; } try { var fileManager = new CsvFileManager(_logger); var items = fileManager.LoadDataItems(_openSourceFileDialog.FileName); gridSource.SuspendLayout(); _matchingManager.SourceData.Clear(); _matchingManager.SourceMatchedData.Clear(); foreach (var item in items) { _matchingManager.SourceData.Add(item); } fileNameStatusLabel.Text = Path.GetFileName(_openSourceFileDialog.FileName); MessageBox.Show($"Загрузка файла {_openSourceFileDialog.FileName} завершена.", "XDataConv", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { _logger.Error($"Error opening file {_openSourceFileDialog.FileName}", ex); MessageBox.Show($"Ошибка открытия файла {_openSourceFileDialog.FileName}.{Environment.NewLine}{ex.Message}", "XDataConv", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { gridSource.ResumeLayout(); UpdateSourceTabsCounters(); } }
private string GetStringsGeneratedCodeFileContents(ReferencedFileSave referencedFileSave) { var glueState = Container.Get <IGlueState>(); var glueCommands = Container.Get <IGlueCommands>(); string toReturn = null; if (referencedFileSave != null) { var namespaceName = $"{glueState.ProjectNamespace}.DataTypes"; ICodeBlock document = new CodeDocument(0); ICodeBlock codeBlock = document.Namespace(namespaceName); codeBlock = codeBlock.Class("Strings"); string fileName = glueCommands.GetAbsoluteFileName(referencedFileSave); var doesFileExist = System.IO.File.Exists(fileName); if (System.IO.File.Exists(fileName)) { var runtime = CsvFileManager.CsvDeserializeToRuntime(fileName); foreach (var row in runtime.Records) { TryAddMemberForRow(codeBlock, row); } toReturn = document.ToString(); } } return(toReturn); }
public T LoadFromFile <T>(string assetName) { string extension = FileManager.GetExtension(assetName); if (FileManager.IsRelative(assetName)) { // get the absolute path using the current relative directory assetName = FileManager.RelativeDirectory + assetName; } string fullNameWithType = assetName + typeof(T).Name; // get the dictionary by the contentManagerName. If it doesn't exist, GetDisposableDictionaryByName // will create it. if (mDisposableDictionary.ContainsKey(fullNameWithType)) { #if PROFILE mHistory.Add(new ContentLoadHistory( TimeManager.CurrentTime, typeof(T).Name, fullNameWithType, ContentLoadDetail.Cached)); #endif return((T)mDisposableDictionary[fullNameWithType]); } else if (mNonDisposableDictionary.ContainsKey(fullNameWithType)) { return((T)mNonDisposableDictionary[fullNameWithType]); } else { #if PROFILE mHistory.Add(new ContentLoadHistory( TimeManager.CurrentTime, typeof(T).Name, fullNameWithType, ContentLoadDetail.HddFromFile)); #endif #if DEBUG // The ThrowExceptionIfFileDoesntExist // call used to be done before the checks // in the dictionaries. But whatever is held // in there may not really be a file so let's check // if the file exists after we check the dictionaries. FileManager.ThrowExceptionIfFileDoesntExist(assetName); #endif IDisposable loadedAsset = null; if (typeof(T) == typeof(Texture2D) || typeof(T) == typeof(Microsoft.Xna.Framework.Graphics.Texture2D)) { // for now we'll create it here, eventually have it in a dictionary: loadedAsset = textureContentLoader.Load(assetName); } #region Scene else if (typeof(T) == typeof(FlatRedBall.Scene)) { FlatRedBall.Scene scene = FlatRedBall.Content.Scene.SceneSave.FromFile(assetName).ToScene(mName); object sceneAsObject = scene; lock (mNonDisposableDictionary) { if (!mNonDisposableDictionary.ContainsKey(fullNameWithType)) { mNonDisposableDictionary.Add(fullNameWithType, scene); } } return((T)sceneAsObject); } #endregion #region EmitterList else if (typeof(T) == typeof(EmitterList)) { EmitterList emitterList = EmitterSaveList.FromFile(assetName).ToEmitterList(mName); mNonDisposableDictionary.Add(fullNameWithType, emitterList); return((T)((object)emitterList)); } #endregion #region Image #if !MONOGAME else if (typeof(T) == typeof(Image)) { switch (extension.ToLowerInvariant()) { case "gif": Image image = Image.FromFile(assetName); loadedAsset = image; break; } } #endif #endregion #region BitmapList #if !XBOX360 && !SILVERLIGHT && !WINDOWS_PHONE && !MONOGAME else if (typeof(T) == typeof(BitmapList)) { loadedAsset = BitmapList.FromFile(assetName); } #endif #endregion #region NodeNetwork else if (typeof(T) == typeof(NodeNetwork)) { NodeNetwork nodeNetwork = NodeNetworkSave.FromFile(assetName).ToNodeNetwork(); mNonDisposableDictionary.Add(fullNameWithType, nodeNetwork); return((T)((object)nodeNetwork)); } #endregion #region ShapeCollection else if (typeof(T) == typeof(ShapeCollection)) { ShapeCollection shapeCollection = ShapeCollectionSave.FromFile(assetName).ToShapeCollection(); mNonDisposableDictionary.Add(fullNameWithType, shapeCollection); return((T)((object)shapeCollection)); } #endregion #region PositionedObjectList<Polygon> else if (typeof(T) == typeof(PositionedObjectList <FlatRedBall.Math.Geometry.Polygon>)) { PositionedObjectList <FlatRedBall.Math.Geometry.Polygon> polygons = PolygonSaveList.FromFile(assetName).ToPolygonList(); mNonDisposableDictionary.Add(fullNameWithType, polygons); return((T)((object)polygons)); } #endregion #region AnimationChainList else if (typeof(T) == typeof(AnimationChainList)) { if (assetName.EndsWith("gif")) { #if WINDOWS_8 || UWP || DESKTOP_GL throw new NotImplementedException(); #else AnimationChainList acl = new AnimationChainList(); acl.Add(FlatRedBall.Graphics.Animation.AnimationChain.FromGif(assetName, this.mName)); acl[0].ParentGifFileName = assetName; loadedAsset = acl; #endif } else { loadedAsset = AnimationChainListSave.FromFile(assetName).ToAnimationChainList(mName); } mNonDisposableDictionary.Add(fullNameWithType, loadedAsset); } #endregion else if (typeof(T) == typeof(Song)) { var loader = new SongLoader(); return((T)(object)loader.Load(assetName)); } #if MONOGAME else if (typeof(T) == typeof(SoundEffect)) { T soundEffect; if (assetName.StartsWith(@".\") || assetName.StartsWith(@"./")) { soundEffect = base.Load <T>(assetName.Substring(2)); } else { soundEffect = base.Load <T>(assetName); } return(soundEffect); } #endif #region RuntimeCsvRepresentation #if !SILVERLIGHT else if (typeof(T) == typeof(RuntimeCsvRepresentation)) { #if XBOX360 throw new NotImplementedException("Can't load CSV from file. Try instead to use the content pipeline."); #else return((T)((object)CsvFileManager.CsvDeserializeToRuntime(assetName))); #endif } #endif #endregion #region SplineList else if (typeof(T) == typeof(List <Spline>)) { List <Spline> splineList = SplineSaveList.FromFile(assetName).ToSplineList(); mNonDisposableDictionary.Add(fullNameWithType, splineList); object asObject = splineList; return((T)asObject); } else if (typeof(T) == typeof(SplineList)) { SplineList splineList = SplineSaveList.FromFile(assetName).ToSplineList(); mNonDisposableDictionary.Add(fullNameWithType, splineList); object asObject = splineList; return((T)asObject); } #endregion #region BitmapFont else if (typeof(T) == typeof(BitmapFont)) { // We used to assume the texture is named the same as the font file // But now FRB understands the .fnt file and gets the PNG from the font file //string pngFile = FileManager.RemoveExtension(assetName) + ".png"; string fntFile = FileManager.RemoveExtension(assetName) + ".fnt"; BitmapFont bitmapFont = new BitmapFont(fntFile, this.mName); object bitmapFontAsObject = bitmapFont; return((T)bitmapFontAsObject); } #endregion #region Text else if (typeof(T) == typeof(string)) { return((T)((object)FileManager.FromFileText(assetName))); } #endregion #region Catch mistakes #if DEBUG else if (typeof(T) == typeof(Spline)) { throw new Exception("Cannot load Splines. Try using the List<Spline> type instead."); } else if (typeof(T) == typeof(Emitter)) { throw new Exception("Cannot load Emitters. Try using the EmitterList type instead."); } #endif #endregion #region else, exception! else { throw new NotImplementedException("Cannot load content of type " + typeof(T).AssemblyQualifiedName + " from file. If you are loading " + "through the content pipeline be sure to remove the extension of the file " + "name."); } #endregion if (loadedAsset != null) { lock (mDisposableDictionary) { // Multiple threads could try to load this content simultaneously if (!mDisposableDictionary.ContainsKey(fullNameWithType)) { mDisposableDictionary.Add(fullNameWithType, loadedAsset); } } } return((T)loadedAsset); } }
public override TImport Import(string filename, ContentImporterContext context) { BuildtimeCsvRepresentation buildtimeCsvRepresentation = CsvFileManager.CsvDeserializeToRuntime <BuildtimeCsvRepresentation>(filename); return(buildtimeCsvRepresentation); }
void CustomInitialize() { if (StaticVariableEntity.FromGlobalCsv == null) { throw new Exception("Referencing a static entity's CSV variables is not working becaus the static variable is not properly set. This variable is of a type defined in GlobalContent."); } // check if constants are made properly string in1 = SpreadsheetClass.FirstGuy; // to ignore warnings if (in1 != null) { } string in2 = SpreadsheetClass.GuyInFile2; if (in2 != null) { } if (GlobalCsvVariable.Name != "Name2") { throw new Exception("Variables using global CSVs in Screens are not getting their values set"); } if (GlobalCsvVariableWithEvent.Name != "Name3") { throw new Exception("Variables with events using global CSVs in Screens are not getting their values set"); } if (mHasCsvVariableEventBeenRaised == false) { throw new Exception("Events for CSV variables that are set in Glue are not raised"); } if (new DataTypes.Spreadsheet().ListOfString == null) { throw new Exception("new instances of CSV objects should 'new' any lists"); } // Check that the class with no associated CSV actually exists - we'll get a compile error if not: ClassWithNoAssociatedCsvs instance = new ClassWithNoAssociatedCsvs(); var list = CsvFileManager.CsvDeserializeList(typeof(ManualCsvClass), "Content/Screens/CsvScreen/CsvManuallyLoadedForPropertyTest.csv"); ManualCsvClass entry = list[0] as ManualCsvClass; if (entry.StringList.Count == 0) { throw new NotImplementedException("CSVs that contain lists which are deserialized into properties are not set"); } if (CsvUsingCustomDataFile["First"].StringListField.Count == 0) { throw new Exception("Primitive (string) lists as fields in custom data are not being deserialized properly"); } if (CsvUsingCustomDataFile["First"].StringListProperty.Count == 0) { throw new Exception("Primitive (string) lists as properties in custom data are not being deserialized properly"); } if (CsvUsingCustomDataFile["First"].ComplexCustomTypeListField.Count == 0) { throw new Exception("Complex type lists as fields in custom data are not being deserialized properly"); } if (CsvUsingCustomDataFile["First"].ComplexCustomTypeListProperty.Count == 0) { throw new Exception("Complex type lists as properties in custom data are not being deserialized properly"); } if (CsvUsingCustomDataFile["First"].ComplexCustomTypeListProperty[1].CustomEnumType != CustomDataTypes.CustomEnumType.Enum2) { throw new Exception("Enums in complex type property lists are not getting set."); } if (CsvUsingCustomDataFile["First"].StringProperty != "Test1") { throw new Exception("String properties are not being set correctly"); } }
public void SetUp() { _csvFileManager = new CsvFileManager(); }
private static bool CreateConstsForCsvEntries(ReferencedFileSave initialRfs, List <TypedMemberBase> members, Dictionary <string, string> untypedMembers, ICodeBlock codeBlock) { bool succeeded = true; bool addToOrderedLists = true; CustomClassSave customClass = GetCustomClassForCsv(initialRfs.Name); bool usesCustomClass = customClass != null; List <ReferencedFileSave> rfsesForClass = new List <ReferencedFileSave>(); if (usesCustomClass) { foreach (string name in customClass.CsvFilesUsingThis) { ReferencedFileSave foundRfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(name); if (foundRfs != null) { rfsesForClass.Add(foundRfs); } } } else { rfsesForClass.Add(initialRfs); } foreach (ReferencedFileSave rfs in rfsesForClass) { if (rfs.CreatesDictionary) { string fileName = rfs.Name; fileName = ProjectManager.MakeAbsolute(fileName); var rcr = CsvFileManager.CsvDeserializeToRuntime(fileName); rcr.RemoveHeaderWhitespaceAndDetermineIfRequired(); int requiredIndex = rcr.GetRequiredIndex(); if (requiredIndex == -1) { succeeded = false; GlueGui.ShowMessageBox("The file " + rfs.Name + " is marked as a dictionary but has no column marked as required"); } else { string type = GetRequiredKeyType(rcr, members, untypedMembers, requiredIndex); FillCodeBlockWithKeys(codeBlock, type, rcr); // The first entry will be the "primary" one? if (addToOrderedLists) { FillOrderedListWithKeys(codeBlock, type, rcr); addToOrderedLists = false; } } } } return(succeeded); }