Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

This commit was manufactured by cvs2svn to create tag 'WX_2_2_9'.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/WX_2_2_9@13364 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Bryan Petty
2002-01-04 16:15:08 +00:00
parent dc3d889d0b
commit f7f6abe24d
2324 changed files with 375095 additions and 121526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
wxPython/distrib/.cvsignore Normal file
View File

@@ -0,0 +1,6 @@
*.gz
*.rpm
*.zip
build.pyc
filelist
wxp2.wse

5
wxPython/distrib/.rpmrc Normal file
View File

@@ -0,0 +1,5 @@
sourcedir: .
builddir: .
rpmdir: .
srcrpmdir: .

30
wxPython/distrib/README.dbg.txt Normal file
View File

@@ -0,0 +1,30 @@
This zip file contains versions of the wxWindows and wxPython binaries
that have been compiled with __WXDEBUG__ defined. This adds code to
wxWindows that is a bit more agressive about checking parameter
values, return values, and etc. When the debugging library senses
something is wrong it will popup a message dialog telling you so.
Unfortunately the message is specific to the C++ code but it might
give you a hint about what went wrong and how to fix it.
Another debugging feature is when the wxPython program exits, it will
print to stdout information about any wxWindows C++ objects that
havn't been properly cleaned up.
This archive contains a new wxWindows DLL named wx[version]d.dll and a
debugging version of the core wxPython module, wxc_d.pyd. These
should be put into your wxPython package directory. Also included are
the debuging version of Python, python_d.exe and python[VER]_d.dll
which can be put wherever you like.
In order to run the debugging version of wxPython sumply run you
program with python_d.exe instead of python.exe. This lets the
debugging version sit side by side with the production version, with
no need for swapping this around. You will also need _d versions of
any other extension modules you are using. If you need _d's for any
of the other standard Python extensions you can get them here, for 2.0
at least:
http://www.pythonlabs.com/products/python2.0/downloads/BeOpen-Python-2.0-Debug.zip
Robin

168
wxPython/distrib/autobuild.py Executable file
View File

@@ -0,0 +1,168 @@
import sys, os, string, time
from ftplib import FTP
cwd = os.getcwd()
logfile = 'c:\\temp\\autobuild.log'
WXDIR = os.environ['WXWIN']
dllVer = '22_1'
wxpVer = '2.2.1'
dateSt = time.strftime("%Y%m%d", time.localtime(time.time()))
base = os.path.split(sys.argv[0])[0]
base = os.path.join(base, '..')
WXPYDIR = os.path.abspath(base)
#----------------------------------------------------------------------
def do(cmd):
st = " " + cmd + " >> " + logfile
print st
f = open(logfile, "at")
f.write(st + '\n')
f.close()
os.system(cmd + " >>& " + logfile)
#----------------------------------------------------------------------
def logTruncate():
f = open(logfile, "wt")
f.close()
def logSeparator(msg=None, f=None, recurse=1):
if not f:
f = open(logfile, "at")
f.write('\n')
f.write('--' * 35)
f.write('\n')
if msg:
f.write(msg)
f.write('\n')
f.write('--' * 35)
f.write('\n')
if recurse:
logSeparator(msg, sys.stdout, 0)
#----------------------------------------------------------------------
def validateFile(file):
if not os.path.exists(file):
logSeparator("***** %s does not exist, exiting! *****" % file)
raise SystemExit
else:
logSeparator("%s found, continuing..." % file, recurse=0)
#----------------------------------------------------------------------
def main():
logTruncate()
try:
logSeparator("Cleanup")
os.chdir(WXDIR + '/src/msw')
do('make cleandll FINAL=1')
logSeparator("Building Documentation...")
os.chdir(WXDIR + '/src/msw')
do('make touchmanual htmlhelp')
validateFile(WXDIR + '/docs/htmlhelp/wx.chm')
logSeparator("Building wxWindows and other libraries...")
os.chdir(WXDIR + '/src/msw')
do('make dll pch FINAL=1')
validateFile(WXDIR + '/lib/wx'+dllVer+'.dll')
logSeparator("Cleaning wxPython build directory...")
os.chdir(WXPYDIR)
do('buildall.bat -c')
os.rename('build.local', 'build.local.save')
f = open("build.local", "w")
f.write("""
CRTFLAG='/MD'
FINAL=1
""")
f.close()
logSeparator("Building core wxPython...")
os.chdir(WXPYDIR + '\\src')
do("build -b")
validateFile(WXPYDIR+'\\wxPython\\wxc.pyd')
logSeparator("Building wxPython addon modules...")
os.chdir(WXPYDIR+'\\contrib')
do("buildall -b")
validateFile(WXPYDIR+'\\wxPython\\glcanvasc.pyd')
validateFile(WXPYDIR+'\\wxPython\\oglc.pyd')
validateFile(WXPYDIR+'\\wxPython\\stc_c.pyd')
os.chdir(WXPYDIR)
os.unlink('build.local')
os.rename('build.local.save', 'build.local')
logSeparator("Building installer executable...")
os.chdir(WXPYDIR+'\\distrib')
do("autoit2 wise.aut")
srcName = WXPYDIR+'\\distrib\\wxPython-'+wxpVer+'.EXE'
destName = WXPYDIR+'\\distrib\\wxPython-'+wxpVer+'-'+dateSt+'.EXE'
validateFile(srcName)
try:
time.sleep(5)
os.rename(srcName, destName)
validateFile(destName)
except:
logSeparator("****** UNABLE TO RENAME FILE ******")
logSeparator("Building source and docs zip files...")
os.chdir(WXPYDIR)
do("distrib\\zipit.bat %s" % wxpVer)
srcZName = WXPYDIR+'\\distrib\\wxPython-src-'+wxpVer+'.zip'
destZName = WXPYDIR+'\\distrib\\wxPython-src-'+wxpVer+'-'+dateSt+'.zip'
validateFile(srcZName)
try:
os.rename(srcZName, destZName)
except:
pass
srcDName = WXPYDIR+'\\distrib\\wxPython-docs-'+wxpVer+'.zip'
destDName = WXPYDIR+'\\distrib\\wxPython-docs-'+wxpVer+'-'+dateSt+'.zip'
validateFile(srcDName)
try:
os.rename(srcDName, destDName)
except:
pass
# #*#*#*#*#* Comment this out to allow upload...
return
logSeparator("Uploading to website...")
do('python c:\\utils\\sendwxp.py %s' % destName)
#do('python c:\\utils\\sendwxp.py %s' % destZName)
do('python c:\\utils\\sendwxp.py %s' % destDName)
logSeparator("Finished!!!")
finally:
os.system("list " + logfile)
pass
if __name__ == '__main__':
main()

