text_ux 0.0.1

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/nasm.py

@@ -0,0 +1,13 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import waflib.Tools.asm
+from waflib.TaskGen import feature
+def apply_nasm_vars(self):
+	self.env.append_value('ASFLAGS',self.to_list(getattr(self,'nasm_flags',[])))
+def configure(conf):
+	nasm=conf.find_program(['nasm','yasm'],var='AS')
+	conf.env.AS_TGT_F='-o'
+
+feature('asm')(apply_nasm_vars)

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/perl.py

@@ -0,0 +1,78 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import os
+from waflib import Task,Options,Utils
+from waflib.Configure import conf
+from waflib.TaskGen import extension,feature,before_method
+def init_perlext(self):
+	self.uselib=self.to_list(getattr(self,'uselib',[]))
+	if not'PERLEXT'in self.uselib:self.uselib.append('PERLEXT')
+	self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['perlext_PATTERN']
+def xsubpp_file(self,node):
+	outnode=node.change_ext('.c')
+	self.create_task('xsubpp',node,outnode)
+	self.source.append(outnode)
+class xsubpp(Task.Task):
+	run_str='${PERL} ${XSUBPP} -noprototypes -typemap ${EXTUTILS_TYPEMAP} ${SRC} > ${TGT}'
+	color='BLUE'
+	ext_out=['.h']
+def check_perl_version(self,minver=None):
+	res=True
+	cver=""if minver is None else".".join(map(str,minver))
+	self.start_msg('Checking for minimum perl version %s'%cver)
+	perl=getattr(Options.options,'perlbinary',None)
+	if not perl:
+		perl=self.find_program('perl',var='PERL')
+	if not perl:
+		self.end_msg("Perl not found",color="YELLOW")
+		return False
+	self.env['PERL']=perl
+	version=self.cmd_and_log([perl,"-e",'printf \"%vd\", $^V'])
+	if not version:
+		res=False
+		version="Unknown"
+	elif not minver is None:
+		ver=tuple(map(int,version.split(".")))
+		if ver<minver:
+			res=False
+	self.end_msg(version,color="GREEN"if res else"YELLOW")
+	return res
+def check_perl_module(self,module):
+	cmd=[self.env['PERL'],'-e','use %s'%module]
+	self.start_msg('perl module %s'%module)
+	try:
+		r=self.cmd_and_log(cmd)
+	except:
+		self.end_msg(False)
+		return None
+	self.end_msg(r or True)
+	return r
+def check_perl_ext_devel(self):
+	env=self.env
+	perl=env.PERL
+	if not perl:
+		self.fatal('find perl first')
+	def read_out(cmd):
+		return Utils.to_list(self.cmd_and_log(perl+cmd))
+	env['LINKFLAGS_PERLEXT']=read_out(" -MConfig -e'print $Config{lddlflags}'")
+	env['INCLUDES_PERLEXT']=read_out(" -MConfig -e'print \"$Config{archlib}/CORE\"'")
+	env['CFLAGS_PERLEXT']=read_out(" -MConfig -e'print \"$Config{ccflags} $Config{cccdlflags}\"'")
+	env['XSUBPP']=read_out(" -MConfig -e'print \"$Config{privlib}/ExtUtils/xsubpp$Config{exe_ext}\"'")
+	env['EXTUTILS_TYPEMAP']=read_out(" -MConfig -e'print \"$Config{privlib}/ExtUtils/typemap\"'")
+	if not getattr(Options.options,'perlarchdir',None):
+		env['ARCHDIR_PERL']=self.cmd_and_log(perl+" -MConfig -e'print $Config{sitearch}'")
+	else:
+		env['ARCHDIR_PERL']=getattr(Options.options,'perlarchdir')
+	env['perlext_PATTERN']='%s.'+self.cmd_and_log(perl+" -MConfig -e'print $Config{dlext}'")
+def options(opt):
+	opt.add_option('--with-perl-binary',type='string',dest='perlbinary',help='Specify alternate perl binary',default=None)
+	opt.add_option('--with-perl-archdir',type='string',dest='perlarchdir',help='Specify directory where to install arch specific files',default=None)
+
+before_method('apply_incpaths','apply_link','propagate_uselib_vars')(init_perlext)
+feature('perlext')(init_perlext)
+extension('.xs')(xsubpp_file)
+conf(check_perl_version)
+conf(check_perl_module)
+conf(check_perl_ext_devel)

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/python.py

