mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-01-06 21:59:54 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge topic 'cpackifw-access-refactoring'

Browse Source 
543cf134 CPackIFW: Access refactoring

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !820
This commit is contained in:
Brad King
2017-05-11 13:56:45 +00:00
committed by Kitware Robot
parent e736dd9389 543cf13406
commit c2ea011830
5 changed files with 583 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
Source/CPack/IFW/cmCPackIFWCommon.cxx
View File

@@ -19,67 +19,72 @@ cmCPackIFWCommon::cmCPackIFWCommon()
const char* cmCPackIFWCommon::GetOption(const std::string& op) const
{
return Generator ? Generator->cmCPackGenerator::GetOption(op) : CM_NULLPTR;
return this->Generator ? this->Generator->cmCPackGenerator::GetOption(op)
: CM_NULLPTR;
}
bool cmCPackIFWCommon::IsOn(const std::string& op) const
{
return Generator ? Generator->cmCPackGenerator::IsOn(op) : false;
return this->Generator ? this->Generator->cmCPackGenerator::IsOn(op) : false;
}
bool cmCPackIFWCommon::IsSetToOff(const std::string& op) const
{
return Generator ? Generator->cmCPackGenerator::IsSetToOff(op) : false;
return this->Generator ? this->Generator->cmCPackGenerator::IsSetToOff(op)
: false;
}
bool cmCPackIFWCommon::IsSetToEmpty(const std::string& op) const
{
return Generator ? Generator->cmCPackGenerator::IsSetToEmpty(op) : false;
return this->Generator ? this->Generator->cmCPackGenerator::IsSetToEmpty(op)
: false;
}
bool cmCPackIFWCommon::IsVersionLess(const char* version)
{
if (!Generator) {
if (!this->Generator) {
return false;
}
return cmSystemTools::VersionCompare(
cmSystemTools::OP_LESS, Generator->FrameworkVersion.data(), version);
cmSystemTools::OP_LESS, this->Generator->FrameworkVersion.data(), version);
}
bool cmCPackIFWCommon::IsVersionGreater(const char* version)
{
if (!Generator) {
if (!this->Generator) {
return false;
}
return cmSystemTools::VersionCompare(
cmSystemTools::OP_GREATER, Generator->FrameworkVersion.data(), version);
cmSystemTools::OP_GREATER, this->Generator->FrameworkVersion.data(),
version);
}
bool cmCPackIFWCommon::IsVersionEqual(const char* version)
{
if (!Generator) {
if (!this->Generator) {
return false;
}
return cmSystemTools::VersionCompare(
cmSystemTools::OP_EQUAL, Generator->FrameworkVersion.data(), version);
cmSystemTools::OP_EQUAL, this->Generator->FrameworkVersion.data(),
version);
}
void cmCPackIFWCommon::WriteGeneratedByToStrim(cmXMLWriter& xout)
{
if (!Generator) {
if (!this->Generator) {
return;
}
std::ostringstream comment;
comment << "Generated by CPack " << CMake_VERSION << " IFW generator "
<< "for QtIFW ";
if (IsVersionEqual("1.9.9")) {
if (this->IsVersionEqual("1.9.9")) {
comment << "less 2.0";
} else {
comment << Generator->FrameworkVersion;
comment << this->Generator->FrameworkVersion;
}
comment << " tools at " << cmTimestamp().CurrentTime("", true);
xout.Comment(comment.str().c_str());

225
Source/CPack/IFW/cmCPackIFWGenerator.cxx
View File

@@ -17,7 +17,7 @@
cmCPackIFWGenerator::cmCPackIFWGenerator()
{
Generator = this;
this->Generator = this;
}
cmCPackIFWGenerator::~cmCPackIFWGenerator()
@@ -29,38 +29,40 @@ int cmCPackIFWGenerator::PackageFiles()
cmCPackIFWLogger(OUTPUT, "- Configuration" << std::endl);
// Installer configuragion
Installer.GenerateInstallerFile();
this->Installer.GenerateInstallerFile();
// Packages configuration
Installer.GeneratePackageFiles();
this->Installer.GeneratePackageFiles();
std::string ifwTLD = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
std::string ifwTmpFile = ifwTLD;
ifwTmpFile += "/IFWOutput.log";
// Run repogen
if (!Installer.RemoteRepositories.empty()) {
std::string ifwCmd = RepoGen;
if (!this->Installer.RemoteRepositories.empty()) {
std::string ifwCmd = this->RepoGen;
if (IsVersionLess("2.0.0")) {
if (this->IsVersionLess("2.0.0")) {
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) {
if (!this->PkgsDirsVector.empty()) {
for (std::vector<std::string>::iterator it =
this->PkgsDirsVector.begin();
it != this->PkgsDirsVector.end(); ++it) {
ifwCmd += " -p " + *it;
}
}
if (!OnlineOnly && !DownloadedPackages.empty()) {
if (!this->OnlineOnly && !this->DownloadedPackages.empty()) {
ifwCmd += " -i ";
std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
std::set<cmCPackIFWPackage*>::iterator it =
this->DownloadedPackages.begin();
ifwCmd += (*it)->Name;
++it;
while (it != DownloadedPackages.end()) {
while (it != this->DownloadedPackages.end()) {
ifwCmd += "," + (*it)->Name;
++it;
}
@@ -85,8 +87,8 @@ int cmCPackIFWGenerator::PackageFiles()
return 0;
}
if (!Repository.RepositoryUpdate.empty() &&
!Repository.PatchUpdatesXml()) {
if (!this->Repository.RepositoryUpdate.empty() &&
!this->Repository.PatchUpdatesXml()) {
cmCPackIFWLogger(WARNING, "Problem patch IFW \"Updates\" "
<< "file: "
<< this->toplevel + "/repository/Updates.xml"
@@ -100,16 +102,17 @@ int cmCPackIFWGenerator::PackageFiles()
// Run binary creator
{
std::string ifwCmd = BinCreator;
std::string ifwCmd = this->BinCreator;
ifwCmd += " -c " + this->toplevel + "/config/config.xml";
if (!Installer.Resources.empty()) {
if (!this->Installer.Resources.empty()) {
ifwCmd += " -r ";
std::vector<std::string>::iterator it = Installer.Resources.begin();
std::vector<std::string>::iterator it =
this->Installer.Resources.begin();
std::string path = this->toplevel + "/resources/";
ifwCmd += path + *it;
++it;
while (it != Installer.Resources.end()) {
while (it != this->Installer.Resources.end()) {
ifwCmd += "," + path + *it;
++it;
}
@@ -117,45 +120,48 @@ int cmCPackIFWGenerator::PackageFiles()
ifwCmd += " -p " + this->toplevel + "/packages";
if (!PkgsDirsVector.empty()) {
for (std::vector<std::string>::iterator it = PkgsDirsVector.begin();
it != PkgsDirsVector.end(); ++it) {
if (!this->PkgsDirsVector.empty()) {
for (std::vector<std::string>::iterator it =
this->PkgsDirsVector.begin();
it != this->PkgsDirsVector.end(); ++it) {
ifwCmd += " -p " + *it;
}
}
if (OnlineOnly) {
if (this->OnlineOnly) {
ifwCmd += " --online-only";
} else if (!DownloadedPackages.empty() &&
!Installer.RemoteRepositories.empty()) {
} else if (!this->DownloadedPackages.empty() &&
!this->Installer.RemoteRepositories.empty()) {
ifwCmd += " -e ";
std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
std::set<cmCPackIFWPackage*>::iterator it =
this->DownloadedPackages.begin();
ifwCmd += (*it)->Name;
++it;
while (it != DownloadedPackages.end()) {
while (it != this->DownloadedPackages.end()) {
ifwCmd += "," + (*it)->Name;
++it;
}
} else if (!DependentPackages.empty()) {
} else if (!this->DependentPackages.empty()) {
ifwCmd += " -i ";
// Binary
std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
while (bit != BinaryPackages.end()) {
std::set<cmCPackIFWPackage*>::iterator bit =
this->BinaryPackages.begin();
while (bit != this->BinaryPackages.end()) {
ifwCmd += (*bit)->Name + ",";
++bit;
}
// Depend
DependenceMap::iterator it = DependentPackages.begin();
DependenceMap::iterator it = this->DependentPackages.begin();
ifwCmd += it->second.Name;
++it;
while (it != DependentPackages.end()) {
while (it != this->DependentPackages.end()) {
ifwCmd += "," + it->second.Name;
++it;
}
}
// TODO: set correct name for multipackages
if (!this->packageFileNames.empty()) {
ifwCmd += " " + packageFileNames[0];
ifwCmd += " " + this->packageFileNames[0];
} else {
ifwCmd += " installer";
}
@@ -184,12 +190,12 @@ int cmCPackIFWGenerator::PackageFiles()
const char* cmCPackIFWGenerator::GetPackagingInstallPrefix()
{
const char* defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
const char* defPrefix = this->cmCPackGenerator::GetPackagingInstallPrefix();
std::string tmpPref = defPrefix ? defPrefix : "";
if (this->Components.empty()) {
tmpPref += "packages/" + GetRootPackageName() + "/data";
tmpPref += "packages/" + this->GetRootPackageName() + "/data";
}
this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
@@ -199,7 +205,7 @@ const char* cmCPackIFWGenerator::GetPackagingInstallPrefix()
const char* cmCPackIFWGenerator::GetOutputExtension()
{
return ExecutableSuffix.c_str();
return this->ExecutableSuffix.c_str();
}
int cmCPackIFWGenerator::InitializeInternal()
@@ -219,12 +225,12 @@ int cmCPackIFWGenerator::InitializeInternal()
const char* BinCreatorStr = this->GetOption(BinCreatorOpt);
if (!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr)) {
BinCreator = "";
this->BinCreator = "";
} else {
BinCreator = BinCreatorStr;
this->BinCreator = BinCreatorStr;
}
if (BinCreator.empty()) {
if (this->BinCreator.empty()) {
cmCPackIFWLogger(ERROR, "Cannot find QtIFW compiler \"binarycreator\": "
"likely it is not installed, or not in your PATH"
<< std::endl);
@@ -235,39 +241,40 @@ int cmCPackIFWGenerator::InitializeInternal()
const char* RepoGenStr = this->GetOption(RepoGenOpt);
if (!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr)) {
RepoGen = "";
this->RepoGen = "";
} else {
RepoGen = RepoGenStr;
this->RepoGen = RepoGenStr;
}
// Framework version
if (const char* FrameworkVersionSrt = this->GetOption(FrameworkVersionOpt)) {
FrameworkVersion = FrameworkVersionSrt;
this->FrameworkVersion = FrameworkVersionSrt;
} else {
FrameworkVersion = "1.9.9";
this->FrameworkVersion = "1.9.9";
}
// Variables that Change Behavior
// Resolve duplicate names
ResolveDuplicateNames = this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES");
this->ResolveDuplicateNames =
this->IsOn("CPACK_IFW_RESOLVE_DUPLICATE_NAMES");
// Additional packages dirs
PkgsDirsVector.clear();
this->PkgsDirsVector.clear();
if (const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES")) {
cmSystemTools::ExpandListArgument(dirs, PkgsDirsVector);
cmSystemTools::ExpandListArgument(dirs, this->PkgsDirsVector);
}
// Installer
Installer.Generator = this;
Installer.ConfigureFromOptions();
this->Installer.Generator = this;
this->Installer.ConfigureFromOptions();
// Repository
Repository.Generator = this;
Repository.Name = "Unspecified";
this->Repository.Generator = this;
this->Repository.Name = "Unspecified";
if (const char* site = this->GetOption("CPACK_DOWNLOAD_SITE")) {
Repository.Url = site;
Installer.RemoteRepositories.push_back(&Repository);
this->Repository.Url = site;
this->Installer.RemoteRepositories.push_back(&this->Repository);
}
// Repositories
@@ -276,20 +283,20 @@ int cmCPackIFWGenerator::InitializeInternal()
cmSystemTools::ExpandListArgument(RepoAllStr, RepoAllVector);
for (std::vector<std::string>::iterator rit = RepoAllVector.begin();
rit != RepoAllVector.end(); ++rit) {
GetRepository(*rit);
this->GetRepository(*rit);
}
}
if (const char* ifwDownloadAll = this->GetOption("CPACK_IFW_DOWNLOAD_ALL")) {
OnlineOnly = cmSystemTools::IsOn(ifwDownloadAll);
this->OnlineOnly = cmSystemTools::IsOn(ifwDownloadAll);
} else if (const char* cpackDownloadAll =
this->GetOption("CPACK_DOWNLOAD_ALL")) {
OnlineOnly = cmSystemTools::IsOn(cpackDownloadAll);
this->OnlineOnly = cmSystemTools::IsOn(cpackDownloadAll);
} else {
OnlineOnly = false;
this->OnlineOnly = false;
}
if (!Installer.RemoteRepositories.empty() && RepoGen.empty()) {
if (!this->Installer.RemoteRepositories.empty() && this->RepoGen.empty()) {
cmCPackIFWLogger(ERROR,
"Cannot find QtIFW repository generator \"repogen\": "
"likely it is not installed, or not in your PATH"
@@ -299,15 +306,15 @@ int cmCPackIFWGenerator::InitializeInternal()
// Executable suffix
if (const char* optExeSuffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX")) {
ExecutableSuffix = optExeSuffix;
if (ExecutableSuffix.empty()) {
this->ExecutableSuffix = optExeSuffix;
if (this->ExecutableSuffix.empty()) {
std::string sysName(this->GetOption("CMAKE_SYSTEM_NAME"));
if (sysName == "Linux") {
ExecutableSuffix = ".run";
this->ExecutableSuffix = ".run";
}
}
} else {
ExecutableSuffix = cmCPackGenerator::GetOutputExtension();
this->ExecutableSuffix = this->cmCPackGenerator::GetOutputExtension();
}
return this->Superclass::InitializeInternal();
@@ -319,49 +326,50 @@ std::string cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
const std::string prefix = "packages/";
const std::string suffix = "/data";
if (componentPackageMethod == ONE_PACKAGE) {
return std::string(prefix + GetRootPackageName() + suffix);
if (this->componentPackageMethod == this->ONE_PACKAGE) {
return std::string(prefix + this->GetRootPackageName() + suffix);
}
return prefix + GetComponentPackageName(&Components[componentName]) + suffix;
return prefix +
this->GetComponentPackageName(&this->Components[componentName]) + suffix;
}
cmCPackComponent* cmCPackIFWGenerator::GetComponent(
const std::string& projectName, const std::string& componentName)
{
ComponentsMap::iterator cit = Components.find(componentName);
if (cit != Components.end()) {
ComponentsMap::iterator cit = this->Components.find(componentName);
if (cit != this->Components.end()) {
return &(cit->second);
}
cmCPackComponent* component =
cmCPackGenerator::GetComponent(projectName, componentName);
this->cmCPackGenerator::GetComponent(projectName, componentName);
if (!component) {
return component;
}
std::string name = GetComponentPackageName(component);
PackagesMap::iterator pit = Packages.find(name);
if (pit != Packages.end()) {
std::string name = this->GetComponentPackageName(component);
PackagesMap::iterator pit = this->Packages.find(name);
if (pit != this->Packages.end()) {
return component;
}
cmCPackIFWPackage* package = &Packages[name];
cmCPackIFWPackage* package = &this->Packages[name];
package->Name = name;
package->Generator = this;
if (package->ConfigureFromComponent(component)) {
package->Installer = &Installer;
Installer.Packages.insert(
package->Installer = &this->Installer;
this->Installer.Packages.insert(
std::pair<std::string, cmCPackIFWPackage*>(name, package));
ComponentPackages.insert(
this->ComponentPackages.insert(
std::pair<cmCPackComponent*, cmCPackIFWPackage*>(component, package));
if (component->IsDownloaded) {
DownloadedPackages.insert(package);
this->DownloadedPackages.insert(package);
} else {
BinaryPackages.insert(package);
this->BinaryPackages.insert(package);
}
} else {
Packages.erase(name);
this->Packages.erase(name);
cmCPackIFWLogger(ERROR, "Cannot configure package \""
<< name << "\" for component \"" << component->Name
<< "\"" << std::endl);
@@ -374,29 +382,29 @@ cmCPackComponentGroup* cmCPackIFWGenerator::GetComponentGroup(
const std::string& projectName, const std::string& groupName)
{
cmCPackComponentGroup* group =
cmCPackGenerator::GetComponentGroup(projectName, groupName);
this->cmCPackGenerator::GetComponentGroup(projectName, groupName);
if (!group) {
return group;
}
std::string name = GetGroupPackageName(group);
PackagesMap::iterator pit = Packages.find(name);
if (pit != Packages.end()) {
std::string name = this->GetGroupPackageName(group);
PackagesMap::iterator pit = this->Packages.find(name);
if (pit != this->Packages.end()) {
return group;
}
cmCPackIFWPackage* package = &Packages[name];
cmCPackIFWPackage* package = &this->Packages[name];
package->Name = name;
package->Generator = this;
if (package->ConfigureFromGroup(group)) {
package->Installer = &Installer;
Installer.Packages.insert(
package->Installer = &this->Installer;
this->Installer.Packages.insert(
std::pair<std::string, cmCPackIFWPackage*>(name, package));
GroupPackages.insert(
this->GroupPackages.insert(
std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(group, package));
BinaryPackages.insert(package);
this->BinaryPackages.insert(package);
} else {
Packages.erase(name);
this->Packages.erase(name);
cmCPackIFWLogger(ERROR, "Cannot configure package \""
<< name << "\" for component group \"" << group->Name
<< "\"" << std::endl);
@@ -422,7 +430,7 @@ bool cmCPackIFWGenerator::SupportsComponentInstallation() const
bool cmCPackIFWGenerator::IsOnePackage() const
{
return componentPackageMethod == ONE_PACKAGE;
return this->componentPackageMethod == cmCPackGenerator::ONE_PACKAGE;
}
std::string cmCPackIFWGenerator::GetRootPackageName()
@@ -455,16 +463,16 @@ std::string cmCPackIFWGenerator::GetGroupPackageName(
if (!group) {
return name;
}
if (cmCPackIFWPackage* package = GetGroupPackage(group)) {
if (cmCPackIFWPackage* package = this->GetGroupPackage(group)) {
return package->Name;
}
const char* option =
GetOption("CPACK_IFW_COMPONENT_GROUP_" +
cmsys::SystemTools::UpperCase(group->Name) + "_NAME");
this->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;
cmCPackIFWPackage* package = this->GetGroupPackage(group->ParentGroup);
bool dot = !this->ResolveDuplicateNames;
if (dot && name.substr(0, package->Name.size()) == package->Name) {
dot = false;
}
@@ -482,20 +490,21 @@ std::string cmCPackIFWGenerator::GetComponentPackageName(
if (!component) {
return name;
}
if (cmCPackIFWPackage* package = GetComponentPackage(component)) {
if (cmCPackIFWPackage* package = this->GetComponentPackage(component)) {
return package->Name;
}
std::string prefix = "CPACK_IFW_COMPONENT_" +
cmsys::SystemTools::UpperCase(component->Name) + "_";
const char* option = GetOption(prefix + "NAME");
const char* option = this->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")) {
cmCPackIFWPackage* package = this->GetGroupPackage(component->Group);
if ((this->componentPackageMethod ==
cmCPackGenerator::ONE_PACKAGE_PER_GROUP) ||
this->IsOn(prefix + "COMMON")) {
return package->Name;
}
bool dot = !ResolveDuplicateNames;
bool dot = !this->ResolveDuplicateNames;
if (dot && name.substr(0, package->Name.size()) == package->Name) {
dot = false;
}
@@ -510,37 +519,37 @@ cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
cmCPackComponentGroup* group) const
{
std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit =
GroupPackages.find(group);
return pit != GroupPackages.end() ? pit->second : CM_NULLPTR;
this->GroupPackages.find(group);
return pit != this->GroupPackages.end() ? pit->second : CM_NULLPTR;
}
cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
cmCPackComponent* component) const
{
std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit =
ComponentPackages.find(component);
return pit != ComponentPackages.end() ? pit->second : CM_NULLPTR;
this->ComponentPackages.find(component);
return pit != this->ComponentPackages.end() ? pit->second : CM_NULLPTR;
}
cmCPackIFWRepository* cmCPackIFWGenerator::GetRepository(
const std::string& repositoryName)
{
RepositoriesMap::iterator rit = Repositories.find(repositoryName);
if (rit != Repositories.end()) {
RepositoriesMap::iterator rit = this->Repositories.find(repositoryName);
if (rit != this->Repositories.end()) {
return &(rit->second);
}
cmCPackIFWRepository* repository = &Repositories[repositoryName];
cmCPackIFWRepository* repository = &this->Repositories[repositoryName];
repository->Name = repositoryName;
repository->Generator = this;
if (repository->ConfigureFromOptions()) {
if (repository->Update == cmCPackIFWRepository::None) {
Installer.RemoteRepositories.push_back(repository);
this->Installer.RemoteRepositories.push_back(repository);
} else {
Repository.RepositoryUpdate.push_back(repository);
this->Repository.RepositoryUpdate.push_back(repository);
}
} else {
Repositories.erase(repositoryName);
this->Repositories.erase(repositoryName);
repository = CM_NULLPTR;
cmCPackIFWLogger(WARNING, "Invalid repository \""
<< repositoryName << "\""

313
Source/CPack/IFW/cmCPackIFWInstaller.cxx
View File

@@ -35,107 +35,107 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
// Name;
if (const char* optIFW_PACKAGE_NAME =
this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
Name = optIFW_PACKAGE_NAME;
this->Name = optIFW_PACKAGE_NAME;
} else if (const char* optPACKAGE_NAME =
this->GetOption("CPACK_PACKAGE_NAME")) {
Name = optPACKAGE_NAME;
this->Name = optPACKAGE_NAME;
} else {
Name = "Your package";
this->Name = "Your package";
}
// Title;
if (const char* optIFW_PACKAGE_TITLE =
GetOption("CPACK_IFW_PACKAGE_TITLE")) {
Title = optIFW_PACKAGE_TITLE;
this->GetOption("CPACK_IFW_PACKAGE_TITLE")) {
this->Title = optIFW_PACKAGE_TITLE;
} else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
Title = optPACKAGE_DESCRIPTION_SUMMARY;
this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
this->Title = optPACKAGE_DESCRIPTION_SUMMARY;
} else {
Title = "Your package description";
this->Title = "Your package description";
}
// Version;
if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) {
Version = option;
if (const char* option = this->GetOption("CPACK_PACKAGE_VERSION")) {
this->Version = option;
} else {
Version = "1.0.0";
this->Version = "1.0.0";
}
// Publisher
if (const char* optIFW_PACKAGE_PUBLISHER =
GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) {
Publisher = optIFW_PACKAGE_PUBLISHER;
this->GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) {
this->Publisher = optIFW_PACKAGE_PUBLISHER;
} else if (const char* optPACKAGE_VENDOR =
GetOption("CPACK_PACKAGE_VENDOR")) {
Publisher = optPACKAGE_VENDOR;
this->Publisher = optPACKAGE_VENDOR;
}
// ProductUrl
if (const char* option = GetOption("CPACK_IFW_PRODUCT_URL")) {
ProductUrl = option;
if (const char* option = this->GetOption("CPACK_IFW_PRODUCT_URL")) {
this->ProductUrl = option;
}
// ApplicationIcon
if (const char* option = GetOption("CPACK_IFW_PACKAGE_ICON")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_ICON")) {
if (cmSystemTools::FileExists(option)) {
InstallerApplicationIcon = option;
this->InstallerApplicationIcon = option;
} else {
printSkippedOptionWarning("CPACK_IFW_PACKAGE_ICON", option);
this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_ICON", option);
}
}
// WindowIcon
if (const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON")) {
if (cmSystemTools::FileExists(option)) {
InstallerWindowIcon = option;
this->InstallerWindowIcon = option;
} else {
printSkippedOptionWarning("CPACK_IFW_PACKAGE_WINDOW_ICON", option);
this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_WINDOW_ICON", option);
}
}
// Logo
if (const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_LOGO")) {
if (cmSystemTools::FileExists(option)) {
Logo = option;
this->Logo = option;
} else {
printSkippedOptionWarning("CPACK_IFW_PACKAGE_LOGO", option);
this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_LOGO", option);
}
}
// Watermark
if (const char* option = GetOption("CPACK_IFW_PACKAGE_WATERMARK")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_WATERMARK")) {
if (cmSystemTools::FileExists(option)) {
Watermark = option;
this->Watermark = option;
} else {
printSkippedOptionWarning("CPACK_IFW_PACKAGE_WATERMARK", option);
this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_WATERMARK", option);
}
}
// Banner
if (const char* option = GetOption("CPACK_IFW_PACKAGE_BANNER")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_BANNER")) {
if (cmSystemTools::FileExists(option)) {
Banner = option;
this->Banner = option;
} else {
printSkippedOptionWarning("CPACK_IFW_PACKAGE_BANNER", option);
this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_BANNER", option);
}
}
// Background
if (const char* option = GetOption("CPACK_IFW_PACKAGE_BACKGROUND")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_BACKGROUND")) {
if (cmSystemTools::FileExists(option)) {
Background = option;
this->Background = option;
} else {
printSkippedOptionWarning("CPACK_IFW_PACKAGE_BACKGROUND", option);
this->printSkippedOptionWarning("CPACK_IFW_PACKAGE_BACKGROUND", option);
}
}
// WizardStyle
if (const char* option = GetOption("CPACK_IFW_PACKAGE_WIZARD_STYLE")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_WIZARD_STYLE")) {
// Setting the user value in any case
WizardStyle = option;
this->WizardStyle = option;
// Check known values
if (WizardStyle != "Modern" && WizardStyle != "Aero" &&
WizardStyle != "Mac" && WizardStyle != "Classic") {
if (this->WizardStyle != "Modern" && this->WizardStyle != "Aero" &&
this->WizardStyle != "Mac" && this->WizardStyle != "Classic") {
cmCPackIFWLogger(
WARNING, "Option CPACK_IFW_PACKAGE_WIZARD_STYLE has unknown value \""
<< option << "\". Expected values are: Modern, Aero, Mac, Classic."
@@ -145,87 +145,89 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
// WizardDefaultWidth
if (const char* option =
GetOption("CPACK_IFW_PACKAGE_WIZARD_DEFAULT_WIDTH")) {
WizardDefaultWidth = option;
this->GetOption("CPACK_IFW_PACKAGE_WIZARD_DEFAULT_WIDTH")) {
this->WizardDefaultWidth = option;
}
// WizardDefaultHeight
if (const char* option =
GetOption("CPACK_IFW_PACKAGE_WIZARD_DEFAULT_HEIGHT")) {
WizardDefaultHeight = option;
this->GetOption("CPACK_IFW_PACKAGE_WIZARD_DEFAULT_HEIGHT")) {
this->WizardDefaultHeight = option;
}
// TitleColor
if (const char* option = GetOption("CPACK_IFW_PACKAGE_TITLE_COLOR")) {
TitleColor = option;
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_TITLE_COLOR")) {
this->TitleColor = option;
}
// Start menu
if (const char* optIFW_START_MENU_DIR =
this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY")) {
StartMenuDir = optIFW_START_MENU_DIR;
this->StartMenuDir = optIFW_START_MENU_DIR;
} else {
StartMenuDir = Name;
this->StartMenuDir = Name;
}
// Default target directory for installation
if (const char* optIFW_TARGET_DIRECTORY =
GetOption("CPACK_IFW_TARGET_DIRECTORY")) {
TargetDir = optIFW_TARGET_DIRECTORY;
this->GetOption("CPACK_IFW_TARGET_DIRECTORY")) {
this->TargetDir = optIFW_TARGET_DIRECTORY;
} else if (const char* optPACKAGE_INSTALL_DIRECTORY =
GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY")) {
TargetDir = "@ApplicationsDir@/";
TargetDir += optPACKAGE_INSTALL_DIRECTORY;
this->GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY")) {
this->TargetDir = "@ApplicationsDir@/";
this->TargetDir += optPACKAGE_INSTALL_DIRECTORY;
} else {
TargetDir = "@RootDir@/usr/local";
this->TargetDir = "@RootDir@/usr/local";
}
// Default target directory for installation with administrator rights
if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY")) {
AdminTargetDir = option;
if (const char* option =
this->GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY")) {
this->AdminTargetDir = option;
}
// Maintenance tool
if (const char* optIFW_MAINTENANCE_TOOL =
this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME")) {
MaintenanceToolName = optIFW_MAINTENANCE_TOOL;
this->MaintenanceToolName = optIFW_MAINTENANCE_TOOL;
}
// Maintenance tool ini file
if (const char* optIFW_MAINTENANCE_TOOL_INI =
this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE")) {
MaintenanceToolIniFile = optIFW_MAINTENANCE_TOOL_INI;
this->MaintenanceToolIniFile = optIFW_MAINTENANCE_TOOL_INI;
}
// Allow non-ASCII characters
if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
if (IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
AllowNonAsciiCharacters = "true";
if (this->IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
this->AllowNonAsciiCharacters = "true";
} else {
AllowNonAsciiCharacters = "false";
this->AllowNonAsciiCharacters = "false";
}
}
// Space in path
if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
if (IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
AllowSpaceInPath = "true";
if (this->IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
this->AllowSpaceInPath = "true";
} else {
AllowSpaceInPath = "false";
this->AllowSpaceInPath = "false";
}
}
// Control script
if (const char* optIFW_CONTROL_SCRIPT =
this->GetOption("CPACK_IFW_PACKAGE_CONTROL_SCRIPT")) {
ControlScript = optIFW_CONTROL_SCRIPT;
this->ControlScript = optIFW_CONTROL_SCRIPT;
}
// Resources
if (const char* optIFW_PACKAGE_RESOURCES =
this->GetOption("CPACK_IFW_PACKAGE_RESOURCES")) {
Resources.clear();
cmSystemTools::ExpandListArgument(optIFW_PACKAGE_RESOURCES, Resources);
this->Resources.clear();
cmSystemTools::ExpandListArgument(optIFW_PACKAGE_RESOURCES,
this->Resources);
}
}
@@ -239,19 +241,20 @@ public:
: installer(i)
, file(false)
{
path = i->Directory + "/resources";
this->path = i->Directory + "/resources";
}
bool ParseResource(size_t r)
{
hasFiles = false;
hasErrors = false;
this->hasFiles = false;
this->hasErrors = false;
basePath = cmSystemTools::GetFilenamePath(installer->Resources[r]);
this->basePath =
cmSystemTools::GetFilenamePath(this->installer->Resources[r]);
ParseFile(installer->Resources[r].data());
this->ParseFile(this->installer->Resources[r].data());
return hasFiles && !hasErrors;
return this->hasFiles && !this->hasErrors;
}
cmCPackIFWInstaller* installer;
@@ -261,22 +264,22 @@ public:
protected:
void StartElement(const std::string& name, const char** /*atts*/) CM_OVERRIDE
{
file = name == "file";
this->file = name == "file";
if (file) {
hasFiles = true;
this->hasFiles = true;
}
}
void CharacterDataHandler(const char* data, int length) CM_OVERRIDE
{
if (file) {
if (this->file) {
std::string content(data, data + length);
content = cmSystemTools::TrimWhitespace(content);
std::string source = basePath + "/" + content;
std::string destination = path + "/" + content;
std::string source = this->basePath + "/" + content;
std::string destination = this->path + "/" + content;
if (!cmSystemTools::CopyFileIfDifferent(source.data(),
destination.data())) {
hasErrors = true;
this->hasErrors = true;
}
}
}
@@ -287,12 +290,12 @@ protected:
void cmCPackIFWInstaller::GenerateInstallerFile()
{
// Lazy directory initialization
if (Directory.empty() && Generator) {
Directory = Generator->toplevel;
if (this->Directory.empty() && this->Generator) {
this->Directory = this->Generator->toplevel;
}
// Output stream
cmGeneratedFileStream fout((Directory + "/config/config.xml").data());
cmGeneratedFileStream fout((this->Directory + "/config/config.xml").data());
cmXMLWriter xout(fout);
xout.StartDocument();
@@ -301,163 +304,165 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
xout.StartElement("Installer");
xout.Element("Name", Name);
xout.Element("Version", Version);
xout.Element("Title", Title);
xout.Element("Name", this->Name);
xout.Element("Version", this->Version);
xout.Element("Title", this->Title);
if (!Publisher.empty()) {
xout.Element("Publisher", Publisher);
if (!this->Publisher.empty()) {
xout.Element("Publisher", this->Publisher);
}
if (!ProductUrl.empty()) {
xout.Element("ProductUrl", ProductUrl);
if (!this->ProductUrl.empty()) {
xout.Element("ProductUrl", this->ProductUrl);
}
// ApplicationIcon
if (!InstallerApplicationIcon.empty()) {
if (!this->InstallerApplicationIcon.empty()) {
std::string name =
cmSystemTools::GetFilenameName(InstallerApplicationIcon);
std::string path = Directory + "/config/" + name;
cmSystemTools::GetFilenameName(this->InstallerApplicationIcon);
std::string path = this->Directory + "/config/" + name;
name = cmSystemTools::GetFilenameWithoutExtension(name);
cmsys::SystemTools::CopyFileIfDifferent(InstallerApplicationIcon, path);
cmsys::SystemTools::CopyFileIfDifferent(this->InstallerApplicationIcon,
path);
xout.Element("InstallerApplicationIcon", name);
}
// WindowIcon
if (!InstallerWindowIcon.empty()) {
std::string name = cmSystemTools::GetFilenameName(InstallerWindowIcon);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(InstallerWindowIcon, path);
if (!this->InstallerWindowIcon.empty()) {
std::string name =
cmSystemTools::GetFilenameName(this->InstallerWindowIcon);
std::string path = this->Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->InstallerWindowIcon, path);
xout.Element("InstallerWindowIcon", name);
}
// Logo
if (!Logo.empty()) {
std::string name = cmSystemTools::GetFilenameName(Logo);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Logo, path);
if (!this->Logo.empty()) {
std::string name = cmSystemTools::GetFilenameName(this->Logo);
std::string path = this->Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->Logo, path);
xout.Element("Logo", name);
}
// Banner
if (!Banner.empty()) {
std::string name = cmSystemTools::GetFilenameName(Banner);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Banner, path);
if (!this->Banner.empty()) {
std::string name = cmSystemTools::GetFilenameName(this->Banner);
std::string path = this->Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->Banner, path);
xout.Element("Banner", name);
}
// Watermark
if (!Watermark.empty()) {
std::string name = cmSystemTools::GetFilenameName(Watermark);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Watermark, path);
if (!this->Watermark.empty()) {
std::string name = cmSystemTools::GetFilenameName(this->Watermark);
std::string path = this->Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->Watermark, path);
xout.Element("Watermark", name);
}
// Background
if (!Background.empty()) {
std::string name = cmSystemTools::GetFilenameName(Background);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Background, path);
if (!this->Background.empty()) {
std::string name = cmSystemTools::GetFilenameName(this->Background);
std::string path = this->Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->Background, path);
xout.Element("Background", name);
}
// WizardStyle
if (!WizardStyle.empty()) {
xout.Element("WizardStyle", WizardStyle);
if (!this->WizardStyle.empty()) {
xout.Element("WizardStyle", this->WizardStyle);
}
// WizardDefaultWidth
if (!WizardDefaultWidth.empty()) {
xout.Element("WizardDefaultWidth", WizardDefaultWidth);
if (!this->WizardDefaultWidth.empty()) {
xout.Element("WizardDefaultWidth", this->WizardDefaultWidth);
}
// WizardDefaultHeight
if (!WizardDefaultHeight.empty()) {
xout.Element("WizardDefaultHeight", WizardDefaultHeight);
if (!this->WizardDefaultHeight.empty()) {
xout.Element("WizardDefaultHeight", this->WizardDefaultHeight);
}
// TitleColor
if (!TitleColor.empty()) {
xout.Element("TitleColor", TitleColor);
if (!this->TitleColor.empty()) {
xout.Element("TitleColor", this->TitleColor);
}
// Start menu
if (!IsVersionLess("2.0")) {
xout.Element("StartMenuDir", StartMenuDir);
if (!this->IsVersionLess("2.0")) {
xout.Element("StartMenuDir", this->StartMenuDir);
}
// Target dir
if (!TargetDir.empty()) {
xout.Element("TargetDir", TargetDir);
if (!this->TargetDir.empty()) {
xout.Element("TargetDir", this->TargetDir);
}
// Admin target dir
if (!AdminTargetDir.empty()) {
xout.Element("AdminTargetDir", AdminTargetDir);
if (!this->AdminTargetDir.empty()) {
xout.Element("AdminTargetDir", this->AdminTargetDir);
}
// Remote repositories
if (!RemoteRepositories.empty()) {
if (!this->RemoteRepositories.empty()) {
xout.StartElement("RemoteRepositories");
for (RepositoriesVector::iterator rit = RemoteRepositories.begin();
rit != RemoteRepositories.end(); ++rit) {
for (RepositoriesVector::iterator rit = this->RemoteRepositories.begin();
rit != this->RemoteRepositories.end(); ++rit) {
(*rit)->WriteRepositoryConfig(xout);
}
xout.EndElement();
}
// Maintenance tool
if (!IsVersionLess("2.0") && !MaintenanceToolName.empty()) {
xout.Element("MaintenanceToolName", MaintenanceToolName);
if (!this->IsVersionLess("2.0") && !this->MaintenanceToolName.empty()) {
xout.Element("MaintenanceToolName", this->MaintenanceToolName);
}
// Maintenance tool ini file
if (!IsVersionLess("2.0") && !MaintenanceToolIniFile.empty()) {
xout.Element("MaintenanceToolIniFile", MaintenanceToolIniFile);
if (!this->IsVersionLess("2.0") && !this->MaintenanceToolIniFile.empty()) {
xout.Element("MaintenanceToolIniFile", this->MaintenanceToolIniFile);
}
// Different allows
if (IsVersionLess("2.0")) {
if (this->IsVersionLess("2.0")) {
// CPack IFW default policy
xout.Comment("CPack IFW default policy for QtIFW less 2.0");
xout.Element("AllowNonAsciiCharacters", "true");
xout.Element("AllowSpaceInPath", "true");
} else {
if (!AllowNonAsciiCharacters.empty()) {
xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
if (!this->AllowNonAsciiCharacters.empty()) {
xout.Element("AllowNonAsciiCharacters", this->AllowNonAsciiCharacters);
}
if (!AllowSpaceInPath.empty()) {
xout.Element("AllowSpaceInPath", AllowSpaceInPath);
if (!this->AllowSpaceInPath.empty()) {
xout.Element("AllowSpaceInPath", this->AllowSpaceInPath);
}
}
// Control script (copy to config dir)
if (!IsVersionLess("2.0") && !ControlScript.empty()) {
std::string name = cmSystemTools::GetFilenameName(ControlScript);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(ControlScript, path);
if (!this->IsVersionLess("2.0") && !this->ControlScript.empty()) {
std::string name = cmSystemTools::GetFilenameName(this->ControlScript);
std::string path = this->Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->ControlScript, path);
xout.Element("ControlScript", name);
}
// Resources (copy to resources dir)
if (!Resources.empty()) {
if (!this->Resources.empty()) {
std::vector<std::string> resources;
cmCPackIFWResourcesParser parser(this);
for (size_t i = 0; i < Resources.size(); i++) {
for (size_t i = 0; i < this->Resources.size(); i++) {
if (parser.ParseResource(i)) {
std::string name = cmSystemTools::GetFilenameName(Resources[i]);
std::string path = Directory + "/resources/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Resources[i], path);
std::string name = cmSystemTools::GetFilenameName(this->Resources[i]);
std::string path = this->Directory + "/resources/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->Resources[i], path);
resources.push_back(name);
} else {
cmCPackIFWLogger(WARNING, "Can't copy resources from \""
<< Resources[i] << "\". Resource will be skipped."
<< std::endl);
<< this->Resources[i]
<< "\". Resource will be skipped." << std::endl);
}
}
Resources = resources;
this->Resources = resources;
}
xout.EndElement();
@@ -466,13 +471,13 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
void cmCPackIFWInstaller::GeneratePackageFiles()
{
if (Packages.empty() || Generator->IsOnePackage()) {
if (this->Packages.empty() || this->Generator->IsOnePackage()) {
// Generate default package
cmCPackIFWPackage package;
package.Generator = Generator;
package.Generator = this->Generator;
package.Installer = this;
// Check package group
if (const char* option = GetOption("CPACK_IFW_PACKAGE_GROUP")) {
if (const char* option = this->GetOption("CPACK_IFW_PACKAGE_GROUP")) {
package.ConfigureFromGroup(option);
std::string forcedOption = "CPACK_IFW_COMPONENT_GROUP_" +
cmsys::SystemTools::UpperCase(option) + "_FORCED_INSTALLATION";
@@ -487,8 +492,8 @@ void cmCPackIFWInstaller::GeneratePackageFiles()
}
// Generate packages meta information
for (PackagesMap::iterator pit = Packages.begin(); pit != Packages.end();
++pit) {
for (PackagesMap::iterator pit = this->Packages.begin();
pit != this->Packages.end(); ++pit) {
cmCPackIFWPackage* package = pit->second;
package->GeneratePackageFile();
}

400
Source/CPack/IFW/cmCPackIFWPackage.cxx
View File

@@ -18,7 +18,7 @@
//---------------------------------------------------------- CompareStruct ---
cmCPackIFWPackage::CompareStruct::CompareStruct()
: Type(CompareNone)
: Type(cmCPackIFWPackage::CompareNone)
{
}
@@ -33,56 +33,58 @@ cmCPackIFWPackage::DependenceStruct::DependenceStruct(
// 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);
this->Compare.Type = cmCPackIFWPackage::CompareLessOrEqual;
this->Compare.Value = dependence.substr(pos + 2);
} else if ((pos = dependence.find(">=")) != std::string::npos) {
Compare.Type = CompareGreaterOrEqual;
Compare.Value = dependence.substr(pos + 2);
this->Compare.Type = cmCPackIFWPackage::CompareGreaterOrEqual;
this->Compare.Value = dependence.substr(pos + 2);
} else if ((pos = dependence.find('<')) != std::string::npos) {
Compare.Type = CompareLess;
Compare.Value = dependence.substr(pos + 1);
this->Compare.Type = cmCPackIFWPackage::CompareLess;
this->Compare.Value = dependence.substr(pos + 1);
} else if ((pos = dependence.find('=')) != std::string::npos) {
Compare.Type = CompareEqual;
Compare.Value = dependence.substr(pos + 1);
this->Compare.Type = cmCPackIFWPackage::CompareEqual;
this->Compare.Value = dependence.substr(pos + 1);
} else if ((pos = dependence.find('>')) != std::string::npos) {
Compare.Type = CompareGreater;
Compare.Value = dependence.substr(pos + 1);
this->Compare.Type = cmCPackIFWPackage::CompareGreater;
this->Compare.Value = dependence.substr(pos + 1);
} else if ((pos = dependence.find('-')) != std::string::npos) {
Compare.Type = CompareNone;
Compare.Value = dependence.substr(pos + 1);
this->Compare.Type = cmCPackIFWPackage::CompareNone;
this->Compare.Value = dependence.substr(pos + 1);
}
size_t dashPos = dependence.find('-');
if (dashPos != std::string::npos) {
pos = dashPos;
}
Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
this->Name =
pos == std::string::npos ? dependence : dependence.substr(0, pos);
}
std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
{
if (Compare.Type == CompareNone) {
return Name;
if (this->Compare.Type == cmCPackIFWPackage::CompareNone) {
return this->Name;
}
std::string result = Name;
std::string result = this->Name;
if (Compare.Type != CompareNone || !Compare.Value.empty()) {
if (this->Compare.Type != cmCPackIFWPackage::CompareNone ||
!this->Compare.Value.empty()) {
result += "-";
}
if (Compare.Type == CompareLessOrEqual) {
if (this->Compare.Type == cmCPackIFWPackage::CompareLessOrEqual) {
result += "<=";
} else if (Compare.Type == CompareGreaterOrEqual) {
} else if (this->Compare.Type == cmCPackIFWPackage::CompareGreaterOrEqual) {
result += ">=";
} else if (Compare.Type == CompareLess) {
} else if (this->Compare.Type == cmCPackIFWPackage::CompareLess) {
result += "<";
} else if (Compare.Type == CompareEqual) {
} else if (this->Compare.Type == cmCPackIFWPackage::CompareEqual) {
result += "=";
} else if (Compare.Type == CompareGreater) {
} else if (this->Compare.Type == cmCPackIFWPackage::CompareGreater) {
result += ">";
}
result += Compare.Value;
result += this->Compare.Value;
return result;
}
@@ -99,62 +101,62 @@ std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent* component)
return "";
}
const char* option =
GetOption("CPACK_IFW_COMPONENT_" +
cmsys::SystemTools::UpperCase(component->Name) + "_NAME");
this->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();
UserInterfaces.clear();
Translations.clear();
SortingPriority = "";
UpdateText = "";
Default = "";
Essential = "";
Virtual = "";
ForcedInstallation = "";
RequiresAdminRights = "";
this->DisplayName = "";
this->Description = "";
this->Version = "";
this->ReleaseDate = "";
this->Script = "";
this->Licenses.clear();
this->UserInterfaces.clear();
this->Translations.clear();
this->SortingPriority = "";
this->UpdateText = "";
this->Default = "";
this->Essential = "";
this->Virtual = "";
this->ForcedInstallation = "";
this->RequiresAdminRights = "";
}
// Defaul configuration (all in one package)
int cmCPackIFWPackage::ConfigureFromOptions()
{
// Restore defaul configuration
DefaultConfiguration();
this->DefaultConfiguration();
// Name
Name = Generator->GetRootPackageName();
this->Name = this->Generator->GetRootPackageName();
// Display name
if (const char* option = this->GetOption("CPACK_PACKAGE_NAME")) {
DisplayName = option;
this->DisplayName = option;
} else {
DisplayName = "Your package";
this->DisplayName = "Your package";
}
// Description
if (const char* option =
this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
Description = option;
this->Description = option;
} else {
Description = "Your package description";
this->Description = "Your package description";
}
// Version
if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) {
Version = option;
if (const char* option = this->GetOption("CPACK_PACKAGE_VERSION")) {
this->Version = option;
} else {
Version = "1.0.0";
this->Version = "1.0.0";
}
ForcedInstallation = "true";
this->ForcedInstallation = "true";
return 1;
}
@@ -166,36 +168,36 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
}
// Restore defaul configuration
DefaultConfiguration();
this->DefaultConfiguration();
std::string prefix = "CPACK_IFW_COMPONENT_" +
cmsys::SystemTools::UpperCase(component->Name) + "_";
// Display name
DisplayName = component->DisplayName;
this->DisplayName = component->DisplayName;
// Description
Description = component->Description;
this->Description = component->Description;
// Version
if (const char* optVERSION = GetOption(prefix + "VERSION")) {
Version = optVERSION;
if (const char* optVERSION = this->GetOption(prefix + "VERSION")) {
this->Version = optVERSION;
} else if (const char* optPACKAGE_VERSION =
GetOption("CPACK_PACKAGE_VERSION")) {
Version = optPACKAGE_VERSION;
this->GetOption("CPACK_PACKAGE_VERSION")) {
this->Version = optPACKAGE_VERSION;
} else {
Version = "1.0.0";
this->Version = "1.0.0";
}
// Script
if (const char* option = GetOption(prefix + "SCRIPT")) {
Script = option;
if (const char* option = this->GetOption(prefix + "SCRIPT")) {
this->Script = option;
}
// User interfaces
if (const char* option = this->GetOption(prefix + "USER_INTERFACES")) {
UserInterfaces.clear();
cmSystemTools::ExpandListArgument(option, UserInterfaces);
this->UserInterfaces.clear();
cmSystemTools::ExpandListArgument(option, this->UserInterfaces);
}
// CMake dependencies
@@ -203,27 +205,27 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
std::vector<cmCPackComponent*>::iterator dit;
for (dit = component->Dependencies.begin();
dit != component->Dependencies.end(); ++dit) {
Dependencies.insert(Generator->ComponentPackages[*dit]);
this->Dependencies.insert(this->Generator->ComponentPackages[*dit]);
}
}
// Licenses
if (const char* option = this->GetOption(prefix + "LICENSES")) {
Licenses.clear();
cmSystemTools::ExpandListArgument(option, Licenses);
if (Licenses.size() % 2 != 0) {
this->Licenses.clear();
cmSystemTools::ExpandListArgument(option, this->Licenses);
if (this->Licenses.size() % 2 != 0) {
cmCPackIFWLogger(
WARNING,
prefix << "LICENSES"
<< " should contain pairs of <display_name> and <file_path>."
<< std::endl);
Licenses.clear();
this->Licenses.clear();
}
}
// Priority
if (const char* option = this->GetOption(prefix + "PRIORITY")) {
SortingPriority = option;
this->SortingPriority = option;
cmCPackIFWLogger(
WARNING, "The \"PRIORITY\" option is set "
<< "for component \"" << component->Name << "\", but there option is "
@@ -232,20 +234,20 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
}
// Default
Default = component->IsDisabledByDefault ? "false" : "true";
this->Default = component->IsDisabledByDefault ? "false" : "true";
// Essential
if (this->IsOn(prefix + "ESSENTIAL")) {
Essential = "true";
this->Essential = "true";
}
// Virtual
Virtual = component->IsHidden ? "true" : "";
this->Virtual = component->IsHidden ? "true" : "";
// ForcedInstallation
ForcedInstallation = component->IsRequired ? "true" : "false";
this->ForcedInstallation = component->IsRequired ? "true" : "false";
return ConfigureFromPrefix(prefix);
return this->ConfigureFromPrefix(prefix);
}
int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
@@ -255,52 +257,52 @@ int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
}
// Restore defaul configuration
DefaultConfiguration();
this->DefaultConfiguration();
std::string prefix = "CPACK_IFW_COMPONENT_GROUP_" +
cmsys::SystemTools::UpperCase(group->Name) + "_";
DisplayName = group->DisplayName;
Description = group->Description;
this->DisplayName = group->DisplayName;
this->Description = group->Description;
// Version
if (const char* optVERSION = GetOption(prefix + "VERSION")) {
Version = optVERSION;
if (const char* optVERSION = this->GetOption(prefix + "VERSION")) {
this->Version = optVERSION;
} else if (const char* optPACKAGE_VERSION =
GetOption("CPACK_PACKAGE_VERSION")) {
Version = optPACKAGE_VERSION;
this->GetOption("CPACK_PACKAGE_VERSION")) {
this->Version = optPACKAGE_VERSION;
} else {
Version = "1.0.0";
this->Version = "1.0.0";
}
// Script
if (const char* option = GetOption(prefix + "SCRIPT")) {
Script = option;
if (const char* option = this->GetOption(prefix + "SCRIPT")) {
this->Script = option;
}
// User interfaces
if (const char* option = this->GetOption(prefix + "USER_INTERFACES")) {
UserInterfaces.clear();
cmSystemTools::ExpandListArgument(option, UserInterfaces);
this->UserInterfaces.clear();
cmSystemTools::ExpandListArgument(option, this->UserInterfaces);
}
// Licenses
if (const char* option = this->GetOption(prefix + "LICENSES")) {
Licenses.clear();
cmSystemTools::ExpandListArgument(option, Licenses);
if (Licenses.size() % 2 != 0) {
this->Licenses.clear();
cmSystemTools::ExpandListArgument(option, this->Licenses);
if (this->Licenses.size() % 2 != 0) {
cmCPackIFWLogger(
WARNING,
prefix << "LICENSES"
<< " should contain pairs of <display_name> and <file_path>."
<< std::endl);
Licenses.clear();
this->Licenses.clear();
}
}
// Priority
if (const char* option = this->GetOption(prefix + "PRIORITY")) {
SortingPriority = option;
this->SortingPriority = option;
cmCPackIFWLogger(
WARNING, "The \"PRIORITY\" option is set "
<< "for component group \"" << group->Name
@@ -309,7 +311,7 @@ int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
<< std::endl);
}
return ConfigureFromPrefix(prefix);
return this->ConfigureFromPrefix(prefix);
}
int cmCPackIFWPackage::ConfigureFromGroup(const std::string& groupName)
@@ -320,29 +322,29 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string& groupName)
std::string prefix =
"CPACK_COMPONENT_GROUP_" + cmsys::SystemTools::UpperCase(groupName) + "_";
if (const char* option = GetOption(prefix + "DISPLAY_NAME")) {
if (const char* option = this->GetOption(prefix + "DISPLAY_NAME")) {
group.DisplayName = option;
} else {
group.DisplayName = group.Name;
}
if (const char* option = GetOption(prefix + "DESCRIPTION")) {
if (const char* option = this->GetOption(prefix + "DESCRIPTION")) {
group.Description = option;
}
group.IsBold = IsOn(prefix + "BOLD_TITLE");
group.IsExpandedByDefault = IsOn(prefix + "EXPANDED");
group.IsBold = this->IsOn(prefix + "BOLD_TITLE");
group.IsExpandedByDefault = this->IsOn(prefix + "EXPANDED");
// Package configuration
group.Name = groupName;
if (Generator) {
Name = Generator->GetGroupPackageName(&group);
this->Name = this->Generator->GetGroupPackageName(&group);
} else {
Name = group.Name;
this->Name = group.Name;
}
return ConfigureFromGroup(&group);
return this->ConfigureFromGroup(&group);
}
// Common options for components and groups
@@ -353,51 +355,51 @@ int cmCPackIFWPackage::ConfigureFromPrefix(const std::string& prefix)
// Display name
option = prefix + "DISPLAY_NAME";
if (IsSetToEmpty(option)) {
DisplayName.clear();
} else if (const char* value = GetOption(option)) {
DisplayName = value;
if (this->IsSetToEmpty(option)) {
this->DisplayName.clear();
} else if (const char* value = this->GetOption(option)) {
this->DisplayName = value;
}
// Description
option = prefix + "DESCRIPTION";
if (IsSetToEmpty(option)) {
Description.clear();
} else if (const char* value = GetOption(option)) {
Description = value;
if (this->IsSetToEmpty(option)) {
this->Description.clear();
} else if (const char* value = this->GetOption(option)) {
this->Description = value;
}
// Release date
option = prefix + "RELEASE_DATE";
if (IsSetToEmpty(option)) {
ReleaseDate.clear();
} else if (const char* value = GetOption(option)) {
ReleaseDate = value;
if (this->IsSetToEmpty(option)) {
this->ReleaseDate.clear();
} else if (const char* value = this->GetOption(option)) {
this->ReleaseDate = value;
}
// Sorting priority
option = prefix + "SORTING_PRIORITY";
if (IsSetToEmpty(option)) {
SortingPriority.clear();
} else if (const char* value = GetOption(option)) {
SortingPriority = value;
if (this->IsSetToEmpty(option)) {
this->SortingPriority.clear();
} else if (const char* value = this->GetOption(option)) {
this->SortingPriority = value;
}
// Update text
option = prefix + "UPDATE_TEXT";
if (IsSetToEmpty(option)) {
UpdateText.clear();
} else if (const char* value = GetOption(option)) {
UpdateText = value;
if (this->IsSetToEmpty(option)) {
this->UpdateText.clear();
} else if (const char* value = this->GetOption(option)) {
this->UpdateText = value;
}
// Translations
option = prefix + "TRANSLATIONS";
if (IsSetToEmpty(option)) {
Translations.clear();
if (this->IsSetToEmpty(option)) {
this->Translations.clear();
} else if (const char* value = this->GetOption(option)) {
Translations.clear();
cmSystemTools::ExpandListArgument(value, Translations);
this->Translations.clear();
cmSystemTools::ExpandListArgument(value, this->Translations);
}
// QtIFW dependencies
@@ -413,84 +415,84 @@ int cmCPackIFWPackage::ConfigureFromPrefix(const std::string& prefix)
for (std::vector<std::string>::iterator dit = deps.begin();
dit != deps.end(); ++dit) {
DependenceStruct dep(*dit);
if (Generator->Packages.count(dep.Name)) {
cmCPackIFWPackage& depPkg = Generator->Packages[dep.Name];
if (this->Generator->Packages.count(dep.Name)) {
cmCPackIFWPackage& depPkg = this->Generator->Packages[dep.Name];
dep.Name = depPkg.Name;
}
bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
DependenceStruct& depRef = Generator->DependentPackages[dep.Name];
bool hasDep = this->Generator->DependentPackages.count(dep.Name) > 0;
DependenceStruct& depRef = this->Generator->DependentPackages[dep.Name];
if (!hasDep) {
depRef = dep;
}
AlienDependencies.insert(&depRef);
this->AlienDependencies.insert(&depRef);
}
// Automatic dependency on
option = prefix + "AUTO_DEPEND_ON";
if (IsSetToEmpty(option)) {
AlienAutoDependOn.clear();
if (this->IsSetToEmpty(option)) {
this->AlienAutoDependOn.clear();
} else if (const char* value = this->GetOption(option)) {
std::vector<std::string> depsOn;
cmSystemTools::ExpandListArgument(value, depsOn);
for (std::vector<std::string>::iterator dit = depsOn.begin();
dit != depsOn.end(); ++dit) {
DependenceStruct dep(*dit);
if (Generator->Packages.count(dep.Name)) {
cmCPackIFWPackage& depPkg = Generator->Packages[dep.Name];
if (this->Generator->Packages.count(dep.Name)) {
cmCPackIFWPackage& depPkg = this->Generator->Packages[dep.Name];
dep.Name = depPkg.Name;
}
bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
DependenceStruct& depRef = Generator->DependentPackages[dep.Name];
bool hasDep = this->Generator->DependentPackages.count(dep.Name) > 0;
DependenceStruct& depRef = this->Generator->DependentPackages[dep.Name];
if (!hasDep) {
depRef = dep;
}
AlienAutoDependOn.insert(&depRef);
this->AlienAutoDependOn.insert(&depRef);
}
}
// Visibility
option = prefix + "VIRTUAL";
if (IsSetToEmpty(option)) {
Virtual.clear();
} else if (IsOn(option)) {
Virtual = "true";
if (this->IsSetToEmpty(option)) {
this->Virtual.clear();
} else if (this->IsOn(option)) {
this->Virtual = "true";
}
// Default selection
option = prefix + "DEFAULT";
if (IsSetToEmpty(option)) {
Default.clear();
} else if (const char* value = GetOption(option)) {
if (this->IsSetToEmpty(option)) {
this->Default.clear();
} else if (const char* value = this->GetOption(option)) {
std::string lowerValue = cmsys::SystemTools::LowerCase(value);
if (lowerValue == "true") {
Default = "true";
this->Default = "true";
} else if (lowerValue == "false") {
Default = "false";
this->Default = "false";
} else if (lowerValue == "script") {
Default = "script";
this->Default = "script";
} else {
Default = value;
this->Default = value;
}
}
// Forsed installation
option = prefix + "FORCED_INSTALLATION";
if (IsSetToEmpty(option)) {
ForcedInstallation.clear();
} else if (IsOn(option)) {
ForcedInstallation = "true";
} else if (IsSetToOff(option)) {
ForcedInstallation = "false";
if (this->IsSetToEmpty(option)) {
this->ForcedInstallation.clear();
} else if (this->IsOn(option)) {
this->ForcedInstallation = "true";
} else if (this->IsSetToOff(option)) {
this->ForcedInstallation = "false";
}
// Requires admin rights
option = prefix + "REQUIRES_ADMIN_RIGHTS";
if (IsSetToEmpty(option)) {
RequiresAdminRights.clear();
} else if (IsOn(option)) {
RequiresAdminRights = "true";
} else if (IsSetToOff(option)) {
RequiresAdminRights = "false";
if (this->IsSetToEmpty(option)) {
this->RequiresAdminRights.clear();
} else if (this->IsOn(option)) {
this->RequiresAdminRights = "true";
} else if (this->IsSetToOff(option)) {
this->RequiresAdminRights = "false";
}
return 1;
@@ -499,16 +501,16 @@ int cmCPackIFWPackage::ConfigureFromPrefix(const std::string& prefix)
void cmCPackIFWPackage::GeneratePackageFile()
{
// Lazy directory initialization
if (Directory.empty()) {
if (Installer) {
Directory = Installer->Directory + "/packages/" + Name;
} else if (Generator) {
Directory = Generator->toplevel + "/packages/" + Name;
if (this->Directory.empty()) {
if (this->Installer) {
this->Directory = this->Installer->Directory + "/packages/" + this->Name;
} else if (this->Generator) {
this->Directory = this->Generator->toplevel + "/packages/" + this->Name;
}
}
// Output stream
cmGeneratedFileStream fout((Directory + "/meta/package.xml").data());
cmGeneratedFileStream fout((this->Directory + "/meta/package.xml").data());
cmXMLWriter xout(fout);
xout.StartDocument();
@@ -517,28 +519,28 @@ void cmCPackIFWPackage::GeneratePackageFile()
xout.StartElement("Package");
xout.Element("DisplayName", DisplayName);
xout.Element("Description", Description);
xout.Element("DisplayName", this->DisplayName);
xout.Element("Description", this->Description);
// Update text
if (!UpdateText.empty()) {
xout.Element("UpdateText", UpdateText);
if (!this->UpdateText.empty()) {
xout.Element("UpdateText", this->UpdateText);
}
xout.Element("Name", Name);
xout.Element("Version", Version);
xout.Element("Name", this->Name);
xout.Element("Version", this->Version);
if (!ReleaseDate.empty()) {
xout.Element("ReleaseDate", ReleaseDate);
if (!this->ReleaseDate.empty()) {
xout.Element("ReleaseDate", this->ReleaseDate);
} else {
xout.Element("ReleaseDate", cmTimestamp().CurrentTime("%Y-%m-%d", true));
}
// Script (copy to meta dir)
if (!Script.empty()) {
std::string name = cmSystemTools::GetFilenameName(Script);
std::string path = Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Script, path);
if (!this->Script.empty()) {
std::string name = cmSystemTools::GetFilenameName(this->Script);
std::string path = this->Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(this->Script, path);
xout.Element("Script", name);
}
@@ -546,7 +548,7 @@ void cmCPackIFWPackage::GeneratePackageFile()
std::vector<std::string> userInterfaces = UserInterfaces;
for (size_t i = 0; i < userInterfaces.size(); i++) {
std::string name = cmSystemTools::GetFilenameName(userInterfaces[i]);
std::string path = Directory + "/meta/" + name;
std::string path = this->Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(userInterfaces[i], path);
userInterfaces[i] = name;
}
@@ -562,7 +564,7 @@ void cmCPackIFWPackage::GeneratePackageFile()
std::vector<std::string> translations = Translations;
for (size_t i = 0; i < translations.size(); i++) {
std::string name = cmSystemTools::GetFilenameName(translations[i]);
std::string path = Directory + "/meta/" + name;
std::string path = this->Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(translations[i], path);
translations[i] = name;
}
@@ -576,12 +578,13 @@ void cmCPackIFWPackage::GeneratePackageFile()
// Dependencies
std::set<DependenceStruct> compDepSet;
for (std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
ait != AlienDependencies.end(); ++ait) {
for (std::set<DependenceStruct*>::iterator ait =
this->AlienDependencies.begin();
ait != this->AlienDependencies.end(); ++ait) {
compDepSet.insert(*(*ait));
}
for (std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
it != Dependencies.end(); ++it) {
for (std::set<cmCPackIFWPackage*>::iterator it = this->Dependencies.begin();
it != this->Dependencies.end(); ++it) {
compDepSet.insert(DependenceStruct((*it)->Name));
}
// Write dependencies
@@ -599,8 +602,9 @@ void cmCPackIFWPackage::GeneratePackageFile()
// Automatic dependency on
std::set<DependenceStruct> compAutoDepSet;
for (std::set<DependenceStruct*>::iterator ait = AlienAutoDependOn.begin();
ait != AlienAutoDependOn.end(); ++ait) {
for (std::set<DependenceStruct*>::iterator ait =
this->AlienAutoDependOn.begin();
ait != this->AlienAutoDependOn.end(); ++ait) {
compAutoDepSet.insert(*(*ait));
}
// Write automatic dependency on
@@ -617,10 +621,10 @@ void cmCPackIFWPackage::GeneratePackageFile()
}
// Licenses (copy to meta dir)
std::vector<std::string> licenses = Licenses;
std::vector<std::string> licenses = this->Licenses;
for (size_t i = 1; i < licenses.size(); i += 2) {
std::string name = cmSystemTools::GetFilenameName(licenses[i]);
std::string path = Directory + "/meta/" + name;
std::string path = this->Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(licenses[i], path);
licenses[i] = name;
}
@@ -635,28 +639,28 @@ void cmCPackIFWPackage::GeneratePackageFile()
xout.EndElement();
}
if (!ForcedInstallation.empty()) {
xout.Element("ForcedInstallation", ForcedInstallation);
if (!this->ForcedInstallation.empty()) {
xout.Element("ForcedInstallation", this->ForcedInstallation);
}
if (!RequiresAdminRights.empty()) {
xout.Element("RequiresAdminRights", RequiresAdminRights);
if (!this->RequiresAdminRights.empty()) {
xout.Element("RequiresAdminRights", this->RequiresAdminRights);
}
if (!Virtual.empty()) {
xout.Element("Virtual", Virtual);
} else if (!Default.empty()) {
xout.Element("Default", Default);
if (!this->Virtual.empty()) {
xout.Element("Virtual", this->Virtual);
} else if (!this->Default.empty()) {
xout.Element("Default", this->Default);
}
// Essential
if (!Essential.empty()) {
xout.Element("Essential", Essential);
if (!this->Essential.empty()) {
xout.Element("Essential", this->Essential);
}
// Priority
if (!SortingPriority.empty()) {
xout.Element("SortingPriority", SortingPriority);
if (!this->SortingPriority.empty()) {
xout.Element("SortingPriority", this->SortingPriority);
}
xout.EndElement();

172
Source/CPack/IFW/cmCPackIFWRepository.cxx
View File

@@ -11,7 +11,7 @@
#include <stddef.h>
cmCPackIFWRepository::cmCPackIFWRepository()
: Update(None)
: Update(cmCPackIFWRepository::None)
{
}
@@ -19,18 +19,18 @@ bool cmCPackIFWRepository::IsValid() const
{
bool valid = true;
switch (Update) {
case None:
valid = !Url.empty();
switch (this->Update) {
case cmCPackIFWRepository::None:
valid = !this->Url.empty();
break;
case Add:
valid = !Url.empty();
case cmCPackIFWRepository::Add:
valid = !this->Url.empty();
break;
case Remove:
valid = !Url.empty();
case cmCPackIFWRepository::Remove:
valid = !this->Url.empty();
break;
case Replace:
valid = !OldUrl.empty() && !NewUrl.empty();
case cmCPackIFWRepository::Replace:
valid = !this->OldUrl.empty() && !this->NewUrl.empty();
break;
}
@@ -40,74 +40,74 @@ bool cmCPackIFWRepository::IsValid() const
bool cmCPackIFWRepository::ConfigureFromOptions()
{
// Name;
if (Name.empty()) {
if (this->Name.empty()) {
return false;
}
std::string prefix =
"CPACK_IFW_REPOSITORY_" + cmsys::SystemTools::UpperCase(Name) + "_";
"CPACK_IFW_REPOSITORY_" + cmsys::SystemTools::UpperCase(this->Name) + "_";
// Update
if (IsOn(prefix + "ADD")) {
Update = Add;
if (this->IsOn(prefix + "ADD")) {
this->Update = cmCPackIFWRepository::Add;
} else if (IsOn(prefix + "REMOVE")) {
Update = Remove;
this->Update = cmCPackIFWRepository::Remove;
} else if (IsOn(prefix + "REPLACE")) {
Update = Replace;
this->Update = cmCPackIFWRepository::Replace;
} else {
Update = None;
this->Update = cmCPackIFWRepository::None;
}
// Url
if (const char* url = GetOption(prefix + "URL")) {
Url = url;
if (const char* url = this->GetOption(prefix + "URL")) {
this->Url = url;
} else {
Url = "";
this->Url = "";
}
// Old url
if (const char* oldUrl = GetOption(prefix + "OLD_URL")) {
OldUrl = oldUrl;
if (const char* oldUrl = this->GetOption(prefix + "OLD_URL")) {
this->OldUrl = oldUrl;
} else {
OldUrl = "";
this->OldUrl = "";
}
// New url
if (const char* newUrl = GetOption(prefix + "NEW_URL")) {
NewUrl = newUrl;
if (const char* newUrl = this->GetOption(prefix + "NEW_URL")) {
this->NewUrl = newUrl;
} else {
NewUrl = "";
this->NewUrl = "";
}
// Enabled
if (IsOn(prefix + "DISABLED")) {
Enabled = "0";
if (this->IsOn(prefix + "DISABLED")) {
this->Enabled = "0";
} else {
Enabled = "";
this->Enabled = "";
}
// Username
if (const char* username = GetOption(prefix + "USERNAME")) {
Username = username;
if (const char* username = this->GetOption(prefix + "USERNAME")) {
this->Username = username;
} else {
Username = "";
this->Username = "";
}
// Password
if (const char* password = GetOption(prefix + "PASSWORD")) {
Password = password;
if (const char* password = this->GetOption(prefix + "PASSWORD")) {
this->Password = password;
} else {
Password = "";
this->Password = "";
}
// DisplayName
if (const char* displayName = GetOption(prefix + "DISPLAY_NAME")) {
DisplayName = displayName;
if (const char* displayName = this->GetOption(prefix + "DISPLAY_NAME")) {
this->DisplayName = displayName;
} else {
DisplayName = "";
this->DisplayName = "";
}
return IsValid();
return this->IsValid();
}
/** \class cmCPackeIFWUpdatesPatcher
@@ -130,8 +130,8 @@ public:
protected:
void StartElement(const std::string& name, const char** atts) CM_OVERRIDE
{
xout.StartElement(name);
StartFragment(atts);
this->xout.StartElement(name);
this->StartFragment(atts);
}
void StartFragment(const char** atts)
@@ -139,23 +139,23 @@ protected:
for (size_t i = 0; atts[i]; i += 2) {
const char* key = atts[i];
const char* value = atts[i + 1];
xout.Attribute(key, value);
this->xout.Attribute(key, value);
}
}
void EndElement(const std::string& name) CM_OVERRIDE
{
if (name == "Updates" && !patched) {
repository->WriteRepositoryUpdates(xout);
patched = true;
if (name == "Updates" && !this->patched) {
this->repository->WriteRepositoryUpdates(this->xout);
this->patched = true;
}
xout.EndElement();
if (patched) {
this->xout.EndElement();
if (this->patched) {
return;
}
if (name == "Checksum") {
repository->WriteRepositoryUpdates(xout);
patched = true;
this->repository->WriteRepositoryUpdates(this->xout);
this->patched = true;
}
}
@@ -166,20 +166,21 @@ protected:
content == "\n") {
return;
}
xout.Content(content);
this->xout.Content(content);
}
};
bool cmCPackIFWRepository::PatchUpdatesXml()
{
// Lazy directory initialization
if (Directory.empty() && Generator) {
Directory = Generator->toplevel;
if (this->Directory.empty() && this->Generator) {
this->Directory = this->Generator->toplevel;
}
// Filenames
std::string updatesXml = Directory + "/repository/Updates.xml";
std::string updatesPatchXml = Directory + "/repository/UpdatesPatch.xml";
std::string updatesXml = this->Directory + "/repository/Updates.xml";
std::string updatesPatchXml =
this->Directory + "/repository/UpdatesPatch.xml";
// Output stream
cmGeneratedFileStream fout(updatesPatchXml.data());
@@ -187,7 +188,7 @@ bool cmCPackIFWRepository::PatchUpdatesXml()
xout.StartDocument();
WriteGeneratedByToStrim(xout);
this->WriteGeneratedByToStrim(xout);
// Patch
{
@@ -207,22 +208,22 @@ void cmCPackIFWRepository::WriteRepositoryConfig(cmXMLWriter& xout)
xout.StartElement("Repository");
// Url
xout.Element("Url", Url);
xout.Element("Url", this->Url);
// Enabled
if (!Enabled.empty()) {
xout.Element("Enabled", Enabled);
if (!this->Enabled.empty()) {
xout.Element("Enabled", this->Enabled);
}
// Username
if (!Username.empty()) {
xout.Element("Username", Username);
if (!this->Username.empty()) {
xout.Element("Username", this->Username);
}
// Password
if (!Password.empty()) {
xout.Element("Password", Password);
if (!this->Password.empty()) {
xout.Element("Password", this->Password);
}
// DisplayName
if (!DisplayName.empty()) {
xout.Element("DisplayName", DisplayName);
if (!this->DisplayName.empty()) {
xout.Element("DisplayName", this->DisplayName);
}
xout.EndElement();
@@ -232,42 +233,43 @@ void cmCPackIFWRepository::WriteRepositoryUpdate(cmXMLWriter& xout)
{
xout.StartElement("Repository");
switch (Update) {
case None:
switch (this->Update) {
case cmCPackIFWRepository::None:
break;
case Add:
case cmCPackIFWRepository::Add:
xout.Attribute("action", "add");
break;
case Remove:
case cmCPackIFWRepository::Remove:
xout.Attribute("action", "remove");
break;
case Replace:
case cmCPackIFWRepository::Replace:
xout.Attribute("action", "replace");
break;
}
// Url
if (Update == Add || Update == Remove) {
xout.Attribute("url", Url);
} else if (Update == Replace) {
xout.Attribute("oldUrl", OldUrl);
xout.Attribute("newUrl", NewUrl);
if (this->Update == cmCPackIFWRepository::Add ||
this->Update == cmCPackIFWRepository::Remove) {
xout.Attribute("url", this->Url);
} else if (Update == cmCPackIFWRepository::Replace) {
xout.Attribute("oldUrl", this->OldUrl);
xout.Attribute("newUrl", this->NewUrl);
}
// Enabled
if (!Enabled.empty()) {
xout.Attribute("enabled", Enabled);
if (!this->Enabled.empty()) {
xout.Attribute("enabled", this->Enabled);
}
// Username
if (!Username.empty()) {
xout.Attribute("username", Username);
if (!this->Username.empty()) {
xout.Attribute("username", this->Username);
}
// Password
if (!Password.empty()) {
xout.Attribute("password", Password);
if (!this->Password.empty()) {
xout.Attribute("password", this->Password);
}
// DisplayName
if (!DisplayName.empty()) {
xout.Attribute("displayname", DisplayName);
if (!this->DisplayName.empty()) {
xout.Attribute("displayname", this->DisplayName);
}
xout.EndElement();
@@ -275,10 +277,10 @@ void cmCPackIFWRepository::WriteRepositoryUpdate(cmXMLWriter& xout)
void cmCPackIFWRepository::WriteRepositoryUpdates(cmXMLWriter& xout)
{
if (!RepositoryUpdate.empty()) {
if (!this->RepositoryUpdate.empty()) {
xout.StartElement("RepositoryUpdate");
for (RepositoriesVector::iterator rit = RepositoryUpdate.begin();
rit != RepositoryUpdate.end(); ++rit) {
for (RepositoriesVector::iterator rit = this->RepositoryUpdate.begin();
rit != this->RepositoryUpdate.end(); ++rit) {
(*rit)->WriteRepositoryUpdate(xout);
}
xout.EndElement();