infoDict.update(info)

plist = """<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

<plist version="1.0">

<dict>

"""

for key, value in infoDict.items() :

plist += "<key>" + key + "</key>\n"

if handlesXMPPURIs :

plist += """<key>CFBundleURLTypes</key>

<array>

<dict>

<key>CFBundleURLName</key>

<string>XMPP URL</string>

<key>CFBundleURLSchemes</key>

<array>

<string>xmpp</string>

</array>

</dict>

</array>\n"""

if sparklePublicDSAKey :

plist += "<key>SUPublicDSAKeyFile</key>"

env.Install(resourcesDir, sparklePublicDSAKey)

plist += """</dict>

</plist>

"""

env.WriteVal(bundleContentsDir + "/Info.plist", env.Value(plist))

for (target, resource) in resources.items() :

env.Install(os.path.join(resourcesDir, target), resource)

try:

if symlinks and os.path.islink(srcname):

linkto = os.readlink(srcname)

os.symlink(linkto, dstname)

elif os.path.isdir(srcname):

scons_copytree(srcname, dstname, symlinks)

else:

shutil.copy2(srcname, dstname)

# XXX What about devices, sockets etc.?

errors.append((srcname, dstname, str(why)))

# catch the CopytreeError from the recursive copytree so that we can

# continue with other files

errors.extend(err.args[0])

try:

shutil.copystat(src, dst)

except WindowsError:

# can't copy file access times on Windows

pass

errors.extend((src, dst, str(why)))

if errors:

def symlinkBuilderImpl(target, source, env):

lnk = target[0].abspath

src = source[0].abspath

lnkdir,lnkname = path.split(lnk)

srcdir,srcname = path.split(src)

scons_copytree(src, os.path.join(lnk, srcname), True)

