qtversionmanager.cpp 62.4 KB
Newer Older
1
/**************************************************************************
con's avatar
con committed
2
3
4
**
** This file is part of Qt Creator
**
hjk's avatar
hjk committed
5
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
con's avatar
con committed
6
**
7
** Contact: Nokia Corporation (qt-info@nokia.com)
con's avatar
con committed
8
**
9
** Commercial Usage
10
**
11
12
13
14
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
15
**
16
** GNU Lesser General Public License Usage
17
**
18
19
20
21
22
23
** 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.
24
**
25
** If you are unsure which license is appropriate for your use, please
hjk's avatar
hjk committed
26
** contact the sales department at http://qt.nokia.com/contact.
con's avatar
con committed
27
**
28
**************************************************************************/
hjk's avatar
hjk committed
29

con's avatar
con committed
30
#include "qtversionmanager.h"
hjk's avatar
hjk committed
31

32
#include "qt4projectmanagerconstants.h"
Tobias Hunger's avatar
Tobias Hunger committed
33
#include "qt4target.h"
34
#include "profilereader.h"
con's avatar
con committed
35

ck's avatar
ck committed
36
#include "qt-maemo/maemomanager.h"
37
#include "qt-s60/s60manager.h"
38
#include "qt-s60/s60projectchecker.h"
39

40
#include "qmlobservertool.h"
41
#include "qmldumptool.h"
42
43
#include <projectexplorer/debugginghelper.h>
#include <projectexplorer/projectexplorer.h>
44
#include <projectexplorer/projectexplorerconstants.h>
45
#include <projectexplorer/cesdkhandler.h>
46
#include <utils/synchronousprocess.h>
47
#include <coreplugin/coreconstants.h>
48
#include <coreplugin/icore.h>
kh1's avatar
kh1 committed
49
#include <coreplugin/helpmanager.h>
50
#include <extensionsystem/pluginmanager.h>
hjk's avatar
hjk committed
51
#include <utils/qtcassert.h>
52
#include <utils/qtcprocess.h>
53
54
55
#ifdef Q_OS_WIN
#    include <utils/winutils.h>
#endif
con's avatar
con committed
56

57
#include <QtCore/QFile>
hjk's avatar
hjk committed
58
#include <QtCore/QProcess>
con's avatar
con committed
59
60
#include <QtCore/QSettings>
#include <QtCore/QTime>
61
#include <QtCore/QTimer>
62
#include <QtCore/QTextStream>
63
#include <QtCore/QDir>
64
65
#include <QtGui/QApplication>
#include <QtGui/QDesktopServices>
con's avatar
con committed
66

67
68
69
70
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;

using ProjectExplorer::DebuggingHelperLibrary;
con's avatar
con committed
71
72
73

static const char *QtVersionsSectionName = "QtVersions";
static const char *newQtVersionsKey = "NewQtVersions";
74
static const char *PATH_AUTODETECTION_SOURCE = "PATH";
con's avatar
con committed
75

76
77
enum { debug = 0 };

78
QtVersionManager *QtVersionManager::m_self = 0;
79

con's avatar
con committed
80
81
82
QtVersionManager::QtVersionManager()
    : m_emptyVersion(new QtVersion)
{
83
    m_self = this;
84
    QSettings *s = Core::ICore::instance()->settings();
con's avatar
con committed
85
86
87
88
89
90
91
92
93
94
95
96

    m_idcount = 1;
    int size = s->beginReadArray(QtVersionsSectionName);
    for (int i = 0; i < size; ++i) {
        s->setArrayIndex(i);
        // Find the right id
        // Either something saved or something generated
        // Note: This code assumes that either all ids are read from the settings
        // or generated on the fly.
        int id = s->value("Id", -1).toInt();
        if (id == -1)
            id = getUniqueId();
dt's avatar
dt committed
97
98
        else if (m_idcount < id)
            m_idcount = id + 1;
99
        bool isAutodetected;
100
101
        QString autodetectionSource;
        if (s->contains("isAutodetected")) {
102
            isAutodetected = s->value("isAutodetected", false).toBool();
103
104
            autodetectionSource = s->value("autodetectionSource", QString()).toString();
        } else {// compatibility
105
            isAutodetected = s->value("IsSystemVersion", false).toBool();
106
107
108
            if (isAutodetected)
                autodetectionSource = QLatin1String(PATH_AUTODETECTION_SOURCE);
        }
109
110
111
        QString qmakePath = s->value("QMakePath").toString();
        if (qmakePath.isEmpty()) {
            QString path = s->value("Path").toString();
112
113
114
115
116
117
118
119
120
121
122
            if (!path.isEmpty()) {
                foreach(const QString& command, ProjectExplorer::DebuggingHelperLibrary::possibleQMakeCommands())
                {
                    QFileInfo fi(path + "/bin/" + command);
                    if (fi.exists())
                    {
                        qmakePath = fi.filePath();
                        break;
                    }
                }
            }
123
        }
con's avatar
con committed
124
        QtVersion *version = new QtVersion(s->value("Name").toString(),
125
                                           qmakePath,
con's avatar
con committed
126
                                           id,
127
128
                                           isAutodetected,
                                           autodetectionSource);
con's avatar
con committed
129
130
        version->setMingwDirectory(s->value("MingwDirectory").toString());
        version->setMsvcVersion(s->value("msvcVersion").toString());
con's avatar
con committed
131
        version->setMwcDirectory(s->value("MwcDirectory").toString());
132
        version->setS60SDKDirectory(s->value("S60SDKDirectory").toString());
con's avatar
con committed
133
        version->setGcceDirectory(s->value("GcceDirectory").toString());
134
        version->setSbsV2Directory(s->value(QLatin1String("SBSv2Directory")).toString());
con's avatar
con committed
135
136
137
138
139
140
141
142
143
144
        m_versions.append(version);
    }
    s->endArray();
    updateUniqueIdToIndexMap();

    ++m_idcount;
    addNewVersionsFromInstaller();
    updateSystemVersion();

    writeVersionsIntoSettings();
145

con's avatar
con committed
146
    updateDocumentation();
147

148
149
    // cannot call from ctor, needs to get connected extenernally first
    QTimer::singleShot(0, this, SLOT(updateExamples()));
con's avatar
con committed
150
151
152
153
154
155
156
157
158
159
}

