Merge topic 'cmake-gui-select-toolset'

2b958a20 cmake-gui: Add option to specify generator toolset

Help/release/dev/cmake-gui-select-toolset.rst

@@ -0,0 +1,6 @@
+cmake-gui-select-toolset
+------------------------
+
+* The :manual:`cmake-gui(1)` learned an option to set the toolset
+  to be used with VS IDE and Xcode generators, much like the
+  existing ``-T`` option to :manual:`cmake(1)`.

Source/QtDialog/CMakeSetupDialog.cxx

@@ -734,6 +734,7 @@ bool CMakeSetupDialog::setupFirstConfigure()
     {
     dialog.saveToSettings();
     this->CMakeThread->cmakeInstance()->setGenerator(dialog.getGenerator());
+    this->CMakeThread->cmakeInstance()->setToolset(dialog.getToolset());
 
     QCMakeCacheModel* m = this->CacheValues->cacheModel();
 

Source/QtDialog/FirstConfigure.cxx

@@ -15,6 +15,11 @@ StartCompilerSetup::StartCompilerSetup(QWidget* p)
   l->addWidget(new QLabel(tr("Specify the generator for this project")));
   this->GeneratorOptions = new QComboBox(this);
   l->addWidget(this->GeneratorOptions);
+
+  // Add the ability to specify toolset (-T parameter)
+  ToolsetFrame = CreateToolsetWidgets();
+  l->addWidget(ToolsetFrame);
+
   l->addSpacing(6);
 
   this->CompilerSetupOptions[0] = new QRadioButton(tr("Use default native compilers"), this);
@@ -36,17 +41,51 @@ StartCompilerSetup::StartCompilerSetup(QWidget* p)
                    this, SLOT(onSelectionChanged(bool)));
   QObject::connect(this->CompilerSetupOptions[3], SIGNAL(toggled(bool)),
                    this, SLOT(onSelectionChanged(bool)));
+  QObject::connect(GeneratorOptions,
+                   SIGNAL(currentIndexChanged(QString const&)),
+                   this, SLOT(onGeneratorChanged(QString const&)));
+}
+
+QFrame* StartCompilerSetup::CreateToolsetWidgets()
+{
+  QFrame* frame = new QFrame(this);
+  QVBoxLayout* l = new QVBoxLayout(frame);
+  l->setContentsMargins(0, 0, 0, 0);
+
+  ToolsetLabel = new QLabel(tr("Optional toolset to use (-T parameter)"));
+  l->addWidget(ToolsetLabel);
+
+  Toolset = new QLineEdit(frame);
+  l->addWidget(Toolset);
+
+  return frame;
 }
 
 StartCompilerSetup::~StartCompilerSetup()
 {
 }
 
-void StartCompilerSetup::setGenerators(const QStringList& gens)
+void StartCompilerSetup::setGenerators(
+  std::vector<cmake::GeneratorInfo> const& gens)
 {
   this->GeneratorOptions->clear();
-  this->GeneratorOptions->addItems(gens);
+
-};
+  QStringList generator_list;
+
+  std::vector<cmake::GeneratorInfo>::const_iterator it;
+  for (it = gens.begin(); it != gens.end(); ++it)
+    {
+    generator_list.append(QString::fromLocal8Bit(it->name.c_str()));
+
+    if (it->supportsToolset)
+      {
+      this->GeneratorsSupportingToolset.append(
+        QString::fromLocal8Bit(it->name.c_str()));
+      }
+    }
+
+  this->GeneratorOptions->addItems(generator_list);
+}
 
 void StartCompilerSetup::setCurrentGenerator(const QString& gen)
 {
@@ -62,6 +101,11 @@ QString StartCompilerSetup::getGenerator() const
   return this->GeneratorOptions->currentText();
 };
 
+QString StartCompilerSetup::getToolset() const
+{
+  return this->Toolset->text();
+};
+
 bool StartCompilerSetup::defaultSetup() const
 {
   return this->CompilerSetupOptions[0]->isChecked();
@@ -88,6 +132,18 @@ void StartCompilerSetup::onSelectionChanged(bool on)
     selectionChanged();
 }
 
