Source/QtDialog/QCMake.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: QCMake.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-03-12 15:19:26 $
   7   Version:   $Revision: 1.25 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17
  18 #include "QCMake.h"
  19
  20 #include <QDir>
  21 #include <QCoreApplication>
  22
  23 #include "cmake.h"
  24 #include "cmCacheManager.h"
  25 #include "cmSystemTools.h"
  26 #include "cmExternalMakefileProjectGenerator.h"
  27
  28 QCMake::QCMake(QObject* p)
  29   : QObject(p)
  30 {
  31   this->SuppressDevWarnings = false;
  32   qRegisterMetaType<QCMakeProperty>();
  33   qRegisterMetaType<QCMakePropertyList>();
  34
  35   QDir execDir(QCoreApplication::applicationDirPath());
  36
  37 #if defined(Q_OS_MAC)
  38   if(execDir.exists("../bin/cmake"))
  39     {
  40     execDir.cd("../bin");
  41     }
  42   else
  43     {
  44     execDir.cd("../../../");  // path to cmake in build directory (need to fix for deployment)
  45     }
  46 #endif
  47
  48   QString cmakeCommand = QString("cmake")+cmSystemTools::GetExecutableExtension();
  49   cmakeCommand = execDir.filePath(cmakeCommand);
  50
  51   cmSystemTools::DisableRunCommandOutput();
  52   cmSystemTools::SetRunCommandHideConsole(true);
  53   cmSystemTools::SetErrorCallback(QCMake::errorCallback, this);
  54   cmSystemTools::FindExecutableDirectory(cmakeCommand.toAscii().data());
  55
  56   this->CMakeInstance = new cmake;
  57   this->CMakeInstance->SetCMakeCommand(cmakeCommand.toAscii().data());
  58 #if defined(Q_OS_MAC)
  59   this->CMakeInstance->SetCMakeEditCommand("cmake-gui.app/Contents/MacOS/cmake-gui");
  60 #else
  61   this->CMakeInstance->SetCMakeEditCommand("cmake-gui");
  62 #endif
  63   this->CMakeInstance->SetProgressCallback(QCMake::progressCallback, this);
  64
  65   std::vector<std::string> generators;
  66   this->CMakeInstance->GetRegisteredGenerators(generators);
  67   std::vector<std::string>::iterator iter;
  68   for(iter = generators.begin(); iter != generators.end(); ++iter)
  69     {
  70     this->AvailableGenerators.append(iter->c_str());
  71     }
  72 }
  73
  74 QCMake::~QCMake()
  75 {
  76   delete this->CMakeInstance;
  77   //cmDynamicLoader::FlushCache();
  78 }
  79
  80 void QCMake::loadCache(const QString& dir)
  81 {
  82   this->setBinaryDirectory(dir);
  83 }
  84
  85 void QCMake::setSourceDirectory(const QString& dir)
  86 {
  87   if(this->SourceDirectory != dir)
  88     {
  89     this->SourceDirectory = QDir::fromNativeSeparators(dir);
  90     emit this->sourceDirChanged(this->SourceDirectory);
  91     }
  92 }
  93
  94 void QCMake::setBinaryDirectory(const QString& dir)
  95 {
  96   if(this->BinaryDirectory != dir)
  97     {
  98     this->BinaryDirectory = QDir::fromNativeSeparators(dir);
  99     emit this->binaryDirChanged(this->BinaryDirectory);
 100     cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
 101     this->setGenerator(QString());
 102     if(!this->CMakeInstance->GetCacheManager()->LoadCache(
 103       this->BinaryDirectory.toLocal8Bit().data()))
 104       {
 105       QDir testDir(this->BinaryDirectory);
 106       if(testDir.exists("CMakeCache.txt"))
 107         {
 108         cmSystemTools::Error("There is a CMakeCache.txt file for the current binary "
 109             "tree but cmake does not have permission to read it.  "
 110             "Please check the permissions of the directory you are trying to run CMake on.");
 111         }
 112       }
 113
 114     QCMakePropertyList props = this->properties();
 115     emit this->propertiesChanged(props);
 116     cmCacheManager::CacheIterator itm = cachem->NewIterator();
 117     if ( itm.Find("CMAKE_HOME_DIRECTORY"))
 118       {
 119       setSourceDirectory(itm.GetValue());
 120       }
 121     if ( itm.Find("CMAKE_GENERATOR"))
 122       {
 123       const char* extraGen = cachem->GetCacheValue("CMAKE_EXTRA_GENERATOR");
 124       std::string curGen = cmExternalMakefileProjectGenerator::
 125                               CreateFullGeneratorName(itm.GetValue(), extraGen);
 126       this->setGenerator(curGen.c_str());
 127       }
 128     }
 129 }
 130
 131
 132 void QCMake::setGenerator(const QString& gen)
 133 {
 134   if(this->Generator != gen)
 135     {
 136     this->Generator = gen;
 137     emit this->generatorChanged(this->Generator);
 138     }
 139 }
 140
 141 void QCMake::configure()
 142 {
 143   this->CMakeInstance->SetHomeDirectory(this->SourceDirectory.toAscii().data());
 144   this->CMakeInstance->SetStartDirectory(this->SourceDirectory.toAscii().data());
 145   this->CMakeInstance->SetHomeOutputDirectory(this->BinaryDirectory.toAscii().data());
 146   this->CMakeInstance->SetStartOutputDirectory(this->BinaryDirectory.toAscii().data());
 147   this->CMakeInstance->SetGlobalGenerator(
 148     this->CMakeInstance->CreateGlobalGenerator(this->Generator.toAscii().data()));
 149   this->CMakeInstance->LoadCache();
 150   this->CMakeInstance->SetSuppressDevWarnings(this->SuppressDevWarnings);
 151   this->CMakeInstance->PreLoadCMakeFiles();
 152
 153   cmSystemTools::ResetErrorOccuredFlag();
 154
 155   int err = this->CMakeInstance->Configure();
 156
 157   emit this->propertiesChanged(this->properties());
 158   emit this->configureDone(err);
 159 }
 160
 161 void QCMake::generate()
 162 {
 163   cmSystemTools::ResetErrorOccuredFlag();
 164   int err = this->CMakeInstance->Generate();
 165   emit this->generateDone(err);
 166 }
 167
 168 void QCMake::setProperties(const QCMakePropertyList& newProps)
 169 {
 170   QCMakePropertyList props = newProps;
 171
 172   QStringList toremove;
 173
 174   // set the value of properties
 175   cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
 176   for(cmCacheManager::CacheIterator i = cachem->NewIterator();
 177       !i.IsAtEnd(); i.Next())
 178     {
 179
 180     if(i.GetType() == cmCacheManager::INTERNAL ||
 181        i.GetType() == cmCacheManager::STATIC)
 182       {
 183       continue;
 184       }
 185
 186     QCMakeProperty prop;
 187     prop.Key = i.GetName();
 188     int idx = props.indexOf(prop);
 189     if(idx == -1)
 190       {
 191       toremove.append(i.GetName());
 192       }
 193     else
 194       {
 195       prop = props[idx];
 196       if(prop.Value.type() == QVariant::Bool)
 197         {
 198         i.SetValue(prop.Value.toBool() ? "ON" : "OFF");
 199         }
 200       else
 201         {
 202         i.SetValue(prop.Value.toString().toAscii().data());
 203         }
 204       props.removeAt(idx);
 205       }
 206
 207     }
 208
 209   // remove some properites
 210   foreach(QString s, toremove)
 211     {
 212     cachem->RemoveCacheEntry(s.toAscii().data());
 213     }
 214
 215   // add some new properites
 216   foreach(QCMakeProperty s, props)
 217     {
 218     if(s.Type == QCMakeProperty::BOOL)
 219       {
 220       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 221                             s.Value.toBool() ? "ON" : "OFF",
 222                             s.Help.toAscii().data(),
 223                             cmCacheManager::BOOL);
 224       }
 225     else if(s.Type == QCMakeProperty::STRING)
 226       {
 227       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 228                             s.Value.toString().toAscii().data(),
 229                             s.Help.toAscii().data(),
 230                             cmCacheManager::STRING);
 231       }
 232     else if(s.Type == QCMakeProperty::PATH)
 233       {
 234       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 235                             s.Value.toString().toAscii().data(),
 236                             s.Help.toAscii().data(),
 237                             cmCacheManager::PATH);
 238       }
 239     else if(s.Type == QCMakeProperty::FILEPATH)
 240       {
 241       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 242                             s.Value.toString().toAscii().data(),
 243                             s.Help.toAscii().data(),
 244                             cmCacheManager::FILEPATH);
 245       }
 246     }
 247
 248   cachem->SaveCache(this->BinaryDirectory.toAscii().data());
 249 }
 250
 251 QCMakePropertyList QCMake::properties() const
 252 {
 253   QCMakePropertyList ret;
 254
 255   cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
 256   for(cmCacheManager::CacheIterator i = cachem->NewIterator();
 257       !i.IsAtEnd(); i.Next())
 258     {
 259
 260     if(i.GetType() == cmCacheManager::INTERNAL ||
 261        i.GetType() == cmCacheManager::STATIC ||
 262        i.GetType() == cmCacheManager::UNINITIALIZED)
 263       {
 264       continue;
 265       }
 266
 267     QCMakeProperty prop;
 268     prop.Key = i.GetName();
 269     prop.Help = i.GetProperty("HELPSTRING");
 270     prop.Value = i.GetValue();
 271     prop.Advanced = i.GetPropertyAsBool("ADVANCED");
 272
 273     if(i.GetType() == cmCacheManager::BOOL)
 274       {
 275       prop.Type = QCMakeProperty::BOOL;
 276       prop.Value = cmSystemTools::IsOn(i.GetValue());
 277       }
 278     else if(i.GetType() == cmCacheManager::PATH)
 279       {
 280       prop.Type = QCMakeProperty::PATH;
 281       }
 282     else if(i.GetType() == cmCacheManager::FILEPATH)
 283       {
 284       prop.Type = QCMakeProperty::FILEPATH;
 285       }
 286     else if(i.GetType() == cmCacheManager::STRING)
 287       {
 288       prop.Type = QCMakeProperty::STRING;
 289       if (i.PropertyExists("STRINGS"))
 290         {
 291         prop.Strings = QString(i.GetProperty("STRINGS")).split(";");
 292         }
 293       }
 294
 295     ret.append(prop);
 296     }
 297
 298   return ret;
 299 }
 300
 301 void QCMake::interrupt()
 302 {
 303   cmSystemTools::SetFatalErrorOccured();
 304 }
 305
 306 void QCMake::progressCallback(const char* msg, float percent, void* cd)
 307 {
 308   QCMake* self = reinterpret_cast<QCMake*>(cd);
 309   if(percent >= 0)
 310     {
 311     emit self->progressChanged(msg, percent);
 312     }
 313   else
 314     {
 315     emit self->outputMessage(msg);
 316     }
 317   QCoreApplication::processEvents();
 318 }
 319
 320 void QCMake::errorCallback(const char* msg, const char* /*title*/,
 321                            bool& /*stop*/, void* cd)
 322 {
 323   QCMake* self = reinterpret_cast<QCMake*>(cd);
 324   emit self->errorMessage(msg);
 325   QCoreApplication::processEvents();
 326 }
 327
 328 QString QCMake::binaryDirectory() const
 329 {
 330   return this->BinaryDirectory;
 331 }
 332
 333 QString QCMake::sourceDirectory() const
 334 {
 335   return this->SourceDirectory;
 336 }
 337
 338 QString QCMake::generator() const
 339 {
 340   return this->Generator;
 341 }
 342
 343 QStringList QCMake::availableGenerators() const
 344 {
 345   return this->AvailableGenerators;
 346 }
 347
 348 void QCMake::deleteCache()
 349 {
 350   // delete cache
 351   this->CMakeInstance->GetCacheManager()->DeleteCache(this->BinaryDirectory.toAscii().data());
 352   // reload to make our cache empty
 353   this->CMakeInstance->GetCacheManager()->LoadCache(this->BinaryDirectory.toAscii().data());
 354   // emit no generator and no properties
 355   this->setGenerator(QString());
 356   QCMakePropertyList props = this->properties();
 357   emit this->propertiesChanged(props);
 358 }
 359
 360 void QCMake::reloadCache()
 361 {
 362   // emit that the cache was cleaned out
 363   QCMakePropertyList props;
 364   emit this->propertiesChanged(props);
 365   // reload
 366   this->CMakeInstance->GetCacheManager()->LoadCache(this->BinaryDirectory.toAscii().data());
 367   // emit new cache properties
 368   props = this->properties();
 369   emit this->propertiesChanged(props);
 370 }
 371
 372 void QCMake::setDebugOutput(bool flag)
 373 {
 374   if(flag != this->CMakeInstance->GetDebugOutput())
 375     {
 376     this->CMakeInstance->SetDebugOutputOn(flag);
 377     emit this->debugOutputChanged(flag);
 378     }
 379 }
 380
 381 bool QCMake::getDebugOutput() const
 382 {
 383   return this->CMakeInstance->GetDebugOutput();
 384 }
 385
 386
 387 void QCMake::setSuppressDevWarnings(bool value)
 388 {
 389   this->SuppressDevWarnings = value;
 390 }