wxPython/config.py

   1 #----------------------------------------------------------------------
   2 # Name:        wx.build.config
   3 # Purpose:     Most of the contents of this module used to be located
   4 #              in wxPython's setup.py script.  It was moved here so
   5 #              it would be installed with the rest of wxPython and
   6 #              could therefore be used by the setup.py for other
   7 #              projects that needed this same info and functionality
   8 #              (most likely in order to be compatible with wxPython.)
   9 #
  10 #              This split from setup.py is still fairly rough, and
  11 #              some things may still get shuffled back and forth,
  12 #              refactored, etc.  Please send me any comments and
  13 #              suggestions about this.
  14 #
  15 # Author:      Robin Dunn
  16 #
  17 # Created:     23-March-2004
  18 # RCS-ID:      $Id$
  19 # Copyright:   (c) 2004 by Total Control Software
  20 # Licence:     wxWindows license
  21 #----------------------------------------------------------------------
  22
  23 import sys, os, glob, fnmatch, tempfile
  24 from distutils.core      import setup, Extension
  25 from distutils.file_util import copy_file
  26 from distutils.dir_util  import mkpath
  27 from distutils.dep_util  import newer
  28 from distutils.spawn     import spawn
  29
  30 import distutils.command.install
  31 import distutils.command.install_data
  32 import distutils.command.install_headers
  33 import distutils.command.clean
  34
  35 #----------------------------------------------------------------------
  36 # flags and values that affect this script
  37 #----------------------------------------------------------------------
  38
  39 VER_MAJOR        = 2      # The first three must match wxWidgets
  40 VER_MINOR        = 8
  41 VER_RELEASE      = 0
  42 VER_SUBREL       = 1      # wxPython release num for x.y.z release of wxWidgets
  43 VER_FLAGS        = ""  # release flags, such as prerelease or RC num, etc.
  44
  45 DESCRIPTION      = "Cross platform GUI toolkit for Python"
  46 AUTHOR           = "Robin Dunn"
  47 AUTHOR_EMAIL     = "Robin Dunn <robin@alldunn.com>"
  48 URL              = "http://wxPython.org/"
  49 DOWNLOAD_URL     = "http://wxPython.org/download.php"
  50 LICENSE          = "wxWidgets Library License (LGPL derivative)"
  51 PLATFORMS        = "WIN32,OSX,POSIX"
  52 KEYWORDS         = "GUI,wx,wxWindows,wxWidgets,cross-platform"
  53
  54 LONG_DESCRIPTION = """\
  55 wxPython is a GUI toolkit for Python that is a wrapper around the
  56 wxWidgets C++ GUI library.  wxPython provides a large variety of
  57 window types and controls, all implemented with a native look and
  58 feel (by using the native widgets) on the platforms upon which it is
  59 supported.
  60 """
  61
  62 CLASSIFIERS      = """\
  63 Development Status :: 6 - Mature
  64 Environment :: MacOS X :: Carbon
  65 Environment :: Win32 (MS Windows)
  66 Environment :: X11 Applications :: GTK
  67 Intended Audience :: Developers
  68 License :: OSI Approved
  69 Operating System :: MacOS :: MacOS X
  70 Operating System :: Microsoft :: Windows :: Windows 95/98/2000
  71 Operating System :: POSIX
  72 Programming Language :: Python
  73 Topic :: Software Development :: User Interfaces
  74 """
  75
  76 ## License :: OSI Approved :: wxWidgets Library Licence
  77
  78
  79 # Config values below this point can be reset on the setup.py command line.
  80
  81 BUILD_GLCANVAS = 1 # If true, build the contrib/glcanvas extension module
  82 BUILD_OGL = 0      # If true, build the contrib/ogl extension module
  83 BUILD_STC = 1      # If true, build the contrib/stc extension module
  84 BUILD_GIZMOS = 1   # Build a module for the gizmos contrib library
  85 BUILD_DLLWIDGET = 0# Build a module that enables unknown wx widgets
  86                    # to be loaded from a DLL and to be used from Python.
  87
  88                    # Internet Explorer wrapper (experimental)
  89 BUILD_ACTIVEX = (os.name == 'nt')  # new version of IEWIN and more
  90
  91
  92 CORE_ONLY = 0      # if true, don't build any of the above
  93
  94 PREP_ONLY = 0      # Only run the prepatory steps, not the actual build.
  95
  96 USE_SWIG = 0       # Should we actually execute SWIG, or just use the
  97                    # files already in the distribution?
  98
  99 SWIG = "swig"      # The swig executable to use.
 100
 101 BUILD_RENAMERS = 0 # Should we build the renamer modules too?
 102
 103 FULL_DOCS = 0      # Some docstrings are split into a basic docstring and a
 104                    # details string.  Setting this flag to 1 will
 105                    # cause the two strings to be combined and output
 106                    # as the full docstring.
 107
 108 UNICODE = 0        # This will pass the 'wxUSE_UNICODE' flag to SWIG and
 109                    # will ensure that the right headers are found and the
 110                    # right libs are linked.
 111
 112 UNDEF_NDEBUG = 1   # Python 2.2 on Unix/Linux by default defines NDEBUG,
 113                    # and distutils will pick this up and use it on the
 114                    # compile command-line for the extensions.  This could
 115                    # conflict with how wxWidgets was built.  If NDEBUG is
 116                    # set then wxWidgets' __WXDEBUG__ setting will be turned
 117                    # off.  If wxWidgets was actually built with it turned
 118                    # on then you end up with mismatched class structures,
 119                    # and wxPython will crash.
 120
 121 NO_SCRIPTS = 0     # Don't install the tool scripts
 122 NO_HEADERS = 0     # Don't install the wxPython *.h and *.i files
 123
 124 INSTALL_MULTIVERSION = 1 # Install the packages such that multiple versions
 125                    # can co-exist.  When turned on the wx and wxPython
 126                    # pacakges will be installed in a versioned subdir
 127                    # of site-packages, and a *.pth file will be
 128                    # created that adds that dir to the sys.path.  In
 129                    # addition, a wxselect.py module will be installed
 130                    # to site-pacakges that will allow applications to
 131                    # choose a specific version if more than one is
 132                    # installed.
 133
 134 FLAVOUR = ""       # Optional flavour string to be appended to VERSION
 135                    # in MULTIVERSION installs
 136
 137 EP_ADD_OPTS = 1    # When doing MULTIVERSION installs the wx port and
 138                    # ansi/unicode settings can optionally be added to the
 139                    # subdir path used in site-packages
 140
 141 EP_FULL_VER = 0    # When doing MULTIVERSION installs the default is to
 142                    # put only 2 or 3 (depending on stable/unstable) of
 143                    # the version compnonents into the "extra path"
 144                    # subdir of site-packages.  Setting this option to
 145                    # 1 will cause the full 4 components of the version
 146                    # number to be used instead.
 147
 148 WX_CONFIG = None   # Usually you shouldn't need to touch this, but you can set
 149                    # it to pass an alternate version of wx-config or alternate
 150                    # flags, eg. as required by the .deb in-tree build.  By
 151                    # default a wx-config command will be assembled based on
 152                    # version, port, etc. and it will be looked for on the
 153                    # default $PATH.
 154
 155 SYS_WX_CONFIG = None # When installing an in tree build, setup.py uses wx-config
 156                      # for two different purposes.  First, to determine the prefix
 157                      # where files will be installed, and secondly, to initialise
 158                      # build_options.py with the correct options for it.
 159                      # WX_CONFIG is used for the first task.  SYS_WX_CONFIG may
 160                      # be set independently, to the value that should appear in
 161                      # build_options.py, if it is different to that.  The default
 162                      # is to use the value of WX_CONFIG.
 163
 164 WXPORT = 'gtk2'    # On Linux/Unix there are several ports of wxWidgets available.
 165                    # Setting this value lets you select which will be used for
 166                    # the wxPython build.  Possibilites are 'gtk', 'gtk2' and
 167                    # 'x11'.  Curently only gtk and gtk2 works.
 168
 169 BUILD_BASE = "build" # Directory to use for temporary build files.
 170                      # This name will be appended to if the WXPORT or
 171                      # the UNICODE flags are set to non-standard
 172                      # values.  See below.
 173
 174
 175 CONTRIBS_INC = ""  # A dir to add as an -I flag when compiling the contribs
 176
 177
 178 # Some MSW build settings
 179
 180 MONOLITHIC = 0     # The core wxWidgets lib can be built as either a
 181                    # single monolithic DLL or as a collection of DLLs.
 182                    # This flag controls which set of libs will be used
 183                    # on Windows.  (For other platforms it is automatic
 184                    # via using wx-config.)
 185
 186 FINAL = 0          # Will use the release version of the wxWidgets libs on MSW.
 187
 188 HYBRID = 1         # Will use the "hybrid" version of the wxWidgets
 189                    # libs on MSW.  A "hybrid" build is one that is
 190                    # basically a release build, but that also defines
 191                    # __WXDEBUG__ to activate the runtime checks and
 192                    # assertions in the library.  When any of these is
 193                    # triggered it is turned into a Python exception so
 194                    # this is a very useful feature to have turned on.
 195
 196
 197                    # Version part of wxWidgets LIB/DLL names
 198 WXDLLVER = '%d%d' % (VER_MAJOR, VER_MINOR)
 199
 200 WXPY_SRC = '.'  # Assume we're in the source tree already, but allow the
 201                 # user to change it, particularly for extension building.
 202
 203
 204 #----------------------------------------------------------------------
 205
 206 def msg(text):
 207     if hasattr(sys, 'setup_is_main') and sys.setup_is_main:
 208         print text
 209
 210
 211 def opj(*args):
 212     path = os.path.join(*args)
 213     return os.path.normpath(path)
 214
 215
 216 def libFlag():
 217     if FINAL:
 218         rv = ''
 219     elif HYBRID:
 220         rv = 'h'
 221     else:
 222         rv = 'd'
 223     if UNICODE:
 224         rv = 'u' + rv
 225     return rv
 226
 227
 228 #----------------------------------------------------------------------
 229 # Some other globals
 230 #----------------------------------------------------------------------
 231
 232 PKGDIR = 'wx'
 233 wxpExtensions = []
 234 DATA_FILES = []
 235 CLEANUP = []
 236
 237 force = '--force' in sys.argv or '-f' in sys.argv
 238 debug = '--debug' in sys.argv or '-g' in sys.argv
 239 cleaning = 'clean' in sys.argv
 240
 241
 242 # change the PORT default for wxMac
 243 if sys.platform[:6] == "darwin":
 244     WXPORT = 'mac'
 245
 246 # and do the same for wxMSW, just for consistency
 247 if os.name == 'nt':
 248     WXPORT = 'msw'
 249
 250 WXPYTHON_TYPE_TABLE = '_wxPython_table'
 251
 252 #----------------------------------------------------------------------
 253 # Check for build flags on the command line
 254 #----------------------------------------------------------------------
 255
 256 # Boolean (int) flags
 257 for flag in [ 'BUILD_ACTIVEX', 'BUILD_DLLWIDGET',
 258               'BUILD_GIZMOS', 'BUILD_GLCANVAS',
 259               'BUILD_OGL', 'BUILD_STC',
 260              'CORE_ONLY', 'PREP_ONLY', 'USE_SWIG', 'UNICODE',
 261              'UNDEF_NDEBUG', 'NO_SCRIPTS', 'NO_HEADERS', 'BUILD_RENAMERS',
 262              'FULL_DOCS', 'INSTALL_MULTIVERSION', 'EP_ADD_OPTS', 'EP_FULL_VER',
 263              'MONOLITHIC', 'FINAL', 'HYBRID', ]:
 264     for x in range(len(sys.argv)):
 265         if sys.argv[x].find(flag) == 0:
 266             pos = sys.argv[x].find('=') + 1
 267             if pos > 0:
 268                 vars()[flag] = eval(sys.argv[x][pos:])
 269                 sys.argv[x] = ''
 270
 271 # String options
 272 for option in ['WX_CONFIG', 'SYS_WX_CONFIG', 'WXDLLVER', 'BUILD_BASE',
 273                'WXPORT', 'SWIG', 'CONTRIBS_INC', 'WXPY_SRC', 'FLAVOUR',
 274                'VER_FLAGS',
 275                ]:
 276     for x in range(len(sys.argv)):
 277         if sys.argv[x].find(option) == 0:
 278             pos = sys.argv[x].find('=') + 1
 279             if pos > 0:
 280                 vars()[option] = sys.argv[x][pos:]
 281                 sys.argv[x] = ''
 282
 283 sys.argv = filter(None, sys.argv)
 284
 285
 286 #----------------------------------------------------------------------
 287 # some helper functions
 288 #----------------------------------------------------------------------
 289
 290 def Verify_WX_CONFIG():
 291     """ Called below for the builds that need wx-config, if WX_CONFIG
 292         is not set then determines the flags needed based on build
 293         options and searches for wx-config on the PATH.
 294     """
 295     # if WX_CONFIG hasn't been set to an explicit value then construct one.
 296     global WX_CONFIG
 297     if WX_CONFIG is None:
 298         WX_CONFIG='wx-config'
 299         port = WXPORT
 300         if port == "x11":
 301             port = "x11univ"
 302         flags =  ' --toolkit=%s' % port
 303         flags += ' --unicode=%s' % (UNICODE and 'yes' or 'no')
 304         flags += ' --version=%s.%s' % (VER_MAJOR, VER_MINOR)
 305
 306         searchpath = os.environ["PATH"]
 307         for p in searchpath.split(':'):
 308             fp = os.path.join(p, 'wx-config')
 309             if os.path.exists(fp) and os.access(fp, os.X_OK):
 310                 # success
 311                 msg("Found wx-config: " + fp)
 312                 msg("    Using flags: " + flags)
 313                 WX_CONFIG = fp + flags
 314                 if hasattr(sys, 'setup_is_main') and not sys.setup_is_main:
 315                     WX_CONFIG += " 2>/dev/null "
 316                 break
 317         else:
 318             msg("ERROR: WX_CONFIG not specified and wx-config not found on the $PATH")
 319             # should we exit?
 320
 321         # TODO:  execute WX_CONFIG --list and verify a matching config is found
 322
 323
 324 def run_swig(files, dir, gendir, package, USE_SWIG, force, swig_args,
 325              swig_deps=[], add_under=False):
 326     """Run SWIG the way I want it done"""
 327
 328     if USE_SWIG and not os.path.exists(os.path.join(dir, gendir)):
 329         os.mkdir(os.path.join(dir, gendir))
 330
 331     sources = []
 332
 333     if add_under:  pre = '_'
 334     else:          pre = ''
 335
 336     for file in files:
 337         basefile = os.path.splitext(file)[0]
 338         i_file   = os.path.join(dir, file)
 339         py_file  = os.path.join(dir, gendir, pre+basefile+'.py')
 340         cpp_file = os.path.join(dir, gendir, pre+basefile+'_wrap.cpp')
 341
 342         if add_under:
 343             interface = ['-interface', '_'+basefile+'_']
 344         else:
 345             interface = []
 346
 347         sources.append(cpp_file)
 348
 349         if not cleaning and USE_SWIG:
 350             for dep in swig_deps:
 351                 # this may fail for external builds, but it's not
 352                 # a fatal error, so keep going.
 353                 try:
 354                     if newer(dep, py_file) or newer(dep, cpp_file):
 355                         force = 1
 356                         break
 357                 except:
 358                     pass
 359
 360             if force or newer(i_file, py_file) or newer(i_file, cpp_file):
 361                 ## we need forward slashes here, even on win32
 362                 #cpp_file = opj(cpp_file) #'/'.join(cpp_file.split('\\'))
 363                 #i_file = opj(i_file)     #'/'.join(i_file.split('\\'))
 364
 365                 if BUILD_RENAMERS:
 366                     xmltemp = tempfile.mktemp('.xml')
 367
 368                     # First run swig to produce the XML file, adding
 369                     # an extra -D that prevents the old rename
 370                     # directives from being used
 371                     cmd = [ swig_cmd ] + swig_args + \
 372                           [ '-DBUILDING_RENAMERS', '-xmlout', xmltemp ] + \
 373                           ['-I'+dir, '-o', cpp_file, i_file]
 374                     msg(' '.join(cmd))
 375                     spawn(cmd)
 376
 377                     # Next run build_renamers to process the XML
 378                     myRenamer = BuildRenamers()
 379                     myRenamer.run(dir, pre+basefile, xmltemp)
 380                     os.remove(xmltemp)
 381
 382                 # Then run swig for real
 383                 cmd = [ swig_cmd ] + swig_args + interface + \
 384                       ['-I'+dir, '-o', cpp_file, i_file]
 385                 msg(' '.join(cmd))
 386                 spawn(cmd)
 387
 388
 389         # copy the generated python file to the package directory
 390         copy_file(py_file, package, update=not force, verbose=0)
 391         CLEANUP.append(opj(package, os.path.basename(py_file)))
 392
 393     return sources
 394
 395
 396 def swig_version():
 397     # It may come on either stdout or stderr, depending on the
 398     # version, so read both.
 399     i, o, e = os.popen3(SWIG + ' -version', 't')
 400     stext = o.read() + e.read()
 401     import re
 402     match = re.search(r'[0-9]+\.[0-9]+\.[0-9]+$', stext, re.MULTILINE)
 403     if not match:
 404         raise 'NotFound'
 405     SVER = match.group(0)
 406     return SVER
 407
 408
 409 # Specializations of some distutils command classes
 410 class wx_smart_install_data(distutils.command.install_data.install_data):
 411     """need to change self.install_dir to the actual library dir"""
 412     def run(self):
 413         install_cmd = self.get_finalized_command('install')
 414         self.install_dir = getattr(install_cmd, 'install_lib')
 415         return distutils.command.install_data.install_data.run(self)
 416
 417
 418 class wx_extra_clean(distutils.command.clean.clean):
 419     """
 420     Also cleans stuff that this setup.py copies itself.  If the
 421     --all flag was used also searches for .pyc, .pyd, .so files
 422     """
 423     def run(self):
 424         from distutils import log
 425         from distutils.filelist import FileList
 426         global CLEANUP
 427
 428         distutils.command.clean.clean.run(self)
 429
 430         if self.all:
 431             fl = FileList()
 432             fl.include_pattern("*.pyc", 0)
 433             fl.include_pattern("*.pyd", 0)
 434             fl.include_pattern("*.so", 0)
 435             CLEANUP += fl.files
 436
 437         for f in CLEANUP:
 438             if os.path.isdir(f):
 439                 try:
 440                     if not self.dry_run and os.path.exists(f):
 441                         os.rmdir(f)
 442                     log.info("removing '%s'", f)
 443                 except IOError:
 444                     log.warning("unable to remove '%s'", f)
 445
 446             else:
 447                 try:
 448                     if not self.dry_run and os.path.exists(f):
 449                         os.remove(f)
 450                     log.info("removing '%s'", f)
 451                 except IOError:
 452                     log.warning("unable to remove '%s'", f)
 453
 454
 455
 456 class wx_install(distutils.command.install.install):
 457     """
 458     Turns off install_path_file
 459     """
 460     def initialize_options(self):
 461         distutils.command.install.install.initialize_options(self)
 462         self.install_path_file = 0
 463
 464
 465 class wx_install_headers(distutils.command.install_headers.install_headers):
 466     """
 467     Install the header files to the WXPREFIX, with an extra dir per
 468     filename too
 469     """
 470     def initialize_options(self):
 471         self.root = None
 472         distutils.command.install_headers.install_headers.initialize_options(self)
 473
 474     def finalize_options(self):
 475         self.set_undefined_options('install', ('root', 'root'))
 476         distutils.command.install_headers.install_headers.finalize_options(self)
 477
 478     def run(self):
 479         if os.name == 'nt':
 480             return
 481         headers = self.distribution.headers
 482         if not headers:
 483             return
 484
 485         root = self.root
 486         if root is None or WXPREFIX.startswith(root):
 487             root = ''
 488         for header, location in headers:
 489             install_dir = os.path.normpath(root +
 490                                            WXPREFIX +
 491                                            '/include/wx-%d.%d/wx' % (VER_MAJOR, VER_MINOR) +
 492                                            location)
 493             self.mkpath(install_dir)
 494             (out, _) = self.copy_file(header, install_dir)
 495             self.outfiles.append(out)
 496
 497
 498
 499
 500 def build_locale_dir(destdir, verbose=1):
 501     """Build a locale dir under the wxPython package for MSW"""
 502     moFiles = glob.glob(opj(WXDIR, 'locale', '*.mo'))
 503     for src in moFiles:
 504         lang = os.path.splitext(os.path.basename(src))[0]
 505         #dest = opj(destdir, lang)
 506         dest = opj(destdir, lang, 'LC_MESSAGES')
 507         mkpath(dest, verbose=verbose)
 508         copy_file(src, opj(dest, 'wxstd.mo'), update=1, verbose=verbose)
 509         CLEANUP.append(opj(dest, 'wxstd.mo'))
 510         CLEANUP.append(dest)
 511
 512
 513 def build_locale_list(srcdir):
 514     # get a list of all files under the srcdir, to be used for install_data
 515     def walk_helper(lst, dirname, files):
 516         for f in files:
 517             filename = opj(dirname, f)
 518             if not os.path.isdir(filename):
 519                 lst.append( (dirname, [filename]) )
 520     file_list = []
 521     os.path.walk(srcdir, walk_helper, file_list)
 522     return file_list
 523
 524
 525 def find_data_files(srcdir, *wildcards):
 526     # get a list of all files under the srcdir matching wildcards,
 527     # returned in a format to be used for install_data
 528
 529     def walk_helper(arg, dirname, files):
 530         names = []
 531         lst, wildcards = arg
 532         for wc in wildcards:
 533             for f in files:
 534                 filename = opj(dirname, f)
 535                 if fnmatch.fnmatch(filename, wc) and not os.path.isdir(filename):
 536                     names.append(filename)
 537         if names:
 538             lst.append( (dirname, names ) )
 539
 540     file_list = []
 541     os.path.walk(srcdir, walk_helper, (file_list, wildcards))
 542     return file_list
 543
 544
 545 def makeLibName(name):
 546     if os.name == 'posix':
 547         libname = '%s_%s-%s' % (WXBASENAME, name, WXRELEASE)
 548     elif name:
 549         libname = 'wxmsw%s%s_%s' % (WXDLLVER, libFlag(), name)
 550     else:
 551         libname = 'wxmsw%s%s' % (WXDLLVER, libFlag())
 552     return [libname]
 553
 554
 555 def findLib(name, libdirs):
 556     name = makeLibName(name)[0]
 557     if os.name == 'posix':
 558         dirs = libdirs + ['/usr/lib', '/usr/local/lib']
 559         name = 'lib'+name
 560     else:
 561         dirs = libdirs[:]
 562     for d in dirs:
 563         p = os.path.join(d, name)
 564         if glob.glob(p+'*') != []:
 565             return True
 566     return False
 567
 568
 569 def adjustCFLAGS(cflags, defines, includes):
 570     '''Extract the raw -I, -D, and -U flags and put them into
 571        defines and includes as needed.'''
 572     newCFLAGS = []
 573     for flag in cflags:
 574         if flag[:2] == '-I':
 575             includes.append(flag[2:])
 576         elif flag[:2] == '-D':
 577             flag = flag[2:]
 578             if flag.find('=') == -1:
 579                 defines.append( (flag, None) )
 580             else:
 581                 defines.append( tuple(flag.split('=')) )
 582         elif flag[:2] == '-U':
 583             defines.append( (flag[2:], ) )
 584         else:
 585             newCFLAGS.append(flag)
 586     return newCFLAGS
 587
 588
 589
 590 def adjustLFLAGS(lflags, libdirs, libs):
 591     '''Extract the -L and -l flags and put them in libdirs and libs as needed'''
 592     newLFLAGS = []
 593     for flag in lflags:
 594         if flag[:2] == '-L':
 595             libdirs.append(flag[2:])
 596         elif flag[:2] == '-l':
 597             libs.append(flag[2:])
 598         else:
 599             newLFLAGS.append(flag)
 600
 601     # remove any flags for universal binaries, we'll get those from
 602     # distutils instead
 603     return [flag for flag in newLFLAGS
 604             if flag not in ['-isysroot', '-arch', 'ppc', 'i386'] and
 605             not flag.startswith('/Developer') ]
 606
 607
 608
 609 def getExtraPath(shortVer=True, addOpts=False):
 610     """Get the dirname that wxPython will be installed under."""
 611
 612     if shortVer:
 613         # short version, just Major.Minor
 614         ep = "wx-%d.%d" % (VER_MAJOR, VER_MINOR)
 615
 616         # plus release if minor is odd
 617         if VER_MINOR % 2 == 1:
 618             ep += ".%d" % VER_RELEASE
 619
 620         ##ep = "wx-%d.%d.%d" % (VER_MAJOR, VER_MINOR, VER_RELEASE)
 621
 622     else:
 623         # long version, full version
 624         ep = "wx-%d.%d.%d.%d" % (VER_MAJOR, VER_MINOR, VER_RELEASE, VER_SUBREL)
 625
 626     if addOpts:
 627         port = WXPORT
 628         if port == "msw": port = "win32"
 629         ep += "-%s-%s" % (WXPORT, (UNICODE and 'unicode' or 'ansi'))
 630
 631     if FLAVOUR:
 632         ep += "-" + FLAVOUR
 633
 634     return ep
 635
 636 #----------------------------------------------------------------------
 637 # sanity checks
 638
 639 if CORE_ONLY:
 640     BUILD_GLCANVAS = 0
 641     BUILD_OGL = 0
 642     BUILD_STC = 0
 643     BUILD_GIZMOS = 0
 644     BUILD_DLLWIDGET = 0
 645     BUILD_ACTIVEX = 0
 646
 647 if debug:
 648     FINAL  = 0
 649     HYBRID = 0
 650
 651 if FINAL:
 652     HYBRID = 0
 653
 654 if UNICODE and WXPORT not in ['msw', 'gtk2', 'mac']:
 655     raise SystemExit, "UNICODE mode not currently supported on this WXPORT: "+WXPORT
 656
 657
 658 if CONTRIBS_INC:
 659     CONTRIBS_INC = [ CONTRIBS_INC ]
 660 else:
 661     CONTRIBS_INC = []
 662
 663
 664 #----------------------------------------------------------------------
 665 # Setup some platform specific stuff
 666 #----------------------------------------------------------------------
 667
 668 if os.name == 'nt':
 669     # Set compile flags and such for MSVC.  These values are derived
 670     # from the wxWidgets makefiles for MSVC, other compilers settings
 671     # will probably vary...
 672     if os.environ.has_key('WXWIN'):
 673         WXDIR = os.environ['WXWIN']
 674     else:
 675         msg("WARNING: WXWIN not set in environment.")
 676         WXDIR = '..'  # assumes in CVS tree
 677     WXPLAT = '__WXMSW__'
 678     GENDIR = 'msw'
 679
 680     includes = ['include', 'src',
 681                 opj(WXDIR, 'lib', 'vc_dll', 'msw'  + libFlag()),
 682                 opj(WXDIR, 'include'),
 683                 opj(WXDIR, 'contrib', 'include'),
 684                 ]
 685
 686     defines = [ ('WIN32', None),
 687                 ('_WINDOWS', None),
 688
 689                 (WXPLAT, None),
 690                 ('WXUSINGDLL', '1'),
 691
 692                 ('SWIG_TYPE_TABLE', WXPYTHON_TYPE_TABLE),
 693                 ('SWIG_PYTHON_OUTPUT_TUPLE', None),
 694                 ('WXP_USE_THREAD', '1'),
 695                 ]
 696
 697     if UNDEF_NDEBUG:
 698         defines.append( ('NDEBUG',) )  # using a 1-tuple makes it do an undef
 699
 700     if HYBRID:
 701         defines.append( ('__NO_VC_CRTDBG__', None) )
 702
 703     if not FINAL or HYBRID:
 704         defines.append( ('__WXDEBUG__', None) )
 705
 706     if UNICODE:
 707         defines.append( ('wxUSE_UNICODE', 1) )
 708
 709     libdirs = [ opj(WXDIR, 'lib', 'vc_dll') ]
 710     if MONOLITHIC:
 711         libs = makeLibName('')
 712     else:
 713         libs = [ 'wxbase' + WXDLLVER + libFlag(),
 714                  'wxbase' + WXDLLVER + libFlag() + '_net',
 715                  'wxbase' + WXDLLVER + libFlag() + '_xml',
 716                  makeLibName('core')[0],
 717                  makeLibName('adv')[0],
 718                  makeLibName('html')[0],
 719                  ]
 720
 721     libs = libs + ['kernel32', 'user32', 'gdi32', 'comdlg32',
 722             'winspool', 'winmm', 'shell32', 'oldnames', 'comctl32',
 723             'odbc32', 'ole32', 'oleaut32', 'uuid', 'rpcrt4',
 724             'advapi32', 'wsock32']
 725
 726
 727     cflags = [ '/Gy',
 728              # '/GX-'  # workaround for internal compiler error in MSVC on some machines
 729              ]
 730     lflags = None
 731
 732     # Other MSVC flags...
 733     # Too bad I don't remember why I was playing with these, can they be removed?
 734     if FINAL:
 735         pass #cflags = cflags + ['/O1']
 736     elif HYBRID :
 737         pass #cflags = cflags + ['/Ox']
 738     else:
 739         pass # cflags = cflags + ['/Od', '/Z7']
 740              # lflags = ['/DEBUG', ]
 741
 742
 743
 744 #----------------------------------------------------------------------
 745
 746 elif os.name == 'posix':
 747     WXDIR = '..'
 748     includes = ['include', 'src']
 749     defines = [('SWIG_TYPE_TABLE', WXPYTHON_TYPE_TABLE),
 750                ('SWIG_PYTHON_OUTPUT_TUPLE', None),
 751                ('WXP_USE_THREAD', '1'),
 752                ]
 753     if UNDEF_NDEBUG:
 754         defines.append( ('NDEBUG',) )  # using a 1-tuple makes it do an undef
 755
 756     Verify_WX_CONFIG()
 757
 758     libdirs = []
 759     libs = []
 760
 761     # If you get unresolved symbol errors on Solaris and are using gcc, then
 762     # uncomment this block to add the right flags to the link step and build
 763     # again.
 764     ## if os.uname()[0] == 'SunOS':
 765     ##     import commands
 766     ##     libs.append('gcc')
 767     ##     libdirs.append(commands.getoutput("gcc -print-search-dirs | grep '^install' | awk '{print $2}'")[:-1])
 768
 769     cflags = os.popen(WX_CONFIG + ' --cxxflags', 'r').read()[:-1]
 770     cflags = cflags.split()
 771     if debug:
 772         cflags.append('-g')
 773         cflags.append('-O0')
 774     else:
 775         cflags.append('-O3')
 776
 777     lflags = os.popen(WX_CONFIG + ' --libs', 'r').read()[:-1]
 778     MONOLITHIC = (lflags.find("_xrc") == -1)
 779     lflags = lflags.split()
 780
 781     WXBASENAME = os.popen(WX_CONFIG + ' --basename').read()[:-1]
 782     WXRELEASE  = os.popen(WX_CONFIG + ' --release').read()[:-1]
 783     WXPREFIX   = os.popen(WX_CONFIG + ' --prefix').read()[:-1]
 784
 785
 786     if sys.platform[:6] == "darwin" and WXPORT == 'mac':
 787         # Flags and such for a Darwin (Max OS X) build of Python
 788         WXPLAT = '__WXMAC__'
 789         GENDIR = 'mac'
 790         libs = ['stdc++']
 791         NO_SCRIPTS = 1
 792
 793
 794     else:
 795         # Set flags for other Unix type platforms
 796         GENDIR = WXPORT
 797
 798         if WXPORT == 'gtk':
 799             WXPLAT = '__WXGTK__'
 800             portcfg = os.popen('gtk-config --cflags', 'r').read()[:-1]
 801         elif WXPORT == 'gtk2':
 802             WXPLAT = '__WXGTK__'
 803             GENDIR = 'gtk' # no code differences so use the same generated sources
 804             portcfg = os.popen('pkg-config gtk+-2.0 --cflags', 'r').read()[:-1]
 805             BUILD_BASE = BUILD_BASE + '-' + WXPORT
 806         elif WXPORT == 'x11':
 807             WXPLAT = '__WXX11__'
 808             portcfg = ''
 809             BUILD_BASE = BUILD_BASE + '-' + WXPORT
 810         else:
 811             raise SystemExit, "Unknown WXPORT value: " + WXPORT
 812
 813         cflags += portcfg.split()
 814
 815         # Some distros (e.g. Mandrake) put libGLU in /usr/X11R6/lib, but
 816         # wx-config doesn't output that for some reason.  For now, just
 817         # add it unconditionally but we should really check if the lib is
 818         # really found there or wx-config should be fixed.
 819         libdirs.append("/usr/X11R6/lib")
 820
 821
 822     # Move the various -I, -D, etc. flags we got from the *config scripts
 823     # into the distutils lists.
 824     cflags = adjustCFLAGS(cflags, defines, includes)
 825     lflags = adjustLFLAGS(lflags, libdirs, libs)
 826
 827
 828 #----------------------------------------------------------------------
 829 else:
 830     raise 'Sorry, platform not supported...'
 831
 832
 833 #----------------------------------------------------------------------
 834 # build options file
 835 #----------------------------------------------------------------------
 836
 837 if SYS_WX_CONFIG is None:
 838     SYS_WX_CONFIG = WX_CONFIG
 839
 840 build_options_template = """
 841 UNICODE=%d
 842 UNDEF_NDEBUG=%d
 843 INSTALL_MULTIVERSION=%d
 844 FLAVOUR="%s"
 845 EP_ADD_OPTS=%d
 846 EP_FULL_VER=%d
 847 WX_CONFIG="%s"
 848 WXPORT="%s"
 849 MONOLITHIC=%d
 850 FINAL=%d
 851 HYBRID=%d
 852 """ % (UNICODE, UNDEF_NDEBUG, INSTALL_MULTIVERSION, FLAVOUR, EP_ADD_OPTS,
 853        EP_FULL_VER, SYS_WX_CONFIG, WXPORT, MONOLITHIC, FINAL, HYBRID)
 854
 855 try:
 856     from build_options import *
 857 except:
 858     build_options_file = os.path.join(os.path.dirname(__file__), "build_options.py")
 859     if not os.path.exists(build_options_file):
 860         try:
 861             myfile = open(build_options_file, "w")
 862             myfile.write(build_options_template)
 863             myfile.close()
 864         except:
 865             print "WARNING: Unable to create build_options.py."
 866
 867
 868 #----------------------------------------------------------------------
 869 # post platform setup checks and tweaks, create the full version string
 870 #----------------------------------------------------------------------
 871
 872 if UNICODE:
 873     BUILD_BASE = BUILD_BASE + '.unicode'
 874
 875 if os.path.exists('DAILY_BUILD'):
 876     VER_FLAGS += '.' + open('DAILY_BUILD').read().strip()
 877
 878 VERSION = "%s.%s.%s.%s%s" % (VER_MAJOR, VER_MINOR, VER_RELEASE,
 879                              VER_SUBREL, VER_FLAGS)
 880
 881
 882 #----------------------------------------------------------------------
 883 # SWIG defaults
 884 #----------------------------------------------------------------------
 885
 886 # *.i files could live in the wxWidgets/wxPython/src dir, or in
 887 # a subdirectory of the devel package. Let's specify both
 888 # dirs as includes so we don't have to guess which is correct.
 889
 890 wxfilesdir = ""
 891 i_subdir = opj("include", getExtraPath(), "wx", "wxPython", "i_files")
 892 if os.name != "nt":
 893     wxfilesdir = opj(WXPREFIX, i_subdir)
 894 else:
 895     wxfilesdir = opj(WXPY_SRC, i_subdir)
 896
 897 i_files_includes = [ '-I' + opj(WXPY_SRC, 'src'),
 898                      '-I' + wxfilesdir ]
 899
 900 swig_cmd = SWIG
 901 swig_force = force
 902 swig_args = ['-c++',
 903              #'-Wall',
 904              '-python',
 905              '-new_repr',
 906              '-modern',
 907              '-D'+WXPLAT,
 908              ] + i_files_includes
 909
 910 if USE_SWIG:
 911     SVER = swig_version()
 912     if int(SVER[-2:]) >= 29:
 913         swig_args += [ '-fastdispatch',
 914                        '-fvirtual',
 915                        '-fastinit',
 916                        '-fastunpack',
 917                        #'-outputtuple',  Currently setting this with a -D define above
 918                        ]
 919
 920 if UNICODE:
 921     swig_args.append('-DwxUSE_UNICODE')
 922
 923 if FULL_DOCS:
 924     swig_args.append('-D_DO_FULL_DOCS')
 925
 926
 927 swig_deps = [ opj(WXPY_SRC, 'src/my_typemaps.i'),
 928               opj(WXPY_SRC, 'src/pyfragments.swg'),
 929               ]
 930
 931 depends = [ #'include/wx/wxPython/wxPython.h',
 932             #'include/wx/wxPython/wxPython_int.h',
 933             #'src/pyclasses.h',
 934             ]
 935
 936 #----------------------------------------------------------------------
 937
 938 ####################################
 939 # BuildRenamers
 940 ####################################
 941
 942 import pprint, shutil
 943 try:
 944     import libxml2
 945     FOUND_LIBXML2 = True
 946 except ImportError:
 947     FOUND_LIBXML2 = False
 948
 949 #---------------------------------------------------------------------------
 950
 951 renamerTemplateStart = """\
 952 // A bunch of %rename directives generated by BuildRenamers in config.py
 953 // in order to remove the wx prefix from all global scope names.
 954
 955 #ifndef BUILDING_RENAMERS
 956
 957 """
 958
 959 renamerTemplateEnd = """
 960 #endif
 961 """
 962
 963 wxPythonTemplateStart = """\
 964 ## This file reverse renames symbols in the wx package to give
 965 ## them their wx prefix again, for backwards compatibility.
 966 ##
 967 ## Generated by BuildRenamers in config.py
 968
 969 # This silly stuff here is so the wxPython.wx module doesn't conflict
 970 # with the wx package.  We need to import modules from the wx package
 971 # here, then we'll put the wxPython.wx entry back in sys.modules.
 972 import sys
 973 _wx = None
 974 if sys.modules.has_key('wxPython.wx'):
 975     _wx = sys.modules['wxPython.wx']
 976     del sys.modules['wxPython.wx']
 977
 978 import wx.%s
 979
 980 sys.modules['wxPython.wx'] = _wx
 981 del sys, _wx
 982
 983
 984 # Now assign all the reverse-renamed names:
 985 """
 986
 987 wxPythonTemplateEnd = """
 988
 989 """
 990
 991
 992
 993 #---------------------------------------------------------------------------
 994 class BuildRenamers:
 995     def run(self, destdir, modname, xmlfile, wxPythonDir="wxPython"):
 996
 997         assert FOUND_LIBXML2, "The libxml2 module is required to use the BuildRenamers functionality."
 998
 999         if not os.path.exists(wxPythonDir):
