Ejemplo n.º 1
0
 public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 2
0
        public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType, bool relativeItem)
        {
            ProjectItem buildItem;

            if (relativeItem)
            {
                buildItem = GetItem(fileToUpdate);
            }
            else
            {
                buildItem = GetItem(fileToUpdate, false);
            }

            if (buildItem == null)
            {
                if (membershipType == BuildItemMembershipType.Content)
                {
                    buildItem = GetItem("Content\\" + fileToUpdate);
                    if (buildItem != null && buildItem.ItemType == "Content")
                    {
                        return(true);
                    }
                }

                if (buildItem == null)
                {
                    return(false);
                }
            }
            else
            {
                if (membershipType == BuildItemMembershipType.CompileOrContentPipeline)
                {
                    if (!AllowContentCompile || buildItem.ItemType == "Compile" || buildItem.ItemType == "Content")
                    {
                        return(true);
                    }
                }
                else if (membershipType == BuildItemMembershipType.Content)
                {
                    if (!AllowContentCompile || buildItem.ItemType == "Compile" || buildItem.ItemType == "Content")
                    {
                        return(true);
                    }
                    else if (relativeItem == false)
                    {
                        return(true);
                    }
                }
                else if (membershipType == BuildItemMembershipType.CopyIfNewer)
                {
                    bool compile = FileManager.GetExtension(fileToUpdate) == "x";
                    if (compile)
                    {
                        if (!AllowContentCompile || buildItem.ItemType == "Compile")
                        {
                            return(true);
                        }
                    }
                    else
                    {
                        if (!NeedCopyToOutput || buildItem.HasMetadata("CopyToOutputDirectory"))
                        {
                            return(true);
                        }
                    }
                }
                else if (membershipType == BuildItemMembershipType.Any)
                {
                    return(true);
                }
                else if (membershipType.ToString() == buildItem.ItemType)
                {
                    return(true);
                }
            }

            return(false);

            /*
             *
             * // Even though there's some code duplication, let's do the if statement outside of the loop to speed things up
             * if (membershipType == BuildItemMembershipType.CompileOrContentPipeline)
             * {
             *  int count = mProject.EvaluatedItems.Count;
             *  for (int i = 0; i < count ; i++)
             *  {
             *      BuildItem buildItem = mProject.EvaluatedItems[i];
             *
             *      if (buildItem.Include.ToLower().Replace("/", "\\") == fileToUpdate)
             *      {
             *          if (buildItem.Name == "Compile" || buildItem.Name == "Content")
             *          {
             *              return true;
             *          }
             *      }
             *  }
             * }
             * else if (membershipType == BuildItemMembershipType.CopyIfNewer)
             * {
             *  bool compile = FileManager.GetExtension(fileToUpdate) == "x";
             *
             *  int count = mProject.EvaluatedItems.Count;
             *  if (compile)
             *  {
             *      for (int i = 0; i < count; i++)
             *      {
             *          BuildItem buildItem = mProject.EvaluatedItems[i];
             *
             *          if (buildItem.Include.ToLower().Replace("/", "\\") == fileToUpdate)
             *          {
             *              if (buildItem.Name == "Compile")
             *              {
             *                  return true;
             *              }
             *          }
             *      }
             *  }
             *  else
             *  {
             *      for (int i = 0; i < count; i++)
             *      {
             *          BuildItem buildItem = mProject.EvaluatedItems[i];
             *
             *          if (buildItem.Include.ToLower().Replace("/", "\\") == fileToUpdate)
             *          {
             *              if (buildItem.HasMetadata("CopyToOutputDirectory"))
             *              {
             *                  return true;
             *              }
             *          }
             *      }
             *  }
             *
             * }
             * return false;
             */
        }
