tests/uqmlscene/main.cpp · unity8

git.iko.soy/unity8

on 356c4bb help sign in

unity8/tests/uqmlscene/main.cpp

564 lines 20 kB history raw

1/****************************************************************************

2**

4** Contact: http://www.qt-project.org/legal

5**

6** This file is part of the tools applications of the Qt Toolkit.

7**

8** $QT_BEGIN_LICENSE:LGPL$

9** Commercial License Usage

10** Licensees holding valid commercial Qt licenses may use this file in

11** accordance with the commercial license agreement provided with the

12** Software or, alternatively, in accordance with the terms contained in

13** a written agreement between you and Digia. For licensing terms and

14** conditions see http://qt.digia.com/licensing. For further information

15** use the contact form at http://qt.digia.com/contact-us.

16**

17** GNU Lesser General Public License Usage

18** Alternatively, this file may be used under the terms of the GNU Lesser

19** General Public License version 2.1 as published by the Free Software

20** Foundation and appearing in the file LICENSE.LGPL included in the

21** packaging of this file. Please review the following information to

22** ensure the GNU Lesser General Public License version 2.1 requirements

23** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

24**

25** In addition, as a special exception, Digia gives you certain additional

26** rights. These rights are described in the Digia Qt LGPL Exception

27** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

28**

29** GNU General Public License Usage

30** Alternatively, this file may be used under the terms of the GNU

31** General Public License version 3.0 as published by the Free Software

32** Foundation and appearing in the file LICENSE.GPL included in the

33** packaging of this file. Please review the following information to

34** ensure the GNU General Public License version 3.0 requirements will be

35** met: http://www.gnu.org/copyleft/gpl.html.

36**

37**

38** $QT_END_LICENSE$

39**

40****************************************************************************/

42#include <QtCore/qdebug.h>

43#include <QtCore/qabstractanimation.h>

44#include <QtCore/qdir.h>

45#include <QtCore/qmath.h>

46#include <QtCore/qdatetime.h>

48#include <QtGui/QGuiApplication>

50#include <QtQml/qqml.h>

51#include <QtQml/qqmlengine.h>

52#include <QtQml/qqmlcomponent.h>

53#include <QtQml/qqmlcontext.h>

55#include <QtQuick/qquickitem.h>

56#include <QtQuick/qquickview.h>

58#ifdef QT_WIDGETS_LIB

59#include <QtWidgets/QApplication>

60#include <QtWidgets/QFileDialog>

61#endif

63#include <QtCore/QTranslator>

64#include <QtCore/QLibraryInfo>

66#ifdef QML_RUNTIME_TESTING

67class RenderStatistics

68{

69public:

70 static void updateStats();

71 static void printTotalStats();

72private:

73 static QVector<qreal> timePerFrame;

74 static QVector<int> timesPerFrames;

75};

77QVector<qreal> RenderStatistics::timePerFrame;

78QVector<int> RenderStatistics::timesPerFrames;

80void RenderStatistics::updateStats()

81{

82 static QTime time;

83 static int frames;

84 static int lastTime;

86 if (frames == 0) {

87 time.start();

88 } else {

89 int elapsed = time.elapsed();

90 timesPerFrames.append(elapsed - lastTime);

91 lastTime = elapsed;

93 if (elapsed > 5000) {

94 qreal avgtime = elapsed / (qreal) frames;

95 qreal var = 0;

96 for (int i = 0; i < timesPerFrames.size(); ++i) {

97 qreal diff = timesPerFrames.at(i) - avgtime;

98 var += diff * diff;

99 }

100 var /= timesPerFrames.size();

101

102 qDebug("Average time per frame: %f ms (%i fps), std.dev: %f ms", avgtime, qRound(1000. / avgtime), qSqrt(var));

103

104 timePerFrame.append(avgtime);

105 timesPerFrames.clear();

106 time.start();

107 lastTime = 0;

108 frames = 0;

109 }

110 }

111 ++frames;

112}

113

114void RenderStatistics::printTotalStats()