+void StartCompilerSetup::onGeneratorChanged(QString const& name)
+{
+  if (GeneratorsSupportingToolset.contains(name))
+    {
+    ToolsetFrame->show();
+    }
+  else
+    {
+    ToolsetFrame->hide();
+    }
+}
+
 int StartCompilerSetup::nextId() const
 {
   if(compilerSetup())
@@ -325,7 +381,8 @@ FirstConfigure::~FirstConfigure()
 {
 }
 
-void FirstConfigure::setGenerators(const QStringList& gens)
+void FirstConfigure::setGenerators(
+  std::vector<cmake::GeneratorInfo> const& gens)
 {
   this->mStartCompilerSetupPage->setGenerators(gens);
 }
@@ -335,6 +392,11 @@ QString FirstConfigure::getGenerator() const
   return this->mStartCompilerSetupPage->getGenerator();
 }
 
+QString FirstConfigure::getToolset() const
+{
+  return this->mStartCompilerSetupPage->getToolset();
+}
+
 void FirstConfigure::loadFromSettings()
 {
   QSettings settings;

Source/QtDialog/FirstConfigure.h

@@ -4,6 +4,7 @@
 
 #include <QWizard>
 #include <QWizardPage>
+#include "cmake.h"
 #include "ui_Compilers.h"
 #include "ui_CrossCompiler.h"
 
@@ -27,9 +28,10 @@ class StartCompilerSetup : public QWizardPage
   public:
     StartCompilerSetup(QWidget* p);
     ~StartCompilerSetup();
-    void setGenerators(const QStringList& gens);
+    void setGenerators(std::vector<cmake::GeneratorInfo> const& gens);
     void setCurrentGenerator(const QString& gen);
     QString getGenerator() const;
+    QString getToolset() const;
 
     bool defaultSetup() const;
     bool compilerSetup() const;
@@ -43,10 +45,18 @@ class StartCompilerSetup : public QWizardPage
 
   protected slots:
     void onSelectionChanged(bool);
+    void onGeneratorChanged(QString const& name);
 
   protected:
     QComboBox* GeneratorOptions;
     QRadioButton* CompilerSetupOptions[4];
+    QFrame* ToolsetFrame;
+    QLineEdit* Toolset;
+    QLabel* ToolsetLabel;
+    QStringList GeneratorsSupportingToolset;
+
+  private:
+    QFrame* CreateToolsetWidgets();
 };
 
 //! the page that gives basic options for native compilers
@@ -140,8 +150,9 @@ public:
   FirstConfigure();
   ~FirstConfigure();
 
-  void setGenerators(const QStringList& gens);
+  void setGenerators(std::vector<cmake::GeneratorInfo> const& gens);
   QString getGenerator() const;
+  QString getToolset() const;
 
   bool defaultSetup() const;
   bool compilerSetup() const;

Source/QtDialog/QCMake.cxx

@@ -15,7 +15,6 @@
 #include <QDir>
 #include <QCoreApplication>
 
-#include "cmake.h"
 #include "cmState.h"
 #include "cmSystemTools.h"
 #include "cmExternalMakefileProjectGenerator.h"
@@ -46,21 +45,23 @@ QCMake::QCMake(QObject* p)
 
   cmSystemTools::SetInterruptCallback(QCMake::interruptCallback, this);
 
-  std::vector<std::string> generators;
+  std::vector<cmake::GeneratorInfo> generators;
   this->CMakeInstance->GetRegisteredGenerators(generators);
