VS: Add support for XAML source files

XAML files are by default of type Page in the vcxproj and can be
overriden by setting the VS_XAML_TYPE property.  The .cpp and .h file
of the same name are automatically added as depending on the XAML file.

New VSXaml test builds a basic XAML WindowsStore 8.1 app with VS2013.

Source/cmGeneratorTarget.cxx

@@ -56,6 +56,7 @@ struct ResxTag {};
 struct ModuleDefinitionFileTag {};
 struct AppManifestTag{};
 struct CertificatesTag{};
+struct XamlTag{};
 
 template<typename Tag, typename OtherTag>
 struct IsSameTag
@@ -98,6 +99,20 @@ struct DoAccept<true>
     data.ExpectedResxHeaders.insert(hFileName);
     data.ResxSources.push_back(f);
     }
+  static void Do(cmGeneratorTarget::XamlData& data, cmSourceFile* f)
+    {
+    // Build and save the name of the corresponding .h and .cpp file
+    // This relationship will be used later when building the project files.
+    // Both names would have been auto generated from Visual Studio
+    // where the user supplied the file name and Visual Studio
+    // appended the suffix.
+    std::string xaml = f->GetFullPath();
+    std::string hFileName = xaml + ".h";
+    std::string cppFileName = xaml + ".cpp";
+    data.ExpectedXamlHeaders.insert(hFileName);
+    data.ExpectedXamlSources.insert(cppFileName);
+    data.XamlSources.push_back(f);
+    }
   static void Do(std::string& data, cmSourceFile* f)
     {
     data = f->GetFullPath();
@@ -186,6 +201,10 @@ struct TagVisitor
       {
       DoAccept<IsSameTag<Tag, CertificatesTag>::Result>::Do(this->Data, sf);
       }
+    else if (ext == "xaml")
+      {
+      DoAccept<IsSameTag<Tag, XamlTag>::Result>::Do(this->Data, sf);
+      }
     else if(this->Header.find(sf->GetFullPath().c_str()))
       {
       DoAccept<IsSameTag<Tag, HeaderSourcesTag>::Result>::Do(this->Data, sf);
@@ -437,6 +456,36 @@ cmGeneratorTarget
   IMPLEMENT_VISIT(Certificates);
 }
 
+//----------------------------------------------------------------------------
+void
+cmGeneratorTarget::GetExpectedXamlHeaders(std::set<std::string>& headers,
+                                          const std::string& config) const
+{
+  XamlData data;
+  IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData)
+  headers = data.ExpectedXamlHeaders;
+}
+
+//----------------------------------------------------------------------------
+void
+cmGeneratorTarget::GetExpectedXamlSources(std::set<std::string>& srcs,
+                                          const std::string& config) const
+{
+  XamlData data;
+  IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData)
+  srcs = data.ExpectedXamlSources;
+}
+
+//----------------------------------------------------------------------------
+void cmGeneratorTarget
+::GetXamlSources(std::vector<cmSourceFile const*>& srcs,
+                 const std::string& config) const
+{
+  XamlData data;
+  IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData)
+  srcs = data.XamlSources;
+}
+
 //----------------------------------------------------------------------------
 bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
                                               const std::string& config) const

Source/cmGeneratorTarget.h

@@ -58,6 +58,12 @@ public:
                       const std::string& config) const;
   void GetCertificates(std::vector<cmSourceFile const*>&,
                        const std::string& config) const;
+  void GetXamlSources(std::vector<cmSourceFile const*>&,
+                      const std::string& config) const;
+  void GetExpectedXamlHeaders(std::set<std::string>&,
+                              const std::string& config) const;
+  void GetExpectedXamlSources(std::set<std::string>&,
+                              const std::string& config) const;
 
   void ComputeObjectMapping();
 
@@ -132,6 +138,13 @@ public:
     mutable std::set<std::string> ExpectedResxHeaders;
     mutable std::vector<cmSourceFile const*> ResxSources;
   };
+
+  struct XamlData {
+    std::set<std::string> ExpectedXamlHeaders;
+    std::set<std::string> ExpectedXamlSources;
+    std::vector<cmSourceFile const*> XamlSources;
+  };
+
 private:
   friend class cmTargetTraceDependencies;
   struct SourceEntry { std::vector<cmSourceFile*> Depends; };

Source/cmVisualStudio10TargetGenerator.cxx

@@ -461,6 +461,7 @@ void cmVisualStudio10TargetGenerator::Generate()
   this->WriteAllSources();
   this->WriteDotNetReferences();
   this->WriteEmbeddedResourceGroup();
+  this->WriteXamlFilesGroup();
   this->WriteWinRTReferences();
   this->WriteProjectReferences();
   this->WriteString(
@@ -522,8 +523,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
 
       this->WriteString("<DependentUpon>", 3);
       std::string hFileName = obj.substr(0, obj.find_last_of(".")) + ".h";
-      (*this->BuildFileStream ) << hFileName;
-      this->WriteString("</DependentUpon>\n", 3);
+      (*this->BuildFileStream) << hFileName << "</DependentUpon>\n";
 
       std::vector<std::string> const * configs =
         this->GlobalGenerator->GetConfigurations();
@@ -546,6 +546,38 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
     }
 }
 
