CPackIFW: Refactor and revise this generator

Split the monolithic cmCPackIFWGenerator source into three parts:
cmCPackIFWGenerator, cmCPackIFWInstaller, and cmCPackIFWPackage
to isolate the implementations somewhat.

Add a COMMON option to the cpack_ifw_configure_component command to make
the data component common to its parent group.

Change the default packaging method to ONE_PACKAGE_PER_COMPONENT.
This is not incompatible because the CPack IFW generator has not
yet been in a release.

Modules/CPackIFW.cmake

@@ -123,6 +123,7 @@
 # ::
 #
 #   cpack_ifw_configure_component(<compname>
+#                       [COMMON]
 #                       [VERSION <version>]
 #                       [SCRIPT <script>]
 #                       [NAME <name>]
@@ -132,7 +133,11 @@
 #
 # This command should be called after cpack_add_component command.
 #
-# ``VERSION`` is version of component. By default used :variable:`CPACK_PACKAGE_VERSION`.
+# ``COMMON`` if set, then the component will be packaged and installed as part
+# of a group to which he belongs.
+#
+# ``VERSION`` is version of component.
+# By default used :variable:`CPACK_PACKAGE_VERSION`.
 #
 # ``SCRIPT`` is relative or absolute path to operations script
 # for this component.
@@ -163,7 +168,8 @@
 #
 # This command should be called after cpack_add_component_group command.
 #
-# ``VERSION`` is version of component group. By default used :variable:`CPACK_PACKAGE_VERSION`.
+# ``VERSION`` is version of component group.
+# By default used :variable:`CPACK_PACKAGE_VERSION`.
 #
 # ``NAME`` is used to create domain-like identification for this component group.
 # By default used origin component group name.
@@ -346,7 +352,7 @@ macro(cpack_ifw_configure_component compname)
 
   string(TOUPPER ${compname} _CPACK_IFWCOMP_UNAME)
 
-  set(_IFW_OPT)
+  set(_IFW_OPT COMMON)
   set(_IFW_ARGS VERSION SCRIPT NAME PRIORITY)
   set(_IFW_MULTI_ARGS DEPENDS LICENSES)
   cmake_parse_arguments(CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME} "${_IFW_OPT}" "${_IFW_ARGS}" "${_IFW_MULTI_ARGS}" ${ARGN})
@@ -367,6 +373,12 @@ macro(cpack_ifw_configure_component compname)
 
   set(_CPACK_IFWCOMP_STR "\n# Configuration for IFW component \"${compname}\"\n")
 
+  foreach(_IFW_ARG_NAME ${_IFW_OPT})
+  cpack_append_option_set_command(
+    CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME}_${_IFW_ARG_NAME}
+    _CPACK_IFWCOMP_STR)
+  endforeach()
+
   foreach(_IFW_ARG_NAME ${_IFW_ARGS})
   cpack_append_string_variable_set_command(
     CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME}_${_IFW_ARG_NAME}

Source/CMakeLists.txt

