You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1488 lines
49 KiB
1488 lines
49 KiB
# 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 |
|
|
|
import sip_tqt_config |
|
|
|
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["TQTDIR"] |
|
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-TQt configuration. |
|
sipcfg = sip_tqt_config.Configuration() |
|
|
|
# Command line options. |
|
opt_tqtlib = 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-TQt 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-TQt configuration. |
|
extra_lib_dir is an optional directory to add to those supplied by the |
|
SIP-TQt configuration. |
|
extra_lib_dirs is an optional list of directories to add to those |
|
supplied by the SIP-TQt 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", "tqextscintillabase.h", "TQextScintillaBase()", define=qsci_define, include_dir=opt_qsciincdir, lib_dir=opt_qscilibdir, lib="tqscintilla") |
|
|
|
if opt_qtpetag: |
|
pyqt_modules.append("qtpe") |
|
|
|
qtmod_lib = None |
|
|
|
if qt_version >= 0x030100: |
|
sip_tqt_config.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=["tqscintilla"]+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") |
|
|
|
sip_tqt_config.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 = sip_tqt_config.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") |
|
|
|
sip_tqt_config.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 = sip_tqt_config.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: |
|
sip_tqt_config.inform("Creating pyuic Makefile...") |
|
|
|
makefile = sip_tqt_config.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 = "" |
|
|
|
sip_tqt_config.inform("TQt v%s %sis being used." % (sip_tqt_config.version_to_string(qt_version), edstr)) |
|
sip_tqt_config.inform("SIP-TQt %s is being used." % sipcfg.sip_version_str) |
|
sip_tqt_config.inform("These PyTQt modules will be built: %s." % string.join(pyqt_modules)) |
|
|
|
if disabled_classes: |
|
sip_tqt_config.inform("Support for these TQt classes has been disabled: %s." % string.join(disabled_classes)) |
|
|
|
sip_tqt_config.inform("The PyTQt modules will be installed in %s." % opt_pyqtmoddir) |
|
sip_tqt_config.inform("The PyTQt .sip files will be installed in %s." % opt_pyqtsipdir) |
|
|
|
sip_tqt_config.inform("The TQt header files are in %s." % qt_incdir) |
|
sip_tqt_config.inform("The %s TQt library is in %s." % (opt_tqtlib, qt_libdir)) |
|
|
|
if qt_version >= 0x020000: |
|
sip_tqt_config.inform("pyuic will be installed in %s." % opt_pyqtbindir) |
|
|
|
if qt_version >= 0x030000: |
|
sip_tqt_config.inform("pylupdate will be installed in %s." % opt_pyqtbindir) |
|
|
|
if opt_vendorcheck: |
|
sip_tqt_config.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. |
|
""" |
|
sip_tqt_config.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_tqtlib, |
|
"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 |
|
|
|
sip_tqt_config.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 = sip_tqt_config.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, "tqextscintillaglobal.h") |
|
|
|
if os.access(sciglobal, os.F_OK): |
|
# Get the TQScintilla version number. |
|
global qsci_version |
|
|
|
qsci_version, sciversstr = sip_tqt_config.read_version(sciglobal, "TQScintilla", "TQSCINTILLA_VERSION", "TQSCINTILLA_VERSION_STR") |
|
|
|
if glob.glob(os.path.join(opt_qscilibdir, "*tqscintilla*")): |
|
sip_tqt_config.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: |
|
sip_tqt_config.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: |
|
sip_tqt_config.inform("tqextscintillaglobal.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*")): |
|
sip_tqt_config.inform("The VendorID package was found.") |
|
else: |
|
opt_vendorcheck = 0 |
|
sip_tqt_config.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 |
|
sip_tqt_config.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): |
|
sip_tqt_config.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. |
|
""" |
|
sip_tqt_config.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(TQT_THREAD_SUPPORT) |
|
fprintf(fp,"-x TQt_THREAD_SUPPORT\\n"); |
|
#endif |
|
|
|
#if !defined(Q_WS_WIN) || TQT_VERSION < 0x030000 || defined(TQT_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(TQT_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: |
|
sip_tqt_config.error("Unable to build mkfeatures utility.") |
|
|
|
os.system(exe) |
|
|
|
# Check the file was created. |
|
if not os.access(name, os.F_OK): |
|
sip_tqt_config.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-TQt 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): |
|
sip_tqt_config.inform("Using existing features file.") |
|
else: |
|
sip_tqt_config.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-TQt 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 = sip_tqt_config.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 = sip_tqt_config.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-tqt flags to use instead of the defaults. |
|
""" |
|
sip_tqt_config.inform("Generating the C++ source for the %s module..." % mname) |
|
|
|
try: |
|
shutil.rmtree(mname) |
|
except: |
|
pass |
|
|
|
try: |
|
os.mkdir(mname) |
|
except: |
|
sip_tqt_config.error("Unable to create the %s directory." % mname) |
|
|
|
# Build the SIP-TQt 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-TQt 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): |
|
sip_tqt_config.error("Unable to create the C++ code.") |
|
|
|
# Generate the Makefile. |
|
sip_tqt_config.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 = sip_tqt_config.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 |
|
|
|
sip_tqt_config.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"): |
|
sip_tqt_config.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): |
|
sip_tqt_config.inform("Found the license file %s." % lfile) |
|
else: |
|
sip_tqt_config.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): |
|
sip_tqt_config.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_TQT") |
|
names.append("LIBDIR_TQT") |
|
names.append("MOC") |
|
|
|
# Make sure $TQTDIR reflects any directory passed on the command line. |
|
os.environ["TQTDIR"] = 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 sip_tqt_config.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_TQT"] |
|
|
|
if not qt_incdir: |
|
qt_incdir = os.path.join(qt_dir, "include") |
|
macros["INCDIR_TQT"] = qt_incdir |
|
|
|
qt_libdir = macros["LIBDIR_TQT"] |
|
|
|
if not qt_libdir: |
|
qt_libdir = os.path.join(qt_dir, "lib") |
|
macros["LIBDIR_TQT"] = 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): |
|
sip_tqt_config.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 = sip_tqt_config.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: |
|
sip_tqt_config.error("PyTQt for MacOS/X requires TQt v3.1.0 or later.") |
|
|
|
# The way SIP-TQt 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-TQt v3. |
|
if qt_version < 0x030000: |
|
sip_tqt_config.error("TQt v2.x and earlier require SIP-TQt v3.x.") |
|
|
|
if qt_version >= 0x040000: |
|
sip_tqt_config.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): |
|
sip_tqt_config.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: |
|
sip_tqt_config.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_tqtlib 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 sip_tqt_config'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_tqtlib |
|
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_tqtlib |
|
|
|
if opt_tqtlib: |
|
if not is_qt_library(generator, opt_tqtlib): |
|
sip_tqt_config.error("The %s TQt library could not be found in %s." % (opt_tqtlib, 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_tqtlib = "tqt" |
|
names.append(opt_tqtlib) |
|
|
|
if mtlib: |
|
opt_tqtlib = "tqt-mt" |
|
names.append(opt_tqtlib) |
|
|
|
if edlib: |
|
opt_tqtlib = "tqt-mtedu" |
|
names.append(opt_tqtlib) |
|
|
|
if evlib: |
|
opt_tqtlib = "tqt-mteval" |
|
names.append(opt_tqtlib) |
|
|
|
if emlib: |
|
opt_tqtlib = "tqte" |
|
names.append(opt_tqtlib) |
|
|
|
if etlib: |
|
opt_tqtlib = "tqte-mt" |
|
names.append(opt_tqtlib) |
|
|
|
if bmtlib: |
|
opt_tqtlib = "tqtmt" |
|
names.append(opt_tqtlib) |
|
|
|
if bedlib: |
|
opt_tqtlib = "tqtmtedu" |
|
names.append(opt_tqtlib) |
|
|
|
if bevlib: |
|
opt_tqtlib = "tqtmteval" |
|
names.append(opt_tqtlib) |
|
|
|
if not names: |
|
sip_tqt_config.error("No TQt libraries could be found in %s." % qt_libdir) |
|
|
|
if len(names) > 1: |
|
sip_tqt_config.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: |
|
sip_tqt_config.error("PyTQt v3.x does not support Python v3.x") |
|
|
|
# Check SIP-TQt is new enough. |
|
if sipcfg.sip_version_str[:8] != "snapshot": |
|
if sipcfg.sip_version < sip_min_version: |
|
sip_tqt_config.error("This version of PyTQt requires SIP-TQt v%s or later" % sip_tqt_config.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_tqtlib, 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_tqtlib = arg |
|
else: |
|
usage() |
|
|
|
# Check that we know the name of the TQt root directory. |
|
if not qt_dir: |
|
sip_tqt_config.error("A TQt installation could not be found. Use use the -q argument or the TQTDIR environment variable to explicitly specify the correct directory.") |
|
|
|
# When building static libraries, signed interpreter checking makes no |
|
# sense. |
|
if opt_vendorcheck and opt_static: |
|
sip_tqt_config.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-TQt 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. |
|
sip_tqt_config.inform("Creating top level Makefile...") |
|
|
|
sip_tqt_config.ParentMakefile( |
|
configuration=sipcfg, |
|
subdirs=pyqt_modules + pyqt.tools(), |
|
installs=(pyqt.module_installs(), pyqt.module_dir()) |
|
).generate() |
|
|
|
# Install module initialization script. |
|
create_config("__init__.py", os.path.join(src_dir, "module-init.py"), macros) |
|
|
|
# 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
|
|
|