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);
        }
Exemplo n.º 2
0
        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;
        }
        private TreeNode GetTreeNodeFor(ReferencedFileSave referencedFileSave, string currentPath, TreeNode treeNode)
        {

            return null;


		}
Exemplo n.º 4
0
        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;
        }
Exemplo n.º 5
0
 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 TreeNode GetTreeNodeFor(ReferencedFileSave referencedFileSave)
		{
            try
            {
                // the directory may be like Entities/Something but the ReferencedFileSave might be Content/Entities/Something
                // so if the RFS starts with Content, then get rid of it

                string rfsName = referencedFileSave.Name;
                if (rfsName.StartsWith("Content/"))
                {
                    rfsName = rfsName.Substring("Content/".Length);
                }

                string thisRelativePath = FileManager.GetDirectoryKeepRelative(rfsName);
                string parentText = this.Parent.Text.Replace("\\", "/");
                
                // Not sure why this is a .Contains...
                // If we're going to do a substring shouldn't
                // it be a .StartsWith?
                //if (thisRelativePath.Contains(parentText))
                if (thisRelativePath.StartsWith(parentText))
                {
                    thisRelativePath = thisRelativePath.Substring(parentText.Length + 1); // add one for the slash '/'
                }


                
                //this.GetRelativePath().Replace("\\", "/");

                //if (referencedFileSave.Name.Contains(thisRelativePath))
                //{
                //    thisRelativePath = referencedFileSave.Name.Substring(thisRelativePath.Length);
                //}

                TreeNode treeNodeToSearch = GetNodeForDirectory(thisRelativePath, this);

                if (treeNodeToSearch == null)
                {
                    treeNodeToSearch = this;
                }

                for (int i = 0; i < treeNodeToSearch.Nodes.Count; i++)
                {
                    TreeNode node = treeNodeToSearch.Nodes[i];

                    if (node.Tag == referencedFileSave)
                    {
                        return node;
                    }
                }
            }
            catch (Exception e)
            {
                int m = 3;
            }
            return null;

        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
        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);
            }
        }
        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();
                }
            }
        }
Exemplo n.º 10
0
        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;
        }
        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);
                }
            }
        }
Exemplo n.º 12
0
        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);
            }
        }
        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);
                    }
                }
            }

        }
Exemplo n.º 14
0
        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);

        }
Exemplo n.º 15
0
        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());

            }
        }
Exemplo n.º 16
0
        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;
        }
Exemplo n.º 17
0
        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");
            }

        }
Exemplo n.º 18
0
        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;
        }
        static Scene LoadScnx(ReferencedFileSave r, IElement container)
        {
            Scene newScene = null;
            try
            {
                newScene = FlatRedBallServices.Load<Scene>(ElementRuntime.ContentDirectory + r.Name, GluxManager.ContentManagerName);

                foreach (Text text in newScene.Texts)
                {
                    text.AdjustPositionForPixelPerfectDrawing = true;
                    if (ObjectFinder.Self.GlueProject.UsesTranslation)
                    {
                        text.DisplayText = LocalizationManager.Translate(text.DisplayText);
                    }
                }

                if (!r.IsSharedStatic || container is ScreenSave)
                {
                    newScene.AddToManagers();
                }
            }
            catch (Exception e)
            {
                throw new Exception("Error loading Scene file " + ElementRuntime.ContentDirectory + r.Name + e.ToString());
            }
            return newScene;
        }
 static AnimationChainList LoadAchx(ReferencedFileSave r)
 {
     AnimationChainList newAnimationChainList;
     string fileToLoad = ElementRuntime.ContentDirectory + r.Name;
     newAnimationChainList = FlatRedBallServices.Load<AnimationChainList>(fileToLoad, GluxManager.ContentManagerName);
     return newAnimationChainList;
 }
        static ShapeCollection LoadShcx(ReferencedFileSave r, IElement container)
        {
            ShapeCollection newShapeCollection;
            newShapeCollection = FlatRedBallServices.Load<ShapeCollection>(ElementRuntime.ContentDirectory + r.Name, GluxManager.ContentManagerName);

            if (!r.IsSharedStatic || container is ScreenSave)
            {
                newShapeCollection.AddToManagers();
            }
            return newShapeCollection;
        }
 static EmitterList LoadEmix(ReferencedFileSave r)
 {
     return FlatRedBallServices.Load<EmitterList>(ElementRuntime.ContentDirectory + r.Name, GluxManager.ContentManagerName);
 }
