# Made from scons qt.py and (heavily) modified into kde.py # Thomas Nagy, 2004, 2005 <tnagy2^8@yahoo.fr> """ Run scons -h to display the associated help, or look below .. """ BOLD ="\033[1m" RED ="\033[91m" GREEN ="\033[92m" YELLOW ="\033[1m" #"\033[93m" # unreadable on white backgrounds CYAN ="\033[96m" NORMAL ="\033[0m" import os, re # Returns the name of the shared object (i.e. libtdeui.so.4) # referenced by a libtool archive (like libtdeui.la) def getSOfromLA(lafile): contents = open(lafile, 'r').read() match = re.search("^dlname='([^']*)'$", contents, re.M) if match: return match.group(1) return None def exists(env): return True def detect_kde(env): """ Detect the qt and kde environment using tde-config mostly """ prefix = env['ARGS'].get('prefix', None) execprefix = env['ARGS'].get('execprefix', None) datadir = env['ARGS'].get('datadir', None) libdir = env['ARGS'].get('libdir', None) libsuffix = env['ARGS'].get('libsuffix', '') kdeincludes = env['ARGS'].get('kdeincludes', None) tdelibs = env['ARGS'].get('tdelibs', None) qtincludes = env['ARGS'].get('qtincludes', None) tqtincludes = env['ARGS'].get('tqtincludes', None) qtlibs = env['ARGS'].get('qtlibs', None) tdedir = env['ARGS'].get('tdedir', None) if libdir: libdir = libdir+libsuffix ## Detect the tde libraries print "Checking for tde-config : ", str="which tde-config 2>/dev/null" if tdedir: str="which %s 2>/dev/null" % (tdedir+'/bin/tde-config') kde_config = os.popen(str).read().strip() if len(kde_config): print GREEN + 'tde-config was found as ' + kde_config + NORMAL else: if tdedir: print RED + 'tde-config was NOT found in the folder given ' + tdedir + NORMAL else: print RED + 'tde-config was NOT found in your PATH' + NORMAL print "Make sure kde is installed properly" print "(missing package tdebase-devel?)" env.Exit(1) if tdedir: env['TDEDIR']=tdedir else: env['TDEDIR'] = os.popen(kde_config+' -prefix').read().strip() print "Checking for tde version : ", tde_version = os.popen(kde_config + " --version|grep TDE").read().strip().split()[1] tde_major = tde_version.split('.')[0].lstrip('R') tde_minor = tde_version.split('.')[1] tde_patch = tde_version.split('.')[2] try: env['KDEm1']=int(tde_major) except: pass try: env['KDEm2']=int(tde_minor) except: pass try: env['KDEm3']=int(tde_patch) except: pass if int(tde_major) != 14: print RED + tde_version print RED + "Your tde version might be too old" + NORMAL print RED + "Please make sure TDE is at least R14.0" + NORMAL else: print GREEN + tde_version + NORMAL ## Detect the qt library print "Checking for the qt library : ", qtdir = os.getenv("QTDIR") if qtdir: print GREEN+"qt is in "+qtdir+NORMAL else: libdir = os.popen(kde_config + ' --expandvars --install lib').read().strip() libtdeuiSO = libdir+'/'+getSOfromLA(libdir+'/libtdeui.la') try: m = re.search('(.*)/lib/libqt.*', os.popen('ldd ' + libtdeuiSO + ' | grep libqt').read().strip().split()[2]) except: m = re.search('(.*)/lib/libtqt.*', os.popen('ldd ' + libtdeuiSO + ' | grep libtqt').read().strip().split()[2]) pass if m: qtdir = m.group(1) print YELLOW+"qt was found as "+m.group(1)+NORMAL else: print RED+"qt was not found"+NORMAL print RED+"Please set QTDIR first (/usr/lib/qt3?)"+NORMAL env.Exit(1) env['QTDIR'] = qtdir.strip() ## Find the necessary programs uic-tqt and moc print "Checking for uic-tqt : ", uic = qtdir + "/bin/uic-tqt" if os.path.isfile(uic): print GREEN+"uic-tqt was found as "+uic+NORMAL else: uic = os.popen("which uic-tqt 2>/dev/null").read().strip() if len(uic): print YELLOW+"uic-tqt was found as "+uic+NORMAL else: uic = os.popen("which uic-tqt 2>/dev/null").read().strip() if len(uic): print YELLOW+"uic-tqt was found as "+uic+NORMAL else: print RED+"uic-tqt was not found - set QTDIR put it in your PATH ?"+NORMAL env.Exit(1) env['QT_UIC'] = uic print "Checking for moc : ", moc = qtdir + "/bin/tqmoc" if os.path.isfile(moc): print GREEN + "moc was found as " + moc + NORMAL else: moc = os.popen("which moc 2>/dev/null").read().strip() if len(moc): print YELLOW + "moc was found as " + moc + NORMAL elif os.path.isfile("/usr/share/tqt3/bin/tqmoc"): moc = "/usr/share/tqt3/bin/tqmoc" print YELLOW + "moc was found as " + moc + NORMAL elif os.path.isfile("/usr/share/qt3/bin/tqmoc"): moc = "/usr/share/qt3/bin/tqmoc" print YELLOW + "moc was found as " + moc + NORMAL else: print RED + "moc was not found - set QTDIR or put it in your PATH ?" + NORMAL env.Exit(1) env['QT_MOC'] = moc ## check for the tqt includes print "Checking for the tqt includes : ", if tqtincludes and os.path.isfile(tqtincludes + "/tqlayout.h"): # The user told where to look for and it looks valid print GREEN + "ok " + tqtincludes + NORMAL else: if os.path.isfile(qtdir + "/include/qlayout.h"): # Automatic detection print GREEN + "ok " + qtdir + "/include/ " + NORMAL tqtincludes = qtdir + "/include/" elif os.path.isfile("/usr/include/tqt/tqlayout.h"): # Debian probably print YELLOW + "the qt headers were found in /usr/include/tqt/ " + NORMAL tqtincludes = "/usr/include/tqt" elif os.path.isfile("/usr/include/qt4/Qt/qglobal.h"): # Debian probably print YELLOW + "the qt headers were found in /usr/include/qt4/ " + NORMAL tqtincludes = "/usr/include/qt4" else: print RED + "the qt headers were not found" + NORMAL env.Exit(1) ## check for the qt includes print "Checking for the qt includes : ", if qtincludes and os.path.isfile(qtincludes + "/ntqglobal.h"): # The user told where to look for and it looks valid print GREEN + "ok " + qtincludes + NORMAL else: if os.path.isfile(qtdir + "/include/ntqglobal.h"): # Automatic detection print GREEN + "ok " + qtdir + "/include/ " + NORMAL qtincludes = qtdir + "/include/" elif os.path.isfile("/usr/include/tqt3/ntqglobal.h"): # Debian probably print YELLOW + "the qt headers were found in /usr/include/tqt3/ " + NORMAL qtincludes = "/usr/include/tqt3" else: print RED + "the qt headers were not found" + NORMAL env.Exit(1) print "Checking for the tde includes : ", kdeprefix = os.popen(kde_config + " --prefix").read().strip() if not kdeincludes: kdeincludes = kdeprefix+"/include/" if os.path.isfile(kdeincludes + "/klineedit.h"): print GREEN + "ok " + kdeincludes + NORMAL else: if os.path.isfile(kdeprefix+"/include/tde/klineedit.h"): # Debian, Fedora probably print YELLOW + "the kde headers were found in " + kdeprefix + "/include/tde/" + NORMAL kdeincludes = kdeprefix + "/include/tde/" else: print RED + "The kde includes were NOT found" + NORMAL env.Exit(1) if prefix: ## use the user-specified prefix if not execprefix: execprefix = prefix if not datadir: datadir=prefix+"/share" if not libdir: libdir=execprefix+"/lib"+libsuffix subst_vars = lambda x: x.replace('${exec_prefix}', execprefix).replace('${datadir}',datadir).replace('${libdir}', libdir) debian_fix = lambda x: x.replace('/usr/share', '${datadir}') env['KDEBIN'] = subst_vars(os.popen(kde_config + ' --install exe').read().strip()) env['KDEAPPS'] = subst_vars(os.popen(kde_config + ' --install apps').read().strip()) env['KDEDATA'] = subst_vars(os.popen(kde_config + ' --install data').read().strip()) env['KDEMODULE']= subst_vars(os.popen(kde_config + ' --install module').read().strip()) env['KDELOCALE']= subst_vars(os.popen(kde_config + ' --install locale').read().strip()) env['KDEDOC'] = subst_vars( debian_fix(os.popen(kde_config + ' --install html').read().strip()) ) env['KDEKCFG'] = subst_vars(os.popen(kde_config + ' --install kcfg').read().strip()) env['KDEXDG'] = subst_vars(os.popen(kde_config + ' --install xdgdata-apps').read().strip()) env['KDEXDGDIR']= subst_vars(os.popen(kde_config + ' --install xdgdata-dirs').read().strip()) env['KDEMENU'] = subst_vars(os.popen(kde_config + ' --install apps').read().strip()) env['KDEMIME'] = subst_vars(os.popen(kde_config + ' --install mime').read().strip()) env['KDEICONS'] = subst_vars(os.popen(kde_config + ' --install icon').read().strip()) env['KDESERV'] = subst_vars(os.popen(kde_config + ' --install services').read().strip()) else: # the user has given no prefix, install as a normal kde app env['PREFIX'] = os.popen(kde_config + ' --prefix').read().strip() env['KDEBIN'] = os.popen(kde_config + ' --expandvars --install exe').read().strip() env['KDEAPPS'] = os.popen(kde_config + ' --expandvars --install apps').read().strip() env['KDEDATA'] = os.popen(kde_config + ' --expandvars --install data').read().strip() env['KDEMODULE']= os.popen(kde_config + ' --expandvars --install module').read().strip() env['KDELOCALE']= os.popen(kde_config + ' --expandvars --install locale').read().strip() env['KDEDOC'] = os.popen(kde_config + ' --expandvars --install html').read().strip() env['KDEKCFG'] = os.popen(kde_config + ' --expandvars --install kcfg').read().strip() env['KDEXDG'] = os.popen(kde_config + ' --expandvars --install xdgdata-apps').read().strip() env['KDEXDGDIR']= os.popen(kde_config + ' --expandvars --install xdgdata-dirs').read().strip() env['KDEMENU'] = os.popen(kde_config + ' --expandvars --install apps').read().strip() env['KDEMIME'] = os.popen(kde_config + ' --expandvars --install mime').read().strip() env['KDEICONS'] = os.popen(kde_config + ' --expandvars --install icon').read().strip() env['KDESERV'] = os.popen(kde_config + ' --expandvars --install services').read().strip() env['QTPLUGINS']=os.popen(kde_config + ' --expandvars --install qtplugins').read().strip() ## kde libs and includes env['KDEINCLUDEPATH']=kdeincludes if not tdelibs: tdelibs=os.popen(kde_config + ' --expandvars --install lib').read().strip() env['KDELIBPATH']=tdelibs ## qt libs and includes env['QTINCLUDEPATH']=qtincludes env['TQTINCLUDEPATH']=tqtincludes if not qtlibs: qtlibs=qtdir+"/lib" env['QTLIBPATH']=qtlibs def generate(env): """"Set up the qt and kde environment and builders - the moc part is difficult to understand """ env.Help(""" """+BOLD+ """*** KDE options *** -------------------""" +NORMAL+""" """+BOLD+"""* prefix """+NORMAL+""": base install path, ie: /usr/local """+BOLD+"""* execprefix """+NORMAL+""": install path for binaries, ie: /usr/bin """+BOLD+"""* datadir """+NORMAL+""": install path for the data, ie: /usr/local/share """+BOLD+"""* libdir """+NORMAL+""": install path for the libs, ie: /usr/lib """+BOLD+"""* tdedir """+NORMAL+""": path to TDE directory, ie: /opt/trinity """+BOLD+"""* libsuffix """+NORMAL+""": suffix of libraries on amd64, ie: 64, 32 """+BOLD+"""* kdeincludes"""+NORMAL+""": path to the kde includes (/usr/include/tde on debian, ...) """+BOLD+"""* qtincludes """+NORMAL+""": same punishment, for qt includes (/usr/include/qt on debian, ...) """+BOLD+"""* tdelibs """+NORMAL+""": path to the kde libs, for linking the programs """+BOLD+"""* qtlibs """+NORMAL+""": same punishment, for qt libraries ie: """+BOLD+"""scons configure libdir=/usr/local/lib qtincludes=/usr/include/qt """+NORMAL) import SCons.Defaults import SCons.Tool import SCons.Util ui_extensions = [".ui"] header_extensions = [".h", ".hxx", ".hpp", ".hh"] source_extensions = [".cpp", ".cxx", ".cc"] def find_file(filename, paths, node_factory): retval = None for dir in paths: node = node_factory(filename, dir) if node.rexists(): return node return None class _Metasources: """ Callable class, which works as an emitter for Programs, SharedLibraries and StaticLibraries.""" def __init__(self, objBuilderName): self.objBuilderName = objBuilderName def __call__(self, target, source, env): """ Smart autoscan function. Gets the list of objects for the Program or Lib. Adds objects and builders for the special qt files. """ try: if int(env.subst('$QT_AUTOSCAN')) == 0: return target, source except ValueError: pass try: qtdebug = int(env.subst('$QT_DEBUG')) except ValueError: qtdebug = 0 # some shortcuts used in the scanner FS = SCons.Node.FS.default_fs splitext = SCons.Util.splitext objBuilder = getattr(env, self.objBuilderName) # some regular expressions: # Q_OBJECT detection q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]') # The following is kind of hacky to get builders working properly (FIXME) ?? objBuilderEnv = objBuilder.env objBuilder.env = env mocBuilderEnv = env.Moc.env env.Moc.env = env # make a deep copy for the result; MocH objects will be appended out_sources = source[:] for obj in source: if not obj.has_builder(): # binary obj file provided if qtdebug: print "scons: qt: '%s' seems to be a binary. Discarded." % str(obj) continue cpp = obj.sources[0] if not splitext(str(cpp))[1] in source_extensions: if qtdebug: print "scons: qt: '%s' is no cxx file. Discarded." % str(cpp) # c or fortran source continue #cpp_contents = comment.sub('', cpp.get_contents()) cpp_contents = cpp.get_contents() h = None ui = None for ui_ext in ui_extensions: # try to find the ui file in the corresponding source directory uiname = splitext(cpp.name)[0] + ui_ext ui = find_file(uiname, (cpp.get_dir(),), FS.File) if ui: if qtdebug: print "scons: qt: found .ui file of header" #% (str(h), str(cpp)) #h_contents = comment.sub('', h.get_contents()) break # if we have a .ui file, do not continue, it is automatically handled by Uic if ui: continue for h_ext in header_extensions: # try to find the header file in the corresponding source # directory hname = splitext(cpp.name)[0] + h_ext h = find_file(hname, (cpp.get_dir(),), FS.File) if h: if qtdebug: print "scons: qt: Scanning '%s' (header of '%s')" % (str(h), str(cpp)) #h_contents = comment.sub('', h.get_contents()) h_contents = h.get_contents() break if not h and qtdebug: print "scons: qt: no header for '%s'." % (str(cpp)) if h and q_object_search.search(h_contents): # h file with the Q_OBJECT macro found -> add .moc or _moc.cpp file moc_cpp = None if env.has_key('NOMOCSCAN'): moc_cpp = env.Moc(h) else: reg = '\n\s*#include\s*("|<)'+splitext(cpp.name)[0]+'.moc("|>)' meta_object_search = re.compile(reg) if meta_object_search.search(cpp_contents): moc_cpp = env.Moc(h) else: moc_cpp = env.Moccpp(h) moc_o = objBuilder(moc_cpp) out_sources.append(moc_o) if qtdebug: print "scons: qt: found Q_OBJECT macro in '%s', moc'ing to '%s'" % (str(h), str(moc_cpp[0])) if cpp and q_object_search.search(cpp_contents): print "error, bksys cannot handle cpp files with Q_OBJECT classes" print "if you are sure this is a feature worth the effort, " print "report this to the authors tnagyemail-mail yahoo.fr" # restore the original env attributes (FIXME) objBuilder.env = objBuilderEnv env.Moc.env = mocBuilderEnv return (target, out_sources) MetasourcesShared = _Metasources('SharedObject') MetasourcesStatic = _Metasources('StaticObject') 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', 'root of qt directory'), ('QTLIBPATH', 'path to the qt libraries'), ('QTINCLUDEPATH', 'path to the qt includes'), ('TQTINCLUDEPATH', 'path to the tqt includes'), ('QT_UIC', 'moc directory'), ('QT_MOC', 'moc executable command'), ('QTPLUGINS', 'uic executable command'), ('TDEDIR', 'root of kde directory'), ('KDELIBPATH', 'path to the kde libs'), ('KDEINCLUDEPATH', 'path to the kde includes'), ('KDEBIN', 'installation path of the kde binaries'), ('KDEMODULE', 'installation path of the parts and libs'), ('KDEAPPS', ''), ('KDEDATA', 'installation path of the application data'), ('KDELOCALE', ''), ('KDEDOC', 'installation path of the application documentation'), ('KDEKCFG', 'installation path of the .kcfg files'), ('KDEXDG', 'installation path of the service types'), ('KDEXDGDIR', 'installation path of the xdg service directories'), ('KDEMENU', ''), ('KDEMIME', 'installation path of to the mimetypes'), ('KDEICONS', ''), ('KDEm1', ''), ('KDEm2', ''), ('KDEm3', ''), ('KDESERV', ''), ) opts.Update(env) # reconfigure when things are missing if 'configure' in env['TARGS'] or not env.has_key('QTDIR') or not env.has_key('TDEDIR'): detect_kde(env) # finally save the configuration to the cache file opts.Save(cachefile, env) ## set default variables, one can override them in sconscript files env.Append(CXXFLAGS = ['-I'+env['KDEINCLUDEPATH'], '-I'+env['QTINCLUDEPATH'], '-I'+env['TQTINCLUDEPATH'], '-include', 'tqt.h' ]) env.Append(LIBPATH = [env['KDELIBPATH'], env['QTLIBPATH'] ]) env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 1 env['QT_AUTOSCAN'] = 1 env['QT_DEBUG'] = 0 env['QT_UIC_HFLAGS'] = '-L $QTPLUGINS -nounload' env['QT_UIC_CFLAGS'] = '$QT_UIC_HFLAGS -tr tr2i18n' env['QT_LIBS'] = 'tqt' env['QT_UICIMPLPREFIX'] = '' env['QT_UICIMPLSUFFIX'] = '.cpp' env['QT_MOCHPREFIX'] = '' env['QT_MOCHSUFFIX'] = '.moc' env['KDE_KCFG_IMPLPREFIX'] = '' env['KDE_KCFG_IMPL_HSUFFIX'] = '.h' env['KDE_KCFG_IMPL_CSUFFIX'] = '.cpp' env['KDE_SKEL_IMPL_SUFFIX'] = '.skel' env['MEINPROC'] = 'meinproc' env['MSGFMT'] = 'msgfmt' ## ui file processing def uicGenerator(target, source, env, for_signature): act=[] act.append('$QT_UIC $QT_UIC_HFLAGS -o '+target[0].path+' '+source[0].path) act.append('rm -f ' +target[1].path) act.append('echo \'#include <tdelocale.h>\' >> '+target[1].path) act.append('echo \'#include <kdialog.h>\' >> '+target[1].path) act.append('$QT_UIC $QT_UIC_CFLAGS -impl '+target[0].path+' -o '+target[1].path+'.tmp '+source[0].path) act.append('cat '+target[1].path+'.tmp >> '+target[1].path) act.append('rm -f '+target[1].path+'.tmp') act.append('echo \'#include "' + target[2].name + '"\' >> '+target[1].path) act.append('moc-tqt $QT_MOC '+target[0].path+' '+target[2].path) return act def uicEmitter(target, source, env): adjustixes = SCons.Util.adjustixes bs = SCons.Util.splitext(str(source[0].name))[0] bs = os.path.join(str(target[0].get_dir()),bs) # first target is automatically added by builder (.h file) if len(target) < 2: # second target is .cpp file target.append(adjustixes(bs, env.subst('$QT_UICIMPLPREFIX'), env.subst('$QT_UICIMPLSUFFIX'))) if len(target) < 3: # third target is .moc file target.append(adjustixes(bs, env.subst('$QT_MOCHPREFIX'), env.subst('$QT_MOCHSUFFIX'))) return target, source UIC_BUILDER = Builder( generator = uicGenerator, emitter = uicEmitter, suffix = '.h', src_suffix = '.ui') ## moc file processing env['QT_MOCCOM'] = ('moc-tqt $QT_MOC $SOURCE ${TARGETS[0]}') MOC_BUILDER = Builder( action = '$QT_MOCCOM', suffix = '.moc', src_suffix = '.h') MOCCPP_BUILDER = Builder( action = '$QT_MOCCOM', suffix = '_moc.cpp', src_suffix = '.h') ## kcfg file processing def kcfgGenerator(target, source, env, for_signature): act=[] act.append('tdeconfig_compiler -d'+str(source[0].get_dir())+' '+source[1].path+' '+source[0].path) return act def kcfgEmitter(target, source, env): adjustixes = SCons.Util.adjustixes bs = SCons.Util.splitext(str(source[0].name))[0] bs = os.path.join(str(target[0].get_dir()),bs) # .h file is automatically added if len(target) < 2: # add .cpp file target.append(adjustixes(bs, env.subst('$KDE_KCFG_IMPLPREFIX'), env.subst('$KDE_KCFG_IMPL_CSUFFIX'))) if len(source) <2: if not os.path.isfile(str(source[0])): print RED+'kcfg file given'+str(source[0])+' does not exist !'+NORMAL return target, source kfcgfilename="" kcfgFileDeclRx = re.compile("^[fF]ile\s*=\s*(.+)\s*$") for line in file(str(source[0]), "r").readlines(): match = kcfgFileDeclRx.match(line.strip()) if match: kcfgfilename = match.group(1) break source.append(str(source[0].get_dir())+'/'+kcfgfilename) return target, source KCFG_BUILDER = Builder( generator = kcfgGenerator, emitter = kcfgEmitter, suffix = '.h', src_suffix = '.kcfgc') ## dcop processing def dcopGenerator(target, source, env, for_signature): act=[] act.append('dcopidl '+source[0].path+' > '+target[1].path+'|| ( rm -f '+target[1].path+' ; false)') act.append('dcopidl2cpp --c++-suffix cpp --no-signals --no-stub '+target[1].path) return act def dcopEmitter(target, source, env): bs = SCons.Util.splitext(str(source[0].name))[0] bs = os.path.join(str(target[0].get_dir()),bs) target.append(bs+'.kidl') #target.append(bs+'_skel.cpp') return target, source DCOP_BUILDER = Builder( generator = dcopGenerator, emitter = dcopEmitter, suffix = '_skel.cpp', src_suffix = '.h') ## documentation processing MEINPROC_BUILDER = Builder( action = '$MEINPROC --check --cache $TARGET $SOURCE', suffix = '.cache.bz2') ## translation files builder TRANSFILES_BUILDER = Builder( action = '$MSGFMT $SOURCE -o $TARGET', suffix = '.gmo', src_suffix = '.po') ## libtool file builder def laGenerator(target, source, env, for_signature): act=[] act.append('echo "dlname=\''+source[0].name+'\'" > '+target[0].path) act.append('echo "library_names=\''+source[0].name+' '+source[0].name+' '+source[0].name+'\'" >> '+target[0].path) act.append('echo "old_library=\'\'">> '+target[0].path) act.append('echo "dependency_libs=\'\'">> '+target[0].path) act.append('echo "current=0">> '+target[0].path) act.append('echo "age=0">> '+target[0].path) act.append('echo "revision=0">> '+target[0].path) act.append('echo "installed=yes">> '+target[0].path) act.append('echo "shouldnotlink=no">> '+target[0].path) act.append('echo "dlopen=\'\'">> '+target[0].path) act.append('echo "dlpreopen=\'\'">> '+target[0].path) act.append('echo "libdir=\''+env['KDEMODULE']+'\'" >> '+target[0].path) env.Depends(target, source) return act LA_BUILDER = Builder( generator = laGenerator, suffix = '.la', src_suffix = env['SHLIBSUFFIX']) ## register the builders env['BUILDERS']['Uic'] = UIC_BUILDER env['BUILDERS']['Moc'] = MOC_BUILDER env['BUILDERS']['Moccpp'] = MOCCPP_BUILDER env['BUILDERS']['Dcop'] = DCOP_BUILDER env['BUILDERS']['Kcfg'] = KCFG_BUILDER env['BUILDERS']['LaFile'] = LA_BUILDER env['BUILDERS']['Meinproc'] = MEINPROC_BUILDER env['BUILDERS']['Transfiles']= TRANSFILES_BUILDER static_obj, shared_obj = SCons.Tool.createObjBuilders(env) static_obj.src_builder.append('Uic') shared_obj.src_builder.append('Uic') static_obj.src_builder.append('Kcfg') shared_obj.src_builder.append('Kcfg') static_obj.src_builder.append('LaFile') shared_obj.src_builder.append('LaFile') static_obj.src_builder.append('Meinproc') shared_obj.src_builder.append('Meinproc') static_obj.src_builder.append('Transfiles') shared_obj.src_builder.append('Transfiles') ## Find the files to moc, dcop, and link against kde and qt env.AppendUnique(PROGEMITTER = [MetasourcesStatic], SHLIBEMITTER=[MetasourcesShared], LIBEMITTER =[MetasourcesStatic]) ## Handy helpers for building kde programs ## You should not have to modify them .. #import SCons.Util skel_ext = [".skel", ".SKEL"] 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) """ src=[] ui_files=[] kcfg_files=[] skel_files=[] other_files=[] # For each file, check wether it is a dcop file or not, and create the complete list of sources for file in source: bs = SCons.Util.splitext(file)[0] ext = SCons.Util.splitext(file)[1] if ext in skel_ext: lenv.Dcop(bs+'.h') src.append(bs+'_skel.cpp') elif ext == ".moch": lenv.Moccpp(bs+'.h') src.append(bs+'_moc.cpp') else: src.append(file) if ext == '.ui': ui_files.append(bs) elif ext == '.kcfgc': kcfg_files.append(bs) elif ext == '.skel': skel_files.append(bs) else: other_files.append(bs) # Now check against typical newbie errors for file in ui_files: for ofile in other_files: if ofile == file: print RED+"WARNING: You have included "+file+".ui and another file of the same prefix"+NORMAL 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: print RED+"WARNING: You have included "+file+".kcfg and another file of the same prefix"+NORMAL print "Files generated by tdeconfig_compiler (settings.h, settings.cpp) must not be included" return src """ In the future, these functions will contain the code that will dump the configuration for re-use from an IDE """ import glob def KDEinstall(lenv, restype, subdir, files): if not 'install' in env['TARGS']: return basedir=env['DESTDIR'] if len(restype)>0: if not lenv.has_key(restype): print RED+"unknown resource type "+restype+NORMAL else: basedir += lenv[restype]+'/' #print file # <- useful to trace stuff :) install_list = env.Install(basedir+subdir+'/', files) env.Alias('install', install_list) return install_list def KDEinstallas(lenv, restype, destfile, file): if not 'install' in env['TARGS']: return basedir=env['DESTDIR'] if len(restype)>0: if not lenv.has_key(restype): print RED+"unknown resource type "+restype+NORMAL else: basedir += lenv[restype]+'/' install_list = env.InstallAs(basedir+destfile, file) env.Alias('install', install_list) return install_list def KDEprogram(lenv, target, source): """ 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) if not lenv.has_key('NOAUTOINSTALL'): KDEinstall(lenv, 'KDEBIN', '', target) return program_list def KDEshlib(lenv, target, source, kdelib=0, libprefix='lib'): """ 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) lenv['LIBPREFIX']=libprefix library_list = lenv.SharedLibrary(target, src) lafile_list = lenv.LaFile(target, library_list) if not lenv.has_key('NOAUTOINSTALL'): install_dir = 'KDEMODULE' if kdelib==1: install_dir = 'KDELIBPATH' KDEinstall(lenv, install_dir, '', library_list) KDEinstall(lenv, install_dir, '', lafile_list) 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) """ 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 = fl) def KDEaddflags_c(lenv, fl): """ Compilation flags for C programs """ lenv.AppendUnique(CFLAGS = fl) def KDEaddflags_link(lenv, fl): """ Add link flags - Use this if KDEaddlibs below is not enough """ lenv.AppendUnique(LINKFLAGS = fl) def KDEaddlibs(lenv, libs): """ Helper function """ lenv.AppendUnique(LIBS = libs) def KDEaddpaths_includes(lenv, paths): """ Add new include paths """ lenv.AppendUnique(CPPPATH = paths) def KDEaddpaths_libs(lenv, paths): """ Add paths to libraries """ lenv.AppendUnique(LIBPATH = paths) def KDElang(lenv, folder, appname): """ Process translations (.po files) in a po/ dir """ transfiles = glob.glob(folder+'/*.po') for lang in transfiles: result = lenv.Transfiles(lang) country = SCons.Util.splitext(result[0].name)[0] KDEinstallas(lenv, 'KDELOCALE', country+'/LC_MESSAGES/'+appname+'.mo', result) def KDEicon(lenv, icname): """ Emulates the behaviour of Makefile.am to install icons Contributed by: "Andrey Golovizin" <grooz@gorodok@net> """ 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 = [] for ext in ['png', 'xpm', 'mng', 'svg', 'svgz']: files = glob.glob('*-*-%s.%s' % (icname, ext)) iconfiles += files for iconfile in iconfiles: tmp = iconfile.split('-') if len(tmp)!=3: print RED+'WARNING: icon filename has unknown format: '+iconfile+NORMAL continue [icon_dir, icon_type, icon_filename]=tmp try: destfile = '%s/%s/%s/%s' % (lenv['KDEICONS'], dir_dic[icon_dir], type_dic[icon_type], icon_filename) except KeyError: print RED+'WARNING: unknown icon type: '+iconfile+NORMAL continue ## Do not use KDEinstallas here, as parsing from an ide will be necessary if 'install' in env['TARGS']: env.Alias('install', env.InstallAs( env['DESTDIR']+'/'+destfile, iconfile ) ) # Attach the functions to the environment so that sconscripts can use them from SCons.Script.SConscript import SConsEnvironment 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