1 | #! /usr/bin/env python |
---|
2 | # encoding: utf-8 |
---|
3 | # WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file |
---|
4 | |
---|
5 | try: |
---|
6 | from xml.sax import make_parser |
---|
7 | from xml.sax.handler import ContentHandler |
---|
8 | except ImportError: |
---|
9 | has_xml=False |
---|
10 | ContentHandler=object |
---|
11 | else: |
---|
12 | has_xml=True |
---|
13 | import os,sys |
---|
14 | from waflib.Tools import cxx |
---|
15 | from waflib import Task,Utils,Options,Errors,Context |
---|
16 | from waflib.TaskGen import feature,after_method,extension |
---|
17 | from waflib.Configure import conf |
---|
18 | from waflib import Logs |
---|
19 | MOC_H=['.h','.hpp','.hxx','.hh'] |
---|
20 | EXT_RCC=['.qrc'] |
---|
21 | EXT_UI=['.ui'] |
---|
22 | EXT_QT4=['.cpp','.cc','.cxx','.C'] |
---|
23 | QT4_LIBS="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtXmlPatterns QtWebKit Qt3Support QtHelp QtScript QtDeclarative QtDesigner" |
---|
24 | class qxx(Task.classes['cxx']): |
---|
25 | def __init__(self,*k,**kw): |
---|
26 | Task.Task.__init__(self,*k,**kw) |
---|
27 | self.moc_done=0 |
---|
28 | def runnable_status(self): |
---|
29 | if self.moc_done: |
---|
30 | return Task.Task.runnable_status(self) |
---|
31 | else: |
---|
32 | for t in self.run_after: |
---|
33 | if not t.hasrun: |
---|
34 | return Task.ASK_LATER |
---|
35 | self.add_moc_tasks() |
---|
36 | return Task.Task.runnable_status(self) |
---|
37 | def create_moc_task(self,h_node,m_node): |
---|
38 | try: |
---|
39 | moc_cache=self.generator.bld.moc_cache |
---|
40 | except AttributeError: |
---|
41 | moc_cache=self.generator.bld.moc_cache={} |
---|
42 | try: |
---|
43 | return moc_cache[h_node] |
---|
44 | except KeyError: |
---|
45 | tsk=moc_cache[h_node]=Task.classes['moc'](env=self.env,generator=self.generator) |
---|
46 | tsk.set_inputs(h_node) |
---|
47 | tsk.set_outputs(m_node) |
---|
48 | if self.generator: |
---|
49 | self.generator.tasks.append(tsk) |
---|
50 | gen=self.generator.bld.producer |
---|
51 | gen.outstanding.insert(0,tsk) |
---|
52 | gen.total+=1 |
---|
53 | return tsk |
---|
54 | def moc_h_ext(self): |
---|
55 | try: |
---|
56 | ext=Options.options.qt_header_ext.split() |
---|
57 | except AttributeError: |
---|
58 | pass |
---|
59 | if not ext: |
---|
60 | ext=MOC_H |
---|
61 | return ext |
---|
62 | def add_moc_tasks(self): |
---|
63 | node=self.inputs[0] |
---|
64 | bld=self.generator.bld |
---|
65 | try: |
---|
66 | self.signature() |
---|
67 | except KeyError: |
---|
68 | pass |
---|
69 | else: |
---|
70 | delattr(self,'cache_sig') |
---|
71 | include_nodes=[node.parent]+self.generator.includes_nodes |
---|
72 | moctasks=[] |
---|
73 | mocfiles=set([]) |
---|
74 | for d in bld.raw_deps.get(self.uid(),[]): |
---|
75 | if not d.endswith('.moc'): |
---|
76 | continue |
---|
77 | if d in mocfiles: |
---|
78 | continue |
---|
79 | mocfiles.add(d) |
---|
80 | h_node=None |
---|
81 | base2=d[:-4] |
---|
82 | for x in include_nodes: |
---|
83 | for e in self.moc_h_ext(): |
---|
84 | h_node=x.find_node(base2+e) |
---|
85 | if h_node: |
---|
86 | break |
---|
87 | if h_node: |
---|
88 | m_node=h_node.change_ext('.moc') |
---|
89 | break |
---|
90 | else: |
---|
91 | for k in EXT_QT4: |
---|
92 | if base2.endswith(k): |
---|
93 | for x in include_nodes: |
---|
94 | h_node=x.find_node(base2) |
---|
95 | if h_node: |
---|
96 | break |
---|
97 | if h_node: |
---|
98 | m_node=h_node.change_ext(k+'.moc') |
---|
99 | break |
---|
100 | if not h_node: |
---|
101 | raise Errors.WafError('No source found for %r which is a moc file'%d) |
---|
102 | task=self.create_moc_task(h_node,m_node) |
---|
103 | moctasks.append(task) |
---|
104 | self.run_after.update(set(moctasks)) |
---|
105 | self.moc_done=1 |
---|
106 | class trans_update(Task.Task): |
---|
107 | run_str='${QT_LUPDATE} ${SRC} -ts ${TGT}' |
---|
108 | color='BLUE' |
---|
109 | Task.update_outputs(trans_update) |
---|
110 | class XMLHandler(ContentHandler): |
---|
111 | def __init__(self): |
---|
112 | self.buf=[] |
---|
113 | self.files=[] |
---|
114 | def startElement(self,name,attrs): |
---|
115 | if name=='file': |
---|
116 | self.buf=[] |
---|
117 | def endElement(self,name): |
---|
118 | if name=='file': |
---|
119 | self.files.append(str(''.join(self.buf))) |
---|
120 | def characters(self,cars): |
---|
121 | self.buf.append(cars) |
---|
122 | @extension(*EXT_RCC) |
---|
123 | def create_rcc_task(self,node): |
---|
124 | rcnode=node.change_ext('_rc.cpp') |
---|
125 | self.create_task('rcc',node,rcnode) |
---|
126 | cpptask=self.create_task('cxx',rcnode,rcnode.change_ext('.o')) |
---|
127 | try: |
---|
128 | self.compiled_tasks.append(cpptask) |
---|
129 | except AttributeError: |
---|
130 | self.compiled_tasks=[cpptask] |
---|
131 | return cpptask |
---|
132 | @extension(*EXT_UI) |
---|
133 | def create_uic_task(self,node): |
---|
134 | uictask=self.create_task('ui4',node) |
---|
135 | uictask.outputs=[self.path.find_or_declare(self.env['ui_PATTERN']%node.name[:-3])] |
---|
136 | @extension('.ts') |
---|
137 | def add_lang(self,node): |
---|
138 | self.lang=self.to_list(getattr(self,'lang',[]))+[node] |
---|
139 | @feature('qt4') |
---|
140 | @after_method('apply_link') |
---|
141 | def apply_qt4(self): |
---|
142 | if getattr(self,'lang',None): |
---|
143 | qmtasks=[] |
---|
144 | for x in self.to_list(self.lang): |
---|
145 | if isinstance(x,str): |
---|
146 | x=self.path.find_resource(x+'.ts') |
---|
147 | qmtasks.append(self.create_task('ts2qm',x,x.change_ext('.qm'))) |
---|
148 | if getattr(self,'update',None)and Options.options.trans_qt4: |
---|
149 | 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')] |
---|
150 | for x in qmtasks: |
---|
151 | self.create_task('trans_update',cxxnodes,x.inputs) |
---|
152 | if getattr(self,'langname',None): |
---|
153 | qmnodes=[x.outputs[0]for x in qmtasks] |
---|
154 | rcnode=self.langname |
---|
155 | if isinstance(rcnode,str): |
---|
156 | rcnode=self.path.find_or_declare(rcnode+'.qrc') |
---|
157 | t=self.create_task('qm2rcc',qmnodes,rcnode) |
---|
158 | k=create_rcc_task(self,t.outputs[0]) |
---|
159 | self.link_task.inputs.append(k.outputs[0]) |
---|
160 | lst=[] |
---|
161 | for flag in self.to_list(self.env['CXXFLAGS']): |
---|
162 | if len(flag)<2:continue |
---|
163 | f=flag[0:2] |
---|
164 | if f in('-D','-I','/D','/I'): |
---|
165 | if(f[0]=='/'): |
---|
166 | lst.append('-'+flag[1:]) |
---|
167 | else: |
---|
168 | lst.append(flag) |
---|
169 | self.env.append_value('MOC_FLAGS',lst) |
---|
170 | @extension(*EXT_QT4) |
---|
171 | def cxx_hook(self,node): |
---|
172 | return self.create_compiled_task('qxx',node) |
---|
173 | class rcc(Task.Task): |
---|
174 | color='BLUE' |
---|
175 | run_str='${QT_RCC} -name ${tsk.rcname()} ${SRC[0].abspath()} ${RCC_ST} -o ${TGT}' |
---|
176 | ext_out=['.h'] |
---|
177 | def rcname(self): |
---|
178 | return os.path.splitext(self.inputs[0].name)[0] |
---|
179 | def scan(self): |
---|
180 | if not has_xml: |
---|
181 | Logs.error('no xml support was found, the rcc dependencies will be incomplete!') |
---|
182 | return([],[]) |
---|
183 | parser=make_parser() |
---|
184 | curHandler=XMLHandler() |
---|
185 | parser.setContentHandler(curHandler) |
---|
186 | fi=open(self.inputs[0].abspath(),'r') |
---|
187 | try: |
---|
188 | parser.parse(fi) |
---|
189 | finally: |
---|
190 | fi.close() |
---|
191 | nodes=[] |
---|
192 | names=[] |
---|
193 | root=self.inputs[0].parent |
---|
194 | for x in curHandler.files: |
---|
195 | nd=root.find_resource(x) |
---|
196 | if nd:nodes.append(nd) |
---|
197 | else:names.append(x) |
---|
198 | return(nodes,names) |
---|
199 | class moc(Task.Task): |
---|
200 | color='BLUE' |
---|
201 | run_str='${QT_MOC} ${MOC_FLAGS} ${MOCCPPPATH_ST:INCPATHS} ${MOCDEFINES_ST:DEFINES} ${SRC} ${MOC_ST} ${TGT}' |
---|
202 | def keyword(self): |
---|
203 | return"Creating" |
---|
204 | def __str__(self): |
---|
205 | return self.outputs[0].path_from(self.generator.bld.launch_node()) |
---|
206 | class ui4(Task.Task): |
---|
207 | color='BLUE' |
---|
208 | run_str='${QT_UIC} ${SRC} -o ${TGT}' |
---|
209 | ext_out=['.h'] |
---|
210 | class ts2qm(Task.Task): |
---|
211 | color='BLUE' |
---|
212 | run_str='${QT_LRELEASE} ${QT_LRELEASE_FLAGS} ${SRC} -qm ${TGT}' |
---|
213 | class qm2rcc(Task.Task): |
---|
214 | color='BLUE' |
---|
215 | after='ts2qm' |
---|
216 | def run(self): |
---|
217 | txt='\n'.join(['<file>%s</file>'%k.path_from(self.outputs[0].parent)for k in self.inputs]) |
---|
218 | code='<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n%s\n</qresource>\n</RCC>'%txt |
---|
219 | self.outputs[0].write(code) |
---|
220 | def configure(self): |
---|
221 | self.find_qt4_binaries() |
---|
222 | self.set_qt4_libs_to_check() |
---|
223 | self.set_qt4_defines() |
---|
224 | self.find_qt4_libraries() |
---|
225 | self.add_qt4_rpath() |
---|
226 | self.simplify_qt4_libs() |
---|
227 | @conf |
---|
228 | def find_qt4_binaries(self): |
---|
229 | env=self.env |
---|
230 | opt=Options.options |
---|
231 | qtdir=getattr(opt,'qtdir','') |
---|
232 | qtbin=getattr(opt,'qtbin','') |
---|
233 | paths=[] |
---|
234 | if qtdir: |
---|
235 | qtbin=os.path.join(qtdir,'bin') |
---|
236 | if not qtdir: |
---|
237 | qtdir=os.environ.get('QT4_ROOT','') |
---|
238 | qtbin=os.environ.get('QT4_BIN',None)or os.path.join(qtdir,'bin') |
---|
239 | if qtbin: |
---|
240 | paths=[qtbin] |
---|
241 | if not qtdir: |
---|
242 | paths=os.environ.get('PATH','').split(os.pathsep) |
---|
243 | paths.append('/usr/share/qt4/bin/') |
---|
244 | try: |
---|
245 | lst=Utils.listdir('/usr/local/Trolltech/') |
---|
246 | except OSError: |
---|
247 | pass |
---|
248 | else: |
---|
249 | if lst: |
---|
250 | lst.sort() |
---|
251 | lst.reverse() |
---|
252 | qtdir='/usr/local/Trolltech/%s/'%lst[0] |
---|
253 | qtbin=os.path.join(qtdir,'bin') |
---|
254 | paths.append(qtbin) |
---|
255 | cand=None |
---|
256 | prev_ver=['4','0','0'] |
---|
257 | for qmk in('qmake-qt4','qmake4','qmake'): |
---|
258 | try: |
---|
259 | qmake=self.find_program(qmk,path_list=paths) |
---|
260 | except self.errors.ConfigurationError: |
---|
261 | pass |
---|
262 | else: |
---|
263 | try: |
---|
264 | version=self.cmd_and_log(qmake+['-query','QT_VERSION']).strip() |
---|
265 | except self.errors.WafError: |
---|
266 | pass |
---|
267 | else: |
---|
268 | if version: |
---|
269 | new_ver=version.split('.') |
---|
270 | if new_ver>prev_ver: |
---|
271 | cand=qmake |
---|
272 | prev_ver=new_ver |
---|
273 | if cand: |
---|
274 | self.env.QMAKE=cand |
---|
275 | else: |
---|
276 | self.fatal('Could not find qmake for qt4') |
---|
277 | qtbin=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_BINS']).strip()+os.sep |
---|
278 | def find_bin(lst,var): |
---|
279 | if var in env: |
---|
280 | return |
---|
281 | for f in lst: |
---|
282 | try: |
---|
283 | ret=self.find_program(f,path_list=paths) |
---|
284 | except self.errors.ConfigurationError: |
---|
285 | pass |
---|
286 | else: |
---|
287 | env[var]=ret |
---|
288 | break |
---|
289 | find_bin(['uic-qt3','uic3'],'QT_UIC3') |
---|
290 | find_bin(['uic-qt4','uic'],'QT_UIC') |
---|
291 | if not env.QT_UIC: |
---|
292 | self.fatal('cannot find the uic compiler for qt4') |
---|
293 | self.start_msg('Checking for uic version') |
---|
294 | uicver=self.cmd_and_log(env.QT_UIC+["-version"],output=Context.BOTH) |
---|
295 | uicver=''.join(uicver).strip() |
---|
296 | uicver=uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt','') |
---|
297 | self.end_msg(uicver) |
---|
298 | if uicver.find(' 3.')!=-1: |
---|
299 | self.fatal('this uic compiler is for qt3, add uic for qt4 to your path') |
---|
300 | find_bin(['moc-qt4','moc'],'QT_MOC') |
---|
301 | find_bin(['rcc-qt4','rcc'],'QT_RCC') |
---|
302 | find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE') |
---|
303 | find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE') |
---|
304 | env['UIC3_ST']='%s -o %s' |
---|
305 | env['UIC_ST']='%s -o %s' |
---|
306 | env['MOC_ST']='-o' |
---|
307 | env['ui_PATTERN']='ui_%s.h' |
---|
308 | env['QT_LRELEASE_FLAGS']=['-silent'] |
---|
309 | env.MOCCPPPATH_ST='-I%s' |
---|
310 | env.MOCDEFINES_ST='-D%s' |
---|
311 | @conf |
---|
312 | def find_qt4_libraries(self): |
---|
313 | qtlibs=getattr(Options.options,'qtlibs',None)or os.environ.get("QT4_LIBDIR",None) |
---|
314 | if not qtlibs: |
---|
315 | try: |
---|
316 | qtlibs=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_LIBS']).strip() |
---|
317 | except Errors.WafError: |
---|
318 | qtdir=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_PREFIX']).strip()+os.sep |
---|
319 | qtlibs=os.path.join(qtdir,'lib') |
---|
320 | self.msg('Found the Qt4 libraries in',qtlibs) |
---|
321 | qtincludes=os.environ.get("QT4_INCLUDES",None)or self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_HEADERS']).strip() |
---|
322 | env=self.env |
---|
323 | if not'PKG_CONFIG_PATH'in os.environ: |
---|
324 | 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) |
---|
325 | try: |
---|
326 | if os.environ.get("QT4_XCOMPILE",None): |
---|
327 | raise self.errors.ConfigurationError() |
---|
328 | self.check_cfg(atleast_pkgconfig_version='0.1') |
---|
329 | except self.errors.ConfigurationError: |
---|
330 | for i in self.qt4_vars: |
---|
331 | uselib=i.upper() |
---|
332 | if Utils.unversioned_sys_platform()=="darwin": |
---|
333 | frameworkName=i+".framework" |
---|
334 | qtDynamicLib=os.path.join(qtlibs,frameworkName,i) |
---|
335 | if os.path.exists(qtDynamicLib): |
---|
336 | env.append_unique('FRAMEWORK_'+uselib,i) |
---|
337 | self.msg('Checking for %s'%i,qtDynamicLib,'GREEN') |
---|
338 | else: |
---|
339 | self.msg('Checking for %s'%i,False,'YELLOW') |
---|
340 | env.append_unique('INCLUDES_'+uselib,os.path.join(qtlibs,frameworkName,'Headers')) |
---|
341 | elif env.DEST_OS!="win32": |
---|
342 | qtDynamicLib=os.path.join(qtlibs,"lib"+i+".so") |
---|
343 | qtStaticLib=os.path.join(qtlibs,"lib"+i+".a") |
---|
344 | if os.path.exists(qtDynamicLib): |
---|
345 | env.append_unique('LIB_'+uselib,i) |
---|
346 | self.msg('Checking for %s'%i,qtDynamicLib,'GREEN') |
---|
347 | elif os.path.exists(qtStaticLib): |
---|
348 | env.append_unique('LIB_'+uselib,i) |
---|
349 | self.msg('Checking for %s'%i,qtStaticLib,'GREEN') |
---|
350 | else: |
---|
351 | self.msg('Checking for %s'%i,False,'YELLOW') |
---|
352 | env.append_unique('LIBPATH_'+uselib,qtlibs) |
---|
353 | env.append_unique('INCLUDES_'+uselib,qtincludes) |
---|
354 | env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) |
---|
355 | else: |
---|
356 | for k in("lib%s.a","lib%s4.a","%s.lib","%s4.lib"): |
---|
357 | lib=os.path.join(qtlibs,k%i) |
---|
358 | if os.path.exists(lib): |
---|
359 | env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')]) |
---|
360 | self.msg('Checking for %s'%i,lib,'GREEN') |
---|
361 | break |
---|
362 | else: |
---|
363 | self.msg('Checking for %s'%i,False,'YELLOW') |
---|
364 | env.append_unique('LIBPATH_'+uselib,qtlibs) |
---|
365 | env.append_unique('INCLUDES_'+uselib,qtincludes) |
---|
366 | env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) |
---|
367 | uselib=i.upper()+"_debug" |
---|
368 | for k in("lib%sd.a","lib%sd4.a","%sd.lib","%sd4.lib"): |
---|
369 | lib=os.path.join(qtlibs,k%i) |
---|
370 | if os.path.exists(lib): |
---|
371 | env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')]) |
---|
372 | self.msg('Checking for %s'%i,lib,'GREEN') |
---|
373 | break |
---|
374 | else: |
---|
375 | self.msg('Checking for %s'%i,False,'YELLOW') |
---|
376 | env.append_unique('LIBPATH_'+uselib,qtlibs) |
---|
377 | env.append_unique('INCLUDES_'+uselib,qtincludes) |
---|
378 | env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) |
---|
379 | else: |
---|
380 | for i in self.qt4_vars_debug+self.qt4_vars: |
---|
381 | self.check_cfg(package=i,args='--cflags --libs',mandatory=False) |
---|
382 | @conf |
---|
383 | def simplify_qt4_libs(self): |
---|
384 | env=self.env |
---|
385 | def process_lib(vars_,coreval): |
---|
386 | for d in vars_: |
---|
387 | var=d.upper() |
---|
388 | if var=='QTCORE': |
---|
389 | continue |
---|
390 | value=env['LIBPATH_'+var] |
---|
391 | if value: |
---|
392 | core=env[coreval] |
---|
393 | accu=[] |
---|
394 | for lib in value: |
---|
395 | if lib in core: |
---|
396 | continue |
---|
397 | accu.append(lib) |
---|
398 | env['LIBPATH_'+var]=accu |
---|
399 | process_lib(self.qt4_vars,'LIBPATH_QTCORE') |
---|
400 | process_lib(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG') |
---|
401 | @conf |
---|
402 | def add_qt4_rpath(self): |
---|
403 | env=self.env |
---|
404 | if getattr(Options.options,'want_rpath',False): |
---|
405 | def process_rpath(vars_,coreval): |
---|
406 | for d in vars_: |
---|
407 | var=d.upper() |
---|
408 | value=env['LIBPATH_'+var] |
---|
409 | if value: |
---|
410 | core=env[coreval] |
---|
411 | accu=[] |
---|
412 | for lib in value: |
---|
413 | if var!='QTCORE': |
---|
414 | if lib in core: |
---|
415 | continue |
---|
416 | accu.append('-Wl,--rpath='+lib) |
---|
417 | env['RPATH_'+var]=accu |
---|
418 | process_rpath(self.qt4_vars,'LIBPATH_QTCORE') |
---|
419 | process_rpath(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG') |
---|
420 | @conf |
---|
421 | def set_qt4_libs_to_check(self): |
---|
422 | if not hasattr(self,'qt4_vars'): |
---|
423 | self.qt4_vars=QT4_LIBS |
---|
424 | self.qt4_vars=Utils.to_list(self.qt4_vars) |
---|
425 | if not hasattr(self,'qt4_vars_debug'): |
---|
426 | self.qt4_vars_debug=[a+'_debug'for a in self.qt4_vars] |
---|
427 | self.qt4_vars_debug=Utils.to_list(self.qt4_vars_debug) |
---|
428 | @conf |
---|
429 | def set_qt4_defines(self): |
---|
430 | if sys.platform!='win32': |
---|
431 | return |
---|
432 | for x in self.qt4_vars: |
---|
433 | y=x[2:].upper() |
---|
434 | self.env.append_unique('DEFINES_%s'%x.upper(),'QT_%s_LIB'%y) |
---|
435 | self.env.append_unique('DEFINES_%s_DEBUG'%x.upper(),'QT_%s_LIB'%y) |
---|
436 | def options(opt): |
---|
437 | opt.add_option('--want-rpath',action='store_true',default=False,dest='want_rpath',help='enable the rpath for qt libraries') |
---|
438 | opt.add_option('--header-ext',type='string',default='',help='header extension for moc files',dest='qt_header_ext') |
---|
439 | for i in'qtdir qtbin qtlibs'.split(): |
---|
440 | opt.add_option('--'+i,type='string',default='',dest=i) |
---|
441 | opt.add_option('--translate',action="store_true",help="collect translation strings",dest="trans_qt4",default=False) |
---|