-  std::vector<std::string>::iterator iter;
+
-  for(iter = generators.begin(); iter != generators.end(); ++iter)
+  std::vector<cmake::GeneratorInfo>::const_iterator it;
+  for(it = generators.begin(); it != generators.end(); ++it)
     {
     // Skip the generator "KDevelop3", since there is also
     // "KDevelop3 - Unix Makefiles", which is the full and official name.
     // The short name is actually only still there since this was the name
     // in CMake 2.4, to keep "command line argument compatibility", but
     // this is not necessary in the GUI.
-    if (*iter == "KDevelop3")
+    if (it->name == "KDevelop3")
       {
       continue;
       }
-    this->AvailableGenerators.append(QString::fromLocal8Bit(iter->c_str()));
+
+    this->AvailableGenerators.push_back(*it);
     }
 }
 
@@ -96,6 +97,7 @@ void QCMake::setBinaryDirectory(const QString& _dir)
     emit this->binaryDirChanged(this->BinaryDirectory);
     cmState* state = this->CMakeInstance->GetState();
     this->setGenerator(QString());
+    this->setToolset(QString());
     if(!this->CMakeInstance->LoadCache(
       this->BinaryDirectory.toLocal8Bit().data()))
       {
@@ -124,6 +126,12 @@ void QCMake::setBinaryDirectory(const QString& _dir)
         CreateFullGeneratorName(gen, extraGen? extraGen : "");
       this->setGenerator(QString::fromLocal8Bit(curGen.c_str()));
       }
+
+    const char* toolset = state->GetCacheEntryValue("CMAKE_GENERATOR_TOOLSET");
+    if (toolset)
+      {
+      this->setToolset(QString::fromLocal8Bit(toolset));
+      }
     }
 }
 
@@ -137,6 +145,15 @@ void QCMake::setGenerator(const QString& gen)
     }
 }
 
+void QCMake::setToolset(const QString& toolset)
+{
+  if(this->Toolset != toolset)
+    {
+    this->Toolset = toolset;
+    emit this->toolsetChanged(this->Toolset);
+    }
+}
+
 void QCMake::configure()
 {
 #ifdef Q_OS_WIN
@@ -148,7 +165,7 @@ void QCMake::configure()
   this->CMakeInstance->SetGlobalGenerator(
     this->CMakeInstance->CreateGlobalGenerator(this->Generator.toLocal8Bit().data()));
   this->CMakeInstance->SetGeneratorPlatform("");
-  this->CMakeInstance->SetGeneratorToolset("");
+  this->CMakeInstance->SetGeneratorToolset(this->Toolset.toLocal8Bit().data());
   this->CMakeInstance->LoadCache();
   this->CMakeInstance->SetSuppressDevWarnings(this->SuppressDevWarnings);
   this->CMakeInstance->SetWarnUninitialized(this->WarnUninitializedMode);
@@ -396,9 +413,9 @@ QString QCMake::generator() const
   return this->Generator;
 }
 
-QStringList QCMake::availableGenerators() const
+std::vector<cmake::GeneratorInfo> const& QCMake::availableGenerators() const
 {
-  return this->AvailableGenerators;
+  return AvailableGenerators;
 }
 
 void QCMake::deleteCache()
@@ -409,6 +426,7 @@ void QCMake::deleteCache()
   this->CMakeInstance->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
   // emit no generator and no properties
   this->setGenerator(QString());
+  this->setToolset(QString());
   QCMakePropertyList props = this->properties();
   emit this->propertiesChanged(props);
 }

Source/QtDialog/QCMake.h

@@ -17,6 +17,8 @@
 #pragma warning ( disable : 4512 )
 #endif
 
+#include <vector>
+
 #include <QObject>
 #include <QString>
 #include <QVariant>
@@ -25,7 +27,7 @@
 #include <QMetaType>
 #include <QAtomicInt>
 
-class cmake;
+#include "cmake.h"
 
 /// struct to represent cmake properties in Qt
 /// Value is of type String or Bool
@@ -73,6 +75,8 @@ public slots:
   void setBinaryDirectory(const QString& dir);
   /// set the desired generator to use
   void setGenerator(const QString& generator);
+  /// set the desired generator to use
+  void setToolset(const QString& toolset);
   /// do the configure step
   void configure();
   /// generate the files
@@ -104,7 +108,7 @@ public:
   /// get the current generator
   QString generator() const;
   /// get the available generators
