lyx_mirror/SConstruct

# vi:filetype=python:expandtab:tabstop=2:shiftwidth=2
#
# file SConstruct
# 
# This file is part of LyX, the document processor.
# Licence details can be found in the file COPYING.
# 
# \author Bo Peng
# Full author contact details are available in file CREDITS.
#
#
# This is a scons based building system for lyx, you can use it as follows:
# (after of course installation of scons from www.scons.org)
#  
#    scons [frontend=qt3|gt4] [boost=included|auto] ...
#
# Where:
#   * use scons -h for details about parameters
#   * qt3 is used by default on linux, cygwin and mac
#   * qt4 is used by default on win32
#
# File layouts (Important):
#   * Unless you specify builddir=dir, building will happen
#     in $BUILDDIR = $mode/$platform-$frontend. E.g., something like
#       debug/linux-qt3/
#   * All shared libs will be put in $BUILDDIR/libs, e.g.
#       debug/linux-qt3/libs
#   * lyx executable will be in directories like debug/linux-qt3
#  
# Hints:
#   * scons --config=force
#     force re-configuration (use scons -H for details)
#   
#   * check config.log to see why config has failed
#
#   * use extra_inc_path, extra_lib_path, qt_dir, qt_inc_path
#     qt_lib_path to help locate qt and other libraries
#     (there are extra_inc_path1, extra_lib_path1 for now)
#
#   * (Important) use scons logfile=logfile.log to enable command line
#     logging. (default is no logging)
#
# Notes:
#   * Currently, all scons does is building lyx in
#       $LYXROOT/$mode/$build_dir/
#     where $mode is debug or release, $build_dir is the build_dir name 
#     listed above
#
#   * scons install etc may be added later. Interested contributors can follow
#       http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/AccumulateBuilder
#     or
#       http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/DistTarBuilder
#     Please also see the commented out code in scons_utils.py
#       
#   * NSIS support can be found here.
#     http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/NsisSconsTool
#
#   * rpm support?
#     http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/RpmHonchoTemp
#
#   However, I decide to wait since scons seems to be standardizing these
#   features.
#

import os, sys

# config/scons_utils.py defines a few utility function
sys.path.append('config')
import scons_utils as utils

SetOption('implicit_cache', 1)

#----------------------------------------------------------
# Required runtime environment
#----------------------------------------------------------

# FIXME: I remember lyx requires higher version of python?
EnsurePythonVersion(1, 5)
# Please use at least 0.96.91 (not 0.96.1)
EnsureSConsVersion(0, 96)

#----------------------------------------------------------
# Global definitions
#----------------------------------------------------------

# some global settings
PACKAGE_VERSION = '1.5.0svn'
DEVEL_VERSION = True
default_build_mode = 'debug'

PACKAGE = 'lyx'
PACKAGE_BUGREPORT = 'lyx-devel@lists.lyx.org'
PACKAGE_NAME = 'LyX'
PACKAGE_TARNAME = 'lyx'
PACKAGE_STRING = '%s %s' % (PACKAGE_NAME, PACKAGE_VERSION)
PROGRAM_SUFFIX = ''
default_log_file = 'scons_lyx.log'

# FIXME: what is this? (They are used in src/support/package.C.in
LOCALEDIR = "../locale/"
LYX_DIR = "/usr/local/share/lyx"

# platform dependent default build_dir and other settings
#
# I know, somebody would say: 
#   This is TOTALLY wrong! Everything should be automatically
#   determined.
#
if os.name == 'nt':
  platform_name = 'win32'
  default_frontend = 'qt4'
  # boost and gettext are unlikely to be installed already
  default_boost_opt = 'included'
  default_gettext_opt = 'included'
  default_pch_opt = False
  default_with_x = False
  spell_checker = 'auto'
  # FIXME: I need to know what exactly is boost_posix
  # EF: It indicates to boost which API to use (posix or windows).
  # If not specified, boost tries to figure out by itself, but it may fail.
  boost_posix = False
  packaging_method = 'windows'
elif os.name == 'posix' and sys.platform != 'cygwin':
  platform_name = sys.platform
  default_frontend = 'qt3'
  # try to use system boost/gettext libraries
  default_boost_opt = 'auto'
  default_gettext_opt = 'auto'
  default_pch_opt = False
  default_with_x = True
  boost_posix = True
  packaging_method = 'posix'
elif os.name == 'posix' and sys.platform == 'cygwin':
  platform_name = 'cygwin'
  default_frontend = 'qt3'
  # force the use of cygwin/boost/gettext
  default_boost_opt = 'system'
  default_gettext_opt = 'system'
  default_pch_opt = False
  default_with_x = True
  boost_posix = True
  packaging_method = 'posix'
elif os.name == 'darwin':
  platform_name = 'mac'
  default_frontend = 'qt3'
  # to be safe
  default_boost_opt = 'included'
  default_gettext_opt = 'included'
  default_pch_opt = False
  default_with_x = False
  boost_posix = True
  packaging_method = 'msc'
else:  # unsupported system
  platform_name = 'others'
  default_frontend = 'qt3'
  # to be safe
  default_boost_opt = 'included'
  default_gettext_opt = 'included'
  default_pch_opt = False
  default_with_x = True
  boost_posix = False
  packaging_method = 'posix'

#---------------------------------------------------------
# Handling options
#----------------------------------------------------------
# Note that if you set the options via the command line, 
# they will be remembered in the file 'options.cache'
# 
# NOTE: the scons people are trying to fix scons so that
# options like --prefix will be accepted. Right now,
# we have to use the KEY=VALUE style of scons
# 
if os.path.isfile('options.cache'):
  print "Getting options from auto-saved options.cache..."
  print open('options.cache').read()
if os.path.isfile('config.py'):
  print "Getting options from config.py..."
  print open('config.py').read()

