# This script generates the PyTQt configuration and generates the Makefiles.
#
# Copyright (c) 2007
# Riverbank Computing Limited <info@riverbankcomputing.co.uk>
#
# This file is part of PyTQt.
#
# This copy of PyTQt is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 2, or (at your option) any later
# version.
#
# PyTQt is supplied in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# PyTQt; see the file LICENSE. If not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
import sys
import os
import string
import glob
import getopt
import shutil
import py_compile
from sip4_tqt import sipconfig
src_dir = os . path . dirname ( os . path . abspath ( __file__ ) )
# Initialise the globals.
pyqt_version = 0x031201
pyqt_version_str = " 3.18.1 "
sip_min_version = 0x040800
# Try and find a TQt installation to use as the default.
try :
qt_dir = os . environ [ " QTDIR " ]
except KeyError :
qt_dir = " "
qt_version = 0
qt_edition = " "
qt_incdir = None
qt_libdir = None
qt_threaded = 0
qt_winconfig = " "
pyqt = None
pyqt_modules = [ ]
qt_sip_flags = [ ]
qtext_sip_flags = [ ]
qtpe_sip_flags = [ ]
qsci_version = 0
disabled_classes = [ ]
if sys . platform == " win32 " :
qsci_define = " TQEXTSCINTILLA_DLL "
else :
qsci_define = " "
# Get the SIP configuration.
sipcfg = sipconfig . Configuration ( )
# Command line options.
opt_qtlib = None
opt_qconfigdir = None
opt_pyqtbindir = sipcfg . default_bin_dir
opt_pyqtmoddir = os . path . join ( sipcfg . default_mod_dir , " python_tqt " )
opt_pyqtsipdir = sipcfg . default_sip_dir
opt_qtpetag = None
opt_qsciincdir = None
opt_qscilibdir = None
opt_static = 0
opt_debug = 0
opt_concat = 0
opt_split = 1
opt_tracing = 0
opt_verbose = 0
opt_keepfeatures = 0
opt_vendorcheck = 0
opt_vendincdir = sipcfg . py_inc_dir
opt_vendlibdir = sipcfg . py_lib_dir
def usage ( rcode = 2 ) :
""" Display a usage message and exit.
rcode is the return code passed back to the calling process .
"""
if qt_dir :
def_qt_dir = qt_dir
else :
def_qt_dir = " none "
sys . stdout . write ( " Usage: \n " )
sys . stdout . write ( " python configure.py [-h] [-a tag] [-b dir] [-c] [-d dir] [-e lib] [-f] [-g dir] [-i] [-j #] [-k] [-l dir] [-m dir] [-n dir] [-o dir] [-q dir] [-r] [-s] [-u] [-v dir] [-w] [-y lib] option=value option+=value ... \n " )
sys . stdout . write ( " where: \n " )
sys . stdout . write ( " -h display this help message \n " )
sys . stdout . write ( " -a tag explicitly enable the qtpe module \n " )
sys . stdout . write ( " -b dir where pyuic and pylupdate will be installed [default %s ] \n " % opt_pyqtbindir )
sys . stdout . write ( " -c concatenate each module ' s C/C++ source files \n " )
sys . stdout . write ( " -d dir where the PyTQt modules will be installed [default %s ] \n " % opt_pyqtmoddir )
sys . stdout . write ( " -e lib explicitly specify the python library \n " )
sys . stdout . write ( " -f keep any existing features file (when cross-compiling) [default remove] \n " )
sys . stdout . write ( " -g dir where the TQt qconfig.h file can be found [default TQt include directory] \n " )
sys . stdout . write ( " -i enable checking of signed interpreters using the VendorID package [default disabled] \n " )
sys . stdout . write ( " -j # split the concatenated C++ source files into # pieces [default 1] \n " )
sys . stdout . write ( " -k build the PyTQt modules as static libraries \n " )
sys . stdout . write ( " -l dir the directory containing the VendorID header file [default %s ] \n " % opt_vendincdir )
sys . stdout . write ( " -m dir the directory containing the VendorID library [default %s ] \n " % opt_vendlibdir )
sys . stdout . write ( " -n dir the directory containing the TQScintilla header files [default TQt include directory] \n " )
sys . stdout . write ( " -o dir the directory containing the TQScintilla library [default TQt lib directory] \n " )
sys . stdout . write ( " -q dir the root directory of the TQt installation [default %s ] \n " % def_qt_dir )
sys . stdout . write ( " -r generate code with tracing enabled [default disabled] \n " )
sys . stdout . write ( " -s TQScintilla is a static library and not a DLL (Windows only) \n " )
sys . stdout . write ( " -u build with debugging symbols (requires a debug build of Python on Windows \n " )
sys . stdout . write ( " -v dir where the PyTQt .sip files will be installed [default %s ] \n " % opt_pyqtsipdir )
sys . stdout . write ( " -w don ' t suppress compiler output during configuration \n " )
sys . stdout . write ( " -y lib explicitly specify the type of TQt library, either qt, qt-mt, qte, qte-mt, qtmt, tqt, tqt-mt, tqte, tqte-mt or tqtmt \n " )
sys . exit ( rcode )
class ConfigureBase :
""" This is the base class for all PyTQt version specific configurer classes.
Anything here is common to all configurers .
"""
def check_modules ( self ) :
""" Check which modules should be built and add them to the global list.
Returns the name of any additional library that needs to be linked with
the main module .
"""
return None
def sip_flags ( self ) :
""" Get the configuration specific SIP flags.
Returns a list of flags .
"""
return [ ]
def qt_version_tags ( self ) :
""" Get the versions tags for the configuration.
Returns a dictionary of versions and corresponding tags .
"""
return { }
def code ( self , extra_include_dirs , extra_lib_dir , extra_libs ) :
""" Generate the code for a configuration.
extra_include_dirs is a list of directories to add to those supplied by
the SIP configuration .
extra_lib_dir is an optional directory to add to those supplied by the
SIP configuration .
extra_lib_dirs is an optional list of directories to add to those
supplied by the SIP configuration .
"""
pass
def tools ( self ) :
""" Create the Makefiles for any other sub-directories and return a list
of those directories .
Returns a list of sub - directories with Makefile .
"""
return [ ]
def module_dir ( self ) :
""" Return the configuration ' s module directory.
"""
return opt_pyqtmoddir
def module_installs ( self ) :
""" Return a list of files to install in the module directory other than
the modules themselves .
"""
return [ " __init__.py " , " pyqtconfig.py " ]
def sip_dir ( self ) :
""" Return the configuration ' s .sip files directory.
"""
return opt_pyqtsipdir
class ConfigurePyTQt3 ( ConfigureBase ) :
""" This class defines the methods to configure PyTQt v3.
"""
def check_modules ( self ) :
pyqt_modules . append ( " qt " )
check_module ( " qtcanvas " , " qcanvas.h " , " TQCanvas() " )
check_module ( " qtnetwork " , " qsocket.h " , " TQSocket() " )
check_module ( " qttable " , " qtable.h " , " TQTable() " )
check_module ( " qtxml " , " qdom.h " , " TQDomImplementation() " )
check_module ( " qtgl " , " qgl.h " , " TQGLWidget() " , opengl = 1 )
if qt_version > = 0x030000 :
check_module ( " qtui " , " qwidgetfactory.h " , " TQWidgetFactory() " , lib = " tqui " )
if qt_edition in ( " enterprise " , " free " ) :
check_module ( " qtsql " , " qsql.h " , " TQSql() " )
if sys . platform == " win32 " and sipcfg . sip_version > = 0x040200 :
check_module ( " qtaxcontainer " , " qaxobject.h " , " TQAxObject() " , lib = " qaxcontainer " )
if qsci_version :
check_module ( " qtext " , " qextscintillabase.h " , " QextScintillaBase() " , define = qsci_define , include_dir = opt_qsciincdir , lib_dir = opt_qscilibdir , lib = " qscintilla " )
if opt_qtpetag :
pyqt_modules . append ( " qtpe " )
qtmod_lib = None
if qt_version > = 0x030100 :
sipconfig . inform ( " Checking to see if the TQAssistantClient class is available... " )
if check_class ( " qassistantclient.h " , " TQAssistantClient( \" foo \" ) " , lib = " qassistantclient " ) :
qtmod_lib = " qassistantclient "
else :
if check_class ( " ntqassistantclient.h " , " TQAssistantClient( \" foo \" ) " , lib = " qassistantclient " ) :
qtmod_lib = " qassistantclient "
else :
disabled_classes . append ( " TQAssistantClient " )
return qtmod_lib
def sip_flags ( self ) :
return get_feature_flags ( )
def qt_version_tags ( self ) :
return {
0x010403 : None ,
0x020000 : " TQt_1_43 " ,
0x020100 : " TQt_2_00 " ,
0x020200 : " TQt_2_1_0 " ,
0x020300 : " TQt_2_2_0 " ,
0x020301 : " TQt_2_3_0 " ,
0x030000 : " TQt_2_3_1 " ,
0x030001 : " TQt_3_0_0 " ,
0x030002 : " TQt_3_0_1 " ,
0x030004 : " TQt_3_0_2 " ,
0x030005 : " TQt_3_0_4 " ,
0x030006 : " TQt_3_0_5 " ,
0x030100 : " TQt_3_0_6 " ,
0x030101 : " TQt_3_1_0 " ,
0x030102 : " TQt_3_1_1 " ,
0x030200 : " TQt_3_1_2 " ,
0x030300 : " TQt_3_2_0 " ,
0x030305 : " TQt_3_3_0 " ,
0x030306 : " TQt_3_3_5 " ,
0x040000 : " TQt_3_3_6 "
}
def code ( self , extra_include_dirs , extra_lib_dir , extra_libs ) :
generate_code ( " qt " , extra_include_dirs = extra_include_dirs , extra_lib_dir = extra_lib_dir , extra_libs = extra_libs )
if " qtext " in pyqt_modules :
generate_code ( " qtext " , extra_define = qsci_define , extra_include_dirs = [ opt_qsciincdir ] , extra_lib_dir = opt_qscilibdir , extra_libs = [ " qscintilla " ] + extra_libs , sip_flags = qtext_sip_flags )
if " qtgl " in pyqt_modules :
generate_code ( " qtgl " , opengl = 1 , extra_include_dirs = extra_include_dirs , extra_lib_dir = extra_lib_dir , extra_libs = extra_libs )
if " qtpe " in pyqt_modules :
generate_code ( " qtpe " , extra_include_dirs = extra_include_dirs , extra_lib_dir = extra_lib_dir , extra_libs = [ " qpe " ] + extra_libs , sip_flags = qtpe_sip_flags )
if " qtui " in pyqt_modules :
generate_code ( " qtui " , extra_include_dirs = extra_include_dirs , extra_lib_dir = extra_lib_dir , extra_libs = [ " tqui " ] + extra_libs )
if " qtaxcontainer " in pyqt_modules :
generate_code ( " qtaxcontainer " , extra_include_dirs = extra_include_dirs , extra_lib_dir = extra_lib_dir , extra_libs = [ " qaxcontainer " ] + extra_libs )
# The rest don't need special handling.
for m in ( " qtcanvas " , " qtnetwork " , " qtsql " , " qttable " , " qtxml " ) :
if m in pyqt_modules :
generate_code ( m , extra_include_dirs = extra_include_dirs , extra_lib_dir = extra_lib_dir , extra_libs = extra_libs )
def tools ( self ) :
tool_dirs = [ ]
if qt_version > = 0x030000 :
# The Professional Edition needs special handling.
prof = ( qt_edition == " professional " )
sipconfig . inform ( " Creating pyuic Makefile... " )
if prof or " qtxml " not in pyqt_modules :
buildfile = " pyuic-prof.sbf "
for xml in ( " qdom.cpp " , " qxml.cpp " ) :
shutil . copyfile ( qt_dir + " /src/xml/ " + xml , " pyuic3/ " + xml )
else :
buildfile = " pyuic.sbf "
makefile = sipconfig . ProgramMakefile (
configuration = sipcfg ,
build_file = os . path . join ( src_dir , " pyuic3 " , buildfile ) ,
dir = " pyuic3 " ,
install_dir = opt_pyqtbindir ,
console = 1 ,
qt = 1 ,
warnings = 1
)
makefile . extra_defines . append ( " UIC " )
makefile . extra_defines . append ( " QT_INTERNAL_XML " )
if prof or " qtxml " not in pyqt_modules :
makefile . extra_defines . append ( " TQT_MODULE_XML " )
if qt_version < 0x030100 :
makefile . extra_include_dirs . append ( qt_dir + " /src/3rdparty/zlib " )
makefile . extra_include_dirs . append ( os . path . join ( src_dir , " pyuic3 " ) )
if not os . access ( " pyuic3 " , os . F_OK ) :
os . mkdir ( " pyuic3 " )
makefile . generate ( )
tool_dirs . append ( " pyuic3 " )
sipconfig . inform ( " Creating pylupdate Makefile... " )
if prof or " qtxml " not in pyqt_modules :
buildfile = " pylupdate-prof.sbf "
shutil . copyfile ( qt_dir + " /src/xml/qxml.cpp " , " pylupdate3/qxml.cpp " )
else :
buildfile = " pylupdate.sbf "
makefile = sipconfig . ProgramMakefile (
configuration = sipcfg ,
build_file = os . path . join ( src_dir , " pylupdate3 " , buildfile ) ,
dir = " pylupdate3 " ,
install_dir = opt_pyqtbindir ,
console = 1 ,
qt = 1 ,
warnings = 1
)
makefile . extra_defines . append ( " QT_INTERNAL_XML " )
if prof or " qtxml " not in pyqt_modules :
makefile . extra_defines . append ( " TQT_MODULE_XML " )
makefile . extra_include_dirs . append ( os . path . join ( src_dir , " pylupdate3 " ) )
if not os . access ( " pylupdate3 " , os . F_OK ) :
os . mkdir ( " pylupdate3 " )
makefile . generate ( )
tool_dirs . append ( " pylupdate3 " )
elif qt_version > = 0x020000 :
sipconfig . inform ( " Creating pyuic Makefile... " )
makefile = sipconfig . ProgramMakefile (
configuration = sipcfg ,
build_file = " pyuic.sbf " ,
dir = " pyuic2 " ,
install_dir = opt_pyqtbindir ,
console = 1 ,
qt = 1 ,
warnings = 1
)
makefile . extra_defines . append ( " UIC " )
makefile . extra_include_dirs . append ( qt_dir + " /src/3rdparty/zlib " )
makefile . generate ( )
tool_dirs . append ( " pyuic2 " )
return tool_dirs
def inform_user ( ) :
""" Tell the user the option values that are going to be used.
"""
if qt_edition :
edstr = qt_edition + " edition "
else :
edstr = " "
sipconfig . inform ( " TQt v %s %s is being used. " % ( sipconfig . version_to_string ( qt_version ) , edstr ) )
sipconfig . inform ( " SIP %s is being used. " % sipcfg . sip_version_str )
sipconfig . inform ( " These PyTQt modules will be built: %s . " % string . join ( pyqt_modules ) )
if disabled_classes :
sipconfig . inform ( " Support for these TQt classes has been disabled: %s . " % string . join ( disabled_classes ) )
sipconfig . inform ( " The PyTQt modules will be installed in %s . " % opt_pyqtmoddir )
sipconfig . inform ( " The PyTQt .sip files will be installed in %s . " % opt_pyqtsipdir )
sipconfig . inform ( " The TQt header files are in %s . " % qt_incdir )
sipconfig . inform ( " The %s TQt library is in %s . " % ( opt_qtlib , qt_libdir ) )
if qt_version > = 0x020000 :
sipconfig . inform ( " pyuic will be installed in %s . " % opt_pyqtbindir )
if qt_version > = 0x030000 :
sipconfig . inform ( " pylupdate will be installed in %s . " % opt_pyqtbindir )
if opt_vendorcheck :
sipconfig . inform ( " PyTQt will only be usable with signed interpreters. " )
def create_config ( module , template , macros ) :
""" Create the PyTQt configuration module so that it can be imported by build
scripts .
module is the module file name .
template is the template file name .
macros is the dictionary of platform specific build macros .
"""
sipconfig . inform ( " Creating %s ... " % module )
content = {
" pyqt_config_args " : sys . argv [ 1 : ] ,
" pyqt_version " : pyqt_version ,
" pyqt_version_str " : pyqt_version_str ,
" pyqt_bin_dir " : opt_pyqtbindir ,
" pyqt_mod_dir " : opt_pyqtmoddir ,
" pyqt_sip_dir " : opt_pyqtsipdir ,
" pyqt_modules " : pyqt_modules ,
" pyqt_qt_sip_flags " : qt_sip_flags ,
" qt_version " : qt_version ,
" qt_edition " : qt_edition ,
" qt_winconfig " : qt_winconfig ,
" qt_framework " : 0 ,
" qt_threaded " : qt_threaded ,
" qt_dir " : qt_dir ,
" qt_inc_dir " : qt_incdir ,
" qt_lib " : opt_qtlib ,
" qt_lib_dir " : qt_libdir
}
if " qtaxcontainer " in pyqt_modules :
content [ " pyqt_qtaxcontainer_sip_flags " ] = qt_sip_flags
if " qtcanvas " in pyqt_modules :
content [ " pyqt_qtcanvas_sip_flags " ] = qt_sip_flags
if " qtext " in pyqt_modules :
content [ " pyqt_qtext_sip_flags " ] = qtext_sip_flags
# These are internal.
content [ " _pyqt_qscintilla_defines " ] = qsci_define
content [ " _pyqt_qscintilla_inc_dir " ] = opt_qsciincdir
content [ " _pyqt_qscintilla_lib_dir " ] = opt_qscilibdir
if " qtgl " in pyqt_modules :
content [ " pyqt_qtgl_sip_flags " ] = qt_sip_flags
if " qtnetwork " in pyqt_modules :
content [ " pyqt_qtnetwork_sip_flags " ] = qt_sip_flags
if " qtpe " in pyqt_modules :
content [ " pyqt_qtpe_sip_flags " ] = qtpe_sip_flags
if " qtsql " in pyqt_modules :
content [ " pyqt_qtsql_sip_flags " ] = qt_sip_flags
if " qttable " in pyqt_modules :
content [ " pyqt_qttable_sip_flags " ] = qt_sip_flags
if " qtui " in pyqt_modules :
content [ " pyqt_qtui_sip_flags " ] = qt_sip_flags
if " qtxml " in pyqt_modules :
content [ " pyqt_qtxml_sip_flags " ] = qt_sip_flags
sipconfig . create_config_module ( module , template , content , macros )
def compile_qt_program ( name , define = None , include_dir = None , lib_dir = None , lib = None , opengl = 0 , python = 0 , debug = 0 ) :
""" Compile a simple TQt application.
name is the name of the single source file .
define is a name to add to the list of preprocessor defines .
include_dir is the name of a directory to add to the list of include
directories .
lib_dir is the name of a directory to add to the list of library
directories .
lib is the name of a library to add to the list of libraries .
opengl is set if the application uses OpenGL .
python is set if the application #includes Python.h.
debug is set if this is a debug build .
Returns the name of the executable suitable for running or None if it
wasn ' t created.
"""
makefile = sipconfig . ProgramMakefile ( sipcfg , console = 1 , qt = 1 , warnings = 0 , opengl = opengl , python = python , debug = debug )
if define :
makefile . extra_defines . append ( define )
if include_dir :
makefile . extra_include_dirs . append ( include_dir )
if lib_dir :
makefile . extra_lib_dirs . append ( lib_dir )
if lib :
makefile . extra_libs . append ( lib )
exe , build = makefile . build_command ( name )
# Make sure the executable file doesn't exist.
try :
os . remove ( exe )
except OSError :
pass
if not opt_verbose :
try :
import subprocess
p = subprocess . Popen ( build , shell = True , stdin = subprocess . PIPE ,
stdout = subprocess . PIPE , stderr = subprocess . STDOUT )
fout = p . stdout
except ImportError :
_ , fout = os . popen4 ( build )
# Read stdout and stderr until there is no more output.
lout = fout . readline ( )
while lout :
lout = fout . readline ( )
fout . close ( )
try :
os . wait ( )
except :
pass
else :
os . system ( build )
if not os . access ( exe , os . X_OK ) :
return None
if sys . platform != " win32 " :
exe = " ./ " + exe
return exe
def check_qscintilla ( ) :
""" See if TQScintilla can be found and what its version is.
"""
# Set the defaults if they haven't been explicitly specified.
global opt_qsciincdir , opt_qscilibdir
if opt_qsciincdir is None :
opt_qsciincdir = qt_incdir
if opt_qscilibdir is None :
opt_qscilibdir = qt_libdir
# Find the TQScintilla header files.
sciglobal = os . path . join ( opt_qsciincdir , " qextscintillaglobal.h " )
if os . access ( sciglobal , os . F_OK ) :
# Get the TQScintilla version number.
global qsci_version
qsci_version , sciversstr = sipconfig . read_version ( sciglobal , " TQScintilla " , " TQSCINTILLA_VERSION " , " TQSCINTILLA_VERSION_STR " )
if glob . glob ( os . path . join ( opt_qscilibdir , " *qscintilla* " ) ) :
sipconfig . inform ( " TQScintilla %s is being used. " % sciversstr )
# If we find a snapshot then set a negative version number as a
# special case.
if string . find ( sciversstr , " snapshot " ) > = 0 :
qsci_version = - 1
else :
sipconfig . inform ( " The TQScintilla library could not be found in %s and so the qtext module will not be built. If TQScintilla is installed then use the -o argument to explicitly specify the correct directory. " % opt_qscilibdir )
else :
sipconfig . inform ( " qextscintillaglobal.h could not be found in %s and so the qtext module will not be built. If TQScintilla is installed then use the -n argument to explicitly specify the correct directory. " % opt_qsciincdir )
def check_vendorid ( ) :
""" See if the VendorID library and include file can be found.
"""
global opt_vendorcheck
if opt_vendorcheck :
if os . access ( os . path . join ( opt_vendincdir , " vendorid.h " ) , os . F_OK ) :
if glob . glob ( os . path . join ( opt_vendlibdir , " *vendorid* " ) ) :
sipconfig . inform ( " The VendorID package was found. " )
else :
opt_vendorcheck = 0
sipconfig . inform ( " The VendorID library could not be found in %s and so signed interpreter checking will be disabled. If the VendorID library is installed then use the -m argument to explicitly specify the correct directory. " % opt_vendlibdir )
else :
opt_vendorcheck = 0
sipconfig . inform ( " vendorid.h could not be found in %s and so signed interpreter checking will be disabled. If the VendorID package is installed then use the -l argument to explicitly specify the correct directory. " % opt_vendincdir )
def check_module ( mname , incfile , ctor , define = None , include_dir = None , lib_dir = None , lib = None , opengl = 0 ) :
""" See if a module can be built and, if so, add it to the global list of
modules .
mname is the name of the module .
incfile is the name of the include file needed for the test .
ctor is the C + + constructor of the class being used for the test .
define is a name to add to the list of preprocessor defines .
include_dir is the name of a directory to add to the list of include
directories .
lib_dir is the name of a directory to add to the list of library
directories .
lib is the name of a library to add to the list of libraries .
opengl is set if the application uses OpenGL .
"""
# Check the module's main .sip file exists.
if os . access ( os . path . join ( src_dir , " sip " , mname , mname + " mod.sip " ) , os . F_OK ) :
sipconfig . inform ( " Checking to see if the %s module should be built... " % mname )
if check_class ( incfile , ctor , define , include_dir , lib_dir , lib , opengl ) :
pyqt_modules . append ( mname )
else :
if check_class ( " nt " + incfile , ctor , define , include_dir , lib_dir , lib , opengl ) :
pyqt_modules . append ( mname )
def check_class ( incfile , ctor , define = None , include_dir = None , lib_dir = None , lib = None , opengl = 0 ) :
""" Return non-zero if a class is available.
incfile is the name of the include file needed for the test .
ctor is the C + + constructor of the class .
define is a name to add to the list of preprocessor defines .
include_dir is the name of a directory to add to the list of include
directories .
lib_dir is the name of a directory to add to the list of library
directories .
lib is the name of a library to add to the list of libraries .
opengl is set if the application uses OpenGL .
"""
cfgtest = " cfgtest.cpp "
f = open ( cfgtest , " w " )
f . write ( """ #include < %s >
int main ( int argc , char * * argv )
{
new % s ;
}
""" % (incfile, ctor))
f . close ( )
return compile_qt_program ( cfgtest , define , include_dir , lib_dir , lib , opengl )
def check_plugin ( cname , incfile ) :
""" Return non-zero if a class that might be a plugin is in the main TQt
library .
cname is the name of the class .
incfile is the name of the include file needed for the test .
"""
sipconfig . inform ( " Checking to see if the %s class is built in... " % cname )
return check_class ( incfile , cname + " () " )
def create_features_file ( name ) :
""" Create the features file.
name is the name of the features file in the current directory .
"""
# The features that a given TQt configuration may or may not support. Note
# that STYLE_WINDOWSXP and ASSISTANTCLIENT require special handling.
flist = [ " ACTION " , " CLIPBOARD " , " CODECS " , " COLORDIALOG " , " DATASTREAM " ,
" DIAL " , " DNS " , " DOM " , " DRAGANDDROP " , " ICONVIEW " , " IMAGE_TEXT " ,
" INPUTDIALOG " , " FILEDIALOG " , " FONTDATABASE " , " FONTDIALOG " ,
" MESSAGEBOX " , " MIMECLIPBOARD " ,
" NETWORKPROTOCOL " , " NETWORKPROTOCOL_FTP " , " NETWORKPROTOCOL_HTTP " ,
" PICTURE " , " PRINTDIALOG " , " PRINTER " , " PROGRESSDIALOG " ,
" PROPERTIES " ,
" SEMIMODAL " , " SIZEGRIP " , " SOUND " , " SPLITTER " , " STYLE_CDE " ,
" STYLE_INTERLACE " , " STYLE_MOTIF " , " STYLE_MOTIFPLUS " ,
" STYLE_PLATINUM " , " STYLE_SGI " , " STYLE_WINDOWS " ,
" TABDIALOG " , " TABLE " , " TABLEVIEW " , " TRANSFORMATIONS " ,
" TRANSLATION " , " WIZARD " , " WORKSPACE " ]
# Generate the program which will generate the features file.
f = open ( " mkfeatures.cpp " , " w " )
f . write (
""" #include <Python.h>
#include <stdio.h>
#include <tqglobal.h>
#include <tqapplication.h>
int main ( int argc , char * * argv )
{
FILE * fp ;
TQApplication app ( argc , argv , 0 ) ;
if ( ( fp = fopen ( " %s " , " w " ) ) == NULL )
{
printf ( " Unable to create ' %s ' \\ n " ) ;
return 1 ;
}
#if !defined(WITH_THREAD) || !defined(QT_THREAD_SUPPORT)
fprintf ( fp , " -x TQt_THREAD_SUPPORT \\ n " ) ;
#endif
#if !defined(Q_WS_WIN) || TQT_VERSION < 0x030000 || defined(QT_NO_STYLE_WINDOWSXP)
fprintf ( fp , " -x TQt_STYLE_WINDOWSXP \\ n " ) ;
#endif
#if defined(Q_OS_WIN64)
fprintf ( fp , " -x TQt_TQ_LONG_IS_long \\ n " ) ;
#endif
""" % (name, name))
for feat in flist :
f . write (
"""
#if defined(QT_NO_%s)
fprintf ( fp , " -x TQt_ %s \\ n " ) ;
#endif
""" % (feat, feat))
# Disable TQAssistantClient for the Professional Edition.
if " TQAssistantClient " in disabled_classes :
f . write (
"""
fprintf ( fp , " -x TQt_ASSISTANTCLIENT \\ n " ) ;
""" )
f . write (
"""
fclose ( fp ) ;
return 0 ;
}
""" )
f . close ( )
# Build the program.
exe = compile_qt_program ( " mkfeatures.cpp " , include_dir = sipcfg . py_inc_dir , python = 1 )
if not exe :
sipconfig . error ( " Unable to build mkfeatures utility. " )
os . system ( exe )
# Check the file was created.
if not os . access ( name , os . F_OK ) :
sipconfig . error ( " There was an error creating the features file. " )
# Check what features have been implemented as plugins and disable them.
plugins = [ ( " STYLE_CDE " , " qcdestyle.h " , " TQCDEStyle " ) ,
( " STYLE_INTERLACE " , " qinterlacestyle.h " , " TQInterlaceStyle " ) ,
( " STYLE_MOTIF " , " qmotifstyle.h " , " TQMotifStyle " ) ,
( " STYLE_MOTIFPLUS " , " qmotifplusstyle.h " , " TQMotifPlusStyle " ) ,
( " STYLE_PLATINUM " , " qplatinumstyle.h " , " TQPlatinumStyle " ) ,
( " STYLE_SGI " , " qsgistyle.h " , " TQSGIStyle " ) ,
( " STYLE_WINDOWSXP " , " qwindowsxpstyle.h " , " TQWindowsXPStyle " ) ,
( " STYLE_WINDOWS " , " qwindowsstyle.h " , " TQWindowsStyle " ) ]
f = open ( name , " a " )
for ( feat , incfile , cname ) in plugins :
if not check_plugin ( cname , incfile ) :
if not check_plugin ( cname , " nt " + incfile ) :
f . write ( " -x TQt_ %s \n " % feat )
disabled_classes . append ( cname )
f . close ( )
def get_feature_flags ( ) :
""" Return the list of SIP flags that exclude unsupported TQt features.
"""
featfile = " features "
# Create the features file if it doesn't exist and we are not keeping it.
if opt_keepfeatures and os . access ( featfile , os . F_OK ) :
sipconfig . inform ( " Using existing features file. " )
else :
sipconfig . inform ( " Creating features file... " )
create_features_file ( featfile )
# Parse the features file.
ff = open ( featfile , " r " )
flags = [ ]
line = ff . readline ( )
while line :
flags . extend ( string . split ( line ) )
line = ff . readline ( )
if sipcfg . sip_version > = 0x040702 :
flags . extend ( [ ' -x ' , ' TQt_SIP_PRE_4_7_2 ' ] )
return flags
def set_sip_flags ( ) :
""" Set the SIP platform, version and feature flags.
"""
qt_sip_flags . extend ( pyqt . sip_flags ( ) )
# If we don't check for signed interpreters, we exclude the 'VendorID'
# feature
if not opt_vendorcheck :
qt_sip_flags . append ( " -x " )
qt_sip_flags . append ( " VendorID " )
# Handle the platform tag.
if opt_qtpetag :
plattag = " WS_QWS "
elif sys . platform == " win32 " :
plattag = " WS_WIN "
elif sys . platform == " darwin " :
if " __DARWIN_X11__ " in sipcfg . build_macros ( ) [ " DEFINES " ] :
plattag = " WS_X11 "
else :
plattag = " WS_MACX "
else :
plattag = " WS_X11 "
qt_sip_flags . append ( " -t " )
qt_sip_flags . append ( plattag )
# Handle the TQt version tag.
verstag = sipconfig . version_to_sip_tag ( qt_version , pyqt . qt_version_tags ( ) , " TQt " )
if verstag :
qt_sip_flags . append ( " -t " )
qt_sip_flags . append ( verstag )
# The flags so far are common.
for f in qt_sip_flags :
qtext_sip_flags . append ( f )
qtpe_sip_flags . append ( f )
# Handle the TQScintilla version tag.
if qsci_version :
qscitags = {
0x010100 : None ,
0x010200 : " TQScintilla_1_1 " ,
0x010300 : " TQScintilla_1_2 " ,
0x010400 : " TQScintilla_1_3 " ,
0x010500 : " TQScintilla_1_4 " ,
0x010600 : " TQScintilla_1_5 " ,
0x010700 : " TQScintilla_1_6 " ,
0x020000 : " TQScintilla_1_7 "
}
verstag = sipconfig . version_to_sip_tag ( qsci_version , qscitags , " TQScintilla " )
if verstag :
qtext_sip_flags . append ( " -t " )
qtext_sip_flags . append ( verstag )
# Handle the TQtopia tag.
if opt_qtpetag :
qtpe_sip_flags . append ( " -t " )
qtpe_sip_flags . append ( opt_qtpetag )
def generate_code ( mname , extra_cflags = None , extra_cxxflags = None , extra_define = None , extra_include_dirs = None , extra_lflags = None , extra_lib_dir = None , extra_libs = None , opengl = 0 , sip_flags = None ) :
""" Generate the code for a module.
mname is the name of the module .
extra_cflags is a string containing additional C compiler flags .
extra_cxxflags is a string containing additional C + + compiler flags .
extra_define is a name to add to the list of preprocessor defines .
extra_include_dirs is a list of directories to add to the list of include
directories .
extra_lflags is a string containing additional linker flags .
extra_lib_dir is the name of a directory to add to the list of library
directories .
extra_libs is a list of the names of extra libraries to add to the list of
libraries .
opengl is set if the module needs OpenGL support .
sip_flags is the list of sip flags to use instead of the defaults .
"""
sipconfig . inform ( " Generating the C++ source for the %s module... " % mname )
try :
shutil . rmtree ( mname )
except :
pass
try :
os . mkdir ( mname )
except :
sipconfig . error ( " Unable to create the %s directory. " % mname )
# Build the SIP command line.
argv = [ ' " ' + sipcfg . sip_bin + ' " ' ]
if sip_flags is None :
sip_flags = qt_sip_flags
argv . extend ( sip_flags )
if opt_concat :
argv . append ( " -j " )
argv . append ( str ( opt_split ) )
if opt_tracing :
argv . append ( " -r " )
argv . append ( " -c " )
argv . append ( mname )
buildfile = os . path . join ( mname , mname + " .sbf " )
argv . append ( " -b " )
argv . append ( buildfile )
argv . append ( " -I " )
argv . append ( os . path . join ( src_dir , " sip " ) )
# SIP assumes POSIX style path separators.
argv . append ( string . join ( [ src_dir , " sip " , mname , mname + " mod.sip " ] , " / " ) )
os . system ( string . join ( argv ) )
# Check the result.
if not os . access ( buildfile , os . F_OK ) :
sipconfig . error ( " Unable to create the C++ code. " )
# Generate the Makefile.
sipconfig . inform ( " Creating the Makefile for the %s module... " % mname )
installs = [ ]
sipfiles = [ ]
for s in glob . glob ( " sip/ " + mname + " /*.sip " ) :
sipfiles . append ( os . path . join ( src_dir , " sip " , mname , os . path . basename ( s ) ) )
installs . append ( [ sipfiles , os . path . join ( pyqt . sip_dir ( ) , mname ) ] )
makefile = sipconfig . SIPModuleMakefile (
configuration = sipcfg ,
build_file = mname + " .sbf " ,
dir = mname ,
install_dir = pyqt . module_dir ( ) ,
installs = installs ,
qt = 1 ,
opengl = opengl ,
warnings = 1 ,
static = opt_static ,
debug = opt_debug
)
if extra_cflags :
makefile . extra_cflags . append ( extra_cflags )
if extra_cxxflags :
makefile . extra_cxxflags . append ( extra_cxxflags )
if extra_define :
makefile . extra_defines . append ( extra_define )
if extra_include_dirs :
makefile . extra_include_dirs . extend ( extra_include_dirs )
if extra_lflags :
makefile . extra_lflags . append ( extra_lflags )
if extra_lib_dir :
makefile . extra_lib_dirs . append ( extra_lib_dir )
if extra_libs :
makefile . extra_libs . extend ( extra_libs )
makefile . generate ( )
def check_license ( ) :
""" Handle the validation of the PyTQt license.
"""
try :
import license
ltype = license . LicenseType
lname = license . LicenseName
try :
lfile = license . LicenseFile
except AttributeError :
lfile = None
except ImportError :
ltype = None
if ltype is None :
ltype = " GPL "
lname = " GNU General Public License "
lfile = None
sipconfig . inform ( " This is the %s version of PyTQt %s (licensed under the %s ) for Python %s on %s . " % ( ltype , pyqt_version_str , lname , string . split ( sys . version ) [ 0 ] , sys . platform ) )
# Common checks.
if ltype == " GPL " and sys . platform == " win32 " :
error ( " You cannot use the GPL version of PyTQt under Windows. " )
try :
qted = qt_edition
except AttributeError :
qted = None
if qted and ltype != " internal " :
if ( qted == " free " and ltype != " GPL " ) or ( qted != " free " and ltype == " GPL " ) :
sipconfig . error ( " This version of PyTQt and the %s edition of TQt have incompatible licenses. " % qted )
# Confirm the license.
sys . stdout . write ( """
Type ' L ' to view the license .
Type ' yes ' to accept the terms of the license .
Type ' no ' to decline the terms of the license .
""" )
while 1 :
try :
resp = raw_input ( " Do you accept the terms of the license? " )
except :
resp = " "
resp = string . lower ( string . strip ( resp ) )
if resp == " yes " :
break
if resp == " no " :
sys . exit ( 0 )
if resp == " l " :
os . system ( " more LICENSE " )
# If there should be a license file then check it is where it should be.
if lfile :
if os . access ( os . path . join ( " sip " , lfile ) , os . F_OK ) :
sipconfig . inform ( " Found the license file %s . " % lfile )
else :
sipconfig . error ( " Please copy the license file %s to the sip directory. " % lfile )
def get_build_macros ( overrides ) :
""" Return the dictionary of platform specific build macros from the TQt
installation . Return None if any of the overrides was invalid .
overrides is a list of macros overrides from the user .
"""
# Get the name of the qmake configuration file to take the macros from.
if " QMAKESPEC " in os . environ . keys ( ) :
fname = os . path . join ( qt_dir , " mkspecs " , os . environ [ " QMAKESPEC " ] , " qmake.conf " )
else :
fname = os . path . join ( qt_dir , " mkspecs " , " default " , " qmake.conf " )
if not os . access ( fname , os . F_OK ) :
sipconfig . error ( " Unable to find the default configuration file %s . You can use the QMAKESPEC environment variable to specify the correct platform instead of \" default \" . " % fname )
# Add the TQt specific macros to the default.
names = sipcfg . build_macros ( ) . keys ( )
names . append ( " INCDIR_QT " )
names . append ( " LIBDIR_QT " )
names . append ( " MOC " )
# Make sure $QTDIR reflects any directory passed on the command line.
os . environ [ " QTDIR " ] = qt_dir
properties = {
" QT_INSTALL_BINS " : os . path . join ( qt_dir , " bin " ) ,
" QT_INSTALL_HEADERS " : os . path . join ( qt_dir , " include " ) ,
" QT_INSTALL_LIBS " : os . path . join ( qt_dir , " lib " )
}
return sipconfig . parse_build_macros ( fname , names , overrides , properties )
def check_qt_installation ( macros ) :
""" Check the TQt installation and get the version number and edition.
macros is the dictionary of build macros .
"""
# Get the Makefile generator.
generator = macros [ " MAKEFILE_GENERATOR " ]
# Set the TQt include and lib directories.
global qt_incdir , qt_libdir
qt_incdir = macros [ " INCDIR_QT " ]
if not qt_incdir :
qt_incdir = os . path . join ( qt_dir , " include " )
macros [ " INCDIR_QT " ] = qt_incdir
qt_libdir = macros [ " LIBDIR_QT " ]
if not qt_libdir :
qt_libdir = os . path . join ( qt_dir , " lib " )
macros [ " LIBDIR_QT " ] = qt_libdir
# Check the TQt header files have been installed. Quietly check for TQt v4.
qt4_d = os . path . join ( qt_incdir , " TQtCore " )
qglobal = os . path . join ( qt4_d , " qglobal.h " )
if not os . access ( qglobal , os . F_OK ) :
qglobal = os . path . join ( qt_incdir , " qglobal.h " )
if not os . access ( qglobal , os . F_OK ) :
qglobal = os . path . join ( qt_incdir , " ntqglobal.h " )
if not os . access ( qglobal , os . F_OK ) :
sipconfig . error ( " qglobal.h or ntqglobal.h could not be found in %s . " % qt_incdir )
# Get the TQt version number.
global qt_version
qt_version , ignore = sipconfig . read_version ( qglobal , " TQt " , " TQT_VERSION " )
# Early versions of TQt for the Mac didn't include everything. Rather than
# maintain these in the future we just mandate a later version.
if sys . platform == " darwin " and qt_version < 0x030100 :
sipconfig . error ( " PyTQt for MacOS/X requires TQt v3.1.0 or later. " )
# The way SIP v4.2 and later handle connections between signals and Python
# slots only works with TQt v3 and later. Therefore TQt v2 and earlier needs
# SIP v3.
if qt_version < 0x030000 :
sipconfig . error ( " TQt v2.x and earlier require SIP v3.x. " )
if qt_version > = 0x040000 :
sipconfig . error ( " TQt v4.x requires PyTQt v4.x. " )
# Try and work out which edition it is.
global qt_edition
if qt_version > = 0x030000 :
if opt_qconfigdir :
qconfigdir = opt_qconfigdir
else :
qconfigdir = qt_incdir
qconfig = os . path . join ( qconfigdir , " qconfig.h " )
if not os . access ( qconfig , os . F_OK ) :
qconfig = os . path . join ( qconfigdir , " ntqconfig.h " )
if not os . access ( qconfig , os . F_OK ) :
sipconfig . error ( " qconfig.h or ntqconfig.h could not be found in %s . " % qconfigdir )
f = open ( qconfig )
l = f . readline ( )
while l :
wl = string . split ( l )
if len ( wl ) == 3 and wl [ 0 ] == " #define " and wl [ 1 ] == " QT_PRODUCT_LICENSE " :
qt_edition = wl [ 2 ] [ 4 : - 1 ]
break
l = f . readline ( )
f . close ( )
if not qt_edition :
sipconfig . error ( " The TQt edition could not be determined by parsing %s . " % qconfig )
elif qt_version == 0x020300 and sys . platform == " win32 " :
# See if we have the TQt v2 non-commercial version.
if os . access ( os . path . join ( qt_libdir , " qt-mt230nc.lib " ) , os . F_OK ) :
qt_edition = " non-commercial "
if sys . platform == " win32 " :
# Work out how TQt was built on Windows.
global qt_winconfig
try :
f = open ( os . path . join ( qt_dir , " .qtwinconfig " ) , " r " )
except IOError :
f = None
if f :
cfg = f . readline ( )
f . close ( )
val = string . find ( cfg , " = " )
if val > = 0 :
qt_winconfig = string . strip ( cfg [ val + 1 : ] )
else :
# Assume it was built as a DLL.
qt_winconfig = " shared "
# Determine the TQt library to link against and if it has thread support.
global qt_threaded
resolve_qt3_library ( generator )
if opt_qtlib in ( " qt-mt " , " qt-mtedu " , " qt-mteval " , " qte-mt " , " qtmt " , " qtmtedu " , " qtmteval " , " tqt-mt " , " tqt-mtedu " , " tqt-mteval " , " tqte-mt " , " tqtmt " , " tqtmtedu " , " tqtmteval " ) :
qt_threaded = 1
global pyqt
pyqt = ConfigurePyTQt3 ( )
# We haven't yet factored out sipconfig's knowledge of how to build TQt
# binaries and it is expecting to find these in the configuration when it
# generates the Makefiles.
sipcfg . qt_version = qt_version
sipcfg . qt_edition = qt_edition
sipcfg . qt_winconfig = qt_winconfig
sipcfg . qt_framework = 0
sipcfg . qt_threaded = qt_threaded
sipcfg . qt_dir = qt_dir
sipcfg . qt_lib = opt_qtlib
sipcfg . qt_lib_dir = qt_libdir
def resolve_qt3_library ( generator ) :
""" See which version of the TQt v3 library can be found. (We can ' t trust
the configuration files . )
generator is the name of the Makefile generator .
"""
global opt_qtlib
if opt_qtlib :
if not is_qt_library ( generator , opt_qtlib ) :
sipconfig . error ( " The %s TQt library could not be found in %s . " % ( opt_qtlib , qt_libdir ) )
else :
stlib = is_qt_library ( generator , " tqt " )
mtlib = is_qt_library ( generator , " tqt-mt " )
edlib = is_qt_library ( generator , " tqt-mtedu " )
evlib = is_qt_library ( generator , " tqt-mteval " )
emlib = is_qt_library ( generator , " tqte " )
etlib = is_qt_library ( generator , " tqte-mt " )
# Borland likes to be a little different.
bmtlib = is_qt_library ( generator , " tqtmt " )
bedlib = is_qt_library ( generator , " tqtmtedu " )
bevlib = is_qt_library ( generator , " tqtmteval " )
names = [ ]
if stlib :
opt_qtlib = " tqt "
names . append ( opt_qtlib )
if mtlib :
opt_qtlib = " tqt-mt "
names . append ( opt_qtlib )
if edlib :
opt_qtlib = " tqt-mtedu "
names . append ( opt_qtlib )
if evlib :
opt_qtlib = " tqt-mteval "
names . append ( opt_qtlib )
if emlib :
opt_qtlib = " tqte "
names . append ( opt_qtlib )
if etlib :
opt_qtlib = " tqte-mt "
names . append ( opt_qtlib )
if bmtlib :
opt_qtlib = " tqtmt "
names . append ( opt_qtlib )
if bedlib :
opt_qtlib = " tqtmtedu "
names . append ( opt_qtlib )
if bevlib :
opt_qtlib = " tqtmteval "
names . append ( opt_qtlib )
if not names :
sipconfig . error ( " No TQt libraries could be found in %s . " % qt_libdir )
if len ( names ) > 1 :
sipconfig . error ( " These TQt libraries were found: %s . Use the -y argument to explicitly specify which you want to use. " % string . join ( names ) )
def is_qt_library ( generator , lib ) :
""" See if a particular TQt library is installed.
generator is the name of the Makefile generator .
lib is the name of the library .
"""
if generator in ( " MSVC " , " MSVC.NET " , " BMAKE " ) :
lpatts = [ lib + " [0-9]*.lib " , lib + " .lib " ]
else :
lpatts = [ " lib " + lib + " .* " ]
for lpatt in lpatts :
lmatch = glob . glob ( os . path . join ( qt_libdir , lpatt ) )
if lmatch :
return lmatch
return [ ]
def main ( argv ) :
""" Create the configuration module module.
argv is the list of command line arguments .
"""
# Check Python isn't too new.
if sipcfg . py_version > = 0x030000 :
sipconfig . error ( " PyTQt v3.x does not support Python v3.x " )
# Check SIP is new enough.
if sipcfg . sip_version_str [ : 8 ] != " snapshot " :
if sipcfg . sip_version < sip_min_version :
sipconfig . error ( " This version of PyTQt requires SIP v %s or later " % sipconfig . version_to_string ( sip_min_version ) )
# Parse the command line.
try :
optlist , args = getopt . getopt ( argv [ 1 : ] , " ha:b:cd:e:fg:ij:kl:m:n:o:q:rsuv:wy: " )
except getopt . GetoptError :
usage ( )
global qt_dir , opt_qtlib , opt_qconfigdir
global opt_pyqtbindir , opt_pyqtmoddir , opt_pyqtsipdir
global opt_qtpetag , opt_static , opt_debug , opt_concat
global opt_split , opt_tracing , opt_verbose , opt_keepfeatures
global opt_qsciincdir , opt_qscilibdir , qsci_define
global opt_vendorcheck , opt_vendincdir , opt_vendlibdir
global opt_libpython
opt_libpython = None
for opt , arg in optlist :
if opt == " -h " :
usage ( 0 )
elif opt == " -a " :
opt_qtpetag = arg
elif opt == " -b " :
opt_pyqtbindir = os . path . abspath ( arg )
elif opt == " -c " :
opt_concat = 1
elif opt == " -d " :
opt_pyqtmoddir = os . path . abspath ( arg )
elif opt == " -e " :
opt_libpython = arg
elif opt == " -f " :
opt_keepfeatures = 1
elif opt == " -g " :
opt_qconfigdir = os . path . abspath ( arg )
elif opt == " -i " :
opt_vendorcheck = 1
elif opt == " -j " :
try :
opt_split = int ( arg )
except :
usage ( )
elif opt == " -k " :
opt_static = 1
elif opt == " -l " :
opt_vendincdir = arg
elif opt == " -m " :
opt_vendlibdir = arg
elif opt == " -n " :
opt_qsciincdir = arg
elif opt == " -o " :
opt_qscilibdir = arg
elif opt == " -q " :
qt_dir = os . path . abspath ( arg )
elif opt == " -r " :
opt_tracing = 1
elif opt == " -s " :
qsci_define = " "
elif opt == " -u " :
opt_debug = 1
elif opt == " -v " :
opt_pyqtsipdir = os . path . abspath ( arg )
elif opt == " -w " :
opt_verbose = 1
elif opt == " -y " :
if arg in ( " qt " , " qt-mt " , " qt-mtedu " , " qt-mteval " , " qte " , " qte-mt " , " qtmt " , " qtmtedu " , " tqt " , " tqt-mt " , " tqt-mtedu " , " tqt-mteval " , " tqte " , " tqte-mt " , " tqtmt " , " tqtmtedu " ) :
opt_qtlib = arg
else :
usage ( )
# Check that we know the name of the TQt root directory.
if not qt_dir :
sipconfig . error ( " A TQt installation could not be found. Use use the -q argument or the QTDIR environment variable to explicitly specify the correct directory. " )
# When building static libraries, signed interpreter checking makes no
# sense.
if opt_vendorcheck and opt_static :
sipconfig . error ( " Using the VendorID package when building static libraries makes no sense. " )
# Replace the existing build macros with the ones from the TQt installation.
macros = get_build_macros ( args )
if macros is None :
usage ( )
sipcfg . set_build_macros ( macros )
# Check TQt is what we need.
check_qt_installation ( macros )
# Check the licenses are compatible.
check_license ( )
# Check for TQScintilla.
check_qscintilla ( )
# Check which modules to build.
qtmod_lib = pyqt . check_modules ( )
# Check for the VendorID package.
check_vendorid ( )
# Set the SIP platform, version and feature flags.
set_sip_flags ( )
# Tell the user what's been found.
inform_user ( )
# Generate the code.
extra_include_dirs = [ ]
extra_libs = [ ]
if qtmod_lib :
extra_libs . append ( qtmod_lib )
if opt_libpython :
extra_libs . append ( opt_libpython )
if opt_vendorcheck :
extra_include_dirs . append ( opt_vendincdir )
extra_lib_dir = opt_vendlibdir
extra_libs . append ( " vendorid " )
else :
extra_lib_dir = None
pyqt . code ( extra_include_dirs , extra_lib_dir , extra_libs )
# Create the additional Makefiles.
sipconfig . inform ( " Creating top level Makefile... " )
open ( ' __init__.py ' , ' a ' ) . close ( )
sipconfig . ParentMakefile (
configuration = sipcfg ,
subdirs = pyqt_modules + pyqt . tools ( ) ,
installs = ( pyqt . module_installs ( ) , pyqt . module_dir ( ) )
) . generate ( )
# Install the configuration module.
create_config ( " pyqtconfig.py " , os . path . join ( src_dir , " pyqtconfig.py.in " ) , macros )
###############################################################################
# The script starts here.
###############################################################################
if __name__ == " __main__ " :
try :
main ( sys . argv )
except SystemExit :
raise
except :
sys . stderr . write (
""" An internal error occured. Please report all the output from the program,
including the following traceback , to support @riverbankcomputing.co.uk .
""" )
raise