Ejemplo n.º 3
0
        private void AddContentFileItemsFrom(ProjectBase projectBase)
        {
            var contentItemsToSync =
                projectBase.ContentProject.EvaluatedItems.Where(item => IsContentFile(item, projectBase.ContentProject))
                .ToList();

            foreach (var bi in contentItemsToSync)
            {
                string absoluteFileName = projectBase.ContentProject.MakeAbsolute(bi.UnevaluatedInclude);

                bool forceToContent = false;
                if (projectBase.ContentCopiedToOutput)
                {
                    forceToContent = !bi.HasMetadata("CopyToOutputDirectory") &&
                                     CanBeContentType;
                }

                BuildItemMembershipType buildItemMembershipType = DefaultContentBuildType;
                if (forceToContent)
                {
                    buildItemMembershipType = BuildItemMembershipType.CompileOrContentPipeline;
                }
                else if (DefaultContentAction == "Content")
                {
                    buildItemMembershipType = BuildItemMembershipType.Content;
                }

                if (!ContentProject.IsFilePartOfProject(absoluteFileName, buildItemMembershipType, true))
                {
                    if (ContentProject.GetItem(absoluteFileName) != null)
                    {
                        ContentProject.RemoveItem(absoluteFileName);
                    }

                    ContentProject.AddContentBuildItem(absoluteFileName, SyncedProjectRelativeType.Linked, forceToContent);
                }


                var biOnThis = this.GetItem(absoluteFileName);
                // Let's process the path to make sure it's matching the latest standards - like
                // if we add additional restrictions at some point in Glue
                if (biOnThis != null)
                {
                    string includeBefore = biOnThis.UnevaluatedInclude;
                    string includeAfter  = ProcessInclude(biOnThis.UnevaluatedInclude);
                    if (includeBefore != includeAfter)
                    {
                        // simply changing the Include doesn't make a project
                        // dirty, and we only want to make it dirty if we really
                        // did change something so that we don't unnecessarily save
                        // projects.
                        biOnThis.UnevaluatedInclude = includeAfter;
                        this.IsDirty = true;
                    }

                    string linkBefore = biOnThis.GetLink();
                    if (!string.IsNullOrEmpty(linkBefore))
                    {
                        string linkAfter = ProcessLink(linkBefore);

                        // If the original project is linking a file outside of
                        // its own file structure, then the Link value assigned on
                        // this BuildItem will include "..\". This is an invalid link
                        // value, so we'll instead try to use the same link as in the original
                        // file:
                        {
                            var linkOnOriginalBuildItem = bi.GetLink();
                            if (string.IsNullOrEmpty(linkOnOriginalBuildItem) == false)
                            {
                                // first let's make the link relative to the main project's content folder
                                var relativeToProject = FileManager.MakeRelative(linkOnOriginalBuildItem, projectBase.ContentProject.ContentDirectory);

                                linkAfter = this.ContentDirectory + relativeToProject;
                                linkAfter = ProcessLink(linkAfter);
                            }
                        }


                        if (linkBefore != linkAfter)
                        {
                            // simply changing the Link doesn't make a project
                            // dirty, and we only want to make it dirty if we really
                            // did change something so that we don't unnecessarily save
                            // projects.
                            biOnThis.SetLink(linkAfter);
                            this.IsDirty = true;
                        }
                    }
                }
            }
        }
Ejemplo n.º 4
0
        public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType, bool relativeItem)
        {
            BuildItem buildItem;
            if (relativeItem)
            {
                buildItem = GetItem(fileToUpdate);
            }
            else
            {
                buildItem = GetItem(fileToUpdate, false);
            }

            if (buildItem == null)
            {
                return false;
            }

            return true;
        }
Ejemplo n.º 5
0
 public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType)
 {
     return(IsFilePartOfProject(fileToUpdate, membershipType, true));
 }
Ejemplo n.º 6
0
 public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType)
 {
     return IsFilePartOfProject(fileToUpdate, membershipType, true);
 }
Ejemplo n.º 7
0
 public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType, bool relativeItem)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 8