opts = Options(['options.cache', 'config.py'])
opts.AddOptions(
  # frontend, 
  EnumOption('frontend', 'Main GUI', 
    default_frontend,
    allowed_values = ('xform', 'qt3', 'qt4', 'gtk') ),
  # debug or release build
  EnumOption('mode', 'Building method', default_build_mode,
    allowed_values = ('debug', 'release') ),
  # boost libraries
  EnumOption('boost', 
    'Use included, system boost library, or try sytem first.', 
    default_boost_opt,
    allowed_values = (
      'auto',       # detect boost, if not found, use included
      'included',   # always use included boost
      'system',     # always use system boost, fail if can not find
      ) ),
  EnumOption('gettext', 
    'Use included, system gettext library, or try sytem first', 
    default_gettext_opt,
    allowed_values = (
      'auto',       # detect gettext, if not found, use included
      'included',   # always use included gettext
      'system',     # always use system gettext, fail if can not find
      ) ),
  # FIXME: I am not allowed to use '' as default, '.' is not good either.
  PathOption('qt_dir', 'Path to qt directory', '.'),
  PathOption('qt_include_path', 'Path to qt include directory', '.'),
  PathOption('qt_lib_path', 'Path to qt library directory', '.'),
  # FIXME: I do not know how pch is working. Ignore this option now.
  BoolOption('pch', '(NA) Whether or not use pch', default_pch_opt),
  # FIXME: Not implemented yet.
  BoolOption('version_suffix', '(NA) Whether or not add version suffix', False),
  # build directory, will replace build_dir if set
  PathOption('build_dir', 'Build directory', '.'),
  # extra include and libpath
  PathOption('extra_inc_path', 'Extra include path', '.'),
  PathOption('extra_lib_path', 'Extra library path', '.'),
  PathOption('extra_inc_path1', 'Extra include path', '.'),
  PathOption('extra_lib_path1', 'Extra library path', '.'),
  # enable assertion, (config.h has  ENABLE_ASSERTIOS
  BoolOption('assertions', 'Use assertions', True),
  # enable warning, (config.h has  WITH_WARNINGS)
  BoolOption('warnings', 'Use warnings', True),
  # enable glib, (config.h has  _GLIBCXX_CONCEPT_CHECKS)
  BoolOption('concept_checks', 'Enable concept checks', True),
  # FIXME: I do not know what is nls
  BoolOption('nls', '(NA) Whether or not use native language support', False),
  # FIXME: not implemented
  BoolOption('profile', '(NA) Whether or not enable profiling', False),
  # FIXME: not implemented
  PathOption('prefix', '(NA) install architecture-independent files in PREFIX', '.'),
  # FIXME: not implemented
  PathOption('exec_prefix', '(NA) install architecture-independent executable files in PREFIX', '.'),
  # FIXME: not implemented
  BoolOption('std_debug', '(NA) Whether or not turn on stdlib debug', False),
  # using x11?
  BoolOption('X11', 'Use x11 windows system', default_with_x),
  # FIXME: not implemented
  BoolOption('libintl', '(NA) Use libintl library', False),
  # FIXME: not implemented
  PathOption('intl_prefix', '(NA) Path to intl library', '.'),
  # log file
  ('logfile', 'save commands (not outputs) to logfile', default_log_file),
  # Path to aikasurus
  PathOption('aikasurus_path', 'Path to aikasurus library', '.'),
  #
  EnumOption('spell', 'Choose spell checker to use.', 'auto',
    allowed_values = ('aspell', 'pspell', 'ispell', 'auto') ),
  # environment variable can be set as options
  ('CC', '$CC', 'gcc'),
  ('CPP', '$CPP', 'gcc -E'),
  ('CXX', '$CXX', 'g++'),
  ('CXXCPP', '$CXXCPP', 'g++ -E'),
  ('CCFLAGS', '$CCFLAGS', ''),
  ('CPPFLAGS', '$CPPFLAGS', ''),
  ('CPPPATH', '$CPPPATH', ''),
  ('LDFLAGS', '$LDFLAGS', ''),
)  

# Determine the frontend to use
frontend = ARGUMENTS.get('frontend', default_frontend)
use_X11 = ARGUMENTS.get('X11', default_with_x)

#---------------------------------------------------------
# Setting up environment
#---------------------------------------------------------

env = Environment(
  options = opts 
)

# set environment since I do not really like ENV = os.environ
env['ENV']['PATH'] = os.environ.get('PATH')
env['ENV']['HOME'] = os.environ.get('HOME')
# speed up source file processing
#env['CPPSUFFIXES'] = ['.C', '.cc', '.cpp']
#env['CXXSUFFIX'] = ['.C']

def getEnvVariable(env, name):
  # first try command line argument (override environment settings)
  if ARGUMENTS.has_key(name) and ARGUMENTS[name].strip() != '':
    env[name] = ARGUMENTS[name]
  # then try environment variable  
  elif os.environ.has_key(name) and os.environ[name].strip() != '':
    env[name] = os.environ[name]
    print "Acquiring varaible %s from system environment: %s" % (name, env[name])

getEnvVariable(env, 'CC')
getEnvVariable(env, 'CPP')
getEnvVariable(env, 'CXX')
getEnvVariable(env, 'CXXCPP')
getEnvVariable(env, 'CCFLAGS')
getEnvVariable(env, 'CXXFLAGS')
getEnvVariable(env, 'CPPFLAGS')
getEnvVariable(env, 'CPPPATH')
getEnvVariable(env, 'LDFLAGS')

env['TOP_SRC_DIR'] = Dir('.').abspath

# under windows, scons is confused by .C/.c and uses gcc instead of 
# g++. I am forcing the use of g++ here. This is expected to change
# after lyx renames all .C files to .cpp
if platform_name in ['win32', 'cygwin']:
  env['CC'] = 'g++'
  env['LINK'] = 'g++'

#
# frontend, mode, BUILDDIR and LOCALLIBPATH=BUILDDIR/libs
# 
env['frontend'] = frontend
env['mode'] = ARGUMENTS.get('mode', default_build_mode)
# lyx will be built to $build/build_dir so it is possible
# to build multiple build_dirs using the same source 
# $mode can be debug or release
if ARGUMENTS.has_key('build_dir'):
  build_dir = ARGUMENTS['build_dir']
  env['BUILDDIR'] = build_dir
else:
  # Determine the name of the build (platform+frontend
  build_dir = '%s-%s' % (platform_name, frontend)
  if use_X11 and platform_name == 'cygwin':
    build_dir += '-X11'
  env['BUILDDIR'] = os.path.join(env['mode'], build_dir)
# all built libraries will go to build_dir/libs
# (This is different from the make file approach)
env['LOCALLIBPATH'] = '#$BUILDDIR/libs'
env.AppendUnique(LIBPATH = ['$LOCALLIBPATH'])

#
# QTDIR, QT_LIB_PATH, QT_INC_PATH
#
if platform_name == 'win32':
  env.Tool('mingw')

if ARGUMENTS.has_key('qt_dir'):
  env['QTDIR'] = ARGUMENTS['qt_dir']
  # add path to the qt tools
  env.AppendUnique(LIBPATH = [os.path.join(ARGUMENTS['qt_dir'], 'lib')])
  env.AppendUnique(CPPPATH = [os.path.join(ARGUMENTS['qt_dir'], 'include')])
  # set environment so that moc etc can be found even if its path is not set properly
  env.PrependENVPath('PATH', os.path.join(ARGUMENTS['qt_dir'], 'bin'))
else:
  env['QTDIR'] = os.environ.get('QTDIR', '/usr/lib/qt-3.3')

if ARGUMENTS.has_key('qt_lib_path'):
  env['QT_LIB_PATH'] = ARGUMENTS['qt_lib_path']
else:
  env['QT_LIB_PATH'] = '$QTDIR/lib'
env.AppendUnique(LIBPATH = ['$QT_LIB_PATH'])
# qt4 seems to be using pkg_config
env.PrependENVPath('PKG_CONFIG_PATH', env.subst('$QT_LIB_PATH'))

if ARGUMENTS.has_key('qt_inc_path'):
  env['QT_INC_PATH'] = ARGUMENTS['qt_inc_path']
elif os.path.isdir(os.path.join(env.subst('$QTDIR'), 'include')):
  env['QT_INC_PATH'] = '$QTDIR/include'
else: # have to guess
  env['QT_INC_PATH'] = '/usr/include/$frontend/'
env.AppendUnique(CPPPATH = env['QT_INC_PATH'])  

#
# extra_inc_path and extra_lib_path
#
if ARGUMENTS.has_key('extra_inc_path'):
  env.AppendUnique(CPPPATH = [ARGUMENTS['extra_inc_path']])
if ARGUMENTS.has_key('extra_lib_path'):
  env.AppendUnique(LIBPATH = [ARGUMENTS['extra_lib_path']])
if ARGUMENTS.has_key('extra_inc_path1'):
  env.AppendUnique(CPPPATH = [ARGUMENTS['extra_inc_path1']])
if ARGUMENTS.has_key('extra_lib_path1'):
  env.AppendUnique(LIBPATH = [ARGUMENTS['extra_lib_path1']])
if ARGUMENTS.has_key('aikasurus_path'):
  env.AppendUnique(LIBPATH = [ARGUMENTS['aikasurus_path']])

#
# this is a bit out of place (after auto-configration)
# but it is required to do the tests.
if platform_name == 'win32':
  env.AppendUnique(CPPPATH = ['#c:/MinGW/include'])

