CPackIFW: Access refactoring

Changes:
- Access members with this->;
- Access nested enum values with class name.

Source/CPack/IFW/cmCPackIFWCommon.cxx

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

Source/CPack/IFW/cmCPackIFWGenerator.cxx

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

Source/CPack/IFW/cmCPackIFWInstaller.cxx

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

Source/CPack/IFW/cmCPackIFWPackage.cxx

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

Source/CPack/IFW/cmCPackIFWRepository.cxx

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