115{

116 int count = timePerFrame.count();

117 if (count == 0)

118 return;

119

120 qreal minTime = 0;

121 qreal maxTime = 0;

122 qreal avg = 0;

123 for (int i = 0; i < count; ++i) {

124 minTime = minTime == 0 ? timePerFrame.at(i) : qMin(minTime, timePerFrame.at(i));

125 maxTime = qMax(maxTime, timePerFrame.at(i));

126 avg += timePerFrame.at(i);

127 }

128 avg /= count;

129

130 qDebug(" ");

131 qDebug("----- Statistics -----");

132 qDebug("Average time per frame: %f ms (%i fps)", avg, qRound(1000. / avg));

133 qDebug("Best time per frame: %f ms (%i fps)", minTime, int(1000 / minTime));

134 qDebug("Worst time per frame: %f ms (%i fps)", maxTime, int(1000 / maxTime));

135 qDebug("----------------------");

136 qDebug(" ");

137}

138#endif

139

140struct Options

141{

142 Options()

143 : originalQml(false)

144 , originalQmlRaster(false)

145 , maximized(false)

146 , fullscreen(false)

147 , transparent(false)

148 , clip(false)

149 , versionDetection(true)

150 , quitImmediately(false)

151 , resizeViewToRootItem(false)

152 , multisample(false)

153 {

154 }

155

156 QUrl file;

157 bool originalQml;

158 bool originalQmlRaster;

159 bool maximized;

160 bool fullscreen;

161 bool transparent;

162 bool clip;

163 bool versionDetection;

164 bool quitImmediately;

165 bool resizeViewToRootItem;

166 bool multisample;

167 QString translationFile;

168};

169

170#if defined(QMLSCENE_BUNDLE)

171QFileInfoList findQmlFiles(const QString &dirName)

172{

173 QDir dir(dirName);

174

175 QFileInfoList ret;

176 if (dir.exists()) {

177 QFileInfoList fileInfos = dir.entryInfoList(QStringList() << "*.qml",

178 QDir::Files | QDir::AllDirs | QDir::NoDotAndDotDot);

179

180 Q_FOREACH (QFileInfo fileInfo, fileInfos) {

181 if (fileInfo.isDir())

182 ret += findQmlFiles(fileInfo.filePath());

183 else if (fileInfo.fileName().length() > 0 && fileInfo.fileName().at(0).isLower())

184 ret.append(fileInfo);

185 }

186 }

187

188 return ret;

189}

190

191static int displayOptionsDialog(Options *options)

192{

193 QDialog dialog;

194

195 QFormLayout *layout = new QFormLayout(&dialog);

196

197 QComboBox *qmlFileComboBox = new QComboBox(&dialog);

198 QFileInfoList fileInfos = findQmlFiles(":/bundle") + findQmlFiles("./qmlscene-resources");

199

200 Q_FOREACH (QFileInfo fileInfo, fileInfos)

201 qmlFileComboBox->addItem(fileInfo.dir().dirName() + "/" + fileInfo.fileName(), QVariant::fromValue(fileInfo));

202

203 QCheckBox *originalCheckBox = new QCheckBox(&dialog);

204 originalCheckBox->setText("Use original QML viewer");

205 originalCheckBox->setChecked(options->originalQml);

206

207 QCheckBox *fullscreenCheckBox = new QCheckBox(&dialog);

208 fullscreenCheckBox->setText("Start fullscreen");

209 fullscreenCheckBox->setChecked(options->fullscreen);

210

211 QCheckBox *maximizedCheckBox = new QCheckBox(&dialog);

212 maximizedCheckBox->setText("Start maximized");

213 maximizedCheckBox->setChecked(options->maximized);

214

215 QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,

216 Qt::Horizontal,

217 &dialog);

218 QObject::connect(buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);

219 QObject::connect(buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);

220

221 layout->addRow("Qml file:", qmlFileComboBox);

222 layout->addWidget(originalCheckBox);

223 layout->addWidget(maximizedCheckBox);

224 layout->addWidget(fullscreenCheckBox);

225 layout->addWidget(buttonBox);

226

227 int result = dialog.exec();

