private void removeIceBuilder_BeforeQueryStatus(object sender, EventArgs e)
 {
     try
     {
         OleMenuCommand command = sender as OleMenuCommand;
         if (command != null)
         {
             EnvDTE.Project p = DTEUtil.GetSelectedProject();
             if (p != null)
             {
                 if (DTEUtil.IsCppProject(p) || DTEUtil.IsCSharpProject(p))
                 {
                     command.Enabled = MSBuildUtils.IsIceBuilderEnabeld(MSBuildUtils.LoadedProject(p.FullName));
                 }
                 else
                 {
                     command.Enabled = false;
                 }
             }
         }
     }
     catch (Exception ex)
     {
         Package.UnexpectedExceptionWarning(ex);
         throw;
     }
 }
        public static void TryUpgrade(List <IVsProject> projects)
        {
            string baseDir = string.Empty;

            if (!string.IsNullOrEmpty(Package.Instance.DTE2.Solution.FullName))
            {
                baseDir = Path.GetDirectoryName(Package.Instance.DTE2.Solution.FullName);
            }
            Dictionary <string, IVsProject> upgradeProjects = new Dictionary <string, IVsProject>();

            foreach (IVsProject project in projects)
            {
                if (DTEUtil.IsCppProject(project) || DTEUtil.IsCSharpProject(project))
                {
                    string fullName = ProjectUtil.GetProjectFullPath(project);
                    if (new OldConfiguration().Load(MSBuildUtils.LoadedProject(fullName, DTEUtil.IsCppProject(project), true), false))
                    {
                        upgradeProjects.Add(FileUtil.RelativePath(baseDir, fullName), project);
                    }
                }
            }

            if (upgradeProjects.Count > 0)
            {
                UpgradeDialog dialog = new UpgradeDialog();
                dialog.StartPosition = FormStartPosition.CenterParent;
                dialog.Projects      = upgradeProjects;
                dialog.ShowDialog();
            }
        }
 private void addIceBuilder_BeforeQueryStatus(object sender, EventArgs e)
 {
     try
     {
         OleMenuCommand command = sender as OleMenuCommand;
         if (command != null)
         {
             IVsProject p = DTEUtil.GetSelectedProject();
             if (p != null)
             {
                 if (DTEUtil.IsCppProject(p) || DTEUtil.IsCSharpProject(p))
                 {
                     command.Enabled = !MSBuildUtils.IsIceBuilderEnabled(MSBuildUtils.LoadedProject(
                                                                             ProjectUtil.GetProjectFullPath(p), DTEUtil.IsCppProject(p), true));
                 }
                 else
                 {
                     command.Enabled = false;
                 }
             }
         }
     }
     catch (Exception ex)
     {
         Package.UnexpectedExceptionWarning(ex);
         throw;
     }
 }
        private void RemoveIceBuilderFromProject(IVsProject p)
        {
            String path = ProjectUtil.GetProjectFullPath(p);

            foreach (IVsProject p1 in _buildProjects)
            {
                if (path.Equals(ProjectUtil.GetProjectFullPath(p1)))
                {
                    _buildProjects.Remove(p1);
                    break;
                }
            }

            ProjectUtil.DeleteItems(
                ProjectUtil.GetGeneratedFiles(p).Aggregate(
                    new List <String>(),
                    (items, kv) =>
            {
                items.AddRange(kv.Value);
                return(items);
            }));

            if (DTEUtil.IsCSharpProject(p))
            {
                Directory.GetFiles(GetAssembliesDir(GetIceHome()), "*.dll")
                .ToList()
                .ForEach(item =>
                {
                    String name = Path.GetFileNameWithoutExtension(item);
                    if (ProjectUtil.HasAssemblyReference(DTEUtil.GetProject(p as IVsHierarchy), name))
                    {
                        ProjectUtil.RemoveAssemblyReference(DTEUtil.GetProject(p as IVsHierarchy), name);
                    }
                });
            }

            Microsoft.Build.Evaluation.Project project = MSBuildUtils.LoadedProject(path, DTEUtil.IsCppProject(p), true);
            MSBuildUtils.RemoveIceBuilderFromProject(project);
            ProjectUtil.SaveProject(p);

            Guid         projectGUID = Guid.Empty;
            IVsHierarchy hier        = p as IVsHierarchy;

            IVsSolution.GetGuidOfProject(hier, out projectGUID);
            IVsSolution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject, hier, 0);
            project.Save();
            try
            {
                ProjectCollection.GlobalProjectCollection.UnloadProject(project);
            }
            catch (System.Exception)
            {
                //expected if the project is not in the global project collection
            }
            IVsSolution4.ReloadProject(ref projectGUID);
        }
        public static List <String> GetGeneratedFiles(EnvDTE.Project project, String sliceFile)
        {
            List <String> generated = new List <String>();

            if (DTEUtil.IsCSharpProject(project))
            {
                generated.Add(ProjectUtil.GetCSharpGeneratedItemFullPath(project, sliceFile));
            }
            else
            {
                generated.Add(ProjectUtil.GetCppGeneratedSourceItemFullPath(project, sliceFile));
                generated.Add(ProjectUtil.GetCppGeneratedHeaderItemFullPath(project, sliceFile));
            }
            return(generated);
        }
        public static bool Upgrade(IVsProject project)
        {
            OldConfiguration oldConfiguration = new OldConfiguration();

            Microsoft.Build.Evaluation.Project msbuildProject = MSBuildUtils.LoadedProject(ProjectUtil.GetProjectFullPath(project), DTEUtil.IsCppProject(project), true);

            if (oldConfiguration.Load(msbuildProject, true))
            {
                if (DTEUtil.IsCppProject(project))
                {
                    return(UpgadeCppConfiguration(msbuildProject, oldConfiguration));
                }
                else if (DTEUtil.IsCSharpProject(project))
                {
                    return(UpgradeCSharpConfiguration(DTEUtil.GetProject(project as IVsHierarchy), msbuildProject, oldConfiguration));
                }
            }
            return(false);
        }
