Generate all chrome .vcproj files:

site_scons/site_tools/_Node_MSVS.py

 #
 # __COPYRIGHT__
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish,
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
@@ skipping 20 matching lines @@
 import md5
 import os
 import random
 import re
 import UserList
 import xml.dom
 import xml.dom.minidom
 
 import SCons.Node.FS
 import SCons.Script
+import SCons.Util
 
 from SCons.Debug import Trace
 TODO = 0
 
 # Initialize random number generator
 random.seed()
 
 
 #------------------------------------------------------------------------------
 # Entry point for supplying a fixed map of GUIDs for testing.
@@ skipping 162 matching lines @@
   if not topdown:
     yield top, dirs, nondirs
 
 #------------------------------------------------------------------------------
 
 class _MSVSFolder(FileList):
   """Folder in a Visual Studio solution."""
 
   entry_type_guid = '{2150E333-8FDC-42A3-9474-1A3956D46DE8}'
 
-  def initialize(self, path, name = None, entries = None, guid = None, items = None):
+  def initialize(self, path, name=None, entries=None, guid=None, items=None):
     """Initializes the folder.
 
     Args:
       path: The unique name of the folder, by which other MSVS Nodes can
           refer to it.  This is not necessarily the name that gets printed
           in the .sln file.
       name: The name of this folder as actually written in a generated
           .sln file.  The default is
       entries: List of folder entries to nest inside this folder.  May contain
           Folder or Project objects.  May be None, if the folder is empty.
@@ skipping 144 matching lines @@
 class MSVSTool(object):
   """Visual Studio tool."""
 
   def __init__(self, Name, **attrs):
     """Initializes the tool.
 
     Args:
       Name: Tool name.
       **attrs: Tool attributes.
     """
+
+    val = attrs.get('AdditionalDependencies')
+    if val:
+      if isinstance(val, list):
+        val = ' '.join(val)
+      attrs['AdditionalDependencies'] = val.replace('/', '\\')
+
+    val = attrs.get('AdditionalIncludeDirectories')
+    if val:
+      if isinstance(val, list):
+        val = ';'.join(val)
+      attrs['AdditionalIncludeDirectories'] = val.replace('/', '\\')
+
+    val = attrs.get('AdditionalManifestFiles')
+    if val:
+      if isinstance(val, list):
+        val = ';'.join(val)
+      attrs['AdditionalManifestFiles'] = val.replace('/', '\\')
+
+    val = attrs.get('CommandLine')
+    if val:
+      if isinstance(val, list):
+        val = '\r\n'.join(val)
+      attrs['CommandLine'] = val.replace('/', '\\')
+
+    val = attrs.get('PreprocessorDefinitions')
+    if val:
+      if isinstance(val, list):
+        val = ';'.join(val)
+      attrs['PreprocessorDefinitions'] = val
+
+    for a in ('ImportLibrary',
+              'ObjectFile',
+              'OutputFile',
+              'Outputs',
+              'XMLDocumentationFileName'):
+      val = attrs.get(a)
+      if val:
+        val = val.replace('/', '\\')
+        attrs[a] = val
+
     self.Name = Name
     self.attrs = attrs
 
   def CreateElement(self, doc):
     """Creates an element for the tool.
 
     Args:
       doc: xml.dom.Document object to use for node creation.
 
     Returns:
@@ skipping 48 matching lines @@
 
   entry_type_guid = '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}'
   initialized = False
 
   def initialize(self, env, path, name = None,
                                  dependencies = None,
                                  guid = None,
                                  buildtargets = [],
                                  files = [],
                                  root_namespace = None,
-                                 relative_path_prefix = '',
+                                 keyword = None,
+                                 relative_path_prefix = None,
+                                 local_directory_prefix = None,
+                                 relative_path_substitutions = [],
                                  tools = None,
                                  configurations = None,
                                  **attrs):
     """Initializes the project.
 
     Args:
       path: Relative path to project file.
       name: Name of project.  If None, the name will be the same as the base
           name of the project file.
       dependencies: List of other Project objects this project is dependent
@@ skipping 37 matching lines @@
       #  pass
     else:
       self.buildtargets = []
       self.configurations = []
       self.dependencies = []
       self.file_configurations = {}
       self.files = MSVSFiles([])
       self.tool_files = []
       self.file_lists = []
       self.initialized = True
+      self.keyword = None
+      self.local_directory_prefix = ''
+      self.relative_path_prefix = ''
+      self.relative_path_substitutions = []
+      self.root_namespace = name
 
     self.attrs = attrs
     self.env = env
     self.guid = guid
     self.msvs_name = name
     self.msvs_path = path
-    self.relative_path_prefix = relative_path_prefix
-    self.root_namespace = root_namespace or self.msvs_name
+    if relative_path_prefix:
+      self.relative_path_prefix = relative_path_prefix
+    if local_directory_prefix:
+      self.local_directory_prefix = local_directory_prefix
+    for left, right in relative_path_substitutions:
+      t = (left.replace('/', '\\'), right.replace('/', '\\'))
+      self.relative_path_substitutions.append(t)
+    if root_namespace:
+      self.root_namespace = root_namespace
+    if keyword:
+      self.keyword = keyword
     self.tools = tools
 
     self.buildtargets.extend(buildtargets)
     self.configurations.extend(configurations or [])
     self.dependencies.extend(list(dependencies or []))
     self.AddFiles(files)
 
     env.Command(self, [], MSVSProjectAction)
 
   def args2nodes(self, entries):
     result = []
     for entry in entries:
       if SCons.Util.is_String(entry):
         entry = self.env.File(entry)
-        result.append(entry)
+        result.append(entry.srcnode())
       elif hasattr(entry, 'entries'):
         entry.entries = self.args2nodes(entry.entries)
         result.append(entry)
       elif isinstance(entry, (list, UserList.UserList)):
         result.extend(self.args2nodes(entry))
       elif hasattr(entry, 'sources') and entry.sources:
         result.extend(entry.sources)
       else:
         result.append(entry.srcnode())
     return result
@@ skipping 40 matching lines @@
         # 4. We should be able to handle pre-built project files by reading the
         #    GUID from the files.
         guid = MakeGuid(self.msvs_path)
       self.guid = guid
     return self.guid
 
   def get_msvs_path(self, sln):
       return sln.rel_path(self).replace('/', '\\')
 
   def get_rel_path(self, node):
-      result = self.relative_path_prefix + self.rel_path(node)
-      return result.replace('/', '\\')
+      result = self.rel_path(node)
+      if self.relative_path_prefix:
+        if not result.startswith('..'):
+          result = self.relative_path_prefix + result
+      elif not os.path.split(result)[0]:
+        result = self.local_directory_prefix + result
+      result = result.replace('/', '\\')
+      for left, right in self.relative_path_substitutions:
+        result = result.replace(left, right)
+      return result
 
   def AddConfig(self, Name, tools=None, **attrs):
     """Adds a configuration to the parent node.
 
     Args:
       Name: The name of the configuration.
       tools: List of tools (strings or Tool objects); may be None.
       **attrs: Configuration attributes.
     """
     if tools is None:
@@ skipping 94 matching lines @@
     xml_impl = xml.dom.getDOMImplementation()
     self.doc = xml_impl.createDocument(None, 'VisualStudioProject', None)
 
     # Add attributes to root element
     root = self.doc.documentElement
     root.setAttribute('ProjectType', 'Visual C++')
     root.setAttribute('Version', '8.00')
     root.setAttribute('Name', self.msvs_name)
     root.setAttribute('ProjectGUID', self.get_guid())
     root.setAttribute('RootNamespace', self.root_namespace)
-    root.setAttribute('Keyword', 'Win32Proj')
+    if self.keyword:
+      root.setAttribute('Keyword', self.keyword)
 
     # Add platform list
     platforms = self.doc.createElement('Platforms')
     root.appendChild(platforms)
     n = self.doc.createElement('Platform')
     n.setAttribute('Name', 'Win32')
     platforms.appendChild(n)
 
     # Add tool files section
     tool_files = self.doc.createElement('ToolFiles')
@@ skipping 364 matching lines @@
           'InheritedPropertySheets',
       ],
       'FileConfiguration' : [
           'Name',
           'ExcludedFromBuild',
       ],
       'Tool' : [
           'Name',
           'DisableSpecificWarnings',
 
+          'AdditionalIncludeDirectories',
+          'Description',
+          'CommandLine',
+          'OutputFile',
+          'ImportLibrary',
           'PreprocessorDefinitions',
           'UsePrecompiledHeader',
           'PrecompiledHeaderThrough',
           'ForcedIncludeFiles',
       ],
       'VisualStudioProject' : [
           'ProjectType',
           'Version',
           'Name',
           'ProjectGUID',
@@ skipping 63 matching lines @@
   return result
 
 #------------------------------------------------------------------------------
 
 MSVSSolutionAction = SCons.Script.Action(MSVSAction,
                                          "Generating Visual Studio solution `$TARGET' ...")
 
 class _MSVSSolution(SCons.Node.FS.File):
   """Visual Studio solution."""
 
-  def initialize(self, env, path, entries = None, variants = None, websiteProperties = True):
+  def initialize(self, env, path, entries=None, variants=None, websiteProperties=True):
     """Initializes the solution.
 
     Args:
       path: Path to solution file.
       entries: List of entries in solution.  May contain Folder or Project
           objects.  May be None, if the folder is empty.
       variants: List of build variant strings.  If none, a default list will
           be used.
     """
     self.msvs_path = path
@@ skipping 171 matching lines @@
 
 def MSVSSolution(env, item, *args, **kw):
   if not SCons.Util.is_String(item):
       return item
   item = env.subst(item)
   result = env.fs._lookup(item, None, _MSVSSolution, create=1)
   result.initialize(env, item, *args, **kw)
   LookupAdd(item, result)
   return result
 
+class Derived(SCons.Util.Proxy):
+  def srcnode(self, *args, **kw):
+    return self
+  def __getattr__(self, name):
+    if name == 'sources':
+      return []
+    return SCons.Util.Proxy.__getattr__(self, name)
+  def __hash__(self, *args, **kw):
+    return id(self)
+
 import __builtin__
 
+__builtin__.Derived = Derived
 __builtin__.MSVSConfig = MSVSConfig
 __builtin__.MSVSFilter = MSVSFilter
 __builtin__.MSVSProject = MSVSProject
 __builtin__.MSVSSolution = MSVSSolution
 __builtin__.MSVSTool = MSVSTool