+void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup()
+{
+  std::vector<cmSourceFile const*> xamlObjs;
+  this->GeneratorTarget->GetXamlSources(xamlObjs, "");
+  if (!xamlObjs.empty())
+    {
+    this->WriteString("<ItemGroup>\n", 1);
+    for (std::vector<cmSourceFile const*>::const_iterator
+           oi = xamlObjs.begin(); oi != xamlObjs.end(); ++oi)
+      {
+      std::string obj = (*oi)->GetFullPath();
+      std::string xamlType;
+      const char * xamlTypeProperty = (*oi)->GetProperty("VS_XAML_TYPE");
+      if (xamlTypeProperty)
+        {
+        xamlType = xamlTypeProperty;
+        }
+      else
+        {
+        xamlType = "Page";
+        }
+
+      this->WriteSource(xamlType, *oi, ">\n");
+      this->WriteString("<SubType>Designer</SubType>\n", 3);
+      this->WriteString("</", 2);
+      (*this->BuildFileStream) << xamlType << ">\n";
+
+      }
+    this->WriteString("</ItemGroup>\n", 1);
+    }
+}
+
 void cmVisualStudio10TargetGenerator::WriteTargetSpecificReferences()
 {
   if(this->MSTools)
@@ -1192,12 +1224,21 @@ WriteGroupSources(const char* name,
 
 void cmVisualStudio10TargetGenerator::WriteHeaderSource(cmSourceFile const* sf)
 {
-  if(this->IsResxHeader(sf->GetFullPath()))
+  std::string const& fileName = sf->GetFullPath();
+  if (this->IsResxHeader(fileName))
     {
     this->WriteSource("ClInclude", sf, ">\n");
     this->WriteString("<FileType>CppForm</FileType>\n", 3);
     this->WriteString("</ClInclude>\n", 2);
     }
+  else if (this->IsXamlHeader(fileName))
+    {
+    this->WriteSource("ClInclude", sf, ">\n");
+    this->WriteString("<DependentUpon>", 3);
+    std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
+    (*this->BuildFileStream) << xamlFileName << "</DependentUpon>\n";
+    this->WriteString("</ClInclude>\n", 2);
+    }
   else
     {
     this->WriteSource("ClInclude", sf);
@@ -1669,6 +1710,17 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
                                               "      ", "\n", lang);
       }
     }
+  if (this->IsXamlSource(source->GetFullPath()))
+    {
+    (*this->BuildFileStream) << firstString;
+    firstString = ""; // only do firstString once
+    hasFlags = true;
+    this->WriteString("<DependentUpon>", 3);
+    const std::string& fileName = source->GetFullPath();
+    std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
+    (*this->BuildFileStream) << xamlFileName << "</DependentUpon>\n";
+    }
+
   return hasFlags;
 }
 
@@ -2749,6 +2801,28 @@ bool cmVisualStudio10TargetGenerator::
   return it != expectedResxHeaders.end();
 }
 
+bool cmVisualStudio10TargetGenerator::
+IsXamlHeader(const std::string& headerFile)
+{
+  std::set<std::string> expectedXamlHeaders;
+  this->GeneratorTarget->GetExpectedXamlHeaders(expectedXamlHeaders, "");
+
+  std::set<std::string>::const_iterator it =
+    expectedXamlHeaders.find(headerFile);
+  return it != expectedXamlHeaders.end();
+}
+
+bool cmVisualStudio10TargetGenerator::
+IsXamlSource(const std::string& sourceFile)
+{
+  std::set<std::string> expectedXamlSources;
+  this->GeneratorTarget->GetExpectedXamlSources(expectedXamlSources, "");
+
+  std::set<std::string>::const_iterator it =
+    expectedXamlSources.find(sourceFile);
+  return it != expectedXamlSources.end();
+}
+
 void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
 {
   bool isAppContainer = false;

Source/cmVisualStudio10TargetGenerator.h

@@ -69,6 +69,7 @@ private:
   void WriteEmbeddedResourceGroup();
   void WriteWinRTReferences();
   void WriteWinRTPackageCertificateKeyFile();
+  void WriteXamlFilesGroup();
   void WritePathAndIncrementalLinkOptions();
   void WriteItemDefinitionGroups();
   void VerifyNecessaryFiles();
@@ -119,6 +120,8 @@ private:
   void AddMissingSourceGroups(std::set<cmSourceGroup*>& groupsUsed,
                               const std::vector<cmSourceGroup>& allGroups);
   bool IsResxHeader(const std::string& headerFile);
+  bool IsXamlHeader(const std::string& headerFile);
+  bool IsXamlSource(const std::string& headerFile);
 
   cmIDEFlagTable const* GetClFlagTable() const;
   cmIDEFlagTable const* GetRcFlagTable() const;