Maemo: Move MADDE environment information out of MaemoToolChain class.

The toolchain is not available in all places where we need the
respective information, which resulted in duplicated code.

24 files changed, 199 insertions, 243 deletions

diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp
index 0ee1c8f4ed..08abf96191 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp
@@ -33,7 +33,7 @@
 
 #include "maemodeployablelistmodel.h"
 
-#include "maemotoolchain.h"
+#include "maemoglobal.h"
 
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/session.h>
@@ -255,10 +255,10 @@ bool MaemoDeployableListModel::addDesktopFile(QString &error)
             return false;
     }
 
-    const MaemoToolChain *const tc = maemoToolchain();
-    QTC_ASSERT(tc, return false);
+    const QtVersion * const version = qtVersion();
+    QTC_ASSERT(version, return false);
     QString remoteDir = QLatin1String("/usr/share/applications");
-    if (tc->version() == MaemoToolChain::Maemo5)
+    if (MaemoGlobal::version(version) == MaemoGlobal::Maemo5)
         remoteDir += QLatin1String("/hildon");
     const QLatin1String filesLine("desktopfile.files = $${TARGET}.desktop");
     const QString pathLine = QLatin1String("desktopfile.path = ") + remoteDir;
@@ -333,7 +333,7 @@ bool MaemoDeployableListModel::addLinesToProFile(const QStringList &lines)
     return true;
 }
 
