root/juggler/tags/2.0_beta_1/buildwin32.py

#python

# ************** <auto-copyright.pl BEGIN do not edit this line> **************
#
# VR Juggler is (C) Copyright 1998-2003 by Iowa State University
#
# Original Authors:
#   Allen Bierbaum, Christopher Just,
#   Patrick Hartling, Kevin Meinert,
#   Carolina Cruz-Neira, Albert Baker
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
#
# -----------------------------------------------------------------
# File:          $RCSfile$
# Date modified: $Date$
# Version:       $Revision$
# -----------------------------------------------------------------
#
# *************** <auto-copyright.pl END do not edit this line> ***************

import glob
import os
import re
import shutil
import sys
import time
import traceback
import getopt

EXIT_STATUS_SUCCESS           = 0
EXIT_STATUS_NO_MSVS           = 1
EXIT_STATUS_MISSING_DATA_FILE = 2
EXIT_STATUS_MSVS_START_ERROR  = 3
EXIT_STATUS_INVALID_PATH      = 4
EXIT_STATUS_MISSING_REQ_VALUE = 5

gJugglerDir      = os.path.dirname(os.path.abspath(sys.argv[0]))
gOptionsFileName = "options.cache"

gHaveTk = False
try:
   import Tkinter
   import tkMessageBox
   import tkFileDialog
   import threading
   gHaveTk = True
except ImportError, ex:
   print ex

class BuildOption:
   def __init__(self, envVar, desc, defaultValue, isDirectory = True,
                required = True):
      self.envVar      = envVar
      self.desc        = desc
      self.default     = defaultValue
      self.required    = required
      self.isDirectory = isDirectory

def guessBoostToolset(reattempt = False):
   (cl_stdin, cl_stdout, cl_stderr) = os.popen3('cl')
   cl_version_line = cl_stderr.readline()

   cl_ver_match = re.compile(r'Compiler Version ((\d+)\.(\d+)\.(\d+)) for')
   ver_string_match = cl_ver_match.search(cl_version_line)

   if ver_string_match is not None:
      cl_major = int(ver_string_match.group(2))
      cl_minor = int(ver_string_match.group(3))

      if cl_major == 13 and cl_minor < 10:
         vs_ver = '.NET 2002'
         boost_tool_guess = 'vc7'
      else:
         vs_ver = '.NET 2003'
         boost_tool_guess = 'vc71'

      printStatus("It appears that we will be using Visual Studio " + vs_ver)
   else:
      boost_tool_guess = ''

   in_status  = cl_stdin.close()
   out_status = cl_stdout.close()
   err_status = cl_stderr.close()

   # If there was an error closing any of the streams returned by
   # os.popen3(), then the command was not opened correctly.  That means
   # that CL.EXE is not in the user's path.
   if in_status is not None or out_status is not None or err_status is not None:
      # If this is not a reattempt to guess the Visual Studio version, then
      # be nice and extend the user's path to include their Visual Studio
      # installation.
      if not reattempt:
         # Common installation directories for Visual Studio 7.x.
         vs_dirs = [r'C:\Program Files\Microsoft Visual Studio .NET',
                    r'C:\Program Files\Microsoft Visual Studio .NET 2003']

         for d in vs_dirs:
            if os.path.exists(d):
               printStatus("NOTE: Using Visual Studio installation in")
               printStatus("      " + d)
               vs_path = [os.path.join(d, r'Common7\IDE'),
                          os.path.join(d, r'VC7\BIN'),
                          os.path.join(d, r'Common7\Tools'),
                          os.path.join(d, r'Common7\Tools\bin\prerelease'),
                          os.path.join(d, r'Common7\Tools\bin')]
               path_add = ';'.join(vs_path)
               os.environ['PATH'] = path_add + os.pathsep + os.getenv('PATH', '')

               # Try again to guess the Visual Studio version.
               return guessBoostToolset(True)

         # If execution reaches this point, our attempts to guess the
         # location of a Visual Studio 7.x installation failed.
         noVisualStudioError()

      # If this is a reattempt to guess the Visual Studio version, then
      # something is wrong with the user's Visual Studio installation.
      else:
         noVisualStudioError()

   return boost_tool_guess

