qtoptionspage.cpp 25.9 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
Tobias Hunger's avatar
Tobias Hunger committed
2
**
3 4
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
Tobias Hunger's avatar
Tobias Hunger committed
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
Tobias Hunger's avatar
Tobias Hunger committed
7
**
hjk's avatar
hjk committed
8 9 10 11
** 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
12 13 14
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
Tobias Hunger's avatar
Tobias Hunger committed
15
**
16 17 18 19 20 21 22
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
con's avatar
con committed
23
**
hjk's avatar
hjk committed
24
****************************************************************************/
Tobias Hunger's avatar
Tobias Hunger committed
25

26
#include "qtoptionspage.h"
27
#include "qtconfigwidget.h"
28 29
#include "ui_showbuildlog.h"
#include "ui_qtversionmanager.h"
30
#include "ui_qtversioninfo.h"
31
#include "qtsupportconstants.h"
32
#include "qtversionmanager.h"
dt's avatar
dt committed
33
#include "qtversionfactory.h"
34 35

#include <coreplugin/progressmanager/progressmanager.h>
36
#include <coreplugin/coreconstants.h>
37
#include <coreplugin/coreicons.h>
hjk's avatar
hjk committed
38
#include <coreplugin/variablechooser.h>
39
#include <projectexplorer/toolchain.h>
40
#include <projectexplorer/toolchainmanager.h>
41
#include <projectexplorer/projectexplorerconstants.h>
42
#include <utils/buildablehelperlibrary.h>
43
#include <utils/hostosinfo.h>
hjk's avatar
hjk committed
44 45
#include <utils/pathchooser.h>
#include <utils/qtcassert.h>
46
#include <utils/runextensions.h>
47
#include <utils/algorithm.h>
48
#include <utils/treemodel.h>
49

50 51 52
#include <QDir>
#include <QMessageBox>
#include <QFileDialog>
53 54
#include <QTextBrowser>
#include <QDesktopServices>
55 56 57
#include <QSortFilterProxyModel>

#include <utility>
58

hjk's avatar
hjk committed
59
using namespace ProjectExplorer;
60
using namespace Utils;
61

hjk's avatar
hjk committed
62 63 64
namespace QtSupport {
namespace Internal {

65 66 67 68 69 70 71 72 73 74 75 76 77 78
class QtVersionItem : public TreeItem
{
public:
    QtVersionItem(const QString &name) // for auto/manual node
        : TreeItem({name})
    {}

    QtVersionItem(BaseQtVersion *version) // for versions
        : TreeItem(),
          m_version(version)
    {}

    ~QtVersionItem()
    {
Daniel Teske's avatar
Daniel Teske committed
79
        delete m_version;
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
    }

    void setVersion(BaseQtVersion *version)
    {
        m_version = version;
        update();
    }

    int uniqueId() const
    {
        return m_version ? m_version->uniqueId() : -1;
    }

    BaseQtVersion *version() const
    {
        return m_version;
    }

    QVariant data(int column, int role) const
    {
        if (!m_version)
            return TreeItem::data(column, role);

        if (role == Qt::DisplayRole) {
            if (column == 0)
                return m_version->displayName();
            if (column == 1)
                return m_version->qmakeCommand().toUserOutput();
        }

        if (role == Qt::DecorationRole && column == 0)
            return m_icon;

        return QVariant();
    }

    void setIcon(const QIcon &icon)
    {
        m_icon = icon;
        update();
    }

    QString buildLog() const
    {
        return m_buildLog;
    }

    void setBuildLog(const QString &buildLog)
    {
        m_buildLog = buildLog;
    }

    QByteArray toolChainId() const
    {
        return m_toolChainId;
    }