228 if (result == QDialog::Accepted) {

229 QVariant variant = qmlFileComboBox->itemData(qmlFileComboBox->currentIndex());

230 QFileInfo fileInfo = variant.value<QFileInfo>();

231

232 if (fileInfo.canonicalFilePath().startsWith(":"))

233 options->file = QUrl("qrc" + fileInfo.canonicalFilePath());

234 else

235 options->file = QUrl::fromLocalFile(fileInfo.canonicalFilePath());

236 options->originalQml = originalCheckBox->isChecked();

237 options->maximized = maximizedCheckBox->isChecked();

238 options->fullscreen = fullscreenCheckBox->isChecked();

239 }

240 return result;

241}

242#endif

243

244static bool checkVersion(const QUrl &url)

245{

246 if (!qgetenv("QMLSCENE_IMPORT_NAME").isEmpty())

247 qWarning("QMLSCENE_IMPORT_NAME is no longer supported.");

248

249 QString fileName = url.toLocalFile();

250 if (fileName.isEmpty()) {

251 qWarning("qmlscene: filename required.");

252 return false;

253 }

254

255 QFile f(fileName);

256 if (!f.open(QFile::ReadOnly | QFile::Text)) {

257 qWarning("qmlscene: failed to check version of file '%s', could not open...",

258 qPrintable(fileName));

259 return false;

260 }

261

262 QRegExp quick1("^\\s*import +QtQuick +1\\.\\w*");

263 QRegExp qt47("^\\s*import +Qt +4\\.7");

264

265 QTextStream stream(&f);

266 bool codeFound= false;

267 while (!codeFound) {

268 QString line = stream.readLine();

269 if (line.contains("{")) {

270 codeFound = true;

271 } else {

272 QString import;

273 if (quick1.indexIn(line) >= 0)

274 import = quick1.cap(0).trimmed();

275 else if (qt47.indexIn(line) >= 0)

276 import = qt47.cap(0).trimmed();

277

278 if (!import.isNull()) {

279 qWarning("qmlscene: '%s' is no longer supported.\n"

280 "Use qmlviewer to load file '%s'.",

281 qPrintable(import),

282 qPrintable(fileName));

283 return false;

284 }

285 }

286 }

287

288 return true;

289}

290

291static void displayFileDialog(Options *options)

292{

293#if defined(QT_WIDGETS_LIB) && !defined(QT_NO_FILEDIALOG)

294 QString fileName = QFileDialog::getOpenFileName(0, "Open QML file", QString(), "QML Files (*.qml)");

295 if (!fileName.isEmpty()) {

296 QFileInfo fi(fileName);

297 options->file = QUrl::fromLocalFile(fi.canonicalFilePath());

298 }

299#else

300 Q_UNUSED(options);

301 qWarning("No filename specified...");

302#endif

303}

304

305#ifndef QT_NO_TRANSLATION

306static void loadTranslationFile(QTranslator &translator, const QString& directory)

307{

308 translator.load(QLatin1String("qml_" )+QLocale::system().name(), directory + QLatin1String("/i18n"));

309 QCoreApplication::installTranslator(&translator);

310}

311#endif

312

313static void loadDummyDataFiles(QQmlEngine &engine, const QString& directory)

314{

315 QDir dir(directory+"/dummydata", "*.qml");

316 QStringList list = dir.entryList();

317 for (int i = 0; i < list.size(); ++i) {

318 QString qml = list.at(i);

319 QFile f(dir.filePath(qml));

320 f.open(QIODevice::ReadOnly);

321 QByteArray data = f.readAll();

322 QQmlComponent comp(&engine);

323 comp.setData(data, QUrl());

324 QObject *dummyData = comp.create();

325

326 if(comp.isError()) {

327 QList<QQmlError> errors = comp.errors();

328 Q_FOREACH (const QQmlError &error, errors)

329 qWarning() << error;

330 }

331

332 if (dummyData) {

333 qWarning() << "Loaded dummy data:" << dir.filePath(qml);

334 qml.truncate(qml.length()-4);

335 engine.rootContext()->setContextProperty(qml, dummyData);

336 dummyData->setParent(&engine);

337 }

338 }

339}

340

341class DummyTestRootObject : public QObject

342{

343 Q_OBJECT

344 Q_PROPERTY(bool windowShown READ windowShown NOTIFY windowShownChanged)

345

346public:

347 DummyTestRootObject(QObject *o) : QObject(o) {}

348

349 bool windowShown() const { return false; }

350

351Q_SIGNALS:

352 void windowShownChanged();

353};