def printStatus(msg):
   '''
   This is a simple wrapper around the standard Python print function.
   We will use a wrapper function for key status messages so that they
   can be redirected either to the console or to a GUI easily.
   '''
   print msg

def noVisualStudioError():
   print "ERROR: Visual Studio commands are not in your path!"
   print "Run vsvars32.bat in this shell or update the %PATH% environment"
   print "variable on your system."
   sys.exit(EXIT_STATUS_NO_MSVS)

def getCacheFileName():
   return os.path.join(gJugglerDir, gOptionsFileName)

def processInput(optionDict, envVar, inputDesc, required = False):
   default_value = optionDict[envVar]
   print "  %s [%s]: " % (inputDesc, default_value),
   input_str = sys.stdin.readline().strip(" \n")

   if input_str == '':
      if required and (default_value is None or default_value == ''):
         print "ERROR: %s value required" % inputDesc
         sys.exit(EXIT_STATUS_MISSING_REQ_VALUE)
      else:
         value_str = default_value
   else:
      value_str = input_str

   optionDict[envVar] = value_str
   os.environ[envVar] = value_str

   return value_str

def getDefaultVars():
   boost_tool_fallback = guessBoostToolset()

   required = []
   required.append(BuildOption('BOOST_ROOT',
                               'Boost C++ installation directory', ''))
   required.append(BuildOption('BOOST_VERSION', 'Boost C++ version',
                               '1_31', False))
   required.append(BuildOption('BOOST_INCLUDES',
                               'Directory containing the Boost C++ header tree',
                               ''))
   required.append(BuildOption('BOOST_TOOL',
                               'The Boost.Build toolset used to compile Boost C++',
                               boost_tool_fallback, False))
   required.append(BuildOption('NSPR_ROOT', 'NSPR installation directory', ''))
   required.append(BuildOption('CPPDOM_ROOT', 'CppDOM installation directory',
                               ''))
   required.append(BuildOption('GMTL_ROOT', 'GMTL installation directory', ''))

   optional = []
   optional.append(BuildOption('JAVA_HOME', 'Java installation directory',
                               r'C:\java', required = False))
   optional.append(BuildOption('JOGL_HOME', 'Jogl installation directory',
                               os.getenv('JAVA_HOME', ''), required = False))
   optional.append(BuildOption('JAVA3D_HOME', 'Java 3D installation directory',
                               os.getenv('JAVA_HOME', ''), required = False))
   optional.append(BuildOption('OMNIORB_ROOT',
                               'omniORB installation directory', '',
                               required = False))
   optional.append(BuildOption('PFROOT',
                               'OpenGL Performer installation directory',
                               r'C:\Program Files\Silicon Graphics\OpenGL Performer',
                               required = False))
   optional.append(BuildOption('VRPN_ROOT', 'VRPN installation directory', '',
                               required = False))
   optional.append(BuildOption('AUDIERE_ROOT',
                               'Audiere installation directory', '',
                               required = False))
   optional.append(BuildOption('OPENAL_ROOT',
                               'OpenAL SDK installation directory', '',
                               required = False))
   optional.append(BuildOption('TRACKD_API_ROOT',
                               'TrackdAPI installation directory', '',
                               required = False))

   options = {
      'prefix'      : r'C:\vrjuggler',
      'deps-prefix' : r'C:\vrjuggler-deps'
   }

   for opt in required + optional:
      options[opt.envVar] = os.getenv(opt.envVar, opt.default)

   # If there are cached options, read them in.
   cache_file = getCacheFileName()
   if os.path.exists(cache_file):
      execfile(cache_file)

   return required, optional, options

