public static void AdjustDataFilesIfIsCsv(string oldName, ReferencedFileSave rfs)
        {
            // We'll remove the old file from the project, delete it, then have the RFS regenerate/add the new one to the project

            //////////////Early Out///////////////////

            if (!rfs.IsCsvOrTreatedAsCsv || UsesAlterntaiveClass(rfs))
            {
                return;
            }
            ////////////End Early Out/////////////////
            string className = rfs.GetTypeForCsvFile(oldName);

            string whatToRemove = "DataTypes/" + className + ".Generated.cs";
            ProjectManager.ProjectBase.RemoveItem(whatToRemove);
            string fileToDelete = whatToRemove;
            fileToDelete = ProjectManager.MakeAbsolute(fileToDelete);
            if (System.IO.File.Exists(fileToDelete))
            {
                try
                {
                    FileHelper.DeleteFile(fileToDelete);
                }
                catch (Exception e)
                {
                    GlueGui.ShowMessageBox("Could not delete the file " + fileToDelete + "\n\nThe file is no longer referneced by the project so it is not necessary to delete this file manually.");
                }
            }

            CsvCodeGenerator.GenerateAndSaveDataClass(rfs, rfs.CsvDelimiter);
        }

        private TreeNode GetTreeNodeFor(ReferencedFileSave referencedFileSave, string currentPath, TreeNode treeNode)
        {

            return null;


		}

        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 static string CreateZip(ReferencedFileSave rfs)
        {
            string absoluteFile = ProjectManager.MakeAbsolute(rfs.Name, true);

            List<string> allFiles = FileReferenceManager.Self.GetFilesReferencedBy(
                absoluteFile, TopLevelOrRecursive.Recursive);

            #region Check for relative files

            string directoryOfMainFile = FileManager.GetDirectory(absoluteFile);
            bool areAnyFilesOutsideOfMainDirectory = false;
            foreach (string referencedFile in allFiles)
            {
                if (!FileManager.IsRelativeTo(referencedFile, directoryOfMainFile))
                {
                    areAnyFilesOutsideOfMainDirectory = true;
                    break;
                }
            }


            #endregion
            string outputFile;

            if (areAnyFilesOutsideOfMainDirectory)
            {
                outputFile = null;    
            }
            else
            {
                allFiles.Add(absoluteFile);

                string extension = FileManager.GetExtension(rfs.Name);
                string newExtension = "zip";
                if (extension.Length == 4 && extension[3] == 'x')
                {
                    newExtension = extension.Substring(0, 3) + 'z';
                }

                outputFile = FileManager.RemoveExtension(absoluteFile) + "." + newExtension;

                using (ZipFile zip = new ZipFile())
                {
                    foreach (string fileToAdd in allFiles)
                    {
                        string directory = FileManager.MakeRelative(FileManager.GetDirectory(fileToAdd), directoryOfMainFile);
                        if (directory.EndsWith("/"))
                        {
                            directory = directory.Substring(0, directory.Length - 1);
                        }

                        zip.AddFile(fileToAdd, directory);
                    }

                    zip.Save(outputFile);
                }
            }
            return outputFile;
        }

 public static void GenerateTimedEmit(ICodeBlock codeBlock, ReferencedFileSave rfs, IElement element)
 {
     if (rfs.LoadedAtRuntime && !rfs.LoadedOnlyWhenReferenced && (element is ScreenSave || rfs.IsSharedStatic == false)
         && !string.IsNullOrEmpty(rfs.Name) && FileManager.GetExtension(rfs.Name) == "emix")
     {
         codeBlock.Line(rfs.GetInstanceName() + ".TimedEmit();");
     }
 }

        public void Select(ReferencedFileSave referencedFile, string objectInFile = null)
        {
            // first let's select it:
            GlueState.Self.CurrentReferencedFileSave = referencedFile;

            // Next lets tell the plugin manager to try to find this object:
            if( string.IsNullOrEmpty(objectInFile) == false)
            {
                PluginManager.SelectItemInCurrentFile(objectInFile);
            }
        }

        private void CreateCsvContainerEntitySave()
        {
            mCsvContainerEntitySave = new EntitySave();
            mCsvContainerEntitySave.Name = "CsvContainerEntityInExposedVariableTests";
            ObjectFinder.Self.GlueProject.Entities.Add(mCsvContainerEntitySave);

            ReferencedFileSave rfs = new ReferencedFileSave();
            rfs.SourceFile = "Whatever.csv";
            rfs.Name = "Whatever.csv";
            mCsvContainerEntitySave.ReferencedFiles.Add(rfs);
        }

        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();
                }
            }
        }

        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 SetFrom(ReferencedFileSave rfs)
        {
            backingData = rfs;

            foreach(var project in GlueState.Self.GetProjects())
            {
                var projectName = project.Name;

                var settings = new IndividualProjectSetting();
                settings.ProjectName = projectName;
                settings.IsEnabled = backingData.ProjectsToExcludeFrom.Contains(projectName) == false;
                settings.PropertyChanged += HandlePropertyChanged;

                ProjectSettings.Add(settings);
            }
        }

        private static void ExcludeFileFromProject(string projectName, ReferencedFileSave rfs)
        {
            rfs.ProjectsToExcludeFrom.Add(projectName);

            var syncedProject = GlueState.Self.GetProjects().FirstOrDefault(item => item.Name == projectName);

            if(syncedProject != null)
            {
                string absolute = GlueCommands.Self.GetAbsoluteFileName(rfs);
                syncedProject.RemoveItem(absolute);
                if (syncedProject.ContentProject != null)
                {
                    syncedProject.ContentProject.RemoveItem(absolute);
                }
            }
        }

        public void PopulateWithReferencesTo(ReferencedFileSave rfs)
        {
            List<IElement> elements = ObjectFinder.Self.GetAllElementsReferencingFile(rfs.Name);

            foreach (IElement element in elements)
            {
                var rfsInThisElement = element.GetReferencedFileSave(rfs.Name);
                listBox1.Items.Add(rfsInThisElement);

                foreach(var namedObject in element.AllNamedObjects)
                {
                    if(namedObject.SourceType == SourceType.File &&
                        namedObject.SourceFile == rfsInThisElement.Name)
                    {
                        listBox1.Items.Add(namedObject);
                    }
                }
            }

            // If this is a CSV, then loop through all of the variables and see if any of them use this type
            if (rfs.IsCsvOrTreatedAsCsv)
            {
                string className = rfs.Name;
                CustomClassSave customClass = ObjectFinder.Self.GlueProject.GetCustomClassReferencingFile(rfs.Name);
                if (customClass != null)
                {
                    className = customClass.Name;
                }

                foreach (IElement element in ObjectFinder.Self.GlueProject.Screens)
                {
                    foreach (CustomVariable customVariable in element.CustomVariables.Where(customVariable => customVariable.Type == className))
                    {
                        listBox1.Items.Add(customVariable);
                    }
                }
                foreach (IElement element in ObjectFinder.Self.GlueProject.Entities)
                {
                    foreach (CustomVariable customVariable in element.CustomVariables.Where(customVariable => customVariable.Type == className))
                    {
                        listBox1.Items.Add(customVariable);
                    }
                }
            }

        }

        public void CopyToBuildFolder(ReferencedFileSave rfs)
        {
            string projectName = FileManager.RemovePath(FileManager.RemoveExtension(GlueState.Self.CurrentGlueProjectFileName));
            string buildFolder = FileManager.GetDirectory(GlueState.Self.CurrentGlueProjectFileName) + "bin/x86/debug/Content/";

            string destination = buildFolder + rfs.Name;
            string source = ProjectManager.ContentDirectory + rfs.Name;

            try
            {
                System.IO.File.Copy(source, destination, true);

                PluginManager.ReceiveOutput("Copied " + source + " ==> " + destination);
            }
            catch (Exception e)
            {
                System.Windows.Forms.MessageBox.Show("Error copying file:\n\n" + e.ToString());

            }
        }

        public void Initialize()
        {

            // Couldn't run tests here because it requires FRB to be initialized.  
            OverallInitializer.Initialize();

            mBaseEntity = new EntitySave();
            mBaseEntity.Name = "ReferencedFileSaveTestsBaseEntity";

            ReferencedFileSave rfs = new ReferencedFileSave();


            ObjectFinder.Self.GlueProject.Entities.Add(mBaseEntity);

            mDerivedEntity = new EntitySave();
            mDerivedEntity.Name = "ReferencedFileSaveTestsDerivedEntity";
            mDerivedEntity.BaseEntity = mBaseEntity.Name;
            ObjectFinder.Self.GlueProject.Entities.Add(mDerivedEntity);

        }

        public static bool ContainsRecursively(this IElement element, ReferencedFileSave whatToLookFor)
        {
            foreach (ReferencedFileSave rfs in element.ReferencedFiles)
            {
                if (rfs == whatToLookFor)
                {
                    return true;
                }
            }

            if (!string.IsNullOrEmpty(element.BaseElement))
            {
                IElement baseElement = ObjectFinder.Self.GetIElement(element.BaseElement);
                if (baseElement != null)
                {
                    return baseElement.ContainsRecursively(whatToLookFor);
                }
            }
            return false;
        }

        public void TestReferencedFileSave()
        {
            EntitySave entitySave = new EntitySave();

            ReferencedFileSave rfs = new ReferencedFileSave();
            rfs.Name = "File.png";
            entitySave.ReferencedFiles.Add(rfs);

            string whyNot;
            NameVerifier.IsReferencedFileNameValid("File", null, null, entitySave, out whyNot);
            if(string.IsNullOrEmpty(whyNot))
            {
                throw new Exception("Same-named files shouldn't be allowed, but the NameVerifier allows it.");
            }

            NameVerifier.IsReferencedFileNameValid("File.wav", null, null, entitySave, out whyNot);
            if (string.IsNullOrEmpty(whyNot))
            {
                throw new Exception("Same-named files shouldn't be allowed, but the NameVerifier allows it.");
            }

            NameVerifier.IsReferencedFileNameValid("Folder/File.wav", null, null, entitySave, out whyNot);
            if (string.IsNullOrEmpty(whyNot))
            {
                throw new Exception("Same-named files shouldn't be allowed, but the NameVerifier allows it.");
            }

            NameVerifier.IsReferencedFileNameValid("Folder/File", null, null, entitySave, out whyNot);
            if (string.IsNullOrEmpty(whyNot))
            {
                throw new Exception("Same-named files shouldn't be allowed, but the NameVerifier allows it.");
            }

            NameVerifier.IsReferencedFileNameValid("if", null, null, entitySave, out whyNot);
            if (string.IsNullOrEmpty(whyNot))
            {
                throw new Exception("'if' is a reserved keyword and should not be allowed as a file name");
            }

        }

        public void SelectFile(ReferencedFileSave rfs)
        {
            // see if this has a created class
            var customClass = ObjectFinder.Self.GetCustomClassFor(rfs);

            TreeNode treeNodeToSelect = null;

            if(customClass != null)
            {
                var treeNode = this.TreeView.Nodes
                    .FirstOrDefault(item => item.Tag == customClass);

                if(treeNode != null)
                {
                    var subnode = treeNode.Nodes
                        .FirstOrDefault(item => item.Text == rfs.Name);

                    treeNodeToSelect = subnode;
                }
            }
            
            TreeView.SelectedNode = treeNodeToSelect;
        }

 public void RemoveReferencedFile(ReferencedFileSave referencedFileToRemove, List<string> additionalFilesToRemove)
 {
     RemoveReferencedFile(referencedFileToRemove, additionalFilesToRemove, true);
 }

 private static void ApplyOptions(ReferencedFileSave toReturn, string options)
 {
     if (toReturn.IsCsvOrTreatedAsCsv)
     {
         toReturn.CreatesDictionary = options == "Dictionary";
     }
 }

        public TreeNode ReferencedFileSaveTreeNode(ReferencedFileSave referencedFileSave)
        {
            IElement container = referencedFileSave.GetContainer();

            if (container == null)
            {
                return TreeNodeByTagIn(referencedFileSave, ElementViewWindow.GlobalContentFileNode.Nodes);
            }
            else if (container is ScreenSave)
            {
                ScreenTreeNode screenTreeNode = GlueState.Self.Find.ScreenTreeNode((ScreenSave)container);
                return screenTreeNode.GetTreeNodeFor(referencedFileSave);
            }
            else if (container is EntitySave)
            {
                EntityTreeNode entityTreeNode = GlueState.Self.Find.EntityTreeNode((EntitySave)container);
                return entityTreeNode.GetTreeNodeFor(referencedFileSave);
            }

            return null;

        }