diff options
Diffstat (limited to 'configure.py')
| -rw-r--r-- | configure.py | 652 |
1 files changed, 326 insertions, 326 deletions
diff --git a/configure.py b/configure.py index 56c3537..30b117a 100644 --- a/configure.py +++ b/configure.py @@ -33,51 +33,51 @@ 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" +pytqt_version = 0x031201 +pytqt_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"] + tqt_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 + tqt_dir = "" + + +tqt_version = 0 +tqt_edition = "" +tqt_incdir = None +tqt_libdir = None +tqt_threaded = 0 +tqt_winconfig = "" + +pytqt = None +pytqt_modules = [] +tqt_sip_flags = [] +tqtext_sip_flags = [] +tqtpe_sip_flags = [] +tqsci_version = 0 disabled_classes = [] if sys.platform == "win32": - qsci_define = "TQEXTSCINTILLA_DLL" + tqsci_define = "TQEXTSCINTILLA_DLL" else: - qsci_define = "" + tqsci_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, "PyTQt") -opt_pyqtsipdir = sipcfg.default_sip_dir -opt_qtpetag = None -opt_qsciincdir = None -opt_qscilibdir = None +opt_tqconfigdir = None +opt_pytqtbindir = sipcfg.default_bin_dir +opt_pytqtmoddir = os.path.join(sipcfg.default_mod_dir, "PyTQt") +opt_pytqtsipdir = sipcfg.default_sip_dir +opt_tqtpetag = None +opt_tqsciincdir = None +opt_tqscilibdir = None opt_static = 0 opt_debug = 0 opt_concat = 0 @@ -97,22 +97,22 @@ def usage(rcode = 2): rcode is the return code passed back to the calling process. """ - if qt_dir: - def_qt_dir = qt_dir + if tqt_dir: + def_tqt_dir = tqt_dir else: - def_qt_dir = "none" + def_tqt_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(" -a tag explicitly enable the tqtpe module\n") + sys.stdout.write(" -b dir where pytquic and pytqlupdate will be installed [default %s]\n" % opt_pytqtbindir) 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(" -d dir where the PyTQt modules will be installed [default %s]\n" % opt_pytqtmoddir) 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(" -g dir where the TQt tqconfig.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") @@ -120,13 +120,13 @@ def usage(rcode = 2): 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(" -q dir the root directory of the TQt installation [default %s]\n" % def_tqt_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(" -v dir where the PyTQt .sip files will be installed [default %s]\n" % opt_pytqtsipdir) 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.stdout.write(" -y lib explicitly specify the type of TQt library, either tqt, tqt-mt, tqte, tqte-mt or tqtmt\n") sys.stdout.write(" -z accept the license terms without prompting\n") sys.exit(rcode) @@ -151,7 +151,7 @@ class ConfigureBase: """ return [] - def qt_version_tags(self): + def tqt_version_tags(self): """Get the versions tags for the configuration. Returns a dictionary of versions and corresponding tags. @@ -181,66 +181,66 @@ class ConfigureBase: def module_dir(self): """Return the configuration's module directory. """ - return opt_pyqtmoddir + return opt_pytqtmoddir 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"] + return ["__init__.py", "pytqtconfig.py"] def sip_dir(self): """Return the configuration's .sip files directory. """ - return opt_pyqtsipdir + return opt_pytqtsipdir class ConfigurePyTQt3(ConfigureBase): """This class defines the methods to configure PyTQt v3. """ def check_modules(self): - pyqt_modules.append("qt") + pytqt_modules.append("tqt") - 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) + check_module("tqtcanvas", "tqcanvas.h", "TQCanvas()") + check_module("tqtnetwork", "tqsocket.h", "TQSocket()") + check_module("tqttable", "tqtable.h", "TQTable()") + check_module("tqtxml", "tqdom.h", "TQDomImplementation()") + check_module("tqtgl", "tqgl.h", "TQGLWidget()", opengl=1) - if qt_version >= 0x030000: - check_module("qtui", "qwidgetfactory.h", "TQWidgetFactory()", lib="tqui") + if tqt_version >= 0x030000: + check_module("tqtui", "tqwidgetfactory.h", "TQWidgetFactory()", lib="tqui") - if qt_edition in ("enterprise", "free"): - check_module("qtsql", "qsql.h", "TQSql()") + if tqt_edition in ("enterprise", "free"): + check_module("tqtsql", "tqsql.h", "TQSql()") if sys.platform == "win32" and sipcfg.sip_version >= 0x040200: - check_module("qtaxcontainer", "qaxobject.h", "TQAxObject()", lib="qaxcontainer") + check_module("tqtaxcontainer", "tqaxobject.h", "TQAxObject()", lib="tqaxcontainer") - if qsci_version: - check_module("qtext", "tqextscintillabase.h", "TQextScintillaBase()", define=qsci_define, include_dir=opt_qsciincdir, lib_dir=opt_qscilibdir, lib="tqscintilla") + if tqsci_version: + check_module("tqtext", "tqextscintillabase.h", "TQextScintillaBase()", define=tqsci_define, include_dir=opt_tqsciincdir, lib_dir=opt_tqscilibdir, lib="tqscintilla") - if opt_qtpetag: - pyqt_modules.append("qtpe") + if opt_tqtpetag: + pytqt_modules.append("tqtpe") - qtmod_lib = None + tqtmod_lib = None - if qt_version >= 0x030100: + if tqt_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" + if check_class("tqassistantclient.h", "TQAssistantClient(\"foo\")", lib="tqassistantclient"): + tqtmod_lib = "tqassistantclient" else: - if check_class("ntqassistantclient.h", "TQAssistantClient(\"foo\")", lib="qassistantclient"): - qtmod_lib = "qassistantclient" + if check_class("ntqassistantclient.h", "TQAssistantClient(\"foo\")", lib="tqassistantclient"): + tqtmod_lib = "tqassistantclient" else: disabled_classes.append("TQAssistantClient") - return qtmod_lib + return tqtmod_lib def sip_flags(self): return get_feature_flags() - def qt_version_tags(self): + def tqt_version_tags(self): return { 0x010403: None, 0x020000: "TQt_1_43", @@ -265,102 +265,102 @@ class ConfigurePyTQt3(ConfigureBase): } 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) + generate_code("tqt", 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 "tqtext" in pytqt_modules: + generate_code("tqtext", extra_define=tqsci_define, extra_include_dirs=[opt_tqsciincdir], extra_lib_dir=opt_tqscilibdir, extra_libs=["tqscintilla"]+extra_libs, sip_flags=tqtext_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 "tqtgl" in pytqt_modules: + generate_code("tqtgl", 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 "tqtpe" in pytqt_modules: + generate_code("tqtpe", extra_include_dirs=extra_include_dirs, extra_lib_dir=extra_lib_dir, extra_libs=["tqpe"]+extra_libs, sip_flags=tqtpe_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 "tqtui" in pytqt_modules: + generate_code("tqtui", 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) + if "tqtaxcontainer" in pytqt_modules: + generate_code("tqtaxcontainer", extra_include_dirs=extra_include_dirs, extra_lib_dir=extra_lib_dir, extra_libs=["tqaxcontainer"]+extra_libs) # The rest don't need special handling. - for m in ("qtcanvas", "qtnetwork", "qtsql", "qttable", "qtxml"): - if m in pyqt_modules: + for m in ("tqtcanvas", "tqtnetwork", "tqtsql", "tqttable", "tqtxml"): + if m in pytqt_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: + if tqt_version >= 0x030000: # The Professional Edition needs special handling. - prof = (qt_edition == "professional") + prof = (tqt_edition == "professional") - sip_tqt_config.inform("Creating pyuic Makefile...") + sip_tqt_config.inform("Creating pytquic Makefile...") - if prof or "qtxml" not in pyqt_modules: - buildfile= "pyuic-prof.sbf" + if prof or "tqtxml" not in pytqt_modules: + buildfile= "pytquic-prof.sbf" - for xml in ("qdom.cpp", "qxml.cpp"): - shutil.copyfile(qt_dir + "/src/xml/" + xml, "pyuic3/" + xml) + for xml in ("tqdom.cpp", "tqxml.cpp"): + shutil.copyfile(tqt_dir + "/src/xml/" + xml, "pytquic3/" + xml) else: - buildfile= "pyuic.sbf" + buildfile= "pytquic.sbf" makefile = sip_tqt_config.ProgramMakefile( configuration=sipcfg, - build_file=os.path.join(src_dir, "pyuic3", buildfile), - dir="pyuic3", - install_dir=opt_pyqtbindir, + build_file=os.path.join(src_dir, "pytquic3", buildfile), + dir="pytquic3", + install_dir=opt_pytqtbindir, console=1, - qt=1, + tqt=1, warnings=1 ) makefile.extra_defines.append("UIC") - makefile.extra_defines.append("QT_INTERNAL_XML") + makefile.extra_defines.append("TQT_INTERNAL_XML") - if prof or "qtxml" not in pyqt_modules: + if prof or "tqtxml" not in pytqt_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 tqt_version < 0x030100: + makefile.extra_include_dirs.append(tqt_dir + "/src/3rdparty/zlib") + makefile.extra_include_dirs.append(os.path.join(src_dir, "pytquic3")) - if not os.access("pyuic3", os.F_OK): - os.mkdir("pyuic3") + if not os.access("pytquic3", os.F_OK): + os.mkdir("pytquic3") makefile.generate() - tool_dirs.append("pyuic3") + tool_dirs.append("pytquic3") - sip_tqt_config.inform("Creating pylupdate Makefile...") + sip_tqt_config.inform("Creating pytqlupdate Makefile...") - if prof or "qtxml" not in pyqt_modules: - buildfile= "pylupdate-prof.sbf" + if prof or "tqtxml" not in pytqt_modules: + buildfile= "pytqlupdate-prof.sbf" - shutil.copyfile(qt_dir + "/src/xml/qxml.cpp", "pylupdate3/qxml.cpp") + shutil.copyfile(tqt_dir + "/src/xml/tqxml.cpp", "pytqlupdate3/tqxml.cpp") else: - buildfile= "pylupdate.sbf" + buildfile= "pytqlupdate.sbf" makefile = sip_tqt_config.ProgramMakefile( configuration=sipcfg, - build_file=os.path.join(src_dir, "pylupdate3", buildfile), - dir="pylupdate3", - install_dir=opt_pyqtbindir, + build_file=os.path.join(src_dir, "pytqlupdate3", buildfile), + dir="pytqlupdate3", + install_dir=opt_pytqtbindir, console=1, - qt=1, + tqt=1, warnings=1 ) - makefile.extra_defines.append("QT_INTERNAL_XML") + makefile.extra_defines.append("TQT_INTERNAL_XML") - if prof or "qtxml" not in pyqt_modules: + if prof or "tqtxml" not in pytqt_modules: makefile.extra_defines.append("TQT_MODULE_XML") - makefile.extra_include_dirs.append(os.path.join(src_dir, "pylupdate3")) + makefile.extra_include_dirs.append(os.path.join(src_dir, "pytqlupdate3")) - if not os.access("pylupdate3", os.F_OK): - os.mkdir("pylupdate3") + if not os.access("pytqlupdate3", os.F_OK): + os.mkdir("pytqlupdate3") makefile.generate() - tool_dirs.append("pylupdate3") + tool_dirs.append("pytqlupdate3") return tool_dirs @@ -368,29 +368,29 @@ class ConfigurePyTQt3(ConfigureBase): def inform_user(): """Tell the user the option values that are going to be used. """ - if qt_edition: - edstr = qt_edition + " edition " + if tqt_edition: + edstr = tqt_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("TQt v%s %sis being used." % (sip_tqt_config.version_to_string(tqt_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." % ' '.join(pyqt_modules)) + sip_tqt_config.inform("These PyTQt modules will be built: %s." % ' '.join(pytqt_modules)) if disabled_classes: sip_tqt_config.inform("Support for these TQt classes has been disabled: %s." % ' '.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 PyTQt modules will be installed in %s." % opt_pytqtmoddir) + sip_tqt_config.inform("The PyTQt .sip files will be installed in %s." % opt_pytqtsipdir) - 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)) + sip_tqt_config.inform("The TQt header files are in %s." % tqt_incdir) + sip_tqt_config.inform("The %s TQt library is in %s." % (opt_tqtlib, tqt_libdir)) - if qt_version >= 0x020000: - sip_tqt_config.inform("pyuic will be installed in %s." % opt_pyqtbindir) + if tqt_version >= 0x020000: + sip_tqt_config.inform("pyuic will be installed in %s." % opt_pytqtbindir) - if qt_version >= 0x030000: - sip_tqt_config.inform("pylupdate will be installed in %s." % opt_pyqtbindir) + if tqt_version >= 0x030000: + sip_tqt_config.inform("pylupdate will be installed in %s." % opt_pytqtbindir) if opt_vendorcheck: sip_tqt_config.inform("PyTQt will only be usable with signed interpreters.") @@ -407,64 +407,64 @@ def create_config(module, template, 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 + "pytqt_config_args": sys.argv[1:], + "pytqt_version": pytqt_version, + "pytqt_version_str": pytqt_version_str, + "pytqt_bin_dir": opt_pytqtbindir, + "pytqt_mod_dir": opt_pytqtmoddir, + "pytqt_sip_dir": opt_pytqtsipdir, + "pytqt_modules": pytqt_modules, + "pytqt_tqt_sip_flags": tqt_sip_flags, + "tqt_version": tqt_version, + "tqt_edition": tqt_edition, + "tqt_winconfig": tqt_winconfig, + "tqt_framework": 0, + "tqt_threaded": tqt_threaded, + "tqt_dir": tqt_dir, + "tqt_inc_dir": tqt_incdir, + "tqt_lib": opt_tqtlib, + "tqt_lib_dir": tqt_libdir } - if "qtaxcontainer" in pyqt_modules: - content["pyqt_qtaxcontainer_sip_flags"] = qt_sip_flags + if "tqtaxcontainer" in pytqt_modules: + content["pytqt_tqtaxcontainer_sip_flags"] = tqt_sip_flags - if "qtcanvas" in pyqt_modules: - content["pyqt_qtcanvas_sip_flags"] = qt_sip_flags + if "tqtcanvas" in pytqt_modules: + content["pytqt_tqtcanvas_sip_flags"] = tqt_sip_flags - if "qtext" in pyqt_modules: - content["pyqt_qtext_sip_flags"] = qtext_sip_flags + if "tqtext" in pytqt_modules: + content["pytqt_tqtext_sip_flags"] = tqtext_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 + content["_pytqt_tqscintilla_defines"] = tqsci_define + content["_pytqt_tqscintilla_inc_dir"] = opt_tqsciincdir + content["_pytqt_tqscintilla_lib_dir"] = opt_tqscilibdir - if "qtgl" in pyqt_modules: - content["pyqt_qtgl_sip_flags"] = qt_sip_flags + if "tqtgl" in pytqt_modules: + content["pytqt_tqtgl_sip_flags"] = tqt_sip_flags - if "qtnetwork" in pyqt_modules: - content["pyqt_qtnetwork_sip_flags"] = qt_sip_flags + if "tqtnetwork" in pytqt_modules: + content["pytqt_tqtnetwork_sip_flags"] = tqt_sip_flags - if "qtpe" in pyqt_modules: - content["pyqt_qtpe_sip_flags"] = qtpe_sip_flags + if "tqtpe" in pytqt_modules: + content["pytqt_tqtpe_sip_flags"] = tqtpe_sip_flags - if "qtsql" in pyqt_modules: - content["pyqt_qtsql_sip_flags"] = qt_sip_flags + if "tqtstql" in pytqt_modules: + content["pytqt_tqtsql_sip_flags"] = tqt_sip_flags - if "qttable" in pyqt_modules: - content["pyqt_qttable_sip_flags"] = qt_sip_flags + if "tqttable" in pytqt_modules: + content["pytqt_tqttable_sip_flags"] = tqt_sip_flags - if "qtui" in pyqt_modules: - content["pyqt_qtui_sip_flags"] = qt_sip_flags + if "tqtui" in pytqt_modules: + content["pytqt_tqtui_sip_flags"] = tqt_sip_flags - if "qtxml" in pyqt_modules: - content["pyqt_qtxml_sip_flags"] = qt_sip_flags + if "tqtxml" in pytqt_modules: + content["pytqt_tqtxml_sip_flags"] = tqt_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): +def compile_tqt_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. @@ -481,7 +481,7 @@ def compile_qt_program(name, define=None, include_dir=None, lib_dir=None, lib=No 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) + makefile = sip_tqt_config.ProgramMakefile(sipcfg, console=1, tqt=1, warnings=0, opengl=opengl, python=python, debug=debug) if define: makefile.extra_defines.append(define) @@ -537,38 +537,38 @@ def compile_qt_program(name, define=None, include_dir=None, lib_dir=None, lib=No return exe -def check_qscintilla(): +def check_tqscintilla(): """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 + global opt_tqsciincdir, opt_tqscilibdir - if opt_qsciincdir is None: - opt_qsciincdir = qt_incdir + if opt_tqsciincdir is None: + opt_tqsciincdir = tqt_incdir - if opt_qscilibdir is None: - opt_qscilibdir = qt_libdir + if opt_tqscilibdir is None: + opt_tqscilibdir = tqt_libdir # Find the TQScintilla header files. - sciglobal = os.path.join(opt_qsciincdir, "tqextscintillaglobal.h") + sciglobal = os.path.join(opt_tqsciincdir, "tqextscintillaglobal.h") if os.access(sciglobal, os.F_OK): # Get the TQScintilla version number. - global qsci_version + global tqsci_version - qsci_version, sciversstr = sip_tqt_config.read_version(sciglobal, "TQScintilla", "TQSCINTILLA_VERSION", "TQSCINTILLA_VERSION_STR") + tqsci_version, sciversstr = sip_tqt_config.read_version(sciglobal, "TQScintilla", "TQSCINTILLA_VERSION", "TQSCINTILLA_VERSION_STR") - if glob.glob(os.path.join(opt_qscilibdir, "*tqscintilla*")): + if glob.glob(os.path.join(opt_tqscilibdir, "*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 sciversstr.find("snapshot") >= 0: - qsci_version = -1 + tqsci_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) + sip_tqt_config.inform("The TQScintilla library could not be found in %s and so the tqtext module will not be built. If TQScintilla is installed then use the -o argument to explicitly specify the correct directory." % opt_tqscilibdir) 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) + sip_tqt_config.inform("tqextscintillaglobal.h could not be found in %s and so the tqtext module will not be built. If TQScintilla is installed then use the -n argument to explicitly specify the correct directory." % opt_tqsciincdir) def check_vendorid(): @@ -608,10 +608,10 @@ def check_module(mname, incfile, ctor, define=None, include_dir=None, lib_dir=No 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) + pytqt_modules.append(mname) else: if check_class("nt" + incfile, ctor, define, include_dir, lib_dir, lib, opengl): - pyqt_modules.append(mname) + pytqt_modules.append(mname) def check_class(incfile, ctor, define=None, include_dir=None, lib_dir=None, lib=None, opengl=0): @@ -641,7 +641,7 @@ int main(int argc, char **argv) f.close() - return compile_qt_program(cfgtest, define, include_dir, lib_dir, lib, opengl) + return compile_tqt_program(cfgtest, define, include_dir, lib_dir, lib, opengl) def check_plugin(cname, incfile): @@ -735,7 +735,7 @@ int main(int argc,char **argv) f.close() # Build the program. - exe = compile_qt_program("mkfeatures.cpp", include_dir=sipcfg.py_inc_dir, python=1) + exe = compile_tqt_program("mkfeatures.cpp", include_dir=sipcfg.py_inc_dir, python=1) if not exe: sip_tqt_config.error("Unable to build mkfeatures utility.") @@ -746,14 +746,14 @@ int main(int argc,char **argv) 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")] + plugins = [("STYLE_CDE", "tqcdestyle.h", "TQCDEStyle"), + ("STYLE_INTERLACE", "tqinterlacestyle.h", "TQInterlaceStyle"), + ("STYLE_MOTIF", "tqmotifstyle.h", "TQMotifStyle"), + ("STYLE_MOTIFPLUS", "tqmotifplusstyle.h", "TQMotifPlusStyle"), + ("STYLE_PLATINUM", "tqplatinumstyle.h", "TQPlatinumStyle"), + ("STYLE_SGI", "tqsgistyle.h", "TQSGIStyle"), + ("STYLE_WINDOWSXP", "tqwindowsxpstyle.h", "TQWindowsXPStyle"), + ("STYLE_WINDOWS", "tqwindowsstyle.h", "TQWindowsStyle")] f = open(name, "a") @@ -797,16 +797,16 @@ def get_feature_flags(): def set_sip_flags(): """Set the SIP-TQt platform, version and feature flags. """ - qt_sip_flags.extend(pyqt.sip_flags()) + tqt_sip_flags.extend(pytqt.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") + tqt_sip_flags.append("-x") + tqt_sip_flags.append("VendorID") # Handle the platform tag. - if opt_qtpetag: + if opt_tqtpetag: plattag = "WS_QWS" elif sys.platform == "win32": plattag = "WS_WIN" @@ -818,24 +818,24 @@ def set_sip_flags(): else: plattag = "WS_X11" - qt_sip_flags.append("-t") - qt_sip_flags.append(plattag) + tqt_sip_flags.append("-t") + tqt_sip_flags.append(plattag) # Handle the TQt version tag. - verstag = sip_tqt_config.version_to_sip_tag(qt_version, pyqt.qt_version_tags(), "TQt") + verstag = sip_tqt_config.version_to_sip_tag(tqt_version, pytqt.tqt_version_tags(), "TQt") if verstag: - qt_sip_flags.append("-t") - qt_sip_flags.append(verstag) + tqt_sip_flags.append("-t") + tqt_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) + for f in tqt_sip_flags: + tqtext_sip_flags.append(f) + tqtpe_sip_flags.append(f) # Handle the TQScintilla version tag. - if qsci_version: - qscitags = { + if tqsci_version: + tqscitags = { 0x010100: None, 0x010200: "TQScintilla_1_1", 0x010300: "TQScintilla_1_2", @@ -846,16 +846,16 @@ def set_sip_flags(): 0x020000: "TQScintilla_1_7" } - verstag = sip_tqt_config.version_to_sip_tag(qsci_version, qscitags, "TQScintilla") + verstag = sip_tqt_config.version_to_sip_tag(tqsci_version, tqscitags, "TQScintilla") if verstag: - qtext_sip_flags.append("-t") - qtext_sip_flags.append(verstag) + tqtext_sip_flags.append("-t") + tqtext_sip_flags.append(verstag) # Handle the TQtopia tag. - if opt_qtpetag: - qtpe_sip_flags.append("-t") - qtpe_sip_flags.append(opt_qtpetag) + if opt_tqtpetag: + tqtpe_sip_flags.append("-t") + tqtpe_sip_flags.append(opt_tqtpetag) 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): @@ -891,7 +891,7 @@ def generate_code(mname, extra_cflags=None, extra_cxxflags=None, extra_define=No argv = ['"' + sipcfg.sip_bin + '"'] if sip_flags is None: - sip_flags = qt_sip_flags + sip_flags = tqt_sip_flags argv.extend(sip_flags) @@ -930,15 +930,15 @@ def generate_code(mname, extra_cflags=None, extra_cxxflags=None, extra_define=No 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)]) + installs.append([sipfiles, os.path.join(pytqt.sip_dir(), mname)]) makefile = sip_tqt_config.SIPModuleMakefile( configuration=sipcfg, build_file=mname + ".sbf", dir=mname, - install_dir=pyqt.module_dir(), + install_dir=pytqt.module_dir(), installs=installs, - qt=1, + tqt=1, opengl=opengl, warnings=1, static=opt_static, @@ -989,20 +989,20 @@ def check_license(): 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, sys.version[0].split(), sys.platform)) + sip_tqt_config.inform("This is the %s version of PyTQt %s (licensed under the %s) for Python %s on %s." % (ltype, pytqt_version_str, lname, sys.version[0].split(), 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 + tqted = tqt_edition except AttributeError: - qted = None + tqted = 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) + if tqted and ltype != "internal": + if (tqted == "free" and ltype != "GPL") or (tqted != "free" and ltype == "GPL"): + sip_tqt_config.error("This version of PyTQt and the %s edition of TQt have incompatible licenses." % tqted) # Confirm the license. sys.stdout.write(""" @@ -1050,9 +1050,9 @@ def get_build_macros(overrides): """ # Get the name of the qmake configuration file to take the macros from. if "QMAKESPEC" in list(os.environ.keys()): - fname = os.path.join(qt_dir, "mkspecs", os.environ["QMAKESPEC"], "qmake.conf") + fname = os.path.join(tqt_dir, "mkspecs", os.environ["QMAKESPEC"], "qmake.conf") else: - fname = os.path.join(qt_dir, "mkspecs", "default", "qmake.conf") + fname = os.path.join(tqt_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) @@ -1064,18 +1064,18 @@ def get_build_macros(overrides): names.append("MOC") # Make sure $TQTDIR reflects any directory passed on the command line. - os.environ["TQTDIR"] = qt_dir + os.environ["TQTDIR"] = tqt_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") + "TQT_INSTALL_BINS": os.path.join(tqt_dir, "bin"), + "TQT_INSTALL_HEADERS": os.path.join(tqt_dir, "include"), + "TQT_INSTALL_LIBS": os.path.join(tqt_dir, "lib") } return sip_tqt_config.parse_build_macros(fname, names, overrides, properties) -def check_qt_installation(macros): +def check_tqt_installation(macros): """Check the TQt installation and get the version number and edition. macros is the dictionary of build macros. @@ -1084,97 +1084,97 @@ def check_qt_installation(macros): generator = macros["MAKEFILE_GENERATOR"] # Set the TQt include and lib directories. - global qt_incdir, qt_libdir + global tqt_incdir, tqt_libdir - qt_incdir = macros["INCDIR_TQT"] + tqt_incdir = macros["INCDIR_TQT"] - if not qt_incdir: - qt_incdir = os.path.join(qt_dir, "include") - macros["INCDIR_TQT"] = qt_incdir + if not tqt_incdir: + tqt_incdir = os.path.join(tqt_dir, "include") + macros["INCDIR_TQT"] = tqt_incdir - qt_libdir = macros["LIBDIR_TQT"] + tqt_libdir = macros["LIBDIR_TQT"] - if not qt_libdir: - qt_libdir = os.path.join(qt_dir, "lib") - macros["LIBDIR_TQT"] = qt_libdir + if not tqt_libdir: + tqt_libdir = os.path.join(tqt_dir, "lib") + macros["LIBDIR_TQT"] = tqt_libdir # Check the TQt header files have been installed. Quietly check for TQt v4. - qt4_d = os.path.join(qt_incdir, "TQtCore") + tqt4_d = os.path.join(tqt_incdir, "TQtCore") - qglobal = os.path.join(qt4_d, "qglobal.h") + tqglobal = os.path.join(tqt4_d, "tqglobal.h") - if not os.access(qglobal, os.F_OK): - qglobal = os.path.join(qt_incdir, "qglobal.h") + if not os.access(tqglobal, os.F_OK): + tqglobal = os.path.join(tqt_incdir, "tqglobal.h") - if not os.access(qglobal, os.F_OK): - qglobal = os.path.join(qt_incdir, "ntqglobal.h") + if not os.access(tqglobal, os.F_OK): + tqglobal = os.path.join(tqt_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) + if not os.access(tqglobal, os.F_OK): + sip_tqt_config.error("tqglobal.h or ntqglobal.h could not be found in %s." % tqt_incdir) # Get the TQt version number. - global qt_version + global tqt_version - qt_version, ignore = sip_tqt_config.read_version(qglobal, "TQt", "TQT_VERSION") + tqt_version, ignore = sip_tqt_config.read_version(tqglobal, "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: + if sys.platform == "darwin" and tqt_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: + if tqt_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.") + if tqt_version >= 0x040000: + sip_tqt_config.error("TQt v4.x requires PyTQt v5.x.") # Try and work out which edition it is. - global qt_edition + global tqt_edition - if qt_version >= 0x030000: - if opt_qconfigdir: - qconfigdir = opt_qconfigdir + if tqt_version >= 0x030000: + if opt_tqconfigdir: + tqconfigdir = opt_tqconfigdir else: - qconfigdir = qt_incdir + tqconfigdir = tqt_incdir - qconfig = os.path.join(qconfigdir, "qconfig.h") + tqconfig = os.path.join(tqconfigdir, "tqconfig.h") - if not os.access(qconfig,os.F_OK): - qconfig = os.path.join(qconfigdir, "ntqconfig.h") + if not os.access(tqconfig,os.F_OK): + tqconfig = os.path.join(tqconfigdir, "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) + if not os.access(tqconfig,os.F_OK): + sip_tqt_config.error("tqconfig.h or ntqconfig.h could not be found in %s." % tqconfigdir) - f = open(qconfig) + f = open(tqconfig) l = f.readline() while l: wl = l.split() if len(wl) == 3 and wl[0] == "#define" and wl[1] == "QT_PRODUCT_LICENSE": - qt_edition = wl[2][4:-1] + tqt_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": + if not tqt_edition: + sip_tqt_config.error("The TQt edition could not be determined by parsing %s." % tqconfig) + elif tqt_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 os.access(os.path.join(tqt_libdir, "tqt-mt230nc.lib"), os.F_OK): + tqt_edition = "non-commercial" if sys.platform == "win32": # Work out how TQt was built on Windows. - global qt_winconfig + global tqt_winconfig try: - f = open(os.path.join(qt_dir, ".qtwinconfig"), "r") + f = open(os.path.join(tqt_dir, ".tqtwinconfig"), "r") except IOError: f = None @@ -1185,37 +1185,37 @@ def check_qt_installation(macros): val = cfg.find("=") if val >= 0: - qt_winconfig = string.strip(cfg[val + 1:]) + tqt_winconfig = string.strip(cfg[val + 1:]) else: # Assume it was built as a DLL. - qt_winconfig = "shared" + tqt_winconfig = "shared" # Determine the TQt library to link against and if it has thread support. - global qt_threaded + global tqt_threaded - resolve_qt3_library(generator) + resolve_tqt3_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 + if opt_tqtlib in ("tqt-mt", "tqt-mtedu", "tqt-mteval", "tqte-mt", "tqtmt", "tqtmtedu", "tqtmteval", "tqt-mt", "tqt-mtedu", "tqt-mteval", "tqte-mt", "tqtmt", "tqtmtedu", "tqtmteval"): + tqt_threaded = 1 - global pyqt + global pytqt - pyqt = ConfigurePyTQt3() + pytqt = 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 + sipcfg.tqt_version = tqt_version + sipcfg.tqt_edition = tqt_edition + sipcfg.tqt_winconfig = tqt_winconfig + sipcfg.tqt_framework = 0 + sipcfg.tqt_threaded = tqt_threaded + sipcfg.tqt_dir = tqt_dir + sipcfg.tqt_lib = opt_tqtlib + sipcfg.tqt_lib_dir = tqt_libdir -def resolve_qt3_library(generator): +def resolve_tqt3_library(generator): """See which version of the TQt v3 library can be found. (We can't trust the configuration files.) @@ -1224,20 +1224,20 @@ def resolve_qt3_library(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)) + if not is_tqt_library(generator, opt_tqtlib): + sip_tqt_config.error("The %s TQt library could not be found in %s." % (opt_tqtlib, tqt_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") + stlib = is_tqt_library(generator, "tqt") + mtlib = is_tqt_library(generator, "tqt-mt") + edlib = is_tqt_library(generator, "tqt-mtedu") + evlib = is_tqt_library(generator, "tqt-mteval") + emlib = is_tqt_library(generator, "tqte") + etlib = is_tqt_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") + bmtlib = is_tqt_library(generator, "tqtmt") + bedlib = is_tqt_library(generator, "tqtmtedu") + bevlib = is_tqt_library(generator, "tqtmteval") names = [] @@ -1278,13 +1278,13 @@ def resolve_qt3_library(generator): names.append(opt_tqtlib) if not names: - sip_tqt_config.error("No TQt libraries could be found in %s." % qt_libdir) + sip_tqt_config.error("No TQt libraries could be found in %s." % tqt_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." % ' '.join(names)) -def is_qt_library(generator, lib): +def is_tqt_library(generator, lib): """See if a particular TQt library is installed. generator is the name of the Makefile generator. @@ -1296,7 +1296,7 @@ def is_qt_library(generator, lib): lpatts = ["lib" + lib + ".*"] for lpatt in lpatts: - lmatch = glob.glob(os.path.join(qt_libdir, lpatt)) + lmatch = glob.glob(os.path.join(tqt_libdir, lpatt)) if lmatch: return lmatch @@ -1320,11 +1320,11 @@ def main(argv): 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 tqt_dir, opt_tqtlib, opt_tqconfigdir + global opt_pytqtbindir, opt_pytqtmoddir, opt_pytqtsipdir + global opt_tqtpetag, opt_static, opt_debug, opt_concat global opt_split, opt_tracing, opt_verbose, opt_keepfeatures - global opt_qsciincdir, opt_qscilibdir, qsci_define + global opt_tqsciincdir, opt_tqscilibdir, tqsci_define global opt_vendorcheck, opt_vendincdir, opt_vendlibdir global opt_libpython global opt_accept_license @@ -1335,19 +1335,19 @@ def main(argv): if opt == "-h": usage(0) elif opt == "-a": - opt_qtpetag = arg + opt_tqtpetag = arg elif opt == "-b": - opt_pyqtbindir = os.path.abspath(arg) + opt_pytqtbindir = os.path.abspath(arg) elif opt == "-c": opt_concat = 1 elif opt == "-d": - opt_pyqtmoddir = os.path.abspath(arg) + opt_pytqtmoddir = 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) + opt_tqconfigdir = os.path.abspath(arg) elif opt == "-i": opt_vendorcheck = 1 elif opt == "-j": @@ -1362,23 +1362,23 @@ def main(argv): elif opt == "-m": opt_vendlibdir = arg elif opt == "-n": - opt_qsciincdir = arg + opt_tqsciincdir = arg elif opt == "-o": - opt_qscilibdir = arg + opt_tqscilibdir = arg elif opt == "-q": - qt_dir = os.path.abspath(arg) + tqt_dir = os.path.abspath(arg) elif opt == "-r": opt_tracing = 1 elif opt == "-s": - qsci_define = "" + tqsci_define = "" elif opt == "-u": opt_debug = 1 elif opt == "-v": - opt_pyqtsipdir = os.path.abspath(arg) + opt_pytqtsipdir = 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"): + if arg in ("tqt", "tqt-mt", "tqt-mtedu", "tqt-mteval", "tqte", "tqte-mt", "tqtmt", "tqtmtedu", "tqt", "tqt-mt", "tqt-mtedu", "tqt-mteval", "tqte", "tqte-mt", "tqtmt", "tqtmtedu"): opt_tqtlib = arg else: usage() @@ -1386,7 +1386,7 @@ def main(argv): opt_accept_license = 1 # Check that we know the name of the TQt root directory. - if not qt_dir: + if not tqt_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 @@ -1403,7 +1403,7 @@ def main(argv): sipcfg.set_build_macros(macros) # Check TQt is what we need. - check_qt_installation(macros) + check_tqt_installation(macros) # Check the licenses are compatible. if opt_accept_license == 1: @@ -1412,10 +1412,10 @@ def main(argv): check_license() # Check for TQScintilla. - check_qscintilla() + check_tqscintilla() # Check which modules to build. - qtmod_lib = pyqt.check_modules() + tqtmod_lib = pytqt.check_modules() # Check for the VendorID package. check_vendorid() @@ -1431,8 +1431,8 @@ def main(argv): extra_include_dirs = [] extra_libs = [] - if qtmod_lib: - extra_libs.append(qtmod_lib) + if tqtmod_lib: + extra_libs.append(tqtmod_lib) if opt_libpython: extra_libs.append(opt_libpython) @@ -1444,22 +1444,22 @@ def main(argv): else: extra_lib_dir = None - pyqt.code(extra_include_dirs, extra_lib_dir, extra_libs) + pytqt.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()) + subdirs=pytqt_modules + pytqt.tools(), + installs=(pytqt.module_installs(), pytqt.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) + create_config("pytqtconfig.py", os.path.join(src_dir, "pytqtconfig.py.in"), macros) ############################################################################### |