865
wxPython/distrib/build.py Executable file
View File

@@ -0,0 +1,865 @@
#!/usr/bin/env python
#----------------------------------------------------------------------------
# Name: build.py
# Purpose: This script is used to build wxPython. It reads a build
# configuration file in the requested project directory and
# based on the contents of the file can build Makefiles for
# unix or win32, and can execute make with various options
# potentially automating the entire build/install/clean process
# from a single command.
#
# Author: Robin Dunn
#
# Created: 18-Aug-1999
# RCS-ID: $Id$
# Copyright: (c) 1999 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
"""
build.py
This script is used to build wxPython. It reads a build configuration
file in the requested project directory and based on the contents of
the file can build Makefiles for unix or win32, and can execute make
with various options potentially automating the entire
build/install/clean process from a single command.
The default action is to build the Makefile and exit.
Options
-C dir CD to dir before doing anything
-B file Use file as the build configuration (default ./build.cfg)
-M file Use file as the name of the makefile to create
(default Makefile)
-b Build the module (runs make)
-i Install the module (runs make install)
-c Cleanup (runs make clean)
-u Uninstall (runs make uninstall)
-h Show help and exit
Configuration Files
The build configuration file lists targets, source files and options
for the the build process. The contents of the build.cfg are used to
dynamically generate the Makefile.
To prevent you from getting screwed when the default build.cfg is
updated, you can override the values in build.cfg by putting your
custom definitions in a file named build.local. You can also place a
build.local file in the parent directory, or even in the grandparent
directory for project-wide overrides. Finally, command-line arguments
of the form NAME=VALUE can also be used to override simple configuration
values. The order of evaluation is:
0. comman-line flags (-M, -b, etc.)
1. ./build.cfg
2. ../../build.local (if present)
3. ../build.local (if present)
4. ./build.local (if present)
5. command-line NAME=VALUEs
The config files are actually just Python files that get exec'ed in a
separate namespace which is then used later as a configuration object.
This keeps the build script simple in that it doesn't have to parse
anything, and the config files can be much more than just names and
values as pretty much any python code can be executed. The global
variables set in the config namespace are what are used later as
configuation values.
Configuration Options
The following variables can be set in the config files. Only a few are
required, the rest will either have suitable defaults or will be
calculated from your current Python runtime environment.
MODULE The name of the extension module to produce
SWIGFILES A list of files that should be run through SWIG
SWIGFLAGS Flags for SWIG
SOURCES Other C/C++ sources that should be part of the module
PYFILES Other Python files that should be installed with the module
CFLAGS Flags to be used by the compiler
LFLAGS Flags to be used at the link step
LIBS Libraries to be linked with
OTHERCFLAGS Extra flags to append to CFLAGS
OTHERLFLAGS Extra flags to append to LFLAGS
OTHERSWIGFLAGS Extra flags to append to SWIGFLAGS
OTHERLIBS Other libraries to be linked with, in addition to LIBS
OTHERTARGETS Other targets to be placed on the default rule line
OTHERINSTALLTARGETS
Other targets to be placed on the install rule line
OTHERDEFS Text to place near the begining of the Makefile
OTHERRULES This text is placed at the end of the makefile and
will typically be used for adding rules and such
DEFAULTRULE Text to be used for the default rule in the makefile
TARGETDIR Destination for the install step
MAKE The make program to use
MAKEFILE The name of the makefile
runBuild Setting this to 1 is eqivalent to the -b flag
runInstall Setting this to 1 is eqivalent to the -i flag
runClean Setting this to 1 is eqivalent to the -c flag
runUninstall Setting this to 1 is eqivalent to the -u flag
PYVERSION Version number of Python used in pathnames
PYPREFIX The root of the Python install
EXECPREFIX The root of the Python install for binary files
PYTHONLIB The Python link library
"""
import sys, os, string, getopt
#----------------------------------------------------------------------------
# This is really the wxPython version number, and will be placed in the
# Makefiles for use with the distribution related targets.
major_version = '2.2'
build_version = '2'
__version__ = major_version + '.' + build_version
#----------------------------------------------------------------------------
def main(args):
try:
opts, args = getopt.getopt(args[1:], 'C:B:M:bicu')
except getopt.error:
usage()
sys.exit(1)
if not os.environ.has_key('WXWIN'):
print "WARNING: WXWIN is not set in the environment. WXDIR may not\n"\
" be set properly in the makefile, you will have to \n"\
" set the environment variable or override in build.local."
bldCfg = 'build.cfg'
bldCfgLocal = 'build.local'
MAKEFILE = 'Makefile'
runBuild = 0
runInstall = 0
runClean = 0
runUninstall = 0
for flag, value in opts:
if flag == '-C': os.chdir(value)
elif flag == '-B': bldCfgFile = value
elif flag == '-M': makefile = value
elif flag == '-b': runBuild = 1
elif flag == '-c': runClean = 1
elif flag == '-i': runInstall = 1
elif flag == '-u': runUninstall = 1
elif flag == '-h': usage(); sys.exit(1)
else: usage(); sys.exit(1)
config = BuildConfig(bldCfg = bldCfg,
bldCfgLocal = bldCfgLocal,
MAKEFILE = MAKEFILE,
runBuild = runBuild,
runInstall = runInstall,
runClean = runClean,
runUninstall = runUninstall)
err = 0
if config.readConfigFiles(args):
config.doFixups()
config.makeMakefile()
if config.runBuild:
cmd = "%s -f %s" % (config.MAKE, config.MAKEFILE)
print "Running:", cmd
err = os.system(cmd)
if not err and config.runInstall:
cmd = "%s -f %s install" % (config.MAKE, config.MAKEFILE)
print "Running:", cmd
err = os.system(cmd)
if not err and config.runClean:
cmd = "%s -f %s clean" % (config.MAKE, config.MAKEFILE)
print "Running:", cmd
err = os.system(cmd)
if not err and config.runUninstall:
cmd = "%s -f %s uninstall" % (config.MAKE, config.MAKEFILE)
print "Running:", cmd
err = os.system(cmd)
return err/256
#----------------------------------------------------------------------------
def usage():
print __doc__
#----------------------------------------------------------------------------
def swapslash(st):
if sys.platform != 'win32':
st = string.join(string.split(st, '\\'), '/')
return st
#----------------------------------------------------------------------------
def splitlines(st):
return string.join(string.split(string.strip(st), ' '), ' \\\n\t')
#----------------------------------------------------------------------------
class BuildConfig:
def __init__(self, **kw):
self.__dict__.update(kw)
self.setDefaults()
#------------------------------------------------------------
def setDefaults(self):
base = os.path.split(sys.argv[0])[0]
base = os.path.join(base, '..')
self.WXPYDIR = os.path.abspath(base)
self.VERSION = __version__
self.MAJVER = major_version
self.BLDVER = build_version
self.MODULE = ''
self.SWIGFILES = []
self.SWIGFLAGS = '-c++ -shadow -python -keyword -dnone -I$(WXPSRCDIR)'
self.SOURCES = []
self.PYFILES = []
self.LFLAGS = ''
self.OTHERCFLAGS = ''
self.OTHERLFLAGS = ''
self.OTHERSWIGFLAGS = ''
self.OTHERLIBS = ''
self.OTHERTARGETS = ''
self.OTHERINSTALLTARGETS = ''
self.OTHERUNINSTALLTARGETS = ''
self.OTHERRULES = ''
self.DEFAULTRULE = 'default: $(GENCODEDIR) $(TARGET) $(BUILDDIR)/$(TARGET) bldpycfiles'
self.PYVERSION = sys.version[:3]
self.PYPREFIX = sys.prefix
self.EXECPREFIX = sys.exec_prefix
self.WXDIR = '$(WXWIN)'
self.FINAL = '0'
self.WXP_USE_THREAD = '1'
self.WXUSINGDLL = '1'
self.OTHERDEP = ''
self.WXPSRCDIR = '$(WXPYDIR)/src'
self.SWIGDEPS = ''
self.OTHERDEPS = ''
self.OTHERDEFS = ''
if sys.platform == 'win32':
self.MAKE = 'nmake'
compactver = string.join(string.split(self.PYVERSION, '.'), '')
self.PYTHONLIB = '$(PYPREFIX)\\libs\\python%s.lib' % compactver
self.TARGETDIR = '$(PYPREFIX)\\wxPython'
self.LIBS = '$(PYTHONLIB) $(WXPSRCDIR)\wxc.lib'
self.GENCODEDIR = 'msw'
self.SWIGTOOLKITFLAG = '-D__WXMSW__'
self.OBJEXT = '.obj'
self.TARGET = '$(MODULE).pyd'
self.CFLAGS = '-I$(PYPREFIX)\include -I$(WXPSRCDIR) -I. /Fp$(MODULE).pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H $(THREAD) '
self.LFLAGS = '$(DEBUGLFLAGS) /DLL /subsystem:windows,3.50 /machine:I386 /nologo'
self.RESFILE = ''
self.RESRULE = ''
self.OVERRIDEFLAGS = '/GX-'
self.RMCMD = '-erase '
self.WXPSRCDIR = os.path.normpath(self.WXPSRCDIR)
self.CRTFLAG = ''
else:
self.MAKE = 'make'
self.PYLIB = '$(EXECPREFIX)/lib/python$(PYVERSION)'
self.LIBPL = '$(PYLIB)/config'
self.PYTHONLIB = '$(LIBPL)/libpython$(PYVERSION).a'
self.TARGETDIR = '$(EXECPREFIX)/lib/python$(PYVERSION)/site-packages/wxPython'
self.TARGET = '$(MODULE)module$(SO)'
self.OBJEXT = '.o'
self.HELPERLIB = 'wxPyHelpers'
self.HELPERLIBDIR = '$(EXECPREFIX)/lib'
self.CFLAGS = '-DSWIG_GLOBAL -DHAVE_CONFIG_H $(THREAD) -I. '\
'`$(WXCONFIG) --cflags` -I$(PYINCLUDE) -I$(EXECINCLUDE) '\
'-I$(WXPSRCDIR)'
self.LFLAGS = '-L$(WXPSRCDIR) `$(WXCONFIG) --libs`'
self.RMCMD = '-rm -f '
self.WXCONFIG = 'wx-config'
self.USE_SONAME = '1'
# **** What to do when I start supporting Motif, etc.???
self.GENCODEDIR = 'gtk'
self.SWIGTOOLKITFLAG = '-D__WXGTK__'
# Extract a few things from Python's Makefile...
try:
filename = os.path.join(self.EXECPREFIX,
'lib/python'+self.PYVERSION,
'config/Makefile')
mfText = string.split(open(filename, 'r').read(), '\n')
except IOError:
raise SystemExit, "Python development files not found"
self.CCC = self.findMFValue(mfText, 'CCC')
self.CC = self.findMFValue(mfText, 'CC')
self.OPT = self.findMFValue(mfText, 'OPT')
self.SO = self.findMFValue(mfText, 'SO')
self.LDSHARED = self.findMFValue(mfText, 'LDSHARED')
self.CCSHARED = self.findMFValue(mfText, 'CCSHARED')
#self.LINKFORSHARED = self.findMFValue(mfText, 'LINKFORSHARED')
#self. = self.findMFValue(mfText, '')
#self. = self.findMFValue(mfText, '')
# The majority of cases will require LDSHARED to be
# modified to use the C++ driver instead of the C driver
# for linking. We'll try to do it here and if we goof up
# then the user can correct it in their build.local file.
self.LDSHARED = string.join(['$(CCC)'] +
string.split(self.LDSHARED, ' ')[1:],
' ')
#------------------------------------------------------------
def doFixups(self):
# This is called after the config files have been evaluated
# so we can do some sanity checking...
if sys.platform != 'win32':
if not self.CCC:
self.CCC = os.popen('%(WXCONFIG)s --cxx' % self.__dict__, 'r').read()[:-1]
if not self.CCC:
print "Warning: C++ compiler not specified (CCC). Assuming c++"
self.CCC = 'c++'
if not self.CC:
self.CCC = os.popen('%(WXCONFIG)s --cc' % self.__dict__, 'r').read()[:-1]
if not self.CC:
print "Warning: C compiler not specified (CC). Assuming cc"
self.CC = 'cc'
#------------------------------------------------------------
def findMFValue(self, mfText, st):
# Find line begining with st= and return the value
# Regex would probably be to cooler way to do this, but
# I think this is the most understandable.
for line in mfText:
if string.find(line, st+'=') == 0:
st = string.strip(line[len(st)+1:])
return st
return None
#------------------------------------------------------------
def makeMakefile(self):
# make a list of object file names
objects = ""
for name in self.SWIGFILES:
objects = objects + os.path.splitext(name)[0] + self.OBJEXT + ' '
for name in self.SOURCES:
obj = os.path.basename(name)
objects = objects + os.path.splitext(obj)[0] + self.OBJEXT + ' '
self.OBJECTS = splitlines(objects)
# now build the text for the dependencies
depends = ""
for name in self.SWIGFILES:
rootname = os.path.splitext(name)[0]
text = '$(GENCODEDIR)/%s.cpp $(GENCODEDIR)/%s.py : %s.i %s\n' \
'$(TARGETDIR)\\%s.py : $(GENCODEDIR)\\%s.py\n' \
'$(BUILDDIR)\\%s.py : $(GENCODEDIR)\\%s.py\n' % \
(rootname, rootname, rootname, self.SWIGDEPS,
rootname, rootname, rootname, rootname)
depends = depends + text
if self.OTHERDEPS:
text = '%s%s : %s\n' % \
(os.path.splitext(name)[0], self.OBJEXT, self.OTHERDEPS)
depends = depends + text
for name in self.PYFILES:
text = '$(TARGETDIR)\\%s.py : %s.py\n' % \
tuple([os.path.splitext(name)[0]] * 2)
depends = depends + text
if self.OTHERDEPS:
for name in self.SOURCES:
name = os.path.basename(name)
text = '%s%s : %s\n' % \
(os.path.splitext(name)[0], self.OBJEXT, self.OTHERDEPS)
depends = depends + text
self.DEPENDS = swapslash(depends)
# and the list of .py files
pymodules = ""
bldpymodules = ""
for name in self.SWIGFILES:
pymodules = pymodules + '$(TARGETDIR)\\%s.py ' % os.path.splitext(name)[0]
bldpymodules = bldpymodules + '$(BUILDDIR)\\%s.py ' % os.path.splitext(name)[0]
for name in self.PYFILES:
pymodules = pymodules + '$(TARGETDIR)\\%s.py ' % os.path.splitext(name)[0]
bldpymodules = bldpymodules + '$(BUILDDIR)\\%s.py ' % os.path.splitext(name)[0]
self.PYMODULES = splitlines(swapslash(pymodules))
self.BLDPYMODULES = splitlines(swapslash(bldpymodules))
# now make a list of the python files that would need cleaned up
pycleanup = ""
for name in self.SWIGFILES:
pycleanup = pycleanup + self.makeCleanupList(name)
for name in self.PYFILES:
pycleanup = pycleanup + self.makeCleanupList(name)
self.PYCLEANUP = swapslash(pycleanup)
# now make a list of the python files that would need uninstalled
pyUninstall = ""
for name in self.SWIGFILES:
pyUninstall = pyUninstall + self.makeUninstallList(name)
for name in self.PYFILES:
pyUninstall = pyUninstall + self.makeUninstallList(name)
self.PYUNINSTALL = swapslash(pyUninstall)
# finally, build the makefile
if sys.platform == 'win32':
if self.RESFILE:
self.RESFILE = '$(MODULE).res'
self.RESRULE = '$(MODULE).res : $(MODULE).rc $(WXDIR)\\include\\wx\\msw\\wx.rc\n\t'\
'$(rc) -r /i$(WXDIR)\\include -fo$@ $(MODULE).rc'
text = win32Template % self.__dict__
else:
text = unixTemplate % self.__dict__
f = open(self.MAKEFILE, 'w')
f.write(text)
f.close()
print "Makefile created: ", self.MAKEFILE
#------------------------------------------------------------
def makeUninstallList(self, name):
st = ""
st = st + '\t%s$(TARGETDIR)\\%s.py\n' % (self.RMCMD, os.path.splitext(name)[0])
st = st + '\t%s$(TARGETDIR)\\%s.pyc\n' % (self.RMCMD, os.path.splitext(name)[0])
st = st + '\t%s$(TARGETDIR)\\%s.pyo\n' % (self.RMCMD, os.path.splitext(name)[0])
return st
#------------------------------------------------------------
def makeCleanupList(self, name):
st = ""
st = st + '\t%s$(BUILDDIR)\\%s.py\n' % (self.RMCMD, os.path.splitext(name)[0])
st = st + '\t%s$(BUILDDIR)\\%s.pyc\n' % (self.RMCMD, os.path.splitext(name)[0])
st = st + '\t%s$(BUILDDIR)\\%s.pyo\n' % (self.RMCMD, os.path.splitext(name)[0])
return st
#------------------------------------------------------------
def readConfigFiles(self, args):
return self.processFile(self.bldCfg, 1) and \
self.processFile(os.path.join('../..', self.bldCfgLocal)) and \
self.processFile(os.path.join('..', self.bldCfgLocal)) and \
self.processFile(os.path.join('.', self.bldCfgLocal)) and \
self.processArgs(args)
#------------------------------------------------------------
def processFile(self, filename, required=0):
try:
text = open(filename, 'r').read()
except IOError:
if required:
print "Unable to open %s" % filename
return 0
else:
return 1
try:
exec(text, self.__dict__)
except:
print "Error evaluating %s" % filename
import traceback
traceback.print_exc()
return 0
return 1
#------------------------------------------------------------
def processArgs(self, args):
try:
for st in args:
pair = string.split(st, '=')
name = pair[0]
value = string.join(pair[1:], '=')
self.__dict__[name] = value
except:
print "Error parsing command-line: %s" % st
return 0
return 1
#------------------------------------------------------------
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
win32Template = '''
#----------------------------------------------------------------------
# This makefile was autogenerated from build.py. Your changes will be
# lost if the generator is run again. You have been warned.
#----------------------------------------------------------------------
WXDIR = %(WXDIR)s
VERSION = %(VERSION)s
MAJVER = %(MAJVER)s
BLDVER = %(BLDVER)s
MODULE = %(MODULE)s
SWIGFLAGS = %(SWIGFLAGS)s %(SWIGTOOLKITFLAG)s %(OTHERSWIGFLAGS)s
CFLAGS = %(CFLAGS)s
LFLAGS = %(LFLAGS)s
PYVERSION = %(PYVERSION)s
PYPREFIX = %(PYPREFIX)s
EXECPREFIX = %(EXECPREFIX)s
PYTHONLIB = %(PYTHONLIB)s
FINAL = %(FINAL)s
WXP_USE_THREAD = %(WXP_USE_THREAD)s
WXUSINGDLL = %(WXUSINGDLL)s
GENCODEDIR = %(GENCODEDIR)s
RESFILE = %(RESFILE)s
WXPSRCDIR = %(WXPSRCDIR)s
%(OTHERDEFS)s
WXPYDIR = %(WXPYDIR)s
BUILDDIR = $(WXPYDIR)\\wxPython
TARGETDIR = %(TARGETDIR)s
OBJECTS = %(OBJECTS)s
PYMODULES = %(PYMODULES)s
BLDPYMODULES = %(BLDPYMODULES)s
TARGET = %(TARGET)s
!if "$(FINAL)" == "0"
DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES
!else
DEBUGLFLAGS = /INCREMENTAL:NO
!endif
!if "$(WXP_USE_THREAD)" == "1"
THREAD=-DWXP_USE_THREAD=1
!endif
NOPCH=1
OVERRIDEFLAGS=%(OVERRIDEFLAGS)s
EXTRAFLAGS = $(CFLAGS) %(OTHERCFLAGS)s
LFLAGS = %(LFLAGS)s %(OTHERLFLAGS)s
EXTRALIBS = %(LIBS)s %(OTHERLIBS)s
CRTFLAG=%(CRTFLAG)s
#----------------------------------------------------------------------
!include $(WXDIR)\\src\\makevc.env
#----------------------------------------------------------------------
%(DEFAULTRULE)s %(OTHERTARGETS)s
install: default $(TARGETDIR) $(TARGETDIR)\\$(TARGET) pycfiles %(OTHERINSTALLTARGETS)s
clean:
-erase *.obj
-erase *.exe
-erase *.res
-erase *.map
-erase *.sbr
-erase *.pdb
-erase *.pch
-erase $(MODULE).exp
-erase $(MODULE).lib
-erase $(MODULE).ilk
-erase $(TARGET)
-erase $(BUILDDIR)\$(TARGET)
%(PYCLEANUP)s
uninstall: %(OTHERUNINSTALLTARGETS)s
-erase $(TARGETDIR)\\$(TARGET)
%(PYUNINSTALL)s
#----------------------------------------------------------------------
# implicit rule for compiling .cpp and .c files
{}.cpp{}.obj:
$(cc) @<<
$(CPPFLAGS) /c /Tp $<
<<
{$(GENCODEDIR)}.cpp{}.obj:
$(cc) @<<
$(CPPFLAGS) /c /Tp $<
<<
{}.c{}.obj:
$(cc) @<<
$(CPPFLAGS) /c $<
<<
.SUFFIXES : .i .py
# Implicit rules to run SWIG
{}.i{$(GENCODEDIR)}.cpp:
swig $(SWIGFLAGS) -c -o $@ $<
{}.i{$(GENCODEDIR)}.py:
swig $(SWIGFLAGS) -c -o $(GENCODEDIR)\\tmp_wrap.cpp $<
-erase $(GENCODEDIR)\\tmp_wrap.cpp
{$(GENCODEDIR)}.py{$(TARGETDIR)}.py:
copy $< $@
{}.py{$(TARGETDIR)}.py:
copy $< $@
{$(GENCODEDIR)}.py{$(BUILDDIR)}.py:
copy $< $@
{}.py{$(BUILDDIR)}.py:
copy $< $@
#----------------------------------------------------------------------
$(TARGET) : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(RESFILE)
$(link) @<<
/out:$@
$(LFLAGS) /export:init$(MODULE) /implib:./$(MODULE).lib
$(DUMMYOBJ) $(OBJECTS) $(RESFILE)
$(LIBS)
<<
%(RESRULE)s
$(TARGETDIR)\\$(TARGET) : $(TARGET)
copy $(TARGET) $@
$(BUILDDIR)\\$(TARGET) : $(TARGET)
copy $(TARGET) $@
pycfiles : $(PYMODULES)
$(EXECPREFIX)\\python $(PYPREFIX)\\Lib\\compileall.py -l $(TARGETDIR)
$(EXECPREFIX)\\python -O $(PYPREFIX)\Lib\\compileall.py -l $(TARGETDIR)
bldpycfiles : $(BLDPYMODULES)
$(TARGETDIR) :
mkdir $(TARGETDIR)
$(GENCODEDIR):
mkdir $(GENCODEDIR)
#----------------------------------------------------------------------
%(DEPENDS)s
#----------------------------------------------------------------------
showflags:
@echo CPPFLAGS:
@echo $(CPPFLAGS)
@echo LFLAGS:
@echo $(LFLAGS)
@echo BUILDDIR:
@echo $(BUILDDIR)
%(OTHERRULES)s
'''
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
unixTemplate = '''
#----------------------------------------------------------------------
# This makefile was autogenerated from build.py. Your changes will be
# lost if the generator is run again. You have been warned.
#----------------------------------------------------------------------
WXDIR = %(WXDIR)s
VERSION = %(VERSION)s
MAJVER = %(MAJVER)s
BLDVER = %(BLDVER)s
MODULE = %(MODULE)s
SWIGFLAGS = %(SWIGFLAGS)s %(SWIGTOOLKITFLAG)s %(OTHERSWIGFLAGS)s
CFLAGS = %(CFLAGS)s $(OPT) %(OTHERCFLAGS)s
LFLAGS = %(LFLAGS)s %(OTHERLFLAGS)s
PYVERSION = %(PYVERSION)s
PYPREFIX = %(PYPREFIX)s
EXECPREFIX = %(EXECPREFIX)s
PYINCLUDE = $(PYPREFIX)/include/python$(PYVERSION)
EXECINCLUDE = $(EXECPREFIX)/include/python$(PYVERSION)
PYLIB = %(PYLIB)s
LIBPL = %(LIBPL)s
PYTHONLIB = %(PYTHONLIB)s
FINAL = %(FINAL)s
WXP_USE_THREAD = %(WXP_USE_THREAD)s
GENCODEDIR = %(GENCODEDIR)s
WXPSRCDIR = %(WXPSRCDIR)s
HELPERLIB = %(HELPERLIB)s
HELPERLIBDIR = %(HELPERLIBDIR)s
WXCONFIG=%(WXCONFIG)s
WXPYDIR = %(WXPYDIR)s
BUILDDIR = $(WXPYDIR)/wxPython
TARGETDIR = %(TARGETDIR)s
%(OTHERDEFS)s
CCC = %(CCC)s
CC = %(CC)s
OPT = %(OPT)s
SO = %(SO)s
LDSHARED = %(LDSHARED)s
CCSHARED = %(CCSHARED)s
OBJECTS = %(OBJECTS)s
PYMODULES = %(PYMODULES)s
BLDPYMODULES = %(BLDPYMODULES)s
TARGET = %(TARGET)s
ifeq ($(WXP_USE_THREAD), 1)
THREAD=-DWXP_USE_THREAD
endif
USE_SONAME = %(USE_SONAME)s
ifeq ($(USE_SONAME), 1)
LIBS = -l$(HELPERLIB) %(OTHERLIBS)s
else
LIBS = $(WXPSRCDIR)/lib$(HELPERLIB)$(SO) %(OTHERLIBS)s
endif
#----------------------------------------------------------------------
%(DEFAULTRULE)s %(OTHERTARGETS)s
install: default $(TARGETDIR) $(TARGETDIR)/$(TARGET) pycfiles %(OTHERINSTALLTARGETS)s
clean:
-rm -f *.o *$(SO) *$(SO).* *~
-rm -f $(TARGET)
-rm -f $(BUILDDIR)/$(TARGET)
%(PYCLEANUP)s
uninstall: %(OTHERUNINSTALLTARGETS)s
-rm -f $(TARGETDIR)/$(TARGET)
%(PYUNINSTALL)s
#----------------------------------------------------------------------
%%.o : %%.cpp
$(CCC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
%%.o : $(GENCODEDIR)/%%.cpp
$(CCC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
%%.o : %%.c
$(CC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
%%.o : $(GENCODEDIR)/%%.c
$(CC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
ifndef NOSWIG
$(GENCODEDIR)/%%.cpp : %%.i
swig $(SWIGFLAGS) -c -o $@ $<
$(GENCODEDIR)/%%.py : %%.i
swig $(SWIGFLAGS) -c -o $(GENCODEDIR)/tmp_wrap.cpp $<
rm $(GENCODEDIR)/tmp_wrap.cpp
endif
$(TARGETDIR)/%% : %%
cp -f $< $@
$(TARGETDIR)/$(TARGET) : $(TARGET)
cp -f $< $@
strip $@
$(TARGETDIR)/%% : $(GENCODEDIR)/%%
cp -f $< $@
$(BUILDDIR)/%% : %%
cp -f $< $@
$(BUILDDIR)/%% : $(GENCODEDIR)/%%
cp -f $< $@
#----------------------------------------------------------------------
%(DEPENDS)s
#----------------------------------------------------------------------
$(TARGET) : $(OBJECTS)
$(LDSHARED) $(OBJECTS) $(LFLAGS) $(LIBS) $(OTHERLIBS) -o $(TARGET)
pycfiles : $(PYMODULES)
$(EXECPREFIX)/bin/python $(PYLIB)/compileall.py -l $(TARGETDIR)
$(EXECPREFIX)/bin/python -O $(PYLIB)/compileall.py -l $(TARGETDIR)
bldpycfiles : $(BLDPYMODULES)
$(TARGETDIR) :
mkdir -p $(TARGETDIR)
$(GENCODEDIR):
mkdir $(GENCODEDIR)
#----------------------------------------------------------------------
%(OTHERRULES)s
'''
#----------------------------------------------------------------------------
if __name__ == '__main__':
err = main(sys.argv)
sys.exit(err)
#----------------------------------------------------------------------------