QtVersionManager::~QtVersionManager()
{
    qDeleteAll(m_versions);
    m_versions.clear();
    delete m_emptyVersion;
    m_emptyVersion = 0;
}

160
QtVersionManager *QtVersionManager::instance()
161
{
162
    return m_self;
163
164
}

con's avatar
con committed
165
166
void QtVersionManager::addVersion(QtVersion *version)
{
167
    QTC_ASSERT(version != 0, return);
168
169
170
    if (m_versions.contains(version))
        return;

con's avatar
con committed
171
    m_versions.append(version);
172
173
174
    int uniqueId = version->uniqueId();
    m_uniqueIdToIndex.insert(uniqueId, m_versions.count() - 1);
    emit qtVersionsChanged(QList<int>() << uniqueId);
175
    writeVersionsIntoSettings();
con's avatar
con committed
176
177
}

178
179
void QtVersionManager::removeVersion(QtVersion *version)
{
180
    QTC_ASSERT(version != 0, return);
181
    m_versions.removeAll(version);
182
183
184
    int uniqueId = version->uniqueId();
    m_uniqueIdToIndex.remove(uniqueId);
    emit qtVersionsChanged(QList<int>() << uniqueId);
185
186
187
188
    writeVersionsIntoSettings();
    delete version;
}

Tobias Hunger's avatar
Tobias Hunger committed
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
bool QtVersionManager::supportsTargetId(const QString &id) const
{
    foreach (QtVersion *version, m_versions) {
        if (version->supportsTargetId(id))
            return true;
    }
    return false;
}

QList<QtVersion *> QtVersionManager::versionsForTargetId(const QString &id) const
{
    QList<QtVersion *> targetVersions;
    foreach (QtVersion *version, m_versions) {
        if (version->supportsTargetId(id))
            targetVersions.append(version);
    }
    return targetVersions;
}

QSet<QString> QtVersionManager::supportedTargetIds() const
{
    QSet<QString> results;
    foreach (QtVersion *version, m_versions)
        results.unite(version->supportedTargetIds());
    return results;
}

con's avatar
con committed
216
217
void QtVersionManager::updateDocumentation()
{
kh1's avatar
kh1 committed
218
    Core::HelpManager *helpManager = Core::HelpManager::instance();
dt's avatar
dt committed
219
    Q_ASSERT(helpManager);
con's avatar
con committed
220
221
    QStringList files;
    foreach (QtVersion *version, m_versions) {
222
223
224
225
226
227
        const QString docPath = version->documentationPath() + QLatin1String("/qch/");
        const QDir versionHelpDir(docPath);
        foreach (const QString &helpFile,
                versionHelpDir.entryList(QStringList() << QLatin1String("*.qch"), QDir::Files))
            files << docPath + helpFile;

con's avatar
con committed
228
229
230
231
    }
    helpManager->registerDocumentation(files);
}

232
233
234
void QtVersionManager::updateExamples()
{
    QtVersion *version = 0;
235
236
    QList<QtVersion*> candidates;

Tobias Hunger's avatar
Tobias Hunger committed
237
    // try to find a version which has both, demos and examples
238
239
240
241
242
    foreach (version, m_versions) {
        if (version->hasExamples() && version->hasDemos())
        candidates.append(version);
    }

243
    // in SDKs, we want to prefer the Qt version shipping with the SDK
244
245
246
    QSettings *settings = Core::ICore::instance()->settings();
    QString preferred = settings->value(QLatin1String("PreferredQMakePath")).toString();
    preferred = QDir::fromNativeSeparators(preferred);
247
    if (!preferred.isEmpty()) {
248
249
250
251
252
#ifdef Q_OS_WIN
        preferred = preferred.toLower();
        if (!preferred.endsWith(QLatin1String(".exe")))
            preferred.append(QLatin1String(".exe"));
#endif
253
254
255
256
257
258
        foreach (version, candidates) {
            if (version->qmakeCommand() == preferred) {
                emit updateExamples(version->examplesPath(), version->demosPath(), version->sourcePath());
                return;
            }
        }
259
260
261
262
263
264
    }

    // prefer versions with declarative examples
    foreach (version, candidates) {
        if (QDir(version->examplesPath()+"/declarative").exists()) {
            emit updateExamples(version->examplesPath(), version->demosPath(), version->sourcePath());
265
266
267
            return;
        }
    }
268
269
270
271
272
273
274
275

    if (!candidates.isEmpty()) {
        version = candidates.first();
        emit updateExamples(version->examplesPath(), version->demosPath(), version->sourcePath());
        return;
    }
    return;

276
277
}