Esempio n. 7
0
        public static bool Upgrade(EnvDTE.Project project)
        {
            OldConfiguration oldConfiguration = new OldConfiguration();

            Microsoft.Build.Evaluation.Project msbuildProject = MSBuildUtils.LoadedProject(project.FullName);

            if (oldConfiguration.Load(msbuildProject, true))
            {
                if (DTEUtil.IsCppProject(project))
                {
                    return(UpgadeCppConfiguration(msbuildProject, oldConfiguration));
                }
                else if (DTEUtil.IsCSharpProject(project))
                {
                    return(UpgradeCSharpConfiguration(project, msbuildProject, oldConfiguration));
                }
            }
            return(false);
        }
        public static bool CheckGenerateFileIsValid(EnvDTE.Project project, String path)
        {
            if (DTEUtil.IsCSharpProject(project))
            {
                String generatedSource = ProjectUtil.GetCSharpGeneratedItemFullPath(project, path);
                if (File.Exists(generatedSource))
                {
                    const String message =
                        "A file named '{0}' already exists.\nIf you want to add '{1}' first remove '{0}'.";

                    UIUtil.ShowErrorDialog("Ice Builder",
                                           String.Format(message,
                                                         ProjectUtil.GetPathRelativeToProject(project, generatedSource),
                                                         ProjectUtil.GetPathRelativeToProject(project, path)));
                    return(false);
                }
            }
            else
            {
                String generatedSource = ProjectUtil.GetCppGeneratedSourceItemFullPath(project, path);
                String generatedHeader = ProjectUtil.GetCppGeneratedHeaderItemFullPath(project, path);
                if (File.Exists(generatedSource) || File.Exists(generatedHeader))
                {
                    const String message =
                        "A file named '{0}' or '{1}' already exists.\nIf you want to add '{2}' first remove '{0}' and '{1}'.";

                    UIUtil.ShowErrorDialog("Ice Builder",
                                           String.Format(message,
                                                         ProjectUtil.GetPathRelativeToProject(project, generatedSource),
                                                         ProjectUtil.GetPathRelativeToProject(project, generatedHeader),
                                                         ProjectUtil.GetPathRelativeToProject(project, path)));
                    return(false);
                }
            }
            return(true);
        }