STYLE: some m_ to this-> cleanup

1 files changed, 38 insertions, 38 deletions

diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx
index cb15cfd8c7..717459c01e 100644
--- a/Source/cmQTWrapUICommand.cxx
+++ b/Source/cmQTWrapUICommand.cxx
@@ -25,18 +25,18 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 3);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 3);
 
   // what is the current source dir
-  std::string cdir = m_Makefile->GetCurrentDirectory();
+  std::string cdir = this->Makefile->GetCurrentDirectory();
 
   // keep the library name
-  m_LibraryName = args[0];
-  m_HeaderList = args[1];
-  m_SourceList = args[2];
+  this->LibraryName = args[0];
+  this->HeaderList = args[1];
+  this->SourceList = args[2];
   std::string sourceListValue;
   std::string headerListValue;
-  const char *def = m_Makefile->GetDefinition(m_SourceList.c_str());  
+  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
   if (def)
     {
     sourceListValue = def;
@@ -46,7 +46,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
   for(std::vector<std::string>::iterator j = (args.begin() + 3);
       j != args.end(); ++j)
     {   
-    cmSourceFile *curr = m_Makefile->GetSource(j->c_str());
+    cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
     
     // if we should wrap the class
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -56,15 +56,15 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
       cmSourceFile moc_file;
       std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*j);
       header_file.SetName(srcName.c_str(), 
-                          m_Makefile->GetCurrentOutputDirectory(),
+                          this->Makefile->GetCurrentOutputDirectory(),
                           "h",false);
       source_file.SetName(srcName.c_str(), 
-                          m_Makefile->GetCurrentOutputDirectory(),
+                          this->Makefile->GetCurrentOutputDirectory(),
                           "cxx",false);
       std::string moc_source_name("moc_");
       moc_source_name = moc_source_name + srcName;
       moc_file.SetName(moc_source_name.c_str(), 
-                       m_Makefile->GetCurrentOutputDirectory(),
+                       this->Makefile->GetCurrentOutputDirectory(),
                        "cxx",false);
       std::string origname;
       if ( (*j)[0] == '/' || (*j)[1] == ':' )
@@ -75,7 +75,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
         {
         if ( curr && curr->GetPropertyAsBool("GENERATED") )
           {
-          origname = std::string( m_Makefile->GetCurrentOutputDirectory() ) + "/" + *j;
+          origname = std::string( this->Makefile->GetCurrentOutputDirectory() ) + "/" + *j;
           }
         else
           {
@@ -83,18 +83,18 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
           }
         }
       std::string hname = header_file.GetFullPath();
-      m_WrapUserInterface.push_back(origname);
+      this->WrapUserInterface.push_back(origname);
       // add starting depends
       moc_file.GetDepends().push_back(hname);
       source_file.GetDepends().push_back(hname);
       source_file.GetDepends().push_back(origname);
       header_file.GetDepends().push_back(origname);
-      m_WrapHeadersClasses.push_back(header_file);
-      m_WrapSourcesClasses.push_back(source_file);
-      m_WrapMocClasses.push_back(moc_file);
-      m_Makefile->AddSource(header_file);
-      m_Makefile->AddSource(source_file);
-      m_Makefile->AddSource(moc_file);
+      this->WrapHeadersClasses.push_back(header_file);
+      this->WrapSourcesClasses.push_back(source_file);
+      this->WrapMocClasses.push_back(moc_file);
+      this->Makefile->AddSource(header_file);
+      this->Makefile->AddSource(source_file);
+      this->Makefile->AddSource(moc_file);
       
       // create the list of headers 
       if (headerListValue.size() > 0)
@@ -114,8 +114,8 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
       }
     }
   
-  m_Makefile->AddDefinition(m_SourceList.c_str(), sourceListValue.c_str());  
-  m_Makefile->AddDefinition(m_HeaderList.c_str(), headerListValue.c_str());  
+  this->Makefile->AddDefinition(this->SourceList.c_str(), sourceListValue.c_str());  
+  this->Makefile->AddDefinition(this->HeaderList.c_str(), headerListValue.c_str());  
   return true;
 }
 