-  QStringList availableGenerators() const;
+  std::vector<cmake::GeneratorInfo> const& availableGenerators() const;
   /// get whether to do debug output
   bool getDebugOutput() const;
 
@@ -130,6 +134,8 @@ signals:
   void errorMessage(const QString& msg);
   /// signal when debug output changes
   void debugOutputChanged(bool);
+  /// signal when the toolset changes
+  void toolsetChanged(const QString& toolset);
 
 protected:
   cmake* CMakeInstance;
@@ -147,7 +153,8 @@ protected:
   QString SourceDirectory;
   QString BinaryDirectory;
   QString Generator;
-  QStringList AvailableGenerators;
+  QString Toolset;
+  std::vector<cmake::GeneratorInfo> AvailableGenerators;
   QString CMakeExecutable;
   QAtomicInt InterruptFlag;
 };

Source/cmGlobalGeneratorFactory.h

@@ -38,6 +38,9 @@ public:
 
   /** Get the names of the current registered generators */
   virtual void GetGenerators(std::vector<std::string>& names) const = 0;
+
+  /** Determine whether or not this generator supports toolsets */
+  virtual bool SupportsToolset() const = 0;
 };
 
 template<class T>
@@ -57,6 +60,9 @@ public:
   /** Get the names of the current registered generators */
   virtual void GetGenerators(std::vector<std::string>& names) const {
     names.push_back(T::GetActualName()); }
+
+  /** Determine whether or not this generator supports toolsets */
+  virtual bool SupportsToolset() const { return T::SupportsToolset(); }
 };
 
 #endif

Source/cmGlobalGhsMultiGenerator.h

@@ -35,12 +35,19 @@ public:
 
   /// @return the name of this generator.
   static std::string GetActualName() { return "Green Hills MULTI"; }
+
   ///! Get the name for this generator
   virtual std::string GetName() const { return this->GetActualName(); }
 
   /// Overloaded methods. @see cmGlobalGenerator::GetDocumentation()
   static void GetDocumentation(cmDocumentationEntry &entry);
 
+  /**
+   * Utilized by the generator factory to determine if this generator
+   * supports toolsets.
+   */
+  static bool SupportsToolset() { return false; }
+
   /**
   * Try to determine system information such as shared library
   * extension, pthreads, byte order etc.

Source/cmGlobalNinjaGenerator.h

@@ -73,6 +73,12 @@ public:
    */
   static void WriteComment(std::ostream& os, const std::string& comment);
 
+  /**
+   * Utilized by the generator factory to determine if this generator
+   * supports toolsets.
+   */
+  static bool SupportsToolset() { return false; }
+
   /**
    * Write a build statement to @a os with the @a comment using
    * the @a rule the list of @a outputs files and inputs.

Source/cmGlobalUnixMakefileGenerator3.h

@@ -64,6 +64,12 @@ public:
     return cmGlobalUnixMakefileGenerator3::GetActualName();}
   static std::string GetActualName() {return "Unix Makefiles";}
 
+  /**
+   * Utilized by the generator factory to determine if this generator
+   * supports toolsets.
+   */
+  static bool SupportsToolset() { return false; }
+
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 

Source/cmGlobalVisualStudio10Generator.cxx

@@ -81,6 +81,8 @@ public:
     names.push_back(vs10generatorName + std::string(" IA64"));
     names.push_back(vs10generatorName + std::string(" Win64"));
     }
+
+  virtual bool SupportsToolset() const { return true; }
 };
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio11Generator.cxx

@@ -96,6 +96,8 @@ public:
       names.push_back(std::string(vs11generatorName) + " " + *i);
       }
     }
+
+  virtual bool SupportsToolset() const { return true; }
 };
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio12Generator.cxx

@@ -76,6 +76,8 @@ public:
     names.push_back(vs12generatorName + std::string(" ARM"));
     names.push_back(vs12generatorName + std::string(" Win64"));
     }
+
+  virtual bool SupportsToolset() const { return true; }
 };
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio14Generator.cxx

