Cosmos/source2/VSIP/Cosmos.VS.Wizards/GenerateCosmosProjectWizard.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TemplateWizard;
using System.Windows.Forms;
using System.IO;
using EnvDTE;

namespace Cosmos.VS.Package.Templates {
  public class GenerateCosmosProjectWizard : IWizard {
    public void BeforeOpeningFile(EnvDTE.ProjectItem projectItem) {
    }

    private static string GetTemplateString() {
      var xAsm = typeof(GenerateCosmosProjectWizard).Assembly;
      using (var xStream = xAsm.GetManifestResourceStream(typeof(Cosmos.VS.Wizards.ResHelper), "CosmosProject.Cosmos")) {
        if (xStream == null) {
          MessageBox.Show("Could not find template manifest stream!");
          return null;
        }
        using (var xReader = new StreamReader(xStream)) {
          return xReader.ReadToEnd();
        }
      }
    }

    public void ProjectFinishedGenerating(EnvDTE.Project project) {
      // add Cosmos template to solution
      // read embedded template file
      var xInputString = GetTemplateString();
      if (xInputString == null) {
        return;
      }

      // set project extension for reference
      string extension = project.UniqueName.Split('.')[1];

      xInputString = xInputString.Replace("$KernelGuid$", mGuidKernel.ToString("b"));
      xInputString = xInputString.Replace("$CosmosProjGuid$", mGuidCosmosProj.ToString("b"));
      xInputString = xInputString.Replace("$KernelName$", project.Name);
      xInputString = xInputString.Replace("$CosmosProjectName$", project.Name + "Boot");
      xInputString = xInputString.Replace("$ProjectTypeExtension$", extension);
      var xFilename = Path.GetDirectoryName(project.FullName);
      xFilename = Path.Combine(xFilename, project.Name + "Boot");
      xFilename += ".Cosmos";
      File.WriteAllText(xFilename, xInputString);
      var xCosmosProject = project.DTE.Solution.AddFromFile(xFilename, false);

      // make .Cosmos project dependent on library project.
      var xEnu = project.DTE.Solution.SolutionBuild.BuildDependencies.GetEnumerator();
      dynamic xCosmosBootProjectObj = xCosmosProject.Object; // VSProjectNode
      var xCosmosBootGuid = xCosmosBootProjectObj.ProjectIDGuid;
      while (xEnu.MoveNext()) {
        EnvDTE.BuildDependency bd = (EnvDTE.BuildDependency)xEnu.Current;

        dynamic xDependencyGUID = bd.Project.Object;
        if (xDependencyGUID.ProjectIDGuid == xCosmosBootGuid) {
          bd.AddProject(project.UniqueName);
          break;
        }
      }

      // set Cosmos Boot as startup project
      project.DTE.Windows.Item(EnvDTE.Constants.vsWindowKindSolutionExplorer).Activate();
      EnvDTE.UIHierarchy hierarchy = project.DTE.ActiveWindow.Object as EnvDTE.UIHierarchy;
      string fullPath = FindProject(hierarchy.UIHierarchyItems, xCosmosProject);
      if (fullPath.Length > 0) {
        hierarchy.GetItem(fullPath).Select(EnvDTE.vsUISelectionType.vsUISelectionTypeSelect);
        project.DTE.ExecuteCommand("Project.SetasStartUpProject");
      }

      // set all projects in all configurations are supposed to build
      foreach (SolutionConfiguration item in project.DTE.Solution.SolutionBuild.SolutionConfigurations) {
        for (int i = 1; i <= item.SolutionContexts.Count; i++) {
          SolutionContext context = item.SolutionContexts.Item(i);
          if (context.ProjectName.EndsWith(project.UniqueName))
            context.ShouldBuild = true;
          else if (context.ProjectName.EndsWith(xCosmosProject.UniqueName))
            context.ShouldBuild = true;
        }
      }
    }

    public void ProjectItemFinishedGenerating(EnvDTE.ProjectItem projectItem) {
    }

    public void RunFinished() {
    }

    public string FindProject(EnvDTE.UIHierarchyItems h, Project p) {
      var xEnumerator = h.GetEnumerator();

      while (xEnumerator.MoveNext()) {
        UIHierarchyItem xHierarchyItem = (UIHierarchyItem)xEnumerator.Current;
        if (xHierarchyItem.Name == p.Name) {
          dynamic node = xHierarchyItem.Object;
          dynamic nodeArg = p.Object; // Cosmos.VS.Package.VSProjectNode

          try {
            if (node.Object.Project.ProjectIDGuid == nodeArg.ProjectIDGuid)
              return p.Name;
          } catch {
          }

          try {
            if (node.Project.ProjectIDGuid == nodeArg.ProjectIDGuid)
              return p.Name;
          } catch {
          }
        }
        var xPartOfName = FindProject(xHierarchyItem.UIHierarchyItems, p);
        if (xPartOfName.Length > 0) {
          SolutionClass solution = xHierarchyItem.Object as SolutionClass;
          if (solution != null)
            return xHierarchyItem.Name + "\\" + xPartOfName;
          return xHierarchyItem.Name + "\\" + xPartOfName;
        }
      }
      return string.Empty;
    }

    private Guid mGuidKernel;
    private Guid mGuidCosmosProj;

    public void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams) {
      mGuidKernel = Guid.NewGuid();
      mGuidCosmosProj = Guid.NewGuid();
      replacementsDictionary.Add("$KernelGuid$", mGuidKernel.ToString("B"));
      replacementsDictionary.Add("$CosmosProjGuid$", mGuidCosmosProj.ToString("B"));
    }

    public bool ShouldAddProjectItem(string filePath) {
      return true;
    }
  }
}