def setVars():
   required, optional, options = getDefaultVars()

   print "+++ Required Settings"
   processInput(options, 'prefix', 'Installation prefix')

   boost_dir = ''
   boost_ver = ''
   for opt in required:
      result = processInput(options, opt.envVar, opt.desc, opt.required)

      # The following is a little hack to get a reasonable default set for
      # the BOOST_INCLUDES variable before the user has to enter it manually.
      if opt.envVar == 'BOOST_ROOT':
         boost_dir = result
      elif opt.envVar == 'BOOST_VERSION':
         boost_ver = result
         options['BOOST_INCLUDES'] = boost_dir + r'\include\boost-' + boost_ver

   print "+++ Optional Settings"
   processInput(options, 'deps-prefix', 'Dependency installation prefix')

   for opt in optional:
      processInput(options, opt.envVar, opt.desc, opt.required)

   postProcessOptions(options)
   writeCacheFile(options)

   return options

def postProcessOptions(options):
   # Check for Boost 1.32 Visual C++ toolset names.
   match = re.compile(r'vc-(\d)_(\d)').match(options['BOOST_TOOL'])

   if match is not None:
      os.environ['BOOST_TOOL'] = 'vc%s%s' % (match.group(1), match.group(2))

   # If the %JAVA_HOME% setting is a valid directory, add its bin subdirectory
   # to the path.
   if os.environ['JAVA_HOME'] != '' and os.path.exists(os.environ['JAVA_HOME']):
      jdk_path = os.path.join(os.environ['JAVA_HOME'], 'bin')
      os.environ['PATH'] = jdk_path + os.pathsep + os.environ['PATH']
      os.environ['JACORB_PATH'] = os.path.join(gJugglerDir, r'external\JacORB')

   if os.environ['OMNIORB_ROOT'] != '' and os.path.exists(os.environ['OMNIORB_ROOT']):
      omni_bin = os.path.join(os.environ['OMNIORB_ROOT'], 'bin')

      if os.path.exists(os.path.join(omni_bin, 'omniidl.exe')):
         os.environ['OMNIORB_BIN'] = omni_bin
      else:
         os.environ['OMNIORB_BIN'] = os.path.join(omni_bin, 'x86_win32')

      # Extend the path to include omniORB's bin directory.
      os.environ['PATH'] = os.environ['OMNIORB_BIN'] + os.pathsep + os.environ['PATH']

      omni_lib = os.path.join(os.environ['OMNIORB_ROOT'], 'lib')

      if os.getenv('PYTHONPATH', '') != '':
         os.environ['PYTHONPATH'] = os.path.join(omni_lib, 'python') + os.pathsep + os.environ['PYTHONPATH']
      else:
         os.environ['PYTHONPATH'] = os.path.join(omni_lib, 'python')

      if os.path.exists(os.path.join(omni_lib, 'omnithread.lib')):
         os.environ['OMNIORB_LIB'] = omni_lib
      else:
         os.environ['OMNIORB_LIB'] = os.path.join(omni_lib, 'x86_win32')

      omni_glob = os.path.join(os.environ['OMNIORB_LIB'], 'omniORB*_rt.lib')
      libs = glob.glob(omni_glob)
      omni_ver_re = re.compile(r'omniORB(\d\d\d)_rt.lib')

      for l in libs:
         match = omni_ver_re.search(l)
         if match is not None:
            os.environ['OMNIORB_VERSION'] = match.group(1)
            break

def writeCacheFile(optionDict):
   cache_file = open(getCacheFileName(), 'w')
   for k, v in optionDict.iteritems():
      output = "options['%s'] = r'%s'\n" % (k, v)
      cache_file.write(output)
   cache_file.close()