con's avatar
con committed
278
279
280
281
282
283
284
285
int QtVersionManager::getUniqueId()
{
    return m_idcount++;
}

void QtVersionManager::updateUniqueIdToIndexMap()
{
    m_uniqueIdToIndex.clear();
hjk's avatar
hjk committed
286
    for (int i = 0; i < m_versions.size(); ++i)
con's avatar
con committed
287
288
289
290
291
        m_uniqueIdToIndex.insert(m_versions.at(i)->uniqueId(), i);
}

void QtVersionManager::writeVersionsIntoSettings()
{
292
    QSettings *s = Core::ICore::instance()->settings();
293
    s->beginWriteArray(QtVersionsSectionName);
con's avatar
con committed
294
    for (int i = 0; i < m_versions.size(); ++i) {
295
        const QtVersion *version = m_versions.at(i);
con's avatar
con committed
296
        s->setArrayIndex(i);
297
        s->setValue("Name", version->displayName());
298
299
300
        // for downwards compat
        s->setValue("Path", version->versionInfo().value("QT_INSTALL_DATA"));
        s->setValue("QMakePath", version->qmakeCommand());
301
302
303
304
305
306
        s->setValue("Id", version->uniqueId());
        s->setValue("MingwDirectory", version->mingwDirectory());
        s->setValue("msvcVersion", version->msvcVersion());
        s->setValue("isAutodetected", version->isAutodetected());
        if (version->isAutodetected())
            s->setValue("autodetectionSource", version->autodetectionSource());
con's avatar
con committed
307
        s->setValue("MwcDirectory", version->mwcDirectory());
308
        s->setValue("S60SDKDirectory", version->s60SDKDirectory());
con's avatar
con committed
309
        s->setValue("GcceDirectory", version->gcceDirectory());
310
        s->setValue(QLatin1String("SBSv2Directory"), version->sbsV2Directory());
con's avatar
con committed
311
312
313
314
    }
    s->endArray();
}

315
QList<QtVersion *> QtVersionManager::versions() const
con's avatar
con committed
316
317
318
319
{
    return m_versions;
}

320
321
322
323
324
325
326
327
328
329
QList<QtVersion *> QtVersionManager::validVersions() const
{
    QList<QtVersion *> results;
    foreach(QtVersion *v, m_versions) {
        if (v->isValid())
            results.append(v);
    }
    return results;
}

330
331
332
333
334
335
bool QtVersionManager::isValidId(int id) const
{
    int pos = m_uniqueIdToIndex.value(id, -1);
    return (pos != -1);
}

con's avatar
con committed
336
337
338
339
340
341
QtVersion *QtVersionManager::version(int id) const
{
    int pos = m_uniqueIdToIndex.value(id, -1);
    if (pos != -1)
        return m_versions.at(pos);

Tobias Hunger's avatar
Tobias Hunger committed
342
    return m_emptyVersion;
con's avatar
con committed
343
344
345
346
347
}

void QtVersionManager::addNewVersionsFromInstaller()
{
    // Add new versions which may have been installed by the WB installer in the form:
348
    // NewQtVersions="qt 4.3.2=c:\\qt\\qt432\bin\qmake.exe;qt embedded=c:\\qtembedded;"
349
    // or NewQtVersions="qt 4.3.2=c:\\qt\\qt432bin\qmake.exe=c:\\qtcreator\\mingw\\=MSVCName;
350
351
    // i.e.
    // NewQtVersions="versionname=pathtoversion=mingw=s60sdk=gcce=carbide;"
con's avatar
con committed
352
    // Duplicate entries are not added, the first new version is set as default.
353
    QSettings *settings = Core::ICore::instance()->settings();
354
    QSettings *globalSettings = Core::ICore::instance()->settings(QSettings::SystemScope);
355

356
357
358
359
    QDateTime lastUpdateFromGlobalSettings = globalSettings->value(
            QLatin1String("General/LastQtVersionUpdate")).toDateTime();

    const QFileInfo gsFi(globalSettings->fileName());
360
361
    if ( !lastUpdateFromGlobalSettings.isNull() &&
         (!gsFi.exists() || (gsFi.lastModified() > lastUpdateFromGlobalSettings)) )
con's avatar
con committed
362
363
        return;

364
365
366
367
368
    if (!globalSettings->contains(newQtVersionsKey) &&
        !globalSettings->contains(QLatin1String("Installer/")+newQtVersionsKey))
    {
        return;
    }
con's avatar
con committed
369
370

    QString newVersionsValue = settings->value(newQtVersionsKey).toString();
371
372
373
    if (newVersionsValue.isEmpty())
        newVersionsValue = settings->value(QLatin1String("Installer/")+newQtVersionsKey).toString();

con's avatar
con committed
374
    QStringList newVersionsList = newVersionsValue.split(';', QString::SkipEmptyParts);
375
    foreach (const QString &newVersion, newVersionsList) {
con's avatar
con committed
376
        QStringList newVersionData = newVersion.split('=');
377
        if (newVersionData.count() >= 2) {
378
            if (QFile::exists(newVersionData[1])) {
con's avatar
con committed
379
                QtVersion *version = new QtVersion(newVersionData[0], newVersionData[1], m_idcount++ );
hjk's avatar
hjk committed
380
                if (newVersionData.count() >= 3)
con's avatar
con committed
381
                    version->setMingwDirectory(newVersionData[2]);
382
                if (newVersionData.count() >= 4)
383
                    version->setS60SDKDirectory(QDir::fromNativeSeparators(newVersionData[3]));
384
                if (newVersionData.count() >= 5)
385
                    version->setGcceDirectory(QDir::fromNativeSeparators(newVersionData[4]));
386
                if (newVersionData.count() >= 6)
387
                    version->setMwcDirectory(QDir::fromNativeSeparators(newVersionData[5]));
388
389
                if (newVersionData.count() >= 7)
                    version->setMsvcVersion(newVersionData[6]);
390
                if (newVersionData.count() >= 8)
391
                    version->setSbsV2Directory(QDir::fromNativeSeparators(newVersionData[7]));
con's avatar
con committed
392
393
394

                bool versionWasAlreadyInList = false;
                foreach(const QtVersion * const it, m_versions) {
395
                    if (QDir(version->qmakeCommand()).canonicalPath() == QDir(it->qmakeCommand()).canonicalPath()) {
con's avatar
con committed
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
                        versionWasAlreadyInList = true;
                        break;
                    }
                }

                if (!versionWasAlreadyInList) {
                    m_versions.append(version);
                } else {
                    // clean up
                    delete version;
                }
            }
        }
    }
    updateUniqueIdToIndexMap();
411
    settings->setValue(QLatin1String("General/LastQtVersionUpdate"), QDateTime::currentDateTime());
con's avatar
con committed
412
413
414
415
416
}