Exemplo n.º 23
0
        private static string PerformBuildOnFile(this ReferencedFileSave instance, string absoluteSourceName, string absoluteDestinationName, bool runAsync)
        {
            bool doesFileExist = FileManager.FileExists(absoluteSourceName);

            string error = "";

            if (!doesFileExist)
            {
                MessageBox.Show("Could not find the following source file:\n\n" +
                                absoluteSourceName);
            }
            else
            {
                #region Find the BuildToolAssociation
                BuildToolAssociation buildToolAssociation =
                    GetBuildToolAssociation(instance);
                #endregion

                string destinationExtension = FileManager.GetExtension(instance.Name);

                #region If there is no BuildToolAssociation, tell the user that's the case
                if (buildToolAssociation == null)
                {
                    error = "Could not find the build tool for the source file\n" + absoluteSourceName + "\nwith destination extension\n" + destinationExtension;

                    error += "\nThere are " + BuildToolAssociationManager.Self.ProjectSpecificBuildTools.BuildToolList.Count + " build tools registered with Glue";

                    foreach (BuildToolAssociation bta in BuildToolAssociationManager.Self.ProjectSpecificBuildTools.BuildToolList)
                    {
                        error += "\n\"" + bta.SourceFileType + "\" -> " + bta.BuildToolProcessed + " -> \"" + bta.DestinationFileType + "\"";
                    }

                    System.Windows.Forms.MessageBox.Show(error);
                }

                #endregion

                #region else, there is one, so let's do the build

                else
                {
                    #region Call the process (the build tool)



                    try
                    {
                        // Something could have screwed up the relative directory, so let's reset it here
                        FileManager.RelativeDirectory = ProjectManager.ProjectBase.Directory;

                        error = buildToolAssociation.PerformBuildOn(absoluteSourceName, absoluteDestinationName, instance.AdditionalArguments, PluginManager.ReceiveOutput, PluginManager.ReceiveError, runAsync);
                    }
                    catch (FileNotFoundException fnfe)
                    {
                        System.Windows.Forms.MessageBox.Show("Can't find the file:\n" + fnfe.FileName);
                    }
                    catch (Exception e)
                    {
                        System.Windows.Forms.MessageBox.Show("There was an error building the file\n" + absoluteSourceName + "\n\n" +
                                                             e.Message);
                    }
                    #endregion
                }

                #endregion
            }

            return(error);
        }
Exemplo n.º 24
0
 public static string GetRelativePath(this ReferencedFileSave referencedFileSave)
 {
     return(ProjectManager.ContentDirectoryRelative + referencedFileSave.Name);
 }
Exemplo n.º 25
0
 private static void ApplyOptions(ReferencedFileSave toReturn, string options)
 {
     if (toReturn.IsCsvOrTreatedAsCsv)
     {
         toReturn.CreatesDictionary = options == "Dictionary";
     }
 }
