~ubuntu-sdk-team/qtcreator-plugin-remotelinux/trunk

« back to all changes in this revision

Viewing changes to src/qnx/blackberryndksettingswidget.cpp

  • Committer: CI bot
  • Author(s): Benjamin Zeller
  • Date: 2014-06-16 10:28:43 UTC
  • mfrom: (4.2.4 remotelinux)
  • Revision ID: ps-jenkins@lists.canonical.com-20140616102843-8juvmjvzwlzsboyw
Migrating to Qt5.3 and QtC 3.1 

Show diffs side-by-side

added added

removed removed

Lines of Context:
33
33
#include "ui_blackberryndksettingswidget.h"
34
34
#include "qnxutils.h"
35
35
#include "blackberrysigningutils.h"
36
 
#include "blackberrysetupwizard.h"
37
36
 
38
37
#include "blackberryconfigurationmanager.h"
39
 
#include "blackberryconfiguration.h"
 
38
#include "blackberryapilevelconfiguration.h"
 
39
#include "blackberryruntimeconfiguration.h"
40
40
 
41
41
#include <utils/pathchooser.h>
42
42
 
51
51
namespace Qnx {
52
52
namespace Internal {
53
53
 
 
54
static QIcon invalidConfigIcon(QLatin1String(":/projectexplorer/images/compile_error.png"));
 
55
 
54
56
BlackBerryNDKSettingsWidget::BlackBerryNDKSettingsWidget(QWidget *parent) :
55
57
    QWidget(parent),
56
58
    m_ui(new Ui_BlackBerryNDKSettingsWidget),
 
59
    m_bbConfigManager(BlackBerryConfigurationManager::instance()),
57
60
    m_autoDetectedNdks(0),
58
 