354

355static QObject *s_testRootObject = nullptr;

356static QObject *testRootObject(QQmlEngine *engine, QJSEngine *jsEngine)

357{

358 Q_UNUSED(jsEngine);

359 if (!s_testRootObject) {

360 s_testRootObject = new DummyTestRootObject(engine);

361 }

362 return s_testRootObject;

363}

364

365static void usage()

366{

367 qWarning("Usage: uqmlscene [options] <filename>");

368 qWarning(" ");

369 qWarning(" Options:");

370 qWarning(" --maximized ............................... Run maximized");

371 qWarning(" --fullscreen .............................. Run fullscreen");

372 qWarning(" --transparent ............................. Make the window transparent");

373 qWarning(" --multisample ............................. Enable multisampling (OpenGL anti-aliasing)");

374 qWarning(" --no-version-detection .................... Do not try to detect the version of the .qml file");

375 qWarning(" --resize-to-root .......................... Resize the window to the size of the root item");

376 qWarning(" --quit .................................... Quit immediately after starting");

377 qWarning(" -I <path> ................................. Add <path> to the list of import paths");

378 qWarning(" -B <name> <file> .......................... Add a named bundle");

379 qWarning(" -translation <translationfile> ............ Set the language to run in");

380

381 qWarning(" ");

382 exit(1);

383}

384

385int main(int argc, char ** argv)