Exemplo n.º 26
0
        public static void RefreshSourceFileCache(this ReferencedFileSave instance, bool buildOnMissingFile, out string error)
        {
            error = null;
            string verboseError = "";
            string fullName     = ProjectManager.MakeAbsolute(instance.Name, true);

            try
            {
                // If it has a SourceFile, then no need to throw an error here, it will be built
                if (!FileManager.FileExists(fullName) && string.IsNullOrEmpty(instance.SourceFile))
                {
                }
                else
                {
                    instance.SourceFileCache = ContentParser.GetSourceReferencingFilesReferencedByAsset(fullName, TopLevelOrRecursive.Recursive, ErrorBehavior.ContinueSilently, ref error, ref verboseError);

                    bool hasErrorOccurred = !string.IsNullOrEmpty(error);

                    if (!string.IsNullOrEmpty(verboseError))
                    {
                        int m = 3;
                    }

                    // If the file doesn't exist, no reason to do this, just build it
                    if (hasErrorOccurred)
                    {
                        bool forceError = false;

                        if (buildOnMissingFile && (!string.IsNullOrEmpty(instance.SourceFile) || instance.SourceFileCache.Count != 0))
                        {
                            string subError = instance.PerformExternalBuild(runAsync: false);

                            if (!string.IsNullOrEmpty(subError))
                            {
                                error += "\nTried to build the file, but also got this error:\n" + subError;
                                // This will be returned through the "out"
                                //ErrorReporter.ReportError(fullName, error, forceError);
                            }
                            else if (System.IO.File.Exists(fullName))
                            {
                            }
                        }
                        else
                        {
                            string message = "";
                            if (!FileManager.FileExists(fullName))
                            {
                                message = "Could not find the file\n\n" + fullName + "\n\n" +
                                          "Glue will not be able to properly track dependencies and add the necessary files " +
                                          "to your project until this file is added.\n\nThis often happens if someone forgot to " +
                                          "check something in to Subversion.";
                            }
                            else
                            {
                                message = "Error tracking dependencies for\n\n" + fullName + "\n\nError details:\n\n" +
                                          error;
                            }
                            error = message;
                        }
                    }
                }

                ContentParser.EliminateDuplicateSourceReferencingFiles(instance.SourceFileCache);
            }
            catch (Exception e)
            {
                error = "Error getting referenced files for\n\n" +
                        fullName + "\n\nError:\n\n" + e.ToString();
            }
        }
        public static void ResetVariablesReferencing(this NamedObjectSave namedObject, ReferencedFileSave rfs)
        {
            for (int i = namedObject.InstructionSaves.Count - 1; i > -1; i--)
            {
                var variable = namedObject.InstructionSaves[i];

                if (CustomVariableExtensionMethods.GetIsFile(variable.Type) && (string)(variable.Value) == rfs.GetInstanceName())
                {
                    // We're going to make it null, but
                    // we don't save null instructions in
                    // NOS's so that our .glux stays small
                    // and so there's less chances of conflicts
                    // occurring because of undefined sorting behavior.
                    namedObject.InstructionSaves.RemoveAt(i);
                }
            }
        }
Exemplo n.º 28
0
        public static bool IsReferencedFileNameValid(string name, AssetTypeInfo ati, ReferencedFileSave rfs, IElement container, out string whyItIsntValid)
        {
            whyItIsntValid = "";

            CheckForCommonImproperNames(name, ref whyItIsntValid);

            // CheckForExistingEntity checks if the name is already used, but we can be more specific if it's part of this entity
            if (container != null)
            {
                string unqualifiedContainerName = FileManager.RemovePath(container.Name);

                if (unqualifiedContainerName.ToLowerInvariant() == FileManager.RemovePath(FileManager.RemoveExtension(name)))
                {
                    string containerType = "Entity";

                    if (container is ScreenSave)
                    {
                        containerType = "Screen";
                    }
                    else if (container is EntitySave)
                    {
                        containerType = "Entity";
                    }
                    else
                    {
                        containerType = "Container";
                    }

                    whyItIsntValid = "The " + containerType + " that you are adding the file to has the same name as the file.  This is not allowed in Glue.  Please rename the file";
                }
            }

            if (string.IsNullOrEmpty(whyItIsntValid))
            {
                CheckForExistingEntity(name, ref whyItIsntValid);
            }

            if (string.IsNullOrEmpty(whyItIsntValid))
            {
                CheckForRfsWithMatchingFileName(container, name, rfs, ref whyItIsntValid);
            }

            if (string.IsNullOrEmpty(whyItIsntValid))
            {
                if (ati != null && ati.Extension == "csv")
                {
                    // Let's see if there is already a spreadsheet by this name and if so, let's warn the user
                    // But we only want a spreadsheet that isn't using a created class:
                    var existing = ObjectFinder.Self.GetAllReferencedFiles().Where(item =>
                                                                                   // Is the item a CSV...
                                                                                   item.IsCsvOrTreatedAsCsv &&
                                                                                   // And is the item different than the rfs we're checking
                                                                                   item != rfs &&
                                                                                   // And do the names match?
                                                                                   FileManager.RemovePath(FileManager.RemoveExtension(item.Name)) == name &&
                                                                                   // And does it not use a custom class?
                                                                                   ObjectFinder.Self.GlueProject.CustomClasses.Any(customClass => customClass.CsvFilesUsingThis.Contains(item.Name)) == false)
                                   .ToList();



                    if (existing.Count != 0)
                    {
                        whyItIsntValid = "There is already a CSV file using the name " + name + ". This CSV is not using a custom class:  " + existing[0].ToString();
                    }
                }
            }

            bool returnValue = string.IsNullOrEmpty(whyItIsntValid);

            return(returnValue);
        }
