|
|
@@ -0,0 +1,820 @@
|
|
|
1
|
+# Made from scons qt.py and (heavily) modified into kde.py
|
|
|
2
|
+# Thomas Nagy, 2004, 2005 <tnagy2^8@yahoo.fr>
|
|
|
3
|
+
|
|
|
4
|
+"""
|
|
|
5
|
+Run scons -h to display the associated help, or look below ..
|
|
|
6
|
+"""
|
|
|
7
|
+
|
|
|
8
|
+BOLD ="\033[1m"
|
|
|
9
|
+RED ="\033[91m"
|
|
|
10
|
+GREEN ="\033[92m"
|
|
|
11
|
+YELLOW ="\033[1m" #"\033[93m" # unreadable on white backgrounds
|
|
|
12
|
+CYAN ="\033[96m"
|
|
|
13
|
+NORMAL ="\033[0m"
|
|
|
14
|
+
|
|
|
15
|
+import os, re, types
|
|
|
16
|
+from SCons.Script.SConscript import SConsEnvironment
|
|
|
17
|
+
|
|
|
18
|
+# Returns the name of the shared object (i.e. libkdeui.so.4)
|
|
|
19
|
+# referenced by a libtool archive (like libkdeui.la)
|
|
|
20
|
+def getSOfromLA(lafile):
|
|
|
21
|
+ contents = open(lafile, 'r').read()
|
|
|
22
|
+ match = re.search("^dlname='([^']*)'$", contents, re.M)
|
|
|
23
|
+ if match:
|
|
|
24
|
+ return match.group(1)
|
|
|
25
|
+ return None
|
|
|
26
|
+
|
|
|
27
|
+# A helper, needed .. everywhere
|
|
|
28
|
+def KDEuse(lenv, flags):
|
|
|
29
|
+ if lenv['HELP']: lenv.Exit(0)
|
|
|
30
|
+
|
|
|
31
|
+ _flags=lenv.make_list(flags)
|
|
|
32
|
+ if 'environ' in _flags:
|
|
|
33
|
+ ## The scons developers advise against using this but it is mostly innocuous :)
|
|
|
34
|
+ lenv.AppendUnique( ENV = os.environ )
|
|
|
35
|
+ if not 'lang_qt' in _flags:
|
|
|
36
|
+ ## Use this define if you are using the kde translation scheme (.po files)
|
|
|
37
|
+ lenv.Append( CPPFLAGS = '-DQT_NO_TRANSLATION' )
|
|
|
38
|
+ if 'rpath' in _flags:
|
|
|
39
|
+ ## Use this to set rpath - this may cause trouble if folders are moved (chrpath)
|
|
|
40
|
+ lenv.Append( RPATH = [lenv['QTLIBPATH'], lenv['KDELIBPATH'], lenv['KDEMODULE']] )
|
|
|
41
|
+ kdelibpaths=[]
|
|
|
42
|
+ if lenv['KDELIBPATH'] == lenv['KDELIB']:
|
|
|
43
|
+ kdelibpaths = [lenv['KDELIB']]
|
|
|
44
|
+ else:
|
|
|
45
|
+ kdelibpaths = [lenv['KDELIBPATH'], lenv['KDELIB']]
|
|
|
46
|
+ lenv.Append( RPATH = [lenv['QTLIBPATH'], lenv['KDEMODULE']]+kdelibpaths )
|
|
|
47
|
+ if 'thread' in _flags:
|
|
|
48
|
+ ## Uncomment the following if you need threading support
|
|
|
49
|
+ lenv.KDEaddflags_cxx( ['-DQT_THREAD_SUPPORT', '-D_REENTRANT'] )
|
|
|
50
|
+ if 'fastmoc' in _flags:
|
|
|
51
|
+ lenv['BKSYS_FASTMOC']=1
|
|
|
52
|
+ if not 'nohelp' in _flags:
|
|
|
53
|
+ if lenv['_CONFIGURE'] or lenv['HELP']:
|
|
|
54
|
+ lenv.Exit(0)
|
|
|
55
|
+ if not 'nosmart' or not lenv.has_key('nosmart_includes'):
|
|
|
56
|
+ lenv.AppendUnique(CPPPATH=['#/'])
|
|
|
57
|
+ lst=[]
|
|
|
58
|
+ if lenv.has_key('USE_THE_FORCE_LUKE'):
|
|
|
59
|
+ lst=lenv['USE_THE_FORCE_LUKE']
|
|
|
60
|
+ lenv.__delitem__('USE_THE_FORCE_LUKE')
|
|
|
61
|
+ for v in lst:
|
|
|
62
|
+ v.execute()
|
|
|
63
|
+ else:
|
|
|
64
|
+ lenv['nosmart_includes']=1
|
|
|
65
|
+
|
|
|
66
|
+ ## To use kdDebug(intvalue)<<"some trace"<<endl; you need to define -DDEBUG
|
|
|
67
|
+ ## it is done in admin/generic.py automatically when you do scons configure debug=1
|
|
|
68
|
+
|
|
|
69
|
+def exists(env):
|
|
|
70
|
+ return True
|
|
|
71
|
+
|
|
|
72
|
+def detect_kde(env):
|
|
|
73
|
+ """ Detect the qt and kde environment using kde-config mostly """
|
|
|
74
|
+ def getpath(varname):
|
|
|
75
|
+ if not env.has_key('ARGS'): return None
|
|
|
76
|
+ v=env['ARGS'].get(varname, None)
|
|
|
77
|
+ if v: v=os.path.abspath(v)
|
|
|
78
|
+ return v
|
|
|
79
|
+
|
|
|
80
|
+ prefix = getpath('prefix')
|
|
|
81
|
+ execprefix = getpath('execprefix')
|
|
|
82
|
+ datadir = getpath('datadir')
|
|
|
83
|
+ libdir = getpath('libdir')
|
|
|
84
|
+ kdeincludes = getpath('kdeincludes')
|
|
|
85
|
+ kdelibs = getpath('kdelibs')
|
|
|
86
|
+ qtincludes = getpath('qtincludes')
|
|
|
87
|
+ qtlibs = getpath('qtlibs')
|
|
|
88
|
+ libsuffix = ''
|
|
|
89
|
+ if env.has_key('ARGS'): libsuffix=env['ARGS'].get('libsuffix', '')
|
|
|
90
|
+
|
|
|
91
|
+ if libdir: libdir = libdir+libsuffix
|
|
|
92
|
+
|
|
|
93
|
+ ## Detect the kde libraries
|
|
|
94
|
+ print "Checking for kde-config : ",
|
|
|
95
|
+ kde_config = os.popen("which kde-config 2>/dev/null").read().strip()
|
|
|
96
|
+ if len(kde_config):
|
|
|
97
|
+ print GREEN+"kde-config was found"+NORMAL
|
|
|
98
|
+ else:
|
|
|
99
|
+ print RED+"kde-config was NOT found in your PATH"+NORMAL
|
|
|
100
|
+ print "Make sure kde is installed properly"
|
|
|
101
|
+ print "(missing package kdebase-devel?)"
|
|
|
102
|
+ env.Exit(1)
|
|
|
103
|
+ env['KDEDIR'] = os.popen('kde-config -prefix').read().strip()
|
|
|
104
|
+
|
|
|
105
|
+ print "Checking for kde version : ",
|
|
|
106
|
+ kde_version = os.popen("kde-config --version|grep KDE").read().strip().split()[1]
|
|
|
107
|
+ if int(kde_version[0]) != 3 or int(kde_version[2]) < 2:
|
|
|
108
|
+ print RED+kde_version
|
|
|
109
|
+ print RED+"Your kde version can be too old"+NORMAL
|
|
|
110
|
+ print RED+"Please make sure kde is at least 3.2"+NORMAL
|
|
|
111
|
+ else:
|
|
|
112
|
+ print GREEN+kde_version+NORMAL
|
|
|
113
|
+
|
|
|
114
|
+ ## Detect the qt library
|
|
|
115
|
+ print "Checking for the qt library : ",
|
|
|
116
|
+ qtdir = os.getenv("QTDIR")
|
|
|
117
|
+ if qtdir:
|
|
|
118
|
+ print GREEN+"qt is in "+qtdir+NORMAL
|
|
|
119
|
+ else:
|
|
|
120
|
+ try:
|
|
|
121
|
+ tmplibdir = os.popen('kde-config --expandvars --install lib').read().strip()
|
|
|
122
|
+ libkdeuiSO = tmplibdir+'/'+getSOfromLA(tmplibdir+'/libkdeui.la')
|
|
|
123
|
+ m = re.search('(.*)/lib/libqt.*', os.popen('ldd ' + libkdeuiSO + ' | grep libqt').read().strip().split()[2])
|
|
|
124
|
+ except:
|
|
|
125
|
+ m=None
|
|
|
126
|
+ if m:
|
|
|
127
|
+ qtdir = m.group(1)
|
|
|
128
|
+ print YELLOW+"qt was found as "+m.group(1)+NORMAL
|
|
|
129
|
+ else:
|
|
|
130
|
+ print RED+"qt was not found"+NORMAL
|
|
|
131
|
+ print RED+"Please set QTDIR first (/usr/lib/qt3?) or try scons -h for more options"+NORMAL
|
|
|
132
|
+ env.Exit(1)
|
|
|
133
|
+ env['QTDIR'] = qtdir.strip()
|
|
|
134
|
+
|
|
|
135
|
+ ## Find the necessary programs uic and moc
|
|
|
136
|
+ print "Checking for uic : ",
|
|
|
137
|
+ uic = qtdir + "/bin/uic"
|
|
|
138
|
+ if os.path.isfile(uic):
|
|
|
139
|
+ print GREEN+"uic was found as "+uic+NORMAL
|
|
|
140
|
+ else:
|
|
|
141
|
+ uic = os.popen("which uic 2>/dev/null").read().strip()
|
|
|
142
|
+ if len(uic):
|
|
|
143
|
+ print YELLOW+"uic was found as "+uic+NORMAL
|
|
|
144
|
+ else:
|
|
|
145
|
+ uic = os.popen("which uic 2>/dev/null").read().strip()
|
|
|
146
|
+ if len(uic):
|
|
|
147
|
+ print YELLOW+"uic was found as "+uic+NORMAL
|
|
|
148
|
+ else:
|
|
|
149
|
+ print RED+"uic was not found - set QTDIR put it in your PATH ?"+NORMAL
|
|
|
150
|
+ env.Exit(1)
|
|
|
151
|
+ env['QT_UIC'] = uic
|
|
|
152
|
+
|
|
|
153
|
+ print "Checking for moc : ",
|
|
|
154
|
+ moc = qtdir + "/bin/moc"
|
|
|
155
|
+ if os.path.isfile(moc):
|
|
|
156
|
+ print GREEN + "moc was found as " + moc + NORMAL
|
|
|
157
|
+ else:
|
|
|
158
|
+ moc = os.popen("which moc 2>/dev/null").read().strip()
|
|
|
159
|
+ if len(moc):
|
|
|
160
|
+ print YELLOW + "moc was found as " + moc + NORMAL
|
|
|
161
|
+ elif os.path.isfile("/usr/share/qt3/bin/moc"):
|
|
|
162
|
+ moc = "/usr/share/qt3/bin/moc"
|
|
|
163
|
+ print YELLOW + "moc was found as " + moc + NORMAL
|
|
|
164
|
+ else:
|
|
|
165
|
+ print RED + "moc was not found - set QTDIR or put it in your PATH ?" + NORMAL
|
|
|
166
|
+ env.Exit(1)
|
|
|
167
|
+ env['QT_MOC'] = moc
|
|
|
168
|
+
|
|
|
169
|
+ ## check for the qt and kde includes
|
|
|
170
|
+ print "Checking for the qt includes : ",
|
|
|
171
|
+ if qtincludes and os.path.isfile(qtincludes + "/qlayout.h"):
|
|
|
172
|
+ # The user told where to look for and it looks valid
|
|
|
173
|
+ print GREEN + "ok " + qtincludes + NORMAL
|
|
|
174
|
+ else:
|
|
|
175
|
+ if os.path.isfile(qtdir + "/include/qlayout.h"):
|
|
|
176
|
+ # Automatic detection
|
|
|
177
|
+ print GREEN + "ok " + qtdir + "/include/ " + NORMAL
|
|
|
178
|
+ qtincludes = qtdir + "/include/"
|
|
|
179
|
+ elif os.path.isfile("/usr/include/qt3/qlayout.h"):
|
|
|
180
|
+ # Debian probably
|
|
|
181
|
+ print YELLOW + "the qt headers were found in /usr/include/qt3/ " + NORMAL
|
|
|
182
|
+ qtincludes = "/usr/include/qt3"
|
|
|
183
|
+ else:
|
|
|
184
|
+ print RED + "the qt headers were not found" + NORMAL
|
|
|
185
|
+ env.Exit(1)
|
|
|
186
|
+
|
|
|
187
|
+ print "Checking for the kde includes : ",
|
|
|
188
|
+ kdeprefix = os.popen("kde-config --prefix").read().strip()
|
|
|
189
|
+ if not kdeincludes:
|
|
|
190
|
+ kdeincludes = kdeprefix+"/include/"
|
|
|
191
|
+ if os.path.isfile(kdeincludes + "/klineedit.h"):
|
|
|
192
|
+ print GREEN + "ok " + kdeincludes + NORMAL
|
|
|
193
|
+ else:
|
|
|
194
|
+ if os.path.isfile(kdeprefix+"/include/kde/klineedit.h"):
|
|
|
195
|
+ # Debian, Fedora probably
|
|
|
196
|
+ print YELLOW + "the kde headers were found in " + kdeprefix + "/include/kde/" + NORMAL
|
|
|
197
|
+ kdeincludes = kdeprefix + "/include/kde/"
|
|
|
198
|
+ else:
|
|
|
199
|
+ print RED + "The kde includes were NOT found" + NORMAL
|
|
|
200
|
+ env.Exit(1)
|
|
|
201
|
+
|
|
|
202
|
+ # kde-config options
|
|
|
203
|
+ kdec_opts = {'KDEBIN' : 'exe', 'KDEAPPS' : 'apps',
|
|
|
204
|
+ 'KDEDATA' : 'data', 'KDEICONS' : 'icon',
|
|
|
205
|
+ 'KDEMODULE' : 'module', 'KDELOCALE' : 'locale',
|
|
|
206
|
+ 'KDEKCFG' : 'kcfg', 'KDEDOC' : 'html',
|
|
|
207
|
+ 'KDEMENU' : 'apps', 'KDEXDG' : 'xdgdata-apps',
|
|
|
208
|
+ 'KDEMIME' : 'mime', 'KDEXDGDIR' : 'xdgdata-dirs',
|
|
|
209
|
+ 'KDESERV' : 'services','KDESERVTYPES' : 'servicetypes',
|
|
|
210
|
+ 'KDEINCLUDE': 'include'
|
|
|
211
|
+ }
|
|
|
212
|
+
|
|
|
213
|
+ if prefix:
|
|
|
214
|
+ ## use the user-specified prefix
|
|
|
215
|
+ if not execprefix:
|
|
|
216
|
+ execprefix = prefix
|
|
|
217
|
+ if not datadir:
|
|
|
218
|
+ datadir=prefix+"/share"
|
|
|
219
|
+ if not libdir:
|
|
|
220
|
+ libdir=execprefix+"/lib"+libsuffix
|
|
|
221
|
+
|
|
|
222
|
+ subst_vars = lambda x: x.replace('${exec_prefix}', execprefix)\
|
|
|
223
|
+ .replace('${datadir}', datadir)\
|
|
|
224
|
+ .replace('${libdir}', libdir)
|
|
|
225
|
+ debian_fix = lambda x: x.replace('/usr/share', '${datadir}')
|
|
|
226
|
+ env['PREFIX'] = prefix
|
|
|
227
|
+ env['KDELIB'] = libdir
|
|
|
228
|
+ for (var, option) in kdec_opts.items():
|
|
|
229
|
+ dir = os.popen('kde-config --install ' + option).read().strip()
|
|
|
230
|
+ if var == 'KDEDOC': dir = debian_fix(dir)
|
|
|
231
|
+ env[var] = subst_vars(dir)
|
|
|
232
|
+
|
|
|
233
|
+ else:
|
|
|
234
|
+ env['PREFIX'] = os.popen('kde-config --expandvars --prefix').read().strip()
|
|
|
235
|
+ env['KDELIB'] = os.popen('kde-config --expandvars --install lib').read().strip()
|
|
|
236
|
+ for (var, option) in kdec_opts.items():
|
|
|
237
|
+ dir = os.popen('kde-config --expandvars --install ' + option).read().strip()
|
|
|
238
|
+ env[var] = dir
|
|
|
239
|
+
|
|
|
240
|
+ env['QTPLUGINS']=os.popen('kde-config --expandvars --install qtplugins').read().strip()
|
|
|
241
|
+
|
|
|
242
|
+ ## kde libs and includes
|
|
|
243
|
+ env['KDEINCLUDEPATH']=kdeincludes
|
|
|
244
|
+ if not kdelibs:
|
|
|
245
|
+ kdelibs=os.popen('kde-config --expandvars --install lib').read().strip()
|
|
|
246
|
+ env['KDELIBPATH']=kdelibs
|
|
|
247
|
+
|
|
|
248
|
+ ## qt libs and includes
|
|
|
249
|
+ env['QTINCLUDEPATH']=qtincludes
|
|
|
250
|
+ if not qtlibs:
|
|
|
251
|
+ qtlibs=qtdir+"/lib"+libsuffix
|
|
|
252
|
+ env['QTLIBPATH']=qtlibs
|
|
|
253
|
+
|
|
|
254
|
+def generate(env):
|
|
|
255
|
+ """"Set up the qt and kde environment and builders - the moc part is difficult to understand """
|
|
|
256
|
+
|
|
|
257
|
+ # attach this function immediately
|
|
|
258
|
+ SConsEnvironment.KDEuse = KDEuse
|
|
|
259
|
+ env.addHelpText("""
|
|
|
260
|
+b[*** KDE options ***
|
|
|
261
|
+-------------------]
|
|
|
262
|
+b[* prefix ]: base install path, ie: /usr/local
|
|
|
263
|
+b[* execprefix ]: install path for binaries, ie: /usr/bin
|
|
|
264
|
+b[* datadir ]: install path for the data, ie: /usr/local/share
|
|
|
265
|
+b[* libdir ]: install path for the libs, ie: /usr/lib
|
|
|
266
|
+b[* libsuffix ]: suffix of libraries on amd64, ie: 64, 32
|
|
|
267
|
+b[* kdeincludes]: path to the kde includes (/usr/include/kde on debian, ...)
|
|
|
268
|
+b[* qtincludes ]: path to the for qt includes (/usr/include/qt on debian, ...)
|
|
|
269
|
+b[* kdelibs ]: path to the kde libs, for linking the programs
|
|
|
270
|
+b[* qtlibs ]: path to the qt libs, for linking the programs
|
|
|
271
|
+
|
|
|
272
|
+ie: b[scons configure libdir=/usr/local/lib qtincludes=/usr/include/qt]
|
|
|
273
|
+""")
|
|
|
274
|
+
|
|
|
275
|
+ import SCons.Defaults
|
|
|
276
|
+ import SCons.Tool
|
|
|
277
|
+ import SCons.Util
|
|
|
278
|
+ import SCons.Node
|
|
|
279
|
+
|
|
|
280
|
+ CLVar = SCons.Util.CLVar
|
|
|
281
|
+ splitext = SCons.Util.splitext
|
|
|
282
|
+ Builder = SCons.Builder.Builder
|
|
|
283
|
+
|
|
|
284
|
+ # Detect the environment - replaces ./configure implicitely and store the options into a cache
|
|
|
285
|
+ from SCons.Options import Options
|
|
|
286
|
+ cachefile=env['CACHEDIR']+'kde.cache.py'
|
|
|
287
|
+ opts = Options(cachefile)
|
|
|
288
|
+ opts.AddOptions(
|
|
|
289
|
+ ('PREFIX', 'root of the program installation'),
|
|
|
290
|
+
|
|
|
291
|
+ ('QTDIR', ''),
|
|
|
292
|
+ ('QTLIBPATH', 'path to the qt libraries'),
|
|
|
293
|
+ ('QTINCLUDEPATH', 'path to the qt includes'),
|
|
|
294
|
+ ('QT_UIC', 'uic command'),
|
|
|
295
|
+ ('QT_MOC', 'moc command'),
|
|
|
296
|
+ ('QTPLUGINS', 'uic executable command'),
|
|
|
297
|
+
|
|
|
298
|
+ ('KDEDIR', ''),
|
|
|
299
|
+ ('KDELIBPATH', 'path to the installed kde libs'),
|
|
|
300
|
+ ('KDEINCLUDEPATH', 'path to the installed kde includes'),
|
|
|
301
|
+
|
|
|
302
|
+ ('KDEBIN', 'inst path of the kde binaries'),
|
|
|
303
|
+ ('KDEINCLUDE', 'inst path of the kde include files'),
|
|
|
304
|
+ ('KDELIB', 'inst path of the kde libraries'),
|
|
|
305
|
+ ('KDEMODULE', 'inst path of the parts and libs'),
|
|
|
306
|
+ ('KDEDATA', 'inst path of the application data'),
|
|
|
307
|
+ ('KDELOCALE', ''), ('KDEDOC', ''), ('KDEKCFG', ''),
|
|
|
308
|
+ ('KDEXDG', ''), ('KDEXDGDIR', ''), ('KDEMENU', ''),
|
|
|
309
|
+ ('KDEMIME', ''), ('KDEICONS', ''), ('KDESERV', ''),
|
|
|
310
|
+ ('KDESERVTYPES', ''), ('KDEAPPS', ''),
|
|
|
311
|
+ )
|
|
|
312
|
+ opts.Update(env)
|
|
|
313
|
+
|
|
|
314
|
+ def getInstDirForResType(lenv,restype):
|
|
|
315
|
+ if len(restype) == 0 or not lenv.has_key(restype):
|
|
|
316
|
+ print RED+"unknown resource type "+restype+NORMAL
|
|
|
317
|
+ lenv.Exit(1)
|
|
|
318
|
+ else:
|
|
|
319
|
+ instdir = lenv[restype]
|
|
|
320
|
+ basedir=lenv['DESTDIR']
|
|
|
321
|
+ ## support for installing into other folders when PREFIX is set - used by gnu stow
|
|
|
322
|
+ if basedir: instdir = instdir.replace(lenv['PREFIX'], basedir)
|
|
|
323
|
+ return instdir
|
|
|
324
|
+
|
|
|
325
|
+ # reconfigure when things are missing
|
|
|
326
|
+ if not env['HELP'] and (env['_CONFIGURE'] or not env.has_key('QTDIR') or not env.has_key('KDEDIR')):
|
|
|
327
|
+ detect_kde(env)
|
|
|
328
|
+ opts.Save(cachefile, env)
|
|
|
329
|
+
|
|
|
330
|
+ ## set default variables, one can override them in sconscript files
|
|
|
331
|
+ env.Append(CXXFLAGS = ['-I'+env['KDEINCLUDEPATH'], '-I'+env['QTINCLUDEPATH'] ],
|
|
|
332
|
+ LIBPATH = [env['KDELIBPATH'], env['QTLIBPATH'] ])
|
|
|
333
|
+
|
|
|
334
|
+ env['QT_AUTOSCAN'] = 1
|
|
|
335
|
+ env['QT_DEBUG'] = 0
|
|
|
336
|
+
|
|
|
337
|
+ env['MEINPROC'] = 'meinproc'
|
|
|
338
|
+ env['MSGFMT'] = 'msgfmt'
|
|
|
339
|
+
|
|
|
340
|
+ ## ui file processing
|
|
|
341
|
+ def uic_processing(target, source, env):
|
|
|
342
|
+ inc_kde ='#include <klocale.h>\n#include <kdialog.h>\n'
|
|
|
343
|
+ inc_moc ='#include "%s"\n' % target[2].name
|
|
|
344
|
+ comp_h ='$QT_UIC -L $QTPLUGINS -nounload -o %s %s' % (target[0].path, source[0].path)
|
|
|
345
|
+ comp_c ='$QT_UIC -L $QTPLUGINS -nounload -tr tr2i18n -impl %s %s' % (target[0].path, source[0].path)
|
|
|
346
|
+ comp_moc ='$QT_MOC -o %s %s' % (target[2].path, target[0].path)
|
|
|
347
|
+ if env.Execute(comp_h):
|
|
|
348
|
+ return ret
|
|
|
349
|
+ dest = open( target[1].path, "w" )
|
|
|
350
|
+ dest.write(inc_kde)
|
|
|
351
|
+ dest.close()
|
|
|
352
|
+ if env.Execute( comp_c+" >> "+target[1].path ):
|
|
|
353
|
+ return ret
|
|
|
354
|
+ dest = open( target[1].path, "a" )
|
|
|
355
|
+ dest.write(inc_moc)
|
|
|
356
|
+ dest.close()
|
|
|
357
|
+ ret = env.Execute( comp_moc )
|
|
|
358
|
+ return ret
|
|
|
359
|
+ def uicEmitter(target, source, env):
|
|
|
360
|
+ adjustixes = SCons.Util.adjustixes
|
|
|
361
|
+ bs = SCons.Util.splitext(str(source[0].name))[0]
|
|
|
362
|
+ bs = os.path.join(str(target[0].get_dir()),bs)
|
|
|
363
|
+ target.append(bs+'.cpp')
|
|
|
364
|
+ target.append(bs+'.moc')
|
|
|
365
|
+ return target, source
|
|
|
366
|
+ env['BUILDERS']['Uic']=Builder(action=uic_processing,emitter=uicEmitter,suffix='.h',src_suffix='.ui')
|
|
|
367
|
+
|
|
|
368
|
+ def kcfg_buildit(target, source, env):
|
|
|
369
|
+ comp='kconfig_compiler -d%s %s %s' % (str(source[0].get_dir()), source[1].path, source[0].path)
|
|
|
370
|
+ return env.Execute(comp)
|
|
|
371
|
+ def kcfg_stringit(target, source, env):
|
|
|
372
|
+ print "processing %s to get %s and %s" % (source[0].name, target[0].name, target[1].name)
|
|
|
373
|
+ def kcfgEmitter(target, source, env):
|
|
|
374
|
+ adjustixes = SCons.Util.adjustixes
|
|
|
375
|
+ bs = SCons.Util.splitext(str(source[0].name))[0]
|
|
|
376
|
+ bs = os.path.join(str(target[0].get_dir()),bs)
|
|
|
377
|
+ # .h file is already there
|
|
|
378
|
+ target.append(bs+'.cpp')
|
|
|
379
|
+
|
|
|
380
|
+ if not os.path.isfile(str(source[0])):
|
|
|
381
|
+ print RED+'kcfg file given '+str(source[0])+' does not exist !'+NORMAL
|
|
|
382
|
+ print os.popen('pwd').read()
|
|
|
383
|
+ return target, source
|
|
|
384
|
+ kfcgfilename=""
|
|
|
385
|
+ kcfgFileDeclRx = re.compile("^[fF]ile\s*=\s*(.+)\s*$")
|
|
|
386
|
+ for line in file(str(source[0]), "r").readlines():
|
|
|
387
|
+ match = kcfgFileDeclRx.match(line.strip())
|
|
|
388
|
+ if match:
|
|
|
389
|
+ kcfgfilename = match.group(1)
|
|
|
390
|
+ break
|
|
|
391
|
+ if not kcfgfilename:
|
|
|
392
|
+ print 'invalid kcfgc file'
|
|
|
393
|
+ return 0
|
|
|
394
|
+ source.append(str(source[0].get_dir())+'/'+kcfgfilename)
|
|
|
395
|
+ return target, source
|
|
|
396
|
+
|
|
|
397
|
+ env['BUILDERS']['Kcfg']=Builder(action=env.Action(kcfg_buildit, kcfg_stringit),
|
|
|
398
|
+ emitter=kcfgEmitter, suffix='.h', src_suffix='.kcfgc')
|
|
|
399
|
+
|
|
|
400
|
+ ## MOC processing
|
|
|
401
|
+ env['BUILDERS']['Moc']=Builder(action='$QT_MOC -o $TARGET $SOURCE',suffix='.moc',src_suffix='.h')
|
|
|
402
|
+ env['BUILDERS']['Moccpp']=Builder(action='$QT_MOC -o $TARGET $SOURCE',suffix='_moc.cpp',src_suffix='.h')
|
|
|
403
|
+
|
|
|
404
|
+ ## KIDL file
|
|
|
405
|
+ env['BUILDERS']['Kidl']=Builder(action= 'dcopidl $SOURCE > $TARGET || (rm -f $TARGET ; false)',
|
|
|
406
|
+ suffix='.kidl', src_suffix='.h')
|
|
|
407
|
+ ## DCOP
|
|
|
408
|
+ env['BUILDERS']['Dcop']=Builder(action='dcopidl2cpp --c++-suffix cpp --no-signals --no-stub $SOURCE',
|
|
|
409
|
+ suffix='_skel.cpp', src_suffix='.kidl')
|
|
|
410
|
+ ## STUB
|
|
|
411
|
+ env['BUILDERS']['Stub']=Builder(action= 'dcopidl2cpp --c++-suffix cpp --no-signals --no-skel $SOURCE',
|
|
|
412
|
+ suffix='_stub.cpp', src_suffix='.kidl')
|
|
|
413
|
+ ## DOCUMENTATION
|
|
|
414
|
+ env['BUILDERS']['Meinproc']=Builder(action='$MEINPROC --check --cache $TARGET $SOURCE',suffix='.cache.bz2')
|
|
|
415
|
+ ## TRANSLATIONS
|
|
|
416
|
+ env['BUILDERS']['Transfiles']=Builder(action='$MSGFMT $SOURCE -o $TARGET',suffix='.gmo',src_suffix='.po')
|
|
|
417
|
+
|
|
|
418
|
+ ## Handy helpers for building kde programs
|
|
|
419
|
+ ## You should not have to modify them ..
|
|
|
420
|
+
|
|
|
421
|
+ ui_ext = [".ui"]
|
|
|
422
|
+ kcfg_ext = ['.kcfgc']
|
|
|
423
|
+ header_ext = [".h", ".hxx", ".hpp", ".hh"]
|
|
|
424
|
+ cpp_ext = [".cpp", ".cxx", ".cc"]
|
|
|
425
|
+ skel_ext = [".skel", ".SKEL"]
|
|
|
426
|
+ stub_ext = [".stub", ".STUB"]
|
|
|
427
|
+
|
|
|
428
|
+ def KDEfiles(lenv, target, source):
|
|
|
429
|
+ """ Returns a list of files for scons (handles kde tricks like .skel)
|
|
|
430
|
+ It also makes custom checks against double includes like : ['file.ui', 'file.cpp']
|
|
|
431
|
+ (file.cpp is already included because of file.ui) """
|
|
|
432
|
+
|
|
|
433
|
+ q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]')
|
|
|
434
|
+ def scan_moc(bs, file_cpp):
|
|
|
435
|
+ addfile=None
|
|
|
436
|
+ # try to find the header
|
|
|
437
|
+ h_ext=''
|
|
|
438
|
+ for n_h_ext in header_ext:
|
|
|
439
|
+ if os.path.isfile(bs+n_h_ext):
|
|
|
440
|
+ h_ext=n_h_ext
|
|
|
441
|
+ break
|
|
|
442
|
+ # We have the header corresponding to the cpp file
|
|
|
443
|
+ if h_ext:
|
|
|
444
|
+ needscan=0
|
|
|
445
|
+ # User asked for fastmoc, try to avoid scanning
|
|
|
446
|
+ if env.has_key('BKSYS_FASTMOC'):
|
|
|
447
|
+ if os.path.isfile(bs+'.moc'):
|
|
|
448
|
+ lenv.Moc(bs+h_ext)
|
|
|
449
|
+ elif os.path.isfile(bs+'_moc.cpp'):
|
|
|
450
|
+ lenv.Moccpp(bs+h_ext)
|
|
|
451
|
+ addfile=bs+'_moc.cpp'
|
|
|
452
|
+ else:
|
|
|
453
|
+ #print "need scanning "+os.getcwd()+'/'+bs+".moc"
|
|
|
454
|
+ needscan=1
|
|
|
455
|
+ else:
|
|
|
456
|
+ needscan=1
|
|
|
457
|
+ # We cannot avoid scanning the files ...
|
|
|
458
|
+ if needscan:
|
|
|
459
|
+ file_h=bs+h_ext
|
|
|
460
|
+ h_contents = open(file_h, 'rb').read()
|
|
|
461
|
+ if q_object_search.search(h_contents):
|
|
|
462
|
+ # we know now there is Q_OBJECT macro
|
|
|
463
|
+ lst = bs.split('/')
|
|
|
464
|
+ val = lst[ len(lst) - 1 ]
|
|
|
465
|
+ reg = '\n\s*#include\s*("|<)'+val+'.moc("|>)'
|
|
|
466
|
+ meta_object_search = re.compile(reg)
|
|
|
467
|
+ cpp_contents = open(file_cpp, 'rb').read()
|
|
|
468
|
+ if meta_object_search.search(cpp_contents):
|
|
|
469
|
+ lenv.Moc(file_h)
|
|
|
470
|
+ else:
|
|
|
471
|
+ lenv.Moccpp(file_h)
|
|
|
472
|
+ addfile=bs+'_moc.cpp'
|
|
|
473
|
+ print "WARNING: moc.cpp for "+bs+h_ext+" consider using #include <file.moc> instead"
|
|
|
474
|
+ return addfile
|
|
|
475
|
+
|
|
|
476
|
+ src=[]
|
|
|
477
|
+ ui_files=[]
|
|
|
478
|
+ kcfg_files=[]
|
|
|
479
|
+ other_files=[]
|
|
|
480
|
+ kidl=[]
|
|
|
481
|
+
|
|
|
482
|
+ source_=lenv.make_list(source)
|
|
|
483
|
+
|
|
|
484
|
+ # For each file, check wether it is a dcop file or not, and create the complete list of sources
|
|
|
485
|
+ for file in source_:
|
|
|
486
|
+ bs = SCons.Util.splitext(file)[0]
|
|
|
487
|
+ ext = SCons.Util.splitext(file)[1]
|
|
|
488
|
+ if ext in skel_ext:
|
|
|
489
|
+ if not bs in kidl:
|
|
|
490
|
+ kidl.append(bs)
|
|
|
491
|
+ lenv.Dcop(bs+'.kidl')
|
|
|
492
|
+ src.append(bs+'_skel.cpp')
|
|
|
493
|
+ elif ext in stub_ext:
|
|
|
494
|
+ if not bs in kidl:
|
|
|
495
|
+ kidl.append(bs)
|
|
|
496
|
+ lenv.Stub(bs+'.kidl')
|
|
|
497
|
+ src.append(bs+'_stub.cpp')
|
|
|
498
|
+ elif ext == ".moch":
|
|
|
499
|
+ lenv.Moccpp(bs+'.h')
|
|
|
500
|
+ src.append(bs+'_moc.cpp')
|
|
|
501
|
+ elif ext in cpp_ext:
|
|
|
502
|
+ src.append(file)
|
|
|
503
|
+ if not env.has_key('NOMOCFILE'):
|
|
|
504
|
+ ret = scan_moc(bs, file)
|
|
|
505
|
+ if ret:
|
|
|
506
|
+ src.append( ret )
|
|
|
507
|
+ elif ext in ui_ext:
|
|
|
508
|
+ lenv.Uic(file)
|
|
|
509
|
+ src.append(bs+'.cpp')
|
|
|
510
|
+ elif ext in kcfg_ext:
|
|
|
511
|
+ lenv.Kcfg(file)
|
|
|
512
|
+ src.append(bs+'.cpp')
|
|
|
513
|
+ else:
|
|
|
514
|
+ src.append(file)
|
|
|
515
|
+
|
|
|
516
|
+ for base in kidl:
|
|
|
517
|
+ lenv.Kidl(base+'.h')
|
|
|
518
|
+
|
|
|
519
|
+ # Now check against typical newbie errors
|
|
|
520
|
+ for file in ui_files:
|
|
|
521
|
+ for ofile in other_files:
|
|
|
522
|
+ if ofile == file:
|
|
|
523
|
+ print RED+"WARNING: You have included "+file+".ui and another file of the same prefix"+NORMAL
|
|
|
524
|
+ print "Files generated by uic (file.h, file.cpp must not be included"
|
|
|
525
|
+ for file in kcfg_files:
|
|
|
526
|
+ for ofile in other_files:
|
|
|
527
|
+ if ofile == file:
|
|
|
528
|
+ print RED+"WARNING: You have included "+file+".kcfg and another file of the same prefix"+NORMAL
|
|
|
529
|
+ print "Files generated by kconfig_compiler (settings.h, settings.cpp) must not be included"
|
|
|
530
|
+ return src
|
|
|
531
|
+
|
|
|
532
|
+
|
|
|
533
|
+ """ In the future, these functions will contain the code that will dump the
|
|
|
534
|
+ configuration for re-use from an IDE """
|
|
|
535
|
+ import glob
|
|
|
536
|
+ def KDEinstall(lenv, restype, subdir, files):
|
|
|
537
|
+ if env.has_key('DUMPCONFIG'):
|
|
|
538
|
+ print "<install type=\"%s\" subdir=\"%s\">" % (restype, subdir)
|
|
|
539
|
+ for i in lenv.make_list(files):
|
|
|
540
|
+ print " <file name=\"%s\"/>" % i
|
|
|
541
|
+ print "</install>"
|
|
|
542
|
+ return
|
|
|
543
|
+
|
|
|
544
|
+ if not env['_INSTALL']:
|
|
|
545
|
+ return
|
|
|
546
|
+ dir = getInstDirForResType(lenv, restype)
|
|
|
547
|
+ install_list = lenv.bksys_install(dir+'/'+subdir, files, nodestdir=1)
|
|
|
548
|
+ return install_list
|
|
|
549
|
+
|
|
|
550
|
+ def KDEinstallas(lenv, restype, destfile, file):
|
|
|
551
|
+ if not env['_INSTALL']:
|
|
|
552
|
+ return
|
|
|
553
|
+ dir = getInstDirForResType(lenv, restype)
|
|
|
554
|
+ install_list = lenv.InstallAs(dir+'/'+destfile, file)
|
|
|
555
|
+ env.Alias('install', install_list)
|
|
|
556
|
+ return install_list
|
|
|
557
|
+
|
|
|
558
|
+ def KDEprogram(lenv, target, source,
|
|
|
559
|
+ includes='', localshlibs='', globallibs='', globalcxxflags=''):
|
|
|
560
|
+ """ Makes a kde program
|
|
|
561
|
+ The program is installed except if one sets env['NOAUTOINSTALL'] """
|
|
|
562
|
+ src = KDEfiles(lenv, target, source)
|
|
|
563
|
+ program_list = lenv.Program(target, src)
|
|
|
564
|
+
|
|
|
565
|
+ # we link the program against a shared library done locally, add the dependency
|
|
|
566
|
+ if not lenv.has_key('nosmart_includes'):
|
|
|
567
|
+ lenv.AppendUnique(CPPPATH=['./'])
|
|
|
568
|
+ if len(localshlibs)>0:
|
|
|
569
|
+ lst=lenv.make_list(localshlibs)
|
|
|
570
|
+ lenv.link_local_shlib(lst)
|
|
|
571
|
+ lenv.Depends( program_list, lst )
|
|
|
572
|
+
|
|
|
573
|
+ if len(includes)>0:
|
|
|
574
|
+ lenv.KDEaddpaths_includes(includes)
|
|
|
575
|
+ if len(globallibs)>0:
|
|
|
576
|
+ lenv.KDEaddlibs(globallibs)
|
|
|
577
|
+ if len(globalcxxflags)>0:
|
|
|
578
|
+ lenv.KDEaddflags_cxx(globalcxxflags)
|
|
|
579
|
+
|
|
|
580
|
+ if not lenv.has_key('NOAUTOINSTALL'):
|
|
|
581
|
+ KDEinstall(lenv, 'KDEBIN', '', target)
|
|
|
582
|
+ return program_list
|
|
|
583
|
+
|
|
|
584
|
+ def KDEshlib(lenv, target, source, kdelib=0, libprefix='lib',
|
|
|
585
|
+ includes='', localshlibs='', globallibs='', globalcxxflags='', vnum=''):
|
|
|
586
|
+ """ Makes a shared library for kde (.la file for klibloader)
|
|
|
587
|
+ The library is installed except if one sets env['NOAUTOINSTALL'] """
|
|
|
588
|
+ src = KDEfiles(lenv, target, source)
|
|
|
589
|
+
|
|
|
590
|
+ if not lenv.has_key('nosmart_includes'):
|
|
|
591
|
+ lenv.AppendUnique(CPPPATH=['./'])
|
|
|
592
|
+ # we link the program against a shared library done locally, add the dependency
|
|
|
593
|
+ lst=[]
|
|
|
594
|
+ if len(localshlibs)>0:
|
|
|
595
|
+ lst=lenv.make_list(localshlibs)
|
|
|
596
|
+ lenv.link_local_shlib(lst)
|
|
|
597
|
+ if len(includes)>0:
|
|
|
598
|
+ lenv.KDEaddpaths_includes(includes)
|
|
|
599
|
+ if len(globallibs)>0:
|
|
|
600
|
+ lenv.KDEaddlibs(globallibs)
|
|
|
601
|
+ if len(globalcxxflags)>0:
|
|
|
602
|
+ lenv.KDEaddflags_cxx(globalcxxflags)
|
|
|
603
|
+
|
|
|
604
|
+ restype = 'KDEMODULE'
|
|
|
605
|
+ if kdelib==1:
|
|
|
606
|
+ restype = 'KDELIB'
|
|
|
607
|
+
|
|
|
608
|
+ library_list = lenv.bksys_shlib(target, src, getInstDirForResType(lenv, restype), libprefix, vnum, nodestdir=1)
|
|
|
609
|
+ if len(lst)>0: lenv.Depends( library_list, lst )
|
|
|
610
|
+
|
|
|
611
|
+ return library_list
|
|
|
612
|
+
|
|
|
613
|
+ def KDEstaticlib(lenv, target, source):
|
|
|
614
|
+ """ Makes a static library for kde - in practice you should not use static libraries
|
|
|
615
|
+ 1. they take more memory than shared ones
|
|
|
616
|
+ 2. makefile.am needed it because of limitations
|
|
|
617
|
+ (cannot handle sources in separate folders - takes extra processing) """
|
|
|
618
|
+ if not lenv.has_key('nosmart_includes'):
|
|
|
619
|
+ lenv.AppendUnique(CPPPATH=['./'])
|
|
|
620
|
+ src = KDEfiles(lenv, target, source)
|
|
|
621
|
+ return lenv.StaticLibrary(target, src)
|
|
|
622
|
+ # do not install static libraries by default
|
|
|
623
|
+
|
|
|
624
|
+ def KDEaddflags_cxx(lenv, fl):
|
|
|
625
|
+ """ Compilation flags for C++ programs """
|
|
|
626
|
+ lenv.AppendUnique(CXXFLAGS = lenv.make_list(fl))
|
|
|
627
|
+
|
|
|
628
|
+ def KDEaddflags_c(lenv, fl):
|
|
|
629
|
+ """ Compilation flags for C programs """
|
|
|
630
|
+ lenv.AppendUnique(CFLAGS = lenv.make_list(fl))
|
|
|
631
|
+
|
|
|
632
|
+ def KDEaddflags_link(lenv, fl):
|
|
|
633
|
+ """ Add link flags - Use this if KDEaddlibs below is not enough """
|
|
|
634
|
+ lenv.PrependUnique(LINKFLAGS = lenv.make_list(fl))
|
|
|
635
|
+
|
|
|
636
|
+ def KDEaddlibs(lenv, libs):
|
|
|
637
|
+ """ Helper function """
|
|
|
638
|
+ lenv.AppendUnique(LIBS = lenv.make_list(libs))
|
|
|
639
|
+
|
|
|
640
|
+ def KDEaddpaths_includes(lenv, paths):
|
|
|
641
|
+ """ Add new include paths """
|
|
|
642
|
+ lenv.AppendUnique(CPPPATH = lenv.make_list(paths))
|
|
|
643
|
+
|
|
|
644
|
+ def KDEaddpaths_libs(lenv, paths):
|
|
|
645
|
+ """ Add paths to libraries """
|
|
|
646
|
+ lenv.PrependUnique(LIBPATH = lenv.make_list(paths))
|
|
|
647
|
+
|
|
|
648
|
+ def KDElang(lenv, folder, appname):
|
|
|
649
|
+ """ Process translations (.po files) in a po/ dir """
|
|
|
650
|
+ transfiles = glob.glob(folder+'/*.po')
|
|
|
651
|
+ for lang in transfiles:
|
|
|
652
|
+ result = lenv.Transfiles(lang)
|
|
|
653
|
+ country = SCons.Util.splitext(result[0].name)[0]
|
|
|
654
|
+ KDEinstallas(lenv, 'KDELOCALE', country+'/LC_MESSAGES/'+appname+'.mo', result)
|
|
|
655
|
+
|
|
|
656
|
+ def KDEicon(lenv, icname='*', path='./', restype='KDEICONS', subdir=''):
|
|
|
657
|
+ """Contributed by: "Andrey Golovizin" <grooz()gorodok()net>
|
|
|
658
|
+ modified by "Martin Ellis" <m.a.ellis()ncl()ac()uk>
|
|
|
659
|
+
|
|
|
660
|
+ Installs icons with filenames such as cr22-action-frame.png into
|
|
|
661
|
+ KDE icon hierachy with names like icons/crystalsvg/22x22/actions/frame.png.
|
|
|
662
|
+
|
|
|
663
|
+ Global KDE icons can be installed simply using env.KDEicon('name').
|
|
|
664
|
+ The second parameter, path, is optional, and specifies the icons
|
|
|
665
|
+ location in the source, relative to the SConscript file.
|
|
|
666
|
+
|
|
|
667
|
+ To install icons that need to go under an applications directory (to
|
|
|
668
|
+ avoid name conflicts, for example), use e.g.
|
|
|
669
|
+ env.KDEicon('name', './', 'KDEDATA', 'appname/icons')"""
|
|
|
670
|
+
|
|
|
671
|
+ if env.has_key('DUMPCONFIG'):
|
|
|
672
|
+ print "<icondirent subdir=\"%s\">" % (path+subdir)
|
|
|
673
|
+ return
|
|
|
674
|
+
|
|
|
675
|
+ type_dic = { 'action' : 'actions', 'app' : 'apps', 'device' :
|
|
|
676
|
+ 'devices', 'filesys' : 'filesystems', 'mime' : 'mimetypes' }
|
|
|
677
|
+ dir_dic = {
|
|
|
678
|
+ 'los' :'locolor/16x16',
|
|
|
679
|
+ 'lom' :'locolor/32x32',
|
|
|
680
|
+ 'him' :'hicolor/32x32',
|
|
|
681
|
+ 'hil' :'hicolor/48x48',
|
|
|
682
|
+ 'lo16' :'locolor/16x16',
|
|
|
683
|
+ 'lo22' :'locolor/22x22',
|
|
|
684
|
+ 'lo32' :'locolor/32x32',
|
|
|
685
|
+ 'hi16' :'hicolor/16x16',
|
|
|
686
|
+ 'hi22' :'hicolor/22x22',
|
|
|
687
|
+ 'hi32' :'hicolor/32x32',
|
|
|
688
|
+ 'hi48' :'hicolor/48x48',
|
|
|
689
|
+ 'hi64' :'hicolor/64x64',
|
|
|
690
|
+ 'hi128':'hicolor/128x128',
|
|
|
691
|
+ 'hisc' :'hicolor/scalable',
|
|
|
692
|
+ 'cr16' :'crystalsvg/16x16',
|
|
|
693
|
+ 'cr22' :'crystalsvg/22x22',
|
|
|
694
|
+ 'cr32' :'crystalsvg/32x32',
|
|
|
695
|
+ 'cr48' :'crystalsvg/48x48',
|
|
|
696
|
+ 'cr64' :'crystalsvg/64x64',
|
|
|
697
|
+ 'cr128':'crystalsvg/128x128',
|
|
|
698
|
+ 'crsc' :'crystalsvg/scalable'
|
|
|
699
|
+ }
|
|
|
700
|
+
|
|
|
701
|
+ iconfiles = []
|
|
|
702
|
+ for ext in "png xpm mng svg svgz".split():
|
|
|
703
|
+ files = glob.glob(path+'/'+'*-*-%s.%s' % (icname, ext))
|
|
|
704
|
+ iconfiles += files
|
|
|
705
|
+ for iconfile in iconfiles:
|
|
|
706
|
+ lst = iconfile.split('/')
|
|
|
707
|
+ filename = lst[ len(lst) - 1 ]
|
|
|
708
|
+ tmp = filename.split('-')
|
|
|
709
|
+ if len(tmp)!=3:
|
|
|
710
|
+ print RED+'WARNING: icon filename has unknown format: '+iconfile+NORMAL
|
|
|
711
|
+ continue
|
|
|
712
|
+ [icon_dir, icon_type, icon_filename]=tmp
|
|
|
713
|
+ try:
|
|
|
714
|
+ basedir=getInstDirForResType(lenv, restype)
|
|
|
715
|
+ destfile = '%s/%s/%s/%s/%s' % (basedir, subdir, dir_dic[icon_dir], type_dic[icon_type], icon_filename)
|
|
|
716
|
+ except KeyError:
|
|
|
717
|
+ print RED+'WARNING: unknown icon type: '+iconfile+NORMAL
|
|
|
718
|
+ continue
|
|
|
719
|
+ ## Do not use KDEinstallas here, as parsing from an ide will be necessary
|
|
|
720
|
+ if env['_INSTALL']:
|
|
|
721
|
+ env.Alias('install', env.InstallAs( destfile, iconfile ) )
|
|
|
722
|
+
|
|
|
723
|
+ ## This function uses env imported above
|
|
|
724
|
+ def docfolder(lenv, folder, lang, destination=""):
|
|
|
725
|
+ # folder is the folder to process
|
|
|
726
|
+ # lang is the language
|
|
|
727
|
+ # destination is the subdirectory in KDEDOC
|
|
|
728
|
+ docfiles = glob.glob(folder+"/???*.*") # file files that are at least 4 chars wide :)
|
|
|
729
|
+ # warn about errors
|
|
|
730
|
+ #if len(lang) != 2:
|
|
|
731
|
+ # print "error, lang must be a two-letter string, like 'en'"
|
|
|
732
|
+
|
|
|
733
|
+ # when the destination is not given, use the folder
|
|
|
734
|
+ if len(destination) == 0:
|
|
|
735
|
+ destination=folder
|
|
|
736
|
+ docbook_list = []
|
|
|
737
|
+ for file in docfiles:
|
|
|
738
|
+ # do not process folders
|
|
|
739
|
+ if not os.path.isfile(file):
|
|
|
740
|
+ continue
|
|
|
741
|
+ # do not process the cache file
|
|
|
742
|
+ if file == 'index.cache.bz2':
|
|
|
743
|
+ continue
|
|
|
744
|
+ # ignore invalid files (TODO??)
|
|
|
745
|
+ if len( SCons.Util.splitext( file ) ) <= 1 :
|
|
|
746
|
+ continue
|
|
|
747
|
+
|
|
|
748
|
+ ext = SCons.Util.splitext( file )[1]
|
|
|
749
|
+
|
|
|
750
|
+ # docbook files are processed by meinproc
|
|
|
751
|
+ if ext != '.docbook':
|
|
|
752
|
+ continue
|
|
|
753
|
+ docbook_list.append( file )
|
|
|
754
|
+ lenv.KDEinstall('KDEDOC', lang+'/'+destination, file)
|
|
|
755
|
+ # Now process the index.docbook files ..
|
|
|
756
|
+ if len(docbook_list) == 0:
|
|
|
757
|
+ return
|
|
|
758
|
+ if not os.path.isfile( folder+'/index.docbook' ):
|
|
|
759
|
+ print "Error, index.docbook was not found in "+folder+'/index.docbook'
|
|
|
760
|
+ return
|
|
|
761
|
+ ## Define this to 1 if you are writing documentation else to 0 :)
|
|
|
762
|
+ if env.has_key('i_am_a_documentation_writer'):
|
|
|
763
|
+ for file in docbook_list:
|
|
|
764
|
+ lenv.Depends( folder+'index.cache.bz2', file )
|
|
|
765
|
+ lenv.Meinproc( folder+'/index.cache.bz2', folder+'/index.docbook' )
|
|
|
766
|
+ lenv.KDEinstall( 'KDEDOC', lang+'/'+destination, folder+'/index.cache.bz2' )
|
|
|
767
|
+
|
|
|
768
|
+ #valid_targets = "program shlib kioslave staticlib".split()
|
|
|
769
|
+ import generic
|
|
|
770
|
+ class kobject(generic.genobj):
|
|
|
771
|
+ def __init__(self, val, senv=None):
|
|
|
772
|
+ if senv: generic.genobj.__init__(self, val, senv)
|
|
|
773
|
+ else: generic.genobj.__init__(self, val, env)
|
|
|
774
|
+ self.iskdelib=0
|
|
|
775
|
+ def it_is_a_kdelib(self): self.iskdelib=1
|
|
|
776
|
+ def execute(self):
|
|
|
777
|
+ self.lockchdir()
|
|
|
778
|
+ if self.orenv.has_key('DUMPCONFIG'):
|
|
|
779
|
+ print self.xml()
|
|
|
780
|
+ return
|
|
|
781
|
+ if (self.type=='shlib' or self.type=='kioslave'):
|
|
|
782
|
+ install_dir = 'KDEMODULE'
|
|
|
783
|
+ if self.iskdelib==1: install_dir = 'KDELIB'
|
|
|
784
|
+ self.instdir=getInstDirForResType(self.orenv, install_dir)
|
|
|
785
|
+ self.nodestdir=1
|
|
|
786
|
+ elif self.type=='program':
|
|
|
787
|
+ self.instdir=getInstDirForResType(self.orenv, 'KDEBIN')
|
|
|
788
|
+ self.nodestdir=1
|
|
|
789
|
+
|
|
|
790
|
+ self.src=KDEfiles(env, self.target, self.source)
|
|
|
791
|
+ generic.genobj.execute(self)
|
|
|
792
|
+ self.unlockchdir()
|
|
|
793
|
+
|
|
|
794
|
+ def xml(self):
|
|
|
795
|
+ ret= '<compile type="%s" chdir="%s" target="%s" cxxflags="%s" cflags="%s" includes="%s" linkflags="%s" libpaths="%s" libs="%s" vnum="%s" iskdelib="%s" libprefix="%s">\n' % (self.type, self.chdir, self.target, self.cxxflags, self.cflags, self.includes, self.linkflags, self.libpaths, self.libs, self.vnum, self.iskdelib, self.libprefix)
|
|
|
796
|
+ if self.source:
|
|
|
797
|
+ for i in self.orenv.make_list(self.source):
|
|
|
798
|
+ ret += ' <source file="%s"/>\n' % i
|
|
|
799
|
+ ret += "</compile>"
|
|
|
800
|
+ return ret
|
|
|
801
|
+
|
|
|
802
|
+ # Attach the functions to the environment so that SConscripts can use them
|
|
|
803
|
+ SConsEnvironment.KDEprogram = KDEprogram
|
|
|
804
|
+ SConsEnvironment.KDEshlib = KDEshlib
|
|
|
805
|
+ SConsEnvironment.KDEstaticlib = KDEstaticlib
|
|
|
806
|
+ SConsEnvironment.KDEinstall = KDEinstall
|
|
|
807
|
+ SConsEnvironment.KDEinstallas = KDEinstallas
|
|
|
808
|
+ SConsEnvironment.KDElang = KDElang
|
|
|
809
|
+ SConsEnvironment.KDEicon = KDEicon
|
|
|
810
|
+
|
|
|
811
|
+ SConsEnvironment.KDEaddflags_cxx = KDEaddflags_cxx
|
|
|
812
|
+ SConsEnvironment.KDEaddflags_c = KDEaddflags_c
|
|
|
813
|
+ SConsEnvironment.KDEaddflags_link = KDEaddflags_link
|
|
|
814
|
+ SConsEnvironment.KDEaddlibs = KDEaddlibs
|
|
|
815
|
+ SConsEnvironment.KDEaddpaths_includes = KDEaddpaths_includes
|
|
|
816
|
+ SConsEnvironment.KDEaddpaths_libs = KDEaddpaths_libs
|
|
|
817
|
+
|
|
|
818
|
+ SConsEnvironment.docfolder = docfolder
|
|
|
819
|
+ SConsEnvironment.kobject = kobject
|
|
|
820
|
+
|
tpearson
9 years ago