386{

387 Options options;

388

389 QStringList imports;

390 QList<QPair<QString, QString> > bundles;

391 for (int i = 1; i < argc; ++i) {

392 if (*argv[i] != '-' && QFileInfo(QFile::decodeName(argv[i])).exists()) {

393 options.file = QUrl::fromLocalFile(argv[i]);

394 } else {

395 const QString lowerArgument = QString::fromLatin1(argv[i]).toLower();

396 if (lowerArgument == QLatin1String("--maximized"))

397 options.maximized = true;

398 else if (lowerArgument == QLatin1String("--fullscreen"))

399 options.fullscreen = true;

400 else if (lowerArgument == QLatin1String("--transparent"))

401 options.transparent = true;

402 else if (lowerArgument == QLatin1String("--clip"))

403 options.clip = true;

404 else if (lowerArgument == QLatin1String("--no-version-detection"))

405 options.versionDetection = false;

406 else if (lowerArgument == QLatin1String("--quit"))

407 options.quitImmediately = true;

408 else if (lowerArgument == QLatin1String("-translation"))

409 options.translationFile = QLatin1String(argv[++i]);

410 else if (lowerArgument == QLatin1String("--resize-to-root"))

411 options.resizeViewToRootItem = true;

412 else if (lowerArgument == QLatin1String("--multisample"))

413 options.multisample = true;

414 else if (lowerArgument == QLatin1String("-i") && i + 1 < argc)

415 imports.append(QString::fromLatin1(argv[++i]));

416 else if (lowerArgument == QLatin1String("-b") && i + 2 < argc) {

417 QString name = QString::fromLatin1(argv[++i]);

418 QString file = QString::fromLatin1(argv[++i]);

419 bundles.append(qMakePair(name, file));

420 } else if (lowerArgument == QLatin1String("--help")

421 || lowerArgument == QLatin1String("-help")

422 || lowerArgument == QLatin1String("--h")

423 || lowerArgument == QLatin1String("-h"))

424 usage();

425 }

426 }

427

428#ifdef QT_WIDGETS_LIB

429 QApplication app(argc, argv);

430#else

431 QGuiApplication app(argc, argv);

432#endif

433 app.setApplicationName("Unity8 QtQmlViewer");

434 app.setOrganizationName("Qt Project");

435 app.setOrganizationDomain("qt-project.org");

436

437#ifndef QT_NO_TRANSLATION

438 QTranslator translator;

439 QTranslator qtTranslator;

440 QString sysLocale = QLocale::system().name();

441 if (translator.load(QLatin1String("qmlscene_") + sysLocale, QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {

442 app.installTranslator(&translator);

443 if (qtTranslator.load(QLatin1String("qt_") + sysLocale, QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {

444 app.installTranslator(&qtTranslator);

445 } else {

446 app.removeTranslator(&translator);

447 }

448 }

449

450 QTranslator qmlTranslator;

451 if (!options.translationFile.isEmpty()) {

452 if (qmlTranslator.load(options.translationFile)) {

453 app.installTranslator(&qmlTranslator);

454 } else {

455 qWarning() << "Could not load the translation file" << options.translationFile;

456 }

457 }

458#endif

459

460 if (options.file.isEmpty())

461#if defined(QMLSCENE_BUNDLE)

462 displayOptionsDialog(&options);

463#else

464 displayFileDialog(&options);

465#endif

466

467 int exitCode = 0;

468

469 if (!options.file.isEmpty()) {

470 if (!options.versionDetection || checkVersion(options.file)) {

471#ifndef QT_NO_TRANSLATION

472 QTranslator translator;

473#endif

474

475 // TODO: as soon as the engine construction completes, the debug service is

476 // listening for connections. But actually we aren't ready to debug anything.

477 QQmlEngine engine;

478 QQmlComponent *component = new QQmlComponent(&engine);

479 for (int i = 0; i < imports.size(); ++i)

480 engine.addImportPath(imports.at(i));

481 for (int i = 0; i < bundles.size(); ++i)

482 engine.addNamedBundle(bundles.at(i).first, bundles.at(i).second);

483 if (options.file.isLocalFile()) {

484 QFileInfo fi(options.file.toLocalFile());

485#ifndef QT_NO_TRANSLATION

486 loadTranslationFile(translator, fi.path());

487#endif

488 loadDummyDataFiles(engine, fi.path());

489 }

490 QObject::connect(&engine, &QQmlEngine::quit, QCoreApplication::instance(), &QCoreApplication::quit);

491

492 qmlRegisterSingletonType<QObject>("Qt.test.qtestroot", 1, 0, "QTestRootObject", testRootObject);

493

494 component->loadUrl(options.file);

495 if ( !component->isReady() ) {

496 qWarning("%s", qPrintable(component->errorString()));

497 return -1;

498 }

499

500 QObject *topLevel = component->create();

501 QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);

502 QQuickView* qxView = 0;

503 if (!window) {

504 QQuickItem *contentItem = qobject_cast<QQuickItem *>(topLevel);

505 if (contentItem) {

506 qxView = new QQuickView(&engine, nullptr);

507 window = qxView;

508 // Set window default properties; the qml can still override them

509 QString oname = contentItem->objectName();

510 window->setTitle(oname.isEmpty() ? QString::fromLatin1("qmlscene") : QString::fromLatin1("qmlscene: ") + oname);

512 if (options.resizeViewToRootItem)

513 qxView->setResizeMode(QQuickView::SizeViewToRootObject);

514 else

515 qxView->setResizeMode(QQuickView::SizeRootObjectToView);

516 qxView->setContent(options.file, component, contentItem);

517 }

518 }

519

520 if (window) {

521 QSurfaceFormat surfaceFormat = window->requestedFormat();

522 if (options.multisample)

523 surfaceFormat.setSamples(16);

524 if (options.transparent) {

525 surfaceFormat.setAlphaBufferSize(8);

526 window->setClearBeforeRendering(true);

527 window->setColor(QColor(Qt::transparent));

528 window->setFlags(Qt::FramelessWindowHint);

529 }

530 window->setFormat(surfaceFormat);

531

532 if (options.fullscreen)

533 window->showFullScreen();

534 else if (options.maximized)

535 window->showMaximized();

536 else

537 window->show();

538 }

539

540 if (options.quitImmediately)

541 QMetaObject::invokeMethod(QCoreApplication::instance(), "quit", Qt::QueuedConnection);

542

543 // Now would be a good time to inform the debug service to start listening.

544

545 exitCode = app.exec();

546

547#ifdef QML_RUNTIME_TESTING

548 RenderStatistics::printTotalStats();

549#endif

550 // Ready to exit. If we created qxView, it owns the component;

551 // otherwise, the ownership is still right here. Nobody deletes the engine

552 // (which is odd since the container constructor takes the engine pointer),

553 // but it's stack-allocated anyway.

554 if (qxView)

555 delete qxView;

556 else

557 delete component;

558 }

559 }

560

561 return exitCode;

562}

563

564#include "main.moc"