33
wxPython/distrib/makedbg.bat Executable file
View File

@@ -0,0 +1,33 @@
@echo off
rem Builds a zip containing debugging versions of wxWindows and wxPython
rem that could be unziped over a wxPython installation.
setlocal
iff "%1" == "15" then
set PCBUILD=c:\projects\Python-1.5.2\PCBuild
elseiff "%1" == "20" then
set PCBUILD=c:\projects\Python-2.0\PCBuild
else
echo Specivy Python version!!!
goto end
endiff
iff "%2" == "" then
echo Specify wxPython version!!!
goto end
endiff
mkdir wxPython-dbg
copy README.dbg.txt wxPython-dbg
copy %WXWIN%\lib\wx*d.dll wxPython-dbg
copy %WXWIN%\wxPython\wxPython\*_d.pyd wxPython-dbg
copy %PCBUILD%\python_d.exe wxPython-dbg
copy %PCBUILD%\python%1_d.dll wxPython-dbg
zip -r wxPython-dbg-%2-Py%1.zip wxPython-dbg
del /sx wxPython-dbg
:end

36
wxPython/distrib/makedemo Executable file
View File

@@ -0,0 +1,36 @@
#!/bin/bash
#----------------------------------------------------------------------
if [ -z $1 ]; then
echo "Please specify a version number on the command line."
exit 1
fi
if [ ! -d wxPython ]; then
echo "Please run this script from the root wxPython directory."
exit 1
fi
mkdir _distrib_tgz
mkdir _distrib_tgz/wxPython-$1
cp -R demo _distrib_tgz/wxPython-$1
# do some cleanup
rm -rf `find _distrib_tgz/wxPython-$1 -name CVS`
rm -f `find _distrib_tgz/wxPython-$1 -name "*.pyc"`
rm -f `find _distrib_tgz/wxPython-$1 -name .cvsignore`
rm -f _distrib_tgz/wxPython-$1/demo/core
rm -rf _distrib_tgz/wxPython-$1/demo/wxPython
cd _distrib_tgz
tar cvf ../dist/wxPython-demo-$1.tar wxPython-$1
gzip ../dist/wxPython-demo-$1.tar
cd ..
rm -r _distrib_tgz

