void Qt4ProjectConfigWidget::updateDetails()
{
QtVersion *version = m_buildConfiguration->qtVersion();
QString versionString;
versionString = version->displayName();
if (!version || !version->isValid()) {
// Not a valid qt version
m_detailsContainer->setSummaryText(
tr("using <font color=\"#ff0000\">invalid</font> Qt Version: <b>%1</b><br>"
"%2")
.arg(versionString,
version ? version->invalidReason() : tr("No Qt Version found.")));
} else {
// Qt Version, Build Directory and Toolchain
m_detailsContainer->setSummaryText(
tr("using Qt version: <b>%1</b><br>"
"with tool chain <b>%2</b><br>"
"building in <b>%3</b>")
.arg(versionString,
ProjectExplorer::ToolChain::toolChainName(m_buildConfiguration->toolChainType()),
QDir::toNativeSeparators(m_buildConfiguration->buildDirectory())));
}
}
void Qt4BuildConfigWidget::importLabelClicked()
{
if (m_ui->shadowBuildCheckBox->isChecked()) {
QString directory = m_ui->shadowBuildDirEdit->path();
if (!directory.isEmpty()) {
QtVersionManager *vm = m_pro->qt4ProjectManager()->versionManager();
QString qtPath = vm->findQtVersionFromMakefile(directory);
if (!qtPath.isEmpty()) {
QtVersion *version = vm->qtVersionForDirectory(qtPath);
if (!version) {
version = new QtVersion(QFileInfo(qtPath).baseName(), qtPath);
vm->addVersion(version);
}
QtVersion::QmakeBuildConfig qmakeBuildConfig = version->defaultBuildConfig();
qmakeBuildConfig = vm->scanMakefileForQmakeConfig(directory, qmakeBuildConfig);
// So we got all the information now apply it...
m_pro->setQtVersion(m_buildConfiguration, version->uniqueId());
// Combo box will be updated at the end
// Find qmakestep...
QMakeStep *qmakeStep = m_pro->qmakeStep();
MakeStep *makeStep = m_pro->makeStep();
qmakeStep->setValue(m_buildConfiguration, "buildConfiguration", int(qmakeBuildConfig));
// Adjust command line arguments, this is ugly as hell
// If we are switching to BuildAll we want "release" in there and no "debug"
// or "debug" in there and no "release"
// If we are switching to not BuildAl we want neither "release" nor "debug" in there
QStringList makeCmdArguments = makeStep->value(m_buildConfiguration, "makeargs").toStringList();
bool debug = qmakeBuildConfig & QtVersion::DebugBuild;
if (qmakeBuildConfig & QtVersion::BuildAll) {
makeCmdArguments.removeAll(debug ? "release" : "debug");
if (!makeCmdArguments.contains(debug ? "debug" : "release"))
makeCmdArguments.append(debug ? "debug" : "release");
} else {
makeCmdArguments.removeAll("debug");
makeCmdArguments.removeAll("remove");
}
makeStep->setValue(m_buildConfiguration, "makeargs", makeCmdArguments);
}
}
}
setupQtVersionsComboBox();
}
ProjectExplorer::Target *Qt4DesktopTargetFactory::create(ProjectExplorer::Project *parent, const QString &id)
{
if (!canCreate(parent, id))
return 0;
QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id);
if (knownVersions.isEmpty())
return 0;
QtVersion *qtVersion = knownVersions.first();
QtVersion::QmakeBuildConfigs config = qtVersion->defaultBuildConfig();
QList<BuildConfigurationInfo> infos;
infos.append(BuildConfigurationInfo(qtVersion, config, QString(), QString()));
infos.append(BuildConfigurationInfo(qtVersion, config ^ QtVersion::DebugBuild, QString(), QString()));
return create(parent, id, infos);
}
QtVersionManager::QtVersionManager()
: m_emptyVersion(new QtVersion)
{
QSettings *s = Core::ICore::instance()->settings();
m_defaultVersion = s->value(defaultQtVersionKey, 0).toInt();
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();
else if (id > m_idcount)
m_idcount = id;
QtVersion *version = new QtVersion(s->value("Name").toString(),
s->value("Path").toString(),
id,
s->value("IsSystemVersion", false).toBool());
version->setMingwDirectory(s->value("MingwDirectory").toString());
version->setPrependPath(s->value("PrependPath").toString());
version->setMsvcVersion(s->value("msvcVersion").toString());
m_versions.append(version);
}
s->endArray();
updateUniqueIdToIndexMap();
++m_idcount;
addNewVersionsFromInstaller();
updateSystemVersion();
writeVersionsIntoSettings();
updateDocumentation();
}
void QtOptionsPageWidget::updateCurrentQMakeLocation()
{
QTreeWidgetItem *currentItem = m_ui->qtdirList->currentItem();
Q_ASSERT(currentItem);
int currentItemIndex = indexForTreeItem(currentItem);
if (currentItemIndex < 0)
return;
QtVersion *version = m_versions.at(currentItemIndex).data();
QFileInfo fi(m_versionUi->qmakePath->path());
if (!fi.exists() || !fi.isFile() || version->qmakeCommand() == fi.absoluteFilePath())
return;
version->setQMakeCommand(fi.absoluteFilePath());
currentItem->setText(1, QDir::toNativeSeparators(version->qmakeCommand()));
showEnvironmentPage(currentItem);
updateDebuggingHelperUi();
if (m_versionUi->nameEdit->text().isEmpty() || m_versionUi->nameEdit->text() == m_specifyNameString) {
QString name = ProjectExplorer::DebuggingHelperLibrary::qtVersionForQMake(version->qmakeCommand());
if (!name.isEmpty())
m_versionUi->nameEdit->setText(name);
updateCurrentQtName();
}
}
void QtOptionsPageWidget::updateDebuggingHelperUi()
{
QtVersion *version = currentVersion();
const QTreeWidgetItem *currentItem = m_ui->qtdirList->currentItem();
if (!version || !version->supportsBinaryDebuggingHelper()) {
m_ui->debuggingHelperWidget->setVisible(false);
} else {
bool canBuildQmlDumper = QmlDumpTool::canBuild(version);
bool canBuildQmlDebuggingLib = QmlDebuggingLibrary::canBuild(version);
bool canBuildQmlObserver = QmlObserverTool::canBuild(version);
bool hasGdbHelper = !version->debuggingHelperLibrary().isEmpty();
bool hasQmlDumper = version->hasQmlDump();
bool hasQmlDebuggingLib = version->hasQmlDebuggingLibrary();
bool hasQmlObserver = !version->qmlObserverTool().isEmpty();
bool isBuildingGdbHelper = false;
bool isBuildingQmlDumper = false;
bool isBuildingQmlDebuggingLib = false;
bool isBuildingQmlObserver = false;
if (currentItem) {
DebuggingHelperBuildTask::Tools buildingTools
= currentItem->data(0, BuildRunningRole).value<DebuggingHelperBuildTask::Tools>();
isBuildingGdbHelper = buildingTools & DebuggingHelperBuildTask::GdbDebugging;
isBuildingQmlDumper = buildingTools & DebuggingHelperBuildTask::QmlDump;
isBuildingQmlDebuggingLib = buildingTools & DebuggingHelperBuildTask::QmlDebugging;
isBuildingQmlObserver = buildingTools & DebuggingHelperBuildTask::QmlObserver;
}
// get names of tools from labels
QStringList helperNames;
if (hasGdbHelper)
helperNames << m_debuggingHelperUi->gdbHelperLabel->text().remove(':');
if (hasQmlDumper)
helperNames << m_debuggingHelperUi->qmlDumpLabel->text().remove(':');
if (hasQmlDebuggingLib)
helperNames << m_debuggingHelperUi->qmlDebuggingLibLabel->text().remove(':');
if (hasQmlObserver)
helperNames << m_debuggingHelperUi->qmlObserverLabel->text().remove(':');
QString status;
if (helperNames.isEmpty()) {
status = tr("Helpers: None available");
} else {
//: %1 is list of tool names.
status = tr("Helpers: %1.").arg(helperNames.join(QLatin1String(", ")));
}
m_ui->debuggingHelperWidget->setSummaryText(status);
QString gdbHelperText;
Qt::TextInteractionFlags gdbHelperTextFlags = Qt::NoTextInteraction;
if (hasGdbHelper) {
gdbHelperText = QDir::toNativeSeparators(version->debuggingHelperLibrary());
gdbHelperTextFlags = Qt::TextSelectableByMouse;
} else {
gdbHelperText = tr("<i>Not yet built.</i>");
}
m_debuggingHelperUi->gdbHelperStatus->setText(gdbHelperText);
m_debuggingHelperUi->gdbHelperStatus->setTextInteractionFlags(gdbHelperTextFlags);
m_debuggingHelperUi->gdbHelperBuildButton->setEnabled(!isBuildingGdbHelper);
QString qmlDumpStatusText;
Qt::TextInteractionFlags qmlDumpStatusTextFlags = Qt::NoTextInteraction;
if (hasQmlDumper) {
qmlDumpStatusText = QDir::toNativeSeparators(version->qmlDumpTool(false));
const QString debugQmlDumpPath = QDir::toNativeSeparators(version->qmlDumpTool(true));
if (qmlDumpStatusText != debugQmlDumpPath) {
if (!qmlDumpStatusText.isEmpty()
&& !debugQmlDumpPath.isEmpty())
qmlDumpStatusText += QLatin1String("\n");
qmlDumpStatusText += debugQmlDumpPath;
}
qmlDumpStatusTextFlags = Qt::TextSelectableByMouse;
} else {
if (canBuildQmlDumper) {
qmlDumpStatusText = tr("<i>Not yet built.</i>");
} else {
qmlDumpStatusText = tr("<i>Cannot be compiled.</i>");
}
}
m_debuggingHelperUi->qmlDumpStatus->setText(qmlDumpStatusText);
m_debuggingHelperUi->qmlDumpStatus->setTextInteractionFlags(qmlDumpStatusTextFlags);
m_debuggingHelperUi->qmlDumpBuildButton->setEnabled(canBuildQmlDumper & !isBuildingQmlDumper);
QString qmlDebuggingLibStatusText;
Qt::TextInteractionFlags qmlDebuggingLibStatusTextFlags = Qt::NoTextInteraction;
if (hasQmlDebuggingLib) {
qmlDebuggingLibStatusText = QDir::toNativeSeparators(
version->qmlDebuggingHelperLibrary(false));
const QString debugPath = QDir::toNativeSeparators(
version->qmlDebuggingHelperLibrary(true));
if (qmlDebuggingLibStatusText != debugPath) {
if (!qmlDebuggingLibStatusText.isEmpty()
&& !debugPath.isEmpty()) {
qmlDebuggingLibStatusText += QLatin1String("\n");
}
qmlDebuggingLibStatusText += debugPath;
}
qmlDebuggingLibStatusTextFlags = Qt::TextSelectableByMouse;
} else {
if (canBuildQmlDebuggingLib) {
qmlDebuggingLibStatusText = tr("<i>Not yet built.</i>");
} else {
qmlDebuggingLibStatusText = tr("<i>Cannot be compiled.</i>");
}
}
m_debuggingHelperUi->qmlDebuggingLibStatus->setText(qmlDebuggingLibStatusText);
m_debuggingHelperUi->qmlDebuggingLibStatus->setTextInteractionFlags(qmlDebuggingLibStatusTextFlags);
m_debuggingHelperUi->qmlDebuggingLibBuildButton->setEnabled(canBuildQmlDebuggingLib
&& !isBuildingQmlDebuggingLib);
QString qmlObserverStatusText;
Qt::TextInteractionFlags qmlObserverStatusTextFlags = Qt::NoTextInteraction;
if (hasQmlObserver) {
qmlObserverStatusText = QDir::toNativeSeparators(version->qmlObserverTool());
qmlObserverStatusTextFlags = Qt::TextSelectableByMouse;
} else {
if (canBuildQmlObserver) {
qmlObserverStatusText = tr("<i>Not yet built.</i>");
} else {
qmlObserverStatusText = tr("<i>Cannot be compiled.</i>");
}
}
m_debuggingHelperUi->qmlObserverStatus->setText(qmlObserverStatusText);
m_debuggingHelperUi->qmlObserverStatus->setTextInteractionFlags(qmlObserverStatusTextFlags);
m_debuggingHelperUi->qmlObserverBuildButton->setEnabled(canBuildQmlObserver
& !isBuildingQmlObserver);
const bool hasLog = currentItem && !currentItem->data(0, BuildLogRole).toString().isEmpty();
m_debuggingHelperUi->showLogButton->setEnabled(hasLog);
m_debuggingHelperUi->rebuildButton->setEnabled(!isBuildingGdbHelper
&& !isBuildingQmlDumper
&& !isBuildingQmlDebuggingLib
&& !isBuildingQmlObserver);
m_ui->debuggingHelperWidget->setVisible(true);
}
}
QString Qt4RunConfiguration::dumperLibrary() const
{
Qt4Project *pro = qobject_cast<Qt4Project *>(project());
QtVersion *version = pro->qtVersion(pro->activeBuildConfiguration());
return version->dumperLibrary();
}