void QtVersionManager::updateSystemVersion()
{
    bool haveSystemVersion = false;
417
    QString systemQMakePath = DebuggingHelperLibrary::findSystemQt(Utils::Environment::systemEnvironment());
418
419
    if (systemQMakePath.isNull())
        systemQMakePath = tr("<not found>");
420

con's avatar
con committed
421
    foreach (QtVersion *version, m_versions) {
422
423
        if (version->isAutodetected()
            && version->autodetectionSource() == PATH_AUTODETECTION_SOURCE) {
424
            version->setQMakeCommand(systemQMakePath);
425
            version->setDisplayName(tr("Qt in PATH"));
con's avatar
con committed
426
427
428
429
430
            haveSystemVersion = true;
        }
    }
    if (haveSystemVersion)
        return;
431
    QtVersion *version = new QtVersion(tr("Qt in PATH"),
432
                                       systemQMakePath,
con's avatar
con committed
433
                                       getUniqueId(),
434
435
                                       true,
                                       PATH_AUTODETECTION_SOURCE);
con's avatar
con committed
436
437
438
439
    m_versions.prepend(version);
    updateUniqueIdToIndexMap();
}

Tobias Hunger's avatar
Tobias Hunger committed
440
QtVersion *QtVersionManager::emptyVersion() const
con's avatar
con committed
441
{
Tobias Hunger's avatar
Tobias Hunger committed
442
    return m_emptyVersion;
con's avatar
con committed
443
444
}

445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
class SortByUniqueId
{
public:
    bool operator()(QtVersion *a, QtVersion *b)
    {
        return a->uniqueId() < b->uniqueId();
    }
};

bool QtVersionManager::equals(QtVersion *a, QtVersion *b)
{
    if (a->m_qmakeCommand != b->m_qmakeCommand)
        return false;
    if (a->m_id != b->m_id)
        return false;
    if (a->m_mingwDirectory != b->m_mingwDirectory
        || a->m_msvcVersion != b->m_msvcVersion
        || a->m_mwcDirectory != b->m_mwcDirectory)
        return false;
464
465
    if (a->m_displayName != b->displayName())
        return false;
466
467
468
    return true;
}

Tobias Hunger's avatar
Tobias Hunger committed
469
void QtVersionManager::setNewQtVersions(QList<QtVersion *> newVersions)
470
{
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
    // We want to preserve the same order as in the settings dialog
    // so we sort a copy
    QList<QtVersion *> sortedNewVersions = newVersions;
    SortByUniqueId sortByUniqueId;
    qSort(sortedNewVersions.begin(), sortedNewVersions.end(), sortByUniqueId);
    qSort(m_versions.begin(), m_versions.end(), sortByUniqueId);

    QList<int> changedVersions;
    // So we trying to find the minimal set of changed versions,
    // iterate over both sorted list

    // newVersions and oldVersions iterator
    QList<QtVersion *>::const_iterator nit, nend, oit, oend;
    nit = sortedNewVersions.constBegin();
    nend = sortedNewVersions.constEnd();
    oit = m_versions.constBegin();
    oend = m_versions.constEnd();

    while (nit != nend && oit != oend) {
        int nid = (*nit)->uniqueId();
        int oid = (*oit)->uniqueId();
        if (nid < oid) {
            changedVersions.push_back(nid);
            ++nit;
        } else if (oid < nid) {
            changedVersions.push_back(oid);
            ++oit;
        } else {
            if (!equals(*oit, *nit))
                changedVersions.push_back(oid);
            ++oit;
            ++nit;
503
504
        }
    }
505
506
507

    while (nit != nend) {
        changedVersions.push_back((*nit)->uniqueId());
508
        ++nit;
509
510
511
512
    }

    while (oit != oend) {
        changedVersions.push_back((*oit)->uniqueId());
513
        ++oit;
514
515
    }

516
517
    qDeleteAll(m_versions);
    m_versions.clear();
dt's avatar
dt committed
518
    m_versions = newVersions;
519
520

    if (!changedVersions.isEmpty())
521
522
523
        updateDocumentation();
    updateUniqueIdToIndexMap();

524
    updateExamples();
525
    writeVersionsIntoSettings();
526
527
528

    if (!changedVersions.isEmpty())
        emit qtVersionsChanged(changedVersions);
529
530
}