Exemplo n.º 29
0
        public static ReferencedFileSave AddReferencedFileSave(IElement element, string directoryPath, string fileName,
                                                               AssetTypeInfo resultAssetTypeInfo, string option, out string errorMessage)
        {
            char invalidCharacter;
            ReferencedFileSave rfs = null;

            errorMessage = null;

            #region Get directory

            string directoryRelativeToContent = "";

            if (!String.IsNullOrEmpty(directoryPath))
            {
                //string directory = directoryTreeNode.GetRelativePath().Replace("/", "\\");

                directoryRelativeToContent = directoryPath;
            }
            else if (element != null)
            {
                //string directory = elementToAddTo.GetRelativePath().Replace("/", "\\");

                directoryRelativeToContent = element.Name.Replace(@"/", @"\") + "\\";
            }
            else
            {
                directoryRelativeToContent = "GlobalContent/";
            }


            #endregion

            bool userCancelled = false;


            #region If there is some reason why the file name won't, then work show a message box

            string whyIsntValid;

            if (!NameVerifier.IsReferencedFileNameValid(fileName, resultAssetTypeInfo, rfs, element, out whyIsntValid))
            {
                errorMessage = "Invalid file name:\n" + fileName + "\n" + whyIsntValid;
            }
            else if (resultAssetTypeInfo == null)
            {
                errorMessage = "You must select a valid type for your new file.";
            }
            else if (ObjectFinder.Self.GetReferencedFileSaveFromFile(directoryRelativeToContent + fileName + "." + resultAssetTypeInfo.Extension) != null)
            {
                errorMessage = "There is already a file named\n\n" + directoryRelativeToContent + fileName + "." + resultAssetTypeInfo.Extension;
            }
            // TODO:  This currently checks for an exact match, but we should prevent different files (like a .emix and .scnx) from having the same name
            else if (EditorLogic.CurrentElement != null &&
                     EditorLogic.CurrentElement.GetReferencedFileSaveRecursively(directoryRelativeToContent + fileName + "." + resultAssetTypeInfo.Extension) != null)
            {
                errorMessage = "There is already a file named " + fileName;
            }
            // need to check global content for duplicates.  This is not implemented yet.
            #endregion

            #region Else, create the file

            else
            {
                string createdFile = PluginManager.CreateNewFile(resultAssetTypeInfo, option == "2D",
                                                                 directoryRelativeToContent, fileName);

                // let's just re-route this
                // to the code that adds existing
                // files now that we have a file and
                // that's exactly what we're doing.
                rfs = RightClickHelper.AddSingleFile(createdFile, ref userCancelled, option);

                if (rfs == null && !userCancelled)
                {
                    throw new NullReferenceException("The RFS shouldn't be null");
                }
            }

            #endregion



            return(rfs);
        }
Exemplo n.º 30
0
 private static void CheckForRfsWithMatchingFileName(IElement container, string name, ReferencedFileSave rfsToSkip, ref string whyItIsntValid)
 {
     if (container == null)
     {
         // We need to see if there is already a file with the same name in Global Content
         ReferencedFileSave existingRfs = ObjectFinder.Self.GlueProject.GlobalFiles.FirstOrDefault(
             rfs =>
             (FileManager.RemovePath(rfs.Name) == name ||
              rfs.GetInstanceName() == name) &&
             rfs != rfsToSkip
             );
         if (existingRfs != null)
         {
             whyItIsntValid += "There is already a file in GlobalContent using the name " + name;
         }
     }
     else
     {
         // We need to see if there is already a file with the same name in Global Content
         ReferencedFileSave existingRfs = container.ReferencedFiles.FirstOrDefault(
             rfs =>
         {
             return((FileManager.RemovePath(rfs.Name) == name ||
                     FileManager.RemoveExtension(FileManager.RemovePath(rfs.Name)) == name) &&
                    rfs != rfsToSkip
                    );
         });
         if (existingRfs != null)
         {
             whyItIsntValid += "There is already a file in " + container.Name + " using the name " + name;
         }
     }
 }
Exemplo n.º 31
0
        public void RemoveReferencedFile(ReferencedFileSave referencedFileToRemove, List<string> additionalFilesToRemove, bool regenerateCode)
        {
            // There are some things that need to happen:
            // 1.  Remove the ReferencedFileSave from the Glue project (GLUX)
            // 2.  Remove the GUI item
            // 3.  Remove the item from the Visual Studio project.

            #region Remove the file from the current Screen or Entity if there is a current Screen or Entity

            IElement container = referencedFileToRemove.GetContainer();

            if (container != null)
            {
                // The referenced file better be a globally referenced file


                if (!container.ReferencedFiles.Contains(referencedFileToRemove))
                {
                    throw new ArgumentException();
                }
                else
                {
                    container.ReferencedFiles.Remove(referencedFileToRemove);

                }
                // Ask about any NamedObjects that reference this file.                
                for (int i = container.NamedObjects.Count - 1; i > -1; i--)
                {
                    var nos = container.NamedObjects[i];
                    if (nos.SourceType == SourceType.File && nos.SourceFile == referencedFileToRemove.Name)
                    {
                        MainGlueWindow.Self.Invoke(() =>
                            {
                                // Ask the user what to do here - remove it?  Keep it and not compile?
                                MultiButtonMessageBox mbmb = new MultiButtonMessageBox();
                                mbmb.MessageText = "The object\n" + nos.ToString() + "\nreferences the file\n" + referencedFileToRemove.Name +
                                    "\nWhat would you like to do?";
                                mbmb.AddButton("Remove this object", DialogResult.Yes);
                                mbmb.AddButton("Keep it (object will not be valid until changed)", DialogResult.No);

                                var result = mbmb.ShowDialog();

                                if (result == DialogResult.Yes)
                                {
                                    container.NamedObjects.RemoveAt(i);
                                }
                            });
                    }
                    nos.ResetVariablesReferencing(referencedFileToRemove);
                }

                MainGlueWindow.Self.Invoke(() =>
                    {
                        if (EditorLogic.CurrentScreenTreeNode != null)
                        {
                            EditorLogic.CurrentScreenTreeNode.UpdateReferencedTreeNodes();
                        }
                        else if (EditorLogic.CurrentEntityTreeNode != null)
                        {
                            EditorLogic.CurrentEntityTreeNode.UpdateReferencedTreeNodes(false);
                        }
                        if (regenerateCode)
                        {
                            ElementViewWindow.GenerateSelectedElementCode();
                        }
                    });
                
            }
            #endregion

            #region else, the file is likely part of the GlobalContentFile

            else
            {
                ProjectManager.GlueProjectSave.GlobalFiles.Remove(referencedFileToRemove);
                ProjectManager.GlueProjectSave.GlobalContentHasChanged = true;

                // Much faster to just remove the tree node.  This was done
                // to reuse code and make things reactive, but this has gotten
                // slow on bigger projects.
                //ElementViewWindow.UpdateGlobalContentTreeNodes(false); // don't save here because projects will get saved below 

                Action refreshUiAction = () =>
                {
                    TreeNode treeNode = GlueState.Self.Find.ReferencedFileSaveTreeNode(referencedFileToRemove);

                    if (treeNode.Tag != referencedFileToRemove)
                    {
                        throw new Exception("Error removing the tree node - the selected tree node doesn't reference the file being removed");
                    }

                    treeNode.Parent.Nodes.Remove(treeNode);
                };

                MainGlueWindow.Self.Invoke((MethodInvoker)delegate
                    {
                        refreshUiAction();
                    }
                    );


                ContentLoadWriter.UpdateLoadGlobalContentCode();

                List<IElement> elements = ObjectFinder.Self.GetAllElementsReferencingFile(referencedFileToRemove.Name);

                foreach (IElement element in elements)
                {
                    if (regenerateCode)
                    {
                        CodeWriter.GenerateCode(element);
                    }
                }
            }

            #endregion


            // November 10, 2015
            // I feel like this may
            // have been old code before
            // we had full dependency tracking
            // in Glue. This file should only be
            // removed from the project if nothing
            // else references it, including no entities.
            // This code does just entities/screens/global
            // content, but doesn't check the full dependency
            // tree. I think we can just remove it and depend on
            // the code below.
            // Actually, removing this seems to cause problems - files
            // that should be removed aren't. So instead we'll chnage the
            // call to use the dependency tree:
            // replace:

            List<string> referencedFiles =
                GlueCommands.Self.FileCommands.GetAllReferencedFileNames().Select(item=>item.ToLowerInvariant()).ToList();

            string absoluteToLower = GlueCommands.Self.GetAbsoluteFileName(referencedFileToRemove).ToLowerInvariant();
            string relativeToProject = FileManager.MakeRelative(absoluteToLower, GlueState.Self.ContentDirectory);

            bool isReferencedByOtherContent = referencedFiles.Contains(relativeToProject);

            if (isReferencedByOtherContent == false)
            {
                additionalFilesToRemove.Add(referencedFileToRemove.GetRelativePath());

                string itemName = referencedFileToRemove.GetRelativePath();
                string absoluteName = ProjectManager.MakeAbsolute(referencedFileToRemove.Name, true);

                // I don't know why we were removing the file from the ProjectBase - it should
                // be from the Content project
                //ProjectManager.RemoveItemFromProject(ProjectManager.ProjectBase, itemName);
                ProjectManager.RemoveItemFromProject(ProjectManager.ProjectBase.ContentProject, itemName, performSave: false);

                foreach (ProjectBase syncedProject in ProjectManager.SyncedProjects)
                {
                    ProjectManager.RemoveItemFromProject(syncedProject.ContentProject, absoluteName);
                }
            }



            if (ProjectManager.IsContent(referencedFileToRemove.GetRelativePath()))
            {

                UnreferencedFilesManager.Self.RefreshUnreferencedFiles(false);
                foreach (var file in UnreferencedFilesManager.LastAddedUnreferencedFiles)
                {
                    additionalFilesToRemove.Add(file.FilePath);
                }
            }

            ReactToRemovalIfCsv(referencedFileToRemove, additionalFilesToRemove);

            GluxCommands.Self.SaveGlux();
        }
 public object LoadReferencedFileSave(ReferencedFileSave r, IElement container)
 {
     return LoadReferencedFileSave(r, false, container);
 }
Exemplo n.º 33
0
 public static string PerformExternalBuild(this ReferencedFileSave instance)
 {
     return(PerformExternalBuild(instance, false));
 }
        public object LoadReferencedFileSave(ReferencedFileSave r, bool isBeingAccessed, IElement container)
        {
            //////////////////EARLY OUT///////////////////
            if (r.LoadedAtRuntime == false)
            {
                return null;
            }

            if (mLoadedRfses.ContainsKey(r.Name.ToLower()))
            {
                // do nothing, it's already been loaded)
                return mLoadedRfses[r.Name.ToLower()];
            }
            /////////////END EARLY OUT//////////////////////

            object runtimeObject = LoadRfsAndAddToLists(r, isBeingAccessed, container);

            if (isBeingAccessed || runtimeObject != null)
            {
                mLoadedRfses.Add(r.Name.ToLower(), runtimeObject);

                return mLoadedRfses[r.Name.ToLower()];
            }
            else
            {
                // It's null, but not being accessed so that's okay
                return null;
            }
        }
Exemplo n.º 35
0
 void HandleNewFile(ReferencedFileSave rfs)
 {
     HandleBuiltFileChange(ProjectManager.MakeAbsolute(rfs.Name));
 }
Exemplo n.º 36
0
        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;

        }