    m_manualNdks(0)
 
61
    m_manualApiLevel(0)
59
62
{
60
 
    m_bbConfigManager = &BlackBerryConfigurationManager::instance();
61
63
    m_ui->setupUi(this);
62
64
 
63
 
    m_ui->activateNdkTargetButton->setEnabled(false);
64
 
    m_ui->deactivateNdkTargetButton->setEnabled(false);
 
65
    updateInfoTable(0);
65
66
 
66
 
    m_activatedTargets << m_bbConfigManager->activeConfigurations();
 
67
    m_activatedApiLevel << m_bbConfigManager->activeApiLevels();
67
68
 
68
69
    m_ui->ndksTreeWidget->header()->setResizeMode(QHeaderView::Stretch);
69
70
    m_ui->ndksTreeWidget->header()->setStretchLastSection(false);
70
 
    m_ui->ndksTreeWidget->setHeaderItem(new QTreeWidgetItem(QStringList() << tr("NDK") << tr("NDK Environment File")));
 
71
    m_ui->ndksTreeWidget->setHeaderItem(new QTreeWidgetItem(QStringList() << tr("Configuration")));
71
72
    m_ui->ndksTreeWidget->setTextElideMode(Qt::ElideNone);
72
 
    m_ui->ndksTreeWidget->setColumnCount(2);
73
 
    m_autoDetectedNdks = new QTreeWidgetItem(m_ui->ndksTreeWidget);
 
73
    m_ui->ndksTreeWidget->setColumnCount(1);
 
74
 
 
75
    m_apiLevels = new QTreeWidgetItem(m_ui->ndksTreeWidget);
 
76
    m_apiLevels->setText(0, tr("API Levels"));
 
77
    m_runtimes = new QTreeWidgetItem(m_ui->ndksTreeWidget);
 
78
    m_runtimes->setText(0, tr("Runtimes"));
 
79
 
 
80
    m_autoDetectedNdks = new QTreeWidgetItem(m_apiLevels);
74
81
    m_autoDetectedNdks->setText(0, tr("Auto-Detected"));
75
82
    m_autoDetectedNdks->setFirstColumnSpanned(true);
76
83
    m_autoDetectedNdks->setFlags(Qt::ItemIsEnabled);
77
 
    m_manualNdks = new QTreeWidgetItem(m_ui->ndksTreeWidget);
78
 
    m_manualNdks->setText(0, tr("Manual"));
79
 
    m_manualNdks->setFirstColumnSpanned(true);
80
 
    m_manualNdks->setFlags(Qt::ItemIsEnabled);
 
84
    m_manualApiLevel = new QTreeWidgetItem(m_apiLevels);
 
85
    m_manualApiLevel->setText(0, tr("Manual"));
 
86
    m_manualApiLevel->setFirstColumnSpanned(true);
 
87
    m_manualApiLevel->setFlags(Qt::ItemIsEnabled);
81
88
 
82
89
    m_ui->ndksTreeWidget->expandAll();
83
90
 
84
 
    updateNdkList();
 
91
    connect(m_ui->addConfigButton, SIGNAL(clicked()), this, SLOT(addConfiguration()));
 
92
    connect(m_ui->removeConfigButton, SIGNAL(clicked()), this, SLOT(removeConfiguration()));
 
93
    connect(m_ui->activateNdkTargetButton, SIGNAL(clicked()), this, SLOT(activateApiLevel()));
 
94
    connect(m_ui->deactivateNdkTargetButton, SIGNAL(clicked()), this, SLOT(deactivateApiLevel()));
85
95
 
86
 
    connect(m_ui->wizardButton, SIGNAL(clicked()), this, SLOT(launchBlackBerrySetupWizard()));
87
 
    connect(m_ui->addNdkButton, SIGNAL(clicked()), this, SLOT(addNdkTarget()));
88
 
    connect(m_ui->removeNdkButton, SIGNAL(clicked()), this, SLOT(removeNdkTarget()));
89
 
    connect(m_ui->activateNdkTargetButton, SIGNAL(clicked()), this, SLOT(activateNdkTarget()));
90
 
    connect(m_ui->deactivateNdkTargetButton, SIGNAL(clicked()), this, SLOT(deactivateNdkTarget()));
 
96
    connect(m_ui->cleanUpButton, SIGNAL(clicked()), this, SLOT(cleanUp()));
91
97
    connect(m_ui->ndksTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), this, SLOT(updateInfoTable(QTreeWidgetItem*)));
92
 
}
93
 
 
94
 
void BlackBerryNDKSettingsWidget::setWizardMessageVisible(bool visible)
95
 
{
96
 
    m_ui->wizardLabel->setVisible(visible);
97
 
    m_ui->wizardButton->setVisible(visible);
 
98
    connect(this, SIGNAL(configurationsUpdated()), this, SLOT(populateDefaultConfigurationCombo()));
 
99
 
 
100
    // BlackBerryConfigurationManager.settingsChanged signal may be emitted multiple times
 
101
    // during the same event handling. This would result in multiple updatePage() calls even through
 
102
    // just one is needed.
 
103
    // QTimer allows to merge those multiple signal emits into a single updatePage() call.
 
104
    m_timer.setSingleShot(true);
 
105
    connect(&m_timer, SIGNAL(timeout()), this, SLOT(updatePage()));
 
106
 
 
107
    updatePage();
 
108
    connect(m_bbConfigManager, SIGNAL(settingsChanged()), &m_timer, SLOT(start()));
98
109
}
99
110
 
100
111
bool BlackBerryNDKSettingsWidget::hasActiveNdk() const
101
112
{
102
 
    return !m_bbConfigManager->configurations().isEmpty();
103
 
}
104
 
 
105
 
QList<BlackBerryConfiguration *> BlackBerryNDKSettingsWidget::activatedTargets()
106
 
{
107
 
    return m_activatedTargets;
108
 
}
109
 
 
110
 
QList<BlackBerryConfiguration *> BlackBerryNDKSettingsWidget::deactivatedTargets()
111
 
{
112
 
    return m_deactivatedTargets;
113
 
}
114
 
 
115
 
void BlackBerryNDKSettingsWidget::launchBlackBerrySetupWizard() const
116
 
{
117
 
    BlackBerrySigningUtils &blackBerryUtils = BlackBerrySigningUtils::instance();
118
 
    const bool alreadyConfigured = blackBerryUtils.hasRegisteredKeys() && blackBerryUtils.hasDefaultCertificate();
119
 
 
120
 
    if (alreadyConfigured) {
121
 
        QMessageBox::information(0, tr("Qt Creator"),
122
 
            tr("It appears that your BlackBerry environment has already been configured."));
123
 
            return;
124
 
    }
125
 
 
126
 
    BlackBerrySetupWizard wizard(Core::ICore::mainWindow());
127
 
    connect(&wizard, SIGNAL(ndkTargetsUpdated()), this, SLOT(updateNdkList()));
128
 
    wizard.exec();
 
113
    return !m_bbConfigManager->apiLevels().isEmpty();
 
114
}
 
115
 
 
116
QList<BlackBerryApiLevelConfiguration *> BlackBerryNDKSettingsWidget::activatedApiLevels()
 
117
{
 
118
    return m_activatedApiLevel;
 
119
}
 
120
 
 
121
QList<BlackBerryApiLevelConfiguration *> BlackBerryNDKSettingsWidget::deactivatedApiLevels()
 
122
{
 
123
    return m_deactivatedApiLevel;
 
124
}
 
125
 
 
126
BlackBerryApiLevelConfiguration *BlackBerryNDKSettingsWidget::defaultApiLevel() const
 
127
{
 
128
    const int currentIndex = m_ui->apiLevelCombo->currentIndex();
 
129
 
 
130
    return static_cast<BlackBerryApiLevelConfiguration*>(
 
131
            m_ui->apiLevelCombo->itemData(currentIndex).value<void*>());
129
132
}
130
133
 
131
134
void BlackBerryNDKSettingsWidget::updateInfoTable(QTreeWidgetItem* currentItem)
132
135
{
 
136
    updateUi(currentItem);
133
137
    if (!currentItem)
134
138
        return;
135
139
 
136
 
    QString envFilePath = currentItem->text(1);
137
 
    if (envFilePath.isEmpty()) {
138
 
        m_ui->removeNdkButton->setEnabled(false);
139
 
        m_ui->activateNdkTargetButton->setEnabled(false);
140
 
        m_ui->deactivateNdkTargetButton->setEnabled(false);
141
 
        return;
142
 
    }
143
 
 
144
 
    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromEnvFile(Utils::FileName::fromString(envFilePath));
145
 
    if (!config)
146
 
        return;
147
 
 
148
 
    m_ui->baseNameLabel->setText(config->displayName());
149
 
    m_ui->ndkPathLabel->setText(QDir::toNativeSeparators(config->ndkPath()));
150
 
    m_ui->hostLabel->setText(QDir::toNativeSeparators(config->qnxHost()));
151
 
    m_ui->targetLabel->setText(QDir::toNativeSeparators(config->sysRoot().toString()));
152
 
    m_ui->versionLabel->clear();
153
 
    // TODO: Add a versionNumber attribute for the BlackBerryConfiguration class
154
 
    if (config->isAutoDetected()) {
155
 
        foreach (const NdkInstallInformation &ndkInfo, QnxUtils::installedNdks()) {
156
 
            if (ndkInfo.name == config->displayName()) {
157
 
                m_ui->versionLabel->setText(ndkInfo.version);
158
 
                break;
159
 
            }
 
140
    if (currentItem->parent() == m_runtimes) {
 
141
        BlackBerryRuntimeConfiguration *runtime = static_cast<BlackBerryRuntimeConfiguration*>(
 
142
                    currentItem->data(0, Qt::UserRole).value<void*>());
 
143
        if (runtime) {
 
144
            m_ui->baseName->setText(runtime->displayName());
 
145
            m_ui->version->setText(runtime->version().toString());
 
146
            m_ui->path->setText(runtime->path());
 
147
 
 
148
            m_ui->removeConfigButton->setEnabled(runtime);
 
149
            m_ui->activateNdkTargetButton->setEnabled(false);
 
150
            m_ui->deactivateNdkTargetButton->setEnabled(false);
160
151
        }
 
152
 
 
153
        return;
 
154
    } else if (currentItem->parent() == m_autoDetectedNdks || currentItem->parent() == m_manualApiLevel) {
 
155
        BlackBerryApiLevelConfiguration *config = static_cast<BlackBerryApiLevelConfiguration*>(
 
156
                    currentItem->data(0, Qt::UserRole).value<void*>());
 
157
 
 
158
        m_ui->path->setText(config->ndkEnvFile().toString());
 
159
        m_ui->baseName->setText(config->displayName());
 
160
        m_ui->host->setText(QDir::toNativeSeparators(config->qnxHost()));
 
161
        m_ui->target->setText(QDir::toNativeSeparators(config->sysRoot().toString()));
 
162
        m_ui->version->setText(config->version().toString());
161
163
    }
162
 
 
163
 
    updateUi(currentItem, config);
164
164
}
165
165
 
166
 
void BlackBerryNDKSettingsWidget::updateNdkList()
 
166
void BlackBerryNDKSettingsWidget::updateConfigurationList()
167
167
{
 
168
    m_activatedApiLevel.clear();
 
169
    m_activatedApiLevel << m_bbConfigManager->activeApiLevels();
 
170
    m_deactivatedApiLevel.clear();
 
171
 
168
172
    qDeleteAll(m_autoDetectedNdks->takeChildren());
169
 
    qDeleteAll(m_manualNdks->takeChildren());
 
173
    qDeleteAll(m_manualApiLevel->takeChildren());
 
174
    qDeleteAll(m_runtimes->takeChildren());
170
175
 
171
 
    foreach (BlackBerryConfiguration *config, m_bbConfigManager->configurations()) {
172
 
        QTreeWidgetItem *parent = config->isAutoDetected() ? m_autoDetectedNdks : m_manualNdks;
 
176
    bool enableCleanUp = false;
 
177
    foreach (BlackBerryApiLevelConfiguration *config, m_bbConfigManager->apiLevels()) {
 
178
        QTreeWidgetItem *parent = config->isAutoDetected() ? m_autoDetectedNdks : m_manualApiLevel;
173
179
        QTreeWidgetItem *item = new QTreeWidgetItem(parent);
174
180
        item->setText(0, config->displayName());
175
 
        item->setText(1, config->ndkEnvFile().toString());
176
 
        QFont font;
177
 
        font.setBold(config->isActive() || m_activatedTargets.contains(config));
178
 
        item->setFont(0, font);
179
 
        item->setFont(1, font);
180
 
    }
181
 
 
182
 
    if (m_autoDetectedNdks->child(0)) {
183
 
        m_autoDetectedNdks->child(0)->setSelected(true);
184
 
        updateInfoTable(m_autoDetectedNdks->child(0));
185
 
    }
186
 
}
187
 
 
188
 
void BlackBerryNDKSettingsWidget::addNdkTarget()
189
 
{
190
 
    launchBlackBerryInstallerWizard(BlackBerryInstallerDataHandler::InstallMode);
191
 
    emit targetsUpdated();
192
 
}
193
 
 
194
 
void BlackBerryNDKSettingsWidget::removeNdkTarget()
195
 
{
196
 
    if (!m_ui->ndksTreeWidget->currentItem())
197
 
        return;
198
 
 
199
 
    QString ndk = m_ui->ndksTreeWidget->currentItem()->text(0);
200
 
    QString envFilePath = m_ui->ndksTreeWidget->currentItem()->text(1);
201
 
 
202
 
    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromEnvFile(Utils::FileName::fromString(envFilePath));
203
 
    if (!config)
204
 
        return;
205
 
 
206
 
    if (config->isAutoDetected()) {
207
 
        uninstallNdkTarget();
208
 
        emit targetsUpdated();
209
 
        return;
210
 
    }
211
 
 
212
 
    QMessageBox::StandardButton button =
213
 
            QMessageBox::question(Core::ICore::mainWindow(),
214
 
                                  tr("Clean BlackBerry 10 Configuration"),
215
 
                                  tr("Are you sure you want to remove:\n %1?").arg(ndk),
216
 
                                  QMessageBox::Yes | QMessageBox::No);
217
 
 
218
 
    if (button == QMessageBox::Yes) {
219
 
        m_activatedTargets.removeOne(config);
220
 
        m_deactivatedTargets.removeOne(config);
221
 
        m_bbConfigManager->removeConfiguration(config);
222
 
        m_manualNdks->removeChild(m_ui->ndksTreeWidget->currentItem());
223
 
        emit targetsUpdated();
224
 
    }
225
 
}
226
 
 
227
 
void BlackBerryNDKSettingsWidget::activateNdkTarget()
228
 
{
229
 
    if (!m_ui->ndksTreeWidget->currentItem())
230
 
        return;
231
 
 
232
 
    QString envFilePath = m_ui->ndksTreeWidget->currentItem()->text(1);
233
 
 
234
 
    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromEnvFile(Utils::FileName::fromString(envFilePath));
235
 
    if (config && !m_activatedTargets.contains(config)) {
236
 
        m_activatedTargets << config;
237
 
        if (m_deactivatedTargets.contains(config))
238
 
           m_deactivatedTargets.removeAt(m_deactivatedTargets.indexOf(config));
239
 
 
240
 
        updateUi(m_ui->ndksTreeWidget->currentItem(), config);
241
 
        emit targetsUpdated();
242
 
    }
243
 
}
244
 
 
245
 
void BlackBerryNDKSettingsWidget::deactivateNdkTarget()
246
 
{
247
 
    if (!m_ui->ndksTreeWidget->currentItem())
248
 
        return;
249
 
 
250
 
    QString envFilePath = m_ui->ndksTreeWidget->currentItem()->text(1);
251
 
 
252
 
    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromEnvFile(Utils::FileName::fromString(envFilePath));
253
 
    if (config && m_activatedTargets.contains(config)) {
254
 
        m_deactivatedTargets << config;
255
 
        m_activatedTargets.removeAt(m_activatedTargets.indexOf(config));
256
 
        updateUi(m_ui->ndksTreeWidget->currentItem(), config);
257
 
        emit targetsUpdated();
258
 
    }
259
 
}
260
 
 
261
 
void BlackBerryNDKSettingsWidget::updateUi(QTreeWidgetItem *item, BlackBerryConfiguration *config)
262
 
{
263
 
    if (!item || !config)
264
 
        return;
265
 
 
266
 
    QFont font;
267
 
    font.setBold(m_activatedTargets.contains(config));
268
 
    item->setFont(0, font);
269
 
    item->setFont(1, font);
270
 
 
271
 
    m_ui->activateNdkTargetButton->setEnabled(!m_activatedTargets.contains(config));
272
 
    m_ui->deactivateNdkTargetButton->setEnabled(m_activatedTargets.contains(config)
273
 
                                                && m_activatedTargets.size() > 1);
274
 
    // Disable remove button for auto detected pre-10.2 NDKs (uninstall wizard doesn't handle them)
275
 
    m_ui->removeNdkButton->setEnabled(!(config->isAutoDetected()
276
 
                                            && QnxUtils::sdkInstallerPath(config->ndkPath()).isEmpty()));
277
 
}
278
 
 
279
 
void BlackBerryNDKSettingsWidget::uninstallNdkTarget()
 
181
        item->setData(0, Qt::UserRole, QVariant::fromValue(static_cast<void*>(config)));
 
182
        QFont font;
 
183
        font.setBold(config->isActive() || m_activatedApiLevel.contains(config));
 
184
        item->setFont(0, font);
 
185
        item->setIcon(0, config->isValid() ? QIcon() : invalidConfigIcon);
 
186
        // TODO: Do the same if qmake, qcc, debugger are no longer detected...
 
187
        if (!config->isValid()) {
 
188
            QString toolTip = tr("Invalid target %1:").arg(config->targetName());
 
189
            if (config->isAutoDetected() && !config->autoDetectionSource().toFileInfo().exists())
 
190
                toolTip += QLatin1Char('\n') + tr("- Target no longer installed.");
 
191
 
 
192
            if (!config->ndkEnvFile().toFileInfo().exists())
 
193
                toolTip += QLatin1Char('\n') + tr("- No NDK environment file found.");
 
194
 
 
195
            if (config->qmake4BinaryFile().isEmpty()
 
196
                    && config->qmake5BinaryFile().isEmpty())
 
197
                toolTip += QLatin1Char('\n') + tr("- No Qt version found.");
 
198
 
 
199
            if (config->gccCompiler().isEmpty())
 
200
                toolTip += QLatin1Char('\n') + tr("- No compiler found.");
 
201
 
 
202
            if (config->deviceDebuger().isEmpty())
 
203
                toolTip += QLatin1Char('\n') + tr("- No debugger found for device.");
 
204
 
 
205
            if (config->simulatorDebuger().isEmpty())
 
206
                toolTip += QLatin1Char('\n') + tr("- No debugger found for simulator.");
 
207
 
 
208
            item->setToolTip(0, toolTip);
 
209
            enableCleanUp = true;
 
210
        }
 
211
    }
 
212
 
 
213
    foreach (BlackBerryRuntimeConfiguration *runtime, m_bbConfigManager->runtimes()) {
 
214
        QTreeWidgetItem *item = new QTreeWidgetItem(m_runtimes);
 
215
        item->setText(0, runtime->displayName());
 
216
        item->setData(0, Qt::UserRole, QVariant::fromValue(static_cast<void*>(runtime)));
 
217
    }
 
218
 
 
219
    m_ui->ndksTreeWidget->setCurrentItem(m_autoDetectedNdks->child(0));
 
220
    m_ui->cleanUpButton->setEnabled(enableCleanUp);
 
221
}
 
222
 
 
223
void BlackBerryNDKSettingsWidget::addConfiguration()
 
224
{
 
225
    launchBlackBerryInstallerWizard(BlackBerryInstallerDataHandler::InstallMode, BlackBerryInstallerDataHandler::ApiLevel);
 
226
    emit configurationsUpdated();
 
227
}
 
228
 
 
229
void BlackBerryNDKSettingsWidget::removeConfiguration()
 
230
{
 
231
    QTreeWidgetItem * current = m_ui->ndksTreeWidget->currentItem();
 
232
    if (!current)
 
233
        return;
 
234
 
 
235
    if (current->parent() == m_runtimes) {
 
236
        uninstallConfiguration(BlackBerryInstallerDataHandler::Runtime);
 
237
        emit configurationsUpdated();
 
238
    } else {
 
239
        const QString ndk = m_ui->ndksTreeWidget->currentItem()->text(0);
 
240
        BlackBerryApiLevelConfiguration *config = static_cast<BlackBerryApiLevelConfiguration*>(
 
241
                    current->data(0, Qt::UserRole).value<void*>());
 
242
        if (config->isAutoDetected()) {
 
243
            uninstallConfiguration(BlackBerryInstallerDataHandler::ApiLevel);
 
244
            emit configurationsUpdated();
 
245
            return;
 
246
        }
 
247
 
 
248
        QMessageBox::StandardButton button =
 
249
                QMessageBox::question(Core::ICore::mainWindow(),
 
250
                                      tr("Clean BlackBerry 10 Configuration"),
 
251
                                      tr("Are you sure you want to remove:\n %1?").arg(ndk),
 
252
                                      QMessageBox::Yes | QMessageBox::No);
 
253
 
 
254
        if (button == QMessageBox::Yes) {
 
255
            m_activatedApiLevel.removeOne(config);
 
256
            m_deactivatedApiLevel.removeOne(config);
 
257
            m_bbConfigManager->removeApiLevel(config);
 
258
            m_manualApiLevel->removeChild(m_ui->ndksTreeWidget->currentItem());
 
259
            emit configurationsUpdated();
 
260
        }
 
261
    }
 
262
}
 
263
 
 
264
void BlackBerryNDKSettingsWidget::activateApiLevel()
 
265
{
 
266
    if (!m_ui->ndksTreeWidget->currentItem())
 
267
        return;
 
268
 
 
269
    BlackBerryApiLevelConfiguration *config = static_cast<BlackBerryApiLevelConfiguration*>(
 
270
                m_ui->ndksTreeWidget->currentItem()->data(0, Qt::UserRole).value<void*>());
 
271
 
 
272
    if (!m_activatedApiLevel.contains(config)) {
 
273
        m_activatedApiLevel << config;
 
274
        if (m_deactivatedApiLevel.contains(config))
 
275
           m_deactivatedApiLevel.removeAt(m_deactivatedApiLevel.indexOf(config));
 
276
 
 
277
        updateUi(m_ui->ndksTreeWidget->currentItem());
 
278
        emit configurationsUpdated();
 
279
    }
 
280
}
 
281
 
 
282
void BlackBerryNDKSettingsWidget::deactivateApiLevel()
 
283
{
 
284
    if (!m_ui->ndksTreeWidget->currentItem())
 
285
        return;
 
286
 
 
287
    BlackBerryApiLevelConfiguration *config = static_cast<BlackBerryApiLevelConfiguration*>(
 
288
                m_ui->ndksTreeWidget->currentItem()->data(0, Qt::UserRole).value<void*>());
 
289
    if (m_activatedApiLevel.contains(config)) {
 
290
        m_deactivatedApiLevel << config;
 
291
        m_activatedApiLevel.removeAt(m_activatedApiLevel.indexOf(config));
 
292
        updateUi(m_ui->ndksTreeWidget->currentItem());
 
293
        emit configurationsUpdated();
 
294
    }
 
295
}
 
296
 
 
297
void BlackBerryNDKSettingsWidget::updateUi(QTreeWidgetItem *item)
 
298
{
 
299
    if (!item || (item->parent() != m_runtimes &&
 
300
                  item->parent() != m_autoDetectedNdks &&
 
301
                  item->parent() != m_manualApiLevel )) {
 
302
        m_ui->removeConfigButton->setEnabled(false);
 
303
        m_ui->activateNdkTargetButton->setEnabled(false);
 
304
        m_ui->deactivateNdkTargetButton->setEnabled(false);
 
305
       m_ui->informationBox->setVisible(false);
 
306
        return;
 
307
    }
 
308
 
 
309
    const bool isRuntimeItem = item->parent() == m_runtimes;
 
310
    // Update the infornation to show in the information panel
 
311
    m_ui->informationBox->setVisible(true);
 
312
    m_ui->informationBox->setTitle(isRuntimeItem ?
 
313
                                       tr("Runtime Information") : tr("API Level Information"));
 
314
    m_ui->pathLabel->setText(isRuntimeItem ? tr("Path:") : tr("Environment file:"));
 
315
    m_ui->hostLabel->setVisible(!isRuntimeItem);
 
316
    m_ui->host->setVisible(!isRuntimeItem);
 
317
    m_ui->targetLabel->setVisible(!isRuntimeItem);
 
318
    m_ui->target->setVisible(!isRuntimeItem);
 
319
 
 
320
    if (!isRuntimeItem) {
 
321
        BlackBerryApiLevelConfiguration *config = static_cast<BlackBerryApiLevelConfiguration*>(
 
322
                    item->data(0, Qt::UserRole).value<void*>());
 
323
        const bool contains = m_activatedApiLevel.contains(config);
 
324
        QFont font;
 
325
        font.setBold(contains);
 
326
        item->setFont(0, font);
 
327
 
 
328
        m_ui->activateNdkTargetButton->setEnabled(!contains);
 
329
        m_ui->deactivateNdkTargetButton->setEnabled(contains);
 
330
        // Disable remove button for auto detected pre-10.2 NDKs (uninstall wizard doesn't handle them)
 
331
        m_ui->removeConfigButton->setEnabled(!(config->isAutoDetected()
 
332
                                               && QnxUtils::sdkInstallerPath(config->ndkPath()).isEmpty()));
 
333
    }
 
334
}
 
335
 
 
336
void BlackBerryNDKSettingsWidget::uninstallConfiguration(BlackBerryInstallerDataHandler::Target target)
280
337
{
281
338
    const QMessageBox::StandardButton answer = QMessageBox::question(this, tr("Confirmation"),
282
339
                                                                     tr("Are you sure you want to uninstall %1?").
283
 
                                                                     arg(m_ui->baseNameLabel->text()),
 
340
                                                                     arg(m_ui->baseName->text()),
284
341
                                                                     QMessageBox::Yes | QMessageBox::No);
285
342
 
286
 
    if (answer == QMessageBox::Yes)
287
 
        launchBlackBerryInstallerWizard(BlackBerryInstallerDataHandler::UninstallMode, m_ui->versionLabel->text());
 
343
    if (answer == QMessageBox::Yes) {
 
344
        if (target == BlackBerryInstallerDataHandler::ApiLevel) {
 
345
            launchBlackBerryInstallerWizard(BlackBerryInstallerDataHandler::UninstallMode,
 
346
                                        BlackBerryInstallerDataHandler::ApiLevel, m_ui->version->text());
 
347
        } else if (target == BlackBerryInstallerDataHandler::Runtime) {
 
348
            if (m_ui->ndksTreeWidget->currentItem()) {
 
349
                launchBlackBerryInstallerWizard(BlackBerryInstallerDataHandler::UninstallMode,
 
350
                                                BlackBerryInstallerDataHandler::Runtime,
 
351
                                                m_ui->ndksTreeWidget->currentItem()->text(0));
 
352
            }
 
353
        }
 
354
 
 
355
    }
 
356
}
 
357
 
 
358
void BlackBerryNDKSettingsWidget::cleanUp()
 
359
{
 
360
    foreach (BlackBerryApiLevelConfiguration *config, m_bbConfigManager->apiLevels()) {
 
361
        if (!config->isValid()) {
 
362
            m_activatedApiLevel.removeOne(config);
 
363
            m_deactivatedApiLevel.removeOne(config);
 
364
            m_bbConfigManager->removeApiLevel(config);
 
365
        }
 
366
    }
 
367
 
 
368
    updateConfigurationList();
288
369
}
289
370
 
290
371
void BlackBerryNDKSettingsWidget::handleInstallationFinished()
291
372
{
292
 
    m_bbConfigManager->loadAutoDetectedConfigurations();
293
 
    updateNdkList();
 
373
    m_bbConfigManager->loadAutoDetectedApiLevels();
 
374
    m_bbConfigManager->loadAutoDetectedRuntimes();
 
375
    updateConfigurationList();
294
376
}
295
377
 
296
378
void BlackBerryNDKSettingsWidget::handleUninstallationFinished()
297
379
{
298
 
    if (!m_ui->ndksTreeWidget->currentItem())
299
 
        return;
300
 
 
301
 
    QString targetName = m_ui->ndksTreeWidget->currentItem()->text(0);
302
 
    QString envFilePath = m_ui->ndksTreeWidget->currentItem()->text(1);
 
380
    QTreeWidgetItem *current = m_ui->ndksTreeWidget->currentItem();
 
381
    if (!current)
 
382
        return;
 
383
 
 
384
    if (current->parent() == m_runtimes) {
 
385
        BlackBerryRuntimeConfiguration *runtime = static_cast<BlackBerryRuntimeConfiguration*>(
 
386
                    current->data(0, Qt::UserRole).value<void*>());
 
387
        m_bbConfigManager->removeRuntime(runtime);
 
388
        updateConfigurationList();
 
389
        return;
 
390
    }
 
391
 
 
392
    const QString targetName = current->text(0);
303
393
    // Check if the target is corrrecly uninstalled
304
394
    foreach (const NdkInstallInformation &ndk, QnxUtils::installedNdks()) {
305
395
        if (ndk.name == targetName)
306
396
            return;
307
397
    }
308
398
 
309
 
    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromEnvFile(Utils::FileName::fromString(envFilePath));
310
 
    if (m_activatedTargets.contains(config))
311
 
        m_activatedTargets.removeAt(m_activatedTargets.indexOf(config));
312
 
    else if (m_deactivatedTargets.contains(config))
313
 
        m_deactivatedTargets.removeAt(m_deactivatedTargets.indexOf(config));
314
 
 
315
 
    m_bbConfigManager->removeConfiguration(config);
316
 
 
317
 
    updateNdkList();
318
 
}
319
 
 
320
 
void BlackBerryNDKSettingsWidget::launchBlackBerryInstallerWizard(BlackBerryInstallerDataHandler::Mode mode,
321
 
                                                                  const QString& targetVersion)
322
 
{
323
 
    BlackBerryInstallWizard wizard(mode, targetVersion, this);
 
399
    BlackBerryApiLevelConfiguration *config = static_cast<BlackBerryApiLevelConfiguration*>(
 
400
                current->data(0, Qt::UserRole).value<void*>());
 
401
    if (m_activatedApiLevel.contains(config))
 
402
        m_activatedApiLevel.removeAt(m_activatedApiLevel.indexOf(config));
 
403
    else if (m_deactivatedApiLevel.contains(config))
 
404
        m_deactivatedApiLevel.removeAt(m_deactivatedApiLevel.indexOf(config));
 
405
 
 
406
    m_bbConfigManager->removeApiLevel(config);
 
407
 
 
408
    updateConfigurationList();
 
409
}
 
410
 
 
411
void BlackBerryNDKSettingsWidget::populateDefaultConfigurationCombo()
 
412
{
 
413
    // prevent QComboBox::currentIndexChanged() from being emitted
 
414
    m_ui->apiLevelCombo->clear();
 
415
 
 
416
    QList<BlackBerryApiLevelConfiguration*> configurations = m_bbConfigManager->apiLevels();
 
417
 
 
418
    m_ui->apiLevelCombo->addItem(tr("Newest Version"),
 
419
            QVariant::fromValue(static_cast<void*>(0)));
 
420
 
 
421
    if (configurations.isEmpty())
 
422
        return;
 
423
 
 
424
    int configIndex = 0;
 
425
 
 
426
    BlackBerryApiLevelConfiguration *defaultConfig = m_bbConfigManager->defaultApiLevel();
 
427
 
 
428
    foreach (BlackBerryApiLevelConfiguration *config, configurations) {
 
429
        m_ui->apiLevelCombo->addItem(config->displayName(),
 
430
                QVariant::fromValue(static_cast<void*>(config)));
 
431
 
 
432
        if (config == defaultConfig)
 
433
            configIndex = m_ui->apiLevelCombo->count() - 1;
 
434
    }
 
435
 
 
436
    const int currentIndex = (m_bbConfigManager->newestApiLevelEnabled()) ? 0 : configIndex;
 
437
 
 
438
    m_ui->apiLevelCombo->setCurrentIndex(currentIndex);
 
439
}
 
440
 
 
441
void BlackBerryNDKSettingsWidget::launchBlackBerryInstallerWizard(
 
442
        BlackBerryInstallerDataHandler::Mode mode,
 
443
        BlackBerryInstallerDataHandler::Target target,
 
444
        const QString& targetVersion)
 
445
{
 
446
    BlackBerryInstallWizard wizard(mode, target, targetVersion, this);
324
447
    if (mode == BlackBerryInstallerDataHandler::InstallMode)
325
448
        connect(&wizard, SIGNAL(processFinished()), this, SLOT(handleInstallationFinished()));
326
449
    else
329
452
    wizard.exec();
330
453
}
331
454
 
 
455
void BlackBerryNDKSettingsWidget::updatePage()
 
456
{
 
457
    updateConfigurationList();
 
458
    populateDefaultConfigurationCombo();
 
459
}
 
460
 
332
461
} // namespace Internal
333
462
} // namespace Qnx
334
463