0
        /// <summary>
        /// Adds the argument fileRelativeToProject to the argument project if it's not already part of the project.
        /// </summary>
        /// <param name="project"></param>
        /// <param name="fileName"></param>
        /// <param name="useContentPipeline">Whether this file must be part of the content pipeline. See internal notes on this variable.</param>
        /// <param name="shouldLink"></param>
        /// <param name="parentFile"></param>
        /// <returns>Whether the project was modified.</returns>
        public bool UpdateFileMembershipInProject(ProjectBase project, string fileName, bool useContentPipeline, bool shouldLink, string parentFile = null, bool recursive = true, List <string> alreadyReferencedFiles = null)
        {
            bool wasProjectModified = false;

            ///////////////////Early Out/////////////////////
            if (project == null || GlueState.Self.CurrentMainProject == null)
            {
                return(wasProjectModified);
            }

            /////////////////End Early Out//////////////////

            string fileToAddAbsolute = GlueCommands.Self.GetAbsoluteFileName(fileName, isContent: true);

            fileToAddAbsolute = fileToAddAbsolute.Replace("/", "\\");

            bool isFileAlreadyPartOfProject = false;

            bool needsToBeInContentProject = ShouldFileBeInContentProject(fileToAddAbsolute);

            BuildItemMembershipType bimt = BuildItemMembershipType.CopyIfNewer;

            // useContentPipeline can come from the parent file, if it uses content pipeline. But there may be other cases where we want to force content pepeline

            if (!useContentPipeline)
            {
                useContentPipeline = GetIfShouldUseContentPipeline(fileToAddAbsolute);
            }

            if (useContentPipeline)
            {
                bimt = BuildItemMembershipType.CompileOrContentPipeline;
            }
            else if (!project.ContentProject.ContentCopiedToOutput)
            {
                bimt = BuildItemMembershipType.Content;
            }

            if (!needsToBeInContentProject)
            {
                isFileAlreadyPartOfProject = project.IsFilePartOfProject(fileName, BuildItemMembershipType.CompileOrContentPipeline);
            }

            string fileRelativeToContent = FileManager.MakeRelative(
                fileToAddAbsolute,
                FileManager.GetDirectory(project.ContentProject.FullFileName));

            fileRelativeToContent = fileRelativeToContent.Replace("/", "\\");

            if (!isFileAlreadyPartOfProject && needsToBeInContentProject)
            {
                // Here we're going to get the absolute file name.
                // We want to get the file name

                isFileAlreadyPartOfProject = project.ContentProject.IsFilePartOfProject(fileRelativeToContent, bimt);

                if (!isFileAlreadyPartOfProject)
                {
                    var buildItem = project.ContentProject.GetItem(fileRelativeToContent);
                    if (buildItem != null)
                    {
                        // The item is here but it's using the wrong build types.  Let's
                        // remove it and readd it so that it gets added with the right options.
                        // Let's remove it and say it's not part of the project so it gets removed and readded
                        project.ContentProject.RemoveItem(fileRelativeToContent);
                    }
                }
            }


            bool shouldSkipAdd = useContentPipeline &&
                                 project.ContentProject is VisualStudioProject &&
                                 !((VisualStudioProject)project.ContentProject).AllowContentCompile;

            bool shouldRemoveFile = shouldSkipAdd &&
                                    project.ContentProject.IsFilePartOfProject(fileRelativeToContent, bimt);

            if (shouldRemoveFile)
            {
                // It's using content pipeline, so we use XNBs not PNGs
                var buildItem = project.ContentProject.GetItem(fileRelativeToContent);
                if (buildItem != null)
                {
                    // The item is here but it's using the wrong build types.  Let's
                    // remove it and readd it so that it gets added with the right options.
                    // Let's remove it and say it's not part of the project so it gets removed and readded
                    project.ContentProject.RemoveItem(fileRelativeToContent);
                }
            }


            if (!isFileAlreadyPartOfProject && !shouldSkipAdd)
            {
                wasProjectModified = true;

                if (needsToBeInContentProject)
                {
                    AddFileToContentProject(project, useContentPipeline, shouldLink, fileToAddAbsolute);
                }
                else
                {
                    ProjectManager.CodeProjectHelper.AddFileToCodeProject(project, fileToAddAbsolute);
                }
            }

            var listOfReferencedFiles = new List <string>();

            // Glue is going to assume .cs files can't reference content:
            if (!fileToAddAbsolute.EndsWith(".cs"))
            {
                FileReferenceManager.Self.GetFilesReferencedBy(fileToAddAbsolute, TopLevelOrRecursive.TopLevel, listOfReferencedFiles);

                if (alreadyReferencedFiles != null)
                {
                    listOfReferencedFiles = listOfReferencedFiles.Except(alreadyReferencedFiles).ToList();
                }
            }

            bool shouldAddChildren = true;


            if (fileName.EndsWith(".x") || useContentPipeline)
            {
                shouldAddChildren = false;
            }


            if (shouldAddChildren && listOfReferencedFiles != null && recursive)
            {
                for (int i = 0; i < listOfReferencedFiles.Count; i++)
                {
                    string file = listOfReferencedFiles[i];

                    if (file.Contains(@"../"))
                    {
                        string message = "The file\n\n" + fileToAddAbsolute + "\n\nincludes the file\n\n" + file + "\n\n" +
                                         "This file should not contain ../ in the path.  This likely happened if you saved the file " +
                                         "in a FRBDK tool and didn't select the \"Copy to relative\" option.\n\nYou should probably shut " +
                                         "down Glue, fix this problem, then re-open your project.";

                        System.Windows.Forms.MessageBox.Show(message);
                    }
                    else
                    {
                        wasProjectModified |= UpdateFileMembershipInProject(project, file, useContentPipeline, shouldLink, fileToAddAbsolute, recursive: true, alreadyReferencedFiles: listOfReferencedFiles);
                    }
                }
            }

            return(wasProjectModified);
        }