def generateVersionHeaders():
   class JugglerModule:
      def __init__(self, srcDir, projDir, genFiles = None):
         self.source_dir     = os.path.join(gJugglerDir, srcDir)
         self.version_params = os.path.join(self.source_dir, 'Makefile.inc.in')
         self.version_file   = os.path.join(self.source_dir, 'VERSION')
         self.param_files    = []

         if genFiles is not None:
            for f in genFiles:
               output = os.path.join(gJugglerDir, 'vc7', projDir, f[0])

               if len(f) == 1 or f[1] is None:
                  template = os.path.join(self.source_dir, f[0] + '.in')
               else:
                  template = f[1]

               self.param_files.append((output, template))

      def generateParamFiles(self):
         for (output, template) in self.param_files:
            if os.path.exists(output):
               mtime = os.path.getmtime
               # This test to determine if the module's param header needs to
               # be regenerated is equivalent to that used by the UNIX build
               # system.
               if mtime(self.version_file) > mtime(output) or \
                  mtime(template) > mtime(output):
                  self.__genParamFile(output, template)
            else:
               self.__genParamFile(output, template)

      version_re      = re.compile(r'((\d+)\.(\d+)\.(\d+)-(\d+))\s')
      branch_re       = re.compile(r'BRANCH\s*=\s*(\w+)')
      canon_name_re   = re.compile(r'CANON_NAME\s*=\s*(\S.+)')
      vernum_re       = re.compile(r'@VER_NUMBER@')
      major_vernum_re = re.compile(r'@MAJOR_VER_NUMBER@')
      minor_vernum_re = re.compile(r'@MINOR_VER_NUMBER@')
      patch_vernum_re = re.compile(r'@PATCH_VER_NUMBER@')
      verstr_re       = re.compile(r'@VER_STRING@')
      zero_strip_re   = re.compile(r'^0*([^0]\d+)')

      def __genParamFile(self, output, template):
         ver_file = open(self.version_file)
         cur_ver  = ver_file.readline()
         ver_file.close()
         ver_match = self.version_re.match(cur_ver)
         version = ver_match.group(1)
         major   = int(ver_match.group(2))
         minor   = int(ver_match.group(3))
         patch   = int(ver_match.group(4))

         # NOTE: This will not always be identical to the UNIX version because
         # Python does not have %e as a time formatting directive.
         date       = time.strftime('%b %d, %Y %H:%M:%S')
         canon_name = ''
         branch     = ''

         param_file = open(self.version_params, 'r')
         params     = param_file.readlines()
         param_file.close()

         # This is basically a poor man's grep.  Can this be done better?
         for line in params:
            match = self.branch_re.match(line)
            if match is not None:
               branch_name = match.group(1)
               continue

            match = self.canon_name_re.match(line)
            if match is not None:
               canon_name = match.group(1)
               continue

         version_number = '%03d%03d%03d' % (major, minor, patch)
         version_string = "\"v%s '%s' (NSPR) %s %s\"" % \
                             (version, canon_name, branch, date)

         # Strip leading zeroes from version_number.  Is there an easier way
         # to do this?
         version_number = self.zero_strip_re.match(version_number).group(1)

         try:
            input_file  = open(template, 'r')
            input_lines = input_file.readlines()
            input_file.close()

            for i in xrange(len(input_lines)):
               line = input_lines[i]
               if self.vernum_re.search(line):
                  input_lines[i] = self.vernum_re.sub(version_number, line)
               elif self.major_vernum_re.search(line):
                  input_lines[i] = self.major_vernum_re.sub(str(major), line)
               elif self.minor_vernum_re.search(line):
                  input_lines[i] = self.minor_vernum_re.sub(str(minor), line)
               elif self.patch_vernum_re.search(line):
                  input_lines[i] = self.patch_vernum_re.sub(str(patch), line)
               elif self.verstr_re.search(line):
                  input_lines[i] = self.verstr_re.sub(version_string, line)

            printStatus("Generating updated " + output)
            param_header = open(output, 'w')
            param_header.writelines(input_lines)
            param_header.close()
         except IOError, ex:
            printStatus("ERROR: Could not read from %s" % template)
            printStatus(ex)
            printStatus("Cannot continue; exiting with error status.")
            sys.exit(EXIT_STATUS_MISSING_DATA_FILE)

   mods = []
   mods.append(JugglerModule(r'modules\vapor', 'VPR',
                             [(r'vpr\vprParam.h',), (r'vpr\vprParam.cpp',)]))
   mods.append(JugglerModule(r'modules\tweek', 'Tweek_CXX',
                             [(r'tweek\tweekParam.h',),
                              (r'tweek\tweekParam.cpp',)]))
   mods.append(JugglerModule(r'modules\jackal', 'JCCL',
                             [(r'jccl\jcclParam.h',
                               os.path.join(gJugglerDir,
                                            r'modules\jackal\common\jccl\jcclParam.h.in')),
                              (r'jccl\jcclParam.cpp',
                               os.path.join(gJugglerDir,
                                            r'modules\jackal\common\jccl\jcclParam.cpp.in'))
                             ]))
   mods.append(JugglerModule(r'modules\sonix', 'Sonix',
                             [(r'snx\snxParam.h',), (r'snx\snxParam.cpp',)]))
   mods.append(JugglerModule(r'modules\gadgeteer', 'Gadgeteer',
                             [(r'gadget\gadgetParam.h',),
                              (r'gadget\gadgetParam.cpp',)]))
   mods.append(JugglerModule(r'modules\vrjuggler', 'VRJuggler',
                             [(r'vrj\vrjParam.h',), (r'vrj\vrjParam.cpp',)]))

   for m in mods:
      m.generateParamFiles()