@@ -577,7 +577,9 @@ set(CPACK_SRCS
   CPack/cmCPackGenerator.cxx
   CPack/cmCPackLog.cxx
   CPack/cmCPackNSISGenerator.cxx
-  CPack/cmCPackIFWGenerator.cxx
+  CPack/IFW/cmCPackIFWPackage.cxx
+  CPack/IFW/cmCPackIFWInstaller.cxx
+  CPack/IFW/cmCPackIFWGenerator.cxx
   CPack/cmCPackSTGZGenerator.cxx
   CPack/cmCPackTGZGenerator.cxx
   CPack/cmCPackTXZGenerator.cxx

Source/CPack/IFW/cmCPackIFWGenerator.cxx

@@ -0,0 +1,538 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#include "cmCPackIFWGenerator.h"
+
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWInstaller.h"
+
+#include <CPack/cmCPackLog.h>
+#include <CPack/cmCPackComponentGroup.h>
+
+#include <cmsys/SystemTools.hxx>
+#include <cmsys/Glob.hxx>
+#include <cmsys/Directory.hxx>
+#include <cmsys/RegularExpression.hxx>
+
+#include <cmGlobalGenerator.h>
+#include <cmLocalGenerator.h>
+#include <cmSystemTools.h>
+#include <cmMakefile.h>
+#include <cmGeneratedFileStream.h>
+#include <cmXMLSafe.h>
+
+//----------------------------------------------------------------------------
+cmCPackIFWGenerator::cmCPackIFWGenerator()
+{
+  // Change the default behavior
+  componentPackageMethod = ONE_PACKAGE_PER_COMPONENT;
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWGenerator::~cmCPackIFWGenerator()
+{
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWGenerator::PackageFiles()
+{
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Configuration" << std::endl);
+
+  // Installer configuragion
+  Installer.GenerateInstallerFile();
+
+  // Packages configuration
+  Installer.GeneratePackageFiles();
+
+  std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+  std::string ifwTmpFile = ifwTLD;
+  ifwTmpFile += "/IFWOutput.log";
+
+  // Run repogen
+  if (!DownloadSite.empty())
+    {
+    std::string ifwCmd = RepoGen;
+    ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+    ifwCmd += " -p " + this->toplevel + "/packages";
+
+    if(!PkgsDirsVector.empty())
+      {
+      for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
+          it != PkgsDirsVector.end(); ++it)
+        {
+        ifwCmd += " -p " + *it;
+        }
+      }
+
+    if (!OnlineOnly && !DownloadedPackages.empty())
+      {
+      ifwCmd += " -i ";
+      std::set<cmCPackIFWPackage*>::iterator it
+        = DownloadedPackages.begin();
+      ifwCmd += (*it)->Name;
+      ++it;
+      while(it != DownloadedPackages.end())
+        {
+        ifwCmd += "," + (*it)->Name;
+        ++it;
+        }
+      }
+    ifwCmd += " " + this->toplevel + "/repository";
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
+                  << std::endl);
+    std::string output;
+    int retVal = 1;
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "- Generate repository" << std::endl);
+    bool res = cmSystemTools::RunSingleCommand(
+      ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0);
+    if ( !res || retVal )
+      {
+      cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+      ofs << "# Run command: " << ifwCmd << std::endl
+          << "# Output:" << std::endl
+          << output << std::endl;
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
+                    << ifwCmd << std::endl
+                    << "Please check " << ifwTmpFile << " for errors"
+                    << std::endl);
+      return 0;
+      }
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: " << this->toplevel
+                  << "/repository generated" << std::endl);
+    }
+
+  // Run binary creator
+  {
+  std::string ifwCmd = BinCreator;
+  ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+  ifwCmd += " -p " + this->toplevel + "/packages";
+
+  if(!PkgsDirsVector.empty())
+    {
+    for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
+        it != PkgsDirsVector.end(); ++it)
+      {
+      ifwCmd += " -p " + *it;
+      }
+    }
+
+  if (OnlineOnly)
+    {
+    ifwCmd += " --online-only";
+    }
+  else if (!DownloadedPackages.empty() && !DownloadSite.empty())
+    {
+    ifwCmd += " -e ";
+    std::set<cmCPackIFWPackage*>::iterator it
+      = DownloadedPackages.begin();
+    ifwCmd += (*it)->Name;
+    ++it;
+    while(it != DownloadedPackages.end())
+      {
+      ifwCmd += "," + (*it)->Name;
+      ++it;
+      }
+    }
+  else if (!DependentPackages.empty())
+    {
+    ifwCmd += " -i ";
+    // Binary
+    std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
+    while(bit != BinaryPackages.end())
+      {
+      ifwCmd += (*bit)->Name + ",";
+      ++bit;
+      }
+    // Depend
+    DependenceMap::iterator it = DependentPackages.begin();
+    ifwCmd += it->second.Name;
+    ++it;
+    while(it != DependentPackages.end())
+      {
+      ifwCmd += "," + it->second.Name;
+      ++it;
+      }
+    }
+  // TODO: set correct name for multipackages
+  if (this->packageFileNames.size() > 0)
+    {
+    ifwCmd += " " + packageFileNames[0];
+    }
+  else
+    {
+    ifwCmd += " installer";
+    }
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
+                << std::endl);
+  std::string output;
+  int retVal = 1;
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl);
+  bool res = cmSystemTools::RunSingleCommand(
+    ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0);
+  if ( !res || retVal )
+    {
+    cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+    ofs << "# Run command: " << ifwCmd << std::endl
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
+                  << ifwCmd << std::endl
+                  << "Please check " << ifwTmpFile << " for errors"
+                  << std::endl);
+    return 0;
+    }
+  }
+
+  return 1;
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
+{
+  const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
+
+  std::string tmpPref = defPrefix ? defPrefix : "";
+
+  if(this->Components.empty())
+    {
+    tmpPref += "packages/" + GetRootPackageName() + "/data";
+    }
+
+  this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
+
+  return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWGenerator::GetOutputExtension()
+{
+  const char *suffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX");
+  return suffix ? suffix : cmCPackGenerator::GetOutputExtension();
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWGenerator::InitializeInternal()
+{
+  // Search Qt Installer Framework tools
+
+  if(!this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND") ||
+     !this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND"))
+    {
+    this->ReadListFile("CPackIFW.cmake");
+    }
+
+  // Look 'binarycreator' executable (needs)
+
+  if(this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND"))
+    {
+    const char *ifwBinCreatorStr =
+      this->GetOption("CPACK_IFW_BINARYCREATOR_EXECUTABLE");
+    BinCreator = ifwBinCreatorStr ? ifwBinCreatorStr : "";
+    }
+  else
+    {
+    BinCreator = "";
+    }
+
+  if (BinCreator.empty())
+    {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find QtIFW compiler \"binarycreator\": "
+                  "likely it is not installed, or not in your PATH"
+                  << std::endl);
+    return 0;
+    }
+
+  // Look 'repogen' executable (optional)
+
+  if(this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND"))
+    {
+    const char *ifwRepoGenStr =
+      this->GetOption("CPACK_IFW_REPOGEN_EXECUTABLE");
+    RepoGen = ifwRepoGenStr ? ifwRepoGenStr : "";
+    }
+  else
+    {
+    RepoGen = "";
+    }
+
+  // Variables that Change Behavior
+
+  // Resolve duplicate names
+  ResolveDuplicateNames = this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES");
+
+  // Additional packages dirs
+  PkgsDirsVector.clear();
+  if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES"))
+    {
+    cmSystemTools::ExpandListArgument(dirs,
+                                      PkgsDirsVector);
+    }
+
+  // Remote repository
+
+  if (const char *site = this->GetOption("CPACK_DOWNLOAD_SITE"))
+    {
+    DownloadSite = site;
+    }
+
+  OnlineOnly = this->IsOn("CPACK_DOWNLOAD_ALL") ? true : false;
+
+  if (!DownloadSite.empty() && RepoGen.empty()) {
+  cmCPackLogger(cmCPackLog::LOG_ERROR,
+                "Cannot find QtIFW repository generator \"repogen\": "
+                "likely it is not installed, or not in your PATH"
+                << std::endl);
+  return 0;
+  }
+
+  // Installer
+  Installer.Generator = this;
+  Installer.ConfigureFromOptions();
+
+  return this->Superclass::InitializeInternal();
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
+{
+  const std::string prefix = "packages/";
+  const std::string suffix = "/data";
+
+  if (componentPackageMethod == ONE_PACKAGE) {
+  return std::string(prefix + GetRootPackageName() + suffix);
+  }
+
+  return prefix
+    + GetComponentPackageName(&Components[componentName])
+    + suffix;
+}
+
+//----------------------------------------------------------------------------
+cmCPackComponent*
+cmCPackIFWGenerator::GetComponent(const std::string &projectName,
+                                  const std::string &componentName)
+{
+  ComponentsMap::iterator cit = Components.find(componentName);
+  if ( cit != Components.end() ) return &(cit->second);
+
+  cmCPackComponent* component
+    = cmCPackGenerator::GetComponent(projectName, componentName);
+  if(!component) return component;
+
+  std::string name = GetComponentPackageName(component);
+  PackagesMap::iterator pit = Packages.find(name);
+  if(pit != Packages.end()) return component;
+
+  cmCPackIFWPackage *package = &Packages[name];
+  package->Name = name;
+  package->Generator = this;
+  if(package->ConfigureFromComponent(component))
+    {
+    package->Installer = &Installer;
+    Installer.Packages.insert(
+      std::pair<std::string, cmCPackIFWPackage*>(
+        name, package));
+    ComponentPackages.insert(
+      std::pair<cmCPackComponent*, cmCPackIFWPackage*>(
+        component, package));
+    if(component->IsDownloaded)
+      {
+      DownloadedPackages.insert(package);
+      }
+    else
+      {
+      BinaryPackages.insert(package);
+      }
+    }
+  else
+    {
+    Packages.erase(name);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot configure package \"" << name <<
+                  "\" for component \"" << component->Name << "\""
+                  << std::endl);
+    }
+
+  return component;
+}
+
+//----------------------------------------------------------------------------
+cmCPackComponentGroup*
+cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName,
+                                       const std::string &groupName)
+{
+  ComponentGoupsMap::iterator git = ComponentGroups.find(groupName);
+  if ( git != ComponentGroups.end() ) return &(git->second);
+
+  cmCPackComponentGroup* group
+    = cmCPackGenerator::GetComponentGroup(projectName, groupName);
+  if(!group) return group;
+
+  std::string name = GetGroupPackageName(group);
+  PackagesMap::iterator pit = Packages.find(name);
+  if(pit != Packages.end()) return group;
+
+  cmCPackIFWPackage *package = &Packages[name];
+  package->Name = name;
+  package->Generator = this;
+  if(package->ConfigureFromComponentGroup(group))
+    {
+    package->Installer = &Installer;
+    Installer.Packages.insert(
+      std::pair<std::string, cmCPackIFWPackage*>(
+        name, package));
+    GroupPackages.insert(
+      std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(
+        group, package));
+    BinaryPackages.insert(package);
+    }
+  else
+    {
+    Packages.erase(name);
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot configure package \"" << name <<
+                  "\" for component group \"" << group->Name << "\""
+                  << std::endl);
+    }
+  return group;
+}
+
+//----------------------------------------------------------------------------
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackIFWGenerator::SupportsSetDestdir() const
+{
+  return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const
+{
+  return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWGenerator::SupportsComponentInstallation() const
+{
+  return true;
+}
+
+//----------------------------------------------------------------------------
+bool cmCPackIFWGenerator::IsOnePackage() const
+{
+  return componentPackageMethod == ONE_PACKAGE;
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWGenerator::GetRootPackageName() const
+{
+  std::string name = "root";
+  if(const char* optIFW_ROOT_PACKAGE_NAME =
+     this->GetOption("CPACK_IFW_ROOT_PACKAGE_NAME"))
+    {
+    name = optIFW_ROOT_PACKAGE_NAME;
+    }
+  else if (const char* optPACKAGE_NAME =
+           this->GetOption("CPACK_PACKAGE_NAME"))
+    {
+    name = optPACKAGE_NAME;
+    }
+  return name;
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
+{
+  std::string name;
+  if (!group) return name;
+  if (cmCPackIFWPackage* package = GetGroupPackage(group))
+    {
+    return package->Name;
+    }
+  const char* option = GetOption(
+    "CPACK_IFW_COMPONENT_GROUP_"
+    + cmsys::SystemTools::UpperCase(group->Name)
+    + "_NAME");
+  name = option ? option : group->Name;
+  if(group->ParentGroup)
+    {
+    cmCPackIFWPackage* package = GetGroupPackage(group->ParentGroup);
+    bool dot = !ResolveDuplicateNames;
+    if(dot && name.substr(0, package->Name.size()) == package->Name)
+      {
+      dot = false;
+      }
+    if(dot)
+      {
+      name = package->Name + "." + name;
+      }
+    }
+  return name;
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWGenerator::GetComponentPackageName(
+  cmCPackComponent *component) const
+{
+  std::string name;
+  if (!component) return name;
+  if (cmCPackIFWPackage* package = GetComponentPackage(component))
+    {
+    return package->Name;
+    }
+  std::string prefix = "CPACK_IFW_COMPONENT_"
+    + cmsys::SystemTools::UpperCase(component->Name)
+    + "_";
+  const char* option = GetOption(prefix + "NAME");
+  name = option ? option : component->Name;
+  if(component->Group)
+    {
+    cmCPackIFWPackage* package = GetGroupPackage(component->Group);
+    if((componentPackageMethod == ONE_PACKAGE_PER_GROUP)
+       || IsOn(prefix + "COMMON"))
+      {
+      return package->Name;
+      }
+    bool dot = !ResolveDuplicateNames;
+    if(dot && name.substr(0, package->Name.size()) == package->Name)
+      {
+      dot = false;
+      }
+    if(dot)
+      {
+      name = package->Name + "." + name;
+      }
+    }
+  return name;
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
+  cmCPackComponentGroup *group) const
+{
+  std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit
+    = GroupPackages.find(group);
+  return pit != GroupPackages.end() ? pit->second : 0;
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
+  cmCPackComponent *component) const
+{
+  std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit
+    = ComponentPackages.find(component);
+  return pit != ComponentPackages.end() ? pit->second : 0;
+}

Source/CPack/IFW/cmCPackIFWGenerator.h

@@ -0,0 +1,137 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#ifndef cmCPackIFWGenerator_h
+#define cmCPackIFWGenerator_h
+
+#include <CPack/cmCPackGenerator.h>
+
+#include "cmCPackIFWPackage.h"
+#include "cmCPackIFWInstaller.h"
+
+/** \class cmCPackIFWGenerator
+ * \brief A generator for Qt Installer Framework tools
+ *
+ * http://qt-project.org/doc/qtinstallerframework/index.html
+ */
+class cmCPackIFWGenerator : public cmCPackGenerator
+{
+public:
+  cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator);
+
+  typedef std::map<std::string, cmCPackIFWPackage> PackagesMap;
+  typedef std::map<std::string, cmCPackComponent> ComponentsMap;
+  typedef std::map<std::string, cmCPackComponentGroup> ComponentGoupsMap;
+  typedef std::map<std::string, cmCPackIFWPackage::DependenceStruct>
+    DependenceMap;
+
+  /**
+   * Construct IFW generator
+   */
+  cmCPackIFWGenerator();
+
+  /**
+   * Destruct IFW generator
+   */
+  virtual ~cmCPackIFWGenerator();
+
+protected: // cmCPackGenerator reimplementation
+
+  /**
+   * @brief Initialize generator
+   * @return 0 on failure
+   */
+  virtual int InitializeInternal();
+  virtual int PackageFiles();
+  virtual const char* GetPackagingInstallPrefix();
+
+  /**
+   * @brief Extension of binary installer
+   * @return Executable suffix or value from default implementation
+   */
+  virtual const char* GetOutputExtension();
+
+  virtual std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName);
+
+  /**
+   * @brief Get Component
+   * @param projectName Project name
+   * @param componentName Component name
+   *
+   * This method calls the base implementation.
+   *
+   * @return Pointer to component
+   */
+  virtual cmCPackComponent* GetComponent(
+    const std::string& projectName,
+    const std::string& componentName);
+
+  /**
+   * @brief Get group of component
+   * @param projectName Project name
+   * @param groupName Component group name
+   *
+   * This method calls the base implementation.
+   *
+   * @return Pointer to component group
+   */
+  virtual cmCPackComponentGroup* GetComponentGroup(
+    const std::string& projectName,
+    const std::string& groupName);
+
+  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
+  virtual bool SupportsAbsoluteDestination() const;
+  virtual bool SupportsComponentInstallation() const;
+
+protected: // Methods
+
+  bool IsOnePackage() const;
+
+  std::string GetRootPackageName() const;
+
+  std::string GetGroupPackageName(cmCPackComponentGroup *group) const;
+  std::string GetComponentPackageName(cmCPackComponent *component) const;
+
+  cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup *group) const;
+  cmCPackIFWPackage* GetComponentPackage(cmCPackComponent *component) const;
+
+protected: // Data
+
+  friend class cmCPackIFWPackage;
+  friend class cmCPackIFWInstaller;
+
+  // Installer
+  cmCPackIFWInstaller Installer;
+  // Collection of packages
+  PackagesMap Packages;
+  // Collection of binary packages
+  std::set<cmCPackIFWPackage*> BinaryPackages;
+  // Collection of downloaded packages
+  std::set<cmCPackIFWPackage*> DownloadedPackages;
+  // Dependent packages
+  DependenceMap DependentPackages;
+  std::map<cmCPackComponent*, cmCPackIFWPackage*> ComponentPackages;
+  std::map<cmCPackComponentGroup*, cmCPackIFWPackage*> GroupPackages;
+
+private:
+  std::string RepoGen;
+  std::string BinCreator;
+
+  std::string DownloadSite;
+
+  bool OnlineOnly;
+  bool ResolveDuplicateNames;
+  std::vector<std::string> PkgsDirsVector;
+};
+
+#endif

Source/CPack/IFW/cmCPackIFWInstaller.cxx

@@ -0,0 +1,289 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#include "cmCPackIFWInstaller.h"
+
+#include "cmCPackIFWGenerator.h"
+
+#include <CPack/cmCPackLog.h>
+
+#include <cmGeneratedFileStream.h>
+#include <cmXMLSafe.h>
+
+#ifdef cmCPackLogger
+# undef cmCPackLogger
+#endif
+#define cmCPackLogger(logType, msg)                                     \
+  do {                                                                  \
+  cmOStringStream cmCPackLog_msg;                                       \
+  cmCPackLog_msg << msg;                                                \
+  if(Generator) {                                                       \
+  Generator->Logger->Log(logType, __FILE__, __LINE__,                   \
+                         cmCPackLog_msg.str().c_str());                 \
+  }                                                                     \
+  } while ( 0 )
+
+//----------------------------------------------------------------------------
+cmCPackIFWInstaller::cmCPackIFWInstaller() :
+  Generator(0)
+{
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWInstaller::GetOption(const std::string &op) const
+{
+  return Generator ? Generator->GetOption(op) : 0;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWInstaller::ConfigureFromOptions()
+{
+  // Name;
+  if (const char* option = GetOption("CPACK_PACKAGE_NAME"))
+    {
+    Name = option;
+    }
+  else
+    {
+    Name = "Your package";
+    }
+
+  // Title;
+  if (const char* optIFW_PACKAGE_TITLE =
+      GetOption("CPACK_IFW_PACKAGE_TITLE"))
+    {
+    Title = optIFW_PACKAGE_TITLE;
+    }
+  else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
+           GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
+    {
+    Title = optPACKAGE_DESCRIPTION_SUMMARY;
+    }
+  else
+    {
+    Title = "Your package description";
+    }
+
+  // Version;
+  if (const char* option = GetOption("CPACK_PACKAGE_VERSION"))
+    {
+    Version = option;
+    }
+  else
+    {
+    Version = "1.0.0";
+    }
+
+  // Publisher
+  if(const char* optIFW_PACKAGE_PUBLISHER =
+     GetOption("CPACK_IFW_PACKAGE_PUBLISHER"))
+    {
+    Publisher = optIFW_PACKAGE_PUBLISHER;
+    }
+  else if(const char* optPACKAGE_VENDOR = GetOption("CPACK_PACKAGE_VENDOR"))
+    {
+    Publisher = optPACKAGE_VENDOR;
+    }
+
+  // ProductUrl
+  if(const char* option = GetOption("CPACK_IFW_PRODUCT_URL"))
+    {
+    ProductUrl = option;
+    }
+
+  // ApplicationIcon
+  if(const char* option = GetOption("CPACK_IFW_PACKAGE_ICON"))
+    {
+    if(cmSystemTools::FileExists(option))
+      {
+      InstallerApplicationIcon = option;
+      }
+    else
+      {
+      // TODO: implement warning
+      }
+    }
+
+  // WindowIcon
+  if(const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON"))
+    {
+    if(cmSystemTools::FileExists(option))
+      {
+      InstallerWindowIcon = option;
+      }
+    else
+      {
+      // TODO: implement warning
+      }
+    }
+
+  // Logo
+  if(const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO"))
+    {
+    if(cmSystemTools::FileExists(option))
+      {
+      Logo = option;
+      }
+    else
+      {
+      // TODO: implement warning
+      }
+    }
+
+  // Default target directory for installation
+  if (const char* optIFW_TARGET_DIRECTORY =
+      GetOption("CPACK_IFW_TARGET_DIRECTORY"))
+    {
+    TargetDir = optIFW_TARGET_DIRECTORY;
+    }
+  else if (const char *optPACKAGE_INSTALL_DIRECTORY =
+           GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY"))
+    {
+    TargetDir = "@ApplicationsDir@/";
+    TargetDir += optPACKAGE_INSTALL_DIRECTORY;
+    }
+  else
+    {
+    TargetDir = "@RootDir@/usr/local";
+    }
+
+  // Default target directory for installation with administrator rights
+  if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY"))
+    {
+    AdminTargetDir = option;
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWInstaller::GenerateInstallerFile()
+{
+  // Lazy directory initialization
+  if(Directory.empty() && Generator)
+    {
+    Directory = Generator->toplevel;
+    }
+
+  // Output stream
+  cmGeneratedFileStream xout((Directory + "/config/config.xml").data());
+
+  xout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
+  xout << "<Installer>" << std::endl;
+
+  xout << "    <Name>" << cmXMLSafe(Name).str() << "</Name>" << std::endl;
+
+  xout << "    <Version>" << Version << "</Version>" << std::endl;
+
+  xout << "    <Title>" << cmXMLSafe(Title).str() << "</Title>"
+       << std::endl;
+
+  if(!Publisher.empty())
+    {
+    xout << "    <Publisher>" << cmXMLSafe(Publisher).str()
+         << "</Publisher>" << std::endl;
+    }
+
+  if(!ProductUrl.empty())
+    {
+    xout << "    <ProductUrl>" << ProductUrl << "</ProductUrl>" << std::endl;
+    }
+
+  // ApplicationIcon
+  if(!InstallerApplicationIcon.empty())
+    {
+    std::string name =
+      cmSystemTools::GetFilenameName(InstallerApplicationIcon);
+    std::string path = Directory + "/config/" + name;
+    name = cmSystemTools::GetFilenameWithoutExtension(name);
+    cmsys::SystemTools::CopyFileIfDifferent(
+      InstallerApplicationIcon.data(), path.data());
+    xout << "    <InstallerApplicationIcon>" << name
+         << "</InstallerApplicationIcon>" << std::endl;
+    }
+
+  // WindowIcon
+  if(!InstallerWindowIcon.empty())
+    {
+    std::string name = cmSystemTools::GetFilenameName(InstallerWindowIcon);
+    std::string path = Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(
+      InstallerWindowIcon.data(), path.data());
+    xout << "    <InstallerWindowIcon>" << name
+         << "</InstallerWindowIcon>" << std::endl;
+    }
+
+  // Logo
+  if(!Logo.empty())
+    {
+    std::string name = cmSystemTools::GetFilenameName(Logo);
+    std::string path = Directory + "/config/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(Logo.data(), path.data());
+    xout << "    <Logo>" << name << "</Logo>" << std::endl;
+    }
+
+  if(!TargetDir.empty())
+    {
+    xout << "    <TargetDir>" << TargetDir << "</TargetDir>" << std::endl;
+    }
+
+  if(!AdminTargetDir.empty())
+    {
+    xout << "    <AdminTargetDir>" << AdminTargetDir
+         << "</AdminTargetDir>" << std::endl;
+    }
+
+  // Site
+  if (!Generator->DownloadSite.empty())
+    {
+    xout << "    <RemoteRepositories>" << std::endl;
+    xout << "        <Repository>" << std::endl;
+    xout << "            <Url>" << Generator->DownloadSite
+         << "</Url>" << std::endl;
+    // These properties can not be set from "cpack_configure_downloads"
+    //                 <Enabled>1</Enabled>
+    //                 <Username>user</Username>
+    //                 <Password>password</Password>
+    //                 <DisplayName>Example repository</DisplayName>
+    xout << "        </Repository>" << std::endl;
+    xout << "    </RemoteRepositories>" << std::endl;
+    }
+
+  // CPack IFW default policy
+  xout << "    <!-- CPack IFW default policy -->" << std::endl;
+  xout << "    <AllowNonAsciiCharacters>true</AllowNonAsciiCharacters>"
+       << std::endl;
+  xout << "    <AllowSpaceInPath>true</AllowSpaceInPath>" << std::endl;
+
+  xout << "</Installer>" << std::endl;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWInstaller::GeneratePackageFiles()
+{
+  if (Packages.empty() || Generator->IsOnePackage())
+    {
+    // Generate default package
+    cmCPackIFWPackage package;
+    package.Generator = Generator;
+    package.Installer = this;
+    package.ConfigureFromOptions();
+    package.GeneratePackageFile();
+    return;
+    }
+
+  // Generate packages meta information
+  for(PackagesMap::iterator pit = Packages.begin();
+      pit != Packages.end(); ++pit)
+    {
+    cmCPackIFWPackage* package = pit->second;
+    package->GeneratePackageFile();
+    }
+}

Source/CPack/IFW/cmCPackIFWInstaller.h

@@ -0,0 +1,84 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#ifndef cmCPackIFWInstaller_h
+#define cmCPackIFWInstaller_h
+
+#include "cmStandardIncludes.h"
+
+class cmCPackIFWPackage;
+class cmCPackIFWGenerator;
+
+/** \class cmCPackIFWInstaller
+ * \brief A binary installer to be created CPack IFW generator
+ */
+class cmCPackIFWInstaller
+{
+public: // Types
+
+  typedef std::map<std::string, cmCPackIFWPackage*> PackagesMap;
+
+public: // Constructor
+
+  /**
+   * Construct installer
+   */
+  cmCPackIFWInstaller();
+
+public: // Configuration
+
+  /// Name of the product being installed
+  std::string Name;
+
+  /// Version number of the product being installed
+  std::string Version;
+
+  /// Name of the installer as displayed on the title bar
+  std::string Title;
+
+  /// Publisher of the software (as shown in the Windows Control Panel)
+  std::string Publisher;
+
+  /// URL to a page that contains product information on your web site
+  std::string ProductUrl;
+
+  /// Filename for a custom installer icon
+  std::string InstallerApplicationIcon;
+
+  /// Filename for a custom window icon
+  std::string InstallerWindowIcon;
+
+  /// Filename for a logo
+  std::string Logo;
+
+  /// Default target directory for installation
+  std::string TargetDir;
+
+  /// Default target directory for installation with administrator rights
+  std::string AdminTargetDir;
+
+public: // Internal implementation
+
+  const char* GetOption(const std::string& op) const;
+
+  void ConfigureFromOptions();
+
+  void GenerateInstallerFile();
+
+  void GeneratePackageFiles();
+
+  cmCPackIFWGenerator* Generator;
+  PackagesMap Packages;
+  std::string Directory;
+};
+
+#endif // cmCPackIFWInstaller_h

Source/CPack/IFW/cmCPackIFWPackage.cxx

@@ -0,0 +1,486 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#include "cmCPackIFWPackage.h"
+
+#include "cmCPackIFWGenerator.h"
+
+#include <CPack/cmCPackLog.h>
+
+#include <cmGeneratedFileStream.h>
+#include <cmTimestamp.h>
+
+//----------------------------------------------------------------- Logger ---
+#ifdef cmCPackLogger
+# undef cmCPackLogger
+#endif
+#define cmCPackLogger(logType, msg)                                     \
+  do {                                                                  \
+  cmOStringStream cmCPackLog_msg;                                       \
+  cmCPackLog_msg << msg;                                                \
+  if(Generator) {                                                       \
+  Generator->Logger->Log(logType, __FILE__, __LINE__,                   \
+                         cmCPackLog_msg.str().c_str());                 \
+  }                                                                     \
+  } while ( 0 )
+
+//---------------------------------------------------------- CompareStruct ---
+cmCPackIFWPackage::CompareStruct::CompareStruct() :
+  Type(CompareNone)
+{
+}
+
+//------------------------------------------------------- DependenceStruct ---
+cmCPackIFWPackage::DependenceStruct::DependenceStruct()
+{
+}
+
+//----------------------------------------------------------------------------
+cmCPackIFWPackage::DependenceStruct::DependenceStruct(
+  const std::string &dependence)
+{
+  // Search compare section
+  size_t pos = std::string::npos;
+  if((pos = dependence.find("<=")) != std::string::npos)
+    {
+    Compare.Type = CompareLessOrEqual;
+    Compare.Value = dependence.substr(pos + 2);
+    }
+  else if((pos = dependence.find(">=")) != std::string::npos)
+    {
+    Compare.Type = CompareGreaterOrEqual;
+    Compare.Value = dependence.substr(pos + 2);
+    }
+  else if((pos = dependence.find("<")) != std::string::npos)
+    {
+    Compare.Type = CompareLess;
+    Compare.Value = dependence.substr(pos + 1);
+    }
+  else if((pos = dependence.find("=")) != std::string::npos)
+    {
+    Compare.Type = CompareEqual;
+    Compare.Value = dependence.substr(pos + 1);
+    }
+  else if((pos = dependence.find(">")) != std::string::npos)
+    {
+    Compare.Type = CompareGreater;
+    Compare.Value = dependence.substr(pos + 1);
+    }
+  Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
+{
+  if (Compare.Type == CompareNone) return Name;
+
+  std::string result = Name;
+
+  if (Compare.Type == CompareLessOrEqual)
+    {
+    result += "<=";
+    }
+  else if (Compare.Type == CompareGreaterOrEqual)
+    {
+    result += ">=";
+    }
+  else if (Compare.Type == CompareLess)
+    {
+    result += "<";
+    }
+  else if (Compare.Type == CompareEqual)
+    {
+    result += "=";
+    }
+  else if (Compare.Type == CompareGreater)
+    {
+    result += ">";
+    }
+
+  result += Compare.Value;
+
+  return result;
+}
+
+//------------------------------------------------------ cmCPackIFWPackage ---
+cmCPackIFWPackage::cmCPackIFWPackage() :
+  Generator(0),
+  Installer(0)
+{
+}
+
+//----------------------------------------------------------------------------
+const char *cmCPackIFWPackage::GetOption(const std::string &op) const
+{
+  return Generator ? Generator->GetOption(op) : 0;
+}
+
+//----------------------------------------------------------------------------
+std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
+{
+  if (!component) return "";
+  const char* option = GetOption(
+    "CPACK_IFW_COMPONENT_"
+    + cmsys::SystemTools::UpperCase(component->Name)
+    + "_NAME");
+  return option ? option : component->Name;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWPackage::DefaultConfiguration()
+{
+  DisplayName = "";
+  Description = "";
+  Version = "";
+  ReleaseDate = "";
+  Script = "";
+  Licenses.clear();
+  SortingPriority = "";
+  Default = "";
+  Virtual = "";
+  ForcedInstallation = "";
+}
+
+//----------------------------------------------------------------------------
+// Defaul configuration (all in one package)
+int cmCPackIFWPackage::ConfigureFromOptions()
+{
+  // Restore defaul configuration
+  DefaultConfiguration();
+
+  // Name
+  Name = Generator->GetRootPackageName();
+
+  // Display name
+  if (const char *option = this->GetOption("CPACK_PACKAGE_NAME"))
+    {
+    DisplayName = option;
+    }
+  else
+    {
+    DisplayName = "Your package";
+    }
+
+  // Description
+  if (const char* option =
+      this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
+    {
+    Description = option;
+    }
+  else
+    {
+    Description = "Your package description";
+    }
+
+  // Version
+  if(const char* option = GetOption("CPACK_PACKAGE_VERSION"))
+    {
+    Version = option;
+    }
+  else
+    {
+    Version = "1.0.0";
+    }
+
+  ForcedInstallation = "true";
+
+  return 1;
+}
+
+//----------------------------------------------------------------------------
+int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
+{
+  if(!component) return 0;
+
+  // Restore defaul configuration
+  DefaultConfiguration();
+
+  std::string prefix = "CPACK_IFW_COMPONENT_"
+    + cmsys::SystemTools::UpperCase(component->Name)
+    + "_";
+
+  // Display name
+  DisplayName = component->DisplayName;
+
+  // Description
+  Description = component->Description;
+
+  // Version
+  if(const char* optVERSION = GetOption(prefix + "VERSION"))
+    {
+    Version = optVERSION;
+    }
+  else if(const char* optPACKAGE_VERSION =
+          GetOption("CPACK_PACKAGE_VERSION"))
+    {
+    Version = optPACKAGE_VERSION;
+    }
+  else
+    {
+    Version = "1.0.0";
+    }
+
+  // Script
+  if (const char* option = GetOption(prefix + "SCRIPT"))
+    {
+    // TODO: add check file exist
+    Script = option;
+    }
+
+  // CMake dependencies
+  if (!component->Dependencies.empty())
+    {
+    std::vector<cmCPackComponent*>::iterator dit;
+    for(dit = component->Dependencies.begin();
+        dit != component->Dependencies.end();
+        ++dit)
+      {
+      Dependencies.insert(Generator->ComponentPackages[*dit]);
+      }
+    }
+
+  // QtIFW dependencies
+  if(const char* option = this->GetOption(prefix + "DEPENDS"))
+    {
+    std::vector<std::string> deps;
+    cmSystemTools::ExpandListArgument(option,
+                                      deps);
+    for(std::vector<std::string>::iterator
+          dit = deps.begin(); dit != deps.end(); ++dit)
+      {
+      DependenceStruct dep(*dit);
+      if (!Generator->Packages.count(dep.Name))
+        {
+        bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
+        DependenceStruct &depRef =
+          Generator->DependentPackages[dep.Name];
+        if(!hasDep)
+          {
+          depRef = dep;
+          }
+        AlienDependencies.insert(&depRef);
+        }
+      }
+    }
+
+  // Licenses
+  if (const char* option = this->GetOption(prefix + "LICENSES"))
+    {
+    Licenses.clear();
+    cmSystemTools::ExpandListArgument( option, Licenses );
+    if ( Licenses.size() % 2 != 0 )
+      {
+      cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
+        << " should contain pairs of <display_name> and <file_path>."
+        << std::endl);
+      Licenses.clear();
+      }
+    }
+
+  // Priority
+  if(const char* option = this->GetOption(prefix + "PRIORITY"))
+    {
+    SortingPriority = option;
+    }
+
+  // Default
+  Default = component->IsDisabledByDefault ? "false" : "true";
+
+  // Virtual
+  Virtual = component->IsHidden ? "true" : "";
+
+  // ForcedInstallation
+  ForcedInstallation = component->IsRequired ? "true" : "false";
+
+  return 1;
+}
+
+//----------------------------------------------------------------------------
+int
+cmCPackIFWPackage::ConfigureFromComponentGroup(cmCPackComponentGroup *group)
+{
+  if(!group) return 0;
+
+  // Restore defaul configuration
+  DefaultConfiguration();
+
+  std::string prefix = "CPACK_IFW_COMPONENT_GROUP_"
+    + cmsys::SystemTools::UpperCase(group->Name)
+    + "_";
+
+  DisplayName = group->DisplayName;
+  Description = group->Description;
+
+  // Version
+  if(const char* optVERSION = GetOption(prefix + "VERSION"))
+    {
+    Version = optVERSION;
+    }
+  else if(const char* optPACKAGE_VERSION =
+          GetOption("CPACK_PACKAGE_VERSION"))
+    {
+    Version = optPACKAGE_VERSION;
+    }
+  else
+    {
+    Version = "1.0.0";
+    }
+
+  // Licenses
+  if (const char* option = this->GetOption(prefix + "LICENSES"))
+    {
+    Licenses.clear();
+    cmSystemTools::ExpandListArgument( option, Licenses );
+    if ( Licenses.size() % 2 != 0 )
+      {
+      cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
+        << " should contain pairs of <display_name> and <file_path>."
+        << std::endl);
+      Licenses.clear();
+      }
+    }
+
+  // Priority
+  if(const char* option = this->GetOption(prefix + "PRIORITY"))
+    {
+    SortingPriority = option;
+    }
+
+  return 1;
+}
+
+//----------------------------------------------------------------------------
+void cmCPackIFWPackage::GeneratePackageFile()
+{
+  // Lazy directory initialization
+  if (Directory.empty())
+    {
+    if(Installer)
+      {
+      Directory = Installer->Directory + "/packages/" + Name;
+      }
+    else if (Generator)
+      {
+      Directory = Generator->toplevel + "/packages/" + Name;
+      }
+    }
+
+  // Output stream
+  cmGeneratedFileStream xout((Directory + "/meta/package.xml").data());
+
+  xout << "<?xml version=\"1.0\"?>" << std::endl;
+  xout << "<Package>" << std::endl;
+
+  xout << "    <DisplayName>" << DisplayName
+       << "</DisplayName>" << std::endl;
+
+  xout << "    <Description>" << Description
+       << "</Description>" << std::endl;
+
+  xout << "    <Name>" << Name << "</Name>" << std::endl;
+
+  xout << "    <Version>" <<  Version
+       << "</Version>" << std::endl;
+
+  xout << "    <ReleaseDate>";
+  if(ReleaseDate.empty())
+    {
+    xout << cmTimestamp().CurrentTime("%Y-%m-%d", true);
+    }
+  else
+    {
+    xout << ReleaseDate;
+    }
+  xout << "</ReleaseDate>" << std::endl;
+
+  // Script (copy to meta dir)
+  if(!Script.empty())
+    {
+    std::string name = cmSystemTools::GetFilenameName(Script);
+    std::string path = Directory + "/meta/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data());
+    xout << "    <Script>" << name << "</Script>" << std::endl;
+    }
+
+  // Dependencies
+  std::set<DependenceStruct> compDepSet;
+  for(std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
+      ait != AlienDependencies.end(); ++ait)
+    {
+    compDepSet.insert(*(*ait));
+    }
+  for(std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
+      it != Dependencies.end(); ++it)
+    {
+    compDepSet.insert(DependenceStruct((*it)->Name));
+    }
+  // Write dependencies
+  if  (!compDepSet.empty())
+    {
+    xout << "    <Dependencies>";
+    std::set<DependenceStruct>::iterator it = compDepSet.begin();
+    xout << it->NameWithCompare();
+    ++it;
+    while(it != compDepSet.end())
+      {
+      xout << "," << it->NameWithCompare();
+      ++it;
+      }
+    xout << "</Dependencies>" << std::endl;
+    }
+
+  // Licenses (copy to meta dir)
+  std::vector<std::string> licenses = Licenses;
+  for(size_t i = 1; i < licenses.size(); i += 2)
+    {
+    std::string name = cmSystemTools::GetFilenameName(licenses[i]);
+    std::string path = Directory + "/meta/" + name;
+    cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data());
+    licenses[i] = name;
+    }
+  if(!licenses.empty())
+    {
+    xout << "    <Licenses>" << std::endl;
+    for(size_t i = 0; i < licenses.size(); i += 2)
+      {
+      xout << "        <License "
+           << "name=\"" << licenses[i] << "\" "
+           << "file=\"" << licenses[i + 1] << "\" "
+           << "/>" <<std::endl;
+      }
+    xout << "    </Licenses>" << std::endl;
+    }
+
+  if (!ForcedInstallation.empty())
+    {
+    xout << "    <ForcedInstallation>" << ForcedInstallation
+         << "</ForcedInstallation>" << std::endl;
+    }
+
+  if (!Virtual.empty())
+    {
+    xout << "    <Virtual>" << Virtual << "</Virtual>" << std::endl;
+    }
+  else if (!Default.empty())
+    {
+    xout << "    <Default>" << Default << "</Default>" << std::endl;
+    }
+
+  // Priority
+  if(!SortingPriority.empty())
+    {
+    xout << "    <SortingPriority>" << SortingPriority
+         << "</SortingPriority>" << std::endl;
+    }
+
+  xout << "</Package>" << std::endl;
+}

Source/CPack/IFW/cmCPackIFWPackage.h

@@ -0,0 +1,131 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+
+#ifndef cmCPackIFWPackage_h
+#define cmCPackIFWPackage_h
+
+#include "cmStandardIncludes.h"
+
+class cmCPackComponent;
+class cmCPackComponentGroup;
+class cmCPackIFWInstaller;
+class cmCPackIFWGenerator;
+
+/** \class cmCPackIFWPackage
+ * \brief A single component to be installed by CPack IFW generator
+ */
+class cmCPackIFWPackage
+{
+public: // Types
+  enum CompareTypes
+  {
+    CompareNone           = 0x0,
+    CompareEqual          = 0x1,
+    CompareLess           = 0x2,
+    CompareLessOrEqual    = 0x3,
+    CompareGreater        = 0x4,
+    CompareGreaterOrEqual = 0x5
+  };
+
+  struct CompareStruct
+  {
+    CompareStruct();
+
+    unsigned int Type;
+    std::string Value;
+  };
+
+  struct DependenceStruct
+  {
+    DependenceStruct();
+    DependenceStruct(const std::string &dependence);
+
+    std::string Name;
+    CompareStruct Compare;
+
+    std::string NameWithCompare() const;
+
+    bool operator < (const DependenceStruct &other) const
+      {
+      return Name < other.Name;
+      }
+  };
+
+public: // [Con|De]structor
+
+  /**
+   * Construct package
+   */
+  cmCPackIFWPackage();
+
+public: // Configuration
+
+  /// Human-readable name of the component
+  std::string DisplayName;
+
+  /// Human-readable description of the component
+  std::string Description;
+
+  /// Version number of the component
+  std::string Version;
+
+  /// Date when this component version was released
+  std::string ReleaseDate;
+
+  /// Domain-like identification for this component
+  std::string Name;
+
+  /// File name of a script being loaded
+  std::string Script;
+
+  /// List of license agreements to be accepted by the installing user
+  std::vector<std::string> Licenses;
+
+  /// Priority of the component in the tree
+  std::string SortingPriority;
+
+  /// Set to true to preselect the component in the installer
+  std::string Default;
+
+  /// Set to true to hide the component from the installer
+  std::string Virtual;
+
+  /// Determines that the package must always be installed
+  std::string ForcedInstallation;
+
+public: // Internal implementation
+
+  const char* GetOption(const std::string& op) const;
+
+  std::string GetComponentName(cmCPackComponent *component);
+
+  void DefaultConfiguration();
+
+  int ConfigureFromOptions();
+  int ConfigureFromComponent(cmCPackComponent *component);
+  int ConfigureFromComponentGroup(cmCPackComponentGroup *group);
+
+  void GeneratePackageFile();
+
+  // Pointer to generator
+  cmCPackIFWGenerator* Generator;
+  // Pointer to installer
+  cmCPackIFWInstaller* Installer;
+  // Collection of dependencies
+  std::set<cmCPackIFWPackage*> Dependencies;
+  // Collection of unresolved dependencies
+  std::set<DependenceStruct*> AlienDependencies;
+  // Patch to package directory
+  std::string Directory;
+};
+
+#endif // cmCPackIFWPackage_h

Source/CPack/cmCPackGeneratorFactory.cxx

@@ -21,7 +21,7 @@
 #include "cmCPack7zGenerator.h"
 #include "cmCPackSTGZGenerator.h"
 #include "cmCPackNSISGenerator.h"
-#include "cmCPackIFWGenerator.h"
+#include "IFW/cmCPackIFWGenerator.h"
 
 #ifdef __APPLE__
 #  include "cmCPackDragNDropGenerator.h"

Source/CPack/cmCPackIFWGenerator.cxx

@@ -1,909 +0,0 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-
-#include "cmCPackIFWGenerator.h"
-
-#include "cmGlobalGenerator.h"
-#include "cmLocalGenerator.h"
-#include "cmSystemTools.h"
-#include "cmMakefile.h"
-#include "cmGeneratedFileStream.h"
-#include "cmCPackLog.h"
-#include "cmCPackComponentGroup.h"
-#include "cmTimestamp.h"
-
-#include <cmsys/SystemTools.hxx>
-#include <cmsys/Glob.hxx>
-#include <cmsys/Directory.hxx>
-#include <cmsys/RegularExpression.hxx>
-#include <cmXMLSafe.h>
-
-//----------------------------------------------------------------------
-cmCPackIFWGenerator::cmCPackIFWGenerator()
-{
-}
-
-//----------------------------------------------------------------------
-cmCPackIFWGenerator::~cmCPackIFWGenerator()
-{
-}
-
-//----------------------------------------------------------------------
-int cmCPackIFWGenerator::PackageFiles()
-{
-  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Configuration" << std::endl);
-
-  if (!IfwCreateConfigFile())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-                  "CPack error: Could not create IFW \"config.xml\" file."
-                  << std::endl);
-    return false;
-    }
-
-  if (Components.empty() && !IfwCreatePackageFile())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-                  "CPack error: Could not create IFW "
-                  "\"root/meta/package.xml\" file."
-                  << std::endl);
-    return false;
-    }
-
-  std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
-  std::string ifwTmpFile = ifwTLD;
-  ifwTmpFile += "/IFWOutput.log";
-
-  std::set<std::string> ifwDependsComponents;
-  std::string ifwBinaryComponents;
-  std::string ifwDownloadedComponents;
-
-  // Create groups meta information
-  std::map<std::string, cmCPackComponentGroup>::iterator groupIt;
-  for(groupIt = this->ComponentGroups.begin();
-      groupIt != this->ComponentGroups.end();
-      ++groupIt
-    )
-    {
-    std::string macroPrefix = "CPACK_IFW_COMPONENT_GROUP_"
-      + cmsys::SystemTools::UpperCase(groupIt->second.Name);
-
-    std::string groupId = IfwGetGroupId(&groupIt->second);
-
-    if(!ifwBinaryComponents.empty()) ifwBinaryComponents += ",";
-    ifwBinaryComponents += groupId;
-
-    std::string pkgMetaDir = this->toplevel + "/packages/"
-      + groupId
-      + "/meta";
-
-    std::string pkgXmlFileName = pkgMetaDir
-      + "/package.xml";
-
-    cmGeneratedFileStream pkgXml(pkgXmlFileName.data());
-    pkgXml << "<?xml version=\"1.0\"?>" << std::endl;
-    pkgXml << "<Package>" << std::endl;
-    pkgXml << "    <DisplayName>" << groupIt->second.DisplayName
-           << "</DisplayName>" << std::endl;
-    pkgXml << "    <Description>" << groupIt->second.Description
-           << "</Description>" << std::endl;
-    pkgXml << "    <Name>" << groupId << "</Name>" << std::endl;
-
-    // Version
-    const char* ifwPackageVersion = this->GetOption("CPACK_PACKAGE_VERSION");
-    const char* ifwGroupVersion = this->GetOption(macroPrefix + "_VERSION");
-    pkgXml << "    <Version>"
-           << (ifwGroupVersion ? ifwGroupVersion : ifwPackageVersion)
-           << "</Version>" << std::endl;
-    pkgXml << "    <ReleaseDate>" << IfwCreateCurrentDate()
-           << "</ReleaseDate>" << std::endl;
-
-    // Licenses
-    std::vector<std::string> licenses;
-    if(IfwParseLicenses(licenses, macroPrefix + "_LICENSES", pkgMetaDir))
-      {
-      pkgXml << "    <Licenses>" << std::endl;
-      for(size_t i = 0; i < licenses.size(); i += 2)
-        {
-        pkgXml << "        <License "
-               << "name=\"" << licenses[i] << "\" "
-               << "file=\"" << licenses[i + 1] << "\" "
-               << "/>" <<std::endl;
-        }
-      pkgXml << "    </Licenses>" << std::endl;
-      }
-
-    // Priority
-    if(const char* ifwGroupPriority =
-       this->GetOption(macroPrefix + "_PRIORITY"))
-      {
-      pkgXml << "    <SortingPriority>" << ifwGroupPriority
-             << "</SortingPriority>" << std::endl;
-      }
-    pkgXml << "</Package>" << std::endl;
-    }
-
-  // Create components meta information
-  std::map<std::string, cmCPackComponent>::iterator compIt;
-  for (compIt = this->Components.begin();
-       compIt != this->Components.end();
-       ++compIt)
-    {
-    // Component id
-    std::string ifwCompId = IfwGetComponentId(&compIt->second);
-
-    std::string pkgMetaDir = this->toplevel + "/"
-      + GetComponentInstallDirNamePrefix(compIt->second.Name)
-      + ifwCompId + "/meta";
-    std::string pkgXmlFileName = pkgMetaDir + "/package.xml";
-    cmGeneratedFileStream pkgXml(pkgXmlFileName.data());
-
-    // Check IFW version for component
-    std::string macroPrefix = "CPACK_IFW_COMPONENT_"
-      + cmsys::SystemTools::UpperCase(compIt->second.Name);
-
-    pkgXml << "<?xml version=\"1.0\"?>" << std::endl;
-    pkgXml << "<Package>" << std::endl;
-    pkgXml << "    <DisplayName>" << compIt->second.DisplayName
-           << "</DisplayName>" << std::endl;
-    pkgXml << "    <Description>" << compIt->second.Description
-           << "</Description>" << std::endl;
-    pkgXml << "    <Name>" << ifwCompId << "</Name>" << std::endl;
-
-    // Version
-    const char* ifwPackageVersion = this->GetOption("CPACK_PACKAGE_VERSION");
-    const char* ifwCompVersion =
-      this->GetOption(macroPrefix + "_VERSION");
-    pkgXml << "    <Version>"
-           <<  (ifwCompVersion ? ifwCompVersion : ifwPackageVersion)
-           << "</Version>" << std::endl;
-
-    pkgXml << "    <ReleaseDate>" << IfwCreateCurrentDate()
-           << "</ReleaseDate>" << std::endl;
-
-    // Script
-    const char* ifwCompScript =
-      this->GetOption(macroPrefix + "_SCRIPT");
-    if (ifwCompScript)
-      {
-      // Copy file
-      std::string ifwCompScriptFile = pkgMetaDir + "/operations.qs";
-      cmsys::SystemTools::CopyFileIfDifferent(ifwCompScript,
-                                              ifwCompScriptFile.data());
-      pkgXml << "    <Script>" << "operations.qs" << "</Script>" << std::endl;
-      }
-
-    // Check dependencies
-    std::set<std::string> compDepSet;
-    // CMake dependencies
-    if (!compIt->second.Dependencies.empty())
-      {
-      std::vector<cmCPackComponent *>::iterator depCompIt;
-      for(depCompIt = compIt->second.Dependencies.begin();
-          depCompIt != compIt->second.Dependencies.end();
-          ++depCompIt)
-        {
-        compDepSet.insert(IfwGetComponentId(*depCompIt));
-        }
-      }
-    // QtIFW dependencies
-    if(const char *ifwCompDepsStr = this->GetOption(macroPrefix + "_DEPENDS"))
-      {
-      std::vector<std::string> ifwCompDepsVector;
-      cmSystemTools::ExpandListArgument(ifwCompDepsStr,
-                                        ifwCompDepsVector);
-      for(std::vector<std::string>::iterator
-            depCompIt = ifwCompDepsVector.begin();
-          depCompIt != ifwCompDepsVector.end(); ++depCompIt)
-        {
-        compDepSet.insert(*depCompIt);
-        ifwDependsComponents.insert(*depCompIt);
-        }
-      }
-
-    // Write dependencies
-    if  (!compDepSet.empty())
-      {
-      pkgXml << "    <Dependencies>";
-      std::set<std::string>::iterator it = compDepSet.begin();
-      pkgXml << *it;
-      ++it;
-      while(it != compDepSet.end())
-        {
-        pkgXml << "," << *it;
-        ++it;
-        }
-      pkgXml << "</Dependencies>" << std::endl;
-      }
-
-    // Licenses
-    std::vector<std::string> licenses;
-    if(IfwParseLicenses(licenses, macroPrefix + "_LICENSES", pkgMetaDir))
-      {
-      pkgXml << "    <Licenses>" << std::endl;
-      for(size_t i = 0; i < licenses.size(); i += 2)
-        {
-        pkgXml << "        <License "
-               << "name=\"" << licenses[i] << "\" "
-               << "file=\"" << licenses[i + 1] << "\" "
-               << "/>" <<std::endl;
-        }
-      pkgXml << "    </Licenses>" << std::endl;
-      }
-
-    // TODO: Check how enable virtual component (now it's allways disabled)
-    if (compIt->second.IsRequired) {
-    pkgXml << "    <ForcedInstallation>true</ForcedInstallation>"
-           << std::endl;
-    } else if (compIt->second.IsDisabledByDefault) {
-    pkgXml << "    <Default>false</Default>" << std::endl;
-    } else if (compIt->second.IsHidden) {
-    pkgXml << "    <Virtual>true</Virtual>" << std::endl;
-    } else {
-    pkgXml << "    <Default>true</Default>" << std::endl;
-    }
-
-    // Priority
-    if(const char* ifwCompPriority =
-       this->GetOption(macroPrefix + "_PRIORITY"))
-      {
-      pkgXml << "    <SortingPriority>" << ifwCompPriority
-             << "</SortingPriority>" << std::endl;
-      }
-
-    pkgXml << "</Package>" << std::endl;
-
-    // Downloaded
-    if (compIt->second.IsDownloaded)
-      {
-      if (!ifwDownloadedComponents.empty()) ifwDownloadedComponents += ",";
-      ifwDownloadedComponents += ifwCompId;
-      }
-    else
-      {
-      if (!ifwBinaryComponents.empty()) ifwBinaryComponents += ",";
-      ifwBinaryComponents += ifwCompId;
-      }
-    }
-
-  // Run repogen
-  if (!ifwDownloadSite.empty())
-    {
-    std::string ifwCmd = ifwRepoGen;
-    ifwCmd += " -c " + this->toplevel + "/config/config.xml";
-    ifwCmd += " -p " + this->toplevel + "/packages";
-
-    if(!ifwPkgsDirsVector.empty())
-      {
-      for(std::vector<std::string>::iterator it = ifwPkgsDirsVector.begin();
-          it != ifwPkgsDirsVector.end(); ++it)
-        {
-        ifwCmd += " -p " + *it;
-        }
-      }
-
-    if (!ifwOnlineOnly && !ifwDownloadedComponents.empty()) {
-    ifwCmd += " -i " + ifwDownloadedComponents;
-    }
-    ifwCmd += " " + this->toplevel + "/repository";
-    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
-                  << std::endl);
-    std::string output;
-    int retVal = 1;
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                  "- Generate repository" << std::endl);
-    bool res = cmSystemTools::RunSingleCommand(
-      ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0);
-    if ( !res || retVal )
-      {
-      cmGeneratedFileStream ofs(ifwTmpFile.c_str());
-      ofs << "# Run command: " << ifwCmd << std::endl
-          << "# Output:" << std::endl
-          << output << std::endl;
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
-                    << ifwCmd << std::endl
-                    << "Please check " << ifwTmpFile << " for errors"
-                    << std::endl);
-      return 0;
-      }
-    }
-
-  // Run binary creator
-  {
-  std::string ifwCmd = ifwBinCreator;
-  ifwCmd += " -c " + this->toplevel + "/config/config.xml";
-  ifwCmd += " -p " + this->toplevel + "/packages";
-
-  if(!ifwPkgsDirsVector.empty())
-    {
-    for(std::vector<std::string>::iterator it = ifwPkgsDirsVector.begin();
-        it != ifwPkgsDirsVector.end(); ++it)
-      {
-      ifwCmd += " -p " + *it;
-      }
-    }
-
-  if (ifwOnlineOnly)
-    {
-    ifwCmd += " --online-only";
-    }
-  else if (!ifwDownloadedComponents.empty() && !ifwDownloadSite.empty())
-    {
-    ifwCmd += " -e " + ifwDownloadedComponents;
-    }
-  else if (!ifwDependsComponents.empty())
-    {
-    ifwCmd += " -i ";
-    std::set<std::string>::iterator it = ifwDependsComponents.begin();
-    ifwCmd += *it;
-    ++it;
-    while(it != ifwDependsComponents.end())
-      {
-      ifwCmd += "," + (*it);
-      ++it;
-      }
-
-    ifwCmd += "," + ifwBinaryComponents;
-    }
-  // TODO: set correct name for multipackages
-  if (this->packageFileNames.size() > 0)
-    {
-    ifwCmd += " " + packageFileNames[0];
-    }
-  else
-    {
-    ifwCmd += " installer";
-    }
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
-                << std::endl);
-  std::string output;
-  int retVal = 1;
-  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl);
-  bool res = cmSystemTools::RunSingleCommand(
-    ifwCmd.c_str(), &output, &retVal, 0, this->GeneratorVerbose, 0);
-  if ( !res || retVal )
-    {
-    cmGeneratedFileStream ofs(ifwTmpFile.c_str());
-    ofs << "# Run command: " << ifwCmd << std::endl
-        << "# Output:" << std::endl
-        << output << std::endl;
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
-                  << ifwCmd << std::endl
-                  << "Please check " << ifwTmpFile << " for errors"
-                  << std::endl);
-    return 0;
-    }
-  }
-
-  return 1;
-}
-
-//----------------------------------------------------------------------
-const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
-{
-  const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
-
-  std::string tmpPref = defPrefix ? defPrefix : "";
-
-  if(this->Components.empty())
-    {
-    tmpPref += "packages/root/data";
-    }
-
-  this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
-
-  return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
-}
-
-//----------------------------------------------------------------------
-const char *cmCPackIFWGenerator::GetOutputExtension()
-{
-  const char *suffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX");
-  return suffix ? suffix : "";
-}
-
-//----------------------------------------------------------------------
-std::string cmCPackIFWGenerator::IfwGetGroupId(cmCPackComponentGroup *group)
-{
-  std::string ifwGroupId;
-  std::string ifwGroupName;
-  std::list<cmCPackComponentGroup*> groups;
-  while(group)
-    {
-    groups.push_front(group);
-    group = group->ParentGroup;
-    }
-  std::list<cmCPackComponentGroup*>::iterator it = groups.begin();
-  if(it != groups.end())
-    {
-    ifwGroupId = IfwGetGroupName(*it);
-    ++it;
-    }
-  while(it != groups.end())
-    {
-    ifwGroupName = IfwGetGroupName(*it);
-
-    if(ifwResolveDuplicateNames)
-      {
-      if(ifwGroupName.substr(0, ifwGroupId.size()) == ifwGroupId)
-        {
-        ifwGroupId = ifwGroupName;
-        ++it;
-        continue;
-        }
-      }
-
-    ifwGroupId += "." + ifwGroupName;
-
-    ++it;
-    }
-
-  return ifwGroupId;
-}
-
-//----------------------------------------------------------------------
-std::string cmCPackIFWGenerator::IfwGetComponentId(cmCPackComponent *component)
-{
-  std::string ifwCompId;
-  if(component) {
-  ifwCompId = IfwGetGroupId(component->Group);
-  if(!ifwCompId.empty()) ifwCompId += ".";
-  std::string ifwCompName = IfwGetComponentName(component);
-  if(ifwResolveDuplicateNames &&
-     (ifwCompName.substr(0, ifwCompId.size()) == ifwCompId))
-    {
-    ifwCompId = ifwCompName;
-    }
-  else
-    {
-    ifwCompId += ifwCompName;
-    }
-  }
-  return ifwCompId;
-}
-
-//----------------------------------------------------------------------
-std::string cmCPackIFWGenerator::IfwGetGroupName(cmCPackComponentGroup *group)
-{
-  std::string ifwGroupName = group->Name;
-  if(const char* name =
-     this->GetOption("CPACK_IFW_COMPONENT_GROUP_"
-                     + cmsys::SystemTools::UpperCase(group->Name) + "_NAME"))
-    {
-    ifwGroupName = name;
-    }
-  return ifwGroupName;
-}
-
-//----------------------------------------------------------------------
-std::string
-cmCPackIFWGenerator::IfwGetComponentName(cmCPackComponent *component)
-{
-  return IfwGetComponentName(component->Name);
-}
-
-//----------------------------------------------------------------------
-std::string
-cmCPackIFWGenerator::IfwGetComponentName(const std::string &componentName)
-{
-  std::string ifwCompName = componentName;
-  if(const char* name =
-     this->GetOption("CPACK_IFW_COMPONENT_"
-                     + cmsys::SystemTools::UpperCase(componentName) + "_NAME"))
-    {
-    ifwCompName = name;
-    }
-  return ifwCompName;
-}
-
-//----------------------------------------------------------------------
-int cmCPackIFWGenerator::InitializeInternal()
-{
-  // Search Qt Installer Framework tools
-
-  if(!this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND") ||
-     !this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND"))
-    {
-    this->ReadListFile("CPackIFW.cmake");
-    }
-
-  // Look 'binarycreator' executable (needs)
-
-  if(this->IsOn("CPACK_IFW_BINARYCREATOR_EXECUTABLE_FOUND"))
-    {
-    const char *ifwBinCreatorStr =
-      this->GetOption("CPACK_IFW_BINARYCREATOR_EXECUTABLE");
-    ifwBinCreator = ifwBinCreatorStr ? ifwBinCreatorStr : "";
-    }
-  else
-    {
-    ifwBinCreator = "";
-    }
-
-  if (ifwBinCreator.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-                  "Cannot find QtIFW compiler \"binarycreator\": "
-                  "likely it is not installed, or not in your PATH"
-                  << std::endl);
-    return 0;
-    }
-
-  // Look 'repogen' executable (optional)
-
-  if(this->IsOn("CPACK_IFW_REPOGEN_EXECUTABLE_FOUND"))
-    {
-    const char *ifwRepoGenStr =
-      this->GetOption("CPACK_IFW_REPOGEN_EXECUTABLE");
-    ifwRepoGen = ifwRepoGenStr ? ifwRepoGenStr : "";
-    }
-  else
-    {
-    ifwRepoGen = "";
-    }
-
-  // // Variables that Change Behavior
-
-  // Resolve duplicate names
-  ifwResolveDuplicateNames = this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES");
-
-  // Additional packages dirs
-  ifwPkgsDirsVector.clear();
-  if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES"))
-    {
-    cmSystemTools::ExpandListArgument(dirs,
-                                      ifwPkgsDirsVector);
-    }
-
-  // Remote repository
-
-  if (const char *site = this->GetOption("CPACK_DOWNLOAD_SITE"))
-    {
-    ifwDownloadSite = site;
-    }
-
-  ifwOnlineOnly = this->IsOn("CPACK_DOWNLOAD_ALL") ? true : false;
-
-  if (!ifwDownloadSite.empty() && ifwRepoGen.empty()) {
-  cmCPackLogger(cmCPackLog::LOG_ERROR,
-                "Cannot find QtIFW repository generator \"repogen\": "
-                "likely it is not installed, or not in your PATH"
-                << std::endl);
-  return 0;
-  }
-
-  return this->Superclass::InitializeInternal();
-}
-
-//----------------------------------------------------------------------
-std::string
-cmCPackIFWGenerator::GetComponentInstallDirNamePrefix(
-  const std::string& /*componentName*/)
-{
-  return "packages/";
-}
-
-//----------------------------------------------------------------------
-std::string
-cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
-  const std::string& componentName)
-{
-  std::map<std::string, cmCPackComponent>::iterator
-    compIt = this->Components.find(componentName);
-
-  cmCPackComponent *comp =
-    compIt != this->Components.end() ? &compIt->second : 0;
-
-  const std::string prefix = GetComponentInstallDirNamePrefix(componentName);
-  const std::string suffix = "/data";
-
-  if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
-  return prefix + IfwGetComponentId(comp) + suffix;
-  }
-
-  if (componentPackageMethod == ONE_PACKAGE) {
-  return std::string(prefix + "ALL_COMPONENTS_IN_ONE" + suffix);
-  }
-
-  return prefix + IfwGetComponentId(comp) + suffix;
-}
-
-//----------------------------------------------------------------------
-bool cmCPackIFWGenerator::GetListOfSubdirectories(
-  const char* topdir, std::vector<std::string>& dirs)
-{
-  cmsys::Directory dir;
-  dir.Load(topdir);
-  size_t fileNum;
-  for (fileNum = 0; fileNum <  dir.GetNumberOfFiles(); ++fileNum)
-    {
-    if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") &&
-        strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".."))
-      {
-      cmsys_stl::string fullPath = topdir;
-      fullPath += "/";
-      fullPath += dir.GetFile(static_cast<unsigned long>(fileNum));
-      if(cmsys::SystemTools::FileIsDirectory(fullPath.c_str()) &&
-         !cmsys::SystemTools::FileIsSymlink(fullPath.c_str()))
-        {
-        if (!this->GetListOfSubdirectories(fullPath.c_str(), dirs))
-          {
-          return false;
-          }
-        }
-      }
-    }
-  dirs.push_back(topdir);
-  return true;
-}
-
-//----------------------------------------------------------------------
-enum cmCPackGenerator::CPackSetDestdirSupport
-cmCPackIFWGenerator::SupportsSetDestdir() const
-{
-  return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
-}
-
-//----------------------------------------------------------------------
-bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const
-{
-  return false;
-}
-
-//----------------------------------------------------------------------
-bool cmCPackIFWGenerator::SupportsComponentInstallation() const
-{
-  return true;
-}
-
-//----------------------------------------------------------------------
-int cmCPackIFWGenerator::IfwCreateConfigFile()
-{
-  cmGeneratedFileStream cfg((this->toplevel + "/config/config.xml").data());
-
-  std::string ifwPkgName;
-  if (const char *name = this->GetOption("CPACK_PACKAGE_NAME"))
-    {
-    ifwPkgName = name;
-    }
-  else
-    {
-    ifwPkgName = "Your package";
-    }
-
-  std::string pkgTitle;
-  if (const char *title = this->GetOption("CPACK_IFW_PACKAGE_TITLE"))
-    {
-    pkgTitle = title;
-    }
-  else if (const char *description =
-           this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
-    {
-    pkgTitle = description;
-    }
-  else
-    {
-    pkgTitle = "Your package description";
-    }
-
-  std::string ifwPkgVersion;
-  if (const char *version = this->GetOption("CPACK_PACKAGE_VERSION"))
-    {
-    ifwPkgVersion = version;
-    }
-  else
-    {
-    ifwPkgVersion = "1.0.0";
-    }
-
-  const char *ifwPkgInstDir =
-    this->GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY");
-  const char *ifwTargetDir =
-    this->GetOption("CPACK_IFW_TARGET_DIRECTORY");
-  const char *ifwAdminTargetDir =
-    this->GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY");
-
-  cfg << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
-  cfg << "<Installer>" << std::endl;
-  cfg << "    <Name>" << cmXMLSafe(ifwPkgName).str() << "</Name>" << std::endl;
-  cfg << "    <Version>" << ifwPkgVersion << "</Version>" << std::endl;
-  cfg << "    <Title>" << cmXMLSafe(pkgTitle).str() << "</Title>"
-      << std::endl;
-
-  // Publisher
-  std::string ifwPublisher;
-  if(const char *publisher = GetOption("CPACK_IFW_PACKAGE_PUBLISHER"))
-    {
-    ifwPublisher = publisher;
-    }
-  else if(const char *vendor = GetOption("CPACK_PACKAGE_VENDOR"))
-    {
-    ifwPublisher = vendor;
-    }
-  if(!ifwPublisher.empty())
-    {
-    cfg << "    <Publisher>" << cmXMLSafe(ifwPublisher).str()
-        << "</Publisher>" << std::endl;
-    }
-
-  // ProductUrl
-  if(const char *url = GetOption("CPACK_IFW_PRODUCT_URL"))
-    {
-    cfg << "    <ProductUrl>" << url << "</ProductUrl>" << std::endl;
-    }
-
-  // ApplicationIcon
-  const char *pkgApplicationIcon = GetOption("CPACK_IFW_PACKAGE_ICON");
-  if(pkgApplicationIcon && cmSystemTools::FileExists(pkgApplicationIcon))
-    {
-    std::string name = cmSystemTools::GetFilenameName(pkgApplicationIcon);
-    std::string path = this->toplevel + "/config/" + name;
-    name = cmSystemTools::GetFilenameWithoutExtension(name);
-    cmsys::SystemTools::CopyFileIfDifferent(pkgApplicationIcon, path.data());
-    cfg << "    <InstallerApplicationIcon>" << name
-        << "</InstallerApplicationIcon>" << std::endl;
-    }
-
-  // WindowIcon
-  const char *pkgWindowIcon = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON");
-  if(pkgWindowIcon && cmSystemTools::FileExists(pkgWindowIcon))
-    {
-    std::string name = cmSystemTools::GetFilenameName(pkgWindowIcon);
-    std::string path = this->toplevel + "/config/" + name;
-    cmsys::SystemTools::CopyFileIfDifferent(pkgWindowIcon, path.data());
-    cfg << "    <InstallerWindowIcon>" << name
-        << "</InstallerWindowIcon>" << std::endl;
-    }
-
-  // Logo
-  const char *pkgLogo = GetOption("CPACK_IFW_PACKAGE_LOGO");
-  if(pkgLogo && cmSystemTools::FileExists(pkgLogo))
-    {
-    std::string name = cmSystemTools::GetFilenameName(pkgLogo);
-    std::string path = this->toplevel + "/config/" + name;
-    cmsys::SystemTools::CopyFileIfDifferent(pkgLogo, path.data());
-    cfg << "    <Logo>" << name << "</Logo>" << std::endl;
-    }
-
-  // Default target directory for installation
-  if (ifwTargetDir)
-    {
-    cfg << "    <TargetDir>" << ifwTargetDir << "</TargetDir>" << std::endl;
-    }
-  else if (ifwPkgInstDir)
-    {
-    cfg << "    <TargetDir>@ApplicationsDir@/" << ifwPkgInstDir
-        << "</TargetDir>" << std::endl;
-    }
-  else
-    {
-    cfg << "    <TargetDir>@RootDir@/usr/local</TargetDir>" << std::endl;
-    }
-
-  // Default target directory for installation with administrator rights
-  if (ifwAdminTargetDir)
-    {
-    cfg << "    <AdminTargetDir>" << ifwAdminTargetDir
-        << "</AdminTargetDir>" << std::endl;
-    }
-
-  if (!ifwDownloadSite.empty())
-    {
-    cfg << "    <RemoteRepositories>" << std::endl;
-    cfg << "        <Repository>" << std::endl;
-    cfg << "            <Url>" << ifwDownloadSite << "</Url>" << std::endl;
-    // These properties can now be set from "cpack_configure_downloads"
-    //                 <Enabled>1</Enabled>
-    //                 <Username>user</Username>
-    //                 <Password>password</Password>
-    //                 <DisplayName>Example repository</DisplayName>
-    cfg << "        </Repository>" << std::endl;
-    cfg << "    </RemoteRepositories>" << std::endl;
-    }
-
-  // CPack IFW default policy
-  cfg << "    <!-- CPack IFW default policy -->" << std::endl;
-  cfg << "    <AllowNonAsciiCharacters>true</AllowNonAsciiCharacters>"
-      << std::endl;
-  cfg << "    <AllowSpaceInPath>true</AllowSpaceInPath>" << std::endl;
-
-  cfg << "</Installer>" << std::endl;
-
-  return 1;
-}
-
-//----------------------------------------------------------------------
-// Create default package file
-int cmCPackIFWGenerator::IfwCreatePackageFile()
-{
-  std::string ifwPkgName;
-  if (const char *name = this->GetOption("CPACK_PACKAGE_NAME"))
-    {
-    ifwPkgName = name;
-    }
-  else
-    {
-    ifwPkgName = "Your package";
-    }
-
-  std::string ifwPkgDescription;
-  if (const char *name = this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
-    {
-    ifwPkgDescription = name;
-    }
-  else
-    {
-    ifwPkgDescription = "Your package description";
-    }
-
-  cmGeneratedFileStream
-    pkgXml((this->toplevel + "/packages/root/meta/package.xml").data());
-  pkgXml << "<?xml version=\"1.0\"?>" << std::endl;
-  pkgXml << "<Package>" << std::endl;
-
-  pkgXml << "    <DisplayName>" << ifwPkgName << "</DisplayName>" << std::endl;
-  pkgXml << "    <Description>" << ifwPkgDescription
-         << "</Description>" << std::endl;
-  pkgXml << "    <Name>" << "root" << "</Name>" << std::endl;
-  pkgXml << "    <Version>" << this->GetOption("CPACK_PACKAGE_VERSION")
-         << "</Version>" << std::endl;
-  pkgXml << "    <ReleaseDate>" << IfwCreateCurrentDate() << "</ReleaseDate>"
-         << std::endl;
-
-  pkgXml << "    <ForcedInstallation>true</ForcedInstallation>" << std::endl;
-  pkgXml << "    <Default>true</Default>" << std::endl;
-
-  pkgXml << "</Package>" << std::endl;
-
-  return 1;
-}
-
-//----------------------------------------------------------------------
-std::string cmCPackIFWGenerator::IfwCreateCurrentDate()
-{
-  cmTimestamp timestamp;
-  return timestamp.CurrentTime("%Y-%m-%d", false);
-}
-
-//----------------------------------------------------------------------
-bool cmCPackIFWGenerator::IfwParseLicenses(std::vector<std::string> &licenses,
-                                           const std::string &variable,
-                                           const std::string &metaDir)
-{
-  if (const char *option = this->GetOption(variable))
-    {
-    if(!licenses.empty()) licenses.clear();
-    cmSystemTools::ExpandListArgument( option, licenses );
-    }
-  else
-    {
-    return false;
-    }
-
-  if ( licenses.size() % 2 != 0 )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, variable
-                  << " should contain pairs of <display_name> and <file_path>."
-                  << std::endl);
-    return false;
-    }
-
-  for(size_t i = 1; i < licenses.size(); i += 2)
-    {
-    std::string name = cmSystemTools::GetFilenameName(licenses[i]);
-    std::string path = metaDir + "/" + name;
-    cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data());
-    licenses[i] = name;
-    }
-
-  return licenses.size() > 1;
-}