p = subprocess.Popen(['windeployqt', '--release', '--dry-run', '--list', 'mapping', 'Swift.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=environ)

else:

p = subprocess.Popen(['windeployqt', '--debug', '--dry-run', '--list', 'mapping', 'Swift.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=environ)

if p:

stdout, stderr = p.communicate()

mappings = []

matches = re.findall(p, stdout)

for match in matches:

mappings.append(match)

return mappings

else:

return False

def createWindowsBundleManual(env, bundle, resources = {}, qtplugins = {}, qtlibs = [], qtversion = '4') :

if e.isdir() :

for subresource in env.Glob(str(e) + "/*") :

all_files += env.Install(os.path.join(bundle, dir, e.name), subresource)

else :

all_files += env.Install(os.path.join(bundle, dir), resource)

qtmappings = captureWinDeployQtMapping()

assert(qtmappings)

# handle core DLLs

for qtlib in qtlibs:

if qtlib.startswith("Qt5"):

(src_path, target_path) = next(((src_path, target_path) for (src_path, target_path) in qtmappings if qt_corelib_regex.match(src_path) and qt_corelib_regex.match(src_path).group(1) == qtlib), (None, None))

if src_path != None:

all_files += env.Install(bundle, src_path)

# handle core dependencies

for (src_path, target_path) in qtmappings:

if qt_corelib_regex.match(src_path) and not qt_corelib_regex.match(src_path).group(1).startswith("Qt5"):

all_files += env.Install(bundle, src_path)

# handle plugins

for (src_path, target_path) in qtmappings:

if qt_plugin_regex.match(src_path):

plugin_folder, filename = qt_plugin_regex.match(src_path).groups()

try:

if plugin_folder in ["audio"] or filename[1:] in qtplugins[plugin_folder]:

all_files += env.Install(os.path.join(bundle, plugin_folder), src_path)

except:

pass

return all_files

if which("windeployqt.exe"):

return createWindowsBundleWithWinDeployQt(env, bundle, resources, qtplugins, qtlibs, qtversion)

else:

return createWindowsBundleManual(env, bundle, resources, qtplugins, qtlibs, qtversion)

env.AddMethod(createWindowsBundle, "WindowsBundle")

def exists(env) :

return env["PLATFORM"] == "win32"

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#

__revision__ = "/home/scons/scons/branch.0/branch.96/baseline/src/engine/SCons/Tool/qt.py 0.96.92.D001 2006/04/10 23:13:27 knight"

import os.path

import re

import subprocess

import SCons.Action

import SCons.Builder

import SCons.Defaults

import SCons.Scanner

import SCons.Tool

import SCons.Util

import SCons.SConf

# Q_OBJECT detection

q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]')

# cxx and c comment 'eater'

#comment = re.compile(r'(//.*)|(/\*(([^*])|(\*[^/]))*\*/)')

# CW: something must be wrong with the regexp. See also bug #998222

# CURRENTLY THERE IS NO TEST CASE FOR THAT

# The following is kind of hacky to get builders working properly (FIXME)

objBuilderEnv = objBuilder.env

mocBuilderEnv = env.Moc4.env

env.Moc4.env = env

# make a deep copy for the result; MocH objects will be appended

out_sources = source[:]

for obj in source:

continue

if not obj.has_builder():

# binary obj file provided

if debug:

continue

cpp = obj.sources[0]

if not splitext(str(cpp))[1] in cxx_suffixes:

if debug:

# c or fortran source

continue

#cpp_contents = comment.sub('', cpp.get_contents())

try:

except: continue # may be an still not generated source

h=None

for h_ext in header_extensions:

# try to find the header file in the corresponding source

# directory

hname = splitext(cpp.name)[0] + h_ext

h = find_file(hname, (cpp.get_dir(),), env.File)

if h:

if debug:

#h_contents = comment.sub('', h.get_contents())

break

if not h and debug:

if h and q_object_search.search(h_contents):

# h file with the Q_OBJECT macro found -> add moc_cpp

moc_cpp = env.Moc4(h)

moc_o = objBuilder(moc_cpp)

out_sources.append(moc_o)

#moc_cpp.target_scanner = SCons.Defaults.CScan

if debug:

if cpp and q_object_search.search(cpp_contents):

# cpp file with Q_OBJECT macro found -> add moc

# (to be included in cpp)

moc = env.Moc4(cpp)

env.Ignore(moc, moc)

if debug:

#moc.source_scanner = SCons.Defaults.CScan

# restore the original env attributes (FIXME)

objBuilder.env = objBuilderEnv

env.Moc4.env = mocBuilderEnv

return (target, out_sources)

AutomocShared = _Automoc('SharedObject')

AutomocStatic = _Automoc('StaticObject')

def recursiveFiles(basepath, path) :

result = []

for item in os.listdir(os.path.join(basepath, path)) :

itemPath = os.path.join(path, item)

if os.path.isdir(os.path.join(basepath, itemPath)) :

result += recursiveFiles(basepath, itemPath)

else:

result.append(itemPath)

return result

includes = [included[1] for included in qrcinclude_re.findall(contents)]

qrcpath = os.path.dirname(node.path)

dirs = [included for included in includes if os.path.isdir(os.path.join(qrcpath,included))]

# dirs need to include files recursively

for dir in dirs :

includes.remove(dir)

includes+=recursiveFiles(qrcpath,dir)

return includes

qrcscanner = SCons.Scanner.Scanner(name = 'qrcfile',

source_scanner = qrcscanner,

src_suffix = '$QT4_QRCSUFFIX',

suffix = '$QT4_QRCCXXSUFFIX',

prefix = '$QT4_QRCCXXPREFIX',

single_source = True

)

env.Append( BUILDERS = { 'Qrc': qrcbuilder } )

# Interface builder

uic4builder = Builder(

src_suffix='$QT4_UISUFFIX',

suffix='$QT4_UICDECLSUFFIX',

prefix='$QT4_UICDECLPREFIX',

single_source = True

#TODO: Consider the uiscanner on new scons version

)

env['BUILDERS']['Uic4'] = uic4builder

# Metaobject builder

if is_String(v):

v = env.subst(v)

else:

v = str(v)

subs.append((k,v))

# write the file

try:

fd = open(target[0].get_path(), "wb")

raise SCons.Errors.UserError("Can't write target file %s" % target[0])

# separate lines by 'linesep' only if linesep is not empty

lsep = None

for s in source:

if lsep: fd.write(lsep)

lsep = linesep

fd.close()

def _strfunc(target, source, env):

return "Creating '%s'" % target[0]

def _convert_list_R(newlist, sources):

for elem in sources:

if is_Sequence(elem):

candle_builder = SCons.Builder.Builder(

action = '"$WIX_CANDLE" $WIX_CANDLE_OPTIONS ${SOURCES} -o ${TARGET}',

src_suffix = '.wxs',

suffix = '.wixobj',

source_scanner = candle_scanner,

src_builder = heat_builder)

light_builder = SCons.Builder.Builder(

src_suffix = '.wixobj',

src_builder = candle_builder)

env['BUILDERS']['WiX_Heat'] = heat_builder

env['BUILDERS']['WiX_Candle'] = candle_builder

env['BUILDERS']['WiX_Light'] = light_builder

def exists(env) :

return True