CMakeLua/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-30 20:34:28 $
   7   Version:   $Revision: 1.26 $
   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   QString dir =
  88     cmSystemTools::GetActualCaseForPath(_dir.toAscii().data()).c_str();
  89   if(this->SourceDirectory != dir)
  90     {
  91     this->SourceDirectory = QDir::fromNativeSeparators(dir);
  92     emit this->sourceDirChanged(this->SourceDirectory);
  93     }
  94 }
  95
  96 void QCMake::setBinaryDirectory(const QString& _dir)
  97 {
  98   QString dir =
  99     cmSystemTools::GetActualCaseForPath(_dir.toAscii().data()).c_str();
 100   if(this->BinaryDirectory != dir)
 101     {
 102     this->BinaryDirectory = QDir::fromNativeSeparators(dir);
 103     emit this->binaryDirChanged(this->BinaryDirectory);
 104     cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
 105     this->setGenerator(QString());
 106     if(!this->CMakeInstance->GetCacheManager()->LoadCache(
 107       this->BinaryDirectory.toLocal8Bit().data()))
 108       {
 109       QDir testDir(this->BinaryDirectory);
 110       if(testDir.exists("CMakeCache.txt"))
 111         {
 112         cmSystemTools::Error("There is a CMakeCache.txt file for the current binary "
 113             "tree but cmake does not have permission to read it.  "
 114             "Please check the permissions of the directory you are trying to run CMake on.");
 115         }
 116       }
 117
 118     QCMakePropertyList props = this->properties();
 119     emit this->propertiesChanged(props);
 120     cmCacheManager::CacheIterator itm = cachem->NewIterator();
 121     if ( itm.Find("CMAKE_HOME_DIRECTORY"))
 122       {
 123       setSourceDirectory(itm.GetValue());
 124       }
 125     if ( itm.Find("CMAKE_GENERATOR"))
 126       {
 127       const char* extraGen = cachem->GetCacheValue("CMAKE_EXTRA_GENERATOR");
 128       std::string curGen = cmExternalMakefileProjectGenerator::
 129                               CreateFullGeneratorName(itm.GetValue(), extraGen);
 130       this->setGenerator(curGen.c_str());
 131       }
 132     }
 133 }
 134
 135
 136 void QCMake::setGenerator(const QString& gen)
 137 {
 138   if(this->Generator != gen)
 139     {
 140     this->Generator = gen;
 141     emit this->generatorChanged(this->Generator);
 142     }
 143 }
 144
 145 void QCMake::configure()
 146 {
 147   this->CMakeInstance->SetHomeDirectory(this->SourceDirectory.toAscii().data());
 148   this->CMakeInstance->SetStartDirectory(this->SourceDirectory.toAscii().data());
 149   this->CMakeInstance->SetHomeOutputDirectory(this->BinaryDirectory.toAscii().data());
 150   this->CMakeInstance->SetStartOutputDirectory(this->BinaryDirectory.toAscii().data());
 151   this->CMakeInstance->SetGlobalGenerator(
 152     this->CMakeInstance->CreateGlobalGenerator(this->Generator.toAscii().data()));
 153   this->CMakeInstance->LoadCache();
 154   this->CMakeInstance->SetSuppressDevWarnings(this->SuppressDevWarnings);
 155   this->CMakeInstance->PreLoadCMakeFiles();
 156
 157   cmSystemTools::ResetErrorOccuredFlag();
 158
 159   int err = this->CMakeInstance->Configure();
 160
 161   emit this->propertiesChanged(this->properties());
 162   emit this->configureDone(err);
 163 }
 164
 165 void QCMake::generate()
 166 {
 167   cmSystemTools::ResetErrorOccuredFlag();
 168   int err = this->CMakeInstance->Generate();
 169   emit this->generateDone(err);
 170 }
 171
 172 void QCMake::setProperties(const QCMakePropertyList& newProps)
 173 {
 174   QCMakePropertyList props = newProps;
 175
 176   QStringList toremove;
 177
 178   // set the value of properties
 179   cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
 180   for(cmCacheManager::CacheIterator i = cachem->NewIterator();
 181       !i.IsAtEnd(); i.Next())
 182     {
 183
 184     if(i.GetType() == cmCacheManager::INTERNAL ||
 185        i.GetType() == cmCacheManager::STATIC)
 186       {
 187       continue;
 188       }
 189
 190     QCMakeProperty prop;
 191     prop.Key = i.GetName();
 192     int idx = props.indexOf(prop);
 193     if(idx == -1)
 194       {
 195       toremove.append(i.GetName());
 196       }
 197     else
 198       {
 199       prop = props[idx];
 200       if(prop.Value.type() == QVariant::Bool)
 201         {
 202         i.SetValue(prop.Value.toBool() ? "ON" : "OFF");
 203         }
 204       else
 205         {
 206         i.SetValue(prop.Value.toString().toAscii().data());
 207         }
 208       props.removeAt(idx);
 209       }
 210
 211     }
 212
 213   // remove some properites
 214   foreach(QString s, toremove)
 215     {
 216     cachem->RemoveCacheEntry(s.toAscii().data());
 217     }
 218
 219   // add some new properites
 220   foreach(QCMakeProperty s, props)
 221     {
 222     if(s.Type == QCMakeProperty::BOOL)
 223       {
 224       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 225                             s.Value.toBool() ? "ON" : "OFF",
 226                             s.Help.toAscii().data(),
 227                             cmCacheManager::BOOL);
 228       }
 229     else if(s.Type == QCMakeProperty::STRING)
 230       {
 231       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 232                             s.Value.toString().toAscii().data(),
 233                             s.Help.toAscii().data(),
 234                             cmCacheManager::STRING);
 235       }
 236     else if(s.Type == QCMakeProperty::PATH)
 237       {
 238       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 239                             s.Value.toString().toAscii().data(),
 240                             s.Help.toAscii().data(),
 241                             cmCacheManager::PATH);
 242       }
 243     else if(s.Type == QCMakeProperty::FILEPATH)
 244       {
 245       this->CMakeInstance->AddCacheEntry(s.Key.toAscii().data(),
 246                             s.Value.toString().toAscii().data(),
 247                             s.Help.toAscii().data(),
 248                             cmCacheManager::FILEPATH);
 249       }
 250     }
 251
 252   cachem->SaveCache(this->BinaryDirectory.toAscii().data());
 253 }
 254
 255 QCMakePropertyList QCMake::properties() const
 256 {
 257   QCMakePropertyList ret;
 258
 259   cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
 260   for(cmCacheManager::CacheIterator i = cachem->NewIterator();
 261       !i.IsAtEnd(); i.Next())
 262     {
 263
 264     if(i.GetType() == cmCacheManager::INTERNAL ||
 265        i.GetType() == cmCacheManager::STATIC ||
 266        i.GetType() == cmCacheManager::UNINITIALIZED)
 267       {
 268       continue;
 269       }
 270
 271     QCMakeProperty prop;
 272     prop.Key = i.GetName();
 273     prop.Help = i.GetProperty("HELPSTRING");
 274     prop.Value = i.GetValue();
 275     prop.Advanced = i.GetPropertyAsBool("ADVANCED");
 276
 277     if(i.GetType() == cmCacheManager::BOOL)
 278       {
 279       prop.Type = QCMakeProperty::BOOL;
 280       prop.Value = cmSystemTools::IsOn(i.GetValue());
 281       }
 282     else if(i.GetType() == cmCacheManager::PATH)
 283       {
 284       prop.Type = QCMakeProperty::PATH;
 285       }
 286     else if(i.GetType() == cmCacheManager::FILEPATH)
 287       {
 288       prop.Type = QCMakeProperty::FILEPATH;
 289       }
 290     else if(i.GetType() == cmCacheManager::STRING)
 291       {
 292       prop.Type = QCMakeProperty::STRING;
 293       if (i.PropertyExists("STRINGS"))
 294         {
 295         prop.Strings = QString(i.GetProperty("STRINGS")).split(";");
 296         }
 297       }
 298
 299     ret.append(prop);
 300     }
 301
 302   return ret;
 303 }
 304
 305 void QCMake::interrupt()
 306 {
 307   cmSystemTools::SetFatalErrorOccured();
 308 }
 309
 310 void QCMake::progressCallback(const char* msg, float percent, void* cd)
 311 {
 312   QCMake* self = reinterpret_cast<QCMake*>(cd);
 313   if(percent >= 0)
 314     {
 315     emit self->progressChanged(msg, percent);
 316     }
 317   else
 318     {
 319     emit self->outputMessage(msg);
 320     }
 321   QCoreApplication::processEvents();
 322 }
 323
 324 void QCMake::errorCallback(const char* msg, const char* /*title*/,
 325                            bool& /*stop*/, void* cd)
 326 {
 327   QCMake* self = reinterpret_cast<QCMake*>(cd);
 328   emit self->errorMessage(msg);
 329   QCoreApplication::processEvents();
 330 }
 331
 332 QString QCMake::binaryDirectory() const
 333 {
 334   return this->BinaryDirectory;
 335 }
 336
 337 QString QCMake::sourceDirectory() const
 338 {
 339   return this->SourceDirectory;
 340 }
 341
 342 QString QCMake::generator() const
 343 {
 344   return this->Generator;
 345 }
 346
 347 QStringList QCMake::availableGenerators() const
 348 {
 349   return this->AvailableGenerators;
 350 }
 351
 352 void QCMake::deleteCache()
 353 {
 354   // delete cache
 355   this->CMakeInstance->GetCacheManager()->DeleteCache(this->BinaryDirectory.toAscii().data());
 356   // reload to make our cache empty
 357   this->CMakeInstance->GetCacheManager()->LoadCache(this->BinaryDirectory.toAscii().data());
 358   // emit no generator and no properties
 359   this->setGenerator(QString());
 360   QCMakePropertyList props = this->properties();
 361   emit this->propertiesChanged(props);
 362 }
 363
 364 void QCMake::reloadCache()
 365 {
 366   // emit that the cache was cleaned out
 367   QCMakePropertyList props;
 368   emit this->propertiesChanged(props);
 369   // reload
 370   this->CMakeInstance->GetCacheManager()->LoadCache(this->BinaryDirectory.toAscii().data());
 371   // emit new cache properties
 372   props = this->properties();
 373   emit this->propertiesChanged(props);
 374 }
 375
 376 void QCMake::setDebugOutput(bool flag)
 377 {
 378   if(flag != this->CMakeInstance->GetDebugOutput())
 379     {
 380     this->CMakeInstance->SetDebugOutputOn(flag);
 381     emit this->debugOutputChanged(flag);
 382     }
 383 }
 384
 385 bool QCMake::getDebugOutput() const
 386 {
 387   return this->CMakeInstance->GetDebugOutput();
 388 }
 389
 390
 391 void QCMake::setSuppressDevWarnings(bool value)
 392 {
 393   this->SuppressDevWarnings = value;
 394 }