    void setToolChainId(const QByteArray &id)
    {
        m_toolChainId = id;
    }

private:
Daniel Teske's avatar
Daniel Teske committed
143
    BaseQtVersion *m_version = 0;
144 145 146 147
    QIcon m_icon;
    QString m_buildLog;
    QByteArray m_toolChainId;
};
hjk's avatar
hjk committed
148

149 150 151 152 153
///
// QtOptionsPage
///

QtOptionsPage::QtOptionsPage()
dt's avatar
dt committed
154
    : m_widget(0)
155
{
hjk's avatar
hjk committed
156
    setId(Constants::QTVERSION_SETTINGS_PAGE_ID);
157
    setDisplayName(QCoreApplication::translate("Qt4ProjectManager", Constants::QTVERSION_SETTINGS_PAGE_NAME));
hjk's avatar
hjk committed
158
    setCategory(ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_CATEGORY);
159 160 161
    setDisplayCategory(QCoreApplication::translate("ProjectExplorer",
        ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_TR_CATEGORY));
    setCategoryIcon(QLatin1String(ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_CATEGORY_ICON));
162 163
}

164
QWidget *QtOptionsPage::widget()
165
{
166 167
    if (!m_widget)
        m_widget = new QtOptionsPageWidget;
168 169 170 171 172
    return m_widget;
}

void QtOptionsPage::apply()
{
173 174
    if (!m_widget) // page was never shown
        return;
175
    m_widget->apply();
176 177
}

178
void QtOptionsPage::finish()
179
{
180
    delete m_widget;
181 182
}

183
//-----------------------------------------------------
184 185


186
QtOptionsPageWidget::QtOptionsPageWidget(QWidget *parent)
187 188
    : QWidget(parent)
    , m_specifyNameString(tr("<specify a name>"))
189
    , m_ui(new Internal::Ui::QtVersionManager())
190
    , m_versionUi(new Internal::Ui::QtVersionInfo())
191
    , m_infoBrowser(new QTextBrowser)
192 193
    , m_invalidVersionIcon(Core::Icons::ERROR.icon())
    , m_warningVersionIcon(Core::Icons::WARNING.icon())
dt's avatar
dt committed
194
    , m_configurationWidget(0)
195 196
    , m_autoItem(0)
    , m_manualItem(0)
197
{
198 199
    QWidget *versionInfoWidget = new QWidget();
    m_versionUi->setupUi(versionInfoWidget);
200
    m_versionUi->editPathPushButton->setText(PathChooser::browseButtonLabel());
201

202
    m_ui->setupUi(this);
203

204 205
    m_infoBrowser->setOpenLinks(false);
    m_infoBrowser->setTextInteractionFlags(Qt::TextBrowserInteraction);
206 207
    connect(m_infoBrowser, &QTextBrowser::anchorClicked,
            this, &QtOptionsPageWidget::infoAnchorClicked);
208
    m_ui->infoWidget->setWidget(m_infoBrowser);
209 210
    connect(m_ui->infoWidget, &DetailsWidget::expanded,
            this, &QtOptionsPageWidget::setInfoWidgetVisibility);
211

212
    m_ui->versionInfoWidget->setWidget(versionInfoWidget);
hjk's avatar
hjk committed
213
    m_ui->versionInfoWidget->setState(DetailsWidget::NoSummary);
214

215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
    auto rootItem = new QtVersionItem(QLatin1String("root"));
    m_autoItem = new QtVersionItem(tr("Auto-detected"));
    rootItem->appendChild(m_autoItem);
    m_manualItem = new QtVersionItem(tr("Manual"));
    rootItem->appendChild(m_manualItem);

    m_model = new TreeModel(rootItem);
    m_model->setHeader({tr("Name"), tr("qmake Location"), tr("Type")});

    m_filterModel = new QSortFilterProxyModel(this);
    m_filterModel->setSourceModel(m_model);
    m_filterModel->setSortCaseSensitivity(Qt::CaseInsensitive);

    m_ui->qtdirList->setModel(m_filterModel);
    m_ui->qtdirList->setSortingEnabled(true);

    m_ui->qtdirList->setFirstColumnSpanned(0, QModelIndex(), true);
    m_ui->qtdirList->setFirstColumnSpanned(1, QModelIndex(), true);

dt_'s avatar
dt_ committed
234
    m_ui->qtdirList->header()->setStretchLastSection(false);
235 236
    m_ui->qtdirList->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    m_ui->qtdirList->header()->setSectionResizeMode(1, QHeaderView::Stretch);
dt_'s avatar
dt_ committed
237
    m_ui->qtdirList->setTextElideMode(Qt::ElideNone);
238
    m_ui->qtdirList->sortByColumn(0, Qt::AscendingOrder);
239

240
    QList<int> additions = transform(QtVersionManager::versions(), &BaseQtVersion::uniqueId);
241 242

    updateQtVersions(additions, QList<int>(), QList<int>());
243 244

    m_ui->qtdirList->expandAll();
245

246 247
    connect(m_versionUi->nameEdit, &QLineEdit::textEdited,
            this, &QtOptionsPageWidget::updateCurrentQtName);
248

249 250
    connect(m_versionUi->editPathPushButton, &QAbstractButton::clicked,
            this, &QtOptionsPageWidget::editPath);
dt_'s avatar
dt_ committed
251

252 253 254 255
    connect(m_ui->addButton, &QAbstractButton::clicked,
            this, &QtOptionsPageWidget::addQtDir);
    connect(m_ui->delButton, &QAbstractButton::clicked,
            this, &QtOptionsPageWidget::removeQtDir);
256

257
    connect(m_ui->qtdirList->selectionModel(), &QItemSelectionModel::currentChanged,
258
            this, &QtOptionsPageWidget::versionChanged);
259

260 261
    connect(m_ui->cleanUpButton, &QAbstractButton::clicked,
            this, &QtOptionsPageWidget::cleanUpQtVersions);
dt's avatar
dt committed
262 263
    userChangedCurrentVersion();
    updateCleanUpButton();
264

265 266
    connect(QtVersionManager::instance(), &QtVersionManager::dumpUpdatedFor,
            this, &QtOptionsPageWidget::qtVersionsDumpUpdated);
267

268 269
    connect(QtVersionManager::instance(), &QtVersionManager::qtVersionsChanged,
            this, &QtOptionsPageWidget::updateQtVersions);
270

271 272
    connect(ProjectExplorer::ToolChainManager::instance(), &ToolChainManager::toolChainsChanged,
            this, &QtOptionsPageWidget::toolChainsUpdated);
hjk's avatar
hjk committed
273 274

    auto chooser = new Core::VariableChooser(this);
275
    chooser->addSupportedWidget(m_versionUi->nameEdit, "Qt:Name");
hjk's avatar
hjk committed
276 277 278 279 280
    chooser->addMacroExpanderProvider(
        [this]() -> Utils::MacroExpander * {
            BaseQtVersion *version = currentVersion();
            return version ? version->macroExpander() : 0;
        });
281 282
}

dt's avatar
dt committed
283
BaseQtVersion *QtOptionsPageWidget::currentVersion() const
284
{
285 286 287 288
    QtVersionItem *item = currentItem();
    if (!item)
        return 0;
    return item->version();
289
}
290

291
QtVersionItem *QtOptionsPageWidget::currentItem() const
292
{
293 294 295 296
    QModelIndex idx = m_ui->qtdirList->selectionModel()->currentIndex();
    QModelIndex sourceIdx = m_filterModel->mapToSource(idx);
    QtVersionItem *item = static_cast<QtVersionItem *>(m_model->itemForIndex(sourceIdx));
    return item;
297
}
298

299 300
void QtOptionsPageWidget::cleanUpQtVersions()
{
301 302 303 304 305 306 307 308 309 310 311
    QVector<QtVersionItem *> toRemove;
    QString text;

    foreach (Utils::TreeItem *child, m_manualItem->children()) {
        auto item = static_cast<QtVersionItem *>(child);
        if (item->version() && !item->version()->isValid()) {
            toRemove.append(item);
            if (!text.isEmpty())
                text.append(QLatin1String("</li><li>"));
            text.append(item->version()->displayName());
        }
312 313 314 315 316
    }

    if (toRemove.isEmpty())
        return;

317

Friedemann Kleint's avatar
Friedemann Kleint committed
318
    if (QMessageBox::warning(0, tr("Remove Invalid Qt Versions"),
319 320
                             tr("Do you want to remove all invalid Qt Versions?<br>"
                                "<ul><li>%1</li></ul><br>"
321
                                "will be removed.").arg(text),
322 323 324
                             QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
        return;

325 326 327
    foreach (QtVersionItem *item, toRemove) {
        m_model->takeItem(item);
        delete item;
328
    }
329

dt's avatar
dt committed
330
    updateCleanUpButton();
331 332
}

333 334
void QtOptionsPageWidget::toolChainsUpdated()
{
335 336 337 338 339 340 341
    auto update = [this](Utils::TreeItem *parent) {
        foreach (Utils::TreeItem *child, parent->children()) {
            if (child == currentItem()) {
                updateDescriptionLabel();
            } else {
                updateVersionItem(static_cast<QtVersionItem *>(child));
            }
342
        }
343 344 345 346
    };

    update(m_autoItem);
    update(m_manualItem);
347 348
}

hjk's avatar
hjk committed
349
void QtOptionsPageWidget::qtVersionsDumpUpdated(const FileName &qmakeCommand)
350
{
351 352 353 354 355 356 357 358 359 360 361
    auto recheck = [qmakeCommand](Utils::TreeItem *parent) {
        foreach (Utils::TreeItem *child, parent->children()) {
            auto item = static_cast<QtVersionItem *>(child);
            if (item->version()->qmakeCommand() == qmakeCommand)
                item->version()->recheckDumper();
        }
    };

    recheck(m_autoItem);
    recheck(m_manualItem);

362 363
    if (currentVersion()
            && currentVersion()->qmakeCommand() == qmakeCommand) {
364 365 366 367 368
        updateWidgets();
        updateDescriptionLabel();
    }
}

369
void QtOptionsPageWidget::setInfoWidgetVisibility()
370
{
371 372
    m_ui->versionInfoWidget->setVisible(m_ui->infoWidget->state() == DetailsWidget::Collapsed);
    m_ui->infoWidget->setVisible(true);
373 374
}

375 376 377 378 379
void QtOptionsPageWidget::infoAnchorClicked(const QUrl &url)
{
    QDesktopServices::openUrl(url);
}

380 381 382 383 384 385 386 387
QtOptionsPageWidget::ValidityInfo QtOptionsPageWidget::validInformation(const BaseQtVersion *version)
{
    ValidityInfo info;
    info.icon = m_validVersionIcon;

    if (!version)
        return info;

388
    info.description = tr("Qt version %1 for %2").arg(version->qtVersionString(), version->description());
389 390 391 392 393 394 395 396 397
    if (!version->isValid()) {
        info.icon = m_invalidVersionIcon;
        info.message = version->invalidReason();
        return info;
    }

    // Do we have tool chain issues?
    QStringList missingToolChains;
    int abiCount = 0;
hjk's avatar
hjk committed
398 399 400
    foreach (const Abi &abi, version->qtAbis()) {
        if (ToolChainManager::findToolChains(abi).isEmpty())
            missingToolChains.append(abi.toString());
401 402 403
        ++abiCount;
    }

404
    bool useable = true;
405
    QStringList warnings;
406 407 408
    if (!isNameUnique(version))
        warnings << tr("Display Name is not unique.");

409 410 411
    if (!missingToolChains.isEmpty()) {
        if (missingToolChains.count() == abiCount) {
            // Yes, this Qt version can't be used at all!
412
            info.message = tr("No compiler can produce code for this Qt version. Please define one or more compilers.");
413 414 415 416
            info.icon = m_invalidVersionIcon;
            useable = false;
        } else {
            // Yes, some ABIs are unsupported
417
            warnings << tr("Not all possible target environments can be supported due to missing compilers.");
418 419 420 421
            info.toolTip = tr("The following ABIs are currently not supported:<ul><li>%1</li></ul>")
                    .arg(missingToolChains.join(QLatin1String("</li><li>")));
            info.icon = m_warningVersionIcon;
        }
422
    }
423 424

    if (useable) {
425 426
        warnings += version->warningReason();
        if (!warnings.isEmpty()) {
hjk's avatar
hjk committed
427
            info.message = warnings.join(QLatin1Char('\n'));
428 429 430 431
            info.icon = m_warningVersionIcon;
        }
    }

432 433 434
    return info;
}

hjk's avatar
hjk committed
435
QList<ToolChain*> QtOptionsPageWidget::toolChains(const BaseQtVersion *version)
436
{
437
    QList<ToolChain*> toolChains;
438
    if (!version)
439 440
        return toolChains;

441
    QSet<QByteArray> ids;
442 443 444 445 446 447 448 449
    foreach (const Abi &a, version->qtAbis()) {
        foreach (ToolChain *tc, ToolChainManager::findToolChains(a)) {
            if (ids.contains(tc->id()))
                continue;
            ids.insert(tc->id());
            toolChains.append(tc);
        }
    }
450

451
    return toolChains;
452 453
}

454
QByteArray QtOptionsPageWidget::defaultToolChainId(const BaseQtVersion *version)
455
{
hjk's avatar
hjk committed
456
    QList<ToolChain*> possibleToolChains = toolChains(version);
457 458
    if (!possibleToolChains.isEmpty())
        return possibleToolChains.first()->id();
459
    return QByteArray();
460 461
}

462 463 464
bool QtOptionsPageWidget::isNameUnique(const BaseQtVersion *version)
{
    const QString name = version->displayName().trimmed();
465 466 467 468 469 470 471 472 473 474 475 476 477

    auto isUnique = [name, version](Utils::TreeItem *parent) {
        foreach (Utils::TreeItem *child, parent->children()) {
            auto item = static_cast<QtVersionItem *>(child);
            if (item->version() == version)
                continue;
            if (item->version()->displayName().trimmed() == name)
                return false;
        }
        return true;
    };

    return isUnique(m_manualItem) && isUnique(m_autoItem);
478 479
}

480
void QtOptionsPageWidget::updateVersionItem(QtVersionItem *item)
481
{
482 483 484 485 486 487 488 489
    if (!item)
        return;
    if (!item->version())
        return;

    const ValidityInfo info = validInformation(item->version());
    item->update();
    item->setIcon(info.icon);
490 491
}

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
// Non-modal dialog
class BuildLogDialog : public QDialog {
public:
    explicit BuildLogDialog(QWidget *parent = 0);
    void setText(const QString &text);

private:
    Ui_ShowBuildLog m_ui;
};

BuildLogDialog::BuildLogDialog(QWidget *parent) : QDialog(parent)
{
    m_ui.setupUi(this);
    setAttribute(Qt::WA_DeleteOnClose, true);
}

void BuildLogDialog::setText(const QString &text)
509
{
510 511 512 513
    m_ui.log->setPlainText(text); // Show and scroll to bottom
    m_ui.log->moveCursor(QTextCursor::End);
    m_ui.log->ensureCursorVisible();
}
514

515
void QtOptionsPageWidget::showDebuggingBuildLog(const QtVersionItem *item)
516
{
517 518
    BaseQtVersion *version = item->version();
    if (!version)
519
        return;
520
    BuildLogDialog *dialog = new BuildLogDialog(this->window());
521 522
    dialog->setWindowTitle(tr("Debugging Helper Build Log for \"%1\"").arg(version->displayName()));
    dialog->setText(item->buildLog());
523
    dialog->show();
524 525
}

526 527 528
void QtOptionsPageWidget::updateQtVersions(const QList<int> &additions, const QList<int> &removals,
                                           const QList<int> &changes)
{
529
    QList<QtVersionItem *> toRemove;
530 531 532
    QList<int> toAdd = additions;

    // Generate list of all existing items:
533
    QList<QtVersionItem *> itemList;
534
    for (int i = 0; i < m_autoItem->childCount(); ++i)
535
        itemList.append(static_cast<QtVersionItem *>(m_autoItem->child(i)));
536
    for (int i = 0; i < m_manualItem->childCount(); ++i)
537
        itemList.append(static_cast<QtVersionItem *>(m_manualItem->child(i)));
538 539

    // Find existing items to remove/change:
540 541
    foreach (QtVersionItem *item, itemList) {
        int id = item->uniqueId();
542 543 544 545 546 547 548 549 550 551 552 553 554
        if (removals.contains(id)) {
            toRemove.append(item);
            continue;
        }

        if (changes.contains(id)) {
            toAdd.append(id);
            toRemove.append(item);
            continue;
        }
    }

    // Remove changed/removed items:
555 556
    foreach (QtVersionItem *item, toRemove) {
        m_model->takeItem(item);
557 558 559 560 561
        delete item;
    }

    // Add changed/added items:
    foreach (int a, toAdd) {
hjk's avatar
hjk committed
562
        BaseQtVersion *version = QtVersionManager::version(a)->clone();
563
        auto *item = new QtVersionItem(version);
564

565
        item->setToolChainId(defaultToolChainId(version));
566 567

        // Insert in the right place:
568 569
        Utils::TreeItem *parent = version->isAutodetected()? m_autoItem : m_manualItem;
        parent->appendChild(item);
570
    }
571

572 573 574 575 576 577 578
    auto update = [this](Utils::TreeItem *parent) {
        foreach (Utils::TreeItem *child, parent->children())
            updateVersionItem(static_cast<QtVersionItem *>(child));
    };

    update(m_autoItem);
    update(m_manualItem);
579 580
}

581
QtOptionsPageWidget::~QtOptionsPageWidget()
582 583
{
    delete m_ui;
dt's avatar
dt committed
584
    delete m_versionUi;
dt's avatar
dt committed
585
    delete m_configurationWidget;
586 587
}

dt_'s avatar
dt_ committed
588 589
void QtOptionsPageWidget::addQtDir()
{
hjk's avatar
hjk committed
590
    FileName qtVersion = FileName::fromString(
Tobias Hunger's avatar
Tobias Hunger committed
591
                QFileDialog::getOpenFileName(this,
Friedemann Kleint's avatar
Friedemann Kleint committed
592
                                             tr("Select a qmake Executable"),
Tobias Hunger's avatar
Tobias Hunger committed
593
                                             QString(),
594
                                             BuildableHelperLibrary::filterForQmakeFileDialog(),
Tobias Hunger's avatar
Tobias Hunger committed
595 596
                                             0,
                                             QFileDialog::DontResolveSymlinks));
dt's avatar
dt committed
597 598
    if (qtVersion.isNull())
        return;
599

600
    QFileInfo fi = qtVersion.toFileInfo();
601 602
    // should add all qt versions here ?
    if (BuildableHelperLibrary::isQtChooser(fi))
hjk's avatar
hjk committed
603
        qtVersion = FileName::fromString(BuildableHelperLibrary::qtChooserToQmakePath(fi.symLinkTarget()));
604

605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
    auto checkAlreadyExists = [qtVersion](Utils::TreeItem *parent) {
        for (int i = 0; i < parent->childCount(); ++i) {
            auto item = static_cast<QtVersionItem *>(parent->childAt(i));
            if (item->version()->qmakeCommand() == qtVersion) {
                return std::make_pair(true, item->version()->displayName());
            }
        }
        return std::make_pair(false, QString());
    };

    bool alreadyExists;
    QString otherName;
    std::tie(alreadyExists, otherName) = checkAlreadyExists(m_autoItem);
    if (!alreadyExists)
        std::tie(alreadyExists, otherName) = checkAlreadyExists(m_manualItem);

    if (alreadyExists) {
dt's avatar
dt committed
622
        // Already exist
Friedemann Kleint's avatar
Friedemann Kleint committed
623
        QMessageBox::warning(this, tr("Qt Version Already Known"),
624
                             tr("This Qt version was already registered as \"%1\".")
625
                             .arg(otherName));
626
        return;
dt's avatar
dt committed
627
    }
628

629
    QString error;
630
    BaseQtVersion *version = QtVersionFactory::createQtVersionFromQMakePath(qtVersion, false, QString(), &error);
dt's avatar
dt committed
631
    if (version) {
632 633 634 635 636 637 638
        auto item = new QtVersionItem(version);
        item->setIcon(version->isValid()? m_validVersionIcon : m_invalidVersionIcon);
        m_manualItem->appendChild(item);
        item->setToolChainId(defaultToolChainId(version));

        QModelIndex source = m_model->indexForItem(item);
        m_ui->qtdirList->setCurrentIndex(m_filterModel->mapFromSource(source)); // should update the rest of the ui
dt's avatar
dt committed
639 640
        m_versionUi->nameEdit->setFocus();
        m_versionUi->nameEdit->selectAll();
641
    } else {
642
        QMessageBox::warning(this, tr("Qmake Not Executable"),
Friedemann Kleint's avatar
Friedemann Kleint committed
643
                             tr("The qmake executable %1 could not be added: %2").arg(qtVersion.toUserOutput()).arg(error));
644
        return;
dt's avatar
dt committed
645 646
    }
    updateCleanUpButton();
647 648
}

649
void QtOptionsPageWidget::removeQtDir()
650
{
651 652
    QtVersionItem *item = currentItem();
    if (!item)
653 654
        return;

655
    m_model->takeItem(item);
656 657
    delete item;

dt's avatar
dt committed
658
    updateCleanUpButton();
659 660
}

dt_'s avatar
dt_ committed
661 662
void QtOptionsPageWidget::editPath()
{
663
    BaseQtVersion *current = currentVersion();
664
    QString dir = currentVersion()->qmakeCommand().toFileInfo().absolutePath();
hjk's avatar
hjk committed
665
    FileName qtVersion = FileName::fromString(
666
                QFileDialog::getOpenFileName(this,
Robert Loehning's avatar
Robert Loehning committed
667
                                             tr("Select a qmake Executable"),
668
                                             dir,
669
                                             BuildableHelperLibrary::filterForQmakeFileDialog(),
670 671
                                             0,
                                             QFileDialog::DontResolveSymlinks));
dt_'s avatar
dt_ committed
672 673 674
    if (qtVersion.isNull())
        return;
    BaseQtVersion *version = QtVersionFactory::createQtVersionFromQMakePath(qtVersion);
Daniel Teske's avatar
Daniel Teske committed
675 676
    if (!version)
        return;
dt_'s avatar
dt_ committed
677 678 679
    // Same type? then replace!
    if (current->type() != version->type()) {
        // not the same type, error out
Friedemann Kleint's avatar
Friedemann Kleint committed
680
        QMessageBox::critical(this, tr("Incompatible Qt Versions"),
Friedemann Kleint's avatar
Friedemann Kleint committed
681
                              tr("The Qt version selected must match the device type."),
dt_'s avatar
dt_ committed
682 683 684 685 686 687
                              QMessageBox::Ok);
        delete version;
        return;
    }
    // same type, replace
    version->setId(current->uniqueId());
688 689
    if (current->unexpandedDisplayName() != current->defaultUnexpandedDisplayName(current->qmakeCommand()))
        version->setUnexpandedDisplayName(current->displayName());
dt_'s avatar
dt_ committed
690 691

    // Update ui
692 693 694 695
    QtVersionItem *item = currentItem();
    item->setVersion(version);
    item->setToolChainId(defaultToolChainId(version));
    item->setIcon(version->isValid()? m_validVersionIcon : m_invalidVersionIcon);
696 697 698
    userChangedCurrentVersion();

    delete current;
dt_'s avatar
dt_ committed
699 700
}

Friedemann Kleint's avatar
Friedemann Kleint committed
701
// To be called if a Qt version was removed or added
dt's avatar
dt committed
702
void QtOptionsPageWidget::updateCleanUpButton()
703
{
704
    bool hasInvalidVersion = false;
705 706 707
    foreach (Utils::TreeItem *child, m_manualItem->children()) {
        auto item = static_cast<QtVersionItem *>(child);
        if (item->version() && !item->version()->isValid()) {
708
            hasInvalidVersion = true;
dt's avatar
dt committed
709
            break;
710 711
        }
    }
712

713
    m_ui->cleanUpButton->setEnabled(hasInvalidVersion);
714
}
715

dt's avatar
dt committed
716
void QtOptionsPageWidget::userChangedCurrentVersion()
con's avatar
con committed
717
{
dt's avatar
dt committed
718 719
    updateWidgets();
    updateDescriptionLabel();
720 721
}

dt's avatar
dt committed
722
void QtOptionsPageWidget::qtVersionChanged()
723
{
724 725 726 727 728
    updateDescriptionLabel();
}

void QtOptionsPageWidget::updateDescriptionLabel()
{
729 730
    QtVersionItem *item = currentItem();
    const BaseQtVersion *version = item->version();
731 732 733 734 735 736 737 738 739
    const ValidityInfo info = validInformation(version);
    if (info.message.isEmpty()) {
        m_versionUi->errorLabel->setVisible(false);
    } else {
        m_versionUi->errorLabel->setVisible(true);
        m_versionUi->errorLabel->setText(info.message);
        m_versionUi->errorLabel->setToolTip(info.toolTip);
    }
    m_ui->infoWidget->setSummaryText(info.description);
740
    if (item)
741
        item->setIcon(info.icon);
742 743 744

    if (version) {
        m_infoBrowser->setHtml(version->toHtml(true));
745
        setInfoWidgetVisibility();
746
    } else {
747
        m_infoBrowser->clear();
748
        m_ui->versionInfoWidget->setVisible(false);
749 750
        m_ui->infoWidget->setVisible(false);
    }
751 752
}

753
void QtOptionsPageWidget::versionChanged(const QModelIndex &current, const QModelIndex &previous)
754
{
755 756
    Q_UNUSED(current);
    Q_UNUSED(previous);
dt's avatar
dt committed
757 758 759 760 761 762 763 764 765
    userChangedCurrentVersion();
}

void QtOptionsPageWidget::updateWidgets()
{
    delete m_configurationWidget;
    m_configurationWidget = 0;
    BaseQtVersion *version = currentVersion();
    if (version) {
766
        m_versionUi->nameEdit->setText(version->unexpandedDisplayName());
767
        m_versionUi->qmakePath->setText(version->qmakeCommand().toUserOutput());
dt's avatar
dt committed
768 769 770
        m_configurationWidget = version->createConfigurationWidget();
        if (m_configurationWidget) {
            m_versionUi->formLayout->addRow(m_configurationWidget);
dt's avatar
dt committed
771
            m_configurationWidget->setEnabled(!version->isAutodetected());
dt's avatar
dt committed
772 773 774
            connect(m_configurationWidget, SIGNAL(changed()),
                    this, SLOT(qtVersionChanged()));
        }
775
    } else {
776
        m_versionUi->nameEdit->clear();
777
        m_versionUi->qmakePath->clear();
778 779
    }

dt's avatar
dt committed
780 781 782
    const bool enabled = version != 0;
    const bool isAutodetected = enabled && version->isAutodetected();
    m_ui->delButton->setEnabled(enabled && !isAutodetected);
783
    m_versionUi->nameEdit->setEnabled(enabled);
dt_'s avatar
dt_ committed
784
    m_versionUi->editPathPushButton->setEnabled(enabled && !isAutodetected);
785 786
}

787
void QtOptionsPageWidget::updateCurrentQtName()
788
{
789 790
    QtVersionItem *item = currentItem();
    if (!item || !item->version())
791
        return;
792

793 794
    item->version()->setUnexpandedDisplayName(m_versionUi->nameEdit->text());

795
    updateDescriptionLabel();
796

797 798 799 800 801 802 803
    auto update = [this](Utils::TreeItem *parent) {
        foreach (Utils::TreeItem *child, parent->children())
            updateVersionItem(static_cast<QtVersionItem *>(child));
    };

    update(m_autoItem);
    update(m_manualItem);
804 805
}

806 807
void QtOptionsPageWidget::apply()
{
808 809
    disconnect(QtVersionManager::instance(), &QtVersionManager::qtVersionsChanged,
            this, &QtOptionsPageWidget::updateQtVersions);
810

hjk's avatar
hjk committed
811
    QtVersionManager::setNewQtVersions(versions());
812

813 814
    connect(QtVersionManager::instance(), &QtVersionManager::qtVersionsChanged,
            this, &QtOptionsPageWidget::updateQtVersions);
815 816
}

dt's avatar
dt committed
817
QList<BaseQtVersion *> QtOptionsPageWidget::versions() const
818
{
dt's avatar
dt committed
819
    QList<BaseQtVersion *> result;
820 821 822
    auto gather = [&result](TreeItem *parent) {
        result.reserve(result.size() + parent->childCount());
        for (int i = 0; i < parent->childCount(); ++i)
Daniel Teske's avatar
Daniel Teske committed
823
            result.append(static_cast<QtVersionItem *>(parent->childAt(i))->version()->clone());
824 825 826 827 828
    };

    gather(m_autoItem);
    gather(m_manualItem);

829
    return result;
830 831
}

hjk's avatar
hjk committed
832 833
} // namespace Internal
} // namespace QtSupport