@@ -123,10 +123,10 @@ void cmQTWrapUICommand::FinalPass()
 {
 
   // first we add the rules for all the .ui to .h and .cxx files
-  size_t lastHeadersClass = m_WrapHeadersClasses.size();
+  size_t lastHeadersClass = this->WrapHeadersClasses.size();
   std::vector<std::string> depends;
-  const char* uic_exe = m_Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
-  const char* moc_exe = m_Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
+  const char* uic_exe = this->Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
+  const char* moc_exe = this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
 
   // wrap all the .h files
   depends.push_back(uic_exe);
@@ -134,26 +134,26 @@ void cmQTWrapUICommand::FinalPass()
   for(size_t classNum = 0; classNum < lastHeadersClass; classNum++)
     {
     // set up .ui to .h and .cxx command
-    std::string hres = m_Makefile->GetCurrentOutputDirectory();
+    std::string hres = this->Makefile->GetCurrentOutputDirectory();
     hres += "/";
-    hres += m_WrapHeadersClasses[classNum].GetSourceName() + "." +
-        m_WrapHeadersClasses[classNum].GetSourceExtension();
+    hres += this->WrapHeadersClasses[classNum].GetSourceName() + "." +
+        this->WrapHeadersClasses[classNum].GetSourceExtension();
 
-    std::string cxxres = m_Makefile->GetCurrentOutputDirectory();
+    std::string cxxres = this->Makefile->GetCurrentOutputDirectory();
     cxxres += "/";
-    cxxres += m_WrapSourcesClasses[classNum].GetSourceName() + "." +
-        m_WrapSourcesClasses[classNum].GetSourceExtension();
+    cxxres += this->WrapSourcesClasses[classNum].GetSourceName() + "." +
+        this->WrapSourcesClasses[classNum].GetSourceExtension();
 
-    std::string mocres = m_Makefile->GetCurrentOutputDirectory();
+    std::string mocres = this->Makefile->GetCurrentOutputDirectory();
     mocres += "/";
-    mocres += m_WrapMocClasses[classNum].GetSourceName() + "." +
-        m_WrapMocClasses[classNum].GetSourceExtension();
+    mocres += this->WrapMocClasses[classNum].GetSourceName() + "." +
+        this->WrapMocClasses[classNum].GetSourceExtension();
 
     cmCustomCommandLine hCommand;
     hCommand.push_back(uic_exe);
     hCommand.push_back("-o");
     hCommand.push_back(hres);
-    hCommand.push_back(m_WrapUserInterface[classNum]);
+    hCommand.push_back(this->WrapUserInterface[classNum]);
     cmCustomCommandLines hCommandLines;
     hCommandLines.push_back(hCommand);
 
@@ -163,7 +163,7 @@ void cmQTWrapUICommand::FinalPass()
     cxxCommand.push_back(hres);
     cxxCommand.push_back("-o");
     cxxCommand.push_back(cxxres);
-    cxxCommand.push_back(m_WrapUserInterface[classNum]);
+    cxxCommand.push_back(this->WrapUserInterface[classNum]);
     cmCustomCommandLines cxxCommandLines;
     cxxCommandLines.push_back(cxxCommand);
 
@@ -176,11 +176,11 @@ void cmQTWrapUICommand::FinalPass()
     mocCommandLines.push_back(mocCommand);
 
     depends.clear();
-    depends.push_back(m_WrapUserInterface[classNum]);
+    depends.push_back(this->WrapUserInterface[classNum]);
     const char* no_main_dependency = 0;
     const char* no_comment = 0;
     const char* no_working_dir = 0;
-    m_Makefile->AddCustomCommandToOutput(hres.c_str(),
+    this->Makefile->AddCustomCommandToOutput(hres.c_str(),
                                          depends,
                                          no_main_dependency,
                                          hCommandLines,
@@ -189,7 +189,7 @@ void cmQTWrapUICommand::FinalPass()
 
     depends.push_back(hres);
 
-    m_Makefile->AddCustomCommandToOutput(cxxres.c_str(),
+    this->Makefile->AddCustomCommandToOutput(cxxres.c_str(),
                                          depends,
                                          no_main_dependency,
                                          cxxCommandLines,
@@ -199,7 +199,7 @@ void cmQTWrapUICommand::FinalPass()
     depends.clear();
     depends.push_back(hres);
 
-    m_Makefile->AddCustomCommandToOutput(mocres.c_str(),
+    this->Makefile->AddCustomCommandToOutput(mocres.c_str(),
                                          depends,
                                          no_main_dependency,
                                          mocCommandLines,