def generateAntBuildFiles():
   class AntTarget:
      def __init__(self, srcdir, moduleName, outputFile = 'build.xml'):
         self.srcdir      = os.path.join(gJugglerDir, srcdir)
         self.topdir      = os.path.join(gJugglerDir, r'vc7')
         self.module_name = os.path.join(self.topdir, moduleName)
         self.output_file = os.path.join(self.module_name, outputFile)

         if not os.path.exists(self.module_name):
            os.mkdir(self.module_name)
         elif not os.path.isdir(self.module_name):
            printStatus("ERROR: %s exists, but it is not a directory!" % self.module_name)
            sys.exit(EXIT_STATUS_INVALID_PATH)

      # This form of regular expressions appears to be necessary because
      # the sub() method does not handle backslashes in the replacement string
      # the way I would like.
      srcdir_re         = re.compile(r'^(.*)@srcdir@(.*)$')
      topdir_re         = re.compile(r'^(.*)@topdir@(.*)$')
      juggler_root_re   = re.compile(r'^(.*)@JUGGLERROOT_ABS@(.*)$')
      jdom_jar_re       = re.compile(r'^(.*)@JDOM_JAR@(.*)$')
      tweek_jars_re     = re.compile(r'^(.*)@TWEEK_JARS@(.*)$')
      tweek_ext_jars_re = re.compile(r'^(.*)@TWEEK_EXT_JARS@(.*)$')
      jccl_jars_re      = re.compile(r'^(.*)@JCCL_JARS@(.*)$')
      java_orb_jar_re   = re.compile(r'^(.*)@JAVA_ORB_JAR@(.*)$')
      jogl_jars_re      = re.compile(r'^(.*)@JOGL_JARS@(.*)$')
      java3d_jars_re    = re.compile(r'^(.*)@JAVA3D_JAR@(.*)$')

      jdom_jars = [
         os.path.join(gJugglerDir, r'external\jdom\build\jdom.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\jaxen-core.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\xalan.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\jaxen-jdom.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\xerces.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\xml-apis.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\saxpath.jar')
      ]

      tweek_jars = [
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'Tweek.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'TweekBeans.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'TweekEvents.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'TweekNet.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'TweekBeanDelivery.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'TweekServices.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'Viewers.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'kunststoff-mod.jar')
      ]

      tweek_ext_jars = [
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'ui.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'wizard.jar'),
         os.path.join(gJugglerDir, r'vc7\Tweek_Java', 'WizardBuilder.jar')
      ]

      jccl_jars = [
         os.path.join(gJugglerDir, r'vc7\JCCL_Java', 'jccl_config.jar'),
         os.path.join(gJugglerDir, r'vc7\JCCL_Java', 'jccl_editors.jar')
      ]

      jccl_rtrc_jars = [
         os.path.join(gJugglerDir, r'vc7\JCCL_Java\RTRC_Plugin_Java',
                      'jccl_rtrc.jar')
      ]

      jogl_jars = [
         os.path.join(os.environ['JOGL_HOME'], 'jogl.jar'),
         os.path.join(os.environ['JOGL_HOME'], 'jogl-demos-util.jar')
      ]

      java3d_jars = [
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\j3daudio.jar'),
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\j3dcore.jar'),
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\j3dutils.jar'),
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\vecmath.jar')
      ]

      def generateBuildFile(self):
         input_file = open(os.path.join(self.srcdir, 'build.xml.in'), 'r')
         input = input_file.readlines()
         input_file.close()

         for i in xrange(len(input)):
            line = input[i]

            if self.srcdir_re.search(line):
               match = self.srcdir_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], self.srcdir,
                                        match.groups()[1])
            elif self.topdir_re.search(line):
               match = self.topdir_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], self.topdir,
                                        match.groups()[1])
            elif self.juggler_root_re.search(line):
               match = self.juggler_root_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], gJugglerDir,
                                        match.groups()[1])
            elif self.java_orb_jar_re.search(line):
               match = self.java_orb_jar_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], "",
                                        match.groups()[1])
            elif self.jdom_jar_re.search(line):
               jars = os.pathsep.join(self.jdom_jars)
               match = self.jdom_jar_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.tweek_jars_re.search(line):
               jars = os.pathsep.join(self.tweek_jars + self.jdom_jars)
               match = self.tweek_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.tweek_ext_jars_re.search(line):
               jars = os.pathsep.join(self.tweek_ext_jars)
               match = self.tweek_ext_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.jccl_jars_re.search(line):
               jars = os.pathsep.join(self.jccl_jars + self.jccl_rtrc_jars)
               match = self.jccl_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.jogl_jars_re.search(line):
               jars = os.pathsep.join(self.jogl_jars)
               match = self.jogl_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.java3d_jars_re.search(line):
               jars = os.pathsep.join(self.java3d_jars)
               match = self.java3d_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])

         build_file = open(self.output_file, 'w')
         build_file.writelines(input)
         build_file.close()

   mods = []
   mods.append(AntTarget(r'modules\tweek\java', 'Tweek_Java'))
   mods.append(AntTarget(r'modules\tweek\extensions\java', 'Tweek_Java',
                         'build-ext.xml'))
   mods.append(AntTarget(r'modules\jackal\config', 'JCCL_Java',
                         'build-config.xml'))
   mods.append(AntTarget(r'modules\jackal\editors', 'JCCL_Java',
                         'build-editors.xml'))
   mods.append(AntTarget(r'modules\jackal\plugins\corba_rtrc',
                         r'JCCL_Java\RTRC_Plugin_Java', 'build.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig', 'VRJConfig',
                         'build.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig\commoneditors',
                         r'VRJConfig\commoneditors',
                         'build-commoneditors.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig\customeditors\display_window',
                         'VRJConfig', 'build-display_window.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig\customeditors\intersense',
                         'VRJConfig', 'build-intersense.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig\customeditors\pinchglove',
                         'VRJConfig', 'build-pinchglove.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig\customeditors\proxyeditor',
                         'VRJConfig', 'build-proxyeditor.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig\customeditors\surfacedisplayeditor',
                         'VRJConfig', 'build-surfacedisplayeditor.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\plugins\corba_perf_mon',
                         r'VRJugglerPlugins\Perf_Plugin_Java', 'build.xml'))

   for m in mods:
      m.generateBuildFile()