#----------------------------------------------------------
# Autoconf business 
#----------------------------------------------------------

conf = Configure(env,
  custom_tests = {
    'CheckPkgConfig' : utils.checkPkgConfig,
    'CheckPackage' : utils.checkPackage,
    'CheckPutenv' : utils.checkPutenv,
    'CheckIstreambufIterator' : utils.checkIstreambufIterator,
    'CheckMkdirOneArg' : utils.checkMkdirOneArg,
    'CheckStdCount' : utils.checkStdCount,
    'CheckSelectArgType' : utils.checkSelectArgType,
    'CheckBoostLibraries' : utils.checkBoostLibraries,
  }
)

# pkg-config? (if not, we use hard-coded options)
if conf.CheckPkgConfig('0.15.0'):
  env['HAS_PKG_CONFIG'] = True
else:
  print 'pkg-config >= 0.1.50 is not found'
  env['HAS_PKG_CONFIG'] = False

# zlib? This is required.
if not conf.CheckLibWithHeader('z', 'zlib.h', 'C'): 
  print 'Did not find libz or zlib.h, exiting!'
  Exit(1)

# qt libraries?
#
# qt3 does not use pkg_config
if env['frontend'] == 'qt3':
  if not conf.CheckLibWithHeader('qt-mt', 'qapp.h', 'c++', 'QApplication qapp();'):
    print 'Did not find qt libraries, exiting!'
    Exit(1)
elif env['frontend'] == 'qt4':
  succ = False
  # first: try pkg_config
  if env['HAS_PKG_CONFIG']:
    succ = conf.CheckPackage('QtCore') or conf.CheckPackage('QtCore4')
    env['QT4_PKG_CONFIG'] = succ
  # second: try to link to it
  if not succ:
    # FIXME: under linux, I can test the following perfectly
    # However, under windows, lib names need to passed as libXXX4.a ...
    succ = conf.CheckLibWithHeader('QtCore', 'QtGui/QApplication', 'c++', 'QApplication qapp();') or \
      conf.CheckLibWithHeader('QtCore4', 'QtGui/QApplication', 'c++', 'QApplication qapp();')
  # third: try to look up the path
  if not succ:
    succ = True
    for lib in ['QtCore', 'QtGui', 'Qt3Support']:
      # windows version has something like QtGui4 ...
      if not (os.path.isfile(os.path.join(env.subst('$QT_LIB_PATH'), 'lib%s.a' % lib)) or \
        os.path.isfile(os.path.join(env.subst('$QT_LIB_PATH'), 'lib%s4.a' % lib))):
        succ = False
        break
  # still can not find it
  if succ:
    print "Qt4 libraries are found."
  else:
    print 'Did not find qt libraries, exiting!'
    Exit(1)

# check socket libs
env['socket_libs'] = []
if conf.CheckLib('socket'):
  env.AppendUnique(socket_libs = ['socket'])

# FIXME: What is nsl, is it related to socket?
if conf.CheckLib('nsl'):
  env.AppendUnique(socket_libs = ['nsl'])

# check boost libraries
boost_opt = ARGUMENTS.get('boost', default_boost_opt)
# check for system boost
succ = False
if boost_opt in ['auto', 'system']:
  pathes = env['LIBPATH'] + ['/usr/lib', '/usr/local/lib']
  sig = conf.CheckBoostLibraries('boost_signals', pathes)
  reg = conf.CheckBoostLibraries('boost_regex', pathes)
  fil = conf.CheckBoostLibraries('boost_filesystem', pathes)
  ios = conf.CheckBoostLibraries('boost_iostreams', pathes)
  # if any them is not found
  if ('' in [sig[0], reg[0], fil[0], ios[0]]):
    if boost_opt == 'system':
      print "Can not find system boost libraries"
      print "Please supply a path through extra_lib_path"
      print "and try again."
      Exit(2)
  else:
    env['BOOST_LIBRARIES'] = [sig[1], reg[1], fil[1], ios[1]]
    # assume all boost libraries are in the same path...
    print sig[0]
    env.AppendUnique(LIBPATH = [sig[0]])
    env['INCLUDED_BOOST'] = False
    succ = True
# now, auto and succ = false, or included
if not succ:
  # we do not need to set LIBPATH now.
  env['BOOST_LIBRARIES'] = ['boost_signals', 'boost_regex', 
    'boost_filesystem', 'boost_iostreams']
  env['INCLUDED_BOOST'] = True
  
#
# Building config.h
# 

print "Generating ", utils.config_h, "..."

# I do not handle all macros in src/config.h.in, rather I am following a list
# of *used-by-lyx* macros compiled by Abdelrazak Younes <younes.a@free.fr> 
# 
# Note: addToConfig etc are defined in scons_util
utils.startConfigH()

# HAVE_IO_H
# HAVE_LIMITS_H
# HAVE_LOCALE_H
# HAVE_LOCALE
# HAVE_PROCESS_H
# HAVE_STDLIB_H
# HAVE_SYS_STAT_H
# HAVE_SYS_TIME_H
# HAVE_SYS_TYPES_H
# HAVE_SYS_UTIME_H
# HAVE_UNISTD_H
# HAVE_UTIME_H
# HAVE_ISTREAM
# HAVE_OSTREAM
# HAVE_IOS

# Check header files
headers = [
  ('io.h', 'HAVE_IO_H', 'c'),
  ('limits.h', 'HAVE_LIMITS_H', 'c'),
  ('locale.h', 'HAVE_LOCALE_H', 'c'),
  ('locale', 'HAVE_LOCALE', 'cxx'),
  ('process.h', 'HAVE_PROCESS_H', 'c'),
  ('stdlib.h', 'HAVE_STDLIB_H', 'c'),
  ('sys/stat.h', 'HAVE_SYS_STAT_H', 'c'),
  ('sys/time.h', 'HAVE_SYS_TIME_H', 'c'),
  ('sys/types.h', 'HAVE_SYS_TYPES_H', 'c'),
  ('sys/utime.h', 'HAVE_SYS_UTIME_H', 'c'),
  ('sys/socket.h', 'HAVE_SYS_SOCKET_H', 'c'),
  ('unistd.h', 'HAVE_UNISTD_H', 'c'),
  ('utime.h', 'HAVE_UTIME_H', 'c'),
  ('istream', 'HAVE_ISTREAM', 'cxx'),
  ('ostream', 'HAVE_OSTREAM', 'cxx'),
  ('ios', 'HAVE_IOS', 'cxx')
]

for header in headers:
  if (header[2] == 'c' and conf.CheckCHeader(header[0])) or \
    (header[2] == 'cxx' and conf.CheckCXXHeader(header[0])):
    utils.addToConfig('#define %s 1' % header[1])
  else:
    utils.addToConfig('/* #undef %s */' % header[1])

# HAVE_OPEN
# HAVE_CLOSE
# HAVE_POPEN
# HAVE_PCLOSE
# HAVE__OPEN
# HAVE__CLOSE
# HAVE__POPEN
# HAVE__PCLOSE
# HAVE_GETPID
# HAVE__GETPID
# HAVE_MKDIR
# HAVE__MKDIR
# HAVE_MKTEMP
# HAVE_MKSTEMP
# HAVE_STRERROR

# Check functions
functions = [
  ('open', 'HAVE_OPEN'),
  ('close', 'HAVE_CLOSE'),
  ('popen', 'HAVE_POPEN'),
  ('pclose', 'HAVE_PCLOSE'),
  ('_open', 'HAVE__OPEN'),
  ('_close', 'HAVE__CLOSE'),
  ('_popen', 'HAVE__POPEN'),
  ('_pclose', 'HAVE__PCLOSE'),
  ('getpid', 'HAVE_GETPID'),
  ('_getpid', 'HAVE__GETPID'),
  ('mkdir', 'HAVE_MKDIR'),
  ('_mkdir', 'HAVE__MKDIR'),
  ('mktemp', 'HAVE_MKTEMP'),
  ('mkstemp', 'HAVE_MKSTEMP'),
  ('strerror', 'HAVE_STRERROR')
]