con's avatar
con committed
531
532
533
534
///
/// QtVersion
///

535
QtVersion::QtVersion(const QString &name, const QString &qmakeCommand, int id,
536
                     bool isAutodetected, const QString &autodetectionSource)
537
    : m_displayName(name),
538
    m_isAutodetected(isAutodetected),
539
    m_autodetectionSource(autodetectionSource),
540
    m_hasDebuggingHelper(false),
541
542
    m_hasQmlDump(false),
    m_hasQmlObserver(false),
543
    m_toolChainUpToDate(false),
544
    m_versionInfoUpToDate(false),
545
546
547
    m_notInstalled(false),
    m_defaultConfigIsDebug(true),
    m_defaultConfigIsDebugAndRelease(true),
548
549
    m_hasExamples(false),
    m_hasDemos(false),
550
    m_hasDocumentation(false)
con's avatar
con committed
551
{
hjk's avatar
hjk committed
552
    if (id == -1)
con's avatar
con committed
553
554
555
        m_id = getUniqueId();
    else
        m_id = id;
556
    setQMakeCommand(qmakeCommand);
con's avatar
con committed
557
558
}

559
QtVersion::QtVersion(const QString &name, const QString &qmakeCommand,
560
                     bool isAutodetected, const QString &autodetectionSource)
561
    : m_displayName(name),
562
563
    m_isAutodetected(isAutodetected),
    m_autodetectionSource(autodetectionSource),
564
    m_hasDebuggingHelper(false),
565
566
    m_hasQmlDump(false),
    m_hasQmlObserver(false),
567
    m_toolChainUpToDate(false),
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
    m_versionInfoUpToDate(false),
    m_notInstalled(false),
    m_defaultConfigIsDebug(true),
    m_defaultConfigIsDebugAndRelease(true),
    m_hasExamples(false),
    m_hasDemos(false),
    m_hasDocumentation(false)
{
    m_id = getUniqueId();
    setQMakeCommand(qmakeCommand);
}


QtVersion::QtVersion(const QString &qmakeCommand, bool isAutodetected, const QString &autodetectionSource)
    : m_isAutodetected(isAutodetected),
    m_autodetectionSource(autodetectionSource),
    m_hasDebuggingHelper(false),
585
586
    m_hasQmlDump(false),
    m_hasQmlObserver(false),
587
    m_toolChainUpToDate(false),
588
589
590
591
592
593
594
    m_versionInfoUpToDate(false),
    m_notInstalled(false),
    m_defaultConfigIsDebug(true),
    m_defaultConfigIsDebugAndRelease(true),
    m_hasExamples(false),
    m_hasDemos(false),
    m_hasDocumentation(false)
con's avatar
con committed
595
596
{
    m_id = getUniqueId();
597
    setQMakeCommand(qmakeCommand);
598
    m_displayName = qtVersionString();
con's avatar
con committed
599
600
}

601
QtVersion::QtVersion()
602
    :  m_id(-1),
603
604
    m_isAutodetected(false),
    m_hasDebuggingHelper(false),
605
606
    m_hasQmlDump(false),
    m_hasQmlObserver(false),
607
    m_toolChainUpToDate(false),
608
609
610
611
612
613
614
615
    m_versionInfoUpToDate(false),
    m_notInstalled(false),
    m_defaultConfigIsDebug(true),
    m_defaultConfigIsDebugAndRelease(true),
    m_hasExamples(false),
    m_hasDemos(false),
    m_hasDocumentation(false)
{
616
    setQMakeCommand(QString());
617
618
619
}


620
621
622
623
QtVersion::~QtVersion()
{
}

624
625
626
627
QString QtVersion::toHtml() const
{
    QString rc;
    QTextStream str(&rc);
Robert Loehning's avatar
Robert Loehning committed
628
    str << "<html><body><table>";
629
    str << "<tr><td><b>" << QtVersionManager::tr("Name:")
630
        << "</b></td><td>" << displayName() << "</td></tr>";
631
632
633
634
635
636
    str << "<tr><td><b>" << QtVersionManager::tr("Source:")
        << "</b></td><td>" << sourcePath() << "</td></tr>";
    str << "<tr><td><b>" << QtVersionManager::tr("mkspec:")
        << "</b></td><td>" << mkspec() << "</td></tr>";
    str << "<tr><td><b>" << QtVersionManager::tr("qmake:")
        << "</b></td><td>" << m_qmakeCommand << "</td></tr>";
dt's avatar
dt committed
637
    updateToolChainAndMkspec();
638
    if (m_defaultConfigIsDebug || m_defaultConfigIsDebugAndRelease) {
639
640
        str << "<tr><td><b>" << QtVersionManager::tr("Default:") << "</b></td><td>"
            << (m_defaultConfigIsDebug ? "debug" : "release");
641
        if (m_defaultConfigIsDebugAndRelease)
642
            str << " debug_and_release";
643
644
645
646
647
648
649
650
651
652
653
654
655
        str << "</td></tr>";
    } // default config.
    str << "<tr><td><b>" << QtVersionManager::tr("Version:")
        << "</b></td><td>" << qtVersionString() << "</td></tr>";
    if (hasDebuggingHelper())
        str << "<tr><td><b>" << QtVersionManager::tr("Debugging helper:")
            << "</b></td><td>" << debuggingHelperLibrary() << "</td></tr>";
    const QHash<QString,QString> vInfo = versionInfo();
    if (!vInfo.isEmpty()) {
        const QHash<QString,QString>::const_iterator vcend = vInfo.constEnd();
        for (QHash<QString,QString>::const_iterator it = vInfo.constBegin(); it != vcend; ++it)
            str << "<tr><td><pre>" << it.key() <<  "</pre></td><td>" << it.value() << "</td></tr>";
    }
Robert Loehning's avatar
Robert Loehning committed
656
    str << "</table></body></html>";
657
658
659
    return rc;
}