Exemplo n.º 37
0
        public static string GetTypeForCsvFile(this ReferencedFileSave referencedFileSave, string alternativeFileName = null)//string fileName)
        {
            if (referencedFileSave == null)
            {
                throw new ArgumentNullException("ReferencedFileSave is null - it can't be.");
            }

            string fileName = referencedFileSave.Name;

            if (!string.IsNullOrEmpty(alternativeFileName))
            {
                fileName = alternativeFileName;
            }

            if (!string.IsNullOrEmpty(referencedFileSave.UniformRowType))
            {
                return(referencedFileSave.UniformRowType);
            }
            else
            {
                string className = null;

                // Make sure that the fileName is relative:
                // Wait!  There's no reason to do this.  The
                // RFS's Name property will always be relative
                // to the content project.  This is a must to make
                // projects portable so we don't have to do any processing
                // on the file name.
                //if (!FileManager.IsRelative(fileName))
                //{
                //    if (ProjectManager.ContentProject.Directory != null &&
                //        !FileManager.IsRelativeTo(ProjectManager.ContentProject.Directory, FileManager.RelativeDirectory))
                //    {
                //        fileName = FileManager.MakeRelative(fileName, ProjectManager.ContentProject.Directory);
                //    }
                //    else
                //    {
                //        fileName = FileManager.MakeRelative(fileName);
                //    }
                //}

                // Is this file using a custom class?
                CustomClassSave ccs = ObjectFinder.Self.GlueProject.GetCustomClassReferencingFile(fileName);
                if (ccs == null)
                {
                    className = FileManager.RemovePath(FileManager.RemoveExtension(fileName));
                    if (className.EndsWith("File"))
                    {
                        className = className.Substring(0, className.Length - "File".Length);
                    }

                    className = EditorObjects.IoC.Container.Get <IVsProjectState>().DefaultNamespace + ".DataTypes." + className;
                }
                else
                {
                    if (!string.IsNullOrEmpty(ccs.CustomNamespace))
                    {
                        className = ccs.CustomNamespace + "." + ccs.Name;
                    }
                    else
                    {
                        className = EditorObjects.IoC.Container.Get <IVsProjectState>().DefaultNamespace + ".DataTypes." + ccs.Name;
                    }
                }
                return(className);
            }
        }
