diff options
Diffstat (limited to 'bksys/kde.py')
| -rw-r--r-- | bksys/kde.py | 884 |
1 files changed, 884 insertions, 0 deletions
diff --git a/bksys/kde.py b/bksys/kde.py new file mode 100644 index 0000000..1055a7e --- /dev/null +++ b/bksys/kde.py @@ -0,0 +1,884 @@ +# Thomas Nagy, 2005 <tnagy2^[email protected]> +""" Run scons -h to display the associated help, or look below """ + +import os, re, types +from SCons.Script.SConscript import SConsEnvironment + +# Returns the name of the shared object (eg: libkdeui.so.4) +# referenced by a libtool archive (like libkdeui.la) +def getSOfromLA(lafile): + contents = open(lafile, 'r').read() + match = re.search("^dlname='([^']*)'$", contents, re.M) + if match: return match.group(1) + return None + +# A helper, needed .. everywhere +def KDEuse(lenv, flags): + if lenv['HELP']: lenv.Exit(0) + + _flags=lenv.make_list(flags) + if 'environ' in _flags: + ## The scons developers advise against using this but it is mostly innocuous :) + lenv.AppendUnique( ENV = os.environ ) + if not 'lang_qt' in _flags: + ## Use this define if you are using the kde translation scheme (.po files) + lenv.Append( CPPFLAGS = '-DQT_NO_TRANSLATION' ) + if 'rpath' in _flags: + ## Use this to set rpath - this may cause trouble if folders are moved (chrpath) + kdelibpaths=[] + if lenv['KDELIBPATH'] == lenv['KDELIB']: kdelibpaths = [lenv['KDELIB']] + else: kdelibpaths = [lenv['KDELIBPATH'], lenv['KDELIB']] + lenv.Append( RPATH = [lenv['QTLIBPATH'], lenv['KDEMODULE']]+kdelibpaths ) + if 'thread' in _flags: + ## Uncomment the following if you need threading support + lenv.KDEaddflags_cxx( ['-DQT_THREAD_SUPPORT', '-D_REENTRANT'] ) + if 'fastmoc' in _flags: + lenv['BKSYS_FASTMOC']=1 + if 'dump' in _flags: + lenv['DUMPCONFIG']=1 + if not 'nohelp' in _flags: + if lenv['_CONFIGURE'] or lenv['HELP']: lenv.Exit(0) + if not 'nosmart' or not lenv.has_key('nosmart_includes'): + lenv.AppendUnique(CPPPATH=['#/']) + lst=[] + if lenv.has_key('USE_THE_FORCE_LUKE'): + lst=lenv['USE_THE_FORCE_LUKE'] + lenv.__delitem__('USE_THE_FORCE_LUKE') + for v in lst: v.execute() + else: lenv['nosmart_includes']=1 + + ## To use kdDebug(intvalue)<<"some trace"<<endl; you need to define -DDEBUG + ## it is done in admin/generic.py automatically when you do scons configure debug=1 + +def exists(env): + return True + +def detect_kde(env): + """ Detect the qt and kde environment using kde-config mostly """ + def getpath(varname): + if not env.has_key('ARGS'): return None + v=env['ARGS'].get(varname, None) + if v: v=os.path.abspath(v) + return v + + def getstr(varname): + if env.has_key('ARGS'): return env['ARGS'].get(varname, '') + return '' + + prefix = getpath('prefix') + execprefix = getpath('execprefix') + datadir = getpath('datadir') + libdir = getpath('libdir') + + kdedir = getstr('kdedir') + kdeincludes = getpath('kdeincludes') + kdelibs = getpath('kdelibs') + + qtdir = getstr('qtdir') + qtincludes = getpath('qtincludes') + qtlibs = getpath('qtlibs') + libsuffix = getstr('libsuffix') + + p=env.pprint + + if libdir: libdir = libdir+libsuffix + + ## Detect the kde libraries + print "Checking for kde-config : ", + str="which kde-config 2>/dev/null" + if kdedir: str="which %s 2>/dev/null" % (kdedir+'/bin/kde-config') + kde_config = os.popen(str).read().strip() + if len(kde_config): + p('GREEN', 'kde-config was found as '+kde_config) + else: + if kdedir: p('RED','kde-config was NOT found in the folder given '+kdedir) + else: p('RED','kde-config was NOT found in your PATH') + print "Make sure kde is installed properly" + print "(missing package kdebase-devel?)" + env.Exit(1) + if kdedir: env['KDEDIR']=kdedir + else: env['KDEDIR'] = os.popen(kde_config+' -prefix').read().strip() + + print "Checking for kde version : ", + kde_version = os.popen(kde_config+" --version|grep KDE").read().strip().split()[1] + if int(kde_version[0]) != 3 or int(kde_version[2]) < 2: + p('RED', kde_version) + p('RED',"Your kde version can be too old") + p('RED',"Please make sure kde is at least 3.2") + else: + p('GREEN',kde_version) + + ## Detect the qt library + print "Checking for the qt library : ", + if not qtdir: qtdir = os.getenv("QTDIR") + if qtdir: + p('GREEN',"qt is in "+qtdir) + else: + try: + tmplibdir = os.popen(kde_config+' --expandvars --install lib').read().strip() + libkdeuiSO = env.join(tmplibdir, getSOfromLA(env.join(tmplibdir,'/libkdeui.la')) ) + m = re.search('(.*)/lib/libqt.*', os.popen('ldd ' + libkdeuiSO + ' | grep libqt').read().strip().split()[2]) + except: m=None + if m: + qtdir = m.group(1) + p('YELLOW',"qt was found as "+m.group(1)) + else: + p('RED','qt was not found') + p('RED','Please set QTDIR first (/usr/lib/qt3?) or try scons -h for more options') + env.Exit(1) + env['QTDIR'] = qtdir.strip() + + ## Find the necessary programs uic and moc + print "Checking for uic : ", + uic = qtdir + "/bin/uic" + if os.path.isfile(uic): + p('GREEN',"uic was found as "+uic) + else: + uic = os.popen("which uic 2>/dev/null").read().strip() + if len(uic): + p('YELLOW',"uic was found as "+uic) + else: + uic = os.popen("which uic 2>/dev/null").read().strip() + if len(uic): + p('YELLOW',"uic was found as "+uic) + else: + p('RED',"uic was not found - set QTDIR put it in your PATH ?") + env.Exit(1) + env['QT_UIC'] = uic + + print "Checking for moc : ", + moc = qtdir + "/bin/moc" + if os.path.isfile(moc): + p('GREEN',"moc was found as "+moc) + else: + moc = os.popen("which moc 2>/dev/null").read().strip() + if len(moc): + p('YELLOW',"moc was found as "+moc) + elif os.path.isfile("/usr/share/qt3/bin/moc"): + moc = "/usr/share/qt3/bin/moc" + p('YELLOW',"moc was found as "+moc) + else: + p('RED',"moc was not found - set QTDIR or put it in your PATH ?") + env.Exit(1) + env['QT_MOC'] = moc + + ## check for the qt and kde includes + print "Checking for the qt includes : ", + if qtincludes and os.path.isfile(qtincludes + "/qlayout.h"): + # The user told where to look for and it looks valid + p('GREEN',"ok "+qtincludes) + else: + if os.path.isfile(qtdir + "/include/qlayout.h"): + # Automatic detection + p('GREEN',"ok "+qtdir+"/include/") + qtincludes = qtdir + "/include/" + elif os.path.isfile("/usr/include/qt3/qlayout.h"): + # Debian probably + p('YELLOW','the qt headers were found in /usr/include/qt3/') + qtincludes = "/usr/include/qt3" + else: + p('RED',"the qt headers were not found") + env.Exit(1) + + print "Checking for the kde includes : ", + kdeprefix = os.popen(kde_config+" --prefix").read().strip() + if not kdeincludes: + kdeincludes = kdeprefix+"/include/" + if os.path.isfile(kdeincludes + "/klineedit.h"): + p('GREEN',"ok "+kdeincludes) + else: + if os.path.isfile(kdeprefix+"/include/kde/klineedit.h"): + # Debian, Fedora probably + p('YELLOW',"the kde headers were found in %s/include/kde/"%kdeprefix) + kdeincludes = kdeprefix + "/include/kde/" + else: + p('RED',"The kde includes were NOT found") + env.Exit(1) + + # kde-config options + kdec_opts = {'KDEBIN' : 'exe', 'KDEAPPS' : 'apps', + 'KDEDATA' : 'data', 'KDEICONS' : 'icon', + 'KDEMODULE' : 'module', 'KDELOCALE' : 'locale', + 'KDEKCFG' : 'kcfg', 'KDEDOC' : 'html', + 'KDEMENU' : 'apps', 'KDEXDG' : 'xdgdata-apps', + 'KDEMIME' : 'mime', 'KDEXDGDIR' : 'xdgdata-dirs', + 'KDESERV' : 'services','KDESERVTYPES' : 'servicetypes', + 'KDEINCLUDE': 'include' } + + if prefix: + ## use the user-specified prefix + if not execprefix: execprefix=prefix + if not datadir: datadir=env.join(prefix,'share') + if not libdir: libdir=env.join(execprefix, "lib"+libsuffix) + + subst_vars = lambda x: x.replace('${exec_prefix}', execprefix)\ + .replace('${datadir}', datadir)\ + .replace('${libdir}', libdir)\ + .replace('${prefix}', prefix) + debian_fix = lambda x: x.replace('/usr/share', '${datadir}') + env['PREFIX'] = prefix + env['KDELIB'] = libdir + for (var, option) in kdec_opts.items(): + dir = os.popen(kde_config+' --install ' + option).read().strip() + if var == 'KDEDOC': dir = debian_fix(dir) + env[var] = subst_vars(dir) + + else: + env['PREFIX'] = os.popen(kde_config+' --expandvars --prefix').read().strip() + env['KDELIB'] = os.popen(kde_config+' --expandvars --install lib').read().strip() + for (var, option) in kdec_opts.items(): + dir = os.popen(kde_config+' --expandvars --install ' + option).read().strip() + env[var] = dir + + env['QTPLUGINS']=os.popen(kde_config+' --expandvars --install qtplugins').read().strip() + + ## kde libs and includes + env['KDEINCLUDEPATH']=kdeincludes + if not kdelibs: + kdelibs=os.popen(kde_config+' --expandvars --install lib').read().strip() + env['KDELIBPATH']=kdelibs + + ## qt libs and includes + env['QTINCLUDEPATH']=qtincludes + if not qtlibs: + qtlibs=qtdir+"/lib"+libsuffix + env['QTLIBPATH']=qtlibs + +def generate(env): + """"Set up the qt and kde environment and builders - the moc part is difficult to understand """ + + # attach this function immediately + SConsEnvironment.KDEuse=KDEuse + + if env['HELP']: + p=env.pprint + p('BOLD','*** KDE options ***') + p('BOLD','--------------------') + p('BOLD','* prefix ','base install path, ie: /usr/local') + p('BOLD','* execprefix ','install path for binaries, ie: /usr/bin') + p('BOLD','* datadir ','install path for the data, ie: /usr/local/share') + p('BOLD','* libdir ','install path for the libs, ie: /usr/lib') + + p('BOLD','* qtdir ','base of the kde libraries') + p('BOLD','* kdedir ','base of the qt libraries') + + p('BOLD','* libsuffix ','suffix of libraries on amd64, ie: 64, 32') + p('BOLD','* kdeincludes','kde includes path (/usr/include/kde on debian, ..)') + p('BOLD','* qtincludes ','qt includes path (/usr/include/qt on debian, ..)') + p('BOLD','* kdelibs ','kde libraries path, for linking the programs') + p('BOLD','* qtlibs ','qt libraries path, for linking the program') + + p('BOLD','* scons configure libdir=/usr/local/lib qtincludes=/usr/include/qt\n') + return + + import SCons.Defaults + import SCons.Tool + import SCons.Util + import SCons.Node + + def reldir(dir): + ndir = SCons.Node.FS.default_fs.Dir(dir).srcnode().abspath + rootdir = SCons.Node.FS.default_fs.Dir('#').abspath + return ndir.replace(rootdir, '').lstrip('/') + + def relfile(file): + nfile = SCons.Node.FS.default_fs.File(file).srcnode().abspath + rootdir = SCons.Node.FS.default_fs.Dir('#').abspath + return nfile.replace(rootdir, '').lstrip('/') + + CLVar = SCons.Util.CLVar + splitext = SCons.Util.splitext + Builder = SCons.Builder.Builder + + # Detect the environment - replaces ./configure implicitely and store the options into a cache + from SCons.Options import Options + cachefile=env['CACHEDIR']+'kde.cache.py' + opts = Options(cachefile) + opts.AddOptions( + ('PREFIX', 'root of the program installation'), + + ('QTDIR', ''), + ('QTLIBPATH', 'path to the qt libraries'), + ('QTINCLUDEPATH', 'path to the qt includes'), + ('QT_UIC', 'uic command'), + ('QT_MOC', 'moc command'), + ('QTPLUGINS', 'uic executable command'), + + ('KDEDIR', ''), + ('KDELIBPATH', 'path to the installed kde libs'), + ('KDEINCLUDEPATH', 'path to the installed kde includes'), + + ('KDEBIN', 'inst path of the kde binaries'), + ('KDEINCLUDE', 'inst path of the kde include files'), + ('KDELIB', 'inst path of the kde libraries'), + ('KDEMODULE', 'inst path of the parts and libs'), + ('KDEDATA', 'inst path of the application data'), + ('KDELOCALE', ''), ('KDEDOC', ''), ('KDEKCFG', ''), + ('KDEXDG', ''), ('KDEXDGDIR', ''), ('KDEMENU', ''), + ('KDEMIME', ''), ('KDEICONS', ''), ('KDESERV', ''), + ('KDESERVTYPES', ''), ('KDEAPPS', ''), + ) + opts.Update(env) + + def getInstDirForResType(lenv,restype): + if len(restype) == 0 or not lenv.has_key(restype): + lenv.pprint('RED',"unknown resource type "+restype) + lenv.Exit(1) + else: instdir = lenv[restype] + + if env['ARGS'] and env['ARGS'].has_key('prefix'): + instdir = instdir.replace(lenv['PREFIX'], env['ARGS']['prefix']) + return instdir + + # reconfigure when things are missing + if not env['HELP'] and (env['_CONFIGURE'] or not env.has_key('QTDIR') or not env.has_key('KDEDIR')): + detect_kde(env) + opts.Save(cachefile, env) + + ## set default variables, one can override them in sconscript files + env.Append(CXXFLAGS = ['-I'+env['KDEINCLUDEPATH'], '-I'+env['QTINCLUDEPATH'] ], + LIBPATH = [env['KDELIBPATH'], env['QTLIBPATH'] ]) + + env['QT_AUTOSCAN'] = 1 + env['QT_DEBUG'] = 0 + + env['MEINPROC'] = 'meinproc' + env['MSGFMT'] = 'msgfmt' + + ## ui file processing + def uic_processing(target, source, env): + inc_kde ='#include <klocale.h>\n#include <kdialog.h>\n' + inc_moc ='#include "%s"\n' % target[2].name + comp_h ='$QT_UIC -L $QTPLUGINS -nounload -o %s %s' % (target[0].path, source[0].path) + comp_c ='$QT_UIC -L $QTPLUGINS -nounload -tr tr2i18n -impl %s %s' % (target[0].path, source[0].path) + comp_moc ='$QT_MOC -o %s %s' % (target[2].path, target[0].path) + if env.Execute(comp_h): return ret + dest = open( target[1].path, "w" ) + dest.write(inc_kde) + dest.close() + if env.Execute( comp_c+" >> "+target[1].path ): return ret + dest = open( target[1].path, "a" ) + dest.write(inc_moc) + dest.close() + ret = env.Execute( comp_moc ) + return ret + def uicEmitter(target, source, env): + adjustixes = SCons.Util.adjustixes + bs = SCons.Util.splitext(str(source[0].name))[0] + bs = env.join(str(target[0].get_dir()),bs) + target.append(bs+'.cpp') + target.append(bs+'.moc') + return target, source + env['BUILDERS']['Uic']=Builder(action=uic_processing,emitter=uicEmitter,suffix='.h',src_suffix='.ui') + + def kcfg_buildit(target, source, env): + comp='kconfig_compiler -d%s %s %s' % (str(source[0].get_dir()), source[1].path, source[0].path) + return env.Execute(comp) + def kcfg_stringit(target, source, env): + print "processing %s to get %s and %s" % (source[0].name, target[0].name, target[1].name) + def kcfgEmitter(target, source, env): + adjustixes = SCons.Util.adjustixes + file=str(source[0].srcnode().name) + bs = SCons.Util.splitext(str(source[0].name))[0] + bs = env.join(str(target[0].get_dir()),bs) + # .h file is already there + target.append( bs+'.cpp' ) + + content=source[0].srcnode().get_contents() + + kcfgfilename="" + kcfgFileDeclRx = re.compile("[fF]ile\s*=\s*(.+)\s*") + match = kcfgFileDeclRx.search(content) + if match: kcfgfilename = match.group(1) + + if not kcfgfilename: + env.pprint('RED','invalid kcfgc file '+source[0].srcnode().abspath) + env.Exit(1) + source.append( env.join( str(source[0].get_dir()), kcfgfilename) ) + return target, source + + env['BUILDERS']['Kcfg']=Builder(action=env.Action(kcfg_buildit, kcfg_stringit), + emitter=kcfgEmitter, suffix='.h', src_suffix='.kcfgc') + + ## MOC processing + env['BUILDERS']['Moc']=Builder(action='$QT_MOC -o $TARGET $SOURCE',suffix='.moc',src_suffix='.h') + env['BUILDERS']['Moccpp']=Builder(action='$QT_MOC -o $TARGET $SOURCE',suffix='_moc.cpp',src_suffix='.h') + + ## KIDL file + env['BUILDERS']['Kidl']=Builder(action= 'dcopidl $SOURCE > $TARGET || (rm -f $TARGET ; false)', + suffix='.kidl', src_suffix='.h') + ## DCOP + env['BUILDERS']['Dcop']=Builder(action='dcopidl2cpp --c++-suffix cpp --no-signals --no-stub $SOURCE', + suffix='_skel.cpp', src_suffix='.kidl') + ## STUB + env['BUILDERS']['Stub']=Builder(action= 'dcopidl2cpp --c++-suffix cpp --no-signals --no-skel $SOURCE', + suffix='_stub.cpp', src_suffix='.kidl') + ## DOCUMENTATION + env['BUILDERS']['Meinproc']=Builder(action='cd $TARGET.dir && $MEINPROC --check --cache $TARGET.name $SOURCE.name', + suffix='.cache.bz2') + ## TRANSLATIONS + env['BUILDERS']['Transfiles']=Builder(action='$MSGFMT $SOURCE -o $TARGET',suffix='.gmo',src_suffix='.po') + + ## Handy helpers for building kde programs + ## You should not have to modify them .. + + ui_ext = [".ui"] + kcfg_ext = ['.kcfgc'] + header_ext = [".h", ".hxx", ".hpp", ".hh"] + cpp_ext = [".cpp", ".cxx", ".cc"] + skel_ext = [".skel", ".SKEL"] + stub_ext = [".stub", ".STUB"] + + def KDEfiles(lenv, target, source): + """ Returns a list of files for scons (handles kde tricks like .skel) + It also makes custom checks against double includes like : ['file.ui', 'file.cpp'] + (file.cpp is already included because of file.ui) """ + + # ITA + #print "kdefiles" + + q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]') + def scan_moc(cppfile): + addfile=None + + # try to find the header + orifile=cppfile.srcnode().name + bs=SCons.Util.splitext(orifile)[0] + + h_file='' + dir=cppfile.dir + for n_h_ext in header_ext: + afile=dir.File(bs+n_h_ext) + if afile.rexists(): + #h_ext=n_h_ext + h_file=afile + break + # We have the header corresponding to the cpp file + if h_file: + h_contents = h_file.get_contents() + if q_object_search.search(h_contents): + # we know now there is Q_OBJECT macro + reg = '\n\s*#include\s*("|<)'+str(bs)+'.moc("|>)' + meta_object_search = re.compile(reg) + #cpp_contents = open(file_cpp, 'rb').read() + cpp_contents=cppfile.get_contents() + if meta_object_search.search(cpp_contents): + lenv.Moc(h_file) + else: + lenv.Moccpp(h_file) + addfile=bs+'_moc.cpp' + print "WARNING: moc.cpp for "+h_file.name+" consider using #include <file.moc> instead" + return addfile + + src=[] + ui_files=[] + kcfg_files=[] + other_files=[] + kidl=[] + + source_=lenv.make_list(source) + + # For each file, check wether it is a dcop file or not, and create the complete list of sources + for file in source_: + + sfile=SCons.Node.FS.default_fs.File(str(file)) # why str(file) ? because ordinal not in range issues + bs = SCons.Util.splitext(file)[0] + ext = SCons.Util.splitext(file)[1] + if ext in skel_ext: + if not bs in kidl: + kidl.append(bs) + lenv.Dcop(bs+'.kidl') + src.append(bs+'_skel.cpp') + elif ext in stub_ext: + if not bs in kidl: + kidl.append(bs) + lenv.Stub(bs+'.kidl') + src.append(bs+'_stub.cpp') + elif ext == ".moch": + lenv.Moccpp(bs+'.h') + src.append(bs+'_moc.cpp') + elif ext in cpp_ext: + src.append(file) + if not env.has_key('NOMOCFILE'): + ret = scan_moc(sfile) + if ret: src.append( sfile.dir.File(ret) ) + elif ext in ui_ext: + lenv.Uic(file) + src.append(bs+'.cpp') + elif ext in kcfg_ext: + name=SCons.Util.splitext(sfile.name)[0] + hfile=lenv.Kcfg(file) + cppkcfgfile=sfile.dir.File(bs+'.cpp') + src.append(bs+'.cpp') + else: + src.append(file) + + for base in kidl: lenv.Kidl(base+'.h') + + # Now check against typical newbie errors + for file in ui_files: + for ofile in other_files: + if ofile == file: + env.pprint('RED',"WARNING: You have included %s.ui and another file of the same prefix"%file) + print "Files generated by uic (file.h, file.cpp must not be included" + for file in kcfg_files: + for ofile in other_files: + if ofile == file: + env.pprint('RED',"WARNING: You have included %s.kcfg and another file of the same prefix"%file) + print "Files generated by kconfig_compiler (settings.h, settings.cpp) must not be included" + # ITA + #print "end kdefiles" + return src + + + """ In the future, these functions will contain the code that will dump the + configuration for re-use from an IDE """ + def KDEinstall(lenv, restype, subdir, files, perms=None): + if env.has_key('DUMPCONFIG'): + ret= "<install type=\"%s\" subdir=\"%s\">\n" % (restype, subdir) + for i in lenv.make_list(files): + ret += " <file name=\"%s\"/>\n" % (relfile(i)) + ret += "</install>\n" + lenv.add_dump(ret) + return None + + if not env['_INSTALL']: return None + dir = getInstDirForResType(lenv, restype) + + p=None + if not perms: + if restype=='KDEBIN': p=0755 + else: p=perms + install_list = lenv.bksys_install(lenv.join(dir, subdir), files, perms=p) + return install_list + + def KDEinstallas(lenv, restype, destfile, file): + if not env['_INSTALL']: return + dir = getInstDirForResType(lenv, restype) + install_list = lenv.InstallAs(lenv.join(dir, destfile), file) + env.Alias('install', install_list) + return install_list + + def KDEprogram(lenv, target, source, + includes='', localshlibs='', globallibs='', globalcxxflags=''): + """ Makes a kde program + The program is installed except if one sets env['NOAUTOINSTALL'] """ + src = KDEfiles(lenv, target, source) + program_list = lenv.Program(target, src) + + # we link the program against a shared library done locally, add the dependency + if not lenv.has_key('nosmart_includes'): + lenv.AppendUnique(CPPPATH=['./']) + if len(localshlibs)>0: + lst=lenv.make_list(localshlibs) + lenv.link_local_shlib(lst) + lenv.Depends( program_list, lst ) + + if len(includes)>0: lenv.KDEaddpaths_includes(includes) + if len(globallibs)>0: lenv.KDEaddlibs(globallibs) + if len(globalcxxflags)>0: lenv.KDEaddflags_cxx(globalcxxflags) + + if not lenv.has_key('NOAUTOINSTALL'): + KDEinstall(lenv, 'KDEBIN', '', target) + return program_list + + def KDEshlib(lenv, target, source, kdelib=0, libprefix='lib', + includes='', localshlibs='', globallibs='', globalcxxflags='', vnum=''): + """ Makes a shared library for kde (.la file for klibloader) + The library is installed except if one sets env['NOAUTOINSTALL'] """ + src = KDEfiles(lenv, target, source) + + if not lenv.has_key('nosmart_includes'): + lenv.AppendUnique(CPPPATH=['./']) + # we link the program against a shared library done locally, add the dependency + lst=[] + if len(localshlibs)>0: + lst=lenv.make_list(localshlibs) + lenv.link_local_shlib(lst) + if len(includes)>0: lenv.KDEaddpaths_includes(includes) + if len(globallibs)>0: lenv.KDEaddlibs(globallibs) + if len(globalcxxflags)>0: lenv.KDEaddflags_cxx(globalcxxflags) + + restype='KDEMODULE' + if kdelib==1: restype='KDELIB' + + library_list = lenv.bksys_shlib(target, src, getInstDirForResType(lenv, restype), libprefix, vnum) + if len(lst)>0: lenv.Depends( library_list, lst ) + + return library_list + + def KDEstaticlib(lenv, target, source): + """ Makes a static library for kde - in practice you should not use static libraries + 1. they take more memory than shared ones + 2. makefile.am needed it because of limitations + (cannot handle sources in separate folders - takes extra processing) """ + if not lenv.has_key('nosmart_includes'): lenv.AppendUnique(CPPPATH=['./']) + src=KDEfiles(lenv, target, source) + return lenv.StaticLibrary(target, src) + # do not install static libraries by default + + def KDEaddflags_cxx(lenv, fl): + """ Compilation flags for C++ programs """ + lenv.AppendUnique(CXXFLAGS = lenv.make_list(fl)) + + def KDEaddflags_c(lenv, fl): + """ Compilation flags for C programs """ + lenv.AppendUnique(CFLAGS = lenv.make_list(fl)) + + def KDEaddflags_link(lenv, fl): + """ Add link flags - Use this if KDEaddlibs below is not enough """ + lenv.PrependUnique(LINKFLAGS = lenv.make_list(fl)) + + def KDEaddlibs(lenv, libs): + """ Helper function """ + lenv.AppendUnique(LIBS = lenv.make_list(libs)) + + def KDEaddpaths_includes(lenv, paths): + """ Add new include paths """ + lenv.AppendUnique(CPPPATH = lenv.make_list(paths)) + + def KDEaddpaths_libs(lenv, paths): + """ Add paths to libraries """ + lenv.PrependUnique(LIBPATH = lenv.make_list(paths)) + + def KDElang(lenv, folder, appname): + """ Process translations (.po files) in a po/ dir """ + import glob + dir=SCons.Node.FS.default_fs.Dir(folder).srcnode() + fld=dir.srcnode() + tmptransfiles = glob.glob(str(fld)+'/*.po') + + if lenv.has_key('DUMPCONFIG'): + lenv.add_dump( "<podir dir=\"%s\" name=\"%s\"/>\n" % (reldir(dir), appname) ) + return + + transfiles=[] + if lenv.has_key('_BUILDDIR_'): + bdir=lenv['_BUILDDIR_'] + for pof in lenv.make_list(tmptransfiles): + # ITA + d=relfile(pof) + d2=d.replace(bdir,'').lstrip('/') + d3=lenv.join(bdir, d2) + #print d2 + #print d3 + transfiles.append( lenv.join('#', bdir, d2) ) + else: transfiles=tmptransfiles + + languages=None + if lenv['ARGS'] and lenv['ARGS'].has_key('languages'): + languages=lenv.make_list(lenv['ARGS']['languages']) + mydir=SCons.Node.FS.default_fs.Dir('.') + for f in transfiles: + #fname=f.replace(mydir.abspath, '') + fname=f + file=SCons.Node.FS.default_fs.File(fname) + country = SCons.Util.splitext(file.name)[0] + if not languages or country in languages: + result = lenv.Transfiles(file) + dir=lenv.join( getInstDirForResType(lenv, 'KDELOCALE'), country) + lenv.bksys_install(lenv.join(dir, 'LC_MESSAGES'), result, destfile=appname+'.mo') + + def KDEicon(lenv, icname='*', path='./', restype='KDEICONS', subdir=''): + """Contributed by: "Andrey Golovizin" <grooz()gorodok()net> + modified by "Martin Ellis" <m.a.ellis()ncl()ac()uk> + + Installs icons with filenames such as cr22-action-frame.png into + KDE icon hierachy with names like icons/crystalsvg/22x22/actions/frame.png. + + Global KDE icons can be installed simply using env.KDEicon('name'). + The second parameter, path, is optional, and specifies the icons + location in the source, relative to the SConscript file. + + To install icons that need to go under an applications directory (to + avoid name conflicts, for example), use e.g. + env.KDEicon('name', './', 'KDEDATA', 'appname/icons')""" + + if lenv.has_key('DUMPCONFIG'): + lenv.add_dump( "<icondir>\n" ) + lenv.add_dump( " <icondirent dir=\"%s\" subdir=\"%s\"/>\n" % (reldir(path), subdir) ) + lenv.add_dump( "</icondir>\n" ) + return + + type_dic = { 'action':'actions', 'app':'apps', 'device':'devices', + 'filesys':'filesystems', 'mime':'mimetypes' } + dir_dic = { + 'los' :'locolor/16x16', 'lom' :'locolor/32x32', + 'him' :'hicolor/32x32', 'hil' :'hicolor/48x48', + 'lo16' :'locolor/16x16', 'lo22' :'locolor/22x22', 'lo32' :'locolor/32x32', + 'hi16' :'hicolor/16x16', 'hi22' :'hicolor/22x22', 'hi32' :'hicolor/32x32', + 'hi48' :'hicolor/48x48', 'hi64' :'hicolor/64x64', 'hi128':'hicolor/128x128', + 'hisc' :'hicolor/scalable', + 'cr16' :'crystalsvg/16x16', 'cr22' :'crystalsvg/22x22', 'cr32' :'crystalsvg/32x32', + 'cr48' :'crystalsvg/48x48', 'cr64' :'crystalsvg/64x64', 'cr128':'crystalsvg/128x128', + 'crsc' :'crystalsvg/scalable' + } + + iconfiles = [] + dir=SCons.Node.FS.default_fs.Dir(path).srcnode() + mydir=SCons.Node.FS.default_fs.Dir('.') + import glob + for ext in ['png', 'xpm', 'mng', 'svg', 'svgz']: + files = glob.glob(str(dir)+'/'+'*-*-%s.%s' % (icname, ext)) + for file in files: + iconfiles.append( file.replace(mydir.abspath, '') ) + for iconfile in iconfiles: + lst = iconfile.split('/') + filename = lst[ len(lst) - 1 ] + tmp = filename.split('-') + if len(tmp)!=3: + env.pprint('RED','WARNING: icon filename has unknown format: '+iconfile) + continue + [icon_dir, icon_type, icon_filename]=tmp + try: + basedir=getInstDirForResType(lenv, restype) + destdir = '%s/%s/%s/%s/' % (basedir, subdir, dir_dic[icon_dir], type_dic[icon_type]) + except KeyError: + env.pprint('RED','WARNING: unknown icon type: '+iconfile) + continue + lenv.bksys_install(destdir, iconfile, icon_filename) + + ## This function uses env imported above - WARNING ugly code, i will have to rewrite (ITA) + def docfolder(lenv, folder, lang, destination=""): + # folder is the folder to process + # lang is the language + # destination is the subdirectory in KDEDOC (appname) + import glob + docfiles=[] + dir=SCons.Node.FS.default_fs.Dir(folder).srcnode() + mydir=SCons.Node.FS.default_fs.Dir('.') + dirpath=mydir.srcnode().abspath + docg = glob.glob(str(dir)+"/???*.*") # file files that are at least 4 chars wide :) + for file in docg: + f = file.replace(dirpath, '') + docfiles.append(f) + + if lenv.has_key('DUMPCONFIG'): + lenv.add_dump( "<docdir name=\"%s\">\n" % destination) + lenv.add_dump( " <docdirent lang=\"%s\" dir=\"%s\"/>\n" % (lang, reldir(dir)) ) + lenv.add_dump( "</docdir>\n" ) + return + + # warn about errors + #if len(lang) != 2: + # print "error, lang must be a two-letter string, like 'en'" + + # when the destination is not given, use the folder + if len(destination) == 0: destination=folder + docbook_list = [] + + bdir='.' + if lenv.has_key('_BUILDDIR_'): bdir = lenv['_BUILDDIR_'] + for file in docfiles: + # do not process folders + #if not os.path.isfile( lenv.join('.', file) ): continue + + # build a node representing the file in the build directory to force symlinking + nodefile=relfile( lenv.join(mydir.abspath, file) ) + #print nodefile + #nodefile=relfile( lenv.join(self.dirprefix, file) ) + nodefile=SCons.Node.FS.default_fs.File( lenv.join('#', bdir, nodefile) ) + #print nodefile.abspath + + # do not process the cache file + if file == 'index.cache.bz2': continue + # ignore invalid files (TODO??) + if len( SCons.Util.splitext( file ) ) <= 1: continue + ext = SCons.Util.splitext( file )[1] + + # install picture files + if ext in ['.jpeg', '.jpg', '.png']: lenv.KDEinstall('KDEDOC', lenv.join(lang,destination), nodefile.abspath) + # docbook files are processed by meinproc + if ext != '.docbook': continue + + docbook_list.append( nodefile ) + lenv.KDEinstall('KDEDOC', lenv.join(lang,destination), nodefile.abspath) + + # Now process the index.docbook files .. + if len(docbook_list) == 0: return + + index='' + cache='' + for file in docbook_list: + if file.name=='index.docbook': + index=file + cache=file.dir.File('index.cache.bz2') + + if not index: + print "BUG in docfolder: no index.docbook but docbook files found" + lenv.Exit(1) + + for file in docbook_list: + # make the cache.bz2 file depend on all .docbook files in the same dir + lenv.Depends( cache, file ) + + lenv.Meinproc( cache, index ) + lenv.KDEinstall( 'KDEDOC', lenv.join(lang,destination), cache ) + + if env['_INSTALL']: + dir=lenv.join(env['DESTDIR'], lenv.getInstDirForResType('KDEDOC'), lang, destination) + comp='mkdir -p %s && cd %s && rm -f common && ln -s ../common common' % (dir, dir) + lenv.Execute(comp) + + #self.env.AddPostAction(lenv.join(dir, 'common'), self.env.Chmod(ins, self.perms)) + # TODO add post action of cache (index.cache.bz2) + + #valid_targets = "program shlib kioslave staticlib".split() + import generic + class kobject(generic.genobj): + def __init__(self, val, senv=None): + if senv: generic.genobj.__init__(self, val, senv) + else: generic.genobj.__init__(self, val, env) + self.iskdelib=0 + def it_is_a_kdelib(self): self.iskdelib=1 + def execute(self): + if self.executed: return + if self.orenv.has_key('DUMPCONFIG'): + self.executed=1 + self.xml() + return + if (self.type=='shlib' or self.type=='kioslave'): + install_dir = 'KDEMODULE' + if self.iskdelib==1: install_dir = 'KDELIB' + self.instdir=getInstDirForResType(self.orenv, install_dir) + elif self.type=='program': + self.instdir=getInstDirForResType(self.orenv, 'KDEBIN') + self.perms=0755 + + # ITA + #print self.source + #print "hallo" + self.p_localsource=KDEfiles(env, self.joinpath(self.target), self.joinpath(self.source)) + # ITA + #print self.p_localsource + generic.genobj.execute(self) + + def xml(self): + dirprefix = reldir('.') + if not dirprefix: dirprefix=self.dirprefix + ret='<compile type="%s" dirprefix="%s" target="%s" cxxflags="%s" cflags="%s" includes="%s" linkflags="%s" libpaths="%s" libs="%s" vnum="%s" iskdelib="%s" libprefix="%s">\n' % (self.type, dirprefix, self.target, self.cxxflags, self.cflags, self.includes, self.linkflags, self.libpaths, self.libs, self.vnum, self.iskdelib, self.libprefix) + if self.source: + for i in self.orenv.make_list(self.source): ret+=' <source file="%s"/>\n' % i + ret+="</compile>\n" + self.orenv.add_dump(ret) + + # Attach the functions to the environment so that SConscripts can use them + SConsEnvironment.KDEprogram = KDEprogram + SConsEnvironment.KDEshlib = KDEshlib + SConsEnvironment.KDEstaticlib = KDEstaticlib + SConsEnvironment.KDEinstall = KDEinstall + SConsEnvironment.KDEinstallas = KDEinstallas + SConsEnvironment.KDElang = KDElang + SConsEnvironment.KDEicon = KDEicon + + SConsEnvironment.KDEaddflags_cxx = KDEaddflags_cxx + SConsEnvironment.KDEaddflags_c = KDEaddflags_c + SConsEnvironment.KDEaddflags_link = KDEaddflags_link + SConsEnvironment.KDEaddlibs = KDEaddlibs + SConsEnvironment.KDEaddpaths_includes = KDEaddpaths_includes + SConsEnvironment.KDEaddpaths_libs = KDEaddpaths_libs + + SConsEnvironment.docfolder = docfolder + SConsEnvironment.getInstDirForResType = getInstDirForResType + SConsEnvironment.kobject = kobject + |