Added kstreamripper

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kstreamripper@1239912 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

2 files changed, 844 insertions, 0 deletions

diff --git a/admin/generic.py b/admin/generic.py
new file mode 100644
index 0000000..dbefaf5
--- /dev/null
+++ b/admin/generic.py
@@ -0,0 +1,161 @@
+## Thomas Nagy, 2005
+
+"""
+Detect and store the most common options
+* kdecxxflags  : debug=1 (-g) or debug=full (-g3, slower)
+  else use the user CXXFLAGS if any, - or -O2 by default
+* prefix : the installation path
+* extraincludes : a list of paths separated by ':'
+ie: scons configure debug=full prefix=/usr/local extraincludes=/tmp/include:/usr/local
+"""
+
+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
+
+def exists(env):
+	return true
+
+def generate(env):
+	env.Help("""
+"""+BOLD+
+"""*** Generic options ***
+-----------------------"""+NORMAL+"""
+"""+BOLD+"""* debug  """+NORMAL+""": debug=1 (-g) or debug=full (-g3, slower) else use environment CXXFLAGS, or -O2 by default
+"""+BOLD+"""* prefix """+NORMAL+""": the installation path
+"""+BOLD+"""* extraincludes """+NORMAL+""": a list of paths separated by ':'
+ie: """+BOLD+"""scons configure debug=full prefix=/usr/local extraincludes=/tmp/include:/usr/local
+"""+NORMAL)
+
+	## Bksys requires scons 0.96
+	env.EnsureSConsVersion(0, 96)
+	
+	## Global cache directory
+	## Put all project files in it so a rm -rf cache will clean up the config
+	if not env.has_key('CACHEDIR'):
+		env['CACHEDIR'] = os.getcwd()+'/cache/'
+	if not os.path.isdir(env['CACHEDIR']):
+		os.mkdir(env['CACHEDIR'])
+	
+	## SCons cache directory
+	## this avoids recompiling the same files over and over again: very handy when working with cvs
+	env.CacheDir(os.getcwd()+'/cache/objects')
+
+	## Avoid spreading .sconsign files everywhere - keep this line
+	env.SConsignFile(env['CACHEDIR']+'/scons_signatures')
+	
+	# Special trick for installing rpms ...
+	env['DESTDIR']=''
+	if 'install' in env['TARGS'] and os.environ.has_key('DESTDIR'):
+		env['DESTDIR']=os.environ['DESTDIR']+'/'
+		print CYAN+'** Enabling DESTDIR for the project ** ' + NORMAL + env['DESTDIR']
+
+	# load the options
+	from SCons.Options import Options, PathOption
+	cachefile=env['CACHEDIR']+'generic.cache.py'
+	opts = Options(cachefile)
+	opts.AddOptions(
+		( 'KDECCFLAGS', 'C flags' ),
+		( 'KDECXXFLAGS', 'debug level for the project : full or just anything' ),
+		( 'KDELINKFLAGS', 'additional link flags' ),
+		( 'PREFIX', 'prefix for installation' ),
+		( 'EXTRAINCLUDES', 'extra include paths for the project' ),
+		( 'ISCONFIGURED', 'is the project configured' ),
+	)
+	opts.Update(env)
+	
+	# use this to avoid an error message 'how to make target configure ?'
+	env.Alias('configure', None)
+
+	import SCons.Util
+
+	# configure the environment if needed
+	if 'configure' in env['TARGS'] or not env.has_key('ISCONFIGURED'):
+		# be paranoid, unset existing variables
+		if env.has_key('KDECXXFLAGS'):
+			env.__delitem__('KDECXXFLAGS')
+		if env.has_key('KDECCFLAGS'):
+			env.__delitem__('KDECCFLAGS')
+		if env.has_key('KDELINKFLAGS'):
+			env.__delitem__('KDELINKFLAGS')
+		if env.has_key('PREFIX'):
+			env.__delitem__('PREFIX')
+		if env.has_key('EXTRAINCLUDES'):
+			env.__delitem__('EXTRAINCLUDES')
+		if env.has_key('ISCONFIGURED'):
+			env.__delitem__('ISCONFIGURED')
+
+		if env['ARGS'].get('debug', None):
+			debuglevel = env['ARGS'].get('debug', None)
+			print CYAN+'** Enabling debug for the project **' + NORMAL
+			if (debuglevel == "full"):
+				env['KDECXXFLAGS'] = ['-DDEBUG', '-g3']
+			else:
+				env['KDECXXFLAGS'] = ['-DDEBUG', '-g']
+		else:
+			if os.environ.has_key('CXXFLAGS'):
+				# user-defined flags (gentooers will be elighted)
+				env['KDECXXFLAGS'] = SCons.Util.CLVar( os.environ['CXXFLAGS'] )
+				env.Append( KDECXXFLAGS = ['-DNDEBUG', '-DNO_DEBUG'] )
+			else:
+				env.Append(KDECXXFLAGS = ['-O2', '-DNDEBUG', '-DNO_DEBUG'])
+
+		if os.environ.has_key('CFLAGS'):
+			env['KDECCFLAGS'] = SCons.Util.CLVar( os.environ['CFLAGS'] )
+
+		## FreeBSD settings (contributed by will at freebsd dot org)
+		if os.uname()[0] == "FreeBSD":
+		        if os.environ.has_key('PTHREAD_LIBS'):
+		                env.AppendUnique( KDELINKFLAGS = SCons.Util.CLVar( os.environ['PTHREAD_LIBS'] ) )
+		        else:
+		                syspf = os.popen('/sbin/sysctl kern.osreldate')
+		                osreldate = int(syspf.read().split()[1])
+		                syspf.close()
+		                if osreldate < 500016:
+		                        env.AppendUnique( KDELINKFLAGS = ['-pthread'])
+		                        env.AppendUnique( KDECXXFLAGS = ['-D_THREAD_SAFE'])
+		                elif osreldate < 502102:
+		                        env.AppendUnique( KDELINKFLAGS = ['-lc_r'])
+		                        env.AppendUnique( KDECXXFLAGS = ['-D_THREAD_SAFE'])
+		                else:
+		                        env.AppendUnique( KDELINKFLAGS = ['-pthread'])
+
+		# User-specified prefix
+		if env['ARGS'].get('prefix', None):
+			env['PREFIX'] = env['ARGS'].get('prefix', None)
+			print CYAN+'** set the installation prefix for the project : ' + env['PREFIX'] +' **'+ NORMAL
+		elif env.has_key('PREFIX'):
+			env.__delitem__('PREFIX')
+
+		# User-specified include paths
+		env['EXTRAINCLUDES'] = env['ARGS'].get('extraincludes', None)
+		if env['ARGS'].get('extraincludes', None):
+			print CYAN+'** set extra include paths for the project : ' + env['EXTRAINCLUDES'] +' **'+ NORMAL
+		elif env.has_key('EXTRAINCLUDES'):
+			env.__delitem__('EXTRAINCLUDES')
+
+		env['ISCONFIGURED']=1
+
+		# And finally save the options in the cache
+		opts.Save(cachefile, env)
+
+	if env.has_key('KDECXXFLAGS'):
+                env.AppendUnique( CPPFLAGS = env['KDECXXFLAGS'] )
+
+	if env.has_key('KDECCFLAGS'):
+		env.AppendUnique( CCFLAGS = env['KDECCFLAGS'] )
+
+	if env.has_key('KDELINKFLAGS'):
+		env.AppendUnique( LINKFLAGS = env['KDELINKFLAGS'] )
+
+	if env.has_key('EXTRAINCLUDES'):
+		incpaths = []
+		for dir in str(env['EXTRAINCLUDES']).split(':'):
+			incpaths.append( dir )
+		env.Append(CPPPATH = incpaths)
+
diff --git a/admin/kde.py b/admin/kde.py
new file mode 100644
index 0000000..3a061ed
--- /dev/null
+++ b/admin/kde.py
@@ -0,0 +1,683 @@
+#! /usr/bin/env python
+# more or less derived from scons qt.py
+# this version makes less scans over the data and is thus faster
+# it is less accurate however (when mocable classes become unmocable)
+# Thomas Nagy, 2004, 2005 <tnagy2^8@yahoo.fr>
+
+from time import *
+import SCons.Util
+import string
+
+import os, re
+
+BOLD   ="\033[1m"
+RED    ="\033[91m"
+GREEN  ="\033[92m"
+YELLOW ="\033[1m" #"\033[93m" # unreadable on white backgrounds
+CYAN   ="\033[96m"
+NORMAL ="\033[0m"
+
+# Returns the name of the shared object (i.e. 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
+
+def exists(env):
+	return True
+
+def detect_kde(env):
+	""" Detect the qt and kde environment using kde-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)
+	kdeincludes= env['ARGS'].get('kdeincludes', None)
+	kdelibs    = env['ARGS'].get('kdelibs', None)
+	qtincludes = env['ARGS'].get('qtincludes', None)
+	qtlibs     = env['ARGS'].get('qtlibs', None)
+
+	## Detect the kde libraries
+	print "Checking for kde-config           : ",
+	kde_config = os.popen("which kde-config 2>/dev/null").read().strip()
+	if len(kde_config):
+		print GREEN + "kde-config was found" + NORMAL
+	else:
+		print RED + "kde-config was NOT found in your PATH"+ NORMAL
+		print "Make sure kde is installed properly"
+		print "(missing package kdebase-devel?)"
+		env.Exit(1)
+	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:
+		print RED + kde_version
+		print RED + "Your kde version can be too old" + NORMAL
+		print RED + "Please make sure kde is at least 3.2" + NORMAL
+	else:
+		print GREEN + kde_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()
+		libkdeuiSO = libdir+'/'+getSOfromLA(libdir+'/libkdeui.la')
+		m = re.search('(.*)/lib/libqt.*', os.popen('ldd '+libkdeuiSO+' | grep libqt').read().strip().split()[2])
+		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 and moc
+	print "Checking for uic                  : ",
+	uic = qtdir + "/bin/uic"
+	if os.path.isfile(uic):
+		print GREEN+"uic was found as "+uic+NORMAL
+	else:
+		uic = os.popen("which uic 2>/dev/null").read().strip()
+		if len(uic):
+			print YELLOW+"uic was found as "+uic+NORMAL
+		else:
+			uic = os.popen("which uic 2>/dev/null").read().strip()
+			if len(uic):
+				print YELLOW+"uic was found as "+uic+NORMAL
+			else:
+				print RED+"uic 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/moc"
+	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/qt3/bin/moc"):
+			moc = "/usr/share/qt3/bin/moc"
+			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 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
+		print GREEN+"ok "+qtincludes+NORMAL
+	else:
+		if os.path.isfile(qtdir + "/include/qlayout.h"):
+			# Automatic detection
+			print GREEN+"ok "+qtdir + "/include/ "+NORMAL
+			qtincludes = qtdir + "/include/"
+		elif os.path.isfile("/usr/include/qt3/qlayout.h"):
+			# Debian probably
+			print YELLOW+"the qt headers were found in /usr/include/qt3/ "+NORMAL
+			qtincludes = "/usr/include/qt3"
+		else:
+			print RED+"the qt headers were not found"+NORMAL
+			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"):
+		print GREEN+"ok "+kdeincludes+NORMAL
+	else:
+		if os.path.isfile(kdeprefix+"/include/kde/klineedit.h"):
+			# Debian, Fedora probably
+			print YELLOW+"the kde headers were found in "+kdeprefix+"/include/kde/"+NORMAL
+			kdeincludes = kdeprefix + "/include/kde/"
+		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"
+
+		subst_vars = lambda x: x.replace('${exec_prefix}',execprefix).replace('${datadir}',datadir).replace('${libdir}',libdir)
+		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(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['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['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 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"
+	env['QTLIBPATH']= qtlibs
+
+def mocscan(target, source, env):
+	splitext = SCons.Util.splitext
+
+	q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]')
+
+	for obj in source:
+
+		if not obj.has_builder():
+			# binary obj file provided
+			continue
+
+		cpp = obj.sources[0]
+		if not splitext(str(cpp))[1] == '.cpp':
+			# not a cplusplus source
+			continue
+
+		# if we have a .ui file, it is automatically handled by Uic
+		uiname = string.split(cpp.abspath, '.cpp')[0] + ".ui"
+		if os.path.isfile(uiname):
+			continue
+
+                hname = splitext(cpp.name)[0] + ".h"
+		h = SCons.Node.FS.find_file(hname, (cpp.get_dir(),) )
+
+		if h:
+			# h file with the Q_OBJECT macro found -> add .moc file
+			mocfile = string.split(cpp.abspath, '.cpp')[0] + ".moc"
+			# trick : check if the moc file already exists (avoid a scan)
+			if os.path.isfile(mocfile):
+				env.Moc(h)
+			elif q_object_search.search(h.get_contents()):
+				# FIXME : strong assumption
+				env.Moc(h)
+
+	return (target, source)
+
+def generate(env):
+
+	import SCons.Defaults
+	import SCons.Tool
+	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+"""* kdeincludes"""+NORMAL+""": path to the kde includes (/usr/include/kde on debian, ...)
+"""+BOLD+"""* qtincludes """+NORMAL+""": same punishment, for qt includes (/usr/include/qt on debian, ...)
+"""+BOLD+"""* kdelibs    """+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)
+	
+	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(
+		( 'QTDIR', 'root of qt directory' ),
+		( 'QTLIBPATH', 'path to the qt libraries' ),
+		( 'QTINCLUDEPATH', 'path to the qt includes' ),
+		( 'QT_UIC', 'moc directory'),
+		( 'QT_MOC', 'moc executable command'),
+		( 'QTPLUGINS', 'uic executable command'),
+		( 'KDEDIR', 'root of kde directory' ),
+		( 'KDELIBPATH', 'path to the kde libs' ),
+		( 'KDEINCLUDEPATH', 'path to the kde includes' ),
+
+		( 'PREFIX', 'root of the program installation'),
+
+		( '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'),
+		( 'KDEMENU', ''),
+		( 'KDEMIME', 'installation path of to the mimetypes'),
+		( 'KDEICONS', ''),
+		( '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('KDEDIR'):
+		detect_kde(env)
+
+	# finally save the configuration
+	opts.Save(cachefile, env)
+
+	## set default variables, one can override them in sconscript files
+	env.Append(CXXFLAGS = ['-I'+env['KDEINCLUDEPATH'], '-I'+env['QTINCLUDEPATH'] ])
+	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']         = 'qt-mt'
+	
+	env['LIBTOOL_FLAGS']   = '--silent --mode=compile --tag=CXX'
+	
+	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 <klocale.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('$QT_MOC -o '+target[2].path+' '+target[0].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'] = ('$QT_MOC -o ${TARGETS[0]} $SOURCE')
+	
+	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('kconfig_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)
+		# first target is automatically added by builder (.h file)
+		if len(target) < 2:
+			# second target is .cpp file
+			target.append(adjustixes(bs, env.subst('$KDE_KCFG_IMPLPREFIX'), env.subst('$KDE_KCFG_IMPL_CSUFFIX')))
+	
+		if len(source) <2:
+			kcfgfilename = os.popen("cat "+str(source[0])+"|grep File|sed 's/File.*=//i'").read().rstrip()
+			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 (meinproc) processing
+	MEINPROC_BUILDER = Builder(
+		action     = '$MEINPROC --check --cache $TARGET $SOURCE',
+		suffix     = '.cache.bz2',
+		src_suffix = '.docbook' )
+
+	###### 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)
+		return act
+	
+	LA_BUILDER = Builder(
+		generator  = laGenerator,
+		suffix     = '.la',
+		src_suffix = '.so' )
+	
+	##### 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=[mocscan], SHLIBEMITTER=[mocscan], LIBEMITTER =[mocscan])
+
+	###########################################
+	## 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)
+		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):
+		""" 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)
+		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'
+		}
+
+		import glob
+		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