Exemplo n.º 38
0
 public void RemoveReferencedFile(ReferencedFileSave referencedFileToRemove, List<string> additionalFilesToRemove)
 {
     RemoveReferencedFile(referencedFileToRemove, additionalFilesToRemove, true);
 }
Exemplo n.º 39
0
 private static int CompareReferencedFiles(ReferencedFileSave rfs1, ReferencedFileSave rfs2)
 {
     return(rfs1.Name.CompareTo(rfs2.Name));
 }
Exemplo n.º 40
0
        private static void ReactToRemovalIfCsv(ReferencedFileSave referencedFileToRemove, List<string> additionalFilesToRemove)
        {
            if (referencedFileToRemove.IsCsvOrTreatedAsCsv)
            {
                string name = referencedFileToRemove.GetTypeForCsvFile();
                // If the CSV uses a custom class then the user should not
                // be asked if the file for that class should be removed.  That
                // class was created independent of any CSV (perhaps by hand, perhaps
                // by plugin), so the user should have to explicitly remove the class.

                var customClass = ObjectFinder.Self.GlueProject.GetCustomClassReferencingFile(referencedFileToRemove.Name);

                if (customClass == null)
                {

                    var first = ObjectFinder.Self.GetAllReferencedFiles().FirstOrDefault(item => item.IsCsvOrTreatedAsCsv && item.GetTypeForCsvFile() == name);

                    if (first == null)
                    {
                        // Remove the class
                        string whatToRemove = "DataTypes/" + name + ".Generated.cs";

                        additionalFilesToRemove.Add(whatToRemove);

                    }
                }
                
                // See if this uses a custom class.  If so, remove the CSV from
                // the class' list.
                if (customClass != null)
                {
                    customClass.CsvFilesUsingThis.Remove(referencedFileToRemove.Name);
                }
            }
        }