for func in functions:
  if conf.CheckFunc(func[0]):
    utils.addToConfig('#define %s 1' % func[1])
  else:
    utils.addToConfig('/* #undef %s */' % func[1])

# PACKAGE
# PACKAGE_VERSION
# DEVEL_VERSION
utils.addToConfig('#define PACKAGE "%s"' % PACKAGE)
utils.addToConfig('#define PACKAGE_VERSION "%s"' % PACKAGE_VERSION)
if DEVEL_VERSION:
  utils.addToConfig('#define DEVEL_VERSION 1')

# ENABLE_ASSERTIONS
# ENABLE_NLS
# WITH_WARNINGS
# _GLIBCXX_CONCEPT_CHECKS

# items are (ENV, ARGUMENTS)
values = [
  ('ENABLE_ASSERTIONS', 'assertions'),
  ('ENABLE_NLS', 'nls'),
  ('WITH_WARNINGS', 'warnings'),
  ('_GLIBCXX_CONCEPT_CHECKS', 'concept_checks'),
]

for val in values:
  if (env.has_key(val[0]) and env[val[0]]) or \
      ARGUMENTS.get(val[1]):
    utils.addToConfig('#define %s 1' % val[0])
  else:
    utils.addToConfig('/* #undef %s */' % val[0])


env['EXTRA_LIBS'] = []
# HAVE_LIBAIKSAURUS
# AIKSAURUS_H_LOCATION
if conf.CheckLib('Aiksaurus'):
  utils.addToConfig("#define HAVE_LIBAIKSAURUS 1")
  if (conf.CheckCXXHeader("Aiksaurus.h")):
    utils.addToConfig("#define AIKSAURUS_H_LOCATION <Aiksaurus.h>")
  elif (conf.CheckCXXHeader("Aiksaurus/Aiksaurus.h")):
    utils.addToConfig("#define AIKSAURUS_H_LOCATION <Aiksaurus/Aiksaurus.h>")
  else:
    utils.addToConfig("#define AIKSAURUS_H_LOCATION")
  env['EXTRA_LIBS'].append('Aiksaurus')

# USE_ASPELL
# USE_PSPELL
# USE_ISPELL

# determine headers to use
spell_engine = ARGUMENTS.get('spell', 'auto')
spell_detected = False
if spell_engine in ['auto', 'aspell'] and \
  conf.CheckLib('aspell'):
  utils.addToConfig('#define USE_ASPELL 1')
  env['USE_ASPELL'] = True
  env['EXTRA_LIBS'].append('aspell')
  spell_detected = True
elif spell_engine in ['auto', 'pspell'] and \
  conf.CheckLib('pspell'):
  utils.addToConfig('#define USE_PSPELL 1')
  env['USE_PSPELL'] = True
  env['EXTRA_LIBS'].append('pspell')
  spell_detected = True
elif spell_engine in ['auto', 'ispell'] and \
  conf.CheckLib('ispell'):
  utils.addToConfig('#define USE_ISPELL 1')
  env['USE_ISPELL'] = True
  env['EXTRA_LIBS'].append('ispell')
  spell_detected = True

if not spell_detected:
  # FIXME: can lyx work without an spell engine
  if spell_engine == 'auto':
    print "Warning: Can not locate any spell checker"
  else:
    print "Warning: Can not locate specified spell checker:", spell_engine

# USE_POSIX_PACKAGING
# USE_MACOSX_PACKAGING
# USE_WINDOWS_PACKAGING
if packaging_method == 'windows':
  utils.addToConfig('#define USE_WINDOWS_PACKAGING 1')
elif packaging_method == 'posix':
  utils.addToConfig('#define USE_POSIX_PACKAGING 1')
elif packaging_method == 'mac':
  utils.addToConfig('#define USE_MACOSX_PACKAGING 1')

# BOOST_POSIX
if boost_posix:
  utils.addToConfig('#define BOOST_POSIX 1')
else:
  utils.addToConfig('/* #undef BOOST_POSIX */')

# HAVE_PUTENV
if conf.CheckPutenv():
  utils.addToConfig('#define HAVE_PUTENV 1')
else:
  utils.addToConfig('/* #undef HAVE_PUTENV */')
  
# HAVE_DECL_ISTREAMBUF_ITERATOR
if conf.CheckIstreambufIterator():
  utils.addToConfig('#define HAVE_DECL_ISTREAMBUF_ITERATOR 1')
else:
  utils.addToConfig('/* #undef HAVE_DECL_ISTREAMBUF_ITERATOR */')

# MKDIR_TAKES_ONE_ARG
if conf.CheckMkdirOneArg():
  utils.addToConfig('#define MKDIR_TAKES_ONE_ARG 1')
else:
  utils.addToConfig('/* #undef MKDIR_TAKES_ONE_ARG */')

# HAVE_STD_COUNT
if conf.CheckStdCount():
  utils.addToConfig('#define HAVE_STD_COUNT 1')
else:
  utils.addToConfig('/* #undef HAVE_STD_COUNT */')

# SELECT_TYPE_ARG1
# SELECT_TYPE_ARG234
# SELECT_TYPE_ARG5
(arg1, arg234, arg5) = conf.CheckSelectArgType()
utils.addToConfig('#define SELECT_TYPE_ARG1 %s' % arg1)
utils.addToConfig('#define SELECT_TYPE_ARG234 %s' % arg234)
utils.addToConfig('#define SELECT_TYPE_ARG5 %s' % arg5)

# mkstemp
# USE_BOOST_FORMAT
# WANT_GETFILEATTRIBUTESEX_WRAPPER
utils.endConfigH()

#
# Finish auto-configuration
env = conf.Finish()

#----------------------------------------------------------
# Now set up our build process accordingly 
#----------------------------------------------------------

#
# QT_LIB etc (EXTRA_LIBS holds lib for each frontend)
#
# NOTE: Tool('qt') or Tool('qt4') will be loaded later
# in their respective directory and specialized env.
try:
  if frontend == 'qt3':
    # note: env.Tool('qt') my set QT_LIB to qt
    env['QT_LIB'] = 'qt-mt'
    env['EXTRA_LIBS'] += ['qt-mt']
    if platform_name == 'cygwin' and use_X11:
      env['EXTRA_LIBS'] += ['GL',  'Xmu', 'Xi', 'Xrender', 'Xrandr', 'Xcursor',
        'Xft', 'freetype', 'fontconfig', 'Xext', 'X11', 'SM', 'ICE', 'resolv',
        'pthread']
      env.AppendUnique(LIBPATH = ['/usr/X11R6/lib'])
  elif frontend == 'qt4':
    # local qt4 toolset from 
    # http://www.iua.upf.es/~dgarcia/Codders/sconstools.html
    if platform_name == "win32":
      env['QT_LIB'] = ['QtCore4', 'QtGui4', 'Qt3Support4']
    else:
      env['QT_LIB'] = ['QtCore', 'QtGui', 'Qt3Support']
    env['EXTRA_LIBS'] += [x for x in env['QT_LIB']]
except:
  print "Can not locate qt tools"
  print "What I get is "
  print "  QTDIR: ", env['QTDIR']

if platform_name == 'win32':
  env['SYSTEM_LIBS'] = ['shlwapi', 'zlib1']
elif platform_name == 'cygwin':
  env['SYSTEM_LIBS'] = ['shlwapi', 'z']