660
661
662
663
664
665
bool QtVersion::supportsShadowBuilds() const
{
    QSet<QString> targets = supportedTargetIds();
    // Symbian does not support shadow building
    if (targets.contains(Constants::S60_DEVICE_TARGET_ID) ||
        targets.contains(Constants::S60_EMULATOR_TARGET_ID)) {
Tobias Hunger's avatar
Tobias Hunger committed
666
        // We can not support shadow building with the ABLD system
667
668
669
670
671
        return false;
    }
    return true;
}

672
QList<ProjectExplorer::Task>
673
QtVersion::reportIssues(const QString &proFile, const QString &buildDir)
674
675
676
{
    QList<ProjectExplorer::Task> results;

677
678
679
680
    QString tmpBuildDir = buildDir;
    if (!buildDir.endsWith(QChar('/')))
        tmpBuildDir.append(QChar('/'));

Friedemann Kleint's avatar
Friedemann Kleint committed
681
682
683
684
    if (!isValid()) {
        //: %1: Reason for being invalid
        const QString msg = QCoreApplication::translate("Qt4ProjectManager::QtVersion", "The Qt version is invalid: %1").arg(invalidReason());
        results.append(ProjectExplorer::Task(ProjectExplorer::Task::Error, msg, QString(), -1,
685
                                             QLatin1String(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)));
Friedemann Kleint's avatar
Friedemann Kleint committed
686
    }
687
688
689

    QFileInfo qmakeInfo(qmakeCommand());
    if (!qmakeInfo.exists() ||
Friedemann Kleint's avatar
Friedemann Kleint committed
690
691
692
693
694
        !qmakeInfo.isExecutable()) {
        //: %1: Path to qmake executable
        const QString msg = QCoreApplication::translate("Qt4ProjectManager::QtVersion",
                                                        "The qmake command \"%1\" was not found or is not executable.").arg(qmakeCommand());
        results.append(ProjectExplorer::Task(ProjectExplorer::Task::Error, msg, QString(), -1,
695
                                             QLatin1String(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)));
Friedemann Kleint's avatar
Friedemann Kleint committed
696
    }
697

698
699
700
701
702
703
704
705
706
707
708
    QString sourcePath = QFileInfo(proFile).absolutePath();
    if (!sourcePath.endsWith(QChar('/')))
        sourcePath.append(QChar('/'));

    if ((tmpBuildDir.startsWith(sourcePath)) && (tmpBuildDir != sourcePath)) {
        const QString msg = QCoreApplication::translate("Qt4ProjectManager::QtVersion",
                                                        "Qmake does not support build directories below the source directory.");
        results.append(ProjectExplorer::Task(ProjectExplorer::Task::Warning, msg, QString(), -1,
                                             QLatin1String(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)));
    } else if (tmpBuildDir.count(QChar('/')) != sourcePath.count(QChar('/'))) {
        const QString msg = QCoreApplication::translate("Qt4ProjectManager::QtVersion",
709
                                                        "The build directory needs to be at the same level as the source directory.");
710

711
712
713
714
        results.append(ProjectExplorer::Task(ProjectExplorer::Task::Warning, msg, QString(), -1,
                                             QLatin1String(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)));
    }

715
716
717
718
719
720
721
    QSet<QString> targets = supportedTargetIds();
    if (targets.contains(Constants::S60_DEVICE_TARGET_ID) ||
        targets.contains(Constants::S60_EMULATOR_TARGET_ID))
        results.append(S60ProjectChecker::reportIssues(proFile, this));
    return results;
}

722
QString QtVersion::displayName() const
con's avatar
con committed
723
{
724
    return m_displayName;
con's avatar
con committed
725
726
}

727
QString QtVersion::qmakeCommand() const
con's avatar
con committed
728
{
729
    return m_qmakeCommand;
con's avatar
con committed
730
731
732
733
734
735
736
737
738
}

QString QtVersion::sourcePath() const
{
    return m_sourcePath;
}

QString QtVersion::mkspec() const
{
dt's avatar
dt committed
739
    updateToolChainAndMkspec();
con's avatar
con committed
740
741
742
    return m_mkspec;
}

dt's avatar
dt committed
743
744
QString QtVersion::mkspecPath() const
{
dt's avatar
dt committed
745
    updateToolChainAndMkspec();
dt's avatar
dt committed
746
747
748
    return m_mkspecFullPath;
}

749
750
751
752
753
754
bool QtVersion::isBuildWithSymbianSbsV2() const
{
    updateToolChainAndMkspec();
    return m_isBuildUsingSbsV2;
}

755
756
QString QtVersion::qtVersionString() const
{
757
758
759
760
761
762
763
764
    if (m_qtVersionString.isNull()) {
        QFileInfo qmake(m_qmakeCommand);
        if (qmake.exists() && qmake.isExecutable()) {
            m_qtVersionString = DebuggingHelperLibrary::qtVersionForQMake(qmake.absoluteFilePath());
        } else {
            m_qtVersionString = QLatin1String("");
        }
    }
765
766
767
    return m_qtVersionString;
}

