Merge topic 'cpack-ifw-generator'

ebe8d51b CPackIFW: Refactor and revise this generator
82382479 Doxygen: Add STRIP_FROM_PATH variable to doxyfile.in
3040ab8f Doxygen: Add CPack/IFW subdir to doxyfile.in INPUT section
This commit is contained in:
Brad King 2014-08-11 09:54:10 -04:00 committed by CMake Topic Stage
commit 2fdd5d88a1
12 changed files with 1689 additions and 996 deletions

View File

@ -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}

View File

@ -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

View File

@ -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;
}

View File

@ -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

View File

@ -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();
}
}

View File

@ -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

View File

@ -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;
}

View File

@ -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

View File

@ -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"

View File

@ -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;
}

View File

@ -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

View File

@ -6,6 +6,10 @@
PROJECT_NAME = CMake
FULL_PATH_NAMES = YES
STRIP_FROM_PATH = \
"@CMake_SOURCE_DIR@/Source/" \
"@CMake_BINARY_DIR@/Source/"
WARN_IF_UNDOCUMENTED = NO
GENERATE_TREEVIEW = NO
@ -40,6 +44,7 @@ OUTPUT_DIRECTORY = "@CMake_BINARY_DIR@/Utilities/Doxygen/doc"
INPUT = \
"@CMake_SOURCE_DIR@/Source" \
"@CMake_SOURCE_DIR@/Source/CPack" \
"@CMake_SOURCE_DIR@/Source/CPack/IFW" \
"@CMake_SOURCE_DIR@/Source/CTest" \
"@CMake_SOURCE_DIR@/Source/CursesDialog" \
"@CMake_SOURCE_DIR@/Source/MFCDialog" \