Qt Version refactoring

Split up target specific code into subclasses. Also change
Qt4BuildConfiguration to allow a null qtversion.

Remove code that relied on always having a qt version.
Also make it possible to remove all qt versions.

Completly change the qt in path autodetection to be only
a fall back if no configuration was found.

Note: For now the old settings are not removed, as such 2.2 and master
can coexist.

Reviewed-By: hunger

28 files changed, 552 insertions, 138 deletions

diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodebugsupport.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemodebugsupport.cpp
index 5ea7f4732c..fb885f3bd1 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodebugsupport.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodebugsupport.cpp
@@ -68,7 +68,8 @@ RunControl *MaemoDebugSupport::createDebugRunControl(MaemoRunConfiguration *runC
     }
     if (debuggingType != MaemoRunConfiguration::DebugQmlOnly) {
         params.processArgs = runConfig->arguments();
-        params.sysRoot = runConfig->activeQt4BuildConfiguration()->qtVersion()->systemRoot();
+        if (runConfig->activeQt4BuildConfiguration()->qtVersion())
+            params.sysRoot = runConfig->activeQt4BuildConfiguration()->qtVersion()->systemRoot();
         params.toolChainAbi = runConfig->abi();
         if (runConfig->useRemoteGdb()) {
             params.startMode = StartRemoteGdb;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp
index 2e5fe20c6d..9ea292f176 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.cpp
@@ -41,6 +41,7 @@
 #include <projectexplorer/session.h>
 #include <qt4projectmanager/qt4buildconfiguration.h>
 #include <qt4projectmanager/qt4target.h>
+#include <qt4projectmanager/baseqtversion.h>
 
 #include <utils/qtcassert.h>
 #include <utils/fileutils.h>
@@ -244,10 +245,10 @@ bool MaemoDeployableListModel::addDesktopFile()
             return false;
     }
 
-    const QtVersion * const version = qtVersion();
+    const BaseQtVersion * const version = qtVersion();
     QTC_ASSERT(version, return false);
     QString remoteDir = QLatin1String("/usr/share/applications");
-    if (MaemoGlobal::version(version) == MaemoDeviceConfig::Maemo5)
+    if (MaemoGlobal::version(version->qmakeCommand()) == MaemoDeviceConfig::Maemo5)
         remoteDir += QLatin1String("/hildon");
     const QLatin1String filesLine("desktopfile.files = $${TARGET}.desktop");
     const QString pathLine = QLatin1String("desktopfile.path = ") + remoteDir;
@@ -311,7 +312,7 @@ bool MaemoDeployableListModel::addLinesToProFile(const QStringList &lines)
     return saver.finalize(Core::ICore::instance()->mainWindow());
 }
 