41
wxPython/distrib/makedev.bat Executable file
View File

@@ -0,0 +1,41 @@
@echo off
rem Builds a zip containing stuff needed to link with the wxWindows DLL
rem shipped with wxPython. This allows other developers to create apps
rem or extensions that can share the same DLL.
mkdir wxWin
mkdir wxWin\lib
copy %WXWIN%\lib\*.lib wxWin\lib
del wxWin\lib\*_d.lib
mkdir wxWin\src
copy %WXWIN%\src\makevc.env wxWin\src
copy %WXWIN%\src\*.vc wxWin\src
mkdir wxWin\src\msw
mkdir wxWin\src\msw\ReleaseDLL
copy %WXWIN%\src\msw\*.pch wxWin\src\msw
del wxWin\src\msw\*_d.pch
copy %WXWIN%\src\msw\ReleaseDLL\dummy*.obj wxWin\src\msw\ReleaseDLL
mkdir wxWin\include
mkdir wxWin\include\wx
mkdir wxWin\include\wx\msw
mkdir wxWin\include\wx\generic
mkdir wxWin\include\wx\html
mkdir wxWin\include\wx\protocol
copy %WXWIN%\include\wx\*.* wxWin\include\wx
copy /s %WXWIN%\include\wx\msw\* wxWin\include\wx\msw
copy /s %WXWIN%\include\wx\generic\* wxWin\include\wx\generic
copy /s %WXWIN%\include\wx\html\* wxWin\include\wx\html
copy /s %WXWIN%\include\wx\protocol\* wxWin\include\wx\protocol
zip -r wxPython-dev-%1.zip wxWin
del /sx wxWin