Ejemplo n.º 9
0
 public abstract bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType, bool relativeItem);
Ejemplo n.º 10
0
        public override bool IsFilePartOfProject(string fileToUpdate, BuildItemMembershipType membershipType, bool relativeItem)
        {
            ProjectItem buildItem;
            if (relativeItem)
            {
                buildItem = GetItem(fileToUpdate);
            }
            else
            {
                buildItem = GetItem(fileToUpdate, false);
            }

            if (buildItem == null)
            {
                if (membershipType == BuildItemMembershipType.Content)
                {
                    buildItem = GetItem("Content\\" + fileToUpdate);
                    if (buildItem != null && buildItem.ItemType == "Content")
                    {
                        return true;
                    }
                }

                if (buildItem == null)
                {
                    return false;
                }
            }
            else
            {
                if (membershipType == BuildItemMembershipType.CompileOrContentPipeline)
                {
                    if (!AllowContentCompile || buildItem.ItemType == "Compile" || buildItem.ItemType == "Content")
                    {
                        return true;
                    }
                }
                else if (membershipType == BuildItemMembershipType.Content)
                {
                    if (!AllowContentCompile || buildItem.ItemType == "Compile" || buildItem.ItemType == "Content")
                    {
                        return true;
                    }
                    else if (relativeItem == false)
                    {
                        return true;
                    }
                }
                else if (membershipType == BuildItemMembershipType.CopyIfNewer)
                {
                    bool compile = FileManager.GetExtension(fileToUpdate) == "x";
                    if (compile)
                    {
                        if (!AllowContentCompile || buildItem.ItemType == "Compile")
                        {
                            return true;
                        }
                    }
                    else
                    {
                        if (!NeedCopyToOutput || buildItem.HasMetadata("CopyToOutputDirectory"))
                        {
                            return true;
                        }
                    }
                }
                else if (membershipType == BuildItemMembershipType.Any)
                {
                    return true;
                }
                else if(membershipType.ToString() == buildItem.ItemType)
                {
                    return true;
                }

            }

            return false;

            /*

            // Even though there's some code duplication, let's do the if statement outside of the loop to speed things up
            if (membershipType == BuildItemMembershipType.CompileOrContentPipeline)
            {
                int count = mProject.EvaluatedItems.Count;
                for (int i = 0; i < count ; i++)
                {
                    BuildItem buildItem = mProject.EvaluatedItems[i];

                    if (buildItem.Include.ToLower().Replace("/", "\\") == fileToUpdate)
                    {
                        if (buildItem.Name == "Compile" || buildItem.Name == "Content")
                        {
                            return true;
                        }
                    }
                }
            }
            else if (membershipType == BuildItemMembershipType.CopyIfNewer)
            {
                bool compile = FileManager.GetExtension(fileToUpdate) == "x";

                int count = mProject.EvaluatedItems.Count;
                if (compile)
                {
                    for (int i = 0; i < count; i++)
                    {
                        BuildItem buildItem = mProject.EvaluatedItems[i];

                        if (buildItem.Include.ToLower().Replace("/", "\\") == fileToUpdate)
                        {
                            if (buildItem.Name == "Compile")
                            {
                                return true;
                            }
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < count; i++)
                    {
                        BuildItem buildItem = mProject.EvaluatedItems[i];

                        if (buildItem.Include.ToLower().Replace("/", "\\") == fileToUpdate)
                        {
                            if (buildItem.HasMetadata("CopyToOutputDirectory"))
                            {
                                return true;
                            }
                        }
                    }
                }

            }
            return false;
             */
        }