Source/CPack/cmCPackIFWGenerator.h

@@ -1,82 +0,0 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2009 Kitware, Inc.
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-
-#ifndef cmCPackIFWGenerator_h
-#define cmCPackIFWGenerator_h
-
-
-#include "cmCPackGenerator.h"
-#include <set>
-
-/** \class cmCPackIFWGenerator
- * \brief A generator for Qt Installer Framework tools
- *
- * http://qt-project.org/doc/qtinstallerframework/index.html
- */
-class cmCPackIFWGenerator : public cmCPackGenerator
-{
-public:
-  cmCPackTypeMacro(cmCPackIFWGenerator, cmCPackGenerator);
-
-  /**
-   * Construct generator
-   */
-  cmCPackIFWGenerator();
-  virtual ~cmCPackIFWGenerator();
-
-protected:
-  virtual int InitializeInternal();
-  virtual int PackageFiles();
-  virtual const char* GetPackagingInstallPrefix();
-
-  virtual const char* GetOutputExtension();
-
-  std::string IfwGetGroupId(cmCPackComponentGroup *group);
-  std::string IfwGetComponentId(cmCPackComponent *component);
-
-   std::string IfwGetGroupName(cmCPackComponentGroup *group);
-
-  std::string IfwGetComponentName(cmCPackComponent *component);
-  std::string IfwGetComponentName(const std::string &componentName);
-
-  virtual std::string GetComponentInstallDirNamePrefix(
-      const std::string& componentName);
-
-  virtual std::string GetComponentInstallDirNameSuffix(
-      const std::string& componentName);
-
-  bool GetListOfSubdirectories(const char* dir,
-    std::vector<std::string>& dirs);
-
-  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
-  virtual bool SupportsAbsoluteDestination() const;
-  virtual bool SupportsComponentInstallation() const;
-
-private:
-  int IfwCreateConfigFile();
-  int IfwCreatePackageFile();
-  std::string IfwCreateCurrentDate();
-  bool IfwParseLicenses(std::vector<std::string> &licenses,
-                        const std::string &variable,
-                        const std::string &metaDir);
-
-  std::string ifwRepoGen;
-  std::string ifwBinCreator;
-
-  std::string ifwDownloadSite;
-
-  bool ifwOnlineOnly;
-  bool ifwResolveDuplicateNames;
-  std::vector<std::string> ifwPkgsDirsVector;
-};
-
-#endif