@@ -0,0 +1,303 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import os,sys
+from waflib import Utils,Options,Errors
+from waflib.Logs import debug,warn,info,error
+from waflib.TaskGen import extension,before_method,after_method,feature
+from waflib.Configure import conf
+FRAG='''
+#include <Python.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+	void Py_Initialize(void);
+	void Py_Finalize(void);
+#ifdef __cplusplus
+}
+#endif
+int main()
+{
+   Py_Initialize();
+   Py_Finalize();
+   return 0;
+}
+'''
+INST='''
+import sys, py_compile
+py_compile.compile(sys.argv[1], sys.argv[2], sys.argv[3])
+'''
+def process_py(self,node):
+	try:
+		if not self.bld.is_install:
+			return
+	except:
+		return
+	try:
+		if not self.install_path:
+			return
+	except AttributeError:
+		self.install_path='${PYTHONDIR}'
+	def inst_py(ctx):
+		install_from=getattr(self,'install_from',None)
+		if install_from:
+			install_from=self.path.find_dir(install_from)
+		install_pyfile(self,node,install_from)
+	self.bld.add_post_fun(inst_py)
+def install_pyfile(self,node,install_from=None):
+	from_node=install_from or node.parent
+	tsk=self.bld.install_as(self.install_path+'/'+node.path_from(from_node),node,postpone=False)
+	path=tsk.get_install_path()
+	if self.bld.is_install<0:
+		info("+ removing byte compiled python files")
+		for x in'co':
+			try:
+				os.remove(path+x)
+			except OSError:
+				pass
+	if self.bld.is_install>0:
+		try:
+			st1=os.stat(path)
+		except:
+			error('The python file is missing, this should not happen')
+		for x in['c','o']:
+			do_inst=self.env['PY'+x.upper()]
+			try:
+				st2=os.stat(path+x)
+			except OSError:
+				pass
+			else:
+				if st1.st_mtime<=st2.st_mtime:
+					do_inst=False
+			if do_inst:
+				lst=(x=='o')and[self.env['PYFLAGS_OPT']]or[]
+				(a,b,c)=(path,path+x,tsk.get_install_path(destdir=False)+x)
+				argv=self.env['PYTHON']+lst+['-c',INST,a,b,c]
+				info('+ byte compiling %r'%(path+x))
+				ret=Utils.subprocess.Popen(argv).wait()
+				if ret:
+					raise Errors.WafError('py%s compilation failed %r'%(x,path))
+def feature_py(self):
+	pass
+def init_pyext(self):
+	try:
+		if not self.install_path:
+			return
+	except AttributeError:
+		self.install_path='${PYTHONARCHDIR}'
+	self.uselib=self.to_list(getattr(self,'uselib',[]))
+	if not'PYEXT'in self.uselib:
+		self.uselib.append('PYEXT')
+	self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['macbundle_PATTERN']=self.env['pyext_PATTERN']
+def set_bundle(self):
+	if sys.platform.startswith('darwin'):
+		self.mac_bundle=True
+def init_pyembed(self):
+	self.uselib=self.to_list(getattr(self,'uselib',[]))
+	if not'PYEMBED'in self.uselib:
+		self.uselib.append('PYEMBED')
+def get_python_variables(conf,variables,imports=['import sys']):
+	program=list(imports)
+	program.append('')
+	for v in variables:
+		program.append("print(repr(%s))"%v)
+	os_env=dict(os.environ)
+	try:
+		del os_env['MACOSX_DEPLOYMENT_TARGET']
+	except KeyError:
+		pass
+	try:
+		out=conf.cmd_and_log(conf.env.PYTHON+['-c','\n'.join(program)],env=os_env)
+	except Errors.WafError:
+		conf.fatal('The distutils module is unusable: install "python-devel"?')
+	return_values=[]
+	for s in out.split('\n'):
+		s=s.strip()
+		if not s:
+			continue
+		if s=='None':
+			return_values.append(None)
+		elif s[0]=="'"and s[-1]=="'":
+			return_values.append(s[1:-1])
+		elif s[0].isdigit():
+			return_values.append(int(s))
+		else:break
+	return return_values
+def check_python_headers(conf):
+	if not conf.env['CC_NAME']and not conf.env['CXX_NAME']:
+		conf.fatal('load a compiler first (gcc, g++, ..)')
+	if not conf.env['PYTHON_VERSION']:
+		conf.check_python_version()
+	env=conf.env
+	pybin=conf.env.PYTHON
+	if not pybin:
+		conf.fatal('could not find the python executable')
+	v='prefix SO LDFLAGS LIBDIR LIBPL INCLUDEPY Py_ENABLE_SHARED MACOSX_DEPLOYMENT_TARGET LDSHARED CFLAGS'.split()
+	try:
+		lst=conf.get_python_variables(["get_config_var('%s') or ''"%x for x in v],['from distutils.sysconfig import get_config_var'])
+	except RuntimeError:
+		conf.fatal("Python development headers not found (-v for details).")
+	vals=['%s = %r'%(x,y)for(x,y)in zip(v,lst)]
+	conf.to_log("Configuration returned from %r:\n%r\n"%(pybin,'\n'.join(vals)))
+	dct=dict(zip(v,lst))
+	x='MACOSX_DEPLOYMENT_TARGET'
+	if dct[x]:
+		conf.env[x]=conf.environ[x]=dct[x]
+	env['pyext_PATTERN']='%s'+dct['SO']
+	all_flags=dct['LDFLAGS']+' '+dct['CFLAGS']
+	conf.parse_flags(all_flags,'PYEMBED')
+	all_flags=dct['LDFLAGS']+' '+dct['LDSHARED']+' '+dct['CFLAGS']
+	conf.parse_flags(all_flags,'PYEXT')
+	result=None
+	for name in('python'+env['PYTHON_VERSION'],'python'+env['PYTHON_VERSION'].replace('.','')):
+		if not result and env['LIBPATH_PYEMBED']:
+			path=env['LIBPATH_PYEMBED']
+			conf.to_log("\n\n# Trying default LIBPATH_PYEMBED: %r\n"%path)
+			result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in LIBPATH_PYEMBED'%name)
+		if not result and dct['LIBDIR']:
+			path=[dct['LIBDIR']]
+			conf.to_log("\n\n# try again with -L$python_LIBDIR: %r\n"%path)
+			result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in LIBDIR'%name)
+		if not result and dct['LIBPL']:
+			path=[dct['LIBPL']]
+			conf.to_log("\n\n# try again with -L$python_LIBPL (some systems don't install the python library in $prefix/lib)\n")
+			result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in python_LIBPL'%name)
+		if not result:
+			path=[os.path.join(dct['prefix'],"libs")]
+			conf.to_log("\n\n# try again with -L$prefix/libs, and pythonXY name rather than pythonX.Y (win32)\n")
+			result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in $prefix/libs'%name)
+		if result:
+			break
+	if result:
+		env['LIBPATH_PYEMBED']=path
+		env.append_value('LIB_PYEMBED',[name])
+	else:
+		conf.to_log("\n\n### LIB NOT FOUND\n")
+	if(Utils.is_win32 or sys.platform.startswith('os2')or dct['Py_ENABLE_SHARED']):
+		env['LIBPATH_PYEXT']=env['LIBPATH_PYEMBED']
+		env['LIB_PYEXT']=env['LIB_PYEMBED']
+	num='.'.join(env['PYTHON_VERSION'].split('.')[:2])
+	conf.find_program(['python%s-config'%num,'python-config-%s'%num,'python%sm-config'%num],var='PYTHON_CONFIG',mandatory=False)
+	includes=[]
+	if conf.env.PYTHON_CONFIG:
+		for incstr in conf.cmd_and_log([conf.env.PYTHON_CONFIG,'--includes']).strip().split():
+			if(incstr.startswith('-I')or incstr.startswith('/I')):
+				incstr=incstr[2:]
+			if incstr not in includes:
+				includes.append(incstr)
+		conf.to_log("Include path for Python extensions (found via python-config --includes): %r\n"%(includes,))
+		env['INCLUDES_PYEXT']=includes
+		env['INCLUDES_PYEMBED']=includes
+	else:
+		conf.to_log("Include path for Python extensions ""(found via distutils module): %r\n"%(dct['INCLUDEPY'],))
+		env['INCLUDES_PYEXT']=[dct['INCLUDEPY']]
+		env['INCLUDES_PYEMBED']=[dct['INCLUDEPY']]
+	if env['CC_NAME']=='gcc':
+		env.append_value('CFLAGS_PYEMBED',['-fno-strict-aliasing'])
+		env.append_value('CFLAGS_PYEXT',['-fno-strict-aliasing'])
+	if env['CXX_NAME']=='gcc':
+		env.append_value('CXXFLAGS_PYEMBED',['-fno-strict-aliasing'])
+		env.append_value('CXXFLAGS_PYEXT',['-fno-strict-aliasing'])
+	if env.CC_NAME=="msvc":
+		from distutils.msvccompiler import MSVCCompiler
+		dist_compiler=MSVCCompiler()
+		dist_compiler.initialize()
+		env.append_value('CFLAGS_PYEXT',dist_compiler.compile_options)
+		env.append_value('CXXFLAGS_PYEXT',dist_compiler.compile_options)
+		env.append_value('LINKFLAGS_PYEXT',dist_compiler.ldflags_shared)
+	try:
+		conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',uselib='PYEMBED',fragment=FRAG,errmsg='Could not find the python development headers')
+	except conf.errors.ConfigurationError:
+		conf.check_cfg(path=conf.env.PYTHON_CONFIG,package='',uselib_store='PYEMBED',args=['--cflags','--libs'])
+		conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',msg='Getting the python flags from python-config',uselib='PYEMBED',fragment=FRAG,errmsg='Could not find the python development headers elsewhere')
+def check_python_version(conf,minver=None):
+	assert minver is None or isinstance(minver,tuple)
+	pybin=conf.env['PYTHON']
+	if not pybin:
+		conf.fatal('could not find the python executable')
+	cmd=pybin+['-c','import sys\nfor x in sys.version_info: print(str(x))']
+	debug('python: Running python command %r'%cmd)
+	lines=conf.cmd_and_log(cmd).split()
+	assert len(lines)==5,"found %i lines, expected 5: %r"%(len(lines),lines)
+	pyver_tuple=(int(lines[0]),int(lines[1]),int(lines[2]),lines[3],int(lines[4]))
+	result=(minver is None)or(pyver_tuple>=minver)
+	if result:
+		pyver='.'.join([str(x)for x in pyver_tuple[:2]])
+		conf.env['PYTHON_VERSION']=pyver
+		if'PYTHONDIR'in conf.environ:
+			pydir=conf.environ['PYTHONDIR']
+		else:
+			if Utils.is_win32:
+				(python_LIBDEST,pydir)=conf.get_python_variables(["get_config_var('LIBDEST') or ''","get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']],['from distutils.sysconfig import get_config_var, get_python_lib'])
+			else:
+				python_LIBDEST=None
+				(pydir,)=conf.get_python_variables(["get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']],['from distutils.sysconfig import get_python_lib'])
+			if python_LIBDEST is None:
+				if conf.env['LIBDIR']:
+					python_LIBDEST=os.path.join(conf.env['LIBDIR'],"python"+pyver)
+				else:
+					python_LIBDEST=os.path.join(conf.env['PREFIX'],"lib","python"+pyver)
+		if'PYTHONARCHDIR'in conf.environ:
+			pyarchdir=conf.environ['PYTHONARCHDIR']
+		else:
+			(pyarchdir,)=conf.get_python_variables(["get_python_lib(plat_specific=1, standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']],['from distutils.sysconfig import get_python_lib'])
+			if not pyarchdir:
+				pyarchdir=pydir
+		if hasattr(conf,'define'):
+			conf.define('PYTHONDIR',pydir)
+			conf.define('PYTHONARCHDIR',pyarchdir)
+		conf.env['PYTHONDIR']=pydir
+		conf.env['PYTHONARCHDIR']=pyarchdir
+	pyver_full='.'.join(map(str,pyver_tuple[:3]))
+	if minver is None:
+		conf.msg('Checking for python version',pyver_full)
+	else:
+		minver_str='.'.join(map(str,minver))
+		conf.msg('Checking for python version',pyver_tuple,">= %s"%(minver_str,)and'GREEN'or'YELLOW')
+	if not result:
+		conf.fatal('The python version is too old, expecting %r'%(minver,))
+PYTHON_MODULE_TEMPLATE='''
+import %s
+print(1)
+'''
+def check_python_module(conf,module_name):
+	conf.start_msg('Python module %s'%module_name)
+	try:
+		conf.cmd_and_log(conf.env['PYTHON']+['-c',PYTHON_MODULE_TEMPLATE%module_name])
+	except:
+		conf.end_msg(False)
+		conf.fatal('Could not find the python module %r'%module_name)
+	conf.end_msg(True)
+def configure(conf):
+	try:
+		conf.find_program('python',var='PYTHON')
+	except conf.errors.ConfigurationError:
+		warn("could not find a python executable, setting to sys.executable '%s'"%sys.executable)
+		conf.env.PYTHON=sys.executable
+	if conf.env.PYTHON!=sys.executable:
+		warn("python executable '%s' different from sys.executable '%s'"%(conf.env.PYTHON,sys.executable))
+	conf.env.PYTHON=conf.cmd_to_list(conf.env.PYTHON)
+	v=conf.env
+	v['PYCMD']='"import sys, py_compile;py_compile.compile(sys.argv[1], sys.argv[2])"'
+	v['PYFLAGS']=''
+	v['PYFLAGS_OPT']='-O'
+	v['PYC']=getattr(Options.options,'pyc',1)
+	v['PYO']=getattr(Options.options,'pyo',1)
+def options(opt):
+	opt.add_option('--nopyc',action='store_false',default=1,help='Do not install bytecode compiled .pyc files (configuration) [Default:install]',dest='pyc')
+	opt.add_option('--nopyo',action='store_false',default=1,help='Do not install optimised compiled .pyo files (configuration) [Default:install]',dest='pyo')
+
+extension('.py')(process_py)
+feature('py')(feature_py)
+feature('pyext')(init_pyext)
+before_method('propagate_uselib_vars','apply_link')(init_pyext)
+after_method('apply_bundle')(init_pyext)
+feature('pyext')(set_bundle)
+before_method('apply_link','apply_bundle')(set_bundle)
+before_method('propagate_uselib_vars')(init_pyembed)
+feature('pyembed')(init_pyembed)
+conf(get_python_variables)
+conf(check_python_headers)
+conf(check_python_version)
+conf(check_python_module)

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/qt4.py

@@ -0,0 +1,424 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+try:
+	from xml.sax import make_parser
+	from xml.sax.handler import ContentHandler
+except ImportError:
+	has_xml=False
+	ContentHandler=object
+else:
+	has_xml=True
+import os,sys
+from waflib.Tools import c_preproc,cxx
+from waflib import Task,Utils,Options,Errors
+from waflib.TaskGen import feature,after_method,extension
+from waflib.Configure import conf
+from waflib.Logs import error
+MOC_H=['.h','.hpp','.hxx','.hh']
+EXT_RCC=['.qrc']
+EXT_UI=['.ui']
+EXT_QT4=['.cpp','.cc','.cxx','.C']
+QT4_LIBS="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtXmlPatterns QtWebKit Qt3Support QtHelp QtScript QtDeclarative"
+class qxx(cxx.cxx):
+	def __init__(self,*k,**kw):
+		Task.Task.__init__(self,*k,**kw)
+		self.moc_done=0
+	def scan(self):
+		(nodes,names)=c_preproc.scan(self)
+		for x in nodes:
+			if x.name.endswith('.moc'):
+				nodes.remove(x)
+				names.append(x.path_from(self.inputs[0].parent.get_bld()))
+		return(nodes,names)
+	def runnable_status(self):
+		if self.moc_done:
+			return Task.Task.runnable_status(self)
+		else:
+			for t in self.run_after:
+				if not t.hasrun:
+					return Task.ASK_LATER
+			self.add_moc_tasks()
+			return Task.Task.runnable_status(self)
+	def add_moc_tasks(self):
+		node=self.inputs[0]
+		bld=self.generator.bld
+		try:
+			self.signature()
+		except KeyError:
+			pass
+		else:
+			delattr(self,'cache_sig')
+		moctasks=[]
+		mocfiles=[]
+		try:
+			tmp_lst=bld.raw_deps[self.uid()]
+			bld.raw_deps[self.uid()]=[]
+		except KeyError:
+			tmp_lst=[]
+		for d in tmp_lst:
+			if not d.endswith('.moc'):
+				continue
+			if d in mocfiles:
+				error("paranoia owns")
+				continue
+			mocfiles.append(d)
+			h_node=None
+			try:ext=Options.options.qt_header_ext.split()
+			except AttributeError:pass
+			if not ext:ext=MOC_H
+			base2=d[:-4]
+			for x in[node.parent]+self.generator.includes_nodes:
+				for e in ext:
+					h_node=x.find_node(base2+e)
+					if h_node:
+						break
+				else:
+					continue
+				break
+			else:
+				raise Errors.WafError('no header found for %r which is a moc file'%d)
+			m_node=h_node.change_ext('.moc')
+			bld.node_deps[(self.inputs[0].parent.abspath(),m_node.name)]=h_node
+			task=Task.classes['moc'](env=self.env,generator=self.generator)
+			task.set_inputs(h_node)
+			task.set_outputs(m_node)
+			gen=bld.producer
+			gen.outstanding.insert(0,task)
+			gen.total+=1
+			moctasks.append(task)
+		tmp_lst=bld.raw_deps[self.uid()]=mocfiles
+		lst=bld.node_deps.get(self.uid(),())
+		for d in lst:
+			name=d.name
+			if name.endswith('.moc'):
+				task=Task.classes['moc'](env=self.env,generator=self.generator)
+				task.set_inputs(bld.node_deps[(self.inputs[0].parent.abspath(),name)])
+				task.set_outputs(d)
+				gen=bld.producer
+				gen.outstanding.insert(0,task)
+				gen.total+=1
+				moctasks.append(task)
+		self.run_after.update(set(moctasks))
+		self.moc_done=1
+	run=Task.classes['cxx'].__dict__['run']
+class trans_update(Task.Task):
+	run_str='${QT_LUPDATE} ${SRC} -ts ${TGT}'
+	color='BLUE'
+Task.update_outputs(trans_update)
+class XMLHandler(ContentHandler):
+	def __init__(self):
+		self.buf=[]
+		self.files=[]
+	def startElement(self,name,attrs):
+		if name=='file':
+			self.buf=[]
+	def endElement(self,name):
+		if name=='file':
+			self.files.append(str(''.join(self.buf)))
+	def characters(self,cars):
+		self.buf.append(cars)
+def create_rcc_task(self,node):
+	rcnode=node.change_ext('_rc.cpp')
+	rcctask=self.create_task('rcc',node,rcnode)
+	cpptask=self.create_task('cxx',rcnode,rcnode.change_ext('.o'))
+	try:
+		self.compiled_tasks.append(cpptask)
+	except AttributeError:
+		self.compiled_tasks=[cpptask]
+	return cpptask
+def create_uic_task(self,node):
+	uictask=self.create_task('ui4',node)
+	uictask.outputs=[self.path.find_or_declare(self.env['ui_PATTERN']%node.name[:-3])]
+def add_lang(self,node):
+	self.lang=self.to_list(getattr(self,'lang',[]))+[node]
+def apply_qt4(self):
+	if getattr(self,'lang',None):
+		qmtasks=[]
+		for x in self.to_list(self.lang):
+			if isinstance(x,str):
+				x=self.path.find_resource(x+'.ts')
+			qmtasks.append(self.create_task('ts2qm',x,x.change_ext('.qm')))
+		if getattr(self,'update',None)and Options.options.trans_qt4:
+			cxxnodes=[a.inputs[0]for a in self.compiled_tasks]+[a.inputs[0]for a in self.tasks if getattr(a,'inputs',None)and a.inputs[0].name.endswith('.ui')]
+			for x in qmtasks:
+				self.create_task('trans_update',cxxnodes,x.inputs)
+		if getattr(self,'langname',None):
+			qmnodes=[x.outputs[0]for x in qmtasks]
+			rcnode=self.langname
+			if isinstance(rcnode,str):
+				rcnode=self.path.find_or_declare(rcnode+'.qrc')
+			t=self.create_task('qm2rcc',qmnodes,rcnode)
+			k=create_rcc_task(self,t.outputs[0])
+			self.link_task.inputs.append(k.outputs[0])
+	lst=[]
+	for flag in self.to_list(self.env['CXXFLAGS']):
+		if len(flag)<2:continue
+		f=flag[0:2]
+		if f in['-D','-I','/D','/I']:
+			if(f[0]=='/'):
+				lst.append('-'+flag[1:])
+			else:
+				lst.append(flag)
+	self.env['MOC_FLAGS']=lst
+def cxx_hook(self,node):
+	return self.create_compiled_task('qxx',node)
+class rcc(Task.Task):
+	color='BLUE'
+	run_str='${QT_RCC} -name ${SRC[0].name} ${SRC[0].abspath()} ${RCC_ST} -o ${TGT}'
+	ext_out=['.h']
+	def scan(self):
+		node=self.inputs[0]
+		parser=make_parser()
+		curHandler=XMLHandler()
+		parser.setContentHandler(curHandler)
+		fi=open(self.inputs[0].abspath())
+		parser.parse(fi)
+		fi.close()
+		nodes=[]
+		names=[]
+		root=self.inputs[0].parent
+		for x in curHandler.files:
+			nd=root.find_resource(x)
+			if nd:nodes.append(nd)
+			else:names.append(x)
+		return(nodes,names)
+class moc(Task.Task):
+	color='BLUE'
+	run_str='${QT_MOC} ${MOC_FLAGS} ${MOCCPPPATH_ST:INCPATHS} ${MOCDEFINES_ST:DEFINES} ${SRC} ${MOC_ST} ${TGT}'
+class ui4(Task.Task):
+	color='BLUE'
+	run_str='${QT_UIC} ${SRC} -o ${TGT}'
+	ext_out=['.h']
+class ts2qm(Task.Task):
+	color='BLUE'
+	run_str='${QT_LRELEASE} ${QT_LRELEASE_FLAGS} ${SRC} -qm ${TGT}'
+class qm2rcc(Task.Task):
+	color='BLUE'
+	after='ts2qm'
+	def run(self):
+		txt='\n'.join(['<file>%s</file>'%k.path_from(self.outputs[0].parent)for k in self.inputs])
+		code='<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n%s\n</qresource>\n</RCC>'%txt
+		self.outputs[0].write(code)
+def configure(self):
+	self.find_qt4_binaries()
+	self.set_qt4_libs_to_check()
+	self.find_qt4_libraries()
+	self.add_qt4_rpath()
+	self.simplify_qt4_libs()
+def find_qt4_binaries(self):
+	env=self.env
+	opt=Options.options
+	qtdir=getattr(opt,'qtdir','')
+	qtbin=getattr(opt,'qtbin','')
+	paths=[]
+	if qtdir:
+		qtbin=os.path.join(qtdir,'bin')
+	if not qtdir:
+		qtdir=self.environ.get('QT4_ROOT','')
+		qtbin=os.path.join(qtdir,'bin')
+	if qtbin:
+		paths=[qtbin]
+	if not qtdir:
+		paths=os.environ.get('PATH','').split(os.pathsep)
+		paths.append('/usr/share/qt4/bin/')
+		try:
+			lst=Utils.listdir('/usr/local/Trolltech/')
+		except OSError:
+			pass
+		else:
+			if lst:
+				lst.sort()
+				lst.reverse()
+				qtdir='/usr/local/Trolltech/%s/'%lst[0]
+				qtbin=os.path.join(qtdir,'bin')
+				paths.append(qtbin)
+	cand=None
+	prev_ver=['4','0','0']
+	for qmk in['qmake-qt4','qmake4','qmake']:
+		try:
+			qmake=self.find_program(qmk,path_list=paths)
+		except self.errors.ConfigurationError:
+			pass
+		else:
+			try:
+				version=self.cmd_and_log([qmake,'-query','QT_VERSION']).strip()
+			except self.errors.ConfigurationError:
+				pass
+			else:
+				if version:
+					new_ver=version.split('.')
+					if new_ver>prev_ver:
+						cand=qmake
+						prev_ver=new_ver
+	if cand:
+		self.env.QMAKE=cand
+	else:
+		self.fatal('Could not find qmake for qt4')
+	qtbin=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_BINS']).strip()+os.sep
+	def find_bin(lst,var):
+		for f in lst:
+			try:
+				ret=self.find_program(f,path_list=paths)
+			except self.errors.ConfigurationError:
+				pass
+			else:
+				env[var]=ret
+				break
+	find_bin(['uic-qt3','uic3'],'QT_UIC3')
+	find_bin(['uic-qt4','uic'],'QT_UIC')
+	if not env['QT_UIC']:
+		self.fatal('cannot find the uic compiler for qt4')
+	try:
+		uicver=self.cmd_and_log(env['QT_UIC']+" -version 2>&1").strip()
+	except self.errors.ConfigurationError:
+		self.fatal('this uic compiler is for qt3, add uic for qt4 to your path')
+	uicver=uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt','')
+	self.msg('Checking for uic version','%s'%uicver)
+	if uicver.find(' 3.')!=-1:
+		self.fatal('this uic compiler is for qt3, add uic for qt4 to your path')
+	find_bin(['moc-qt4','moc'],'QT_MOC')
+	find_bin(['rcc'],'QT_RCC')
+	find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE')
+	find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE')
+	env['UIC3_ST']='%s -o %s'
+	env['UIC_ST']='%s -o %s'
+	env['MOC_ST']='-o'
+	env['ui_PATTERN']='ui_%s.h'
+	env['QT_LRELEASE_FLAGS']=['-silent']
+	env.MOCCPPPATH_ST='-I%s'
+	env.MOCDEFINES_ST='-D%s'
+def find_qt4_libraries(self):
+	qtlibs=getattr(Options.options,'qtlibs','')
+	if not qtlibs:
+		try:
+			qtlibs=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_LIBS']).strip()
+		except Errors.WafError:
+			qtdir=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_PREFIX']).strip()+os.sep
+			qtlibs=os.path.join(qtdir,'lib')
+	self.msg('Found the Qt4 libraries in',qtlibs)
+	qtincludes=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_HEADERS']).strip()
+	env=self.env
+	if not'PKG_CONFIG_PATH'in os.environ:
+		os.environ['PKG_CONFIG_PATH']='%s:%s/pkgconfig:/usr/lib/qt4/lib/pkgconfig:/opt/qt4/lib/pkgconfig:/usr/lib/qt4/lib:/opt/qt4/lib'%(qtlibs,qtlibs)
+	try:
+		self.check_cfg(atleast_pkgconfig_version='0.1')
+	except self.errors.ConfigurationError:
+		for i in self.qt4_vars:
+			uselib=i.upper()
+			if sys.platform=="darwin":
+				frameworkName=i+".framework"
+				qtDynamicLib=os.path.join(qtlibs,frameworkName,i)
+				if os.path.exists(qtDynamicLib):
+					env.append_unique('FRAMEWORK_'+uselib,i)
+					self.msg('Checking for %s'%i,qtDynamicLib,'GREEN')
+				else:
+					self.msg('Checking for %s'%i,False,'YELLOW')
+				env.append_unique('INCLUDES_'+uselib,os.path.join(qtlibs,frameworkName,'Headers'))
+			elif sys.platform!="win32":
+				qtDynamicLib=os.path.join(qtlibs,"lib"+i+".so")
+				qtStaticLib=os.path.join(qtlibs,"lib"+i+".a")
+				if os.path.exists(qtDynamicLib):
+					env.append_unique('LIB_'+uselib,i)
+					self.msg('Checking for %s'%i,qtDynamicLib,'GREEN')
+				elif os.path.exists(qtStaticLib):
+					env.append_unique('LIB_'+uselib,i)
+					self.msg('Checking for %s'%i,qtStaticLib,'GREEN')
+				else:
+					self.msg('Checking for %s'%i,False,'YELLOW')
+				env.append_unique('LIBPATH_'+uselib,qtlibs)
+				env.append_unique('INCLUDES_'+uselib,qtincludes)
+				env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i))
+			else:
+				for k in("lib%s.a","lib%s4.a","%s.lib","%s4.lib"):
+					lib=os.path.join(qtlibs,k%i)
+					if os.path.exists(lib):
+						env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')])
+						self.msg('Checking for %s'%i,lib,'GREEN')
+						break
+				else:
+					self.msg('Checking for %s'%i,False,'YELLOW')
+				env.append_unique('LIBPATH_'+uselib,qtlibs)
+				env.append_unique('INCLUDES_'+uselib,qtincludes)
+				env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i))
+				uselib=i.upper()+"_debug"
+				for k in("lib%sd.a","lib%sd4.a","%sd.lib","%sd4.lib"):
+					lib=os.path.join(qtlibs,k%i)
+					if os.path.exists(lib):
+						env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')])
+						self.msg('Checking for %s'%i,lib,'GREEN')
+						break
+				else:
+					self.msg('Checking for %s'%i,False,'YELLOW')
+				env.append_unique('LIBPATH_'+uselib,qtlibs)
+				env.append_unique('INCLUDES_'+uselib,qtincludes)
+				env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i))
+	else:
+		for i in self.qt4_vars_debug+self.qt4_vars:
+			self.check_cfg(package=i,args='--cflags --libs',mandatory=False)
+def simplify_qt4_libs(self):
+	env=self.env
+	def process_lib(vars_,coreval):
+		for d in vars_:
+			var=d.upper()
+			if var=='QTCORE':
+				continue
+			value=env['LIBPATH_'+var]
+			if value:
+				core=env[coreval]
+				accu=[]
+				for lib in value:
+					if lib in core:
+						continue
+					accu.append(lib)
+				env['LIBPATH_'+var]=accu
+	process_lib(self.qt4_vars,'LIBPATH_QTCORE')
+	process_lib(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG')
+def add_qt4_rpath(self):
+	env=self.env
+	if Options.options.want_rpath:
+		def process_rpath(vars_,coreval):
+			for d in vars_:
+				var=d.upper()
+				value=env['LIBPATH_'+var]
+				if value:
+					core=env[coreval]
+					accu=[]
+					for lib in value:
+						if var!='QTCORE':
+							if lib in core:
+								continue
+						accu.append('-Wl,--rpath='+lib)
+					env['RPATH_'+var]=accu
+		process_rpath(self.qt4_vars,'LIBPATH_QTCORE')
+		process_rpath(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG')
+def set_qt4_libs_to_check(self):
+	if not hasattr(self,'qt4_vars'):
+		self.qt4_vars=QT4_LIBS
+	self.qt4_vars=Utils.to_list(self.qt4_vars)
+	if not hasattr(self,'qt4_vars_debug'):
+		self.qt4_vars_debug=[a+'_debug'for a in self.qt4_vars]
+	self.qt4_vars_debug=Utils.to_list(self.qt4_vars_debug)
+def options(opt):
+	opt.add_option('--want-rpath',action='store_true',default=False,dest='want_rpath',help='enable the rpath for qt libraries')
+	opt.add_option('--header-ext',type='string',default='',help='header extension for moc files',dest='qt_header_ext')
+	for i in'qtdir qtbin qtlibs'.split():
+		opt.add_option('--'+i,type='string',default='',dest=i)
+	if sys.platform=="darwin":
+		opt.add_option('--no-qt4-framework',action="store_false",help='do not use the framework version of Qt4 in OS X',dest='use_qt4_osxframework',default=True)
+	opt.add_option('--translate',action="store_true",help="collect translation strings",dest="trans_qt4",default=False)
+
+extension(*EXT_RCC)(create_rcc_task)
+extension(*EXT_UI)(create_uic_task)
+extension('.ts')(add_lang)
+feature('qt4')(apply_qt4)
+after_method('apply_link')(apply_qt4)
+extension(*EXT_QT4)(cxx_hook)
+conf(find_qt4_binaries)
+conf(find_qt4_libraries)
+conf(simplify_qt4_libs)
+conf(add_qt4_rpath)
+conf(set_qt4_libs_to_check)