#!python
def print_all_nodes(dirnode, level=0):
    """Print all the scons nodes that are children of this node, recursively."""
    if type(dirnode)==type(''):
        dirnode=Dir(dirnode)
    dt = type(Dir('.'))
    for f in dirnode.all_children():
        if type(f) == dt:
            print "%s%s: .............."%(level * ' ', str(f))
            print_dir(f, level+2)
        print "%s%s"%(level * ' ', str(f))

#!python
import fnmatch
import os
def Glob( includes = Split( '*' ), excludes = None, dir = '.'):
   """Similar to glob.glob, except globs SCons nodes, and thus sees
   generated files and files from build directories.  Basically, it sees
   anything SCons knows about.  A key subtlety is that since this function
   operates on generated nodes as well as source nodes on the filesystem,
   it needs to be called after builders that generate files you want to
   include.
   It will return both Dir entries and File entries
   """
   def fn_filter(node):
      fn = os.path.basename(str(node))
      match = False
      for include in includes:
         if fnmatch.fnmatchcase( fn, include ):
            match = True
            break
      if match and excludes is not None:
         for exclude in excludes:
            if fnmatch.fnmatchcase( fn, exclude ):
               match = False
               break
      return match
   def filter_nodes(where):
       children = filter(fn_filter, where.all_children(scan=0))
       nodes = []
       for f in children:
           nodes.append(gen_node(f))
       return nodes
   def gen_node(n):
       """Checks first to see if the node is a file or a dir, then
       creates the appropriate node. [code seems redundant, if the node
       is a node, then shouldn't it just be left as is?
       """
       if type(n) in (type(''), type(u'')):
           path = n
       else:
           path = n.abspath
       if os.path.isdir(path):
           return Dir(n)
       else:
           return File(n)
   here = Dir(dir)
   nodes = filter_nodes(here)
   node_srcs = [n.srcnode() for n in nodes]
   src = here.srcnode()
   if src is not here:
       for s in filter_nodes(src):
           if s not in node_srcs:
               # Probably need to check if this node is a directory
               nodes.append(gen_node(os.path.join(dir,os.path.basename(str(s)))))
   return nodes

#!python
def Glob(match):
    """Similar to glob.glob, except globs SCons nodes, and thus sees
    generated files and files from build directories.  Basically, it sees
    anything SCons knows about.  A key subtlety is that since this function
    operates on generated nodes as well as source nodes on the filesystem,
    it needs to be called after builders that generate files you want to
    include."""
    def fn_filter(node):
        fn = str(node)
        return fnmatch.fnmatch(os.path.basename(fn), match)
    here = Dir('.')
    children = here.all_children()
    nodes = map(File, filter(fn_filter, children))
    node_srcs = [n.srcnode() for n in nodes]
    src = here.srcnode()
    if src is not here:
        src_children = map(File, filter(fn_filter, src.all_children()))
        for s in src_children:
            if s not in node_srcs:
                nodes.append(File(os.path.basename(str(s))))
    return nodes

#!python
def Glob( pattern = '*.*', dir = '.' ):
    import os, fnmatch
    files = []
    for file in os.listdir( Dir(dir).srcnode().abspath ):
        if fnmatch.fnmatch(file, pattern) :
            files.append( os.path.join( dir, file ) )
    return files

#!python
  def Matches(file, includes, excludes):
      match = False
      for pattern in includes:
         if fnmatch.fnmatchcase(file, pattern):
             match = True
             break
      if match and excludes is not None:
          for pattern in excludes:
              if fnmatch.fnmatchcase(file, pattern):
                  match = False
                  break
      return match
  def AddDir(src_dir, includes, excludes=None):
      files = []
      for file in os.listdir(Dir(src_dir).srcnode().abspath):
          fqpath = src_dir + '/' + file
          if os.path.isdir(fqpath):  continue   #don't include subdirs
          if Matches(file, includes, excludes):
             files.append(file)
      return files
used like so:
   AddDir("c:/mystuff", "*.cpp", excludes=['test*.cpp', '.svn'])

#!python
def SGlob(pattern):
        path = GetBuildPath('SConscript').replace('SConscript', '')
        result = []
        for i in glob.glob(path + pattern):
                result.append(i.replace(path, ''))
        return result