def doInstall(prefix):
   makeTree(prefix)
   installExternal(prefix)
   installVPR(prefix)
   installTweek(prefix)
   installTweekJava(prefix)
   installJCCL(prefix)
   installJCCLJava(prefix)
   installJCCLPlugins(prefix)
   installJCCLPluginsJava(prefix)
   installSonix(prefix)
   installSonixPlugins(prefix)
   installGadgeteer(prefix)
   installGadgeteerDrivers(prefix)
   installGadgeteerPlugins(prefix)
   installVRJuggler(prefix)
   installVRJConfig(prefix)
   installVRJugglerPlugins(prefix)
   installVRJugglerPluginsJava(prefix)
   installMsvcRT(prefix)

def mkinstalldirs(dir):
#   print "Checking for", dir
   if not os.path.exists(dir):
      (head, tail) = os.path.split(dir)
      mkinstalldirs(head)
      os.mkdir(dir)

def makeTree(prefix):
   mkinstalldirs(os.path.join(prefix, 'bin'))
   mkinstalldirs(os.path.join(prefix, 'include'))
   mkinstalldirs(os.path.join(prefix, 'lib'))
   mkinstalldirs(os.path.join(prefix, 'share'))

def installDir(startDir, destDir, allowedExts = None, disallowedExts = None,
               disallowedFiles = None):
   cwd = os.getcwd()
   mkinstalldirs(destDir)

   os.chdir(startDir)
   contents = os.listdir(startDir)

   if disallowedExts is None:
      disallowedExts = []

   if disallowedFiles is None:
      disallowedFiles = []

   # Add some extensions that should always be disallowed.  This relieves the
   # caller from having to add these repeatedly.
   disallowedExts.append('.ilk')
   disallowedExts.append('.ncb')
   disallowedExts.append('.pdb')
   disallowedExts.append('.suo')

   skip_dirs = ['CVS', 'autom4te.cache']
   for f in contents:
      if os.path.isdir(f):
         if f in skip_dirs:
            continue

         start_dir = os.path.join(startDir, f)
         dest_dir  = os.path.join(destDir, f)
         installDir(start_dir, dest_dir, allowedExts, disallowedExts)
      else:
         (root, f_ext) = os.path.splitext(f)
         if allowedExts is None:
            if f_ext not in disallowedExts:
               shutil.copy2(f, destDir)
         elif f_ext in allowedExts:
            (head, tail) = os.path.split(f)
            if f not in disallowedFiles:
               shutil.copy2(f, destDir)

   os.chdir(cwd)

