diff options
Diffstat (limited to 'lib/python2.7/site-packages/wx-3.0-msw/wx/build')
4 files changed, 1296 insertions, 0 deletions
diff --git a/lib/python2.7/site-packages/wx-3.0-msw/wx/build/__init__.py b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/__init__.py new file mode 100644 index 0000000..4bf06ac --- /dev/null +++ b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/__init__.py @@ -0,0 +1,20 @@ +# A Python package +""" +This package provides the config module, which is used by wxPython's +setup.py distutils script. It was moved here so it would be installed +with the rest of wxPython and could therefore be used by the setup.py +for other projects that needed this same info and functionality (most +likely in order to be compatible with wxPython.) + +See config.py and wxPython's setup.py for more details. + +""" + + +# Exclude config from the epydoc docs because it will currently cause +# a lot of noise. Once it has been refactored then add "config" to +# the list below. + +__all__ = [] + + diff --git a/lib/python2.7/site-packages/wx-3.0-msw/wx/build/build_options.py b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/build_options.py new file mode 100644 index 0000000..eb0e02a --- /dev/null +++ b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/build_options.py @@ -0,0 +1,10 @@ + +UNICODE=1 +UNDEF_NDEBUG=1 +INSTALL_MULTIVERSION=1 +FLAVOUR="" +EP_ADD_OPTS=1 +EP_FULL_VER=0 +WX_CONFIG="C:/msys64/mingw32/bin/wx-config --toolkit=msw --unicode=yes --version=3.0" +WXPORT="msw" +MONOLITHIC=0 diff --git a/lib/python2.7/site-packages/wx-3.0-msw/wx/build/cfg_version.py b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/cfg_version.py new file mode 100644 index 0000000..677c636 --- /dev/null +++ b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/cfg_version.py @@ -0,0 +1,8 @@ + +# wxPython version numbers used in build + +VER_MAJOR = 3 # The first three must match wxWidgets +VER_MINOR = 0 +VER_RELEASE = 2 +VER_SUBREL = 0 # wxPython release num for x.y.z release of wxWidgets +VER_FLAGS = "" # release flags, such as prerelease or RC num, etc. diff --git a/lib/python2.7/site-packages/wx-3.0-msw/wx/build/config.py b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/config.py new file mode 100644 index 0000000..08f8d6a --- /dev/null +++ b/lib/python2.7/site-packages/wx-3.0-msw/wx/build/config.py @@ -0,0 +1,1258 @@ +#---------------------------------------------------------------------- +# Name: wx.build.config +# Purpose: Most of the contents of this module used to be located +# in wxPython's setup.py script. It was moved here so +# it would be installed with the rest of wxPython and +# could therefore be used by the setup.py for other +# projects that needed this same info and functionality +# (most likely in order to be compatible with wxPython.) +# +# This split from setup.py is still fairly rough, and +# some things may still get shuffled back and forth, +# refactored, etc. Please send me any comments and +# suggestions about this. +# +# Author: Robin Dunn +# +# Created: 23-March-2004 +# RCS-ID: $Id$ +# Copyright: (c) 2004 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------- + +import sys, os, glob, fnmatch, tempfile +import subprocess +import re + +EGGing = 'bdist_egg' in sys.argv or 'egg_info' in sys.argv +if not EGGing: + from distutils.core import setup, Extension +else: + # EXPERIMENTAL Egg support... + try: + import ez_setup + ez_setup.use_setuptools() + from setuptools import setup, Extension + except ImportError: + print "Setuptools must be installed to build an egg" + sys.exit(1) + +from distutils.file_util import copy_file +from distutils.dir_util import mkpath +from distutils.dep_util import newer +from distutils.spawn import spawn + +import distutils.command.install +import distutils.command.install_data +import distutils.command.install_headers +import distutils.command.clean + +from cfg_version import * + +#---------------------------------------------------------------------- +# flags and values that affect this script +#---------------------------------------------------------------------- + +DESCRIPTION = "Cross platform GUI toolkit for Python" +AUTHOR = "Robin Dunn" +AUTHOR_EMAIL = "Robin Dunn <robin@alldunn.com>" +URL = "http://wxPython.org/" +DOWNLOAD_URL = "http://wxPython.org/download.php" +LICENSE = "wxWidgets Library License (LGPL derivative)" +PLATFORMS = "WIN32,OSX,POSIX" +KEYWORDS = "GUI,wx,wxWindows,wxWidgets,cross-platform,awesome" + +LONG_DESCRIPTION = """\ +wxPython is a GUI toolkit for Python that is a wrapper around the +wxWidgets C++ GUI library. wxPython provides a large variety of +window types and controls, all implemented with a native look and +feel (by using the native widgets) on the platforms upon which it is +supported. +""" + +CLASSIFIERS = """\ +Development Status :: 6 - Mature +Environment :: MacOS X :: Carbon +Environment :: Win32 (MS Windows) +Environment :: X11 Applications :: GTK +Intended Audience :: Developers +License :: OSI Approved +Operating System :: MacOS :: MacOS X +Operating System :: Microsoft :: Windows :: Windows 98/2000/XP/Vista +Operating System :: POSIX +Programming Language :: Python +Topic :: Software Development :: User Interfaces +""" + +## License :: OSI Approved :: wxWidgets Library Licence + + +# Config values below this point can be reset on the setup.py command line. + +BUILD_GLCANVAS = 1 # If true, build the contrib/glcanvas extension module +BUILD_STC = 1 # If true, build the contrib/stc extension module +BUILD_GIZMOS = 1 # Build a module for the gizmos contrib library +BUILD_DLLWIDGET = 0# Build a module that enables unknown wx widgets + # to be loaded from a DLL and to be used from Python. + + # Internet Explorer wrapper (experimental) +BUILD_ACTIVEX = (os.name == 'nt') + + +CORE_ONLY = 0 # if true, don't build any of the above + +PREP_ONLY = 0 # Only run the prepatory steps, not the actual build. + +USE_SWIG = 0 # Should we actually execute SWIG, or just use the + # files already in the distribution? + +SWIG = "swig" # The swig executable to use. + +BUILD_RENAMERS = 0 # Should we build the renamer modules too? + +FULL_DOCS = 0 # Some docstrings are split into a basic docstring and a + # details string. Setting this flag to 1 will + # cause the two strings to be combined and output + # as the full docstring. + +UNICODE = 1 # This will pass the 'wxUSE_UNICODE' flag to SWIG and + # will ensure that the right headers are found and the + # right libs are linked. + +UNDEF_NDEBUG = 1 # Python 2.2 on Unix/Linux by default defines NDEBUG, + # and distutils will pick this up and use it on the + # compile command-line for the extensions. This could + # conflict with how wxWidgets was built. If NDEBUG is + # set then wxWidgets' __WXDEBUG__ setting will be turned + # off. If wxWidgets was actually built with it turned + # on then you end up with mismatched class structures, + # and wxPython will crash. + +NO_SCRIPTS = 0 # Don't install the tool scripts +NO_HEADERS = 0 # Don't install the wxPython *.h and *.i files + +INSTALL_MULTIVERSION = 1 # Install the packages such that multiple versions + # can co-exist. When turned on the wx and wxPython + # pacakges will be installed in a versioned subdir + # of site-packages, and a *.pth file will be + # created that adds that dir to the sys.path. In + # addition, a wxselect.py module will be installed + # to site-pacakges that will allow applications to + # choose a specific version if more than one is + # installed. + +FLAVOUR = "" # Optional flavour string to be appended to VERSION + # in MULTIVERSION installs + +EP_ADD_OPTS = 1 # When doing MULTIVERSION installs the wx port and + # ansi/unicode settings can optionally be added to the + # subdir path used in site-packages + +EP_FULL_VER = 0 # When doing MULTIVERSION installs the default is to + # put only 2 or 3 (depending on stable/unstable) of + # the version compnonents into the "extra path" + # subdir of site-packages. Setting this option to + # 1 will cause the full 4 components of the version + # number to be used instead. + +WX_CONFIG = None # Usually you shouldn't need to touch this, but you can set + # it to pass an alternate version of wx-config or alternate + # flags, eg. as required by the .deb in-tree build. By + # default a wx-config command will be assembled based on + # version, port, etc. and it will be looked for on the + # default $PATH. + +SYS_WX_CONFIG = None # When installing an in tree build, setup.py uses wx-config + # for two different purposes. First, to determine the prefix + # where files will be installed, and secondly, to initialise + # build_options.py with the correct options for it. + # WX_CONFIG is used for the first task. SYS_WX_CONFIG may + # be set independently, to the value that should appear in + # build_options.py, if it is different to that. The default + # is to use the value of WX_CONFIG. + +WXPORT = 'gtk2' # On Linux/Unix there are several ports of wxWidgets available. + # Setting this value lets you select which will be used for + # the wxPython build. Possibilities are 'gtk', 'gtk2', + # 'gtk3', and 'x11'. Currently only gtk2, and gtk3 work. + +BUILD_BASE = "build" # Directory to use for temporary build files. + # This name will be appended to if the WXPORT or + # the UNICODE flags are set to non-standard + # values. See below. + + +CONTRIBS_INC = "" # A dir to add as an -I flag when compiling the contribs + + +# Some MSW build settings + +MONOLITHIC = 0 # The core wxWidgets lib can be built as either a + # single monolithic DLL or as a collection of DLLs. + # This flag controls which set of libs will be used + # on Windows. (For other platforms it is automatic + # via using wx-config.) + + # Version part of wxWidgets LIB/DLL names +WXDLLVER = '%d%d' % (VER_MAJOR, VER_MINOR) + + +COMPILER = 'msvc' # Used to select which compiler will be used on + # Windows. This not only affects distutils, but + # also some of the default flags and other + # assumptions in this script. Current supported + # values are 'msvc' and 'mingw32' + +WXPY_SRC = '.' # Assume we're in the source tree already, but allow the + # user to change it, particularly for extension building. + +ARCH = '' # If this is set, add an -arch XXX flag to cflags + # Only tested (and presumably, needed) for OS X universal + # binary builds created using lipo. + + +#---------------------------------------------------------------------- + +def msg(text): + if hasattr(sys, 'setup_is_main') and sys.setup_is_main: + print text + + +def opj(*args): + path = os.path.join(*args) + return os.path.normpath(path) + + +def libFlag(): + if not debug: + rv = '' + else: + rv = 'd' + if UNICODE: + rv = 'u' + rv + return rv + + +#---------------------------------------------------------------------- +# Some other globals +#---------------------------------------------------------------------- + +PKGDIR = 'wx' +wxpExtensions = [] +DATA_FILES = [] +CLEANUP = [] + +force = '--force' in sys.argv or '-f' in sys.argv +debug = '--debug' in sys.argv or '-g' in sys.argv +cleaning = 'clean' in sys.argv + + +# change the PORT default for wxMac +if sys.platform[:6] == "darwin": + WXPORT = 'osx_carbon' + +# and do the same for wxMSW, just for consistency +if os.name == 'nt': + WXPORT = 'msw' + +WXPYTHON_TYPE_TABLE = '_wxPython_table' + +#---------------------------------------------------------------------- +# Check for build flags on the command line +#---------------------------------------------------------------------- + +# Boolean (int) flags +for flag in [ 'BUILD_ACTIVEX', 'BUILD_DLLWIDGET', + 'BUILD_GIZMOS', 'BUILD_GLCANVAS', 'BUILD_STC', + 'CORE_ONLY', 'PREP_ONLY', 'USE_SWIG', 'UNICODE', + 'UNDEF_NDEBUG', 'NO_SCRIPTS', 'NO_HEADERS', 'BUILD_RENAMERS', + 'FULL_DOCS', 'INSTALL_MULTIVERSION', 'EP_ADD_OPTS', 'EP_FULL_VER', + 'MONOLITHIC', ]: + for x in range(len(sys.argv)): + if sys.argv[x].find(flag) == 0: + pos = sys.argv[x].find('=') + 1 + if pos > 0: + vars()[flag] = eval(sys.argv[x][pos:]) + sys.argv[x] = '' + +# String options +for option in ['WX_CONFIG', 'SYS_WX_CONFIG', 'WXDLLVER', 'BUILD_BASE', + 'WXPORT', 'SWIG', 'CONTRIBS_INC', 'WXPY_SRC', 'FLAVOUR', + 'VER_FLAGS', 'ARCH', 'COMPILER', + ]: + for x in range(len(sys.argv)): + if sys.argv[x].find(option) == 0: + pos = sys.argv[x].find('=') + 1 + if pos > 0: + vars()[option] = sys.argv[x][pos:] + sys.argv[x] = '' + +sys.argv = filter(None, sys.argv) + + +#---------------------------------------------------------------------- +# some helper functions +#---------------------------------------------------------------------- + +def Verify_WX_CONFIG(): + """ Called below for the builds that need wx-config, if WX_CONFIG + is not set then determines the flags needed based on build + options and searches for wx-config on the PATH. + """ + # if WX_CONFIG hasn't been set to an explicit value then construct one. + global WX_CONFIG + if WX_CONFIG is None: + WX_CONFIG='wx-config' + port = WXPORT + if port == "x11": + port = "x11univ" + flags = ' --toolkit=%s' % port + flags += ' --unicode=%s' % (UNICODE and 'yes' or 'no') + flags += ' --version=%s.%s' % (VER_MAJOR, VER_MINOR) + + searchpath = os.environ["PATH"] + for p in searchpath.split(':'): + fp = os.path.join(p, 'wx-config') + if os.path.exists(fp) and os.access(fp, os.X_OK): + # success + msg("Found wx-config: " + fp) + msg(" Using flags: " + flags) + WX_CONFIG = fp + flags + if hasattr(sys, 'setup_is_main') and not sys.setup_is_main: + WX_CONFIG += " 2>/dev/null " + break + else: + msg("ERROR: WX_CONFIG not specified and wx-config not found on the $PATH") + # should we exit? + + # TODO: execute WX_CONFIG --list and verify a matching config is found + + + +def getWxConfigValue(flag): + cmd = "%s --version=%s.%s %s" % (WX_CONFIG, VER_MAJOR, VER_MINOR, flag) + value = os.popen(cmd, 'r').read()[:-1] + return value + + +def run_swig(files, dir, gendir, package, USE_SWIG, force, swig_args, + swig_deps=[], add_under=False): + """Run SWIG the way I want it done""" + + if USE_SWIG and not os.path.exists(os.path.join(dir, gendir)): + os.mkdir(os.path.join(dir, gendir)) + + sources = [] + + if add_under: pre = '_' + else: pre = '' + + for file in files: + basefile = os.path.splitext(file)[0] + i_file = os.path.join(dir, file) + py_file = os.path.join(dir, gendir, pre+basefile+'.py') + cpp_file = os.path.join(dir, gendir, pre+basefile+'_wrap.cpp') + + if add_under: + interface = ['-interface', '_'+basefile+'_'] + else: + interface = [] + + sources.append(cpp_file) + + if not cleaning and USE_SWIG: + for dep in swig_deps: + # this may fail for external builds, but it's not + # a fatal error, so keep going. + try: + if newer(dep, py_file) or newer(dep, cpp_file): + force = 1 + break + except: + pass + + if force or newer(i_file, py_file) or newer(i_file, cpp_file): + ## we need forward slashes here, even on win32 + #cpp_file = opj(cpp_file) #'/'.join(cpp_file.split('\\')) + #i_file = opj(i_file) #'/'.join(i_file.split('\\')) + + if BUILD_RENAMERS: + xmltemp = tempfile.mktemp('.xml') + + # First run swig to produce the XML file, adding + # an extra -D that prevents the old rename + # directives from being used + cmd = [ swig_cmd ] + swig_args + \ + [ '-DBUILDING_RENAMERS', '-xmlout', xmltemp ] + \ + ['-I'+dir, '-o', cpp_file, i_file] + msg(' '.join(cmd)) + spawn(cmd) + + # Next run build_renamers to process the XML + myRenamer = BuildRenamers() + myRenamer.run(dir, pre+basefile, xmltemp) + os.remove(xmltemp) + + # Then run swig for real + cmd = [ swig_cmd ] + swig_args + interface + \ + ['-I'+dir, '-o', cpp_file, i_file] + msg(' '.join(cmd)) + spawn(cmd) + + + # copy the generated python file to the package directory + copy_file(py_file, package, update=not force, verbose=0) + CLEANUP.append(opj(package, os.path.basename(py_file))) + + return sources + + +def swig_version(): + # It may come on either stdout or stderr, depending on the + # version, so read both. + p = subprocess.Popen(SWIG + ' -version', shell=True, universal_newlines=True, + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + stext = p.stdout.read() + p.stderr.read() + import re + match = re.search(r'[0-9]+\.[0-9]+\.[0-9]+$', stext, re.MULTILINE) + if not match: + raise RuntimeError('SWIG version not found') + SVER = match.group(0) + return SVER + + +# Specializations of some distutils command classes +class wx_smart_install_data(distutils.command.install_data.install_data): + """need to change self.install_dir to the actual library dir""" + def run(self): + install_cmd = self.get_finalized_command('install') + self.install_dir = getattr(install_cmd, 'install_lib') + return distutils.command.install_data.install_data.run(self) + + +class wx_extra_clean(distutils.command.clean.clean): + """ + Also cleans stuff that this setup.py copies itself. If the + --all flag was used also searches for .pyc, .pyd, .so files + """ + def run(self): + from distutils import log + from distutils.filelist import FileList + global CLEANUP + + distutils.command.clean.clean.run(self) + + if self.all: + fl = FileList() + fl.include_pattern("*.pyc", 0) + fl.include_pattern("*.pyd", 0) + fl.include_pattern("*.so", 0) + CLEANUP += fl.files + + for f in CLEANUP: + if os.path.isdir(f): + try: + if not self.dry_run and os.path.exists(f): + os.rmdir(f) + log.info("removing '%s'", f) + except IOError: + log.warn("unable to remove '%s'", f) + + else: + try: + if not self.dry_run and os.path.exists(f): + os.remove(f) + log.info("removing '%s'", f) + except IOError: + log.warn("unable to remove '%s'", f) + + + +# The Ubuntu Python adds a --install-layout option to distutils that +# is used in our package build. If we detect that the current +# distutils does not have it then make sure that it is removed from +# the command-line options, otherwise the build will fail. +for item in distutils.command.install.install.user_options: + if item[0] == 'install-layout=': + break +else: + for arg in sys.argv: + if arg.startswith('--install-layout'): + sys.argv.remove(arg) + break + + + +class wx_install(distutils.command.install.install): + """ + Turns off install_path_file + """ + def initialize_options(self): + distutils.command.install.install.initialize_options(self) + self.install_path_file = 0 + + +class wx_install_headers(distutils.command.install_headers.install_headers): + """ + Install the header files to the WXPREFIX, with an extra dir per + filename too + """ + def initialize_options(self): + self.root = None + distutils.command.install_headers.install_headers.initialize_options(self) + + def finalize_options(self): + self.set_undefined_options('install', ('root', 'root')) + distutils.command.install_headers.install_headers.finalize_options(self) + + def run(self): + if os.name == 'nt': + return + headers = self.distribution.headers + if not headers: + return + + root = self.root + #print "WXPREFIX is %s, root is %s" % (WXPREFIX, root) + # hack for universal builds, which append i386/ppc + # to the root + if root is None or WXPREFIX.startswith(os.path.dirname(root)): + root = '' + for header, location in headers: + install_dir = os.path.normpath(root + + WXPREFIX + + '/include/wx-%d.%d/wx' % (VER_MAJOR, VER_MINOR) + + location) + self.mkpath(install_dir) + (out, _) = self.copy_file(header, install_dir) + self.outfiles.append(out) + + + +def build_locale_dir(destdir, verbose=1): + """Build a locale dir under the wxPython package for MSW""" + moFiles = glob.glob(opj(WXDIR, 'locale', '*.mo')) + for src in moFiles: + lang = os.path.splitext(os.path.basename(src))[0] + #dest = opj(destdir, lang) + dest = opj(destdir, lang, 'LC_MESSAGES') + mkpath(dest, verbose=verbose) + copy_file(src, opj(dest, 'wxstd.mo'), update=1, verbose=verbose) + CLEANUP.append(opj(dest, 'wxstd.mo')) + CLEANUP.append(dest) + + +def build_locale_list(srcdir): + # get a list of all files under the srcdir, to be used for install_data + def walk_helper(lst, dirname, files): + for f in files: + filename = opj(dirname, f) + if not os.path.isdir(filename): + lst.append( (dirname, [filename]) ) + file_list = [] + os.path.walk(srcdir, walk_helper, file_list) + return file_list + + +def find_data_files(srcdir, *wildcards, **kw): + # get a list of all files under the srcdir matching wildcards, + # returned in a format to be used for install_data + + def walk_helper(arg, dirname, files): + if '.svn' in dirname: + return + names = [] + lst, wildcards = arg + for wc in wildcards: + wc_name = opj(dirname, wc) + for f in files: + filename = opj(dirname, f) + + if fnmatch.fnmatch(filename, wc_name) and not os.path.isdir(filename): + names.append(filename) + if names: + lst.append( (dirname, names ) ) + + file_list = [] + recursive = kw.get('recursive', True) + if recursive: + os.path.walk(srcdir, walk_helper, (file_list, wildcards)) + else: + walk_helper((file_list, wildcards), + srcdir, + [os.path.basename(f) for f in glob.glob(opj(srcdir, '*'))]) + return file_list + + +def makeLibName(name): + if os.name == 'posix' or COMPILER == 'mingw32': + libname = '%s_%s-%s' % (WXBASENAME, name, WXRELEASE) + elif name: + libname = 'wxmsw%s%s_%s' % (WXDLLVER, libFlag(), name) + else: + libname = 'wxmsw%s%s' % (WXDLLVER, libFlag()) + return [libname] + + +def findLib(name, libdirs): + name = makeLibName(name)[0] + if os.name == 'posix' or COMPILER == 'mingw32': + lflags = getWxConfigValue('--libs') + lflags = lflags.split() + + # if wx-config --libs output does not start with -L, wx is + # installed with a standard prefix and wx-config does not + # output these libdirs because they are already searched by + # default by the compiler and linker. + if lflags[0][:2] != '-L': + dirs = libdirs + ['/usr/lib', '/usr/local/lib'] + else: + dirs = libdirs + name = 'lib'+name + else: + dirs = libdirs[:] + for d in dirs: + p = os.path.join(d, name) + if glob.glob(p+'*') != []: + return True + return False + + +def removeDuplicates(seq): + # This code causes problems on OS X as we do need some duplicates + # there... TODO: are there actually times when having duplicates hurts us? +## seen = {} +## result = [] +## for item in seq: +## if item in seen: +## continue +## seen[item] = 1 +## result.append(item) +## return result + return seq + + +def adjustCFLAGS(cflags, defines, includes): + '''Extract the raw -I, -D, and -U flags and put them into + defines and includes as needed.''' + newCFLAGS = [] + for flag in cflags: + if flag[:2] == '-I': + includes.append(flag[2:]) + elif flag[:2] == '-D': + flag = flag[2:] + if flag.find('=') == -1: + defines.append( (flag, None) ) + else: + defines.append( tuple(flag.split('=')) ) + elif flag[:2] == '-U': + defines.append( (flag[2:], ) ) + else: + newCFLAGS.append(flag) + return removeDuplicates(newCFLAGS) + + + +def adjustLFLAGS(lflags, libdirs, libs): + '''Extract the -L and -l flags and put them in libdirs and libs as needed''' + newLFLAGS = [] + for flag in lflags: + if flag[:2] == '-L': + libdirs.append(flag[2:]) + elif flag[:2] == '-l': + libs.append(flag[2:]) + else: + newLFLAGS.append(flag) + return removeDuplicates(newLFLAGS) + + + +def getExtraPath(shortVer=True, addOpts=False, addRelease=True): + """Get the dirname that wxPython will be installed under.""" + + if shortVer: + # short version, just Major.Minor + ep = "wx-%d.%d" % (VER_MAJOR, VER_MINOR) + + # plus release if minor is odd + if addRelease and VER_MINOR % 2 == 1: + ep += ".%d" % VER_RELEASE + + else: + # long version, full version + ep = "wx-%d.%d.%d.%d" % (VER_MAJOR, VER_MINOR, VER_RELEASE, VER_SUBREL) + + if addOpts: + port = WXPORT + if port == "msw": port = "win32" + #ep += "-%s-%s" % (WXPORT, (UNICODE and 'unicode' or 'ansi')) + # no more ansi builds, so no need to include chartype in the path any more + ep += '-' + WXPORT + + if FLAVOUR: + ep += "-" + FLAVOUR + + return ep + + +def getoutput(cmd): + sp = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + output = None + output = sp.stdout.read() + if sys.version_info > (3,): + output = output.decode('utf-8') # TODO: is utf-8 okay here? + output = output.rstrip() + rval = sp.wait() + if rval: + # Failed! + print("Command '%s' failed with exit code %d." % (cmd, rval)) + sys.exit(rval) + return output + +def getVisCVersion(): + text = getoutput("cl.exe") + if 'Version 13' in text: + return '71' + if 'Version 15' in text: + return '90' + # TODO: Add more tests to get the other versions... + else: + return 'UNKNOWN' + +#---------------------------------------------------------------------- +# These functions and class are copied from distutils in Python 2.5 +# and then grafted back into the distutils modules so we can change +# how the -arch and -isysroot compiler args are handled. Basically if +# -arch is specified in our compiler args then we need to strip all of +# the -arch and -isysroot args provided by Python. + +import distutils.unixccompiler +import distutils.sysconfig +from distutils.errors import DistutilsExecError, CompileError + +def _darwin_compiler_fixup(compiler_so, cc_args): + """ + This function will strip '-isysroot PATH' and '-arch ARCH' from the + compile flags if the user has specified one of them in extra_compile_flags. + + This is needed because '-arch ARCH' adds another architecture to the + build, without a way to remove an architecture. Furthermore GCC will + barf if multiple '-isysroot' arguments are present. + + Robin: I've further modified our copy of this function to check if there + is a -isysroot flag in the CC/CXX values in the environment. If so then we + want to make sure that we keep that one and strip the others, instead of + stripping it and leaving Python's. + """ + + ccHasSysroot = '-isysroot' in os.environ.get('CC', '') \ + or '-isysroot' in os.environ.get('CXX', '') + + stripArch = stripSysroot = 0 + + compiler_so = list(compiler_so) + kernel_version = os.uname()[2] # 8.4.3 + major_version = int(kernel_version.split('.')[0]) + + if major_version < 8: + # OSX before 10.4.0, these don't support -arch and -isysroot at + # all. + stripArch = stripSysroot = True + else: + stripArch = '-arch' in cc_args + stripSysroot = '-isysroot' in cc_args or stripArch or ccHasSysroot + + if stripArch: + while 1: + try: + index = compiler_so.index('-arch') + # Strip this argument and the next one: + del compiler_so[index:index+2] + except ValueError: + break + + if stripSysroot: + try: + index = 0 + if ccHasSysroot: + index = compiler_so.index('-isysroot') + 1 + index = compiler_so.index('-isysroot', index) + # Strip this argument and the next one: + del compiler_so[index:index+2] + except ValueError: + pass + + # Check if the SDK that is used during compilation actually exists, + # the universal build requires the usage of a universal SDK and not all + # users have that installed by default. + sysroot = None + if '-isysroot' in cc_args: + idx = cc_args.index('-isysroot') + sysroot = cc_args[idx+1] + elif '-isysroot' in compiler_so: + idx = compiler_so.index('-isysroot') + sysroot = compiler_so[idx+1] + + if sysroot and not os.path.isdir(sysroot): + from distutils import log + log.warn("Compiling with an SDK that doesn't seem to exist: %s", + sysroot) + log.warn("Please check your Xcode installation") + + return compiler_so + + +def _darwin_compiler_fixup_24(compiler_so, cc_args): + compiler_so = _darwin_compiler_fixup(compiler_so, cc_args) + return compiler_so, cc_args + + +class MyUnixCCompiler(distutils.unixccompiler.UnixCCompiler): + def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + compiler_so = self.compiler_so + if sys.platform == 'darwin': + compiler_so = _darwin_compiler_fixup(compiler_so, cc_args + extra_postargs) + # Mandriva / Mageia Hack ------------------------------------ + #self.linker_so = [el for el in self.linker_so if el != '-Wl,--no-undefined'] + #compiler_so = [el for el in compiler_so if el != '-Werror=format-security'] + # Mandriva / Mageia Hack ------------------------------------ + try: + self.spawn(compiler_so + cc_args + [src, '-o', obj] + + extra_postargs) + except DistutilsExecError, msg: + raise CompileError, msg + + +_orig_parse_makefile = distutils.sysconfig.parse_makefile +def _parse_makefile(filename, g=None): + rv = _orig_parse_makefile(filename, g) + + # If a different deployment target is specified in the + # environment then make sure it is put in the global + # config dict. + if os.getenv('MACOSX_DEPLOYMENT_TARGET'): + val = os.getenv('MACOSX_DEPLOYMENT_TARGET') + rv['MACOSX_DEPLOYMENT_TARGET'] = val + rv['CONFIGURE_MACOSX_DEPLOYMENT_TARGET'] = val + + return rv + + +distutils.unixccompiler.UnixCCompiler = MyUnixCCompiler +distutils.unixccompiler._darwin_compiler_fixup = _darwin_compiler_fixup +distutils.unixccompiler._darwin_compiler = _darwin_compiler_fixup_24 +distutils.sysconfig.parse_makefile = _parse_makefile + + +#---------------------------------------------------------------------- +# Another hack-job for the CygwinCCompiler class, this time replacing +# the _compile function with one that will pass the -I flags to windres. + +import distutils.cygwinccompiler +from distutils.errors import DistutilsExecError, CompileError + +def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): + if ext == '.rc' or ext == '.res': + # gcc needs '.res' and '.rc' compiled to object files !!! + try: + #self.spawn(["windres", "-i", src, "-o", obj]) + self.spawn(["windres", "-i", src, "-o", obj] + + [arg for arg in cc_args if arg.startswith("-I")] ) + except DistutilsExecError, msg: + raise CompileError, msg + else: # for other files use the C-compiler + try: + self.spawn(self.compiler_so + cc_args + [src, '-o', obj] + + extra_postargs) + except DistutilsExecError, msg: + raise CompileError, msg + +distutils.cygwinccompiler.CygwinCCompiler._compile = _compile + + +#---------------------------------------------------------------------- +# Yet another distutils hack, this time for the msvc9compiler. There +# is a bug in at least version distributed with Python 2.6 where it +# adds '/pdb:None' to the linker command-line, but that just results +# in a 'None' file being created instead of putting the debug info +# into the .pyd files as expected. So we'll strip out that option via +# a monkey-patch of the msvc9compiler.MSVCCompiler.initialize method. + +if os.name == 'nt' and COMPILER == 'msvc' and sys.version_info >= (2,6): + import distutils.msvc9compiler + _orig_initialize = distutils.msvc9compiler.MSVCCompiler.initialize + + def _initialize(self, *args, **kw): + rv = _orig_initialize(self, *args, **kw) + try: + self.ldflags_shared_debug.remove('/pdb:None') + except ValueError: + pass + return rv + + distutils.msvc9compiler.MSVCCompiler.initialize = _initialize + + +#---------------------------------------------------------------------- +# sanity checks + +if CORE_ONLY: + BUILD_GLCANVAS = 0 + BUILD_STC = 0 + BUILD_GIZMOS = 0 + BUILD_DLLWIDGET = 0 + BUILD_ACTIVEX = 0 + + +if UNICODE and WXPORT not in ['msw', 'gtk2', 'gtk3', 'osx_carbon', 'osx_cocoa']: + raise SystemExit, "UNICODE mode not currently supported on this WXPORT: "+WXPORT + + +if CONTRIBS_INC: + CONTRIBS_INC = [ CONTRIBS_INC ] +else: + CONTRIBS_INC = [] + +if WXPORT != 'msw': + # make sure we only use the compiler value on MSW builds + COMPILER=None + +WXPLAT2 = None + +#---------------------------------------------------------------------- +# Setup some platform specific stuff +#---------------------------------------------------------------------- + +if os.name == 'nt' and COMPILER == 'msvc': + # Set compile flags and such for MSVC. These values are derived + # from the wxWidgets makefiles for MSVC, other compilers settings + # will probably vary... + if os.environ.has_key('WXWIN'): + WXDIR = os.environ['WXWIN'] + else: + if os.path.exists('..\\wxWidgets'): + WXDIR = '..\\wxWidgets' # assumes in parallel SVN tree + else: + WXDIR = '..' # assumes wxPython is subdir + msg("WARNING: WXWIN not set in environment. Assuming '%s'" % WXDIR) + WXPLAT = '__WXMSW__' + GENDIR = 'msw' + + if os.environ.get('CPU', None) in ['AMD64', 'X64']: + VCDLL = 'vc%s_x64_dll' % getVisCVersion() + else: + VCDLL = 'vc%s_dll' % getVisCVersion() + + includes = ['include', 'src', + opj(WXDIR, 'lib', VCDLL, 'msw' + libFlag()), + opj(WXDIR, 'include'), + opj(WXDIR, 'contrib', 'include'), + ] + + defines = [ ('WIN32', None), + ('_WINDOWS', None), + + (WXPLAT, None), + ('WXUSINGDLL', '1'), + + ('SWIG_TYPE_TABLE', WXPYTHON_TYPE_TABLE), + ('SWIG_PYTHON_OUTPUT_TUPLE', None), + ('SWIG_PYTHON_SILENT_MEMLEAK', None), + ('WXP_USE_THREAD', '1'), + ('ISOLATION_AWARE_ENABLED', None), + ] + + if UNDEF_NDEBUG: + defines.append( ('NDEBUG',) ) # using a 1-tuple makes it do an undef + + if UNICODE: + defines.append( ('wxUSE_UNICODE', 1) ) + + libs = [] + libdirs = [ opj(WXDIR, 'lib', VCDLL) ] + if MONOLITHIC: + libs += makeLibName('') + else: + libs += [ 'wxbase' + WXDLLVER + libFlag(), + 'wxbase' + WXDLLVER + libFlag() + '_net', + 'wxbase' + WXDLLVER + libFlag() + '_xml', + makeLibName('core')[0], + makeLibName('adv')[0], + makeLibName('html')[0], + ] + + libs += ['kernel32', 'user32', 'gdi32', 'comdlg32', + 'winspool', 'winmm', 'shell32', 'oldnames', 'comctl32', + 'odbc32', 'ole32', 'oleaut32', 'uuid', 'rpcrt4', + 'advapi32', 'wsock32'] + + cflags = [ '/Gy', + '/EHsc', + # '/GX-' # workaround for internal compiler error in MSVC on some machines + ] + lflags = None + + # Other MSVC flags... + # Uncomment these to have debug info for all kinds of builds + #cflags += ['/Od', '/Z7'] + #lflags = ['/DEBUG', ] + + +#---------------------------------------------------------------------- + +elif os.name == 'posix' or COMPILER == 'mingw32': + if os.environ.has_key('WXWIN'): + WXDIR = os.environ['WXWIN'] + else: + if os.path.exists('../wxWidgets'): + WXDIR = '../wxWidgets' # assumes in parallel SVN tree + else: + WXDIR = '..' # assumes wxPython is subdir + msg("WARNING: WXWIN not set in environment. Assuming '%s'" % WXDIR) + includes = ['include', 'src'] + defines = [('SWIG_TYPE_TABLE', WXPYTHON_TYPE_TABLE), + ('SWIG_PYTHON_OUTPUT_TUPLE', None), + ('SWIG_PYTHON_SILENT_MEMLEAK', None), + ('WXP_USE_THREAD', '1'), + ] + if UNDEF_NDEBUG: + defines.append( ('NDEBUG',) ) # using a 1-tuple makes it do an undef + + Verify_WX_CONFIG() + + libdirs = [] + libs = [] + + # If you get unresolved symbol errors on Solaris and are using gcc, then + # uncomment this block to add the right flags to the link step and build + # again. + ## if os.uname()[0] == 'SunOS': + ## import commands + ## libs.append('gcc') + ## libdirs.append(commands.getoutput("gcc -print-search-dirs | grep '^install' | awk '{print $2}'")[:-1]) + + cflags = getWxConfigValue('--cxxflags') + cflags = cflags.split() + if debug: + cflags.append('-ggdb') + cflags.append('-O0') + else: + cflags.append('-O3') + + lflags = getWxConfigValue('--libs') + MONOLITHIC = (lflags.find("_xrc") == -1) + lflags = lflags.split() + + WXBASENAME = getWxConfigValue('--basename') + WXRELEASE = getWxConfigValue('--release') + WXPREFIX = getWxConfigValue('--prefix') + + + if sys.platform[:6] == "darwin": + WXPLAT = '__WXMAC__' + + if WXPORT == 'osx_carbon': + # Flags and such for a Darwin (Max OS X) build of Python + GENDIR = 'osx_carbon' + WXPLAT2 = '__WXOSX_CARBON__' + else: + GENDIR = 'osx_cocoa' + WXPLAT2 = '__WXOSX_COCOA__' + + libs = ['stdc++'] + NO_SCRIPTS = 1 + if ARCH != "": + splitArch = "-arch " + re.sub(","," -arch ",ARCH) + cflags.extend(splitArch.split(' ')) + lflags.extend(splitArch.split(' ')) + + if not os.environ.get('CC') or not os.environ.get('CXX'): + os.environ["CXX"] = getWxConfigValue('--cxx') + os.environ["CC"] = getWxConfigValue('--cc') + + # We want to use the linker command from wx to make sure + # we get the right sysroot, but we also need to ensure that + # the other linker flags that distutils wants to use are + # included as well. + LDSHARED = distutils.sysconfig.get_config_var('LDSHARED').split() + # remove the compiler command + del LDSHARED[0] + # remove any -sysroot flags and their arg + while 1: + try: + index = LDSHARED.index('-isysroot') + # Strip this argument and the next one: + del LDSHARED[index:index+2] + except ValueError: + break + LDSHARED = ' '.join(LDSHARED) + # Combine with wx's ld command and stash it in the env + # where distutils will get it later. + LDSHARED = getWxConfigValue('--ld').replace(' -o', '') + ' ' + LDSHARED + os.environ["LDSHARED"] = LDSHARED + + else: + # Set flags for other Unix type platforms + GENDIR = WXPORT + + if WXPORT == 'gtk': + WXPLAT = '__WXGTK__' + portcfg = os.popen('gtk-config --cflags', 'r').read()[:-1] + BUILD_BASE = BUILD_BASE + '-' + WXPORT + elif WXPORT == 'gtk2': + WXPLAT = '__WXGTK__' + GENDIR = 'gtk' # no code differences so use the same generated sources + portcfg = os.popen('pkg-config gtk+-2.0 --cflags', 'r').read()[:-1] + elif WXPORT == 'gtk3': + WXPLAT = '__WXGTK__' + GENDIR = 'gtk' # no code differences so use the same generated sources + portcfg = os.popen('pkg-config gtk+-3.0 --cflags', 'r').read()[:-1] + elif WXPORT == 'x11': + WXPLAT = '__WXX11__' + portcfg = '' + BUILD_BASE = BUILD_BASE + '-' + WXPORT + elif WXPORT == 'msw': + WXPLAT = '__WXMSW__' + GENDIR = 'msw' + portcfg = '' + else: + raise SystemExit, "Unknown WXPORT value: " + WXPORT + + cflags += portcfg.split() + + # Some distros (e.g. Mandrake) put libGLU in /usr/X11R6/lib, but + # wx-config doesn't output that for some reason. For now, just + # add it unconditionally but we should really check if the lib is + # really found there or wx-config should be fixed. + if WXPORT != 'msw': + libdirs.append("/usr/X11R6/lib") + + + # Move the various -I, -D, etc. flags we got from the *config scripts + # into the distutils lists. + cflags = adjustCFLAGS(cflags, defines, includes) + lflags = adjustLFLAGS(lflags, libdirs, libs) + + if debug and WXPORT == 'msw' and COMPILER != 'mingw32': + defines.append( ('_DEBUG', None) ) + +## from pprint import pprint +## print 'cflags:',; pprint(cflags) +## print 'defines:',; pprint(defines) +## print 'includes:',; pprint(includes) +## print +## print 'lflags:',; pprint(lflags) +## print 'libdirs:',; pprint(libdirs) +## print 'libs:',; pprint(libs) +## print +## sys.exit() + +#---------------------------------------------------------------------- +else: + raise Exception('Sorry, platform not supported...') + + +#---------------------------------------------------------------------- +# build options file +#---------------------------------------------------------------------- + +if SYS_WX_CONFIG is None: + SYS_WX_CONFIG = WX_CONFIG + +build_options_template = """ +UNICODE=%d +UNDEF_NDEBUG=%d +INSTALL_MULTIVERSION=%d +FLAVOUR="%s" +EP_ADD_OPTS=%d +EP_FULL_VER=%d +WX_CONFIG="%s" +WXPORT="%s" +MONOLITHIC=%d +""" % (UNICODE, UNDEF_NDEBUG, INSTALL_MULTIVERSION, FLAVOUR, EP_ADD_OPTS, + EP_FULL_VER, SYS_WX_CONFIG, WXPORT, MONOLITHIC) + +try: + from build_options import * +except: + build_options_file = os.path.join(os.path.dirname(__file__), "build_options.py") + if not os.path.exists(build_options_file): + try: + myfile = open(build_options_file, "w") + myfile.write(build_options_template) + myfile.close() + except: + print "WARNING: Unable to create build_options.py." + + +#---------------------------------------------------------------------- +# post platform setup checks and tweaks, create the full version string +#---------------------------------------------------------------------- + +if os.path.exists('DAILY_BUILD'): + VER_FLAGS += '.b' + open('DAILY_BUILD').read().strip() + +VERSION = "%s.%s.%s.%s%s" % (VER_MAJOR, VER_MINOR, VER_RELEASE, + VER_SUBREL, VER_FLAGS) + + +#---------------------------------------------------------------------- +# SWIG defaults +#---------------------------------------------------------------------- + +# *.i files could live in the wxWidgets/wxPython/src dir, or in +# a subdirectory of the devel package. Let's specify both +# dirs as includes so we don't have to guess which is correct. + +wxfilesdir = "" +i_subdir = opj("include", getExtraPath(addRelease=False), "wx", "wxPython", "i_files") +if os.name != "nt": + wxfilesdir = opj(WXPREFIX, i_subdir) +else: + wxfilesdir = opj(WXPY_SRC, i_subdir) + +i_files_includes = [ '-I' + opj(WXPY_SRC, 'src'), + '-I' + wxfilesdir ] + +swig_cmd = SWIG +swig_force = force +swig_args = ['-c++', + #'-Wall', + '-python', + '-new_repr', + '-modern', + '-D'+WXPLAT, + ] +if WXPLAT2: + swig_args.append('-D' + WXPLAT2) + +swig_args += i_files_includes + +if USE_SWIG: + SVER = swig_version() + if int(SVER[-2:]) >= 29: + swig_args += [ '-fastdispatch', + '-fvirtual', + '-fastinit', + '-fastunpack', + #'-outputtuple', Currently setting this with a -D define above + ] + +if UNICODE: + swig_args.append('-DwxUSE_UNICODE') + +if FULL_DOCS: + swig_args.append('-D_DO_FULL_DOCS') + + +swig_deps = [ opj(WXPY_SRC, 'src/my_typemaps.i'), + opj(WXPY_SRC, 'src/pyfragments.swg'), + ] + +depends = [ #'include/wx/wxPython/wxPython.h', + #'include/wx/wxPython/wxPython_int.h', + #'src/pyclasses.h', + ] + +#---------------------------------------------------------------------- + |