-const QtVersion *MaemoDeployableListModel::qtVersion() const
+const BaseQtVersion *MaemoDeployableListModel::qtVersion() const
 {
     const ProjectExplorer::Project *const activeProject
         = ProjectExplorer::ProjectExplorerPlugin::instance()->session()->startupProject();
@@ -327,9 +328,9 @@ const QtVersion *MaemoDeployableListModel::qtVersion() const
 
 QString MaemoDeployableListModel::proFileScope() const
 {
-    const QtVersion *const qv = qtVersion();
+    const BaseQtVersion *const qv = qtVersion();
     QTC_ASSERT(qv, return QString());
-    return QLatin1String(MaemoGlobal::version(qv) == MaemoDeviceConfig::Maemo5
+    return QLatin1String(MaemoGlobal::version(qv->qmakeCommand()) == MaemoDeviceConfig::Maemo5
         ? "maemo5" : "unix:!symbian:!maemo5");
 }
 
@@ -340,10 +341,10 @@ QString MaemoDeployableListModel::installPrefix() const
 
 QString MaemoDeployableListModel::remoteIconDir() const
 {
-    const QtVersion *const qv = qtVersion();
+    const BaseQtVersion *const qv = qtVersion();
     QTC_ASSERT(qv, return QString());
     return QString::fromLocal8Bit("/usr/share/icons/hicolor/%1x%1/apps")
-        .arg(MaemoGlobal::applicationIconSize(MaemoGlobal::version(qv)));
+            .arg(MaemoGlobal::applicationIconSize(MaemoGlobal::version(qv->qmakeCommand())));
 }
 
 } // namespace Qt4ProjectManager
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h
index 086bec5316..8d04026e77 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodeployablelistmodel.h
@@ -44,7 +44,7 @@
 #include <QtCore/QString>
 
 namespace Qt4ProjectManager {
-class QtVersion;
+class BaseQtVersion;
 namespace Internal {
 
 class MaemoDeployableListModel : public QAbstractTableModel
@@ -64,7 +64,7 @@ public:
     MaemoDeployable deployableAt(int row) const;
     bool isModified() const { return m_modified; }
     void setUnModified() { m_modified = false; }
-    const QtVersion *qtVersion() const;
+    const BaseQtVersion *qtVersion() const;
     QString localExecutableFilePath() const;
     QString remoteExecutableFilePath() const;
     QString projectName() const { return m_projectName; }
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemodeployconfigurationwidget.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemodeployconfigurationwidget.cpp
index eb3c3501ed..803e556789 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemodeployconfigurationwidget.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemodeployconfigurationwidget.cpp
@@ -37,6 +37,7 @@
 #include "maemodeployables.h"
 #include "qt4maemodeployconfiguration.h"
 
+#include <qt4projectmanager/qtversionmanager.h>
 #include <utils/qtcassert.h>
 
 #include <QtGui/QFileDialog>
@@ -137,7 +138,7 @@ void MaemoDeployConfigurationWidget::addIcon()
 
     MaemoDeployableListModel *const model
         = m_deployConfig->deployables()->modelAt(modelRow);
-    const int iconDim = MaemoGlobal::applicationIconSize(MaemoGlobal::version(model->qtVersion()));
+    const int iconDim = MaemoGlobal::applicationIconSize(MaemoGlobal::version(model->qtVersion()->qmakeCommand()));
     const QString origFilePath = QFileDialog::getOpenFileName(this,
         tr("Choose Icon (will be scaled to %1x%1 pixels, if necessary)").arg(iconDim),
         model->projectDir(), QLatin1String("(*.png)"));
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp
index e908c6f4f2..70d5a270cf 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.cpp
@@ -76,35 +76,35 @@ bool MaemoGlobal::isMeegoTargetId(const QString &id)
     return id == QLatin1String(Constants::MEEGO_DEVICE_TARGET_ID);
 }
 
-bool MaemoGlobal::isValidMaemo5QtVersion(const QtVersion *version)
+bool MaemoGlobal::isValidMaemo5QtVersion(const QString &qmakePath)
 {
-    return isValidMaemoQtVersion(version, MaemoDeviceConfig::Maemo5);
+    return isValidMaemoQtVersion(qmakePath, MaemoDeviceConfig::Maemo5);
 }
 
-bool MaemoGlobal::isValidHarmattanQtVersion(const QtVersion *version)
+bool MaemoGlobal::isValidHarmattanQtVersion(const QString &qmakePath)
 {
-    return isValidMaemoQtVersion(version, MaemoDeviceConfig::Maemo6);
+    return isValidMaemoQtVersion(qmakePath, MaemoDeviceConfig::Maemo6);
 }
 
-bool MaemoGlobal::isValidMeegoQtVersion(const Qt4ProjectManager::QtVersion *version)
+bool MaemoGlobal::isValidMeegoQtVersion(const QString &qmakePath)
 {
-    return isValidMaemoQtVersion(version, MaemoDeviceConfig::Meego);
+    return isValidMaemoQtVersion(qmakePath, MaemoDeviceConfig::Meego);
 }
 
-bool MaemoGlobal::isValidMaemoQtVersion(const QtVersion *qtVersion,
+bool MaemoGlobal::isValidMaemoQtVersion(const QString &qmakePath,
     MaemoDeviceConfig::OsVersion maemoVersion)
 {
-    if (version(qtVersion) != maemoVersion)
+    if (version(qmakePath) != maemoVersion)
         return false;
     QProcess madAdminProc;
     const QStringList arguments(QLatin1String("list"));
-    if (!callMadAdmin(madAdminProc, arguments, qtVersion, false))
+    if (!callMadAdmin(madAdminProc, arguments, qmakePath, false))
         return false;
     if (!madAdminProc.waitForStarted() || !madAdminProc.waitForFinished())
         return false;
 
     madAdminProc.setReadChannel(QProcess::StandardOutput);
-    const QByteArray tgtName = targetName(qtVersion).toAscii();
+    const QByteArray tgtName = targetName(qmakePath).toAscii();
     while (madAdminProc.canReadLine()) {
         const QByteArray &line = madAdminProc.readLine();
         if (line.contains(tgtName)
@@ -199,9 +199,9 @@ QString MaemoGlobal::deviceConfigurationName(const MaemoDeviceConfig::ConstPtr &
 }
 
 MaemoPortList MaemoGlobal::freePorts(const MaemoDeviceConfig::ConstPtr &devConf,
-    const QtVersion *qtVersion)
+    const BaseQtVersion *qtVersion)
 {
-    if (!devConf)
+    if (!devConf || !qtVersion)
         return MaemoPortList();
     if (devConf->type() == MaemoDeviceConfig::Emulator) {
         MaemoQemuRuntime rt;
@@ -212,31 +212,31 @@ MaemoPortList MaemoGlobal::freePorts(const MaemoDeviceConfig::ConstPtr &devConf,
     return devConf->freePorts();
 }
 
-QString MaemoGlobal::maddeRoot(const QtVersion *qtVersion)
+QString MaemoGlobal::maddeRoot(const QString &qmakePath)
 {
-    QDir dir(targetRoot(qtVersion));
+    QDir dir(targetRoot(qmakePath));
     dir.cdUp(); dir.cdUp();
     return dir.absolutePath();
 }
 
-QString MaemoGlobal::targetRoot(const QtVersion *qtVersion)
+QString MaemoGlobal::targetRoot(const QString &qmakePath)
 {
-    return QDir::cleanPath(qtVersion->qmakeCommand()).remove(binQmake);
+    return QDir::cleanPath(qmakePath).remove(binQmake);
 }
 
-QString MaemoGlobal::targetName(const QtVersion *qtVersion)
+QString MaemoGlobal::targetName(const QString &qmakePath)
 {
-    return QDir(targetRoot(qtVersion)).dirName();
+    return QDir(targetRoot(qmakePath)).dirName();
 }
 
-QString MaemoGlobal::madAdminCommand(const QtVersion *qtVersion)
+QString MaemoGlobal::madAdminCommand(const QString &qmakePath)
 {
-    return maddeRoot(qtVersion) + QLatin1String("/bin/mad-admin");
+    return maddeRoot(qmakePath) + QLatin1String("/bin/mad-admin");
 }
 
-QString MaemoGlobal::madCommand(const QtVersion *qtVersion)
+QString MaemoGlobal::madCommand(const QString &qmakePath)
 {
-    return maddeRoot(qtVersion) + QLatin1String("/bin/mad");
+    return maddeRoot(qmakePath) + QLatin1String("/bin/mad");
 }
 
 QString MaemoGlobal::madDeveloperUiName(MaemoDeviceConfig::OsVersion osVersion)
@@ -245,9 +245,9 @@ QString MaemoGlobal::madDeveloperUiName(MaemoDeviceConfig::OsVersion osVersion)
         ? tr("SDK Connectivity") : tr("Mad Developer");
 }
 
-MaemoDeviceConfig::OsVersion MaemoGlobal::version(const QtVersion *qtVersion)
+MaemoDeviceConfig::OsVersion MaemoGlobal::version(const QString &qmakePath)
 {
-    const QString &name = targetName(qtVersion);
+    const QString &name = targetName(qmakePath);
     if (name.startsWith(QLatin1String("fremantle")))
         return MaemoDeviceConfig::Maemo5;
     if (name.startsWith(QLatin1String("harmattan")))
@@ -257,12 +257,12 @@ MaemoDeviceConfig::OsVersion MaemoGlobal::version(const QtVersion *qtVersion)
     return static_cast<MaemoDeviceConfig::OsVersion>(-1);
 }
 
-QString MaemoGlobal::architecture(const QtVersion *qtVersion)
+QString MaemoGlobal::architecture(const QString &qmakePath)
 {
     QProcess proc;
     const QStringList args = QStringList() << QLatin1String("uname")
         << QLatin1String("-m");
-    if (!callMad(proc, args, qtVersion, true))
+    if (!callMad(proc, args, qmakePath, true))
         return QString();
     if (!proc.waitForFinished())
         return QString();
@@ -359,30 +359,30 @@ bool MaemoGlobal::isFileNewerThan(const QString &filePath,
 }
 
 bool MaemoGlobal::callMad(QProcess &proc, const QStringList &args,
-    const QtVersion *qtVersion, bool useTarget)
+    const QString &qmakePath, bool useTarget)
 {
-    return callMaddeShellScript(proc, qtVersion, madCommand(qtVersion), args,
+    return callMaddeShellScript(proc, qmakePath, madCommand(qmakePath), args,
         useTarget);
 }
 
 bool MaemoGlobal::callMadAdmin(QProcess &proc, const QStringList &args,
-    const QtVersion *qtVersion, bool useTarget)
+    const QString &qmakePath, bool useTarget)
 {
-    return callMaddeShellScript(proc, qtVersion, madAdminCommand(qtVersion),
+    return callMaddeShellScript(proc, qmakePath, madAdminCommand(qmakePath),
         args, useTarget);
 }
 
 bool MaemoGlobal::callMaddeShellScript(QProcess &proc,
-    const QtVersion *qtVersion, const QString &command, const QStringList &args,
+    const QString &qmakePath, const QString &command, const QStringList &args,
     bool useTarget)
 {
     if (!QFileInfo(command).exists())
         return false;
     QString actualCommand = command;
-    QStringList actualArgs = targetArgs(qtVersion, useTarget) + args;
+    QStringList actualArgs = targetArgs(qmakePath, useTarget) + args;
 #ifdef Q_OS_WIN
     Utils::Environment env(proc.systemEnvironment());
-    const QString root = maddeRoot(qtVersion);
+    const QString root = maddeRoot(qmakePath);
     env.prependOrSetPath(root + QLatin1String("/bin"));
     env.prependOrSet(QLatin1String("HOME"),
         QDesktopServices::storageLocation(QDesktopServices::HomeLocation));
@@ -394,11 +394,11 @@ bool MaemoGlobal::callMaddeShellScript(QProcess &proc,
     return true;
 }
 
-QStringList MaemoGlobal::targetArgs(const QtVersion *qtVersion, bool useTarget)
+QStringList MaemoGlobal::targetArgs(const QString &qmakePath, bool useTarget)
 {
     QStringList args;
     if (useTarget) {
-        args << QLatin1String("-t") << targetName(qtVersion);
+        args << QLatin1String("-t") << targetName(qmakePath);
     }
     return args;
 }
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h
index c98e7a67e0..6f229bdb98 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoglobal.h
@@ -56,7 +56,7 @@ QT_END_NAMESPACE
 
 namespace Utils { class SshConnection; }
 namespace Qt4ProjectManager {
-class QtVersion;
+class BaseQtVersion;
 namespace Internal {
 
 class MaemoGlobal
@@ -69,9 +69,9 @@ public:
     static bool isFremantleTargetId(const QString &id);
     static bool isHarmattanTargetId(const QString &id);
     static bool isMeegoTargetId(const QString &id);
-    static bool isValidMaemo5QtVersion(const Qt4ProjectManager::QtVersion *version);
-    static bool isValidHarmattanQtVersion(const Qt4ProjectManager::QtVersion *version);
-    static bool isValidMeegoQtVersion(const Qt4ProjectManager::QtVersion *version);
+    static bool isValidMaemo5QtVersion(const QString &qmakePath);
+    static bool isValidHarmattanQtVersion(const QString &qmakePath);
+    static bool isValidMeegoQtVersion(const QString &qmakePath);
 
     static QString homeDirOnDevice(const QString &uname);
     static QString devrootshPath();
@@ -86,22 +86,22 @@ public:
         const QSharedPointer<const MaemoDeviceConfig> &deviceConfig);
     static QString deviceConfigurationName(const QSharedPointer<const MaemoDeviceConfig> &devConf);
     static MaemoPortList freePorts(const QSharedPointer<const MaemoDeviceConfig> &devConf,
-        const QtVersion *qtVersion);
+        const BaseQtVersion *qtVersion);
 
-    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 QString maddeRoot(const QString &qmakePath);
+    static QString targetRoot(const QString &qmakePath);
+    static QString targetName(const QString &qmakePath);
+    static QString madCommand(const QString &qmakePath);
     static QString madDeveloperUiName(MaemoDeviceConfig::OsVersion maemoVersion);
-    static MaemoDeviceConfig::OsVersion version(const QtVersion *qtVersion);
+    static MaemoDeviceConfig::OsVersion version(const QString &qmakePath);
 
     // TODO: IS this still needed with Qt Version having an Abi?
-    static QString architecture(const QtVersion *version);
+    static QString architecture(const QString &qmakePath);
 
     static bool callMad(QProcess &proc, const QStringList &args,
-        const QtVersion *qtVersion, bool useTarget);
+        const QString &qmakePath, bool useTarget);
     static bool callMadAdmin(QProcess &proc, const QStringList &args,
-        const QtVersion *qtVersion, bool useTarget);
+        const QString &qmakePath, bool useTarget);
 
     static QString osVersionToString(MaemoDeviceConfig::OsVersion version);
 
@@ -146,12 +146,12 @@ public:
     }
 
 private:
-    static bool isValidMaemoQtVersion(const Qt4ProjectManager::QtVersion *qtVersion,
+    static bool isValidMaemoQtVersion(const QString &qmakePath,
         MaemoDeviceConfig::OsVersion maemoVersion);
-    static QString madAdminCommand(const QtVersion *qtVersion);
-    static bool callMaddeShellScript(QProcess &proc, const QtVersion *qtVersion,
+    static QString madAdminCommand(const QString &qmakePath);
+    static bool callMaddeShellScript(QProcess &proc, const QString &qmakePath,
         const QString &command, const QStringList &args, bool useTarget);
-    static QStringList targetArgs(const QtVersion *qtVersion, bool useTarget);
+    static QStringList targetArgs(const QString &qmakePath, bool useTarget);
 };
 
 } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoinstalltosysrootstep.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoinstalltosysrootstep.cpp
index a43e4181b5..c0ad0dcfcb 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoinstalltosysrootstep.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoinstalltosysrootstep.cpp
@@ -37,6 +37,7 @@
 #include "maemopackagecreationstep.h"
 #include "maemotoolchain.h"
 #include "qt4maemodeployconfiguration.h"
+#include "baseqtversion.h"
 
 #include <qt4projectmanager/qt4buildconfiguration.h>
 #include <qt4projectmanager/qt4target.h>
@@ -166,6 +167,13 @@ void AbstractMaemoInstallPackageToSysrootStep::run(QFutureInterface<bool> &fi)
         return;
     }
 
+    if (!bc->qtVersion()) {
+        addOutput(tr("Can't install package to sysroot without a qt version."),
+            ErrorMessageOutput);
+        fi.reportResult(false);
+        return;
+    }
+
     m_installerProcess = new QProcess;
     connect(m_installerProcess, SIGNAL(readyReadStandardOutput()),
         SLOT(handleInstallerStdout()));
@@ -173,11 +181,11 @@ void AbstractMaemoInstallPackageToSysrootStep::run(QFutureInterface<bool> &fi)
         SLOT(handleInstallerStderr()));
 
     emit addOutput(tr("Installing package to sysroot ..."), MessageOutput);
-    const QtVersion * const qtVersion = bc->qtVersion();
+    const BaseQtVersion * const qtVersion = bc->qtVersion();
     const QString packageFilePath = pStep->packageFilePath();
     const int packageFileSize = QFileInfo(packageFilePath).size() / (1024*1024);
     const QStringList args = madArguments() << packageFilePath;
-    MaemoGlobal::callMadAdmin(*m_installerProcess, args, qtVersion, true);
+    MaemoGlobal::callMadAdmin(*m_installerProcess, args, qtVersion->qmakeCommand(), true);
     if (!m_installerProcess->waitForFinished((2*packageFileSize + 10)*1000)
             || m_installerProcess->exitStatus() != QProcess::NormalExit
             || m_installerProcess->exitCode() != 0) {
@@ -362,16 +370,16 @@ bool MaemoMakeInstallToSysrootStep::init()
             ErrorMessageOutput);
         return false;
     }
-    const QtVersion * const qtVersion = bc->qtVersion();
+    const BaseQtVersion * const qtVersion = bc->qtVersion();
     if (!qtVersion) {
         addOutput("Can't deploy: Unusable build configuration.",
             ErrorMessageOutput);
         return false;
 
     }
-    processParameters()->setCommand(MaemoGlobal::madCommand(qtVersion));
+    processParameters()->setCommand(MaemoGlobal::madCommand(qtVersion->qmakeCommand()));
     const QStringList args = QStringList() << QLatin1String("-t")
-        << MaemoGlobal::targetName(qtVersion) << QLatin1String("make")
+        << MaemoGlobal::targetName(qtVersion->qmakeCommand()) << QLatin1String("make")
         << QLatin1String("install")
         << (QLatin1String("INSTALL_ROOT=") + qtVersion->systemRoot());
     processParameters()->setArguments(args.join(QLatin1String(" ")));
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp
index 69f9cbf992..313262dab1 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemomanager.cpp
@@ -44,6 +44,7 @@
 #include "maemosettingspages.h"
 #include "maemotoolchain.h"
 #include "qt4maemodeployconfiguration.h"
+#include "maemoqtversionfactory.h"
 #include "qt4maemotargetfactory.h"
 #include "qt4projectmanager/qtversionmanager.h"
 #include "qt4projectmanager/qt4projectmanagerconstants.h"
@@ -74,6 +75,7 @@ MaemoManager::MaemoManager()
     , m_publishingFactoryFremantleFree(new MaemoPublishingWizardFactoryFremantleFree(this))
     , m_maemoTargetFactory(new Qt4MaemoTargetFactory(this))
     , m_toolChainFactory(new MaemoToolChainFactory)
+    , m_maemoQtVersionFactory(new MaemoQtVersionFactory(this))
 {
     Q_ASSERT(!m_instance);
 
@@ -92,6 +94,7 @@ MaemoManager::MaemoManager()
     pluginManager->addObject(m_qemuSettingsPage);
     pluginManager->addObject(m_publishingFactoryFremantleFree);
     pluginManager->addObject(m_maemoTargetFactory);
+    pluginManager->addObject(m_maemoQtVersionFactory);
 
     qRegisterMetaType<MaemoDeployable>("MaemoDeployable");
 }
@@ -99,6 +102,7 @@ MaemoManager::MaemoManager()
 MaemoManager::~MaemoManager()
 {
     PluginManager *pluginManager = PluginManager::instance();
+    pluginManager->removeObject(m_maemoQtVersionFactory);
     pluginManager->removeObject(m_maemoTargetFactory);
     pluginManager->removeObject(m_publishingFactoryFremantleFree);
     pluginManager->removeObject(m_qemuSettingsPage);
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemomanager.h b/src/plugins/qt4projectmanager/qt-maemo/maemomanager.h
index 7ede720919..0c14f04094 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemomanager.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemomanager.h
@@ -36,7 +36,6 @@
 #include <QtCore/QObject>
 
 namespace Qt4ProjectManager {
-    class QtVersion;
 namespace Internal {
 
 class MaemoDeployStepFactory;
@@ -50,6 +49,7 @@ class MaemoQemuSettingsPage;
 class Qt4MaemoDeployConfigurationFactory;
 class Qt4MaemoTargetFactory;
 class MaemoToolChainFactory;
+class MaemoQtVersionFactory;
 
 class MaemoManager : public QObject
 {
@@ -77,6 +77,7 @@ private:
     MaemoPublishingWizardFactoryFremantleFree *m_publishingFactoryFremantleFree;
     Qt4MaemoTargetFactory *m_maemoTargetFactory;
     MaemoToolChainFactory *m_toolChainFactory;
+    MaemoQtVersionFactory *m_maemoQtVersionFactory;
 };
 
     } // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp
index 1c679962a9..3a3853e002 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopackagecreationstep.cpp
@@ -255,13 +255,17 @@ bool AbstractMaemoPackageCreationStep::callPackagingCommand(QProcess *proc,
     const QStringList &arguments)
 {
     preparePackagingProcess(proc, qt4BuildConfiguration(), buildDirectory());
-    const QtVersion * const qtVersion = qt4BuildConfiguration()->qtVersion();
-    const QString madCommand = MaemoGlobal::madCommand(qtVersion);
+    const BaseQtVersion * const qtVersion = qt4BuildConfiguration()->qtVersion();
+    if (!qtVersion) {
+        raiseError(tr("Packaging failed."), tr("Packaging error: No qt version."));
+        return false;
+    }
+    const QString madCommand = MaemoGlobal::madCommand(qtVersion->qmakeCommand());
     const QString cmdLine = madCommand + QLatin1Char(' ')
         + arguments.join(QLatin1String(" "));
     emit addOutput(tr("Package Creation: Running command '%1'.").arg(cmdLine),
         BuildStep::MessageOutput);
-    MaemoGlobal::callMad(*proc, arguments, qtVersion, true);
+    MaemoGlobal::callMad(*proc, arguments, qtVersion->qmakeCommand(), true);
     if (!proc->waitForStarted()) {
         raiseError(tr("Packaging failed."),
             tr("Packaging error: Could not start command '%1'. Reason: %2")
@@ -287,7 +291,7 @@ void AbstractMaemoPackageCreationStep::preparePackagingProcess(QProcess *proc,
     const Qt4BuildConfiguration *bc, const QString &workingDir)
 {
     Utils::Environment env = bc->environment();
-    if (bc->qmakeBuildConfiguration() & QtVersion::DebugBuild) {
+    if (bc->qmakeBuildConfiguration() & BaseQtVersion::DebugBuild) {
         env.appendOrSet(QLatin1String("DEB_BUILD_OPTIONS"),
             QLatin1String("nostrip"), QLatin1String(" "));
     }
@@ -466,7 +470,8 @@ QString MaemoDebianPackageCreationStep::packagingCommand(const Qt4BuildConfigura
     const QString &commandName)
 {
     QString perl;
-    const QString maddeRoot = MaemoGlobal::maddeRoot(bc->qtVersion());
+    BaseQtVersion *v = bc->qtVersion();
+    const QString maddeRoot = MaemoGlobal::maddeRoot(v->qmakeCommand());
 #ifdef Q_OS_WIN
     perl = maddeRoot + QLatin1String("/bin/perl.exe ");
 #endif
@@ -504,8 +509,12 @@ bool MaemoDebianPackageCreationStep::adaptRulesFile(
         + QLatin1Char('/') + maemoTarget()->packageName()
         + QLatin1String("/usr/share/applications/");
     const Qt4BuildConfiguration * const bc = qt4BuildConfiguration();
+
+    const BaseQtVersion *const lqt = bc->qtVersion();
+    if (!lqt)
+        return false;
     const MaemoDeviceConfig::OsVersion version
-        = MaemoGlobal::version(bc->qtVersion());
+        = MaemoGlobal::version(lqt->qmakeCommand());
     if (version == MaemoDeviceConfig::Maemo5)
         desktopFileDir += QLatin1String("hildon/");
 #ifdef Q_OS_WIN
@@ -537,7 +546,7 @@ bool MaemoDebianPackageCreationStep::adaptRulesFile(
     }
 
     // Always check for dependencies in release builds.
-    if (!(bc->qmakeBuildConfiguration() & QtVersion::DebugBuild))
+    if (!(bc->qmakeBuildConfiguration() & BaseQtVersion::DebugBuild))
         ensureShlibdeps(content);
 
     Utils::FileSaver saver(rulesFilePath);
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp
index 94a828c1c7..42757776b5 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopublisherfremantlefree.cpp
@@ -37,6 +37,7 @@
 #include "maemopublishingfileselectiondialog.h"
 #include "qt4maemodeployconfiguration.h"
 #include "qt4maemotarget.h"
+#include "baseqtversion.h"
 
 #include <coreplugin/ifile.h>
 #include <projectexplorer/project.h>
@@ -363,13 +364,17 @@ void MaemoPublisherFremantleFree::runDpkgBuildPackage()
         }
     }
 
+    BaseQtVersion *lqt = m_buildConfig->qtVersion();
+    if (!lqt)
+        finishWithFailure(QString(), tr("No qt version set"));
+
     if (m_state == Inactive)
         return;
     setState(BuildingPackage);
     emit progressReport(tr("Building source package..."));
     const QStringList args = QStringList() << QLatin1String("dpkg-buildpackage")
         << QLatin1String("-S") << QLatin1String("-us") << QLatin1String("-uc");
-    MaemoGlobal::callMad(*m_process, args, m_buildConfig->qtVersion(), true);
+    MaemoGlobal::callMad(*m_process, args, lqt->qmakeCommand(), true);
 }
 
 // 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 8481645a70..ce144a460d 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingbuildsettingspagefremantlefree.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingbuildsettingspagefremantlefree.cpp
@@ -39,6 +39,7 @@
 #include <projectexplorer/target.h>
 #include <qt4projectmanager/qt4buildconfiguration.h>
 #include <qt4projectmanager/qt4projectmanagerconstants.h>
+#include <qt4projectmanager/baseqtversion.h>
 #include <utils/qtcassert.h>
 
 using namespace ProjectExplorer;
@@ -79,7 +80,11 @@ void MaemoPublishingBuildSettingsPageFremantleFree::collectBuildConfigurations(c
                 = qobject_cast<Qt4BuildConfiguration *>(bc);
             if (!qt4Bc)
                 continue;
-            if (MaemoGlobal::version(qt4Bc->qtVersion()) == MaemoDeviceConfig::Maemo5)
+
+            BaseQtVersion *lqt = qt4Bc->qtVersion();
+            if (!lqt)
+                continue;
+            if (MaemoGlobal::version(lqt->qmakeCommand()) == MaemoDeviceConfig::Maemo5)
                 m_buildConfigs << qt4Bc;
         }
         break;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp
index 4d75ab204e..fc86d22c73 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemopublishingwizardfactories.cpp
@@ -33,6 +33,7 @@
 
 #include "maemoglobal.h"
 #include "maemopublishingwizardfremantlefree.h"
+#include "baseqtversion.h"
 
 #include <projectexplorer/target.h>
 #include <qt4projectmanager/qmakestep.h>
@@ -76,7 +77,11 @@ bool MaemoPublishingWizardFactoryFremantleFree::canCreateWizard(const Project *p
                 = qobject_cast<const Qt4BuildConfiguration *>(bc);
             if (!qt4Bc)
                 continue;
-            if (MaemoGlobal::version(qt4Bc->qtVersion()) == MaemoDeviceConfig::Maemo5)
+
+            BaseQtVersion *qt = qt4Bc->qtVersion();
+            if (!qt)
+                continue;
+            if (MaemoGlobal::version(qt->qmakeCommand()) == MaemoDeviceConfig::Maemo5)
                 return true;
         }
         break;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp
index ca38b74ad6..bdbf41a8be 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.cpp
@@ -41,6 +41,7 @@
 #include "qt4project.h"
 #include "qt4projectmanagerconstants.h"
 #include "qt4maemotarget.h"
+#include "maemoqtversion.h"
 
 #include <coreplugin/actionmanager/actionmanager.h>
 #include <coreplugin/actionmanager/command.h>
@@ -180,10 +181,9 @@ void MaemoQemuManager::qtVersionsChanged(const QList<int> &uniqueIds)
     QtVersionManager *manager = QtVersionManager::instance();
     foreach (int uniqueId, uniqueIds) {
         if (manager->isValidId(uniqueId)) {
-            QtVersion *version = manager->version(uniqueId);
-            if (version->supportsTargetId(Constants::MAEMO5_DEVICE_TARGET_ID)
-                    || version->supportsTargetId(Constants::HARMATTAN_DEVICE_TARGET_ID)
-                    || version->supportsTargetId(Constants::MEEGO_DEVICE_TARGET_ID)) {
+            MaemoQtVersion *version = dynamic_cast<MaemoQtVersion *>(manager->version(uniqueId));
+
+            if (version) {
                 MaemoQemuRuntime runtime
                     = MaemoQemuRuntimeParser::parseRuntime(version);
                 if (runtime.isValid()) {
@@ -370,7 +370,7 @@ void MaemoQemuManager::startRuntime()
     Project *p = ProjectExplorerPlugin::instance()->session()->startupProject();
     if (!p)
         return;
-    QtVersion *version;
+    BaseQtVersion *version;
     if (!targetUsesMatchingRuntimeConfig(p->activeTarget(), &version)) {
         qWarning("Strange: Qemu button was enabled, but target does not match.");
         return;
@@ -530,7 +530,7 @@ void MaemoQemuManager::toggleStarterButton(Target *target)
     if (target) {
         if (AbstractQt4MaemoTarget *qt4Target = qobject_cast<AbstractQt4MaemoTarget*>(target)) {
             if (Qt4BuildConfiguration *bc = qt4Target->activeBuildConfiguration()) {
-                if (QtVersion *version = bc->qtVersion())
+                if (BaseQtVersion *version = bc->qtVersion())
                     uniqueId = version->uniqueId();
             }
         }
@@ -567,7 +567,7 @@ bool MaemoQemuManager::sessionHasMaemoTarget() const
 }
 
 bool MaemoQemuManager::targetUsesMatchingRuntimeConfig(Target *target,
-    QtVersion **qtVersion)
+    BaseQtVersion **qtVersion)
 {
     if (!target)
         return false;
@@ -582,7 +582,7 @@ bool MaemoQemuManager::targetUsesMatchingRuntimeConfig(Target *target,
         = qobject_cast<Qt4BuildConfiguration *>(target->activeBuildConfiguration());
     if (!bc)
         return false;
-    QtVersion *version = bc->qtVersion();
+    BaseQtVersion *version = bc->qtVersion();
     if (!version || !m_runtimes.value(version->uniqueId(), MaemoQemuRuntime()).isValid())
         return false;
 
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.h b/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.h
index 9ee4c02b14..b4e9214549 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqemumanager.h
@@ -57,7 +57,7 @@ namespace ProjectExplorer {
 }
 
 namespace Qt4ProjectManager {
-    class QtVersion;
+    class BaseQtVersion;
     namespace Internal {
     class MaemoRunConfiguration;
 
@@ -117,7 +117,7 @@ private:
     void updateStarterIcon(bool running);
     void toggleStarterButton(ProjectExplorer::Target *target);
     bool targetUsesMatchingRuntimeConfig(ProjectExplorer::Target *target,
-        QtVersion **qtVersion = 0);
+        BaseQtVersion **qtVersion = 0);
 
     void notify(const QList<int> uniqueIds);
     void toggleDeviceConnections(MaemoRunConfiguration *mrc, bool connect);
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp
index 09e415f25e..c66f3d38bc 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.cpp
@@ -33,6 +33,7 @@
 
 #include "maemoglobal.h"
 #include "maemoqemusettings.h"
+#include "baseqtversion.h"
 
 #include <qt4projectmanager/qtversionmanager.h>
 #include <utils/qtcassert.h>
@@ -88,17 +89,17 @@ MaemoQemuRuntimeParser::MaemoQemuRuntimeParser(const QString &madInfoOutput,
 {
 }
 
-MaemoQemuRuntime MaemoQemuRuntimeParser::parseRuntime(const QtVersion *qtVersion)
+MaemoQemuRuntime MaemoQemuRuntimeParser::parseRuntime(const BaseQtVersion *qtVersion)
 {
     MaemoQemuRuntime runtime;
-    const QString maddeRootPath = MaemoGlobal::maddeRoot(qtVersion);
+    const QString maddeRootPath = MaemoGlobal::maddeRoot(qtVersion->qmakeCommand());
     QProcess madProc;
-    if (!MaemoGlobal::callMad(madProc, QStringList() << QLatin1String("info"), qtVersion, false))
+    if (!MaemoGlobal::callMad(madProc, QStringList() << QLatin1String("info"), qtVersion->qmakeCommand(), false))
         return runtime;
     if (!madProc.waitForStarted() || !madProc.waitForFinished())
         return runtime;
     const QByteArray &madInfoOutput = madProc.readAllStandardOutput();
-    const QString &targetName = MaemoGlobal::targetName(qtVersion);
+    const QString &targetName = MaemoGlobal::targetName(qtVersion->qmakeCommand());
     runtime = MaemoQemuRuntimeParserV2(madInfoOutput, targetName, maddeRootPath)
         .parseRuntime();
     if (!runtime.m_name.isEmpty()) {
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.h b/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.h
index 829480a2d0..780ebc4818 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqemuruntimeparser.h
@@ -38,13 +38,13 @@
 #include <QtXml/QXmlStreamReader>
 
 namespace Qt4ProjectManager {
-class QtVersion;
+class BaseQtVersion;
 namespace Internal {
 
 class MaemoQemuRuntimeParser
 {
 public:
-    static MaemoQemuRuntime parseRuntime(const QtVersion *qtVersion);
+    static MaemoQemuRuntime parseRuntime(const BaseQtVersion *qtVersion);
 
 protected:
     MaemoQemuRuntimeParser(const QString &madInfoOutput,
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqtversion.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversion.cpp
new file mode 100644
index 0000000000..652acfe504
--- /dev/null
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversion.cpp
@@ -0,0 +1,148 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#include "maemoqtversion.h"
+#include "qt4projectmanagerconstants.h"
+#include "qt-maemo/maemoglobal.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QFile>
+#include <QtCore/QDir>
+
+using namespace Qt4ProjectManager;
+using namespace Qt4ProjectManager::Internal;
+
+MaemoQtVersion::MaemoQtVersion()
+    : BaseQtVersion()
+{
+
+}
+
+MaemoQtVersion::MaemoQtVersion(const QString &path, bool isAutodetected, const QString &autodetectionSource)
+    : BaseQtVersion(path, isAutodetected, autodetectionSource)
+{
+
+}
+
+MaemoQtVersion::~MaemoQtVersion()
+{
+
+}
+
+QString MaemoQtVersion::type() const
+{
+    return Constants::MAEMOQT;
+}
+
+MaemoQtVersion *MaemoQtVersion::clone() const
+{
+    return new MaemoQtVersion(*this);
+}
+
+QString MaemoQtVersion::systemRoot() const
+{
+    if (m_systemRoot.isNull()) {
+        QFile file(QDir::cleanPath(MaemoGlobal::targetRoot(qmakeCommand()))
+                   + QLatin1String("/information"));
+        if (file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            QTextStream stream(&file);
+            while (!stream.atEnd()) {
+                const QString &line = stream.readLine().trimmed();
+                const QStringList &list = line.split(QLatin1Char(' '));
+                if (list.count() <= 1)
+                    continue;
+                if (list.at(0) == QLatin1String("sysroot")) {
+                    m_systemRoot = MaemoGlobal::maddeRoot(qmakeCommand())
+                            + QLatin1String("/sysroots/") + list.at(1);
+                }
+            }
+        }
+    }
+    return m_systemRoot;
+}
+
+QList<ProjectExplorer::Abi> MaemoQtVersion::qtAbis() const
+{
+    QList<ProjectExplorer::Abi> result;
+    if (MaemoGlobal::isValidMaemo5QtVersion(qmakeCommand())) {
+        result.append(ProjectExplorer::Abi(ProjectExplorer::Abi::ArmArchitecture, ProjectExplorer::Abi::LinuxOS,
+                                           ProjectExplorer::Abi::MaemoLinuxFlavor, ProjectExplorer::Abi::ElfFormat,
+                                           32));
+    } else if (MaemoGlobal::isValidHarmattanQtVersion(qmakeCommand())) {
+        result.append(ProjectExplorer::Abi(ProjectExplorer::Abi::ArmArchitecture, ProjectExplorer::Abi::LinuxOS,
+                                           ProjectExplorer::Abi::HarmattanLinuxFlavor,
+                                           ProjectExplorer::Abi::ElfFormat,
+                                           32));
+    } else if (MaemoGlobal::isValidMeegoQtVersion(qmakeCommand())) {
+        result.append(ProjectExplorer::Abi(ProjectExplorer::Abi::ArmArchitecture, ProjectExplorer::Abi::LinuxOS,
+                                           ProjectExplorer::Abi::MeegoLinuxFlavor,
+                                           ProjectExplorer::Abi::ElfFormat, 32));
+    }
+    return result;
+}
+
+bool MaemoQtVersion::supportsTargetId(const QString &id) const
+{
+    return supportedTargetIds().contains(id);
+}
+
+QSet<QString> MaemoQtVersion::supportedTargetIds() const
+{
+    QSet<QString> result;
+    if (MaemoGlobal::isValidMaemo5QtVersion(qmakeCommand())) {
+        result.insert(QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID));
+    } else if (MaemoGlobal::isValidHarmattanQtVersion(qmakeCommand())) {
+        result.insert(QLatin1String(Constants::HARMATTAN_DEVICE_TARGET_ID));
+    } else if (MaemoGlobal::isValidMeegoQtVersion(qmakeCommand())) {
+        result.insert(QLatin1String(Constants::MEEGO_DEVICE_TARGET_ID));
+    }
+    return result;
+}
+
+QString MaemoQtVersion::description() const
+{
+    if (MaemoGlobal::isValidMaemo5QtVersion(qmakeCommand()))
+        return QCoreApplication::translate("QtVersion", "Maemo", "Qt Version is meant for Maemo5");
+    else if (MaemoGlobal::isValidHarmattanQtVersion(qmakeCommand()))
+        return QCoreApplication::translate("QtVersion", "Harmattan ", "Qt Version is meant for Harmattan");
+    else if (MaemoGlobal::isValidMeegoQtVersion(qmakeCommand()))
+        return QCoreApplication::translate("QtVersion", "Meego", "Qt Version is meant for Meego");
+    return QString();
+}
+
+bool MaemoQtVersion::supportsShadowBuilds() const
+{
+#ifdef Q_OS_WIN
+    return false;
+#endif
+    return true;
+}
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqtversion.h b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversion.h
new file mode 100644
index 0000000000..184b2add6d
--- /dev/null
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversion.h
@@ -0,0 +1,67 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+#ifndef MAEMOQTVERSION_H
+#define MAEMOQTVERSION_H
+
+#include "baseqtversion.h"
+
+namespace Qt4ProjectManager {
+namespace Internal {
+
+class MaemoQtVersion : public BaseQtVersion
+{
+public:
+    MaemoQtVersion();
+    MaemoQtVersion(const QString &path, bool isAutodetected = false, const QString &autodetectionSource = QString());
+    ~MaemoQtVersion();
+    MaemoQtVersion *clone() const;
+
+    virtual QString type() const;
+
+    virtual QString systemRoot() const;
+    virtual QList<ProjectExplorer::Abi> qtAbis() const;
+
+    virtual bool supportsTargetId(const QString &id) const;
+    virtual QSet<QString> supportedTargetIds() const;
+
+    virtual QString description() const;
+
+    virtual bool supportsShadowBuilds() const;
+private:
+    mutable QString m_systemRoot;
+};
+
+}
+}
+
+
+#endif // MAEMOQTVERSION_H
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqtversionfactory.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversionfactory.cpp
new file mode 100644
index 0000000000..a7c3c7c6a8
--- /dev/null
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversionfactory.cpp
@@ -0,0 +1,84 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#include "maemoqtversionfactory.h"
+#include "maemoglobal.h"
+#include "qt4projectmanagerconstants.h"
+#include "maemoqtversion.h"
+
+#include <QtCore/QFileInfo>
+
+using namespace Qt4ProjectManager;
+using namespace Qt4ProjectManager::Internal;
+
+MaemoQtVersionFactory::MaemoQtVersionFactory(QObject *parent)
+    : QtVersionFactory(parent)
+{
+
+}
+
+MaemoQtVersionFactory::~MaemoQtVersionFactory()
+{
+
+}
+
+bool MaemoQtVersionFactory::canRestore(const QString &type)
+{
+    return type == QLatin1String(Constants::MAEMOQT);
+}
+
+BaseQtVersion *MaemoQtVersionFactory::restore(const QVariantMap &data)
+{
+    MaemoQtVersion *v = new MaemoQtVersion;
+    v->fromMap(data);
+    return v;
+}
+
+int MaemoQtVersionFactory::priority() const
+{
+    return 50;
+}
+
+BaseQtVersion *MaemoQtVersionFactory::create(const QString &qmakePath, ProFileEvaluator *evaluator, bool isAutoDetected, const QString &autoDetectionSource)
+{
+    Q_UNUSED(evaluator);
+    // we are the fallback :) so we don't care what kinf of qt it is
+    QFileInfo fi(qmakePath);
+    if (!fi.exists() || !fi.isExecutable() || !fi.isFile())
+        return 0;
+
+    if (MaemoGlobal::isValidMaemo5QtVersion(qmakePath)
+            || MaemoGlobal::isValidHarmattanQtVersion(qmakePath)
+            || MaemoGlobal::isValidMeegoQtVersion(qmakePath))
+        return new MaemoQtVersion(qmakePath, isAutoDetected, autoDetectionSource);
+    return 0;
+}
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoqtversionfactory.h b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversionfactory.h
new file mode 100644
index 0000000000..c49ff60fb7
--- /dev/null
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoqtversionfactory.h
@@ -0,0 +1,58 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (info@qt.nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at info@qt.nokia.com.
+**
+**************************************************************************/
+
+#ifndef MAEMOQTVERSIONFACTORY_H
+#define MAEMOQTVERSIONFACTORY_H
+
+#include "qtversionfactory.h"
+
+namespace Qt4ProjectManager {
+namespace Internal {
+
+class MaemoQtVersionFactory : public QtVersionFactory
+{
+public:
+    explicit MaemoQtVersionFactory(QObject *parent = 0);
+    ~MaemoQtVersionFactory();
+
+    virtual bool canRestore(const QString &type);
+    virtual BaseQtVersion *restore(const QVariantMap &data);
+
+    virtual int priority() const;
+    virtual BaseQtVersion *create(const QString &qmakePath, ProFileEvaluator *evaluator, bool isAutoDetected = false, const QString &autoDetectionSource = QString());
+};
+
+} // Internal
+} // Qt4ProjectManager
+
+
+#endif // MAEMOQTVERSIONFACTORY_H
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp
index 36140ce544..b4ddf410d2 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemoremotemounter.cpp
@@ -35,6 +35,7 @@
 #include "maemoglobal.h"
 #include "maemousedportsgatherer.h"
 #include "qt4maemotarget.h"
+#include "baseqtversion.h"
 
 #include <utils/ssh/sshconnection.h>
 #include <utils/ssh/sshremoteprocess.h>
@@ -74,10 +75,10 @@ void MaemoRemoteMounter::setConnection(const SshConnection::Ptr &connection,
 void MaemoRemoteMounter::setBuildConfiguration(const Qt4BuildConfiguration *bc)
 {
     ASSERT_STATE(Inactive);
-    const QtVersion * const qtVersion = bc->qtVersion();
+    const BaseQtVersion * const qtVersion = bc->qtVersion();
     m_remoteMountsAllowed
         = qobject_cast<AbstractQt4MaemoTarget *>(bc->target())->allowsRemoteMounts();
-    m_maddeRoot = MaemoGlobal::maddeRoot(qtVersion);
+    m_maddeRoot = qtVersion ? MaemoGlobal::maddeRoot(qtVersion->qmakeCommand()) : "";
 }
 
 void MaemoRemoteMounter::addMountSpecification(const MaemoMountSpecification &mountSpec,
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp
index 4cc7b50935..33618c686d 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemorunconfiguration.cpp
@@ -42,6 +42,7 @@
 #include "qt4maemodeployconfiguration.h"
 #include "qt4maemotarget.h"
 #include "qtoutputformatter.h"
+#include "maemoqtversion.h"
 
 #include <coreplugin/icore.h>
 #include <coreplugin/messagemanager.h>
@@ -235,7 +236,10 @@ AbstractLinuxDeviceDeployStep *MaemoRunConfiguration::deployStep() const
 const QString MaemoRunConfiguration::targetRoot() const
 {
     QTC_ASSERT(activeQt4BuildConfiguration(), return QString());
-    return MaemoGlobal::targetRoot(activeQt4BuildConfiguration()->qtVersion());
+    BaseQtVersion *v = activeQt4BuildConfiguration()->qtVersion();
+    if (!v)
+        return QString();
+    return MaemoGlobal::targetRoot(v->qmakeCommand());
 }
 
 const QString MaemoRunConfiguration::arguments() const
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp
index fd3202d4ce..6fb5eef449 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp
@@ -34,6 +34,7 @@
 
 #include "maemoglobal.h"
 #include "maemomanager.h"
+#include "maemoqtversion.h"
 #include "qt4projectmanagerconstants.h"
 #include "qtversionmanager.h"
 
@@ -93,8 +94,10 @@ bool MaemoToolChain::canClone() const
 
 void MaemoToolChain::addToEnvironment(Utils::Environment &env) const
 {
-    QtVersion *v = QtVersionManager::instance()->version(m_qtVersionId);
-    const QString maddeRoot = MaemoGlobal::maddeRoot(v);
+    BaseQtVersion *v = QtVersionManager::instance()->version(m_qtVersionId);
+    if (!v)
+        return;
+    const QString maddeRoot = MaemoGlobal::maddeRoot(v->qmakeCommand());
 
     // put this into environment to make pkg-config stuff work
     env.prependOrSet(QLatin1String("SYSROOT_DIR"), QDir::toNativeSeparators(sysroot()));
@@ -107,7 +110,7 @@ void MaemoToolChain::addToEnvironment(Utils::Environment &env) const
 
     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/bin").arg(maddeRoot)));
     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/bin")
-                                                  .arg(MaemoGlobal::targetRoot(v))));
+                                                  .arg(MaemoGlobal::targetRoot(v->qmakeCommand()))));
 
     const QString manglePathsKey = QLatin1String("GCCWRAPPER_PATHMANGLE");
     if (!env.hasKey(manglePathsKey)) {
@@ -121,19 +124,19 @@ void MaemoToolChain::addToEnvironment(Utils::Environment &env) const
 
 QString MaemoToolChain::sysroot() const
 {
-    QtVersion *v = QtVersionManager::instance()->version(m_qtVersionId);
+    BaseQtVersion *v = QtVersionManager::instance()->version(m_qtVersionId);
     if (!v)
         return QString();
 
     if (m_sysroot.isEmpty()) {
-        QFile file(QDir::cleanPath(MaemoGlobal::targetRoot(v)) + QLatin1String("/information"));
+        QFile file(QDir::cleanPath(MaemoGlobal::targetRoot(v->qmakeCommand())) + QLatin1String("/information"));
         if (file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
             QTextStream stream(&file);
             while (!stream.atEnd()) {
                 const QString &line = stream.readLine().trimmed();
                 const QStringList &list = line.split(QLatin1Char(' '));
                 if (list.count() > 1 && list.at(0) == QLatin1String("sysroot"))
-                    m_sysroot = MaemoGlobal::maddeRoot(v) + QLatin1String("/sysroots/") + list.at(1);
+                    m_sysroot = MaemoGlobal::maddeRoot(v->qmakeCommand()) + QLatin1String("/sysroots/") + list.at(1);
             }
         }
     }
@@ -180,14 +183,14 @@ void MaemoToolChain::setQtVersionId(int id)
         return;
     }
 
-    QtVersion *version = QtVersionManager::instance()->version(id);
+    BaseQtVersion *version = QtVersionManager::instance()->version(id);
     Q_ASSERT(version);
     ProjectExplorer::Abi::OSFlavor flavour = ProjectExplorer::Abi::HarmattanLinuxFlavor;
-    if (MaemoGlobal::isValidMaemo5QtVersion(version))
+    if (MaemoGlobal::isValidMaemo5QtVersion(version->qmakeCommand()))
         flavour = ProjectExplorer::Abi::MaemoLinuxFlavor;
-    else if (MaemoGlobal::isValidHarmattanQtVersion(version))
+    else if (MaemoGlobal::isValidHarmattanQtVersion(version->qmakeCommand()))
         flavour = ProjectExplorer::Abi::HarmattanLinuxFlavor;
-    else if (MaemoGlobal::isValidMeegoQtVersion(version))
+    else if (MaemoGlobal::isValidMeegoQtVersion(version->qmakeCommand()))
         flavour = ProjectExplorer::Abi::MeegoLinuxFlavor;
     else
         return;
@@ -221,14 +224,14 @@ MaemoToolChainConfigWidget::MaemoToolChainConfigWidget(MaemoToolChain *tc) :
 {
     QVBoxLayout *layout = new QVBoxLayout(this);
     QLabel *label = new QLabel;
-    QtVersion *v = QtVersionManager::instance()->version(tc->qtVersionId());
+    BaseQtVersion *v = QtVersionManager::instance()->version(tc->qtVersionId());
     Q_ASSERT(v);
     label->setText(tr("<html><head/><body><table>"
                       "<tr><td>Path to MADDE:</td><td>%1</td></tr>"
                       "<tr><td>Path to MADDE target:</td><td>%2</td></tr>"
                       "<tr><td>Debugger:</td/><td>%3</td></tr></body></html>")
-                   .arg(QDir::toNativeSeparators(MaemoGlobal::maddeRoot(v)),
-                        QDir::toNativeSeparators(MaemoGlobal::targetRoot(v)),
+                   .arg(QDir::toNativeSeparators(MaemoGlobal::maddeRoot(v->qmakeCommand())),
+                        QDir::toNativeSeparators(MaemoGlobal::targetRoot(v->qmakeCommand())),
                         QDir::toNativeSeparators(tc->debuggerCommand())));
     layout->addWidget(label);
 }
@@ -268,14 +271,12 @@ QString MaemoToolChainFactory::id() const
 
 QList<ProjectExplorer::ToolChain *> MaemoToolChainFactory::autoDetect()
 {
-    QList<ProjectExplorer::ToolChain *> result;
-
     QtVersionManager *vm = QtVersionManager::instance();
     connect(vm, SIGNAL(qtVersionsChanged(QList<int>)),
             this, SLOT(handleQtVersionChanges(QList<int>)));
 
     QList<int> versionList;
-    foreach (QtVersion *v, vm->versions())
+    foreach (BaseQtVersion *v, vm->versions())
         versionList.append(v->uniqueId());
 
     return createToolChainList(versionList);
@@ -296,7 +297,7 @@ QList<ProjectExplorer::ToolChain *> MaemoToolChainFactory::createToolChainList(c
     QList<ProjectExplorer::ToolChain *> result;
 
     foreach (int i, changes) {
-        QtVersion *v = vm->version(i);
+        BaseQtVersion *v = vm->version(i);
         if (!v) {
             // remove tool chain:
             QList<ProjectExplorer::ToolChain *> toRemove;
@@ -309,9 +310,7 @@ QList<ProjectExplorer::ToolChain *> MaemoToolChainFactory::createToolChainList(c
             }
             foreach (ProjectExplorer::ToolChain *tc, toRemove)
                 tcm->deregisterToolChain(tc);
-        } else if (v->supportsTargetId(Constants::MAEMO5_DEVICE_TARGET_ID)
-                   || v->supportsTargetId(Constants::HARMATTAN_DEVICE_TARGET_ID)
-                   || v->supportsTargetId(Constants::MEEGO_DEVICE_TARGET_ID)) {
+        } else if (MaemoQtVersion *mqv = dynamic_cast<MaemoQtVersion *>(v)) {
             // add tool chain:
             MaemoToolChain *mTc = new MaemoToolChain(true);
             mTc->setQtVersionId(i);
@@ -320,11 +319,11 @@ QList<ProjectExplorer::ToolChain *> MaemoToolChainFactory::createToolChainList(c
                 target = "Maemo 6";
             else if (v->supportsTargetId(Constants::MEEGO_DEVICE_TARGET_ID))
                 target = "Meego";
-            mTc->setDisplayName(tr("%1 GCC (%2)").arg(target).arg(MaemoGlobal::maddeRoot(v)));
-            mTc->setCompilerPath(MaemoGlobal::targetRoot(v) + QLatin1String("/bin/gcc"));
-            mTc->setDebuggerCommand(ProjectExplorer::ToolChainManager::instance()->defaultDebugger(v->qtAbis().at(0)));
+            mTc->setDisplayName(tr("%1 GCC (%2)").arg(target).arg(MaemoGlobal::maddeRoot(mqv->qmakeCommand())));
+            mTc->setCompilerPath(MaemoGlobal::targetRoot(mqv->qmakeCommand()) + QLatin1String("/bin/gcc"));
+            mTc->setDebuggerCommand(ProjectExplorer::ToolChainManager::instance()->defaultDebugger(mqv->qtAbis().at(0)));
             if (mTc->debuggerCommand().isEmpty())
-                mTc->setDebuggerCommand(MaemoGlobal::targetRoot(v) + QLatin1String("/bin/gdb"));
+                mTc->setDebuggerCommand(MaemoGlobal::targetRoot(mqv->qmakeCommand()) + QLatin1String("/bin/gdb"));
             result.append(mTc);
         }
     }
diff --git a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h
index 8249ea2318..6f4a796706 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.h
@@ -37,7 +37,6 @@
 #include <projectexplorer/toolchainconfigwidget.h>
 
 namespace Qt4ProjectManager {
-class QtVersion;
 
 namespace Internal {
 
diff --git a/src/plugins/qt4projectmanager/qt-maemo/qt-maemo.pri b/src/plugins/qt4projectmanager/qt-maemo/qt-maemo.pri
index 24893a582a..66a552bc87 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/qt-maemo.pri
+++ b/src/plugins/qt4projectmanager/qt-maemo/qt-maemo.pri
@@ -60,7 +60,9 @@ HEADERS += \
     $$PWD/maemodeploybymountstep.h \
     $$PWD/maemouploadandinstalldeploystep.h \
     $$PWD/maemodirectdeviceuploadstep.h \
-    $$PWD/abstractlinuxdevicedeploystep.h
+    $$PWD/abstractlinuxdevicedeploystep.h \
+    $$PWD/maemoqtversionfactory.h \
+    $$PWD/maemoqtversion.h
 
 SOURCES += \
     $$PWD/maemoconfigtestdialog.cpp \
@@ -121,7 +123,9 @@ SOURCES += \
     $$PWD/maemodeploybymountstep.cpp \
     $$PWD/maemouploadandinstalldeploystep.cpp \
     $$PWD/maemodirectdeviceuploadstep.cpp \
-    $$PWD/abstractlinuxdevicedeploystep.cpp
+    $$PWD/abstractlinuxdevicedeploystep.cpp \
+    $$PWD/maemoqtversionfactory.cpp \
+    $$PWD/maemoqtversion.cpp
 
 FORMS += \
     $$PWD/maemoconfigtestdialog.ui \
diff --git a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotarget.cpp b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotarget.cpp
index 1009f5d319..c5b5a26963 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotarget.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotarget.cpp
@@ -49,9 +49,9 @@
 #include <projectexplorer/toolchain.h>
 #include <qt4projectmanager/qt4project.h>
 #include <utils/fileutils.h>
-
 #include <utils/filesystemwatcher.h>
-#include <utils/fileutils.h>
+#include <qt4projectmanager/baseqtversion.h>
+
 
 #include <QtGui/QApplication>
 #include <QtGui/QMainWindow>
@@ -153,7 +153,7 @@ QList<ProjectExplorer::ToolChain *> AbstractQt4MaemoTarget::possibleToolChains(P
     QList<ProjectExplorer::ToolChain *> candidates = Qt4BaseTarget::possibleToolChains(bc);
     foreach (ProjectExplorer::ToolChain *i, candidates) {
         MaemoToolChain *tc = dynamic_cast<MaemoToolChain *>(i);
-        if (!tc)
+        if (!tc || !qt4Bc->qtVersion())
             continue;
         if (tc->qtVersionId() == qt4Bc->qtVersion()->uniqueId())
             result.append(tc);
@@ -692,7 +692,8 @@ bool AbstractDebBasedQt4MaemoTarget::targetCanBeRemoved() const
 void AbstractDebBasedQt4MaemoTarget::removeTarget()
 {
     QString error;
-    MaemoGlobal::removeRecursively(debianDirPath(), error);
+    if (!MaemoGlobal::removeRecursively(debianDirPath(), error))
+        qDebug("%s", qPrintable(error));
 }
 
 void AbstractDebBasedQt4MaemoTarget::handleDebianFileChanged(const QString &filePath)
@@ -725,7 +726,12 @@ AbstractQt4MaemoTarget::ActionStatus AbstractDebBasedQt4MaemoTarget::createSpeci
         << QLatin1String("-s") << QLatin1String("-n") << QLatin1String("-p")
         << (defaultPackageFileName() + QLatin1Char('_')
             + AbstractMaemoPackageCreationStep::DefaultVersionNumber);
-    if (!MaemoGlobal::callMad(dh_makeProc, dh_makeArgs, activeBuildConfiguration()->qtVersion(), true)
+    BaseQtVersion *lqt = activeBuildConfiguration()->qtVersion();
+    if (!lqt) {
+        raiseError(tr("Unable to create Debian templates: No qt version set"));
+        return ActionFailed;
+    }
+    if (!MaemoGlobal::callMad(dh_makeProc, dh_makeArgs, lqt->qmakeCommand(), true)
             || !dh_makeProc.waitForStarted()) {
         raiseError(tr("Unable to create Debian templates: dh_make failed (%1)")
             .arg(dh_makeProc.errorString()));
@@ -924,9 +930,12 @@ QString AbstractRpmBasedQt4MaemoTarget::shortDescription() const
 
 QString AbstractRpmBasedQt4MaemoTarget::packageFileName() const
 {
+    BaseQtVersion *lqt = activeBuildConfiguration()->qtVersion();
+    if (!lqt)
+        return QString();
     return packageName() + QLatin1Char('-') + projectVersion() + QLatin1Char('-')
         + QString::fromUtf8(getValueForTag(ReleaseTag, 0)) + QLatin1Char('.')
-        + MaemoGlobal::architecture(activeBuildConfiguration()->qtVersion())
+        + MaemoGlobal::architecture(lqt->qmakeCommand())
         + QLatin1String(".rpm");
 }
 
diff --git a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp
index 3c9003d79f..f0f118d137 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp
@@ -73,11 +73,11 @@ QStringList Qt4MaemoTargetFactory::supportedTargetIds(ProjectExplorer::Project *
     QStringList targetIds;
     if (parent && !qobject_cast<Qt4Project *>(parent))
         return targetIds;
-    if (QtVersionManager::instance()->supportsTargetId(QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID)))
+    if (!QtVersionManager::instance()->versionsForTargetId(QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID)).isEmpty())
         targetIds << QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID);
-    if (QtVersionManager::instance()->supportsTargetId(QLatin1String(Constants::HARMATTAN_DEVICE_TARGET_ID)))
+    if (!QtVersionManager::instance()->versionsForTargetId(QLatin1String(Constants::HARMATTAN_DEVICE_TARGET_ID)).isEmpty())
         targetIds << QLatin1String(Constants::HARMATTAN_DEVICE_TARGET_ID);
-    if (QtVersionManager::instance()->supportsTargetId(QLatin1String(Constants::MEEGO_DEVICE_TARGET_ID)))
+    if (!QtVersionManager::instance()->versionsForTargetId(QLatin1String(Constants::MEEGO_DEVICE_TARGET_ID)).isEmpty())
         targetIds << QLatin1String(Constants::MEEGO_DEVICE_TARGET_ID);
     return targetIds;
 }
@@ -176,16 +176,16 @@ ProjectExplorer::Target *Qt4MaemoTargetFactory::create(ProjectExplorer::Project
     if (!canCreate(parent, id))
         return 0;
 
-    QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id);
+    QList<BaseQtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id);
     if (knownVersions.isEmpty())
         return 0;
 
-    QtVersion *qtVersion = knownVersions.first();
-    QtVersion::QmakeBuildConfigs config = qtVersion->defaultBuildConfig();
+    BaseQtVersion *qtVersion = knownVersions.first();
+    BaseQtVersion::QmakeBuildConfigs config = qtVersion->defaultBuildConfig();
 
     QList<BuildConfigurationInfo> infos;
     infos.append(BuildConfigurationInfo(qtVersion, config, QString(), QString()));
-    infos.append(BuildConfigurationInfo(qtVersion, config ^ QtVersion::DebugBuild, QString(), QString()));
+    infos.append(BuildConfigurationInfo(qtVersion, config ^ BaseQtVersion::DebugBuild, QString(), QString()));
 
     return create(parent, id, infos);
 }