-const MaemoToolChain *MaemoDeployableListModel::maemoToolchain() const
+const QtVersion *MaemoDeployableListModel::qtVersion() const
 {
     const ProjectExplorer::Project *const activeProject
         = ProjectExplorer::ProjectExplorerPlugin::instance()->session()->startupProject();
@@ -344,25 +344,22 @@ const MaemoToolChain *MaemoDeployableListModel::maemoToolchain() const
     const Qt4BuildConfiguration *const bc
         = activeTarget->activeBuildConfiguration();
     QTC_ASSERT(bc, return 0);
-    const MaemoToolChain *const tc
-        = dynamic_cast<MaemoToolChain *>(bc->toolChain());
-    QTC_ASSERT(tc, return 0);
-    return tc;
+    return bc->qtVersion();
 }
 
 QString MaemoDeployableListModel::proFileScope() const
 {
-    const MaemoToolChain *const tc = maemoToolchain();
-    QTC_ASSERT(tc, return QString());
-    return QLatin1String(tc->version() == MaemoToolChain::Maemo5
+    const QtVersion *const qv = qtVersion();
+    QTC_ASSERT(qv, return QString());
+    return QLatin1String(MaemoGlobal::version(qv) == MaemoGlobal::Maemo5
         ? "maemo5" : "unix:!symbian:!maemo5");
 }
 
 QString MaemoDeployableListModel::installPrefix() const
 {
-    const MaemoToolChain *const tc = maemoToolchain();
-    QTC_ASSERT(tc, return QString());
-    return QLatin1String(tc->version() == MaemoToolChain::Maemo5
+    const QtVersion *const qv = qtVersion();
+    QTC_ASSERT(qv, return QString());
+    return QLatin1String(MaemoGlobal::version(qv) == MaemoGlobal::Maemo5
         ? "/opt/usr" : "/usr");
 }
 
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h
index dc7a5e6c34..14e494fc3f 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h
@@ -45,8 +45,8 @@
 #include <QtCore/QString>
 
 namespace Qt4ProjectManager {
+class QtVersion;
 namespace Internal {
-class MaemoToolChain;
 
 class MaemoDeployableListModel : public QAbstractTableModel
 {
@@ -98,7 +98,7 @@ private:
     bool isEditable(const QModelIndex &index) const;
     bool buildModel();
     bool addLinesToProFile(const QStringList &lines);
-    const MaemoToolChain *maemoToolchain() const;
+    const QtVersion *qtVersion() const;
     QString proFileScope() const;
     QString installPrefix() const;
 
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodeploystep.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemodeploystep.cpp
index 208491fa43..ba13086a27 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodeploystep.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodeploystep.cpp
@@ -455,12 +455,15 @@ void MaemoDeployStep::handleUnmounted()
         m_mounter->resetMountSpecifications();
         setState(Inactive);
         break;
-    case UnmountingOldDirs:
-        if (toolChain()->allowsRemoteMounts())
+    case UnmountingOldDirs: {
+        const Qt4BuildConfiguration * const bc
+            = static_cast<Qt4BuildConfiguration *>(buildConfiguration());
+        if (MaemoGlobal::allowsRemoteMounts(bc->qtVersion()))
             setupMount();
         else
             prepareSftpConnection();
         break;
+    }
     case UnmountingCurrentDirs:
         setState(GatheringPorts);
         m_portsGatherer->start(m_connection, deviceConfig().freePorts());
@@ -519,7 +522,7 @@ void MaemoDeployStep::setupMount()
 
     Q_ASSERT(m_needsInstall || !m_filesToCopy.isEmpty());
     m_mounter->resetMountSpecifications();
-    m_mounter->setToolchain(toolChain());
+    m_mounter->setBuildConfiguration(static_cast<Qt4BuildConfiguration *>(buildConfiguration()));
     if (m_needsInstall) {
         const QString localDir
             = QFileInfo(packagingStep()->packageFilePath()).absolutePath();
@@ -579,11 +582,13 @@ void MaemoDeployStep::installToSysroot()
 
     if (m_needsInstall) {
         writeOutput(tr("Installing package to sysroot ..."));
-        const MaemoToolChain * const tc = toolChain();
+        const Qt4BuildConfiguration * const bc
+            = static_cast<Qt4BuildConfiguration *>(buildConfiguration());
+        const QtVersion * const qtVersion = bc->qtVersion();
         const QStringList args = QStringList() << QLatin1String("-t")
-            << tc->targetName() << QLatin1String("xdpkg") << QLatin1String("-i")
-            << packagingStep()->packageFilePath();
-        m_sysrootInstaller->start(tc->madAdminCommand(), args);
+            << MaemoGlobal::targetName(qtVersion) << QLatin1String("xdpkg")
+            << QLatin1String("-i") << packagingStep()->packageFilePath();
+        MaemoGlobal::callMadAdmin(*m_sysrootInstaller, args, qtVersion);
         if (!m_sysrootInstaller->waitForStarted()) {
             writeOutput(tr("Installation to sysroot failed, continuing anyway."),
                 ErrorMessageOutput);
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp
index bc677cff89..5a16e2e2ee 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp
@@ -37,6 +37,7 @@
 #include "maemodeviceconfigurations.h"
 
 #include <coreplugin/ssh/sshconnection.h>
+#include <qt4projectmanager/qtversionmanager.h>
 #include <utils/environment.h>
 
 #include <QtCore/QCoreApplication>
@@ -107,17 +108,42 @@ QString MaemoGlobal::failedToConnectToServerMessage(const Core::SshConnection::P
     return errorMsg;
 }
 
-QString MaemoGlobal::maddeRoot(const QString &qmakePath)
+QString MaemoGlobal::maddeRoot(const QtVersion *qtVersion)
 {
-    QDir dir(QDir::cleanPath(qmakePath).remove(binQmake));
+    QDir dir(targetRoot(qtVersion));
     dir.cdUp(); dir.cdUp();
     return dir.absolutePath();
 }
 
-QString MaemoGlobal::targetName(const QString &qmakePath)
+QString MaemoGlobal::targetRoot(const QtVersion *qtVersion)
 {
-    const QString target = QDir::cleanPath(qmakePath).remove(binQmake);
-    return target.mid(target.lastIndexOf(QLatin1Char('/')) + 1);
+    return QDir::cleanPath(qtVersion->qmakeCommand()).remove(binQmake);
+}
+
+QString MaemoGlobal::targetName(const QtVersion *qtVersion)
+{
+    return QDir(targetRoot(qtVersion)).dirName();
+}
+
+QString MaemoGlobal::madAdminCommand(const QtVersion *qtVersion)
+{
+    return maddeRoot(qtVersion) + QLatin1String("/bin/mad-admin");
+}
+
+QString MaemoGlobal::madCommand(const QtVersion *qtVersion)
+{
+    return maddeRoot(qtVersion) + QLatin1String("/bin/mad");
+}
+
+MaemoGlobal::MaemoVersion MaemoGlobal::version(const QtVersion *qtVersion)
+{
+    const QString &name = targetName(qtVersion);
+    if (name.startsWith(QLatin1String("fremantle")))
+        return Maemo5;
+    if (name.startsWith(QLatin1String("harmattan")))
+        return Maemo6;
+    qWarning("Unknown Maemo version!");
+    return static_cast<MaemoVersion>(-1);
 }
 
 bool MaemoGlobal::removeRecursively(const QString &filePath, QString &error)
@@ -150,9 +176,25 @@ bool MaemoGlobal::removeRecursively(const QString &filePath, QString &error)
     return true;
 }
 
-void MaemoGlobal::callMaddeShellScript(QProcess &proc, const QString &maddeRoot,
+bool MaemoGlobal::callMad(QProcess &proc, const QStringList &args,
+    const QtVersion *qtVersion)
+{
+    return callMaddeShellScript(proc, maddeRoot(qtVersion),
+        madCommand(qtVersion), args);
+}
+
+bool MaemoGlobal::callMadAdmin(QProcess &proc, const QStringList &args,
+    const QtVersion *qtVersion)
+{
+    return callMaddeShellScript(proc, maddeRoot(qtVersion),
+        madAdminCommand(qtVersion), args);
+}
+
+bool MaemoGlobal::callMaddeShellScript(QProcess &proc, const QString &maddeRoot,
     const QString &command, const QStringList &args)
 {
+    if (!QFileInfo(command).exists())
+        return false;
     QString actualCommand = command;
     QStringList actualArgs = args;
 #ifdef Q_OS_WIN
@@ -167,6 +209,7 @@ void MaemoGlobal::callMaddeShellScript(QProcess &proc, const QString &maddeRoot,
     Q_UNUSED(maddeRoot);
 #endif
     proc.start(actualCommand, actualArgs);
+    return true;
 }
 
 } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h
index efa49d9585..c9484ed4ea 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h
@@ -54,12 +54,15 @@ QT_END_NAMESPACE
 namespace Core { class SshConnection; }
 
 namespace Qt4ProjectManager {
+class QtVersion;
 namespace Internal {
 class MaemoDeviceConfig;
 
 class MaemoGlobal
 {
 public:
+    enum MaemoVersion { Maemo5, Maemo6 };
+
     static QString homeDirOnDevice(const QString &uname);
     static QString remoteSudo();
     static QString remoteCommandPrefix(const QString &commandFilePath);
@@ -67,12 +70,22 @@ public:
     static QString remoteSourceProfilesCommand();
     static QString failedToConnectToServerMessage(const QSharedPointer<Core::SshConnection> &connection,
         const MaemoDeviceConfig &deviceConfig);
-    static QString maddeRoot(const QString &qmakePath);
-    static QString targetName(const QString &qmakePath);
+
+    static QString maddeRoot(const QtVersion *qtVersion);
+    static QString targetRoot(const QtVersion *qtVersion);
+    static QString targetName(const QtVersion *qtVersion);
+    static QString madCommand(const QtVersion *qtVersion);
+    static MaemoVersion version(const QtVersion *qtVersion);
+    static bool allowsRemoteMounts(const QtVersion *qtVersion) { return version(qtVersion) == Maemo5; }
+    static bool allowsPackagingDisabling(const QtVersion *qtVersion) { return version(qtVersion) == Maemo5; }
+    static bool allowsQmlDebugging(const QtVersion *qtVersion) { return version(qtVersion) == Maemo6; }
+
+    static bool callMad(QProcess &proc, const QStringList &args,
+        const QtVersion *qtVersion);
+    static bool callMadAdmin(QProcess &proc, const QStringList &args,
+        const QtVersion *qtVersion);
 
     static bool removeRecursively(const QString &filePath, QString &error);
-    static void callMaddeShellScript(QProcess &proc, const QString &maddeRoot,
-        const QString &command, const QStringList &args);
 
     template<class T> static T *buildStep(const ProjectExplorer::DeployConfiguration *dc)
     {
@@ -101,6 +114,11 @@ public:
                 actual, func);
         }
     }
+
+private:
+    static QString madAdminCommand(const QtVersion *qtVersion);
+    static bool callMaddeShellScript(QProcess &proc, const QString &maddeRoot,
+        const QString &command, const QStringList &args);
 };
 
 } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp
index ace6c27f0f..da681ad62e 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp
@@ -110,26 +110,18 @@ MaemoManager &MaemoManager::instance()
 
 bool MaemoManager::isValidMaemoQtVersion(const QtVersion *version) const
 {
-    QString path = QDir::cleanPath(version->qmakeCommand());
-    path.remove(QLatin1String("/bin/qmake" EXEC_SUFFIX));
-    QDir dir(path);
-    const QByteArray target = dir.dirName().toAscii();
-    dir.cdUp(); dir.cdUp();
-    const QString madAdminCommand(dir.absolutePath() + QLatin1String("/bin/mad-admin"));
-    if (!QFileInfo(madAdminCommand).exists())
-        return false;
-
     QProcess madAdminProc;
     const QStringList arguments(QLatin1String("list"));
-    MaemoGlobal::callMaddeShellScript(madAdminProc, dir.absolutePath(),
-        madAdminCommand, arguments);
+    if (!MaemoGlobal::callMadAdmin(madAdminProc, arguments, version))
+        return false;
     if (!madAdminProc.waitForStarted() || !madAdminProc.waitForFinished())
         return false;
 
     madAdminProc.setReadChannel(QProcess::StandardOutput);
+    const QByteArray targetName = MaemoGlobal::targetName(version).toAscii();
     while (madAdminProc.canReadLine()) {
         const QByteArray &line = madAdminProc.readLine();
-        if (line.contains(target)
+        if (line.contains(targetName)
             && (line.contains("(installed)") || line.contains("(default)")))
             return true;
     }
@@ -138,9 +130,7 @@ bool MaemoManager::isValidMaemoQtVersion(const QtVersion *version) const
 
 ToolChain* MaemoManager::maemoToolChain(const QtVersion *version) const
 {
-    QString targetRoot = QDir::cleanPath(version->qmakeCommand());
-    targetRoot.remove(QLatin1String("/bin/qmake" EXEC_SUFFIX));
-    return new MaemoToolChain(targetRoot);
+    return new MaemoToolChain(version);
 }
 
     } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp
index c2a67b0090..91327c97b9 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp
@@ -47,7 +47,6 @@
 #include "maemoglobal.h"
 #include "maemopackagecreationwidget.h"
 #include "maemotemplatesmanager.h"
-#include "maemotoolchain.h"
 
 #include <projectexplorer/buildsteplist.h>
 #include <projectexplorer/projectexplorerconstants.h>
@@ -172,16 +171,17 @@ bool MaemoPackageCreationStep::createPackage(QProcess *buildProc)
     if (!copyDebianFiles(inSourceBuild))
         return false;
 
-    const QString maddeRoot = maemoToolChain()->maddeRoot();
-    const QString madCommand = maddeRoot + QLatin1String("/bin/mad");
+    const QtVersion * const qtVersion = qt4BuildConfiguration()->qtVersion();
+    const QString madCommand = MaemoGlobal::madCommand(qtVersion);
     const QStringList args = QStringList() << QLatin1String("-t")
-        << maemoToolChain()->targetName() << QLatin1String("dpkg-buildpackage")
-        << QLatin1String("-nc") << QLatin1String("-uc") << QLatin1String("-us");
+        << MaemoGlobal::targetName(qtVersion)
+        << QLatin1String("dpkg-buildpackage") << QLatin1String("-nc")
+        << QLatin1String("-uc") << QLatin1String("-us");
     const QString cmdLine = madCommand + QLatin1Char(' ')
         + args.join(QLatin1String(" "));
     emit addOutput(tr("Package Creation: Running command '%1'.").arg(cmdLine),
         BuildStep::MessageOutput);
-    MaemoGlobal::callMaddeShellScript(*buildProc, maddeRoot, madCommand, args);
+    MaemoGlobal::callMad(*buildProc, args, qtVersion);
     if (!buildProc->waitForStarted()) {
         raiseError(tr("Packaging failed."),
             tr("Packaging error: Could not start command '%1'. Reason: %2")
@@ -233,7 +233,7 @@ bool MaemoPackageCreationStep::createPackage(QProcess *buildProc)
     emit addOutput(tr("Package created."), BuildStep::MessageOutput);
     deployStep()->deployables()->setUnmodified();
     if (inSourceBuild) {
-        buildProc->start(packagingCommand(maemoToolChain(),
+        buildProc->start(packagingCommand(qt4BuildConfiguration(),
             QLatin1String("dh_clean")));
         buildProc->waitForFinished();
         buildProc->terminate();
@@ -341,11 +341,6 @@ QString MaemoPackageCreationStep::projectName() const
         ->rootProjectNode()->displayName().toLower();
 }
 
-const MaemoToolChain *MaemoPackageCreationStep::maemoToolChain() const
-{
-    return static_cast<MaemoToolChain *>(qt4BuildConfiguration()->toolChain());
-}
-
 MaemoDeployStep *MaemoPackageCreationStep::deployStep() const
 {
     MaemoDeployStep * const deployStep
@@ -355,16 +350,6 @@ MaemoDeployStep *MaemoPackageCreationStep::deployStep() const
     return deployStep;
 }
 
-QString MaemoPackageCreationStep::maddeRoot() const
-{
-    return maemoToolChain()->maddeRoot();
-}
-
-QString MaemoPackageCreationStep::targetRoot() const
-{
-    return maemoToolChain()->targetRoot();
-}
-
 bool MaemoPackageCreationStep::packagingNeeded() const
 {
     const QSharedPointer<MaemoDeployables> &deployables
@@ -427,7 +412,8 @@ QString MaemoPackageCreationStep::packageFilePath() const
 
 bool MaemoPackageCreationStep::isPackagingEnabled() const
 {
-    return m_packagingEnabled || !maemoToolChain()->allowsPackagingDisabling();
+    return m_packagingEnabled
+        || !MaemoGlobal::allowsPackagingDisabling(qt4BuildConfiguration()->qtVersion());
 }
 
 QString MaemoPackageCreationStep::versionString(QString *error) const
@@ -463,13 +449,8 @@ void MaemoPackageCreationStep::raiseError(const QString &shortMsg,
 bool MaemoPackageCreationStep::preparePackagingProcess(QProcess *proc,
     const Qt4BuildConfiguration *bc, const QString &workingDir, QString *error)
 {
-    const MaemoToolChain * const tc
-        = dynamic_cast<const MaemoToolChain *>(bc->toolChain());
-    if (!tc) {
-        *error = tr("Build configuration has no Maemo toolchain.");
-        return false;
-    }
-    QFile configFile(tc->targetRoot() % QLatin1String("/config.sh"));
+    const QString targetRoot = MaemoGlobal::targetRoot(bc->qtVersion());
+    QFile configFile(targetRoot % QLatin1String("/config.sh"));
     if (!configFile.open(QIODevice::ReadOnly)) {
         *error = tr("Cannot open MADDE config file '%1'.")
             .arg(nativePath(configFile));
@@ -478,11 +459,12 @@ bool MaemoPackageCreationStep::preparePackagingProcess(QProcess *proc,
 
     Utils::Environment env = bc->environment();
     const QString &path
-        = QDir::toNativeSeparators(tc->maddeRoot() + QLatin1Char('/'));
+        = QDir::toNativeSeparators(MaemoGlobal::maddeRoot(bc->qtVersion())
+              + QLatin1Char('/'));
 #ifdef Q_OS_WIN
     env.prependOrSetPath(path % QLatin1String("bin"));
 #endif
-    env.prependOrSetPath(tc->targetRoot() % QLatin1String("/bin"));
+    env.prependOrSetPath(targetRoot % QLatin1String("/bin"));
     env.prependOrSetPath(path % QLatin1String("madbin"));
 
     if (bc->qmakeBuildConfiguration() & QtVersion::DebugBuild) {
@@ -512,14 +494,15 @@ bool MaemoPackageCreationStep::preparePackagingProcess(QProcess *proc,
     return true;
 }
 
-QString MaemoPackageCreationStep::packagingCommand(const MaemoToolChain *tc,
+QString MaemoPackageCreationStep::packagingCommand(const Qt4BuildConfiguration *bc,
     const QString &commandName)
 {
     QString perl;
 #ifdef Q_OS_WIN
     perl = tc->maddeRoot() + QLatin1String("/bin/perl.exe ");
 #endif
-    return perl + tc->maddeRoot() % QLatin1String("/madbin/") % commandName;
+    return perl + MaemoGlobal::maddeRoot(bc->qtVersion())
+        % QLatin1String("/madbin/") % commandName;
 }
 
 void MaemoPackageCreationStep::checkProjectName()
@@ -571,7 +554,9 @@ void MaemoPackageCreationStep::updateDesktopFiles(const QString &rulesFilePath)
     QString desktopFileDir = QFileInfo(rulesFile).dir().path()
         + QLatin1Char('/') + projectName()
         + QLatin1String("/usr/share/applications/");
-    if (maemoToolChain()->version() == MaemoToolChain::Maemo5)
+    const MaemoGlobal::MaemoVersion version
+        = MaemoGlobal::version(qt4BuildConfiguration()->qtVersion());
+    if (version == MaemoGlobal::Maemo5)
         desktopFileDir += QLatin1String("hildon/");
 #ifdef Q_OS_WIN
     desktopFileDir.remove(QLatin1Char(':'));
@@ -583,7 +568,7 @@ void MaemoPackageCreationStep::updateDesktopFiles(const QString &rulesFilePath)
             = deployStep()->deployables()->modelAt(i);
         if (!model->hasDesktopFile())
             continue;
-        if (maemoToolChain()->version() == MaemoToolChain::Maemo6) {
+        if (version == MaemoGlobal::Maemo6) {
             addWorkaroundForHarmattanBug(content, insertPos,
                 model, desktopFileDir);
         }
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.h b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.h
index 79c9529000..941a996805 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.h
@@ -56,8 +56,6 @@ class Qt4BuildConfiguration;
 namespace Internal {
 class MaemoDeployStep;
 class MaemoDeployableListModel;
-class MaemoToolChain;
-class MaemoProFileWrapper;
 
 class MaemoPackageCreationStep : public ProjectExplorer::BuildStep
 {
@@ -74,18 +72,17 @@ public:
     QString versionString(QString *error) const;
     bool setVersionString(const QString &version, QString *error);
 
-    const MaemoToolChain *maemoToolChain() const;
-
     static bool preparePackagingProcess(QProcess *proc,
         const Qt4BuildConfiguration *bc, const QString &workingDir,
         QString *error);
-    static QString packagingCommand(const MaemoToolChain *tc,
+    static QString packagingCommand(const Qt4BuildConfiguration *bc,
         const QString &commandName);
     static QString packageName(const ProjectExplorer::Project *project);
     static QString packageFileName(const ProjectExplorer::Project *project,
         const QString &version);
 
     QString projectName() const;
+    const Qt4BuildConfiguration *qt4BuildConfiguration() const;
 
     static const QLatin1String DefaultVersionNumber;
 
@@ -111,8 +108,6 @@ private:
 
     bool createPackage(QProcess *buildProc);
     bool copyDebianFiles(bool inSourceBuild);
-    QString maddeRoot() const;
-    QString targetRoot() const;
     static QString nativePath(const QFile &file);
     bool packagingNeeded() const;
     bool isFileNewerThan(const QString &filePath,
@@ -120,7 +115,6 @@ private:
     void raiseError(const QString &shortMsg,
                     const QString &detailedMsg = QString());
     QString buildDirectory() const;
-    const Qt4BuildConfiguration *qt4BuildConfiguration() const;
     MaemoDeployStep * deployStep() const;
     void checkProjectName();
     void updateDesktopFiles(const QString &rulesFilePath);
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationwidget.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationwidget.cpp
index 43e630da7a..5ce4ee2234 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationwidget.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationwidget.cpp
@@ -42,9 +42,9 @@
 #include "maemopackagecreationwidget.h"
 #include "ui_maemopackagecreationwidget.h"
 
+#include "maemoglobal.h"
 #include "maemopackagecreationstep.h"
 #include "maemotemplatesmanager.h"
-#include "maemotoolchain.h"
 
 #include <coreplugin/editormanager/editormanager.h>
 #include <projectexplorer/project.h>
@@ -209,10 +209,11 @@ void MaemoPackageCreationWidget::setShortDescription()
 
 void MaemoPackageCreationWidget::handleToolchainChanged()
 {
-    if (!m_step->maemoToolChain())
+    const Qt4BuildConfiguration * const bc = m_step->qt4BuildConfiguration();
+    if (!bc)
         return;
-    m_ui->skipCheckBox
-        ->setVisible(m_step->maemoToolChain()->allowsPackagingDisabling());
+    m_ui->skipCheckBox->setVisible(MaemoGlobal::allowsPackagingDisabling(
+        bc->qtVersion()));
     m_ui->skipCheckBox->setChecked(!m_step->isPackagingEnabled());
     emit updateSummary();
 }
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp
index 2f40b73ee6..3ea8f2d49a 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp
@@ -38,7 +38,6 @@
 #include "maemopackagecreationstep.h"
 #include "maemopublishingfileselectiondialog.h"
 #include "maemotemplatesmanager.h"
-#include "maemotoolchain.h"
 
 #include <coreplugin/ifile.h>
 #include <projectexplorer/project.h>
@@ -364,13 +363,11 @@ void MaemoPublisherFremantleFree::runDpkgBuildPackage()
         return;
     setState(BuildingPackage);
     emit progressReport(tr("Building source package..."));
-    const MaemoToolChain * const tc
-        = dynamic_cast<MaemoToolChain *>(m_buildConfig->toolChain());
     const QStringList args = QStringList() << QLatin1String("-t")
-        << tc->targetName() << QLatin1String("dpkg-buildpackage")
-        << QLatin1String("-S") << QLatin1String("-us") << QLatin1String("-uc");
-    const QString madCommand = tc->maddeRoot() + QLatin1String("/bin/mad");
-    MaemoGlobal::callMaddeShellScript(*m_process, tc->maddeRoot(), madCommand, args);
+        << MaemoGlobal::targetName(m_buildConfig->qtVersion())
+        << QLatin1String("dpkg-buildpackage") << QLatin1String("-S")
+        << QLatin1String("-us") << QLatin1String("-uc");
+    MaemoGlobal::callMad(*m_process, args, m_buildConfig->qtVersion());
 }
 
 // We have to implement the SCP protocol, because the maemo.org
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingbuildsettingspagefremantlefree.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingbuildsettingspagefremantlefree.cpp
index 64d605ba26..ded215cba2 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingbuildsettingspagefremantlefree.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingbuildsettingspagefremantlefree.cpp
@@ -33,8 +33,8 @@
 #include "maemopublishingbuildsettingspagefremantlefree.h"
 #include "ui_maemopublishingbuildsettingspagefremantlefree.h"
 
+#include "maemoglobal.h"
 #include "maemopublisherfremantlefree.h"
-#include "maemotoolchain.h"
 
 #include <projectexplorer/project.h>
 #include <projectexplorer/target.h>
@@ -80,11 +80,7 @@ void MaemoPublishingBuildSettingsPageFremantleFree::collectBuildConfigurations(c
                 = qobject_cast<Qt4BuildConfiguration *>(bc);
             if (!qt4Bc)
                 continue;
-            const MaemoToolChain * const tc
-                = dynamic_cast<MaemoToolChain *>(qt4Bc->toolChain());
-            if (!tc)
-                continue;
-            if (tc->version() == MaemoToolChain::Maemo5)
+            if (MaemoGlobal::version(qt4Bc->qtVersion()) == MaemoGlobal::Maemo5)
                 m_buildConfigs << qt4Bc;
         }
         break;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp
index b111714f04..4ce00c180b 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp
@@ -32,8 +32,8 @@
 **************************************************************************/
 #include "maemopublishingwizardfactories.h"
 
+#include "maemoglobal.h"
 #include "maemopublishingwizardfremantlefree.h"
-#include "maemotoolchain.h"
 
 #include <projectexplorer/target.h>
 #include <qt4projectmanager/qmakestep.h>
@@ -77,11 +77,7 @@ bool MaemoPublishingWizardFactoryFremantleFree::canCreateWizard(const Project *p
                 = qobject_cast<const Qt4BuildConfiguration *>(bc);
             if (!qt4Bc)
                 continue;
-            const MaemoToolChain * const tc
-                = dynamic_cast<MaemoToolChain *>(qt4Bc->toolChain());
-            if (!tc)
-                continue;
-            if (tc->version() == MaemoToolChain::Maemo5)
+            if (MaemoGlobal::version(qt4Bc->qtVersion()) == MaemoGlobal::Maemo5)
                 return true;
         }
         break;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp
index e2f93e1549..3afa3a5baa 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp
@@ -38,7 +38,6 @@
 #include "maemoqemuruntimeparser.h"
 #include "maemosettingspages.h"
 #include "maemorunconfiguration.h"
-#include "maemotoolchain.h"
 #include "qtversionmanager.h"
 #include "qt4project.h"
 #include "qt4projectmanagerconstants.h"
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp
index cc3a35e288..8b9e732f39 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp
@@ -92,19 +92,14 @@ MaemoQemuRuntimeParser::MaemoQemuRuntimeParser(const QString &madInfoOutput,
 MaemoQemuRuntime MaemoQemuRuntimeParser::parseRuntime(const QtVersion *qtVersion)
 {
     MaemoQemuRuntime runtime;
-    const QString maddeRootPath
-        = MaemoGlobal::maddeRoot(qtVersion->qmakeCommand());
-    const QString madCommand = maddeRootPath + QLatin1String("/bin/mad");
-    if (!QFileInfo(madCommand).exists())
-        return runtime;
+    const QString maddeRootPath = MaemoGlobal::maddeRoot(qtVersion);
     QProcess madProc;
-    MaemoGlobal::callMaddeShellScript(madProc, maddeRootPath, madCommand,
-        QStringList() << QLatin1String("info"));
+    if (!MaemoGlobal::callMad(madProc, QStringList() << QLatin1String("info"), qtVersion))
+        return runtime;
     if (!madProc.waitForStarted() || !madProc.waitForFinished())
         return runtime;
     const QByteArray &madInfoOutput = madProc.readAllStandardOutput();
-    const QString &targetName
-        = MaemoGlobal::targetName(qtVersion->qmakeCommand());
+    const QString &targetName = MaemoGlobal::targetName(qtVersion);
     runtime = MaemoQemuRuntimeParserV2(madInfoOutput, targetName, maddeRootPath)
         .parseRuntime();
     if (!runtime.m_name.isEmpty()) {
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp
index e2bb2b03e4..f1d3502ae0 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp
@@ -34,12 +34,12 @@
 #include "maemoremotemounter.h"
 
 #include "maemoglobal.h"
-#include "maemotoolchain.h"
 #include "maemousedportsgatherer.h"
 
 #include <coreplugin/ssh/sftpchannel.h>
 #include <coreplugin/ssh/sshconnection.h>
 #include <coreplugin/ssh/sshremoteprocess.h>
+#include <qt4projectmanager/qt4buildconfiguration.h>
 #include <utils/qtcassert.h>
 
 #include <QtCore/QTimer>
@@ -70,11 +70,12 @@ void MaemoRemoteMounter::setConnection(const SshConnection::Ptr &connection)
     m_connection = connection;
 }
 
-void MaemoRemoteMounter::setToolchain(const MaemoToolChain *toolChain)
+void MaemoRemoteMounter::setBuildConfiguration(const Qt4BuildConfiguration *bc)
 {
     ASSERT_STATE(Inactive);
-    m_remoteMountsAllowed = toolChain->allowsRemoteMounts();
-    m_maddeRoot = toolChain->maddeRoot();
+    const QtVersion * const qtVersion = bc->qtVersion();
+    m_remoteMountsAllowed = MaemoGlobal::allowsRemoteMounts(qtVersion);
+    m_maddeRoot = MaemoGlobal::maddeRoot(qtVersion);
 }
 
 void MaemoRemoteMounter::addMountSpecification(const MaemoMountSpecification &mountSpec,
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.h b/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.h
index b62dff9c87..e3ac5e3649 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.h
@@ -54,8 +54,8 @@ class SshRemoteProcess;
 }
 
 namespace Qt4ProjectManager {
+class Qt4BuildConfiguration;
 namespace Internal {
-class MaemoToolChain;
 class MaemoUsedPortsGatherer;
 
 class MaemoRemoteMounter : public QObject
@@ -68,7 +68,7 @@ public:
     // Must already be connected.
     void setConnection(const QSharedPointer<Core::SshConnection> &connection);
 
-    void setToolchain(const MaemoToolChain *toolChain);
+    void setBuildConfiguration(const Qt4BuildConfiguration *bc);
     void addMountSpecification(const MaemoMountSpecification &mountSpec,
         bool mountAsRoot);
     bool hasValidMountSpecifications() const;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp
index e8b8043b12..48963be250 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp
@@ -227,9 +227,7 @@ const MaemoToolChain *MaemoRunConfiguration::toolchain() const
 
 const QString MaemoRunConfiguration::gdbCmd() const
 {
-    if (const MaemoToolChain *tc = toolchain())
-        return QDir::toNativeSeparators(tc->targetRoot() + QLatin1String("/bin/gdb"));
-    return QString();
+    return QDir::toNativeSeparators(targetRoot() + QLatin1String("/bin/gdb"));
 }
 
 MaemoDeployStep *MaemoRunConfiguration::deployStep() const
@@ -241,13 +239,6 @@ MaemoDeployStep *MaemoRunConfiguration::deployStep() const
     return step;
 }
 
-QString MaemoRunConfiguration::maddeRoot() const
-{
-    if (const MaemoToolChain *tc = toolchain())
-        return tc->maddeRoot();
-    return QString();
-}
-
 const QString MaemoRunConfiguration::sysRoot() const
 {
     if (const MaemoToolChain *tc = toolchain())
@@ -257,9 +248,8 @@ const QString MaemoRunConfiguration::sysRoot() const
 
 const QString MaemoRunConfiguration::targetRoot() const
 {
-    if (const MaemoToolChain *tc = toolchain())
-        return tc->targetRoot();
-    return QString();
+    QTC_ASSERT(activeQt4BuildConfiguration(), return QString());
+    return MaemoGlobal::targetRoot(activeQt4BuildConfiguration()->qtVersion());
 }
 
 const QString MaemoRunConfiguration::arguments() const
@@ -331,7 +321,8 @@ MaemoPortList MaemoRunConfiguration::freePorts() const
 
 bool MaemoRunConfiguration::useRemoteGdb() const
 {
-    return m_useRemoteGdb && toolchain()->allowsRemoteMounts();
+    return m_useRemoteGdb
+        && MaemoGlobal::allowsRemoteMounts(activeQt4BuildConfiguration()->qtVersion());
 }
 
 void MaemoRunConfiguration::setArguments(const QString &args)
@@ -341,7 +332,7 @@ void MaemoRunConfiguration::setArguments(const QString &args)
 
 MaemoRunConfiguration::DebuggingType MaemoRunConfiguration::debuggingType() const
 {
-    if (!toolchain() || !toolchain()->allowsQmlDebugging())
+    if (!MaemoGlobal::allowsQmlDebugging(activeQt4BuildConfiguration()->qtVersion()))
         return DebugCppOnly;
     if (useCppDebugger()) {
         if (useQmlDebugger())
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.h b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.h
index 491f6c180a..d3391ef2af 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.h
@@ -91,7 +91,6 @@ public:
     MaemoRemoteMountsModel *remoteMounts() const { return m_remoteMounts; }
 
     const MaemoToolChain *toolchain() const;
-    QString maddeRoot() const;
     QString localExecutableFilePath() const;
     QString remoteExecutableFilePath() const;
     const QString sysRoot() const;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfigurationwidget.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfigurationwidget.cpp
index da20acae0b..641ac6a652 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfigurationwidget.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfigurationwidget.cpp
@@ -39,10 +39,10 @@
 #include "maemodeviceconfiglistmodel.h"
 #include "maemodeviceenvreader.h"
 #include "maemomanager.h"
+#include "maemoglobal.h"
 #include "maemoremotemountsmodel.h"
 #include "maemorunconfiguration.h"
 #include "maemosettingspages.h"
-#include "maemotoolchain.h"
 
 #include <coreplugin/coreconstants.h>
 #include <coreplugin/icore.h>
@@ -322,12 +322,16 @@ void MaemoRunConfigurationWidget::handleBuildConfigChanged()
 
 void MaemoRunConfigurationWidget::handleToolchainChanged()
 {
-    const MaemoToolChain * const toolChain = m_runConfiguration->toolchain();
-    if (toolChain) {
-        const bool remoteMountsAvailable = toolChain->allowsRemoteMounts();
+    const Qt4BuildConfiguration * const bc
+        = m_runConfiguration->activeQt4BuildConfiguration();
+    if (bc) {
+        const QtVersion * const qtVersion = bc->qtVersion();
+        const bool remoteMountsAvailable
+            = MaemoGlobal::allowsRemoteMounts(qtVersion);
         m_debugDetailsContainer->setVisible(remoteMountsAvailable);
         m_mountDetailsContainer->setVisible(remoteMountsAvailable);
-        const bool qmlDebuggingAvailable = toolChain->allowsQmlDebugging();
+        const bool qmlDebuggingAvailable
+            = MaemoGlobal::allowsQmlDebugging(qtVersion);
         m_debuggingLanguagesLabel->setVisible(qmlDebuggingAvailable);
         m_debugCppOnlyButton->setVisible(qmlDebuggingAvailable);
         m_debugQmlOnlyButton->setVisible(qmlDebuggingAvailable);
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemorunfactories.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemorunfactories.cpp
index e5f67c5eaf..c61dc72a4d 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemorunfactories.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemorunfactories.cpp
@@ -36,10 +36,10 @@
 
 #include "maemoconstants.h"
 #include "maemodebugsupport.h"
+#include "maemoglobal.h"
 #include "maemoremotemountsmodel.h"
 #include "maemorunconfiguration.h"
 #include "maemoruncontrol.h"
-#include "maemotoolchain.h"
 
 #include <projectexplorer/projectexplorerconstants.h>
 #include <debugger/debuggerconstants.h>
@@ -169,10 +169,13 @@ bool MaemoRunControlFactory::canRun(RunConfiguration *runConfiguration,
         return false;
     const int freePortCount = maemoRunConfig->freePorts().count();
 
-    if (maemoRunConfig->toolchain()->allowsRemoteMounts() && freePortCount == 0)
+    const QtVersion * const qtVersion
+        = maemoRunConfig->activeQt4BuildConfiguration()->qtVersion();
+    const bool remoteMountsAllowed = MaemoGlobal::allowsRemoteMounts(qtVersion);
+    if (remoteMountsAllowed && freePortCount == 0)
         return false;
     const int mountDirCount
-        = maemoRunConfig->toolchain()->allowsRemoteMounts()
+        = remoteMountsAllowed
             ? maemoRunConfig->remoteMounts()->validMountSpecificationCount()
             : 0;
     if (mode == Debugger::Constants::DEBUGMODE)
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemosshrunner.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemosshrunner.cpp
index 8e4e0fca97..7eb9f14393 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemosshrunner.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemosshrunner.cpp
@@ -70,7 +70,7 @@ MaemoSshRunner::MaemoSshRunner(QObject *parent,
       m_state(Inactive)
 {
     m_connection = runConfig->deployStep()->sshConnection();
-    m_mounter->setToolchain(runConfig->toolchain());
+    m_mounter->setBuildConfiguration(runConfig->activeQt4BuildConfiguration());
     if (debugging && runConfig->useRemoteGdb()) {
         m_mountSpecs << MaemoMountSpecification(runConfig->localDirToMountForRemoteGdb(),
             runConfig->remoteProjectSourcesMountPoint());
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemotemplatesmanager.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemotemplatesmanager.cpp
index ea0893c26f..a18fa7cdc2 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemotemplatesmanager.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemotemplatesmanager.cpp
@@ -38,7 +38,6 @@
 #include "maemodeploystep.h"
 #include "maemoglobal.h"
 #include "maemopackagecreationstep.h"
-#include "maemotoolchain.h"
 
 #include <projectexplorer/project.h>
 #include <projectexplorer/projectexplorer.h>
@@ -163,12 +162,6 @@ bool MaemoTemplatesManager::createDebianTemplatesIfNecessary(const ProjectExplor
     Q_ASSERT_X(qt4Target, Q_FUNC_INFO, "Target ID does not match actual type.");
     const Qt4BuildConfiguration * const bc
         = qt4Target->activeBuildConfiguration();
-    const MaemoToolChain * const tc
-        = dynamic_cast<MaemoToolChain *>(bc->toolChain());
-    if (!tc) {
-        qDebug("Maemo target has no Maemo toolchain.");
-        return false;
-    }
     if (!MaemoPackageCreationStep::preparePackagingProcess(&dh_makeProc, bc,
         projectDir.path() + QLatin1Char('/') + PackagingDirName, &error)) {
         raiseError(error);
@@ -182,7 +175,7 @@ bool MaemoTemplatesManager::createDebianTemplatesIfNecessary(const ProjectExplor
     const QString command = QLatin1String("dh_make -s -n -p ")
         + MaemoPackageCreationStep::packageName(project) + QLatin1Char('_')
         + MaemoPackageCreationStep::DefaultVersionNumber;
-    dh_makeProc.start(MaemoPackageCreationStep::packagingCommand(tc, command));
+    dh_makeProc.start(MaemoPackageCreationStep::packagingCommand(bc, command));
     if (!dh_makeProc.waitForStarted()) {
         raiseError(tr("Unable to create Debian templates: dh_make failed (%1)")
             .arg(dh_makeProc.errorString()));
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp
index 2e700e9b33..8950db2107 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp
@@ -32,20 +32,23 @@
 **************************************************************************/
 
 #include "maemotoolchain.h"
+
 #include "maemoconstants.h"
+#include "maemoglobal.h"
 
 #include <QtCore/QDir>
 #include <QtCore/QStringBuilder>
 #include <QtCore/QTextStream>
 
 using namespace ProjectExplorer;
-using namespace Qt4ProjectManager::Internal;
 
-MaemoToolChain::MaemoToolChain(const QString &targetRoot)
-    : GccToolChain(targetRoot % QLatin1String("/bin/gcc"))
-    , m_maddeInitialized(false)
+namespace Qt4ProjectManager {
+namespace Internal {
+
+MaemoToolChain::MaemoToolChain(const QtVersion *qtVersion)
+    : GccToolChain(MaemoGlobal::targetRoot(qtVersion) % QLatin1String("/bin/gcc"))
     , m_sysrootInitialized(false)
-    , m_targetRoot(targetRoot)
+    , m_qtVersion(qtVersion)
 {
 }
 
@@ -60,19 +63,20 @@ ProjectExplorer::ToolChainType MaemoToolChain::type() const
 
 void MaemoToolChain::addToEnvironment(Utils::Environment &env)
 {
+    const QString maddeRoot = MaemoGlobal::maddeRoot(m_qtVersion);
     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/bin")
-        .arg(maddeRoot())));
+        .arg(maddeRoot)));
     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/bin")
-        .arg(targetRoot())));
+        .arg(MaemoGlobal::targetRoot(m_qtVersion))));
 
     // put this into environment to make pkg-config stuff work
     env.prependOrSet(QLatin1String("SYSROOT_DIR"), sysrootRoot());
     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/madbin")
-        .arg(maddeRoot())));
+        .arg(maddeRoot)));
     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/madlib")
-        .arg(maddeRoot())));
+        .arg(maddeRoot)));
     env.prependOrSet(QLatin1String("PERL5LIB"),
-        QDir::toNativeSeparators(QString("%1/madlib/perl5").arg(maddeRoot())));
+        QDir::toNativeSeparators(QString("%1/madlib/perl5").arg(maddeRoot)));
 }
 
 QString MaemoToolChain::makeCommand() const
@@ -83,31 +87,7 @@ QString MaemoToolChain::makeCommand() const
 bool MaemoToolChain::equals(const ToolChain *other) const
 {
     const MaemoToolChain *toolChain = static_cast<const MaemoToolChain*> (other);
-    return other->type() == type()
-        && toolChain->sysrootRoot() == sysrootRoot()
-        && toolChain->targetRoot() == targetRoot();
-}
-
-QString MaemoToolChain::maddeRoot() const
-{
-    if (!m_maddeInitialized)
-        setMaddeRoot();
-    return m_maddeRoot;
-}
-
-QString MaemoToolChain::madAdminCommand() const
-{
-    return maddeRoot() + QLatin1String("/bin/mad-admin");
-}
-
-QString MaemoToolChain::targetRoot() const
-{
-    return m_targetRoot;
-}
-
-QString MaemoToolChain::targetName() const
-{
-    return QDir(targetRoot()).dirName();
+    return other->type() == type() && toolChain->m_qtVersion == m_qtVersion;
 }
 
 QString MaemoToolChain::sysrootRoot() const
@@ -117,29 +97,10 @@ QString MaemoToolChain::sysrootRoot() const
     return m_sysrootRoot;
 }
 
-MaemoToolChain::MaemoVersion MaemoToolChain::version() const
-{
-    const QString &name = targetName();
-    if (name.startsWith(QLatin1String("fremantle")))
-        return Maemo5;
-    if (name.startsWith(QLatin1String("harmattan")))
-        return Maemo6;
-    qWarning("Unknown Maemo version!");
-    return static_cast<MaemoVersion>(-1);
-}
-
-void MaemoToolChain::setMaddeRoot() const
-{
-    QDir dir(targetRoot());
-    dir.cdUp(); dir.cdUp();
-
-    m_maddeInitialized = true;
-    m_maddeRoot = dir.absolutePath();
-}
-
 void MaemoToolChain::setSysroot() const
 {
-    QFile file(QDir::cleanPath(targetRoot()) + QLatin1String("/information"));
+    QFile file(QDir::cleanPath(MaemoGlobal::targetRoot(m_qtVersion))
+        + QLatin1String("/information"));
     if (file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         QTextStream stream(&file);
         while (!stream.atEnd()) {
@@ -148,11 +109,14 @@ void MaemoToolChain::setSysroot() const
             if (list.count() <= 1)
                 continue;
             if (list.at(0) == QLatin1String("sysroot")) {
-                m_sysrootRoot = maddeRoot() + QLatin1String("/sysroots/")
-                    + list.at(1);
+                m_sysrootRoot = MaemoGlobal::maddeRoot(m_qtVersion)
+                    + QLatin1String("/sysroots/") + list.at(1);
             }
         }
     }
 
     m_sysrootInitialized = true;
 }
+
+} // namespace Internal
+} // namespace Qt4ProjectManager
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h
index 3627925b05..e8e149a6af 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h
@@ -37,49 +37,34 @@
 #include <projectexplorer/toolchain.h>
 
 namespace Qt4ProjectManager {
-    class QtVersion;
-    namespace Internal {
+class QtVersion;
+namespace Internal {
 
 class MaemoToolChain : public ProjectExplorer::GccToolChain
 {
 public:
-    MaemoToolChain(const QString &targetRoot);
+    MaemoToolChain(const QtVersion *qtVersion);
     virtual ~MaemoToolChain();
 
     void addToEnvironment(Utils::Environment &env);
     ProjectExplorer::ToolChainType type() const;
     QString makeCommand() const;
 
-    QString maddeRoot() const;
-    QString targetRoot() const;
-    QString targetName() const;
     QString sysrootRoot() const;
-    QString madAdminCommand() const;
-
-    enum MaemoVersion { Maemo5, Maemo6 };
-    MaemoVersion version() const;
-    bool allowsRemoteMounts() const { return version() == Maemo5; }
-    bool allowsPackagingDisabling() const { return version() == Maemo5; }
-    bool allowsQmlDebugging() const { return version() == Maemo6; }
 
 protected:
     bool equals(const ToolChain *other) const;
 
 private:
-    void setMaddeRoot() const;
     void setSysroot() const;
 
 private:
-    mutable QString m_maddeRoot;
-    mutable bool m_maddeInitialized;
-
     mutable QString m_sysrootRoot;
     mutable bool m_sysrootInitialized;
-
-    const QString m_targetRoot;
+    const QtVersion * const m_qtVersion;
 };
 
-    } // namespace Internal
+} // namespace Internal
 } // namespace Qt4ProjectManager
 
 #endif // MAEMOTOOLCHAIN_H