Exemplo n.º 41
0
        public static TypeConverter GetTypeConverter(this CustomVariable customVariable, IElement containingElement, StateSave stateSave, FlatRedBall.Glue.Plugins.ExportedInterfaces.IGlueState glueState)
        {
            TypeConverter typeConverter = null;

            if (customVariable.GetIsVariableState())
            {
                typeConverter = new AvailableStates(
                    FacadeContainer.Self.GlueState.CurrentNamedObjectSave,
                    FacadeContainer.Self.GlueState.CurrentElement,
                    FacadeContainer.Self.GlueState.CurrentCustomVariable,
                    FacadeContainer.Self.GlueState.CurrentStateSave
                    );
            }
            else
            {
                Type runtimeType = customVariable.GetRuntimeType();

                if (runtimeType != null)
                {
                    if (runtimeType.IsEnum)
                    {
                        typeConverter = new EnumConverter(runtimeType);
                    }
                    else if (runtimeType == typeof(Color))
                    {
                        return(new AvailableColorTypeConverter());
                    }

                    else if ((runtimeType == typeof(string) || runtimeType == typeof(AnimationChainList)) &&
                             customVariable.SourceObjectProperty == "CurrentChainName")
                    {
                        typeConverter = new AvailableAnimationChainsStringConverter(customVariable, stateSave);
                    }
                    else if (customVariable.GetIsFile())
                    {
                        AvailableFileStringConverter converter = new AvailableFileStringConverter(containingElement);
                        converter.QualifiedRuntimeTypeName = runtimeType.FullName;
                        converter.ShowNewFileOption        = false;
                        converter.RemovePathAndExtension   = true;
                        typeConverter = converter;
                    }
                }
                else if (customVariable.GetIsCsv())
                {
                    if (FacadeContainer.Self.ProjectValues == null)
                    {
                        throw new NullReferenceException("The ProjectValues property in FAcadeContainer.Self.ProjectValues must be set before trying to get the CSV type converter for the variable " + customVariable.ToString());
                    }

                    ReferencedFileSave rfs = ObjectFinder.Self.GetAllReferencedFiles().FirstOrDefault(item =>
                                                                                                      item.IsCsvOrTreatedAsCsv && item.GetTypeForCsvFile() == customVariable.Type);

                    AvailableSpreadsheetValueTypeConverter converter = null;
                    if (rfs != null)
                    {
                        converter = new AvailableSpreadsheetValueTypeConverter(
                            FacadeContainer.Self.ProjectValues.ContentDirectory + rfs.Name, containingElement);
                    }
                    else
                    {
                        converter = new AvailableSpreadsheetValueTypeConverter(
                            FacadeContainer.Self.ProjectValues.ContentDirectory + customVariable.Type, containingElement);
                    }
                    converter.ShouldAppendFileName = true;

                    typeConverter = converter;
                }
                else if (customVariable.GetIsFile())
                {
                    // If we got here, that means that the
                    // CustomVariable is a file, but it doesn't
                    // have a System.Type, so it only knows its runtime
                    // type;
                    AvailableFileStringConverter converter = new AvailableFileStringConverter(containingElement);
                    converter.UnqualifiedRuntimeTypeName = customVariable.Type;
                    converter.ShowNewFileOption          = false;
                    converter.RemovePathAndExtension     = true;
                    typeConverter = converter;
                }
            }


            return(typeConverter);
        }