con's avatar
con committed
768
769
770
771
772
773
QHash<QString,QString> QtVersion::versionInfo() const
{
    updateVersionInfo();
    return m_versionInfo;
}

774
void QtVersion::setDisplayName(const QString &name)
con's avatar
con committed
775
{
776
    m_displayName = name;
con's avatar
con committed
777
778
}

779
void QtVersion::setQMakeCommand(const QString& qmakeCommand)
con's avatar
con committed
780
{
781
    m_qmakeCommand = QDir::fromNativeSeparators(qmakeCommand);
782
#ifdef Q_OS_WIN
783
    m_qmakeCommand = m_qmakeCommand.toLower();
784
#endif
785
786
    m_designerCommand.clear();
    m_linguistCommand.clear();
787
    m_qmlviewerCommand.clear();
788
    m_uicCommand.clear();
789
    m_toolChainUpToDate = false;
790
791
    // TODO do i need to optimize this?
    m_versionInfoUpToDate = false;
792
    m_qtVersionString = QString();
793
    updateSourcePath();
con's avatar
con committed
794
795
796
797
}

void QtVersion::updateSourcePath()
{
798
799
800
801
    updateVersionInfo();
    const QString installData = m_versionInfo["QT_INSTALL_DATA"];
    m_sourcePath = installData;
    QFile qmakeCache(installData + QLatin1String("/.qmake.cache"));
con's avatar
con committed
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
    if (qmakeCache.exists()) {
        qmakeCache.open(QIODevice::ReadOnly | QIODevice::Text);
        QTextStream stream(&qmakeCache);
        while (!stream.atEnd()) {
            QString line = stream.readLine().trimmed();
            if (line.startsWith(QLatin1String("QT_SOURCE_TREE"))) {
                m_sourcePath = line.split(QLatin1Char('=')).at(1).trimmed();
                if (m_sourcePath.startsWith(QLatin1String("$$quote("))) {
                    m_sourcePath.remove(0, 8);
                    m_sourcePath.chop(1);
                }
                break;
            }
        }
    }
817
    m_sourcePath = QDir::cleanPath(m_sourcePath);
dt's avatar
dt committed
818
819
820
#ifdef Q_OS_WIN
    m_sourcePath = m_sourcePath.toLower();
#endif
con's avatar
con committed
821
822
823
824
}

// Returns the version that was used to build the project in that directory
// That is returns the directory
Tobias Hunger's avatar
Tobias Hunger committed
825
// To find out whether we already have a qtversion for that directory call
con's avatar
con committed
826
// QtVersion *QtVersionManager::qtVersionForDirectory(const QString directory);
827
QString QtVersionManager::findQMakeBinaryFromMakefile(const QString &makefile)
con's avatar
con committed
828
829
{
    bool debugAdding = false;
830
831
832
    QFile fi(makefile);
    if (fi.exists() && fi.open(QFile::ReadOnly)) {
        QTextStream ts(&fi);
833
        QRegExp r1("QMAKE\\s*=(.*)");
con's avatar
con committed
834
835
836
837
838
839
        while (!ts.atEnd()) {
            QString line = ts.readLine();
            if (r1.exactMatch(line)) {
                if (debugAdding)
                    qDebug()<<"#~~ QMAKE is:"<<r1.cap(1).trimmed();
                QFileInfo qmake(r1.cap(1).trimmed());
840
                QString qmakePath = qmake.filePath();
841
#ifdef Q_OS_WIN
842
843
                if (!qmakePath.endsWith(QLatin1String(".exe")))
                    qmakePath.append(QLatin1String(".exe"));
844
#endif
845
                // Is qmake still installed?
846
847
848
849
850
851
                QFileInfo fi(qmakePath);
                if (fi.exists()) {
                    qmakePath = fi.absoluteFilePath();
#ifdef Q_OS_WIN
                    qmakePath = qmakePath.toLower();
#endif
852
                    return qmakePath;
853
                }
con's avatar
con committed
854
855
856
            }
        }
    }
857
    return QString();
con's avatar
con committed
858
859
}

860
QtVersion *QtVersionManager::qtVersionForQMakeBinary(const QString &qmakePath)
con's avatar
con committed
861
862
{
   foreach(QtVersion *v, versions()) {
Tobias Hunger's avatar
Tobias Hunger committed
863
864
865
866
867
       if (v->qmakeCommand() == qmakePath) {
           return v;
           break;
       }
   }
con's avatar
con committed
868
869
870
   return 0;
}

871
void dumpQMakeAssignments(const QList<QMakeAssignment> &list)
con's avatar
con committed
872
{
873
    foreach(const QMakeAssignment &qa, list) {
874
875
876
877
        qDebug()<<qa.variable<<qa.op<<qa.value;
    }
}

878
bool QtVersionManager::makefileIsFor(const QString &makefile, const QString &proFile)
879
880
881
882
{
    if (proFile.isEmpty())
        return true;

883
    QString line = findQMakeLine(makefile, QLatin1String("# Project:")).trimmed();
884
885
886
887
888
889
    if (line.isEmpty())
        return false;

    line = line.mid(line.indexOf(QChar(':')) + 1);
    line = line.trimmed();

890
    QFileInfo srcFileInfo(QFileInfo(makefile).absoluteDir(), line);
891
892
893
894
    QFileInfo proFileInfo(proFile);
    return srcFileInfo == proFileInfo;
}