@@ -76,6 +76,8 @@ public:
     names.push_back(vs14generatorName + std::string(" ARM"));
     names.push_back(vs14generatorName + std::string(" Win64"));
     }
+
+  virtual bool SupportsToolset() const { return true; }
 };
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio6Generator.h

@@ -36,6 +36,12 @@ public:
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
+  /**
+   * Utilized by the generator factory to determine if this generator
+   * supports toolsets.
+   */
+  static bool SupportsToolset() { return false; }
+
   ///! Create a local generator appropriate to this Global Generator
   virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
 

Source/cmGlobalVisualStudio7Generator.h

@@ -52,6 +52,12 @@ public:
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
+  /**
+   * Utilized by the generator factory to determine if this generator
+   * supports toolsets.
+   */
+  static bool SupportsToolset() { return false; }
+
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.

Source/cmGlobalVisualStudio8Generator.cxx

@@ -84,6 +84,8 @@ public:
       names.push_back("Visual Studio 8 2005 " + *i);
       }
   }
+
+  virtual bool SupportsToolset() const { return false; }
 };
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio9Generator.cxx

@@ -88,6 +88,8 @@ public:
       names.push_back("Visual Studio 9 2008 " + *i);
       }
   }
+
+  virtual bool SupportsToolset() const { return false; }
 };
 
 //----------------------------------------------------------------------------

Source/cmGlobalXCodeGenerator.cxx

@@ -125,6 +125,8 @@ public:
 
   virtual void GetGenerators(std::vector<std::string>& names) const {
     names.push_back(cmGlobalXCodeGenerator::GetActualName()); }
+
+  virtual bool SupportsToolset() const { return true; }
 };
 
 //----------------------------------------------------------------------------

Source/cmake.cxx

@@ -957,18 +957,32 @@ void cmake::AddDefaultExtraGenerators()
 
 
 //----------------------------------------------------------------------------
-void cmake::GetRegisteredGenerators(std::vector<std::string>& names)
+void cmake::GetRegisteredGenerators(std::vector<GeneratorInfo>& generators)
 {
-  for(RegisteredGeneratorsVector::const_iterator i = this->Generators.begin();
+  for (RegisteredGeneratorsVector::const_iterator
-      i != this->Generators.end(); ++i)
+       i = this->Generators.begin(), e = this->Generators.end();
+       i != e; ++i)
     {
+    std::vector<std::string> names;
     (*i)->GetGenerators(names);
+
+    for (size_t j = 0; j < names.size(); ++j)
+      {
+      GeneratorInfo info;
+      info.supportsToolset = (*i)->SupportsToolset();
+      info.name = names[j];
+      generators.push_back(info);
+      }
     }
-  for(RegisteredExtraGeneratorsMap::const_iterator
+
-      i = this->ExtraGenerators.begin();
+  for (RegisteredExtraGeneratorsMap::const_iterator
-      i != this->ExtraGenerators.end(); ++i)
+       i = this->ExtraGenerators.begin(), e = this->ExtraGenerators.end();
+       i != e; ++i)
     {
-    names.push_back(i->first);
+    GeneratorInfo info;
+    info.name = i->first;
+    info.supportsToolset = false;
+    generators.push_back(info);
     }
 }
 

Source/cmake.h

@@ -89,6 +89,13 @@ class cmake
      */
     FIND_PACKAGE_MODE
   };
+
+  struct GeneratorInfo
+    {
+    std::string name;
+    bool supportsToolset;
+    };
+
   typedef std::map<std::string, cmInstalledFile> InstalledFilesMap;
 
   /// Default constructor
@@ -161,7 +168,7 @@ class cmake
   void SetGlobalGenerator(cmGlobalGenerator *);
 
   ///! Get the names of the current registered generators
-  void GetRegisteredGenerators(std::vector<std::string>& names);
+  void GetRegisteredGenerators(std::vector<GeneratorInfo>& generators);
 
   ///! Set the name of the selected generator-specific platform.
   void SetGeneratorPlatform(std::string const& ts)