def installLibs(srcRoot, destdir,
                buildTypes = ['ReleaseDLL', 'DebugDLL', 'Release', 'Debug'],
                extensions = ['.dll', '.lib']):
   for t in buildTypes:
      srcdir = os.path.join(srcRoot, t)
      if os.path.exists(srcdir):
         installDir(srcdir, destdir, extensions)

def installExternal(prefix):
   # Install Doozer (even though it probably won't be used).
   printStatus("Installing Doozer ...")
   destdir = os.path.join(prefix, 'share', 'Doozer')
   srcdir  = os.path.join(gJugglerDir, 'external', 'Doozer')
   installDir(srcdir, destdir, ['.mk'])

def installVPR(prefix):
   printStatus("Installing VPR headers and libraries ...")

   destdir = os.path.join(prefix, 'include', 'vpr')
   srcdir  = os.path.join(gJugglerDir, 'modules', 'vapor', 'vpr')
   installDir(srcdir, destdir, ['.h'])

   srcdir  = os.path.join(gJugglerDir, 'vc7', 'VPR', 'vpr')
   installDir(srcdir, destdir, ['.h'])

   destdir = os.path.join(prefix, 'lib')
   srcroot = os.path.join(gJugglerDir, 'vc7', 'VPR')
   installLibs(srcroot, destdir)

   destdir = os.path.join(prefix, 'share', 'vpr', 'test')
   srcdir  = os.path.join(gJugglerDir, 'modules', 'vapor', 'test')
   installDir(srcdir, destdir, None, ['.in'])

   # Install additional files into <prefix>\share\vpr
   destdir = os.path.join(prefix, 'share', 'vpr')
   srcroot = os.path.join(gJugglerDir, 'modules', 'vapor')

   shutil.copy2(os.path.join(gJugglerDir, 'COPYING.txt'), destdir)
   extra_files = ['ChangeLog', 'README.txt', 'RELEASE_NOTES.txt']
   for f in extra_files:
      shutil.copy2(os.path.join(srcroot, f), destdir)

def installTweek(prefix):
   printStatus("Installing Tweek C++ headers, libraries, and data files ...")