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_data
  31 import distutils.command.install_headers
  32 import distutils.command.clean
  33
  34 #----------------------------------------------------------------------
  35 # flags and values that affect this script
  36 #----------------------------------------------------------------------
  37
  38 VER_MAJOR        = 2      # The first three must match wxWidgets
  39 VER_MINOR        = 5
  40 VER_RELEASE      = 2
  41 VER_SUBREL       = 9      # wxPython release num for x.y.z release of wxWidgets
  42 VER_FLAGS        = "p"     # release flags, such as prerelease num, unicode, etc.
  43
  44 DESCRIPTION      = "Cross platform GUI toolkit for Python"
  45 AUTHOR           = "Robin Dunn"
  46 AUTHOR_EMAIL     = "Robin Dunn <robin@alldunn.com>"
  47 URL              = "http://wxPython.org/"
  48 DOWNLOAD_URL     = "http://wxPython.org/download.php"
  49 LICENSE          = "wxWidgets Library License (LGPL derivative)"
  50 PLATFORMS        = "WIN32,OSX,POSIX"
  51 KEYWORDS         = "GUI,wx,wxWindows,wxWidgets,cross-platform"
  52
  53 LONG_DESCRIPTION = """\
  54 wxPython is a GUI toolkit for Python that is a wrapper around the
  55 wxWidgets C++ GUI library.  wxPython provides a large variety of
  56 window types and controls, all implemented with a native look and
  57 feel (by using the native widgets) on the platforms it is supported
  58 on.
  59 """
  60
  61 CLASSIFIERS      = """\
  62 Development Status :: 6 - Mature
  63 Environment :: MacOS X :: Carbon
  64 Environment :: Win32 (MS Windows)
  65 Environment :: X11 Applications :: GTK
  66 Intended Audience :: Developers
  67 License :: OSI Approved
  68 Operating System :: MacOS :: MacOS X
  69 Operating System :: Microsoft :: Windows :: Windows 95/98/2000
  70 Operating System :: POSIX
  71 Programming Language :: Python
  72 Topic :: Software Development :: User Interfaces
  73 """
  74
  75 ## License :: OSI Approved :: wxWidgets Library Licence
  76
  77
  78 # Config values below this point can be reset on the setup.py command line.
  79
  80 BUILD_GLCANVAS = 1 # If true, build the contrib/glcanvas extension module
  81 BUILD_OGL = 1      # If true, build the contrib/ogl extension module
  82 BUILD_STC = 1      # If true, build the contrib/stc extension module
  83 BUILD_GIZMOS = 1   # Build a module for the gizmos contrib library
  84 BUILD_DLLWIDGET = 0# Build a module that enables unknown wx widgets
  85                    # to be loaded from a DLL and to be used from Python.
  86
  87                    # Internet Explorer wrapper (experimental)
  88 BUILD_IEWIN = (os.name == 'nt')
  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 = 1 # 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 WX_CONFIG = None   # Usually you shouldn't need to touch this, but you can set
 125                    # it to pass an alternate version of wx-config or alternate
 126                    # flags, eg. as required by the .deb in-tree build.  By
 127                    # default a wx-config command will be assembled based on
 128                    # version, port, etc. and it will be looked for on the
 129                    # default $PATH.
 130
 131 WXPORT = 'gtk2'    # On Linux/Unix there are several ports of wxWidgets available.
 132                    # Setting this value lets you select which will be used for
 133                    # the wxPython build.  Possibilites are 'gtk', 'gtk2' and
 134                    # 'x11'.  Curently only gtk and gtk2 works.
 135
 136 BUILD_BASE = "build" # Directory to use for temporary build files.
 137                      # This name will be appended to if the WXPORT or
 138                      # the UNICODE flags are set to non-standard
 139                      # values.  See below.
 140
 141
 142 CONTRIBS_INC = ""  # A dir to add as an -I flag when compiling the contribs
 143
 144
 145 # Some MSW build settings
 146
 147 FINAL = 0          # Mirrors use of same flag in wx makefiles,
 148                    # (0 or 1 only) should probably find a way to
 149                    # autodetect this...
 150
 151 HYBRID = 1         # If set and not debug or FINAL, then build a
 152                    # hybrid extension that can be used by the
 153                    # non-debug version of python, but contains
 154                    # debugging symbols for wxWidgets and wxPython.
 155                    # wxWidgets must have been built with /MD, not /MDd
 156                    # (using FINAL=hybrid will do it.)
 157
 158                    # Version part of wxWidgets LIB/DLL names
 159 WXDLLVER = '%d%d' % (VER_MAJOR, VER_MINOR)
 160
 161 WXPY_SRC = '.'  # Assume we're in the source tree already, but allow the
 162                 # user to change it, particularly for extension building.
 163
 164
 165 #----------------------------------------------------------------------
 166
 167 def msg(text):
 168     if hasattr(sys, 'setup_is_main') and sys.setup_is_main:
 169         print text
 170
 171
 172 def opj(*args):
 173     path = os.path.join(*args)
 174     return os.path.normpath(path)
 175
 176
 177 def libFlag():
 178     if FINAL:
 179         rv = ''
 180     elif HYBRID:
 181         rv = 'h'
 182     else:
 183         rv = 'd'
 184     if UNICODE:
 185         rv = 'u' + rv
 186     return rv
 187
 188
 189 #----------------------------------------------------------------------
 190 # Some other globals
 191 #----------------------------------------------------------------------
 192
 193 PKGDIR = 'wx'
 194 wxpExtensions = []
 195 DATA_FILES = []
 196 CLEANUP = []
 197
 198 force = '--force' in sys.argv or '-f' in sys.argv
 199 debug = '--debug' in sys.argv or '-g' in sys.argv
 200 cleaning = 'clean' in sys.argv
 201
 202
 203 # change the PORT default for wxMac
 204 if sys.platform[:6] == "darwin":
 205     WXPORT = 'mac'
 206
 207 # and do the same for wxMSW, just for consistency
 208 if os.name == 'nt':
 209     WXPORT = 'msw'
 210
 211
 212 #----------------------------------------------------------------------
 213 # Check for build flags on the command line
 214 #----------------------------------------------------------------------
 215
 216 # Boolean (int) flags
 217 for flag in ['BUILD_GLCANVAS', 'BUILD_OGL', 'BUILD_STC',
 218              'BUILD_GIZMOS', 'BUILD_DLLWIDGET', 'BUILD_IEWIN', 'BUILD_ACTIVEX',
 219              'CORE_ONLY', 'PREP_ONLY', 'USE_SWIG', 'UNICODE',
 220              'UNDEF_NDEBUG', 'NO_SCRIPTS', 'NO_HEADERS', 'BUILD_RENAMERS',
 221              'FULL_DOCS',
 222              'FINAL', 'HYBRID', ]:
 223     for x in range(len(sys.argv)):
 224         if sys.argv[x].find(flag) == 0:
 225             pos = sys.argv[x].find('=') + 1
 226             if pos > 0:
 227                 vars()[flag] = eval(sys.argv[x][pos:])
 228                 sys.argv[x] = ''
 229
 230 # String options
 231 for option in ['WX_CONFIG', 'WXDLLVER', 'BUILD_BASE', 'WXPORT', 'SWIG',
 232                'CONTRIBS_INC', 'WXPY_SRC']:
 233     for x in range(len(sys.argv)):
 234         if sys.argv[x].find(option) == 0:
 235             pos = sys.argv[x].find('=') + 1
 236             if pos > 0:
 237                 vars()[option] = sys.argv[x][pos:]
 238                 sys.argv[x] = ''
 239
 240 sys.argv = filter(None, sys.argv)
 241
 242
 243 #----------------------------------------------------------------------
 244 # some helper functions
 245 #----------------------------------------------------------------------
 246
 247 def Verify_WX_CONFIG():
 248     """ Called below for the builds that need wx-config, if WX_CONFIG
 249         is not set then determins the flags needed based on build
 250         options and searches for wx-config on the PATH.
 251     """
 252     # if WX_CONFIG hasn't been set to an explicit value then construct one.
 253     global WX_CONFIG
 254     if WX_CONFIG is None:
 255         WX_CONFIG='wx-config'
 256         port = WXPORT
 257         if port == "x11":
 258             port = "x11univ"
 259         flags =  ' --toolkit=%s' % port
 260         flags += ' --unicode=%s' % (UNICODE and 'yes' or 'no')
 261         flags += ' --version=%s.%s' % (VER_MAJOR, VER_MINOR)
 262
 263         searchpath = os.environ["PATH"]
 264         for p in searchpath.split(':'):
 265             fp = os.path.join(p, 'wx-config')
 266             if os.path.exists(fp) and os.access(fp, os.X_OK):
 267                 # success
 268                 msg("Found wx-config: " + fp)
 269                 msg("    Using flags: " + flags)
 270                 WX_CONFIG = fp + flags
 271                 break
 272         else:
 273             msg("ERROR: WX_CONFIG not specified and wx-config not found on the $PATH")
 274             # should we exit?
 275
 276         # TODO:  exeucte WX_CONFIG --list and verify a matching config is found
 277
 278
 279 def run_swig(files, dir, gendir, package, USE_SWIG, force, swig_args,
 280              swig_deps=[], add_under=False):
 281     """Run SWIG the way I want it done"""
 282
 283     if USE_SWIG and not os.path.exists(os.path.join(dir, gendir)):
 284         os.mkdir(os.path.join(dir, gendir))
 285
 286     if USE_SWIG and not os.path.exists(os.path.join("docs", "xml-raw")):
 287         if not os.path.exists("docs"):
 288             os.mkdir("docs")
 289         os.mkdir(os.path.join("docs", "xml-raw"))
 290
 291     sources = []
 292
 293     if add_under:  pre = '_'
 294     else:          pre = ''
 295
 296     for file in files:
 297         basefile = os.path.splitext(file)[0]
 298         i_file   = os.path.join(dir, file)
 299         py_file  = os.path.join(dir, gendir, pre+basefile+'.py')
 300         cpp_file = os.path.join(dir, gendir, pre+basefile+'_wrap.cpp')
 301         xml_file = os.path.join("docs", "xml-raw", basefile+pre+'_swig.xml')
 302
 303         if add_under:
 304             interface = ['-interface', '_'+basefile+'_']
 305         else:
 306             interface = []
 307
 308         sources.append(cpp_file)
 309
 310         if not cleaning and USE_SWIG:
 311             for dep in swig_deps:
 312                 if newer(dep, py_file) or newer(dep, cpp_file):
 313                     force = 1
 314                     break
 315
 316             if force or newer(i_file, py_file) or newer(i_file, cpp_file):
 317                 ## we need forward slashes here even on win32
 318                 #cpp_file = opj(cpp_file) #'/'.join(cpp_file.split('\\'))
 319                 #i_file = opj(i_file)     #'/'.join(i_file.split('\\'))
 320
 321                 if BUILD_RENAMERS:
 322                     xmltemp = tempfile.mktemp('.xml')
 323
 324                     # First run swig to produce the XML file, adding
 325                     # an extra -D that prevents the old rename
 326                     # directives from being used
 327                     cmd = [ swig_cmd ] + swig_args + \
 328                           [ '-DBUILDING_RENAMERS', '-xmlout', xmltemp ] + \
 329                           ['-I'+dir, '-o', cpp_file, i_file]
 330                     msg(' '.join(cmd))
 331                     spawn(cmd)
 332
 333                     # Next run build_renamers to process the XML
 334                     myRenamer = BuildRenamers()
 335                     myRenamer.run(dir, pre+basefile, xmltemp)
 336                     os.remove(xmltemp)
 337
 338                 # Then run swig for real
 339                 cmd = [ swig_cmd ] + swig_args + interface + \
 340                       ['-I'+dir, '-o', cpp_file, '-xmlout', xml_file, i_file]
 341                 msg(' '.join(cmd))
 342                 spawn(cmd)
 343
 344
 345         # copy the generated python file to the package directory
 346         copy_file(py_file, package, update=not force, verbose=0)
 347         CLEANUP.append(opj(package, os.path.basename(py_file)))
 348
 349     return sources
 350
 351
 352
 353 # Specializations of some distutils command classes
 354 class wx_smart_install_data(distutils.command.install_data.install_data):
 355     """need to change self.install_dir to the actual library dir"""
 356     def run(self):
 357         install_cmd = self.get_finalized_command('install')
 358         self.install_dir = getattr(install_cmd, 'install_lib')
 359         return distutils.command.install_data.install_data.run(self)
 360
 361
 362 class wx_extra_clean(distutils.command.clean.clean):
 363     """
 364     Also cleans stuff that this setup.py copies itself.  If the
 365     --all flag was used also searches for .pyc, .pyd, .so files
 366     """
 367     def run(self):
 368         from distutils import log
 369         from distutils.filelist import FileList
 370         global CLEANUP
 371
 372         distutils.command.clean.clean.run(self)
 373
 374         if self.all:
 375             fl = FileList()
 376             fl.include_pattern("*.pyc", 0)
 377             fl.include_pattern("*.pyd", 0)
 378             fl.include_pattern("*.so", 0)
 379             CLEANUP += fl.files
 380
 381         for f in CLEANUP:
 382             if os.path.isdir(f):
 383                 try:
 384                     if not self.dry_run and os.path.exists(f):
 385                         os.rmdir(f)
 386                     log.info("removing '%s'", f)
 387                 except IOError:
 388                     log.warning("unable to remove '%s'", f)
 389
 390             else:
 391                 try:
 392                     if not self.dry_run and os.path.exists(f):
 393                         os.remove(f)
 394                     log.info("removing '%s'", f)
 395                 except IOError:
 396                     log.warning("unable to remove '%s'", f)
 397
 398
 399
 400 class wx_install_headers(distutils.command.install_headers.install_headers):
 401     """
 402     Install the header files to the WXPREFIX, with an extra dir per
 403     filename too
 404     """
 405     def initialize_options(self):
 406         self.root = None
 407         distutils.command.install_headers.install_headers.initialize_options(self)
 408
 409     def finalize_options(self):
 410         self.set_undefined_options('install', ('root', 'root'))
 411         distutils.command.install_headers.install_headers.finalize_options(self)
 412
 413     def run(self):
 414         if os.name == 'nt':
 415             return
 416         headers = self.distribution.headers
 417         if not headers:
 418             return
 419
 420         root = self.root
 421         if root is None or WXPREFIX.startswith(root):
 422             root = ''
 423         for header, location in headers:
 424             install_dir = os.path.normpath(root +
 425                                            WXPREFIX +
 426                                            '/include/wx-%d.%d/wx' % (VER_MAJOR, VER_MINOR) +
 427                                            location)
 428             self.mkpath(install_dir)
 429             (out, _) = self.copy_file(header, install_dir)
 430             self.outfiles.append(out)
 431
 432
 433
 434
 435 def build_locale_dir(destdir, verbose=1):
 436     """Build a locale dir under the wxPython package for MSW"""
 437     moFiles = glob.glob(opj(WXDIR, 'locale', '*.mo'))
 438     for src in moFiles:
 439         lang = os.path.splitext(os.path.basename(src))[0]
 440         dest = opj(destdir, lang, 'LC_MESSAGES')
 441         mkpath(dest, verbose=verbose)
 442         copy_file(src, opj(dest, 'wxstd.mo'), update=1, verbose=verbose)
 443         CLEANUP.append(opj(dest, 'wxstd.mo'))
 444         CLEANUP.append(dest)
 445
 446
 447 def build_locale_list(srcdir):
 448     # get a list of all files under the srcdir, to be used for install_data
 449     def walk_helper(lst, dirname, files):
 450         for f in files:
 451             filename = opj(dirname, f)
 452             if not os.path.isdir(filename):
 453                 lst.append( (dirname, [filename]) )
 454     file_list = []
 455     os.path.walk(srcdir, walk_helper, file_list)
 456     return file_list
 457
 458
 459 def find_data_files(srcdir, *wildcards):
 460     # get a list of all files under the srcdir matching wildcards,
 461     # returned in a format to be used for install_data
 462
 463     def walk_helper(arg, dirname, files):
 464         names = []
 465         lst, wildcards = arg
 466         for wc in wildcards:
 467             for f in files:
 468                 filename = opj(dirname, f)
 469                 if fnmatch.fnmatch(filename, wc) and not os.path.isdir(filename):
 470                     names.append(filename)
 471         if names:
 472             lst.append( (dirname, names ) )
 473
 474     file_list = []
 475     os.path.walk(srcdir, walk_helper, (file_list, wildcards))
 476     return file_list
 477
 478
 479 def makeLibName(name):
 480     if os.name == 'posix':
 481         libname = '%s_%s-%s' % (WXBASENAME, name, WXRELEASE)
 482     else:
 483         libname = 'wxmsw%s%s_%s' % (WXDLLVER, libFlag(), name)
 484
 485     return [libname]
 486
 487
 488
 489 def adjustCFLAGS(cflags, defines, includes):
 490     '''Extract the raw -I, -D, and -U flags and put them into
 491        defines and includes as needed.'''
 492     newCFLAGS = []
 493     for flag in cflags:
 494         if flag[:2] == '-I':
 495             includes.append(flag[2:])
 496         elif flag[:2] == '-D':
 497             flag = flag[2:]
 498             if flag.find('=') == -1:
 499                 defines.append( (flag, None) )
 500             else:
 501                 defines.append( tuple(flag.split('=')) )
 502         elif flag[:2] == '-U':
 503             defines.append( (flag[2:], ) )
 504         else:
 505             newCFLAGS.append(flag)
 506     return newCFLAGS
 507
 508
 509
 510 def adjustLFLAGS(lfags, libdirs, libs):
 511     '''Extrace the -L and -l flags and put them in libdirs and libs as needed'''
 512     newLFLAGS = []
 513     for flag in lflags:
 514         if flag[:2] == '-L':
 515             libdirs.append(flag[2:])
 516         elif flag[:2] == '-l':
 517             libs.append(flag[2:])
 518         else:
 519             newLFLAGS.append(flag)
 520
 521     return newLFLAGS
 522
 523 #----------------------------------------------------------------------
 524 # sanity checks
 525
 526 if CORE_ONLY:
 527     BUILD_GLCANVAS = 0
 528     BUILD_OGL = 0
 529     BUILD_STC = 0
 530     BUILD_GIZMOS = 0
 531     BUILD_DLLWIDGET = 0
 532     BUILD_IEWIN = 0
 533     BUILD_ACTIVEX = 0
 534
 535 if debug:
 536     FINAL  = 0
 537     HYBRID = 0
 538
 539 if FINAL:
 540     HYBRID = 0
 541
 542 if UNICODE and WXPORT not in ['msw', 'gtk2']:
 543     raise SystemExit, "UNICODE mode not currently supported on this WXPORT: "+WXPORT
 544
 545
 546 if CONTRIBS_INC:
 547     CONTRIBS_INC = [ CONTRIBS_INC ]
 548 else:
 549     CONTRIBS_INC = []
 550
 551
 552 #----------------------------------------------------------------------
 553 # Setup some platform specific stuff
 554 #----------------------------------------------------------------------
 555
 556 if os.name == 'nt':
 557     # Set compile flags and such for MSVC.  These values are derived
 558     # from the wxWidgets makefiles for MSVC, other compilers settings
 559     # will probably vary...
 560     if os.environ.has_key('WXWIN'):
 561         WXDIR = os.environ['WXWIN']
 562     else:
 563         msg("WARNING: WXWIN not set in environment.")
 564         WXDIR = '..'  # assumes in CVS tree
 565     WXPLAT = '__WXMSW__'
 566     GENDIR = 'msw'
 567
 568     includes = ['include', 'src',
 569                 opj(WXDIR, 'lib', 'vc_dll', 'msw'  + libFlag()),
 570                 opj(WXDIR, 'include'),
 571                 opj(WXDIR, 'contrib', 'include'),
 572                 ]
 573
 574     defines = [ ('WIN32', None),
 575                 ('_WINDOWS', None),
 576
 577                 (WXPLAT, None),
 578                 ('WXUSINGDLL', '1'),
 579
 580                 ('SWIG_GLOBAL', None),
 581                 ('WXP_USE_THREAD', '1'),
 582                 ]
 583
 584     if UNDEF_NDEBUG:
 585         defines.append( ('NDEBUG',) )  # using a 1-tuple makes it do an undef
 586
 587     if HYBRID:
 588         defines.append( ('__NO_VC_CRTDBG__', None) )
 589
 590     if not FINAL or HYBRID:
 591         defines.append( ('__WXDEBUG__', None) )
 592
 593     libdirs = [ opj(WXDIR, 'lib', 'vc_dll') ]
 594     libs = [ 'wxbase' + WXDLLVER + libFlag(),  # TODO: trim this down to what is really needed for the core
 595              'wxbase' + WXDLLVER + libFlag() + '_net',
 596              'wxbase' + WXDLLVER + libFlag() + '_xml',
 597              makeLibName('core')[0],
 598              makeLibName('adv')[0],
 599              makeLibName('html')[0],
 600              makeLibName('xrc')[0],
 601              ]
 602
 603     libs = libs + ['kernel32', 'user32', 'gdi32', 'comdlg32',
 604             'winspool', 'winmm', 'shell32', 'oldnames', 'comctl32',
 605             'odbc32', 'ole32', 'oleaut32', 'uuid', 'rpcrt4',
 606             'advapi32', 'wsock32']
 607
 608
 609     cflags = [ '/Gy',
 610              # '/GX-'  # workaround for internal compiler error in MSVC on some machines
 611              ]
 612     lflags = None
 613
 614     # Other MSVC flags...
 615     # Too bad I don't remember why I was playing with these, can they be removed?
 616     if FINAL:
 617         pass #cflags = cflags + ['/O1']
 618     elif HYBRID :
 619         pass #cflags = cflags + ['/Ox']
 620     else:
 621         pass # cflags = cflags + ['/Od', '/Z7']
 622              # lflags = ['/DEBUG', ]
 623
 624
 625
 626 #----------------------------------------------------------------------
 627
 628 elif os.name == 'posix':
 629     WXDIR = '..'
 630     includes = ['include', 'src']
 631     defines = [('SWIG_GLOBAL', None),
 632                ('HAVE_CONFIG_H', None),
 633                ('WXP_USE_THREAD', '1'),
 634                ]
 635     if UNDEF_NDEBUG:
 636         defines.append( ('NDEBUG',) )  # using a 1-tuple makes it do an undef
 637
 638     Verify_WX_CONFIG()
 639
 640     libdirs = []
 641     libs = []
 642
 643     # If you get unresolved symbol errors on Solaris and are using gcc, then
 644     # uncomment this block to add the right flags to the link step and build
 645     # again.
 646     ## if os.uname()[0] == 'SunOS':
 647     ##     libs.append('gcc')
 648     ##     libdirs.append(commands.getoutput("gcc -print-search-dirs | grep '^install' | awk '{print $2}'")[:-1])
 649
 650     cflags = os.popen(WX_CONFIG + ' --cxxflags', 'r').read()[:-1]
 651     cflags = cflags.split()
 652     if debug:
 653         cflags.append('-g')
 654         cflags.append('-O0')
 655     else:
 656         cflags.append('-O3')
 657
 658     lflags = os.popen(WX_CONFIG + ' --libs', 'r').read()[:-1]
 659     lflags = lflags.split()
 660
 661     WXBASENAME = os.popen(WX_CONFIG + ' --basename').read()[:-1]
 662     WXRELEASE  = os.popen(WX_CONFIG + ' --release').read()[:-1]
 663     WXPREFIX   = os.popen(WX_CONFIG + ' --prefix').read()[:-1]
 664
 665
 666     if sys.platform[:6] == "darwin":
 667         # Flags and such for a Darwin (Max OS X) build of Python
 668         WXPLAT = '__WXMAC__'
 669         GENDIR = 'mac'
 670         libs = ['stdc++']
 671         NO_SCRIPTS = 1
 672
 673
 674     else:
 675         # Set flags for other Unix type platforms
 676         GENDIR = WXPORT
 677
 678         if WXPORT == 'gtk':
 679             WXPLAT = '__WXGTK__'
 680             portcfg = os.popen('gtk-config --cflags', 'r').read()[:-1]
 681         elif WXPORT == 'gtk2':
 682             WXPLAT = '__WXGTK__'
 683             GENDIR = 'gtk' # no code differences so use the same generated sources
 684             portcfg = os.popen('pkg-config gtk+-2.0 --cflags', 'r').read()[:-1]
 685             BUILD_BASE = BUILD_BASE + '-' + WXPORT
 686         elif WXPORT == 'x11':
 687             WXPLAT = '__WXX11__'
 688             portcfg = ''
 689             BUILD_BASE = BUILD_BASE + '-' + WXPORT
 690         else:
 691             raise SystemExit, "Unknown WXPORT value: " + WXPORT
 692
 693         cflags += portcfg.split()
 694
 695         # Some distros (e.g. Mandrake) put libGLU in /usr/X11R6/lib, but
 696         # wx-config doesn't output that for some reason.  For now, just
 697         # add it unconditionally but we should really check if the lib is
 698         # really found there or wx-config should be fixed.
 699         libdirs.append("/usr/X11R6/lib")
 700
 701
 702     # Move the various -I, -D, etc. flags we got from the *config scripts
 703     # into the distutils lists.
 704     cflags = adjustCFLAGS(cflags, defines, includes)
 705     lflags = adjustLFLAGS(lflags, libdirs, libs)
 706
 707
 708 #----------------------------------------------------------------------
 709 else:
 710     raise 'Sorry, platform not supported...'
 711
 712
 713 #----------------------------------------------------------------------
 714 # post platform setup checks and tweaks, create the full version string
 715 #----------------------------------------------------------------------
 716
 717 if UNICODE:
 718     BUILD_BASE = BUILD_BASE + '.unicode'
 719     VER_FLAGS += 'u'
 720
 721 if os.path.exists('DAILY_BUILD'):
 722
 723     VER_FLAGS += '.' + open('DAILY_BUILD').read().strip()
 724
 725 VERSION = "%s.%s.%s.%s%s" % (VER_MAJOR, VER_MINOR, VER_RELEASE,
 726                              VER_SUBREL, VER_FLAGS)
 727
 728
 729 #----------------------------------------------------------------------
 730 # SWIG defaults
 731 #----------------------------------------------------------------------
 732
 733 swig_cmd = SWIG
 734 swig_force = force
 735 swig_args = ['-c++',
 736              '-Wall',
 737              '-nodefault',
 738
 739              '-python',
 740              '-keyword',
 741              '-new_repr',
 742              '-modern',
 743
 744              '-I' + opj(WXPY_SRC, 'src'),
 745              '-D'+WXPLAT,
 746              '-noruntime'
 747              ]
 748 if UNICODE:
 749     swig_args.append('-DwxUSE_UNICODE')
 750
 751 if FULL_DOCS:
 752     swig_args.append('-D_DO_FULL_DOCS')
 753
 754
 755 swig_deps = [ opj(WXPY_SRC, 'src/my_typemaps.i'),
 756               opj(WXPY_SRC, 'src/my_fragments.i'),
 757               opj(WXPY_SRC, 'src/common.swg'),
 758               opj(WXPY_SRC, 'src/pyrun.swg'),
 759               opj(WXPY_SRC, 'src/python.swg'),
 760               ]
 761
 762 depends = [ #'include/wx/wxPython/wxPython.h',
 763             #'include/wx/wxPython/wxPython_int.h',
 764             #'src/pyclasses.h',
 765             ]
 766
 767 #----------------------------------------------------------------------
 768
 769 ####################################
 770 # BuildRenamers
 771 ####################################
 772
 773 import pprint
 774 import xml.sax
 775
 776 try:
 777     import libxml2
 778     FOUND_LIBXML2 = True
 779 except ImportError:
 780     FOUND_LIBXML2 = False
 781
 782 #---------------------------------------------------------------------------
 783
 784
 785 renamerTemplateStart = """\
 786 // A bunch of %rename directives generated by BuildRenamers in config.py
 787 // in order to remove the wx prefix from all global scope names.
 788
 789 #ifndef BUILDING_RENAMERS
 790
 791 """
 792
 793 renamerTemplateEnd = """
 794 #endif
 795 """
 796
 797 wxPythonTemplateStart = """\
 798 ## This file reverse renames symbols in the wx package to give
 799 ## them their wx prefix again, for backwards compatibility.
 800 ##
 801 ## Generated by BuildRenamers in config.py
 802
 803 # This silly stuff here is so the wxPython.wx module doesn't conflict
 804 # with the wx package.  We need to import modules from the wx package
 805 # here, then we'll put the wxPython.wx entry back in sys.modules.
 806 import sys
 807 _wx = None
 808 if sys.modules.has_key('wxPython.wx'):
 809     _wx = sys.modules['wxPython.wx']
 810     del sys.modules['wxPython.wx']
 811
 812 import wx.%s
 813
 814 sys.modules['wxPython.wx'] = _wx
 815 del sys, _wx
 816
 817
 818 # Now assign all the reverse-renamed names:
 819 """
 820
 821 wxPythonTemplateEnd = """
 822
 823 """
 824
 825
 826
 827 #---------------------------------------------------------------------------
 828 class BuildRenamers:
 829     def run(self, destdir, modname, xmlfile, wxPythonDir="wxPython"):
 830
 831         assert FOUND_LIBXML2, "The libxml2 module is required to use the BuildRenamers functionality."
 832
 833         if not os.path.exists(wxPythonDir):
 834             os.mkdir(wxPythonDir)
 835
 836         swigDest = os.path.join(destdir, "_"+modname+"_rename.i")
 837         pyDest = os.path.join(wxPythonDir, modname + '.py')
 838
 839         swigDestTemp = tempfile.mktemp('.tmp')
 840         swigFile = open(swigDestTemp, "w")
 841         swigFile.write(renamerTemplateStart)
 842
 843         pyDestTemp = tempfile.mktemp('.tmp')
 844         pyFile = open(pyDestTemp, "w")
 845         pyFile.write(wxPythonTemplateStart % modname)
 846
 847         print "Parsing XML and building renamers..."
 848         self.processXML(xmlfile, modname, swigFile, pyFile)
 849
 850         self.checkOtherNames(pyFile, modname,
 851                         os.path.join(destdir, '_'+modname+'_reverse.txt'))
 852         pyFile.write(wxPythonTemplateEnd)
 853         pyFile.close()
 854
 855         swigFile.write(renamerTemplateEnd)
 856         swigFile.close()
 857
 858         # Compare the files just created with the existing one and
 859         # blow away the old one if they are different.
 860         for dest, temp in [(swigDest, swigDestTemp),
 861                            (pyDest, pyDestTemp)]:
 862             if not os.path.exists(dest):
 863                 os.rename(temp, dest)
 864             elif open(dest).read() != open(temp).read():
 865                 os.unlink(dest)
 866                 os.rename(temp, dest)
 867             else:
 868                 print dest + " not changed."
 869                 os.unlink(temp)
 870
 871     #---------------------------------------------------------------------------
 872
 873
 874     def GetAttr(self, node, name):
 875         path = "./attributelist/attribute[@name='%s']/@value" % name
 876         n = node.xpathEval2(path)
 877         if len(n):
 878             return n[0].content
 879         else:
 880             return None
 881
 882
 883     def processXML(self, xmlfile, modname, swigFile, pyFile):
 884
 885         topnode = libxml2.parseFile(xmlfile).children
 886
 887         # remove any import nodes as we don't need to do renamers for symbols found therein
 888         imports = topnode.xpathEval2("*/import")
 889         for n in imports:
 890             n.unlinkNode()
 891             n.freeNode()
 892
 893         # do a depth first iteration over what's left
 894         for node in topnode:
 895             doRename = False
 896             doPtr = False
 897             addWX = False
 898             revOnly = False
 899
 900
 901             if node.name == "class":
 902                 lastClassName = name = self.GetAttr(node, "name")
 903                 lastClassSymName = sym_name = self.GetAttr(node, "sym_name")
 904                 doRename = True
 905                 doPtr = True
 906                 if sym_name != name:
 907                     name = sym_name
 908                     addWX = True
 909
 910             # renamed constructors
 911             elif node.name == "constructor":
 912                 name     = self.GetAttr(node, "name")
 913                 sym_name = self.GetAttr(node, "sym_name")
 914                 if sym_name != name:
 915                     name = sym_name
 916                     addWX = True
 917                     doRename = True
 918
 919             # only enumitems at the top level
 920             elif node.name == "enumitem" and node.parent.parent.name == "include":
 921                 name     = self.GetAttr(node, "name")
 922                 sym_name = self.GetAttr(node, "sym_name")
 923                 doRename = True
 924
 925
 926             elif node.name in ["cdecl", "constant"]:
 927                 name      = self.GetAttr(node, "name")
 928                 sym_name  = self.GetAttr(node, "sym_name")
 929                 toplevel  = node.parent.name == "include"
 930
 931                 # top-level functions
 932                 if toplevel and self.GetAttr(node, "view") == "globalfunctionHandler":
 933                     doRename = True
 934
 935                 # top-level global vars
 936                 elif toplevel and self.GetAttr(node, "feature_immutable") == "1":
 937                     doRename = True
 938
 939                 # static methods
 940                 elif self.GetAttr(node, "view") == "staticmemberfunctionHandler":
 941                     name     = lastClassName + '_' + name
 942                     sym_name = lastClassSymName + '_' + sym_name
 943                     # only output the reverse renamer in this case
 944                     doRename = revOnly = True
 945
 946                 if doRename and name != sym_name:
 947                     name = sym_name
 948                     addWX = True
 949
 950
 951             if doRename and name:
 952                 old = new = name
 953                 if old.startswith('wx') and not old.startswith('wxEVT_'):
 954                     # remove all wx prefixes except wxEVT_ and write a %rename directive for it
 955                     new = old[2:]
 956                     if not revOnly:
 957                         swigFile.write("%%rename(%s)  %35s;\n" % (new, old))
 958
 959                 # Write assignments to import into the old wxPython namespace
 960                 if addWX and not old.startswith('wx'):
 961                     old = 'wx'+old
 962                 pyFile.write("%s = wx.%s.%s\n" % (old, modname, new))
 963                 if doPtr:
 964                     pyFile.write("%sPtr = wx.%s.%sPtr\n" % (old, modname, new))
 965
 966
 967     #---------------------------------------------------------------------------
 968
 969     def checkOtherNames(self, pyFile, moduleName, filename):
 970         if os.path.exists(filename):
 971             prefixes = []
 972             for line in file(filename):
 973                 if line.endswith('\n'):
 974                     line = line[:-1]
 975                 if line and not line.startswith('#'):
 976                     if line.endswith('*'):
 977                         prefixes.append(line[:-1])
 978                     elif line.find('=') != -1:
 979                         pyFile.write("%s\n" % line)
 980                     else:
 981                         wxname = 'wx' + line
 982                         if line.startswith('wx') or line.startswith('WX') or line.startswith('EVT'):
 983                             wxname = line
 984                         pyFile.write("%s = wx.%s.%s\n" % (wxname, moduleName, line))
 985
 986             if prefixes:
 987                 pyFile.write(
 988                     "\n\nd = globals()\nfor k, v in wx.%s.__dict__.iteritems():"
 989                     % moduleName)
 990                 first = True
 991                 for p in prefixes:
 992                     if first:
 993                         pyFile.write("\n    if ")
 994                         first = False
 995                     else:
 996                         pyFile.write("\n    elif ")
 997                     pyFile.write("k.startswith('%s'):\n        d[k] = v" % p)
 998                 pyFile.write("\ndel d, k, v\n\n")
 999
1000
1001 #---------------------------------------------------------------------------