else:
  env['SYSTEM_LIBS'] = ['z']

#
# Build parameters CPPPATH etc
#
# boost is always in
env.AppendUnique(CPPPATH = ['#boost', '#src'])

# TODO: add (more) appropriate compiling options (-DNDEBUG etc)
# for debug/release mode 
if ARGUMENTS.get('mode', default_build_mode) == 'debug':
  env.AppendUnique(CCFLAGS = [])
else:
  env.AppendUnique(CCFLAGS = [])

#
# Customized builders
#
# install customized builders
env['BUILDERS']['substFile'] = Builder(action = utils.env_subst)
# FIXME: there must be a better way.
env['BUILDERS']['fileCopy'] = Builder(action = utils.env_filecopy)

#
# A Link script for cygwin see
# http://www.cygwin.com/ml/cygwin/2004-09/msg01101.html
# http://www.cygwin.com/ml/cygwin-apps/2004-09/msg00309.html
# for details
# 
if platform_name == 'cygwin' and env['frontend'] == 'qt3':
  ld_script_path = '/usr/lib/qt3/mkspecs/cygwin-g++'
  ld_script = utils.installCygwinLDScript(ld_script_path)
  env.AppendUnique(LINKFLAGS = ['-Wl,--enable-runtime-pseudo-reloc', 
    '-Wl,--script,%s' % ld_script, '-Wl,-s'])

#
# Report results
#
# src/support/package.C.in needs the following to replace
env['LYX_DIR'] = LYX_DIR
env['LOCALEDIR'] = LOCALEDIR
env['TOP_SRCDIR'] = str(Dir('#'))
env['PROGRAM_SUFFIX'] = PROGRAM_SUFFIX
# needed by src/version.C.in => src/version.C
env['PACKAGE_VERSION'] = PACKAGE_VERSION
# fill in the version info
env['VERSION_INFO'] = '''Configuration
  Host type:                      %s
  Special build flags:            %s
  C   Compiler:                   %s
  C   Compiler flags:             %s %s
  C++ Compiler:                   %s
  C++ Compiler LyX flags:         %s
  C++ Compiler flags:             %s %s
  Linker flags:                   %s
  Linker user flags:              %s
Build info: 
  Builing directory:              %s
  Local library directory:        %s
  Libraries pathes:               %s
  Boost libraries:                %s
  Extra libraries:                %s
  System libraries:               %s
Frontend: 
  Frontend:                       %s
  Packaging:                      %s
  LyX binary dir:                 FIXME
  LyX files dir:                  FIXME
''' % (platform_name, 
  env.subst('$CCFLAGS'), env.subst('$CC'),
  env.subst('$CPPFLAGS'), env.subst('$CFLAGS'),
  env.subst('$CXX'), env.subst('$CXXFLAGS'),
  env.subst('$CPPFLAGS'), env.subst('$CXXFLAGS'),
  env.subst('$LINKFLAGS'), env.subst('$LINKFLAGS'),
  env.subst('$BUILDDIR'), env.subst('$LOCALLIBPATH'),
  str(env['LIBPATH']), str(env['BOOST_LIBRARIES']),
  str(env['EXTRA_LIBS']), str(env['SYSTEM_LIBS']),
  env['frontend'], packaging_method)

if env['frontend'] in ['qt3', 'qt4']:
  env['VERSION_INFO'] += '''  include dir:                    %s
  library dir:                    %s
  X11:                            %s
''' % (env.subst('$QT_INC_PATH'), env.subst('$QT_LIB_PATH'), use_X11)

print env['VERSION_INFO']

#
# Mingw command line may be too short for our link usage, 
# Here we use a trick from scons wiki
# http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/LongCmdLinesOnWin32
#
# I also would like to add logging (commands only) capacity to the
# spawn system. 
logfile = ARGUMENTS.get('logfile', default_log_file)
if logfile != '' or platform_name == 'win32':
  import time
  utils.setLoggedSpawn(env, logfile, longarg = (platform_name == 'win32'),
    info = '''# This is a log of commands used by scons to build lyx
# Time: %s 
# Command: %s
# Info: %s
''' % (time.asctime(), ' '.join(sys.argv), 
  env['VERSION_INFO'].replace('\n','\n# ')) )


#
# Cleanup stuff
#
# save options
opts.Save('options.cache', env)
# -h will print out help info
Help(opts.GenerateHelpText(env))



#----------------------------------------------------------
# Start building
#----------------------------------------------------------
#Export('env')
SConsignFile(os.path.abspath('%s/sconsign' % env['BUILDDIR']))
BuildDir('#$BUILDDIR', 'src', duplicate = 0)
env.BuildDir('#$BUILDDIR', 'src', duplicate = 0)
print "Building all targets recursively"

print "Entering src/support"

env.Append(CPPPATH = ['.'])

env['SUBST_KEYS'] = ['LYX_DIR', 'LOCALEDIR', 'TOP_SRCDIR', 'PROGRAM_SUFFIX']
env.substFile('#$BUILDDIR/support/package.C', 'src/support/package.C.in')

supports = env.StaticLibrary(
  target = '$LOCALLIBPATH/supports',
  source = map(lambda a: '#$BUILDDIR/support/%s' % a, Split('''
    FileMonitor.C
    abort.C
    chdir.C
    convert.C
    copy.C
    environment.C
    filefilterlist.C
    filename.C
    filetools.C
    forkedcall.C
    forkedcallqueue.C
    forkedcontr.C
    fs_extras.C
    getcwd.C
    kill.C
    lstrings.C
    lyxtime.C
    lyxsum.C
    mkdir.C
    os.C
    path.C
    package.C
    rename.C
    socktools.C
    systemcall.C
    tempname.C
    userinfo.C
    unlink.C
  '''))
)

print "Entering src/mathed"

mathed = env.StaticLibrary(
  target = '$LOCALLIBPATH/mathed',
  source = map(lambda a: "#$BUILDDIR/mathed/%s" % a, Split('''
    textpainter.C
    math_amsarrayinset.C
    math_arrayinset.C
    math_atom.C
    math_autocorrect.C
    math_biginset.C
    math_binominset.C
    math_boldsymbolinset.C
    math_boxinset.C
    math_boxedinset.C
    math_braceinset.C
    math_casesinset.C
    math_charinset.C
    math_colorinset.C
    math_commentinset.C
    math_data.C
    math_decorationinset.C
    math_deliminset.C
    math_dfracinset.C
    math_diffinset.C
    math_diminset.C
    math_dotsinset.C
    math_envinset.C
    math_extern.C
    math_exfuncinset.C
    math_exintinset.C
    math_factory.C
    math_fboxinset.C
    math_frameboxinset.C
    math_fontinset.C
    math_fontoldinset.C
    math_fracinset.C
    math_fracbase.C
    math_gridinset.C
    math_hullinset.C
    math_inset.C
    math_kerninset.C
    math_lefteqninset.C
    math_liminset.C
    math_macro.C
    math_macroarg.C
    math_macrotemplate.C
    math_macrotable.C
    math_makeboxinset.C
    math_mathmlstream.C
    math_matrixinset.C
    math_nestinset.C
    math_numberinset.C
    math_oversetinset.C
    math_parinset.C
    math_parser.C
    math_phantominset.C
    math_rootinset.C
    math_scriptinset.C
    math_sizeinset.C
    math_spaceinset.C
    math_splitinset.C
    math_sqrtinset.C
    math_stackrelinset.C
    math_streamstr.C
    math_stringinset.C
    math_substackinset.C
    math_support.C
    math_symbolinset.C
    math_tabularinset.C
    math_tfracinset.C
    math_unknowninset.C
    math_undersetinset.C
    math_xarrowinset.C
    math_xymatrixinset.C
    command_inset.C
    ref_inset.C
  '''))
)