895
QPair<QtVersion::QmakeBuildConfigs, QString> QtVersionManager::scanMakeFile(const QString &makefile, QtVersion::QmakeBuildConfigs defaultBuildConfig)
896
{
897
898
    if (debug)
        qDebug()<<"ScanMakeFile, the gory details:";
899
    QtVersion::QmakeBuildConfigs result = defaultBuildConfig;
900
    QString result2;
901

902
    QString line = findQMakeLine(makefile, QLatin1String("# Command:"));
903
    if (!line.isEmpty()) {
904
905
        if (debug)
            qDebug()<<"Found line"<<line;
906
907
908
        line = trimLine(line);
        QList<QMakeAssignment> assignments;
        QList<QMakeAssignment> afterAssignments;
909
        parseArgs(line, &assignments, &afterAssignments, &result2);
910

911
912
913
914
915
916
        if (debug) {
            dumpQMakeAssignments(assignments);
            if (!afterAssignments.isEmpty())
                qDebug()<<"-after";
            dumpQMakeAssignments(afterAssignments);
        }
917
918
919
920
921

        // Search in assignments for CONFIG(+=,-=,=)(debug,release,debug_and_release)
        // Also remove them from the list
        result = qmakeBuildConfigFromCmdArgs(&assignments, defaultBuildConfig);

dt's avatar
dt committed
922
923
        if (debug)
            dumpQMakeAssignments(assignments);
924

925
        foreach(const QMakeAssignment &qa, assignments)
926
            Utils::QtcProcess::addArg(&result2, qa.variable + qa.op + qa.value);
927
        if (!afterAssignments.isEmpty()) {
928
            Utils::QtcProcess::addArg(&result2, QLatin1String("-after"));
929
            foreach(const QMakeAssignment &qa, afterAssignments)
930
                Utils::QtcProcess::addArg(&result2, qa.variable + qa.op + qa.value);
931
932
933
934
        }
    }

    // Dump the gathered information:
935
936
937
938
939
940
941
942
943
944
    if (debug) {
        qDebug()<<"\n\nDumping information from scanMakeFile";
        qDebug()<<"QMake CONFIG variable parsing";
        qDebug()<<"  "<< (result & QtVersion::NoBuild ? "No Build" : QString::number(int(result)));
        qDebug()<<"  "<< (result & QtVersion::DebugBuild ? "debug" : "release");
        qDebug()<<"  "<< (result & QtVersion::BuildAll ? "debug_and_release" : "no debug_and_release");
        qDebug()<<"\nAddtional Arguments";
        qDebug()<<result2;
        qDebug()<<"\n\n";
    }
945
946
947
    return qMakePair(result, result2);
}

948
QString QtVersionManager::findQMakeLine(const QString &makefile, const QString &key)
949
{
950
951
952
    QFile fi(makefile);
    if (fi.exists() && fi.open(QFile::ReadOnly)) {
        QTextStream ts(&fi);
con's avatar
con committed
953
        while (!ts.atEnd()) {
954
            const QString line = ts.readLine();
955
            if (line.startsWith(key))
956
957
958
959
960
961
962
963
964
965
966
                return line;
        }
    }
    return QString();
}

/// This function trims the "#Command /path/to/qmake" from the the line
QString QtVersionManager::trimLine(const QString line)
{

    // Actually the first space after #Command: /path/to/qmake
967
    const int firstSpace = line.indexOf(QLatin1Char(' '), 11);
968
969
970
    return line.mid(firstSpace).trimmed();
}

971
void QtVersionManager::parseArgs(const QString &args, QList<QMakeAssignment> *assignments, QList<QMakeAssignment> *afterAssignments, QString *additionalArguments)
972
973
974
975
{
    QRegExp regExp("([^\\s\\+-]*)\\s*(\\+=|=|-=|~=)(.*)");
    bool after = false;
    bool ignoreNext = false;
976
977
978
    *additionalArguments = args;
    Utils::QtcProcess::ArgIterator ait(additionalArguments);
    while (ait.next()) {
979
980
981
        if (ignoreNext) {
            // Ignoring
            ignoreNext = false;
982
983
            ait.deleteArg();
        } else if (ait.value() == QLatin1String("-after")) {
984
            after = true;
985
986
987
            ait.deleteArg();
        } else if (ait.value().contains(QLatin1Char('='))) {
            if (regExp.exactMatch(ait.value())) {
988
989
990
991
992
993
994
995
996
997
998
                QMakeAssignment qa;
                qa.variable = regExp.cap(1);
                qa.op = regExp.cap(2);
                qa.value = regExp.cap(3).trimmed();
                if (after)
                    afterAssignments->append(qa);
                else
                    assignments->append(qa);
            } else {
                qDebug()<<"regexp did not match";
            }
999
1000
            ait.deleteArg();
        } else if (ait.value() == QLatin1String("-o")) {
1001
            ignoreNext = true;
1002
            ait.deleteArg();
1003
#if defined(Q_OS_WIN32)
1004
        } else if (ait.value() == QLatin1String("-win32")) {
1005
#elif defined(Q_OS_MAC)
1006
        } else if (ait.value() == QLatin1String("-macx")) {
1007
#elif defined(Q_OS_QNX6)
1008
        } else if (ait.value() == QLatin1String("-qnx6")) {
1009
#else
1010
        } else if (ait.value() == QLatin1String("-unix")) {
1011
#endif
1012
1013
1014
1015
            ait.deleteArg();
        }
    }
    ait.deleteArg();  // The .pro file is always the last arg