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.

977 lines
33 KiB

# This script generates the PyKDE configuration and generates the Makefiles.
# Copyright (c) 2004
# Riverbank Computing Limited <>
# Jim Bublitz <>
# This file is part of PyKDE.
# This copy of PyKDE 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.
# PyKDE 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
# PyKDE; see the file LICENSE. If not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
import sys
import os
import string
import glob
import getopt
import shutil
import py_compile
import sip_tqt_config
print ("Can't find (expected in sys.path)")
print ("Have you built the correct version of sip-tqt?")
sys.exit (-1)
from PyTQt import pytqtconfig
sip_tqt_config.error ("Can't find in sys.path - exiting")
topsrcdir = os.path.dirname(os.path.abspath(__file__))
has_objdir = topsrcdir != os.path.abspath(os.path.curdir)
if not has_objdir:
topsrcdir = None
def srcPath(filename):
if topsrcdir is not None:
return os.path.join(topsrcdir, filename)
return filename
topsrcdir = os.path.dirname(os.path.abspath(__file__))
has_objdir = topsrcdir != os.path.abspath(os.path.curdir)
if not has_objdir:
topsrcdir = None
def srcPath(filename):
if topsrcdir is not None:
return os.path.join(topsrcdir, filename)
return filename
# Get the SIP-TQt configuration.
sipcfg = sip_tqt_config.Configuration()
pytqtcfg = pytqtconfig.Configuration ()
# Initialise the globals.
pytde_version = 0x031006
pytde_version_str = "3.16.6"
kde_version = None
kde_version_str = None
kde_version_sfx = None
kde_version_extra = None
kde_max_version = 0x030503
sip_min_v4_version = 0x040900
tqt_min_version = 0x030200
pytqt_min_version = 0x031000
kde_sip_flags = []
# Command line options.
opt_pytdemoddir = sipcfg.default_mod_dir
opt_pytdesipdir = sipcfg.default_sip_dir
opt_debug = 0
opt_concat = None
opt_split = 1
opt_releasegil = 0
opt_tracing = 0
opt_static = 0
opt_tdebasedir = None
opt_kdelibdir = None
opt_kdeincdir = None
opt_dep_warnings = 0
opt_libdir = "lib"
opt_dist_name = ""
pytde_modules = ["dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tderesources", "tdeabc", "tdeutils", "tdefile", "tdeparts",\
"tdehtml", "tdespell", "tdeprint", "tdemdi"] #, "tdespell2"]
pytde_imports = {
"dcop": ["PyTQt.tqt"],
"tdecore": ["PyTQt.tqt", "dcop"],
# "tdesu": ["PyTQt.tqt", "dcop", "tdecore"],
"tdefx": ["PyTQt.tqt", "dcop", "tdecore"],
"tdeui": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx"],
"tdeio": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui"],
"tderesources": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"],
"tdeabc": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tderesources"],
"tdeutils": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"],
"tdefile": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"],
"tdeparts": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"],
"tdehtml": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeutils", "tdeio", "tdeparts"],
"tdespell": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tdefile"],
"tdeprint": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui"],
"tdemdi": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tdeparts"],
"tdespell2": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui"]
kde_includes = {
"dcop": None,
"tdecore": None,
# "tdesu": ["tdesu"],
"tdefx": None,
"tdeui": None,
"tdeio": ["tdeio"],
"tderesources": ["tdeio", "../tdeio", "tderesources"],
"tdeabc": ["tdeio", "../tdeio", "tderesources", "tdeabc"],
"tdefile": ["tdeio", "../tdeio"],
"tdeparts": ["tdeio", "../tdeio", "tdeparts"],
"tdehtml": ["tdeio", "../tdeio", "tdeparts", "dom"],
"tdespell": ["tdeio"],
"tdeprint": ["tdeprint"],
"tdemdi": ["tdemdi", "tdeio", "../tdeio", "tdeparts"],
"tdeutils": ["tdeio", "../tdeio"] #,
# "tdespell2": None
postProcess = {
"dcop": None,
"tdecore": [["-p ", "tdecore", "-o", "appQuit", ""],
#["-p ", "tdecore", "-o", "fixTQVariant", "tdecore.sbf"],
["-p ", "tdecore", "-o", "fixSignal", "tdecorepart0.*"]],
# "tdesu": None,
"tdefx": None,
"tdeui": None, #[["-p ", "tdeui", "-o", "shpix", "siptdeuiTDESharedPixmap.cpp"]],
"tderesources": None,
"tdeabc": None,
"tdeio": None,
"tdefile": None,
"tdeparts": None,
"tdehtml": None,
"tdespell": None,
"tdeprint": None,
"tdemdi": None,
"tdeutils": None #,
# "tdespell2": None
opt_startModName = ""
opt_startmod = 0
opt_endmod = len (pytde_modules)
def check_gcc ():
global opt_concat
os.system ("gcc -dumpversion > gccvers.txt")
m = open ('gccvers.txt', 'r')
vers =
m.close ()
os.unlink ('gccvers.txt')
print("gcc version %s" % vers)
if opt_concat == None:
if vers < "4.0.0" or vers >= "4.0.3":
opt_concat = 1
opt_concat = 0
if opt_concat == 1:
print("concatenating files")
print("no concatenation")
def init_and_check_sanity ():
""" Do some initialization and check various versions and
attributes of sip-tqt and PyTQt installations
check_gcc ()
# Check SIP-TQt is new enough.
if sipcfg.sip_version_str[:8] != "snapshot":
minv = None
if sipcfg.sip_version < sip_min_v4_version:
minv = sip_min_v4_version
if minv:
sipcfg.error("This version of PyKDE requires SIP-TQt v%s or later" % sipcfg.version_to_string(minv))
# Check SIP-TQt has TQt support enabled and check version
if pytqtcfg.tqt_version == 0:
sip_tqt_config.error("SIP-TQt has been built with TQt support disabled.")
if pytqtcfg.tqt_version < tqt_min_version:
sip_tqt_config.error("SIP-TQt has been built with an unsupported TQt version (%s)"\
% sipcfg.version_to_string (sipcfg.tqt_version))
# Check PyTQt built with libtqt-mt
if pytqtcfg.tqt_threaded == 0:
sip_tqt_config.error ("PyKDE requires a threaded TQt version (libtqt-mt)")
# Check PyTQt version
if pytqtcfg.pytqt_version < pytqt_min_version:
sipcfg.error("This version of PyKDE requires PyTQt v%s or later"\
% pytqtcfg.version_to_string(pytqtcfg.pytqt_version))
# find the libs, includes, and version info
check_kde_installation ()
def usage(rcode = 2):
"""Display a usage message and exit.
rcode is the return code passed back to the calling process.
print(" python [-h] [-c] [-d dir] [-g] [-j #] [-k] [-n dir] [-o dir] [-r] [-u] [-v dir] [-z file]")
print(" -h displays this help message")
print(" -c concatenates each module's C/C++ source files [default]")
print(" -d dir where the PyKDE modules will be installed [default %s]" % opt_pytdemoddir)
print(" -e lib explicitly specify the python library")
print(" -g always release the GIL (SIP-TQt v3.x behaviour)")
print(" -i no concatenation of each module's C/C++ source files")
print(" -j # splits the concatenated C++ source files into # pieces [default 1]")
print(" -k dir the KDE base directory")
print(" -L dir the library directory name [default lib]")
print(" -n dir the directory containing the KDE lib files")
print(" -o dir the directory containing the KDE header files")
print(" -r generates code with tracing enabled [default disabled]")
print(" -u build with debugging symbols")
print(" -v dir where the PyKDE .sip files will be installed [default %s]" % opt_pytdesipdir)
print(" -w turn on KDE deprecated object warnings when compiling [default off]")
print(" -z file the name of a file containing command line flags")
def inform_user(stage):
"""Tell the user the option values that are going to be used.
if stage == 0:
print(" PyKDE version %s" % pytde_version_str)
print(" -------")
sip_tqt_config.inform ("Python include directory is %s" % sipcfg.py_inc_dir)
sip_tqt_config.inform ("Python version is %s" % sip_tqt_config.version_to_string (sipcfg.py_version))
sip_tqt_config.inform ("sip-tqt version is %s (%s)" % (sipcfg.sip_version_str,
sip_tqt_config.version_to_string (sipcfg.sip_version)))
sip_tqt_config.inform ("TQt directory is %s" % pytqtcfg.tqt_dir)
sip_tqt_config.inform ("TQt version is %s" % sip_tqt_config.version_to_string (pytqtcfg.tqt_version))
sip_tqt_config.inform ("PyTQt directory is %s" % pytqtcfg.pytqt_sip_dir)
sip_tqt_config.inform ("PyTQt version is %s (%s)" % (pytqtcfg.pytqt_version_str,
sip_tqt_config.version_to_string (pytqtcfg.pytqt_version)))
elif stage == 1:
sip_tqt_config.inform ("KDE base directory is %s" % opt_tdebasedir)
sip_tqt_config.inform ("KDE include directory is %s" % opt_kdeincdir)
sip_tqt_config.inform ("KDE lib directory is %s" % opt_kdelibdir)
sip_tqt_config.inform ("lib directory is %s" % opt_libdir)
elif stage == 2:
sip_tqt_config.inform ("KDE version is %s (0x%x)" % (kde_version_str, kde_version))
sip_tqt_config.inform("PyKDE modules will be installed in %s" % opt_pytdemoddir)
sip_tqt_config.inform("PyKDE .sip files will be installed in %s" % opt_pytdesipdir)
def create_config(module, template):
"""Create the PyKDE configuration module so that it can be imported by build
module is the module file name.
template is the template file name.
sip_tqt_config.inform("Creating %s..." % module)
content = {
"pytde_version": pytde_version,
"pytde_version_str": pytde_version_str,
"kde_version": kde_version,
"kde_version_str": kde_version_str,
"kde_version_sfx": kde_version_sfx,
"kde_version_extra": kde_version_extra,
# "pytde_bin_dir": opt_pytdebindir,
"pytde_mod_dir": opt_pytdemoddir,
"pytde_sip_dir": opt_pytdesipdir,
"pytde_modules": pytde_modules,
"pytde_kde_sip_flags": kde_sip_flags,
"tdebasedir": opt_tdebasedir,
"kdelibdir": opt_kdelibdir,
"libdir": opt_libdir,
"kdeincdir": opt_kdeincdir,
"pytde_modules": pytde_modules,
"dist_name": opt_dist_name
sip_tqt_config.create_config_module(module, template, content)
def getKDEVersion (versFile):
if not os.path.isfile (versFile):
major = None
minor = None
micro = None
global kde_version, kde_version_str, kde_version_sfx, kde_version_extra
f = open (versFile)
l = f.readline ()
ok = 0
while not ok and l:
wl = l.split()
if len(wl) == 3 and wl[0] == "#define":
if wl[1] == "TDE_VERSION_MAJOR":
major = wl[2].strip()
if wl[1] == "TDE_VERSION_MINOR":
minor = wl[2].strip()
if wl[1] == "TDE_VERSION_RELEASE":
micro = wl[2].strip()
if major and minor and micro:
ok = 1
l = f.readline()
if micro >= "90" and minor == "2":
micro = "0"
minor = "3"
kde_version = (int (major) << 16) + (int (minor) << 8) + int (micro)
if kde_version > kde_max_version:
sip_tqt_config.inform ("*** True KDE version is %s -- building for KDE %s ***" % (hex (kde_version), hex (kde_max_version)))
kde_version = kde_max_version
major = hex ((kde_version & 0xff0000) >> 16) [ 2:]
minor = hex ((kde_version & 0x00ff00) >> 8) [ 2:]
micro = hex (kde_version & 0x0000ff) [ 2:]
if ok:
kde_version_str = ".".join([major, minor, micro])
kde_version_sfx = "".join(["-kde", major, minor, micro, ".diff"])
kde_version_extra = "".join(["kde", major, minor, micro])
sip_tqt_config.error ("KDE version not found in %s" % versFile)
global postProcess
def search (target, searchPath):
if not searchPath:
path = None
for searchEntry in searchPath:
if os.path.isdir (searchEntry)\
and (not target or os.path.isfile (os.path.join (searchEntry, target))):
path = searchEntry
return path
def discoverKDE3 ():
global opt_kdeincdir, opt_tdebasedir, opt_kdelibdir, opt_libdir
if not opt_tdebasedir:
kdeSearchPaths = []
libSearchPaths = []
incSearchPaths = []
kdeSearchPaths.append (os.environ ["TDEDIR"])
kdeSearchPaths.append (os.path.join ("/opt", "trinity"))
kdeSearchPaths.append ("/usr")
opt_tdebasedir = search (None, kdeSearchPaths)
if not opt_kdelibdir:
libSearchPaths = [os.path.join (opt_tdebasedir, "lib"), os.path.join (opt_tdebasedir, "lib64"), os.path.join (opt_tdebasedir, opt_libdir)]
# print opt_libdir
opt_kdelibdir = search ("", libSearchPaths)
if not opt_kdeincdir:
incSearchPaths = [os.path.join (opt_tdebasedir, "include")]
incSearchPaths.append (os.path.join (opt_tdebasedir, "include", "tde")) # Red Hat
opt_kdeincdir = search ("tdeapplication.h", incSearchPaths)
def check_kde_installation():
"""Check the KDE installation and get the version number
# Check the KDE header files have been installed.
discoverKDE3 ()
if not opt_tdebasedir:
sip_tqt_config.error ("Couldn't locate KDE3 base directory")
if not opt_kdeincdir:
sip_tqt_config.error ("Couldn't locate KDE3 include directory (%s is KDE base)" % opt_tdebasedir)
if not opt_kdelibdir:
sip_tqt_config.error ("Couldn't locate KDE3 lib directory (%s is KDE base)" % opt_tdebasedir)
tdeversion_h = os.path.join(opt_kdeincdir, "tdeversion.h")
inform_user (1)
if not os.access(tdeversion_h, os.F_OK):
sip_tqt_config.error("tdeversion.h could not be found in %s." % opt_kdeincdir)
# Get the KDE version number.
inform_user (2)
def create_top_level (mname):
""" Create the top level sip-tqt file <mname>mod.sip from <mname>mod.sip-in
and add/delete any %Included sip-tqt files per the current KDE version
diff = srcPath(os.path.join ("sip", mname, mname + kde_version_sfx))
plus = []
minus = []
if os.path.exists (diff):
d = open (diff)
line = d.readline()
while line:
if line.find ("+") == 0:
plus.append (line [2:])
elif line.find ("-") == 0:
minus.append (line [2:])
line = d.readline()
sipin = open (srcPath(os.path.join ("sip", mname, mname + "")))
sipout = open (srcPath(os.path.join ("sip", mname, mname + "mod.sip")), "w")
line = sipin.readline()
while line:
if line.find("%Include") == 0:
inclFound = 1
if minus and line in minus:
line = sipin.readline()
sipout.write (line)
elif line.find ("@mark@") == 0:
for p in plus:
sipout.write (p)
elif mname == "tdeabc" and kde_version < 0x030200 and line.find("tderesourcesmod.sip") >= 0:
sipout.write (line)
line = sipin.readline()
sipin.close ()
sipout.close ()
if mname == "tdehtml":
# PyKDE < 3.3.0 doesn't provide tdeutils (and tdehtml doesn't need it)
sippath = srcPath(os.path.join ("sip", mname))
if kde_version < 0x030300:
sipin = open (os.path.join (sippath, mname + "mod.sip"))
sipout = open (os.path.join (sippath, mname + ""), "w")
for line in sipin:
if line.find ("tdeutilsmod.sip") > 0:
sipout.write (line)
sipin.close ()
sipout.close ()
os.unlink (os.path.join (sippath, mname + "mod.sip"))
os.rename (os.path.join (sippath, mname + ""), os.path.join (sippath, mname + "mod.sip"))
os.system ("cp %s %s" % (os.path.join (sippath, "tdehtml_part.sip.323"), os.path.join (sippath, "tdehtml_part.sip")))
os.system ("cp %s %s" % (os.path.join (sippath, "tdehtml_part.sip.330"), os.path.join (sippath, "tdehtml_part.sip")))
def check_distribution ():
dist = glob.glob ("/etc/*-release")
kde_sip_flags.append ("-t")
kde_sip_flags.append ("ALL")
for file in dist:
if file.find ("andrake") > 0:
kde_sip_flags.append ("D_MANDRAKE")
def set_sip_flags():
"""Set the SIP-TQt platform, version and feature flags.
global kde_sip_flags
check_distribution ()
kde_sip_flags.append (pytqtcfg.pytqt_tqt_sip_flags)
kdetags = {
0x030001: "KDE_3_0_0",
0x030003: "KDE_3_0_1",
0x030100: "KDE_3_0_3",
0x030101: "KDE_3_1_0",
0x030102: "KDE_3_1_1",
0x030103: "KDE_3_1_2",
0x030104: "KDE_3_1_3",
0x030105: "KDE_3_1_4",
0x030200: "KDE_3_1_5",
0x030201: "KDE_3_2_0",
0x030202: "KDE_3_2_1",
0x030203: "KDE_3_2_2",
0x030300: "KDE_3_2_3",
0x030301: "KDE_3_3_0",
0x030302: "KDE_3_3_1",
0x030400: "KDE_3_3_2",
0x030401: "KDE_3_4_0",
0x030402: "KDE_3_4_1",
0x030403: "KDE_3_4_2",
0x030500: "KDE_3_4_3",
0x030501: "KDE_3_5_0",
0x030502: "KDE_3_5_1",
0x030503: "KDE_3_5_2",
0x040000: "KDE_3_5_3"
kde_sip_flags.append(sip_tqt_config.version_to_sip_tag(kde_version, kdetags, "KDE"))
def generate_code(mname, imports=None, extra_cflags=None, extra_cxxflags=None, extra_define=None, extra_include_dir=None, extra_lflags=None, extra_lib_dir=None, extra_lib=None, extra_libs=None, opengl=0, sip_flags=None):
"""Generate the code for a module.
mname is the name of the module.
imports is the list of PyTQt/PyKDE modules that this one %Imports.
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_dir is the name of a directory to add to the list of include
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
extra_lib is the name of an extra library 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)
create_top_level (mname)
#create_top_level (mname)
sip_tqt_config.error ("Couldn't create top level sip-tqt file for %s" % mname)
sip_tqt_config.error("Unable to create the %s directory." % mname)
# Build the SIP-TQt command line.
argv = [sipcfg.sip_bin]
if opt_concat:
if mname == "tdeui" and opt_split == 1:
splits = 2
splits = opt_split
if opt_tracing:
if opt_releasegil:
buildfile = os.path.join(mname, mname + ".sbf")
pytqtInclPathSeen = 0
for mod in pytde_imports [mname]:
if mod.find("PyTQt.tq") == 0 and not pytqtInclPathSeen:
argv.append ("-I")
argv.append (pytqtcfg.pytqt_sip_dir)
pytqtInclPathSeen = 1
elif mod == "dcop" or mod.find("k") == 0 or mod.find("tde") == 0:
subdir = os.path.join(srcPath("sip"), mod)
# SIP-TQt assumes POSIX style path separators.
argv.append(srcPath("/".join(["sip", mname, mname + "mod.sip"])))
# finally, run SIP-TQt and generate the C++ code
os.system (" ".join(argv))
# post process the C++ code for TQT_NO_TRANSLATION
if os.system (" ".join ([sys.executable, srcPath("postproc")] + ['-p', mname, "-o", "tr", "*.cpp"])) != 0:
sip_tqt_config.error ("Post processing of C++ code failed %s (tr)" % mname)
# Check the result.
if not os.access(buildfile, os.F_OK):
sip_tqt_config.error("Unable to create the C++ code.")
if mname == "tdecore" and not opt_concat:
postProcess ["tdecore"][-1][-1] = "tdecorecmodule.*"
# Compile the Python stub.
if sipcfg.sip_version < 0x040000:
sip_tqt_config.inform("Compiling" % mname)
py_compile.compile(os.path.join(mname, mname + ".py"), os.path.join(mname, mname + ".pyc"))
elif mname == "tdecore":
postProcess ["tdecore"][-1][-1] = "sip" + postProcess ["tdecore"][-1][-1]
# needs to be here (not earlier) to catch .py files if any
if postProcess [mname]:
for s in postProcess [mname]:
if os.system (" ".join ([sys.executable, srcPath("postproc")] + s)) != 0:
sip_tqt_config.error ("Post processing of C++ code failed %s (%s)" % (mname, s [3]))
# Generate the Makefile.
sip_tqt_config.inform("Creating the Makefile for the %s module..." % mname)
installs = []
if mname == "dcop":
if has_objdir:
installs.append ([[srcPath("extensions/"), srcPath("extensions/")], opt_pytdemoddir])
installs.append ([["../extensions/", "../extensions/"], opt_pytdemoddir])
if sipcfg.sip_version >= 0x040000:
warnings = 1
warnings = 0
installs.append([[mname + ".py", mname + ".pyc"], opt_pytdemoddir])
sipfiles = []
# for s in glob.glob("sip/*.sip"):
# sipfiles.append(os.path.join("..", "sip", os.path.basename(s)))
for s in os.listdir (srcPath(os.path.join ("sip", mname))):
if s.endswith (".sip"):
if has_objdir:
sipfiles.append(srcPath(os.path.join("sip", mname, os.path.basename(s))))
sipfiles.append(os.path.join("..", "sip", mname, os.path.basename(s)))
installs.append([sipfiles, os.path.join(opt_pytdesipdir, mname)])
makefile = sip_tqt_config.SIPModuleMakefile(
configuration = pytqtcfg,
build_file = mname + ".sbf",
dir = mname,
install_dir = opt_pytdemoddir,
installs = installs,
tqt = 1,
opengl = opengl,
warnings = warnings,
static = opt_static,
debug = opt_debug,
if extra_cflags:
if extra_cxxflags:
if opt_dep_warnings == 0:
makefile.extra_cflags.append ("-Wno-deprecated-declarations")
makefile.extra_cxxflags.append ("-Wno-deprecated-declarations")
if extra_define:
if has_objdir:
makefile.extra_include_dirs.append (srcPath(os.path.join("extra", kde_version_extra)))
makefile.extra_include_dirs.append (os.path.join ("..", "extra", kde_version_extra))
makefile.extra_include_dirs.append (opt_kdeincdir)
if kde_includes [mname]:
for incdir in kde_includes [mname]:
if "/" not in incdir:
makefile.extra_include_dirs.append (os.path.join (opt_kdeincdir, incdir))
makefile.extra_include_dirs.append (incdir)
if extra_include_dir:
makefile.extra_include_dirs.append ("/usr/include/tqt")
if extra_lflags:
makefile.extra_lib_dirs.append (opt_kdelibdir)
if extra_lib_dir:
if extra_lib == "dcop":
extra_lib = "DCOP"
elif extra_lib == "tdefile":
extra_lib = "tdeio"
if extra_lib == "tdefx":
makefile.extra_libs.append ("tdecore")
if extra_lib == "tdespell":
makefile.extra_libs.append ("tdeui")
if extra_lib == "tdeabc" and kde_version >= 0x030200:
makefile.extra_libs.append ("tdeabc_file")
if extra_lib == "tdeparts" and kde_version >= 0x030500:
makefile.extra_lib_dirs.append (os.path.join (opt_kdelibdir, "trinity"))
if extra_lib == "tdeprint":
makefile.extra_cflags.append ("-fno-rtti")
makefile.extra_cxxflags.append ("-fno-rtti")
if extra_libs:
if sipcfg.sip_version < 0x040000 and imports:
# Inter-module links.
for im in imports:
makefile.extra_lib_dirs.insert(0, os.path.join("..", im))
makefile.extra_libs.insert(0, makefile.module_as_lib(im))
def create_makefiles():
"""Create the additional Makefiles.
subdirs = pytde_modules[:]
sip_tqt_config.inform("Creating top level Makefile...")
configuration = pytqtcfg,
subdirs = subdirs,
installs= [("", opt_pytdemoddir), (srcPath("contrib/tdepyuic"), opt_tdebasedir + "/bin")]
def fileOpts (fn):
optfile = open (fn, 'r')
error ("Could not open option file %s" % (fn))
opts = []
for line in optfile.readlines ():
if (line [0] == '#') or (line == '\n'):
elif line [0] == '-':
opts.append ((line [0:2], line[2:].strip()))
opts.append (("-" + line [0:1], line[1:].strip()))
print('Additional options: ', end=' ')
for opt, arg in opts:
print("%s %s " %(opt, arg))
return opts
def main(argv):
"""Create the configuration module module.
argv is the list of command line arguments.
optlist, args = getopt.getopt(argv[1:], "hcd:e:gij:k:L:l:n:o:ruv:wz:")
except getopt.GetoptError:
global opt_pytdemoddir, opt_pytdesipdir
global opt_debug, opt_concat, opt_releasegil
global opt_split, opt_tracing, opt_startModName
global opt_startmod, opt_endmod
global opt_tdebasedir, opt_kdelibdir, opt_kdeincdir, opt_libdir
global pytde_modules, opt_dep_warnings, opt_dist_name
global pytde_imports, kde_includes
global opt_libpython
opt_libpython = None
# Look for '-z' first and process that switch
# (command line switches override file switches)
for opt, arg in optlist:
if opt == "-z":
optlist = fileOpts (arg) + optlist
elif opt == "-h":
usage (0)
if args: usage()
for opt, arg in optlist:
if opt == "-h":
elif opt == "-e":
opt_libpython = arg
# turns on concatentation (on by default, here for consistency)
elif opt == "-c":
opt_concat = 1
elif opt == "-d":
opt_pytdemoddir = arg
elif opt == "-g":
opt_releasegil = 1
# turns off concatenation (on by default)
elif opt == "-i":
opt_concat = 0
elif opt == "-j":
opt_split = int(arg)
elif opt == "-k":
opt_tdebasedir = arg
elif opt == "-L":
opt_libdir = arg
# allows build of single module (-lmodule) or all modules
# beginning at specified module (-lmodule:)
elif opt == "-l":
opt_startModName = arg
elif opt == "-n":
opt_kdelibdir = arg
elif opt == "-o":
opt_kdeincdir = arg
elif opt == "-r":
opt_tracing = 1
elif opt == "-u":
opt_debug = 1
elif opt == "-v":
opt_pytdesipdir = arg
elif opt == "-w":
opt_dep_warnings = 1
inform_user (0)
init_and_check_sanity ()
# Set the SIP-TQt platform, version and feature flags.
if kde_version < 0x030200:
pytde_modules.remove ("tdemdi")
pytde_modules.remove ("tderesources")
pytde_imports ["tdeabc"].remove ("tderesources")
kde_includes ["tdeabc"].remove ("tderesources")
if kde_version < 0x030300:
pytde_modules.remove ("tdeutils")
# pytde_modules.remove ("tdespell2")
pytde_imports ["tdehtml"].remove ("tdeutils")
opt_endmod = len (pytde_modules)
if opt_startModName != "":
if opt_startModName in pytde_modules:
single = opt_startModName [-1] != ":"
if not single:
opt_startModName = opt_startModName [:-1]
opt_startmod = pytde_modules.index (opt_startModName)
if single:
opt_endmod = opt_startmod + 1
sip_tqt_config.error ("%s is not a PyKDE module" % opt_startModName)
print("PyKDE modules to be built:\n %s\n" % " ".join(pytde_modules[opt_startmod:opt_endmod]))
for module in pytde_modules [opt_startmod:opt_endmod]:
extra_libs = []
if opt_libpython:
generate_code (module, pytde_imports [module], extra_lib = module, extra_libs = extra_libs)
# Create the additional Makefiles.
# Install the configuration module.
create_config("", srcPath(""))
def reporting_msg ():
If reporting errors, paste all of the output above into your
message and post to the PyKDE mailing list at:
You can redirect the output into a file (> output.txt) if needed
# The script starts here.
if __name__ == "__main__":
except SystemExit:
reporting_msg ()
reporting_msg ()
An internal error occured. Please report all output from the program,
including the following traceback, to the PyKDE mailing list