print "Entering src/insets"

insets = env.StaticLibrary(
  target = '$LOCALLIBPATH/insets',
  source = map(lambda a: "#$BUILDDIR/insets/%s" % a, Split('''
    mailinset.C
    ExternalSupport.C
    ExternalTemplate.C
    ExternalTransforms.C
    render_button.C
    render_graphic.C
    render_preview.C
    inset.C
    insetbase.C
    insetbibitem.C
    insetbibtex.C
    insetbox.C
    insetbranch.C
    insetcaption.C
    insetcharstyle.C
    insetcite.C
    insetcollapsable.C
    insetcommand.C
    insetcommandparams.C
    insetenv.C
    insetert.C
    insetexternal.C
    insetfloat.C
    insetfloatlist.C
    insetfoot.C
    insetfootlike.C
    insetgraphicsParams.C
    insetgraphics.C
    insethfill.C
    insetinclude.C
    insetindex.C
    insetlabel.C
    insetlatexaccent.C
    insetline.C
    insetmarginal.C
    insetnewline.C
    insetnote.C
    insetoptarg.C
    insetpagebreak.C
    insetquotes.C
    insetref.C
    insetspace.C
    insetspecialchar.C
    insettabular.C
    insettext.C
    insettoc.C
    inseturl.C
    insetvspace.C
    insetwrap.C
  '''))
)

print "Entering src/frontends"

frontends = env.StaticLibrary(
  target = '$LOCALLIBPATH/frontends',
  source = map(lambda a: "#$BUILDDIR/frontends/%s" % a, Split('''
    Alert.C
    Dialogs.C
    LyXView.C
    Painter.C
    Timeout.C
    Toolbars.C
    guiapi.C
    nullpainter.C
    screen.C
    screen.h
  '''))
)

print "Entering src/frontends/qt3"

qtenv = env.Copy()

# load qt3 tools
qtenv.Tool('qt')

qtenv.Append(CPPPATH = [
  '#$BUILDDIR',
  '#$BUILDDIR/frontends',
  '#$BUILDDIR/images',
  '#$BUILDDIR/frontends/controllers',
  '#$BUILDDIR/frontends/qt3',
  '$QT_INC_DIR',
  '.']
)

ui_files = Split('''
  BiblioModuleBase.ui
  BranchesModuleBase.ui
  BulletsModuleBase.ui
  TextLayoutModuleBase.ui
  LanguageModuleBase.ui
  LaTeXModuleBase.ui
  MarginsModuleBase.ui
  NumberingModuleBase.ui
  MathsModuleBase.ui
  PageLayoutModuleBase.ui
  PreambleModuleBase.ui
  QAboutDialogBase.ui
  QAskForTextDialog.ui
  QBibitemDialogBase.ui
  QBibtexDialogBase.ui
  QBibtexAddDialogBase.ui
  QBoxDialogBase.ui
  QBranchDialogBase.ui
  QChangesDialogBase.ui
  QCharacterDialogBase.ui
  QCitationDialogBase.ui
  QCitationFindDialogBase.ui
  QDelimiterDialogBase.ui
  QDocumentDialogBase.ui
  QErrorListDialogBase.ui
  QERTDialogBase.ui
  QExternalDialogBase.ui
  QFloatDialogBase.ui
  QGraphicsDialogBase.ui
  QIncludeDialogBase.ui
  QIndexDialogBase.ui
  QLogDialogBase.ui
  QViewSourceDialogBase.ui
  QMathDialogBase.ui
  QMathMatrixDialogBase.ui
  QNoteDialogBase.ui
  QParagraphDialogBase.ui
  QPrefAsciiModule.ui
  QPrefColorsModule.ui
  QPrefConvertersModule.ui
  QPrefCopiersModule.ui
  QPrefCygwinPathModule.ui
  QPrefDateModule.ui
  QPrefDisplayModule.ui
  QPrefFileformatsModule.ui
  QPrefIdentityModule.ui
  QPrefKeyboardModule.ui
  QPrefLanguageModule.ui
  QPrefLatexModule.ui
  QPrefPathsModule.ui
  QPrefPrinterModule.ui
  QPrefScreenFontsModule.ui
  QPrefsDialogBase.ui
  QPrefSpellcheckerModule.ui
  QPrefUIModule.ui
  QPrintDialogBase.ui
  QRefDialogBase.ui
  QSearchDialogBase.ui
  QSendtoDialogBase.ui
  QShowFileDialogBase.ui
  QSpellcheckerDialogBase.ui
  QTabularCreateDialogBase.ui
  QTabularDialogBase.ui
  QTexinfoDialogBase.ui
  QThesaurusDialogBase.ui
  QTocDialogBase.ui
  QURLDialogBase.ui
  QVSpaceDialogBase.ui
  QWrapDialogBase.ui
''')


moc_files = map(lambda a: "#$BUILDDIR/frontends/qt3/%s" % a, Split('''
  BulletsModule.C
  emptytable.C
  FileDialog_private.C
  floatplacement.C
  iconpalette.C
  lengthcombo.C
  panelstack.C
  QAboutDialog.C
  QBibitemDialog.C
  QBibtexDialog.C
  QBoxDialog.C
  QBranchDialog.C
  QBrowseBox.C
  QChangesDialog.C
  QCharacterDialog.C
  QCitationDialog.C
  QCommandBuffer.C
  QCommandEdit.C
  QContentPane.C
  QDelimiterDialog.C
  QDocumentDialog.C
  QErrorListDialog.C
  QERTDialog.C
  QExternalDialog.C
  QFloatDialog.C
  QGraphicsDialog.C
  QIncludeDialog.C
  QIndexDialog.C
  QLogDialog.C
  QViewSourceDialog.C
  QLPopupMenu.C
  QLPrintDialog.C
  QMathDialog.C
  QMathMatrixDialog.C
  QNoteDialog.C
  QParagraphDialog.C
  QPrefsDialog.C
  QRefDialog.C
  QSearchDialog.C
  QSendtoDialog.C
  qsetborder.C
  QShowFileDialog.C
  QSpellcheckerDialog.C
  QDialogView.C
  QTabularCreateDialog.C
  QTabularDialog.C
  QTexinfoDialog.C
  QThesaurusDialog.C
  QTocDialog.C
  qttableview.C
  QtView.C
  QURLDialog.C
  QVSpaceDialog.C
  QWrapDialog.C
  QLToolbar.C
  socket_callback.C
  validators.C
'''))

# under windows, because of the .C/.c confusion
# moc_files are not moced automatically.
# I am doing it manually here, until lyx changes
# file extension from .C to .cpp
moced_files = []
if os.name == 'nt' or sys.platform == 'cygwin':
  moced_files = [qtenv.Moc(x.replace('.C', '.h')) for x in moc_files]

