src/plugins/qt4projectmanager/qt-maemo/maemotoolchain.cpp

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (info@qt.nokia.com)
   8 **
   9 **
  10 ** GNU Lesser General Public License Usage
  11 **
  12 ** This file may be used under the terms of the GNU Lesser General Public
  13 ** License version 2.1 as published by the Free Software Foundation and
  14 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
  15 ** Please review the following information to ensure the GNU Lesser General
  16 ** Public License version 2.1 requirements will be met:
  17 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  18 **
  19 ** In addition, as a special exception, Nokia gives you certain additional
  20 ** rights. These rights are described in the Nokia Qt LGPL Exception
  21 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  22 **
  23 ** Other Usage
  24 **
  25 ** Alternatively, this file may be used in accordance with the terms and
  26 ** conditions contained in a signed written agreement between you and Nokia.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **************************************************************************/
  32
  33 #include "maemotoolchain.h"
  34
  35 #include "maemoglobal.h"
  36 #include "maemomanager.h"
  37 #include "qt4projectmanagerconstants.h"
  38 #include "qtversionmanager.h"
  39
  40 #include <projectexplorer/gccparser.h>
  41 #include <projectexplorer/headerpath.h>
  42 #include <projectexplorer/toolchainmanager.h>
  43 #include <utils/environment.h>
  44
  45 #include <QtCore/QDir>
  46 #include <QtCore/QFileInfo>
  47 #include <QtGui/QLabel>
  48 #include <QtGui/QVBoxLayout>
  49
  50 namespace Qt4ProjectManager {
  51 namespace Internal {
  52
  53 static const char *const MAEMO_QT_VERSION_KEY = "Qt4ProjectManager.Maemo.QtVersion";
  54
  55 // --------------------------------------------------------------------------
  56 // MaemoToolChain
  57 // --------------------------------------------------------------------------
  58
  59 MaemoToolChain::MaemoToolChain(bool autodetected) :
  60     ProjectExplorer::GccToolChain(QLatin1String(Constants::MAEMO_TOOLCHAIN_ID), autodetected),
  61     m_qtVersionId(-1)
  62 {
  63     updateId();
  64 }
  65
  66 MaemoToolChain::MaemoToolChain(const MaemoToolChain &tc) :
  67     ProjectExplorer::GccToolChain(tc),
  68     m_qtVersionId(tc.m_qtVersionId)
  69 { }
  70
  71 MaemoToolChain::~MaemoToolChain()
  72 { }
  73
  74 QString MaemoToolChain::typeName() const
  75 {
  76     return MaemoToolChainFactory::tr("Maemo GCC");
  77 }
  78
  79 ProjectExplorer::Abi MaemoToolChain::targetAbi() const
  80 {
  81     return m_targetAbi;
  82 }
  83
  84 bool MaemoToolChain::isValid() const
  85 {
  86     return GccToolChain::isValid() && m_qtVersionId >= 0 && m_targetAbi.isValid();
  87 }
  88
  89 bool MaemoToolChain::canClone() const
  90 {
  91     return false;
  92 }
  93
  94 void MaemoToolChain::addToEnvironment(Utils::Environment &env) const
  95 {
  96     QtVersion *v = QtVersionManager::instance()->version(m_qtVersionId);
  97     const QString maddeRoot = MaemoGlobal::maddeRoot(v);
  98
  99     // put this into environment to make pkg-config stuff work
 100     env.prependOrSet(QLatin1String("SYSROOT_DIR"), QDir::toNativeSeparators(sysroot()));
 101     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/madbin")
 102         .arg(maddeRoot)));
 103     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/madlib")
 104         .arg(maddeRoot)));
 105     env.prependOrSet(QLatin1String("PERL5LIB"),
 106         QDir::toNativeSeparators(QString("%1/madlib/perl5").arg(maddeRoot)));
 107
 108     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/bin").arg(maddeRoot)));
 109     env.prependOrSetPath(QDir::toNativeSeparators(QString("%1/bin")
 110                                                   .arg(MaemoGlobal::targetRoot(v))));
 111
 112     const QString manglePathsKey = QLatin1String("GCCWRAPPER_PATHMANGLE");
 113     if (!env.hasKey(manglePathsKey)) {
 114         const QStringList pathsToMangle = QStringList() << QLatin1String("/lib")
 115             << QLatin1String("/opt") << QLatin1String("/usr");
 116         env.set(manglePathsKey, QString());
 117         foreach (const QString &path, pathsToMangle)
 118             env.appendOrSet(manglePathsKey, path, QLatin1String(":"));
 119     }
 120 }
 121
 122 QString MaemoToolChain::sysroot() const
 123 {
 124     QtVersion *v = QtVersionManager::instance()->version(m_qtVersionId);
 125     if (!v)
 126         return QString();
 127
 128     if (m_sysroot.isEmpty()) {
 129         QFile file(QDir::cleanPath(MaemoGlobal::targetRoot(v)) + QLatin1String("/information"));
 130         if (file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 131             QTextStream stream(&file);
 132             while (!stream.atEnd()) {
 133                 const QString &line = stream.readLine().trimmed();
 134                 const QStringList &list = line.split(QLatin1Char(' '));
 135                 if (list.count() > 1 && list.at(0) == QLatin1String("sysroot"))
 136                     m_sysroot = MaemoGlobal::maddeRoot(v) + QLatin1String("/sysroots/") + list.at(1);
 137             }
 138         }
 139     }
 140     return m_sysroot;
 141 }
 142
 143 bool MaemoToolChain::operator ==(const ProjectExplorer::ToolChain &tc) const
 144 {
 145     if (!ToolChain::operator ==(tc))
 146         return false;
 147
 148     const MaemoToolChain *tcPtr = static_cast<const MaemoToolChain *>(&tc);
 149     return m_qtVersionId == tcPtr->m_qtVersionId;
 150 }
 151
 152 ProjectExplorer::ToolChainConfigWidget *MaemoToolChain::configurationWidget()
 153 {
 154     return new MaemoToolChainConfigWidget(this);
 155 }
 156
 157 QVariantMap MaemoToolChain::toMap() const
 158 {
 159     QVariantMap result = GccToolChain::toMap();
 160     result.insert(QLatin1String(MAEMO_QT_VERSION_KEY), m_qtVersionId);
 161     return result;
 162 }
 163
 164 bool MaemoToolChain::fromMap(const QVariantMap &data)
 165 {
 166     if (!GccToolChain::fromMap(data))
 167         return false;
 168
 169     m_qtVersionId = data.value(QLatin1String(MAEMO_QT_VERSION_KEY), -1).toInt();
 170
 171     return isValid();
 172 }
 173
 174 void MaemoToolChain::setQtVersionId(int id)
 175 {
 176     if (id < 0) {
 177         m_targetAbi = ProjectExplorer::Abi();
 178         m_qtVersionId = -1;
 179         updateId(); // Will trigger toolChainUpdated()!
 180         return;
 181     }
 182
 183     QtVersion *version = QtVersionManager::instance()->version(id);
 184     Q_ASSERT(version);
 185     ProjectExplorer::Abi::OSFlavor flavour = ProjectExplorer::Abi::HarmattanLinuxFlavor;
 186     if (MaemoGlobal::isValidMaemo5QtVersion(version))
 187         flavour = ProjectExplorer::Abi::MaemoLinuxFlavor;
 188     else if (MaemoGlobal::isValidHarmattanQtVersion(version))
 189         flavour = ProjectExplorer::Abi::HarmattanLinuxFlavor;
 190     else if (MaemoGlobal::isValidMeegoQtVersion(version))
 191         flavour = ProjectExplorer::Abi::MeegoLinuxFlavor;
 192     else
 193         return;
 194
 195     m_qtVersionId = id;
 196
 197     Q_ASSERT(version->qtAbis().count() == 1);
 198     m_targetAbi = version->qtAbis().at(0);
 199
 200     updateId(); // Will trigger toolChainUpdated()!
 201     setDisplayName(MaemoToolChainFactory::tr("Maemo GCC for %1").arg(version->displayName()));
 202 }
 203
 204 int MaemoToolChain::qtVersionId() const
 205 {
 206     return m_qtVersionId;
 207 }
 208
 209 void MaemoToolChain::updateId()
 210 {
 211     setId(QString::fromLatin1("%1:%2.%3").arg(Constants::MAEMO_TOOLCHAIN_ID)
 212           .arg(m_qtVersionId).arg(debuggerCommand()));
 213 }
 214
 215 // --------------------------------------------------------------------------
 216 // ToolChainConfigWidget
 217 // --------------------------------------------------------------------------
 218
 219 MaemoToolChainConfigWidget::MaemoToolChainConfigWidget(MaemoToolChain *tc) :
 220     ProjectExplorer::ToolChainConfigWidget(tc)
 221 {
 222     QVBoxLayout *layout = new QVBoxLayout(this);
 223     QLabel *label = new QLabel;
 224     QtVersion *v = QtVersionManager::instance()->version(tc->qtVersionId());
 225     Q_ASSERT(v);
 226     label->setText(tr("<html><head/><body><table>"
 227                       "<tr><td>Path to MADDE:</td><td>%1</td></tr>"
 228                       "<tr><td>Path to MADDE target:</td><td>%2</td></tr>"
 229                       "<tr><td>Debugger:</td/><td>%3</td></tr></body></html>")
 230                    .arg(QDir::toNativeSeparators(MaemoGlobal::maddeRoot(v)),
 231                         QDir::toNativeSeparators(MaemoGlobal::targetRoot(v)),
 232                         QDir::toNativeSeparators(tc->debuggerCommand())));
 233     layout->addWidget(label);
 234 }
 235
 236 void MaemoToolChainConfigWidget::apply()
 237 {
 238     // nothing to do!
 239 }
 240
 241 void MaemoToolChainConfigWidget::discard()
 242 {
 243     // nothing to do!
 244 }
 245
 246 bool MaemoToolChainConfigWidget::isDirty() const
 247 {
 248     return false;
 249 }
 250
 251 // --------------------------------------------------------------------------
 252 // ToolChainFactory
 253 // --------------------------------------------------------------------------
 254
 255 MaemoToolChainFactory::MaemoToolChainFactory() :
 256     ProjectExplorer::ToolChainFactory()
 257 { }
 258
 259 QString MaemoToolChainFactory::displayName() const
 260 {
 261     return tr("Maemo GCC");
 262 }
 263
 264 QString MaemoToolChainFactory::id() const
 265 {
 266     return QLatin1String(Constants::MAEMO_TOOLCHAIN_ID);
 267 }
 268
 269 QList<ProjectExplorer::ToolChain *> MaemoToolChainFactory::autoDetect()
 270 {
 271     QList<ProjectExplorer::ToolChain *> result;
 272
 273     QtVersionManager *vm = QtVersionManager::instance();
 274     connect(vm, SIGNAL(qtVersionsChanged(QList<int>)),
 275             this, SLOT(handleQtVersionChanges(QList<int>)));
 276
 277     QList<int> versionList;
 278     foreach (QtVersion *v, vm->versions())
 279         versionList.append(v->uniqueId());
 280
 281     return createToolChainList(versionList);
 282 }
 283
 284 void MaemoToolChainFactory::handleQtVersionChanges(const QList<int> &changes)
 285 {
 286     ProjectExplorer::ToolChainManager *tcm = ProjectExplorer::ToolChainManager::instance();
 287     QList<ProjectExplorer::ToolChain *> tcList = createToolChainList(changes);
 288     foreach (ProjectExplorer::ToolChain *tc, tcList)
 289         tcm->registerToolChain(tc);
 290 }
 291
 292 QList<ProjectExplorer::ToolChain *> MaemoToolChainFactory::createToolChainList(const QList<int> &changes)
 293 {
 294     ProjectExplorer::ToolChainManager *tcm = ProjectExplorer::ToolChainManager::instance();
 295     QtVersionManager *vm = QtVersionManager::instance();
 296     QList<ProjectExplorer::ToolChain *> result;
 297
 298     foreach (int i, changes) {
 299         QtVersion *v = vm->version(i);
 300         if (!v) {
 301             // remove tool chain:
 302             QList<ProjectExplorer::ToolChain *> toRemove;
 303             foreach (ProjectExplorer::ToolChain *tc, tcm->toolChains()) {
 304                 if (!tc->id().startsWith(QLatin1String(Constants::MAEMO_TOOLCHAIN_ID)))
 305                     continue;
 306                 MaemoToolChain *mTc = static_cast<MaemoToolChain *>(tc);
 307                 if (mTc->qtVersionId() == i)
 308                     toRemove.append(mTc);
 309             }
 310             foreach (ProjectExplorer::ToolChain *tc, toRemove)
 311                 tcm->deregisterToolChain(tc);
 312         } else if (v->supportsTargetId(Constants::MAEMO5_DEVICE_TARGET_ID)
 313                    || v->supportsTargetId(Constants::HARMATTAN_DEVICE_TARGET_ID)
 314                    || v->supportsTargetId(Constants::MEEGO_DEVICE_TARGET_ID)) {
 315             // add tool chain:
 316             MaemoToolChain *mTc = new MaemoToolChain(true);
 317             mTc->setQtVersionId(i);
 318             QString target = "Maemo 5";
 319             if (v->supportsTargetId(Constants::HARMATTAN_DEVICE_TARGET_ID))
 320                 target = "Maemo 6";
 321             else if (v->supportsTargetId(Constants::MEEGO_DEVICE_TARGET_ID))
 322                 target = "Meego";
 323             mTc->setDisplayName(tr("%1 GCC (%2)").arg(target).arg(MaemoGlobal::maddeRoot(v)));
 324             mTc->setCompilerPath(MaemoGlobal::targetRoot(v) + QLatin1String("/bin/gcc"));
 325             mTc->setDebuggerCommand(ProjectExplorer::ToolChainManager::instance()->defaultDebugger(v->qtAbis().at(0)));
 326             if (mTc->debuggerCommand().isEmpty())
 327                 mTc->setDebuggerCommand(MaemoGlobal::targetRoot(v) + QLatin1String("/bin/gdb"));
 328             result.append(mTc);
 329         }
 330     }
 331     return result;
 332 }
 333
 334 } // namespace Internal
 335 } // namespace Qt4ProjectManager