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