if frontend == "qt3":
  qt3 = qtenv.StaticLibrary(
    target = '$LOCALLIBPATH/qt3',
    source = map(lambda a: "#$BUILDDIR/frontends/qt3/%s" % a, Split('''
    QDialogView.C
    Alert_pimpl.C
    Dialogs.C
    FileDialog.C
    LyXKeySymFactory.C
    LyXScreenFactory.C
    QLMenubar.C
    qtTimeout.C
    QAbout.C
    QBibitem.C
    QBibtex.C
    QBox.C
    QBranch.C
    QChanges.C
    QCharacter.C
    QCitation.C
    QDocument.C
    QErrorList.C
    QERT.C
    QExternal.C
    QFloat.C
    QGraphics.C
    QInclude.C
    QIndex.C
    QLImage.C
    QLog.C
    QViewSource.C
    QLPainter.C
    QLyXKeySym.C
    QMath.C
    QNote.C
    QParagraph.C
    QPrefs.C
    QPrint.C
    QRef.C
    QSearch.C
    QSendto.C
    QShowFile.C
    QSpellchecker.C
    QTabular.C
    QTabularCreate.C
    QTexinfo.C
    QThesaurus.C
    QToc.C
    QURL.C
    QVSpace.C
    QWorkArea.C
    QWrap.C
    Qt2BC.C
    WorkAreaFactory.C
    checkedwidgets.C
    lyx_gui.C
    lcolorcache.C
    panelstack.C
    qcoloritem.C
    qfontexample.C
    qfont_loader.C
    qfont_metrics.C
    qscreen.C
    qt_helpers.C
  ''')) +
  moc_files + moced_files +
  ['#$BUILDDIR/frontends/qt3/ui/' + x for x in ui_files]
)


print "Entering src/frontends/qt4"

qtenv = env.Copy()

# local qt4 toolset from
# http://www.iua.upf.es/~dgarcia/Codders/sconstools.html
#
# NOTE: I have to patch qt4.py since it does not automatically
# process .C file!!! (add to cxx_suffixes )
#
if frontend == 'qt4':
  qtenv.Tool('qt4', ['$TOP_SRC_DIR/config'])
  qtenv.EnableQt4Modules(env['QT_LIB'], debug = False)

qtenv.Append(CPPPATH = [
  '#$BUILDDIR',
  '#$BUILDDIR/frontends',
  '#$BUILDDIR/images',
  '#$BUILDDIR/frontends/controllers',
  '$QT_INC_PATH',
  '$QT_INC_PATH/Qt',
  '$QT_INC_PATH/QtCore',
  '$QT_INC_PATH/QtGui',
  '$QT_INC_PATH/Qt3Support',
  '.']
)

# FIXME: replace by something from pkg_config
qtenv.Append(CCFLAGS = [
  '-DHAVE_CONFIG_H',
  '-DQT_CLEAN_NAMESPACE',
  '-DQT_GENUINE_STR',
  '-DQT_NO_STL',
  '-DQT3_SUPPORT',
  '-Winvalid-pch']
)
ui_files = Split('''
  BiblioUi
  BranchesUi
  BulletsUi
  TextLayoutUi
  LanguageUi
  LaTeXUi
  MarginsUi
  NumberingUi
  MathsUi
  PageLayoutUi
  PreambleUi
  QAboutUi
  QAskForTextUi
  QBibitemUi
  QBibtexUi
  QBibtexAddUi
  QBoxUi
  QBranchUi
  QChangesUi
  QCharacterUi
  QCitationUi
  QCitationFindUi
  QDelimiterUi
  QDocumentUi
  QErrorListUi
  QERTUi
  QExternalUi
  QFloatUi
  QGraphicsUi
  QIncludeUi
  QIndexUi
  QLogUi
  QViewSourceUi
  QMathUi
  QMathMatrixUi
  QNoteUi
  QParagraphUi
  QPrefAsciiUi
  QPrefColorsUi
  QPrefConvertersUi
  QPrefCopiersUi
  QPrefCygwinPathUi
  QPrefDateUi
  QPrefDisplayUi
  QPrefFileformatsUi
  QPrefIdentityUi
  QPrefKeyboardUi
  QPrefLanguageUi
  QPrefLatexUi
  QPrefPathsUi
  QPrefPrinterUi
  QPrefScreenFontsUi
  QPrefsUi
  QPrefSpellcheckerUi
  QPrefUi
  QPrintUi
  QRefUi
  QSearchUi
  QSendtoUi
  QShowFileUi
  QSpellcheckerUi
  QTabularCreateUi
  QTabularUi
  QTexinfoUi
  QThesaurusUi
  QTocUi
  QURLUi
  QVSpaceUi
  QWrapUi
''')

moc_files = Split('''
  BulletsModule.C
  emptytable.C
  FileDialog_private.C
  floatplacement.C
  iconpalette.C
  lengthcombo.C
  panelstack.C
  QAboutDialog.C
  QBibitemDialog.C
  QBibtexDialog.C
  QBoxDialog.C
  QBranchDialog.C
  QBranches.C
  QChangesDialog.C
  QCharacterDialog.C
  QCitationDialog.C
  QCommandBuffer.C
  QCommandEdit.C
  QDelimiterDialog.C
  QDocumentDialog.C
  QErrorListDialog.C
  QERTDialog.C
  QExternalDialog.C
  QFloatDialog.C
  QGraphicsDialog.C
  QIncludeDialog.C
  QIndexDialog.C
  QLAction.C
  QLogDialog.C
  QViewSourceDialog.C
  QViewSource.C
  QLMenubar.C
  QLPopupMenu.C
  QLPrintDialog.C
  QMathDialog.C
  QMathMatrixDialog.C
  QNoteDialog.C
  QParagraphDialog.C
  QPrefsDialog.C
  QRefDialog.C
  QSearchDialog.C
  QSendtoDialog.C
  qsetborder.C
  QShowFileDialog.C
  QSpellcheckerDialog.C
  QDialogView.C
  QTabularCreateDialog.C
  QTabularDialog.C
  QTexinfoDialog.C
  QThesaurusDialog.C
  TocModel.C
  QTocDialog.C
  QtView.C
  QURLDialog.C
  QVSpaceDialog.C
  QWorkArea.C
  QWrapDialog.C
  QLToolbar.C
  socket_callback.C
  validators.C
''')

#
# Compile resources
#
if frontend == 'qt4':
  resources = [qtenv.Uic4('ui/' + x) for x in ui_files]

source_files = Split('''
  QDialogView.C
  Alert_pimpl.C
  Dialogs.C
  FileDialog.C
  LyXKeySymFactory.C
  LyXScreenFactory.C
  QLMenubar.C
  qtTimeout.C
  QAbout.C
  QBibitem.C
  QBibtex.C
  QBox.C
  QBranch.C
  QBranches.C
  QChanges.C
  QCharacter.C
  QCitation.C
  QDocument.C
  QErrorList.C
  QERT.C
  QExternal.C
  QFloat.C
  QGraphics.C
  QInclude.C
  QIndex.C
  QLAction.C
  QLImage.C
  QLog.C
  QViewSource.C
  QLPainter.C
  QLyXKeySym.C
  QMath.C
  QNote.C
  QParagraph.C
  QPrefs.C
  QPrint.C
  QRef.C
  QSearch.C
  QSendto.C
  QShowFile.C
  QSpellchecker.C
  QTabular.C
  QTabularCreate.C
  QTexinfo.C
  QThesaurus.C
  QToc.C
  QURL.C
  QVSpace.C
  QWorkArea.C
  QWrap.C
  Qt2BC.C
  WorkAreaFactory.C
  checkedwidgets.C
  lyx_gui.C
  lcolorcache.C
  panelstack.C
  qfontexample.C
  qfont_loader.C
  qfont_metrics.C
  qscreen.C
  qt_helpers.C
''')

if frontend == 'qt4':
  qt4 = qtenv.StaticLibrary(
    target = '$LOCALLIBPATH/qt4',
    LIBS = qtenv['QT_LIB'],
    source = map(lambda a: "#$BUILDDIR/frontends/qt4/%s" % a, source_files + moc_files)
   )

print "Entering src/frontends/controllers"