1000             os.mkdir(wxPythonDir)
1001
1002         swigDest = os.path.join(destdir, "_"+modname+"_rename.i")
1003         pyDest = os.path.join(wxPythonDir, modname + '.py')
1004
1005         swigDestTemp = tempfile.mktemp('.tmp')
1006         swigFile = open(swigDestTemp, "w")
1007         swigFile.write(renamerTemplateStart)
1008
1009         pyDestTemp = tempfile.mktemp('.tmp')
1010         pyFile = open(pyDestTemp, "w")
1011         pyFile.write(wxPythonTemplateStart % modname)
1012
1013         print "Parsing XML and building renamers..."
1014         self.processXML(xmlfile, modname, swigFile, pyFile)
1015
1016         self.checkOtherNames(pyFile, modname,
1017                         os.path.join(destdir, '_'+modname+'_reverse.txt'))
1018         pyFile.write(wxPythonTemplateEnd)
1019         pyFile.close()
1020
1021         swigFile.write(renamerTemplateEnd)
1022         swigFile.close()
1023
1024         # Compare the files just created with the existing one and
1025         # blow away the old one if they are different.
1026         for dest, temp in [(swigDest, swigDestTemp),
1027                            (pyDest, pyDestTemp)]:
1028             # NOTE: we don't use shutil.move() because it was introduced
1029             # in Python 2.3. Eventually we can switch to it when people
1030             # stop building using 2.2.
1031             if not os.path.exists(dest):
1032                 shutil.copyfile(temp, dest)
1033             elif open(dest).read() != open(temp).read():
1034                 os.unlink(dest)
1035                 shutil.copyfile(temp, dest)
1036             else:
1037                 print dest + " not changed."
1038                 os.unlink(temp)
1039
1040     #---------------------------------------------------------------------------
1041
1042
1043     def GetAttr(self, node, name):
1044         path = "./attributelist/attribute[@name='%s']/@value" % name
1045         n = node.xpathEval2(path)
1046         if len(n):
1047             return n[0].content
1048         else:
1049             return None
1050
1051
1052     def processXML(self, xmlfile, modname, swigFile, pyFile):
1053
1054         topnode = libxml2.parseFile(xmlfile).children
1055
1056         # remove any import nodes as we don't need to do renamers for symbols found therein
1057         imports = topnode.xpathEval2("*/import")
1058         for n in imports:
1059             n.unlinkNode()
1060             n.freeNode()
1061
1062         # do a depth first iteration over what's left
1063         for node in topnode:
1064             doRename = False
1065             addWX = False
1066             revOnly = False
1067
1068
1069             if node.name == "class":
1070                 lastClassName = name = self.GetAttr(node, "name")
1071                 lastClassSymName = sym_name = self.GetAttr(node, "sym_name")
1072                 doRename = True
1073                 if sym_name != name:
1074                     name = sym_name
1075                     addWX = True
1076
1077             # renamed constructors
1078             elif node.name == "constructor":
1079                 name     = self.GetAttr(node, "name")
1080                 sym_name = self.GetAttr(node, "sym_name")
1081                 if sym_name != name:
1082                     name = sym_name
1083                     addWX = True
1084                     doRename = True
1085
1086             # only enumitems at the top level
1087             elif node.name == "enumitem" and node.parent.parent.name == "include":
1088                 name     = self.GetAttr(node, "name")
1089                 sym_name = self.GetAttr(node, "sym_name")
1090                 doRename = True
1091
1092
1093             elif node.name in ["cdecl", "constant"]:
1094                 name      = self.GetAttr(node, "name")
1095                 sym_name  = self.GetAttr(node, "sym_name")
1096                 toplevel  = node.parent.name == "include"
1097
1098                 # top-level functions
1099                 if toplevel and self.GetAttr(node, "view") == "globalfunctionHandler":
1100                     doRename = True
1101
1102                 # top-level global vars
1103                 elif toplevel and self.GetAttr(node, "feature_immutable") == "1":
1104                     doRename = True
1105
1106                 # static methods
1107                 elif self.GetAttr(node, "view") == "staticmemberfunctionHandler":
1108                     name     = lastClassName + '_' + name
1109                     sym_name = lastClassSymName + '_' + sym_name
1110                     # only output the reverse renamer in this case
1111                     doRename = revOnly = True
1112
1113                 if doRename and name != sym_name:
1114                     name = sym_name
1115                     addWX = True
1116
1117
1118             if doRename and name:
1119                 old = new = name
1120                 if old.startswith('wx') and not old.startswith('wxEVT_'):
1121                     # remove all wx prefixes except wxEVT_ and write a %rename directive for it
1122                     new = old[2:]
1123                     if not revOnly:
1124                         swigFile.write("%%rename(%s)  %35s;\n" % (new, old))
1125
1126                 # Write assignments to import into the old wxPython namespace
1127                 if addWX and not old.startswith('wx'):
1128                     old = 'wx'+old
1129                 pyFile.write("%s = wx.%s.%s\n" % (old, modname, new))
1130
1131
1132     #---------------------------------------------------------------------------
1133
1134     def checkOtherNames(self, pyFile, moduleName, filename):
1135         if os.path.exists(filename):
1136             prefixes = []
1137             for line in file(filename):
1138                 if line.endswith('\n'):
1139                     line = line[:-1]
1140                 if line and not line.startswith('#'):
1141                     if line.endswith('*'):
1142                         prefixes.append(line[:-1])
1143                     elif line.find('=') != -1:
1144                         pyFile.write("%s\n" % line)
1145                     else:
1146                         wxname = 'wx' + line
1147                         if line.startswith('wx') or line.startswith('WX') or line.startswith('EVT'):
1148                             wxname = line
1149                         pyFile.write("%s = wx.%s.%s\n" % (wxname, moduleName, line))
1150
1151             if prefixes:
1152                 pyFile.write(
1153                     "\n\nd = globals()\nfor k, v in wx.%s.__dict__.iteritems():"
1154                     % moduleName)
1155                 first = True
1156                 for p in prefixes:
1157                     if first:
1158                         pyFile.write("\n    if ")
1159                         first = False
1160                     else:
1161                         pyFile.write("\n    elif ")
1162                     pyFile.write("k.startswith('%s'):\n        d[k] = v" % p)
1163                 pyFile.write("\ndel d, k, v\n\n")
1164
1165
1166 #---------------------------------------------------------------------------