CPackIFW: Access refactoring

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

1 files changed, 159 insertions, 154 deletions

diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
index 317137f..288e924 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx
+++ b/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();
   }