1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
|
#!/usr/bin/env python
#############################################################################
#
# Copyright (C) 2015 The Qt Company Ltd.
# Contact: http://www.qt.io/licensing/
#
# This file is part of the QtWebEngine module of the Qt Toolkit.
#
# $QT_BEGIN_LICENSE:LGPL$
# Commercial License Usage
# Licensees holding valid commercial Qt licenses may use this file in
# accordance with the commercial license agreement provided with the
# Software or, alternatively, in accordance with the terms contained in
# a written agreement between you and The Qt Company. For licensing terms
# and conditions see http://www.qt.io/terms-conditions. For further
# information use the contact form at http://www.qt.io/contact-us.
#
# GNU Lesser General Public License Usage
# Alternatively, this file may be used under the terms of the GNU Lesser
# General Public License version 2.1 as published by the Free Software
# Foundation and appearing in the file LICENSE.LGPL included in the
# packaging of this file. Please review the following information to
# ensure the GNU Lesser General Public License version 2.1 requirements
# will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
#
# As a special exception, The Qt Company gives you certain additional
# rights. These rights are described in The Qt Company LGPL Exception
# version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
#
# GNU General Public License Usage
# Alternatively, this file may be used under the terms of the GNU
# General Public License version 3.0 as published by the Free Software
# Foundation and appearing in the file LICENSE.GPL included in the
# packaging of this file. Please review the following information to
# ensure the GNU General Public License version 3.0 requirements will be
# met: http://www.gnu.org/copyleft/gpl.html.
#
#
# $QT_END_LICENSE$
#
#############################################################################
import argparse
import os
import re
import subprocess
import shutil
import sys
class Api:
QUICK = "webengine"
WIDGET = "webenginewidgets"
class Mode:
RELEASE = "release"
DEBUG = "debug"
def is_windows():
return os.name == "nt"
class ArgManager(object):
def __init__(self):
try:
self.__args = self.__parse()
except:
raise
self.build_dir = self.__args.build_dir
self.src_dir = self.__args.src_dir
self.example_filter = re.compile("%s-%s-%s" % (self.__api_filter(), self.__name_filter(), self.__mode_filter()))
self.list_examples = self.__args.list_examples
self.force = self.__args.force
self.verbose = self.__args.verbose
self.out_dir = self.__args.out_dir
def __parse(self):
ap = argparse.ArgumentParser(description="Deploy QtWebEngine example binaries on Windows.")
ap.add_argument("--release", dest="release", action="store_true", default=False,
help="Deploy release binaries only")
ap.add_argument("--debug", dest="debug", action="store_true", default=False,
help="Deploy debug binaries only")
ap.add_argument("--quick", dest="quick", action="store_true", default=False,
help="Deploy quick examples only")
ap.add_argument("--widget", dest="widget", action="store_true", default=False,
help="Deploy widget examples only")
ap.add_argument("-e", "--examples", dest="examples", nargs="+", action="store", default=".*",
help="Select example to deploy")
ap.add_argument("-l", "--list-examples", dest="list_examples", action="store_true", default=False,
help="List available examples")
ap.add_argument("-f", "--force", dest="force", action="store_true", default=False,
help="Force to overwrite existing files")
ap.add_argument("-v", "--verbose", dest="verbose", action="store_true", default=False,
help="Print windeployqt output")
ap.add_argument("--src-dir", dest="src_dir", action="store", type=self.__validate_src_dir, default=None,
help="Specify path of Qt sources. It is used for finding QML files of the example"
"and scanning for QML imports")
ap.add_argument("--build-dir", dest="build_dir", action="store", type=self.__validate_build_dir, default=None,
help="Specify path of the Qt binaries. It is used for finding qmake.exe, windeployqt.exe and"
"binaries of the examples. It is not necessary to set if qmake.exe is set in the path")
ap.add_argument("-o", "--out-dir", dest="out_dir", action="store", default=os.getcwd(),
help="Specify path for the deployed examples. If it is not set"
"current working directory is used")
return ap.parse_args()
def __validate_src_dir(self, src_dir):
if not os.path.exists(src_dir):
raise OSError("The specified Qt source directory does not exist: %s" % src_dir)
qtwebengine_dir = src_dir
# Accept Qt top level source directory too
if os.path.exists(os.path.join(src_dir, "qtwebengine")):
qtwebengine_dir = os.path.join(src_dir, "qtwebengine")
examples_dir = os.path.join(qtwebengine_dir, "examples")
must_have_paths = [
os.path.join(examples_dir, "examples.pro"),
os.path.join(examples_dir, Api.QUICK),
os.path.join(examples_dir, Api.WIDGET),
]
# Check whether src_dir is the proper QtWebEngine source directory
for p in must_have_paths:
if not os.path.exists(p):
raise OSError("The specified Qt source directory is invalid: %s" % src_dir)
return src_dir
def __validate_build_dir(self, build_dir):
if not os.path.exists(build_dir):
raise OSError("The specified Qt build directory does not exist: %s" % build_dir)
# Accept QtWebEngine build directory too
if os.path.basename(build_dir) == "qtwebengine":
build_dir = os.path.abspath(os.path.join(build_dir, ".."))
# Attempt to support custom build directories
if os.path.exists(os.path.join(build_dir, "bin", "qmake.exe")):
return build_dir
# Check existence of qtbase/bin/qmake.exe
qtbase_dir = os.path.join(build_dir, "qtbase")
if not os.path.exists(os.path.join(qtbase_dir, "bin", "qmake.exe")):
raise OSError("Program 'qmake.exe' cannot be found in the specified Qt build directory: %s" % build_dir)
return qtbase_dir
def __mode_filter(self):
if self.__args.release and not self.__args.debug:
return Mode.RELEASE
if not self.__args.release and self.__args.debug:
return Mode.DEBUG
return ".*"
def __api_filter(self):
if self.__args.quick and not self.__args.widget:
return Api.QUICK
if not self.__args.quick and self.__args.widget:
return Api.WIDGET
return ".*"
def __name_filter(self):
alt_list = []
examples = self.__args.examples
if not isinstance(examples, list):
examples = [examples]
for e in examples:
if "," in e:
alt_list.extend(e.split(","))
else:
alt_list.append(e)
return "|".join(alt_list)
class QtHelper(object):
def __init__(self, build_path=None, src_path=None):
self.__build_path = build_path if build_path is not None else ""
self.__src_path = src_path if src_path is not None else ""
self.__query = {}
self.__angle = None
self.__qmake = "qmake.exe"
self.__windeployqt = "windeployqt.exe"
if build_path:
self.__qmake = os.path.join(self.__build_path, "bin", self.__qmake)
self.__windeployqt = os.path.join(self.__build_path, "bin", self.__windeployqt)
try:
program = self.__qmake
subprocess.check_output([program, "-v"])
program = self.__windeployqt
subprocess.check_output([program, "-h"])
except OSError as e:
raise OSError("Program '%s' cannot be executed\n%s" % (program, e))
except:
raise
self.__query = self.get_query()
self.__build_path = self.get_build_path()
self.__src_path = self.get_src_path()
self.__angle = self.has_angle()
def get_query(self):
if self.__query:
return self.__query
qmake_output = subprocess.check_output([self.__qmake, "-query"]).split("\r\n")
query = {}
for line in qmake_output:
entry = line.split(":", 1)
if len(entry) != 2:
continue
query[entry[0]] = entry[1]
return query
def get_build_path(self):
return os.path.abspath(os.path.join(self.__query["QT_INSTALL_PREFIX"], ".."))
def get_src_path(self):
if self.__src_path:
return self.__src_path
if "QT_INSTALL_PREFIX/src" in self.__query:
return os.path.abspath(os.path.join(self.__query["QT_INSTALL_PREFIX/src"], ".."))
return self.__build_path
def get_windeployqt(self):
return self.__windeployqt
def has_angle(self):
if self.__angle:
return self.__angle
qconfig_pri_path = os.path.abspath(os.path.join(self.__query["QT_HOST_PREFIX"], "mkspecs", "qconfig.pri"))
print(qconfig_pri_path)
if not os.path.exists(qconfig_pri_path):
sys.stderr.write("Configuration file qconfig.pri cannot be found. Fallback to desktop GL mode.\n")
return False
qt_config = []
qconfig_pri = open(qconfig_pri_path, "r")
for line in qconfig_pri:
if line.startswith("QT_CONFIG +="):
qt_config = re.match("^QT_CONFIG \+= (.+)$", line).group(1).split(" ")
qconfig_pri.close()
return "angle" in qt_config
def collect_examples(self):
examples = []
for api in [Api.QUICK, Api.WIDGET]:
examples_root_dir_path = os.path.join(self.__build_path, "qtwebengine", "examples", api)
if not os.path.exists(examples_root_dir_path):
continue
for example in os.listdir(examples_root_dir_path):
example_dir_path = os.path.join(examples_root_dir_path, example)
if not os.path.exists(example_dir_path):
continue
example_src_path = os.path.join(self.__src_path, "qtwebengine", "examples", api, example)
for mode in [Mode.RELEASE, Mode.DEBUG]:
example_exe_path = os.path.join(example_dir_path, mode, example + ".exe")
if not os.path.exists(example_exe_path):
continue
examples.append(Example(example, api, mode, self.__angle, example_exe_path, example_src_path))
return examples
class Example(str):
def __new__(cls, example, api, mode, angle, exe_path, src_path):
obj = str.__new__(cls, "%s-%s-%s" % (api, example, mode))
return obj
def __init__(self, example, api, mode, angle, exe_path, src_path):
super(Example, self).__init__("%s-%s-%s" % (api, example, mode))
self.__name = example
self.__api = api
self.__mode = mode
self.__angle = angle
self.__exe_path = exe_path
self.__src_path = src_path
def get_deploy_params(self, mode, force):
deploy_params = []
deploy_params.append("--%s" % mode)
deploy_params.append("--compiler-runtime")
if self.__angle:
deploy_params.append("--angle")
if force:
deploy_params.append("--force")
if self.__api is Api.QUICK:
deploy_params.append("--qmldir")
deploy_params.append(self.__src_path)
if self.__mode is Mode.DEBUG:
deploy_params.append("--pdb")
return deploy_params
def name(self):
return self.__name
def deploy(self, qt, dest_path, force=False, verbose=False):
src_path = os.path.dirname(self.__exe_path)
for f in os.listdir(src_path):
shutil.copy(os.path.join(src_path, f), dest_path)
deploy_command = []
deploy_command.append(qt.get_windeployqt())
# Debug executables also need the release libraries
deploy_command.extend(self.get_deploy_params(Mode.RELEASE, force))
deploy_command.append(dest_path)
if verbose:
print("%s" % " ".join(deploy_command))
out = None if verbose else open(os.devnull, "w")
exit_code = subprocess.call(deploy_command, stdout=out)
if self.__mode is Mode.DEBUG and not exit_code:
param_release = "--%s" % Mode.RELEASE
param_debug = "--%s" % Mode.DEBUG
deploy_command = map(lambda item: param_debug if item == param_release else item, deploy_command)
if verbose:
print("%s" % " ".join(deploy_command))
exit_code = subprocess.call(deploy_command, stdout=out)
if out is not None:
out.close()
return exit_code
def main():
try:
args = ArgManager()
if not is_windows():
raise OSError("This script works on Windows only\n")
qt = QtHelper(args.build_dir, args.src_dir)
except Exception as e:
sys.stderr.write(str(e))
exit(1)
example_list = filter((lambda e: args.example_filter.match(e)), qt.collect_examples())
if not example_list:
print("There is no example that fulfills the requirements")
return
for example in example_list:
if args.list_examples:
print(example.name())
continue
print("Deploying %s ..." % example.name())
dest_path = os.path.abspath(os.path.join(args.out_dir, example.name()))
if not os.path.exists(dest_path):
os.makedirs(dest_path)
elif os.listdir(dest_path) and not args.force:
sys.stderr.write("Destination directory is not empty: %s\n" % dest_path)
sys.stderr.write("Skip deploying %s\n" % example.name())
continue
exit_code = example.deploy(qt, dest_path, args.force, args.verbose)
if exit_code:
sys.stderr.write("Deploy of example '%s' has failed: %s\n" % (example.name(), exit_code))
exit(exit_code)
print("Example '%s' has been successfully deployed at %s" % (example.name(), dest_path))
return
if __name__ == "__main__":
main()
|