47
wxPython/distrib/makerpm Executable file
View File

@@ -0,0 +1,47 @@
#!/bin/bash
if [ -z $1 ]; then
echo "Please specify a version number on the command line."
exit 1
fi
if [ ! -f wxPython.spec ]; then
echo "Please run this script from the directory containing the wxPython.spec file."
exit 1
fi
#strip /usr/lib/python1.5/site-packages/wxPython/*.so
#strip /usr/lib/libwxPyHelpers.so
#
#cat wxPython.spec.in | sed s/__VERSION__/$1/g > wxPython.spec
#
#mkdir /usr/doc/wxPython-$1
#cp ../README.txt /usr/doc/wxPython-$1
#cp ../../../docs/preamble.txt /usr/doc/wxPython-$1
#cp ../../../docs/licence.txt /usr/doc/wxPython-$1
#cp ../../../docs/licendoc.txt /usr/doc/wxPython-$1
#cp ../../../docs/lgpl.txt /usr/doc/wxPython-$1
#cp ../../../docs/gpl.txt /usr/doc/wxPython-$1
#
#rpm -bb wxPython.spec
#
#mv /usr/src/redhat/RPMS/*/wxPython*.rpm .
#chown rd:users wxPython*.rpm
#
#rm -r /usr/doc/wxPython-$1
cp -f wxPython-$1.tar.gz /usr/src/redhat/SOURCES
rpm -ba wxPython.spec
mv /usr/src/redhat/RPMS/*/wxPython*.rpm .
mv /usr/src/redhat/SRPMS/wxPython*.rpm .
chown rd:users wxPython*.rpm
rm -rf /usr/lib/python1.5/site-packages/wxPython/
rm -f /usr/lib/libwxPyHelpers*
rm -rf /usr/doc/wxPython-$1

62
wxPython/distrib/maketgz Executable file
View File

@@ -0,0 +1,62 @@
#!/bin/bash
#----------------------------------------------------------------------
# Make a source distribution as a tar.gz file. This script should be
# run from the directory that holds the wxPython dir (../..) and be
# given a version number as an parameter. The best way to do this is
# run "make dist" in the wxPython/src/ directory.
#----------------------------------------------------------------------
if [ -z $1 ]; then
echo "Please specify a version number on the command line."
exit 1
fi
if [ ! -d wxPython ]; then
echo "Please run this script from the root wxPython directory."
exit 1
fi
mkdir _distrib_tgz
mkdir _distrib_tgz/wxPython-$1
# Copy license files
cp $WXWIN/docs/gpl.txt _distrib_tgz/wxPython-$1
cp $WXWIN/docs/lgpl.txt _distrib_tgz/wxPython-$1
cp $WXWIN/docs/licence.txt _distrib_tgz/wxPython-$1
cp $WXWIN/docs/licendoc.txt _distrib_tgz/wxPython-$1
cp $WXWIN/docs/preamble.txt _distrib_tgz/wxPython-$1
# Copy files from the live dirs
# first, get a list of files
for x in `cat distrib/wxPython.rsp`; do
ls $x >> _distrib_tgz/filelist
done
# and make a tar file containing those files
tar cf _distrib_tgz/dist-temp.tar -T _distrib_tgz/filelist
# now untar it in the right place
cd _distrib_tgz/wxPython-$1
tar xf ../dist-temp.tar
cd ..
# update a few things
rm wxPython-$1/src/gtk/helpers.cpp
touch `find wxPython-$1 -name "*.cpp"`
touch `find wxPython-$1 -name "*.py"`
# Finally, make the finished tar file
tar cvf ../distrib/wxPython-$1.tar wxPython-$1
gzip ../distrib/wxPython-$1.tar
cd ..
rm -rf _distrib_tgz

10
wxPython/distrib/makexferzip Executable file
View File

@@ -0,0 +1,10 @@
#!/bin/bash
cd ~/wx/utils/wxPython
find . -name "*.py" > filelist
find . -name "*.i" >> filelist
find . -name "*.h" >> filelist
find . -name "*.cpp" >> filelist
cat filelist | zip -r -u -@ xfer.zip

9
wxPython/distrib/makexferzip.bat Executable file
View File

@@ -0,0 +1,9 @@
cd %WXWIN%\utils\wxPython
find . -name "*.py" > filelist
find . -name "*.i" >> filelist
find . -name "*.h" >> filelist
find . -name "*.cpp" >> filelist
cat filelist | zip -r -u -@ xfer.zip

7
wxPython/distrib/wise.aut Normal file
View File

@@ -0,0 +1,7 @@
run, c:\\Tools\\Wise\\WISE32.EXE wxPython.wse
winwaitactive, wxPython.wse - Wise Installation System
send, !ic
sleep, 1000
winwaitactive, wxPython.wse - Wise Installation System
send, !fx

BIN
wxPython/distrib/wxPython.WSM Normal file
View File

Binary file not shown.

BIN
wxPython/distrib/wxPython.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 128 KiB

106
wxPython/distrib/wxPython.rsp Normal file
View File

@@ -0,0 +1,106 @@
*.txt
demo/*.py
demo/bitmaps/*.bmp
demo/bitmaps/*.ico
demo/bitmaps/*.gif
demo/bitmaps/*.png
demo/bitmaps/*.jpg
demo/README.txt
demo/*.xml
demo/data/*.png
demo/data/*.htm
demo/data/*.html
demo/data/*.bmp
demo/data/*.txt
demo/data/*.i
demo/data/*.h
distrib/build.py
distrib/wxPython.spec
wxPython/lib/*.py
wxPython/lib/*.txt
wxPython/lib/sizers/*.py
wxPython/lib/sizers/*.txt
wxPython/lib/editor/*.py
wxPython/lib/editor/*.txt
src/build.cfg
src/*.i
src/*.py
src/*.cpp
src/*.c
src/*.h
src/*.ico
src/*.def
src/*.rc
src/msw/*.cpp
src/msw/*.h
src/msw/*.py
src/gtk/*.cpp
src/gtk/*.h
src/gtk/*.py
src/motif/*.cpp
src/motif/*.h
src/motif/*.py
contrib/glcanvas/build.cfg
contrib/glcanvas/*.i
contrib/glcanvas/*.py
contrib/glcanvas/*.cpp
contrib/glcanvas/*.c
contrib/glcanvas/*.h
contrib/glcanvas/*.def
contrib/glcanvas/*.rc
contrib/glcanvas/msw/*.cpp
contrib/glcanvas/msw/*.h
contrib/glcanvas/msw/*.py
contrib/glcanvas/gtk/*.cpp
contrib/glcanvas/gtk/*.h
contrib/glcanvas/gtk/*.py
contrib/ogl/build.cfg
contrib/ogl/*.txt
contrib/ogl/*.i
contrib/ogl/*.py
contrib/ogl/*.cpp
contrib/ogl/*.c
contrib/ogl/*.h
contrib/ogl/*.def
contrib/ogl/*.rc
contrib/ogl/contrib/include/wx/ogl/*.h
contrib/ogl/contrib/src/ogl/*.cpp
contrib/stc/build.cfg
contrib/stc/*.txt
contrib/stc/*.i
contrib/stc/*.py
contrib/stc/*.cpp
contrib/stc/*.c
contrib/stc/*.h
contrib/stc/*.def
contrib/stc/*.rc
contrib/stc/*.cpp
contrib/stc/*.h
contrib/stc/*.py
contrib/stc/contrib/include/wx/stc/*.h
contrib/stc/contrib/src/stc/*.h
contrib/stc/contrib/src/stc/*.cpp
contrib/stc/contrib/src/stc/*.txt
contrib/stc/contrib/src/stc/*.py
contrib/stc/contrib/src/stc/scintilla/include/*.h
contrib/stc/contrib/src/stc/scintilla/include/*.iface
contrib/stc/contrib/src/stc/scintilla/src/*.h
contrib/stc/contrib/src/stc/scintilla/src/*.cxx

101
wxPython/distrib/wxPython.spec Normal file
View File

@@ -0,0 +1,101 @@
%define pref /usr
%define ver 2.2.2
%define rpmver 0
Summary: Cross platform GUI toolkit for use with the Python language.
Name: wxPython
Version: %{ver}
Release: %{rpmver}
Copyright: wxWindows License
Group: Development/Languages/Python
Source: wxPython-%{ver}.tar.gz
Packager: Robin Dunn <robin@alldunn.com>
URL:http://alldunn.com/wxPython/index.html
Vendor: Total Control Software
Requires: python >= 1.5.2
##BuildRoot: /tmp/wxPython-build
##Prefix: /usr/lib/python1.5/site-packages
Prefix: %{pref}
%description
wxPython is a GUI toolkit for Python that is a wrapper around the
wxWindows C++ GUI library. wxPython provides a large variety of
window types and controls, all imlemented with a native look and
feel (and runtime speed) on the platforms it is supported on.
%package gl
Summary: Cross platform GUI toolkit for use with the Python language, OpenGL addon.
Group: Development/Languages/Python
Requires: wxPython
%description gl
OpenGL add on for wxPython.
#----------------------------------------------------------------------
%prep
%setup
%build
NOSWIG=1
export NOSWIG
cd src
python ../distrib/build.py -b WXPSRCDIR=$PWD USE_SONAME=1
cd ../contrib/ogl
python ../../distrib/build.py -b WXPSRCDIR=../../src USE_SONAME=1
cd ../stc
python ../../distrib/build.py -b WXPSRCDIR=../../src USE_SONAME=1
if [ -z $NOGLCANVAS ]; then
cd ../glcanvas
python ../../distrib/build.py -b WXPSRCDIR=../../src USE_SONAME=1
fi
#----------------------------------------------------------------------
%install
NOSWIG=1
export NOSWIG
cd src
python ../distrib/build.py -i
cd ../contrib/ogl
python ../../distrib/build.py -i
cd ../stc
python ../../distrib/build.py -i
if [ -z $NOGLCANVAS ]; then
cd ../glcanvas
python ../../distrib/build.py -i
fi
#----------------------------------------------------------------------
%post
/sbin/ldconfig
%postun
/sbin/ldconfig
#----------------------------------------------------------------------
%files
%doc BUILD.txt CHANGES.txt README.txt gpl.txt lgpl.txt licence.txt licendoc.txt preamble.txt
%{pref}/lib/libwxPyHelpers*
%{pref}/lib/python1.5/site-packages/wxPython/*.py
%{pref}/lib/python1.5/site-packages/wxPython/*.py?
%{pref}/lib/python1.5/site-packages/wxPython/lib
%{pref}/lib/python1.5/site-packages/wxPython/demo
%{pref}/lib/python1.5/site-packages/wxPython/wxcmodule.so
%{pref}/lib/python1.5/site-packages/wxPython/oglcmodule.so
%{pref}/lib/python1.5/site-packages/wxPython/stc_cmodule.so
%files gl
%{pref}/lib/python1.5/site-packages/wxPython/glcanvascmodule.so

1364
wxPython/distrib/wxPython.wse Normal file
View File

File diff suppressed because it is too large Load Diff

46
wxPython/distrib/zipit.bat Executable file
View File

@@ -0,0 +1,46 @@
@echo off
rem **** Make a directory to build up a distribution tree
md _distrib_zip
md _distrib_zip\wxPython-%1
REM rem **** Copy the license files
REM copy %WXWIN%\docs\gpl.txt _distrib_zip\wxPython-%1
REM copy %WXWIN%\docs\lgpl.txt _distrib_zip\wxPython-%1
REM copy %WXWIN%\docs\licence.txt _distrib_zip\wxPython-%1
REM copy %WXWIN%\docs\licendoc.txt _distrib_zip\wxPython-%1
REM copy %WXWIN%\docs\preamble.txt _distrib_zip\wxPython-%1
REM rem **** Make a zip fron the live files
REM zip -@ -r _distrib_zip\temp.zip < distrib\wxPython.rsp
REM rem **** Unzip it in our build dir
REM cd _distrib_zip\wxPython-%1
REM unzip ..\temp.zip
REM rem **** zip up the build dir
REM cd ..
REM zip -r ..\distrib\wxPython-src-%1.zip wxPython-%1
cd _distrib_zip
rem **** copy the docs into the tree
md wxPython-%1\docs
md wxPython-%1\docs\wx
md wxPython-%1\docs\ogl
copy %WXWIN%\docs\html\wx\*.gif wxPython-%1\docs\wx
copy %WXWIN%\docs\html\wx\*.htm wxPython-%1\docs\wx
copy wxPython-%1\docs\wx\wx.htm wxPython-%1\docs\wx\index.htm
copy %WXWIN%\docs\html\ogl\*.gif wxPython-%1\docs\ogl
copy %WXWIN%\docs\html\ogl\*.htm wxPython-%1\docs\ogl
copy wxPython-%1\docs\ogl\ogl.htm wxPython-%1\docs\ogl\index.htm
rem **** zip up the docs
rem zip -r ..\distrib\wxPython-docs-%1.zip wxPython-%1\docs
tar cvf ..\distrib\wxPython-docs-%1.tar wxPython-%1
gzip -9 ..\distrib\wxPython-docs-%1.tar
rem **** Cleanup
cd ..
del /sxzy _distrib_zip