controllers = env.StaticLibrary(
  target = '$LOCALLIBPATH/controllers',
  source = map(lambda a: "#$BUILDDIR/frontends/controllers/%s" % a, Split('''
    Dialog.C
    Kernel.C
    biblio.C
    character.C
    frnt_lang.C
    tex_helpers.C
    BCView.C
    ButtonController.C
    ButtonPolicies.C
    ControlAboutlyx.C
    ControlBibtex.C
    ControlBox.C
    ControlBranch.C
    ControlCharacter.C
    ControlChanges.C
    ControlCitation.C
    ControlCommand.C
    ControlCommandBuffer.C
    ControlDocument.C
    ControlErrorList.C
    ControlERT.C
    ControlExternal.C
    ControlFloat.C
    ControlGraphics.C
    ControlInclude.C
    ControlLog.C
    ControlViewSource.C
    ControlMath.C
    ControlNote.C
    ControlParagraph.C
    ControlPreamble.C
    ControlPrefs.C
    ControlPrint.C
    ControlRef.C
    ControlSearch.C
    ControlSendto.C
    ControlShowFile.C
    ControlSpellchecker.C
    ControlTabular.C
    ControlTabularCreate.C
    ControlTexinfo.C
    ControlThesaurus.C
    ControlToc.C
    ControlVSpace.C
    ControlWrap.C
    helper_funcs.C
    helper_funcs.h
  '''))
)

print "Entering src/graphics"

graphics = env.StaticLibrary(
  target = '$LOCALLIBPATH/graphics',
  source = map(lambda a: "#$BUILDDIR/graphics/%s" % a, Split('''
    GraphicsCache.C
    GraphicsCacheItem.C
    GraphicsConverter.C
    GraphicsImage.C
    GraphicsLoader.C
    GraphicsParams.C
    LoaderQueue.C
    GraphicsTypes.C
    PreviewImage.C
    PreviewLoader.C
    Previews.C
  '''))
)


# INCLUDED BOOST not really supported yet.
#if env['INCLUDED_BOOST']:
#  env.SConscript(dirs = ['#boost/libs'], duplicate=0)

#
# Start in src directory
#
env['SUBST_KEYS'] = ['PACKAGE_VERSION', 'VERSION_INFO']
env.substFile('#$BUILDDIR/version.C', 'src/version.C.in')

lyx_source = Split('''
  Bidi.C
  BufferView.C
  BufferView_pimpl.C
  Bullet.C
  BranchList.C
  Chktex.C
  Color.C
  CutAndPaste.C
  DepTable.C
  FloatList.C
  Floating.C
  FontIterator.C
  FuncStatus.C
  InsetList.C
  LColor.C
  LaTeX.C
  LaTeXFeatures.C
  LyXAction.C
  MenuBackend.C
  ParagraphParameters.C
  PrinterParams.C
  Spacing.C
  Thesaurus.C
  ToolbarBackend.C
  author.C
  boost.C
  box.C
  buffer.C
  buffer_funcs.C
  bufferlist.C
  bufferparams.C
  bufferview_funcs.C
  changes.C
  chset.C
  converter.C
  counters.C
  coordcache.C
  cursor.C
  cursor_slice.C
  debug.C
  dimension.C
  dociterator.C
  encoding.C
  errorlist.C
  exporter.C
  gettext.C
  factory.C
  format.C
  funcrequest.C
  graph.C
  importer.C
  intl.C
  insetiterator.C
  kbmap.C
  kbsequence.C
  language.C
  session.C
  lengthcommon.C
  lyx_cb.C
  lyx_main.C
  lyx_sty.C
  lyxfont.C
  lyxfind.C
  lyxfunc.C
  lyxgluelength.C
  lyxlayout.C
  lyxlength.C
  lyxlex.C
  lyxlex_pimpl.C
  lyxrc.C
  lyxrow.C
  lyxrow_funcs.C
  lyxserver.C
  lyxsocket.C
  lyxtextclass.C
  lyxtextclasslist.C
  lyxvc.C
  messages.C
  metricsinfo.C
  mover.C
  output.C
  outputparams.C
  output_docbook.C
  output_latex.C
  output_linuxdoc.C
  output_plaintext.C
  paragraph.C
  paragraph_funcs.C
  paragraph_pimpl.C
  pariterator.C
  SpellBase.C
  rowpainter.C
  sgml.C
  tabular.C
  tex-accent.C
  tex-strings.C
  texrow.C
  text.C
  text2.C
  text3.C
  TocBackend.C
  toc.C
  trans.C
  trans_mgr.C
  undo.C
  vc-backend.C
  version.C
  vspace.C
  main.C
''')

if env.has_key('USE_ASPELL') and env['USE_ASPELL']:
  lyx_source += ['aspell.C']
elif env.has_key('USE_PSPELL') and env['USE_PSPELL']:
  lyx_source += ['pspell.C']
elif env.has_key('USE_ISPELL') and env['USE_ISPELL']:
  lyx_source += ['ispell.C']

#
# Build lyx with given frontend
#
lyx = env.Program(
  target = '#$BUILDDIR/lyx',
  source = map(lambda a: "#$BUILDDIR/%s" % a, lyx_source),
  LIBS = [
    'mathed',
    'insets',
    'frontends',
    env['frontend'],
    'controllers',
    'graphics',
    'supports'] +
    env['BOOST_LIBRARIES'] +
    env['EXTRA_LIBS'] +
    env['SYSTEM_LIBS']
)

print "Entering src/client"

lyxclient = env.Program(
  target = '#$BUILDDIR/client/lyxclient',
  LIBS = [ 'boost_regex', 'boost_filesystem',
    'supports' ] + env['socket_libs'],
  source = map(lambda a: "#$BUILDDIR/client/%s" % a, Split('''
    boost.C
    client.C
    debug.C
    gettext.C
    messages.C
  '''))
)

print "Entering src/tex2lyx"

tex2lyx_env = env.Copy()
# the order is important here.
tex2lyx_env.Prepend(CPPPATH = ['#$BUILDDIR/tex2lyx'])
tex2lyx_env.Append(LIBPATH = ['#$LOCALLIBPATH'])

tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/FloatList.C', 'src/FloatList.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/Floating.C', 'src/Floating.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/counters.C', 'src/counters.C')
# for some reason I do not know, I have to copy the header files as well.
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlayout.h', 'src/lyxlayout.h')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlayout.C', 'src/lyxlayout.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxtextclass.h', 'src/lyxtextclass.h')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxtextclass.C', 'src/lyxtextclass.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlex.C', 'src/lyxlex.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlex_pimpl.C', 'src/lyxlex_pimpl.C')

tex2lyx = tex2lyx_env.Program(
  target = '#$BUILDDIR/tex2lyx/tex2lyx',
  LIBS = ['supports'] + env['BOOST_LIBRARIES'] + env['SYSTEM_LIBS'],
  source = map(lambda a: "#$BUILDDIR/tex2lyx/%s" % a, Split('''
    FloatList.C
    Floating.C
    counters.C
    lyxlayout.C
    lyxtextclass.C
    lyxlex.C
    lyxlex_pimpl.C
    boost.C
    context.C
    gettext.C
    lengthcommon.C
    lyxfont.C
    texparser.C
    tex2lyx.C
    preamble.C
    math.C
    table.C
    text.C
  '''))
)


#client = env.SConscript('#$BUILDDIR/client/SConscript', duplicate = 0)
#lyx = env.SConscript('#$BUILDDIR/SConscript', duplicate=0)
#tex2lyx = env.SConscript('#$BUILDDIR/tex2lyx/SConscript', duplicate = 0)

# avoid using full path to build them
Alias('client', lyxclient)
Alias('tex2lyx', tex2lyx)
Alias('lyx', lyx)

#Default('lyx', 'tex2lyx')
#Default('lyx')

print "Building lyx done with targets", map(str, BUILD_TARGETS)