kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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.
This commit is contained in:
Konstantin Podsvirov 2014-08-06 11:23:00 -04:00 committed by Brad King
parent 82382479f7
commit ebe8d51b11
11 changed files with 1684 additions and 996 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Modules/CPackIFW.cmake
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}

4
Source/CMakeLists.txt
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

538
Source/CPack/IFW/cmCPackIFWGenerator.cxx Normal file
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;
}

137
Source/CPack/IFW/cmCPackIFWGenerator.h Normal file
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

289
Source/CPack/IFW/cmCPackIFWInstaller.cxx Normal file
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();
}
}

84
Source/CPack/IFW/cmCPackIFWInstaller.h Normal file
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

486
Source/CPack/IFW/cmCPackIFWPackage.cxx Normal file
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;
}

131
Source/CPack/IFW/cmCPackIFWPackage.h Normal file
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

2
Source/CPack/cmCPackGeneratorFactory.cxx
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"

909
Source/CPack/cmCPackIFWGenerator.cxx
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;
}

82
Source/CPack/cmCPackIFWGenerator.h
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