66 files changed, 1228 insertions, 205 deletions

diff --git a/Help/manual/cmake-properties.7.rst b/Help/manual/cmake-properties.7.rst
index 658da20..6fbde74 100644
--- a/Help/manual/cmake-properties.7.rst
+++ b/Help/manual/cmake-properties.7.rst
@@ -10,6 +10,7 @@ Properties of Global Scope
 
 .. toctree::
    /prop_gbl/ALLOW_DUPLICATE_CUSTOM_TARGETS
+   /prop_gbl/AUTOGEN_TARGETS_FOLDER
    /prop_gbl/AUTOMOC_TARGETS_FOLDER
    /prop_gbl/DEBUG_CONFIGURATIONS
    /prop_gbl/DISABLED_FEATURES
@@ -72,6 +73,10 @@ Properties on Targets
    /prop_tgt/ARCHIVE_OUTPUT_NAME
    /prop_tgt/AUTOMOC_MOC_OPTIONS
    /prop_tgt/AUTOMOC
+   /prop_tgt/AUTOUIC
+   /prop_tgt/AUTOUIC_OPTIONS
+   /prop_tgt/AUTORCC
+   /prop_tgt/AUTORCC_OPTIONS
    /prop_tgt/BUILD_WITH_INSTALL_RPATH
    /prop_tgt/BUNDLE_EXTENSION
    /prop_tgt/BUNDLE
@@ -235,6 +240,8 @@ Properties on Source Files
 
 .. toctree::
    /prop_sf/ABSTRACT
+   /prop_sf/AUTOUIC_OPTIONS
+   /prop_sf/AUTORCC_OPTIONS
    /prop_sf/COMPILE_DEFINITIONS_CONFIG
    /prop_sf/COMPILE_DEFINITIONS
    /prop_sf/COMPILE_FLAGS
diff --git a/Help/manual/cmake-variables.7.rst b/Help/manual/cmake-variables.7.rst
index 2311ac8..22a1c4d 100644
--- a/Help/manual/cmake-variables.7.rst
+++ b/Help/manual/cmake-variables.7.rst
@@ -155,6 +155,10 @@ Variables that Control the Build
    /variable/CMAKE_ARCHIVE_OUTPUT_DIRECTORY
    /variable/CMAKE_AUTOMOC_MOC_OPTIONS
    /variable/CMAKE_AUTOMOC
+   /variable/CMAKE_AUTORCC
+   /variable/CMAKE_AUTORCC_OPTIONS
+   /variable/CMAKE_AUTOUIC
+   /variable/CMAKE_AUTOUIC_OPTIONS
    /variable/CMAKE_BUILD_WITH_INSTALL_RPATH
    /variable/CMAKE_CONFIG_POSTFIX
    /variable/CMAKE_DEBUG_POSTFIX
diff --git a/Help/prop_gbl/AUTOGEN_TARGETS_FOLDER.rst b/Help/prop_gbl/AUTOGEN_TARGETS_FOLDER.rst
new file mode 100644
index 0000000..48cc8a1
--- /dev/null
+++ b/Help/prop_gbl/AUTOGEN_TARGETS_FOLDER.rst
@@ -0,0 +1,8 @@
+AUTOGEN_TARGETS_FOLDER
+----------------------
+
+Name of FOLDER for ``*_automoc`` targets that are added automatically by CMake for targets for which AUTOMOC is enabled.
+
+If not set, CMake uses the FOLDER property of the parent target as a
+default value for this property.  See also the documentation for the
+FOLDER target property and the AUTOMOC target property.
diff --git a/Help/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst b/Help/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst
index c83fb8b..185e0ec 100644
--- a/Help/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst
+++ b/Help/prop_gbl/AUTOMOC_TARGETS_FOLDER.rst
@@ -3,6 +3,8 @@ AUTOMOC_TARGETS_FOLDER
 
 Name of FOLDER for ``*_automoc`` targets that are added automatically by CMake for targets for which AUTOMOC is enabled.
 
+This property is obsolete.  Use AUTOGEN_TARGETS_FOLDER instead.
+
 If not set, CMake uses the FOLDER property of the parent target as a
 default value for this property.  See also the documentation for the
 FOLDER target property and the AUTOMOC target property.
diff --git a/Help/prop_sf/AUTORCC_OPTIONS.rst b/Help/prop_sf/AUTORCC_OPTIONS.rst
new file mode 100644
index 0000000..4b6bb10
--- /dev/null
+++ b/Help/prop_sf/AUTORCC_OPTIONS.rst
@@ -0,0 +1,14 @@
+AUTORCC_OPTIONS
+---------------
+
+Additional options for rcc when using autorcc (see the :prop_tgt:`AUTORCC` target
+property)
+
+This property holds additional command line options which will be used when
+rcc is executed during the build via autorcc, i.e. it is equivalent to the
+optional OPTIONS argument of the qt4_add_resources() macro.
+
+By default it is empty.
+
+The options set on the .qrc source file may override :prop_tgt:`AUTORCC_OPTIONS` set
+on the target.
diff --git a/Help/prop_sf/AUTOUIC_OPTIONS.rst b/Help/prop_sf/AUTOUIC_OPTIONS.rst
new file mode 100644
index 0000000..a38b2f8
--- /dev/null
+++ b/Help/prop_sf/AUTOUIC_OPTIONS.rst
@@ -0,0 +1,14 @@
+AUTOUIC_OPTIONS
+---------------
+
+Additional options for uic when using autouic (see the :prop_tgt:`AUTOUIC` target property)
+
+This property holds additional command line options
+which will be used when uic is executed during the build via autouic,
+i.e. it is equivalent to the optional OPTIONS argument of the
+qt4_wrap_ui() macro.
+
+By default it is empty.
+
+The options set on the .ui source file may override :prop_tgt:`AUTOUIC_OPTIONS` set
+on the target.
diff --git a/Help/prop_tgt/AUTORCC.rst b/Help/prop_tgt/AUTORCC.rst
new file mode 100644
index 0000000..ef2c9c8
--- /dev/null
+++ b/Help/prop_tgt/AUTORCC.rst
@@ -0,0 +1,21 @@
+
+AUTORCC
+-------
+
+Should the target be processed with autorcc (for Qt projects).
+
+AUTORCC is a boolean specifying whether CMake will handle
+the Qt rcc code generator automatically, i.e. without having to use
+the QT4_ADD_RESOURCES() or QT5_ADD_RESOURCES() macro. Currently Qt4 and Qt5 are
+supported.
+
+When this property is set to TRUE, CMake will handle .qrc files added
+as target sources at build time and invoke rcc accordingly.
+This property is initialized by the value of the :variable:`CMAKE_AUTORCC`
+variable if it is set when a target is created.
+
+Additional command line options for rcc can be set via the
+:prop_sf:`AUTORCC_OPTIONS` source file property on the .qrc file.
+
+The global property :prop_gbl:`AUTOGEN_TARGETS_FOLDER` can be used to group the
+autouic targets together in an IDE, e.g. in MSVS.
diff --git a/Help/prop_tgt/AUTORCC_OPTIONS.rst b/Help/prop_tgt/AUTORCC_OPTIONS.rst
new file mode 100644
index 0000000..489e277
--- /dev/null
+++ b/Help/prop_tgt/AUTORCC_OPTIONS.rst
@@ -0,0 +1,17 @@
+AUTORCC_OPTIONS
+---------------
+
+Additional options for rcc when using autorcc (see the :prop_tgt:`AUTORCC` target property)
+
+This property holds additional command line options
+which will be used when rcc is executed during the build via autorcc,
+i.e. it is equivalent to the optional OPTIONS argument of the
+qt4_add_resources() macro.
+
+By default it is empty.
+
+This property is initialized by the value of the variable
+:variable:`CMAKE_AUTORCC` if it is set when a target is created.
+
+The options set on the target may be overridden by :prop_sf:`AUTORCC_OPTIONS` set
+on the .qrc source file.
diff --git a/Help/prop_tgt/AUTOUIC.rst b/Help/prop_tgt/AUTOUIC.rst
new file mode 100644
index 0000000..548c259
--- /dev/null
+++ b/Help/prop_tgt/AUTOUIC.rst
@@ -0,0 +1,22 @@
+AUTOUIC
+-------
+
+Should the target be processed with autouic (for Qt projects).
+
+AUTOUIC is a boolean specifying whether CMake will handle
+the Qt uic code generator automatically, i.e. without having to use
+the QT4_WRAP_UI() or QT5_WRAP_UI() macro. Currently Qt4 and Qt5 are
+supported.
+
+When this property is set to TRUE, CMake will scan the source files
+at build time and invoke uic accordingly.
+If an #include statement like #include "ui_foo.h" is found in
+foo.cpp, a foo.ui file is expected next to foo.cpp, and uic is
+run on the foo.ui file.
+This property is initialized by the value of the :variable:`CMAKE_AUTOUIC`
+variable if it is set when a target is created.
+
+Additional command line options for uic can be set via the
+:prop_sf:`AUTOUIC_OPTIONS` source file property on the foo.ui file.
+The global property :prop_gbl:`AUTOGEN_TARGETS_FOLDER` can be used to group the
+autouic targets together in an IDE, e.g. in MSVS.
diff --git a/Help/prop_tgt/AUTOUIC_OPTIONS.rst b/Help/prop_tgt/AUTOUIC_OPTIONS.rst
new file mode 100644
index 0000000..c6cf885
--- /dev/null
+++ b/Help/prop_tgt/AUTOUIC_OPTIONS.rst
@@ -0,0 +1,17 @@
+AUTOUIC_OPTIONS
+---------------
+
+Additional options for uic when using autouic (see the :prop_tgt:`AUTOUIC` target property)
+
+This property holds additional command line options
+which will be used when uic is executed during the build via autouic,
+i.e. it is equivalent to the optional OPTIONS argument of the
+qt4_wrap_ui() macro.
+
+By default it is empty.
+
+This property is initialized by the value of the variable
+:variable:`CMAKE_AUTOUIC` if it is set when a target is created.
+
+The options set on the target may be overridden by :prop_sf:`AUTOUIC_OPTIONS` set
+on the .ui source file.
diff --git a/Help/variable/CMAKE_AUTORCC.rst b/Help/variable/CMAKE_AUTORCC.rst
new file mode 100644
index 0000000..d213993
--- /dev/null
+++ b/Help/variable/CMAKE_AUTORCC.rst
@@ -0,0 +1,7 @@
+CMAKE_AUTORCC
+-------------
+
+Whether to handle rcc automatically for Qt targets.
+
+This variable is used to initialize the :prop_tgt:`AUTORCC` property on all the targets.
+See that target property for additional information.
diff --git a/Help/variable/CMAKE_AUTORCC_OPTIONS.rst b/Help/variable/CMAKE_AUTORCC_OPTIONS.rst
new file mode 100644
index 0000000..5efbfa3
--- /dev/null
+++ b/Help/variable/CMAKE_AUTORCC_OPTIONS.rst
@@ -0,0 +1,7 @@
+CMAKE_AUTORCC_OPTIONS
+---------------------
+
+Whether to handle rcc automatically for Qt targets.
+
+This variable is used to initialize the :prop_tgt:`AUTORCC_OPTIONS` property on
+all the targets.  See that target property for additional information.
diff --git a/Help/variable/CMAKE_AUTOUIC.rst b/Help/variable/CMAKE_AUTOUIC.rst
new file mode 100644
index 0000000..3b016b0
--- /dev/null
+++ b/Help/variable/CMAKE_AUTOUIC.rst
@@ -0,0 +1,7 @@
+CMAKE_AUTOUIC
+-------------
+
+Whether to handle uic automatically for Qt targets.
+
+This variable is used to initialize the :prop_tgt:`AUTOUIC` property on all the targets.
+See that target property for additional information.
diff --git a/Help/variable/CMAKE_AUTOUIC_OPTIONS.rst b/Help/variable/CMAKE_AUTOUIC_OPTIONS.rst
new file mode 100644
index 0000000..6a88669
--- /dev/null
+++ b/Help/variable/CMAKE_AUTOUIC_OPTIONS.rst
@@ -0,0 +1,7 @@
+CMAKE_AUTOUIC_OPTIONS
+---------------------
+
+Whether to handle uic automatically for Qt targets.
+
+This variable is used to initialize the :prop_tgt:`AUTOUIC_OPTIONS` property on
+all the targets.  See that target property for additional information.
diff --git a/Modules/AutomocInfo.cmake.in b/Modules/AutogenInfo.cmake.in
index 9cff735..7554213 100644
--- a/Modules/AutomocInfo.cmake.in
+++ b/Modules/AutogenInfo.cmake.in
@@ -1,4 +1,7 @@
 set(AM_SOURCES @_moc_files@ )
+set(AM_RCC_SOURCES @_rcc_files@ )
+set(AM_SKIP_MOC @_skip_moc@ )
+set(AM_SKIP_UIC @_skip_uic@ )
 set(AM_HEADERS @_moc_headers@ )
 set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
 set(AM_MOC_INCLUDES @_moc_incs@)
@@ -7,8 +10,15 @@ set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJ
 set(AM_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@/")
 set(AM_CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@/")
 set(AM_QT_MOC_EXECUTABLE "@_qt_moc_executable@")
+set(AM_QT_UIC_EXECUTABLE "@_qt_uic_executable@")
+set(AM_QT_RCC_EXECUTABLE "@_qt_rcc_executable@")
 set(AM_CMAKE_CURRENT_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@/")
 set(AM_CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/")
 set(AM_QT_VERSION_MAJOR "@_target_qt_version@")
 set(AM_TARGET_NAME @_moc_target_name@)
 set(AM_RELAXED_MODE "@_moc_relaxed_mode@")
+set(AM_UIC_TARGET_OPTIONS @_uic_target_options@)
+set(AM_UIC_OPTIONS_FILES @_qt_uic_options_files@)
+set(AM_UIC_OPTIONS_OPTIONS @_qt_uic_options_options@)
+set(AM_RCC_OPTIONS_FILES @_qt_rcc_options_files@)
+set(AM_RCC_OPTIONS_OPTIONS @_qt_rcc_options_options@)
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index fd97a20..c01245c 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -250,8 +250,8 @@ set(SRCS
   cmPropertyDefinitionMap.h
   cmPropertyMap.cxx
   cmPropertyMap.h
-  cmQtAutomoc.cxx
-  cmQtAutomoc.h
+  cmQtAutoGenerators.cxx
+  cmQtAutoGenerators.h
   cmRST.cxx
   cmRST.h
   cmScriptGenerator.h
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 5b0df2c..465763d 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -18,7 +18,7 @@
 #include "cmExternalMakefileProjectGenerator.h"
 #include "cmake.h"
 #include "cmMakefile.h"
-#include "cmQtAutomoc.h"
+#include "cmQtAutoGenerators.h"
 #include "cmSourceFile.h"
 #include "cmVersion.h"
 #include "cmTargetExport.h"
@@ -1096,8 +1096,8 @@ void cmGlobalGenerator::Generate()
     }
 
   // Iterate through all targets and set up automoc for those which have
-  // the AUTOMOC property set
-  this->CreateAutomocTargets();
+  // the AUTOMOC, AUTOUIC or AUTORCC property set
+  this->CreateQtAutoGeneratorsTargets();
 
   // For each existing cmLocalGenerator
   unsigned int i;
@@ -1253,11 +1253,11 @@ bool cmGlobalGenerator::CheckTargets()
 }
 
 //----------------------------------------------------------------------------
-void cmGlobalGenerator::CreateAutomocTargets()
+void cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
 {
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  typedef std::vector<std::pair<cmQtAutomoc, cmTarget*> > Automocs;
-  Automocs automocs;
+  typedef std::vector<std::pair<cmQtAutoGenerators, cmTarget*> > Autogens;
+  Autogens autogens;
   for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
     {
     cmTargets& targets =
@@ -1272,21 +1272,24 @@ void cmGlobalGenerator::CreateAutomocTargets()
          target.GetType() == cmTarget::MODULE_LIBRARY ||
          target.GetType() == cmTarget::OBJECT_LIBRARY)
         {
-        if(target.GetPropertyAsBool("AUTOMOC") && !target.IsImported())
+        if((target.GetPropertyAsBool("AUTOMOC")
+              || target.GetPropertyAsBool("AUTOUIC")
+              || target.GetPropertyAsBool("AUTORCC"))
+            && !target.IsImported())
           {
-          cmQtAutomoc automoc;
-          if(automoc.InitializeMocSourceFile(&target))
+          cmQtAutoGenerators autogen;
+          if(autogen.InitializeMocSourceFile(&target))
             {
-            automocs.push_back(std::make_pair(automoc, &target));
+            autogens.push_back(std::make_pair(autogen, &target));
             }
           }
         }
       }
     }
-  for (Automocs::iterator it = automocs.begin(); it != automocs.end();
+  for (Autogens::iterator it = autogens.begin(); it != autogens.end();
        ++it)
     {
-    it->first.SetupAutomocTarget(it->second);
+    it->first.SetupAutoGenerateTarget(it->second);
     }
 #endif
 }
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 3c4ddb2..1538cb5 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -319,7 +319,7 @@ protected:
   virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS();
 
   bool CheckTargets();
-  void CreateAutomocTargets();
+  void CreateQtAutoGeneratorsTargets();
 
 
   // Fill the ProjectMap, this must be called after LocalGenerators
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index ade4252..c18a7eb 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -4207,6 +4207,18 @@ bool cmMakefile::EnforceUniqueDir(const char* srcPath, const char* binPath)
 }
 
 //----------------------------------------------------------------------------
+void cmMakefile::AddQtUiFileWithOptions(cmSourceFile *sf)
+{
+  this->QtUiFilesWithOptions.push_back(sf);
+}
+
+//----------------------------------------------------------------------------
+std::vector<cmSourceFile*> cmMakefile::GetQtUiFilesWithOptions() const
+{
+  return this->QtUiFilesWithOptions;
+}
+
+//----------------------------------------------------------------------------
 cmPolicies::PolicyStatus
 cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id)
 {
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 918c8bf..76958ca 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -877,6 +877,9 @@ public:
   bool IsGeneratingBuildSystem(){ return this->GeneratingBuildSystem; }
   void SetGeneratingBuildSystem(){ this->GeneratingBuildSystem = true; }
 
+  void AddQtUiFileWithOptions(cmSourceFile *sf);
+  std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const;
+
   std::set<cmStdString> const & GetSystemIncludeDirectories() const
     { return this->SystemIncludeDirectories; }
 
@@ -1054,6 +1057,8 @@ private:
                                cmSourceFile* source);
   void UpdateOutputToSourceMap(std::string const& output,
                                cmSourceFile* source);
+
+  std::vector<cmSourceFile*> QtUiFilesWithOptions;
 };
 
 //----------------------------------------------------------------------------
diff --git a/Source/cmQtAutomoc.cxx b/Source/cmQtAutoGenerators.cxx
index 651e0ad..5f7a26f 100644
--- a/Source/cmQtAutomoc.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -23,13 +23,14 @@
 
 #include <cmsys/Terminal.h>
 #include <cmsys/ios/sstream>
+#include <assert.h>
 
 #include <string.h>
 #if defined(__APPLE__)
 #include <unistd.h>
 #endif
 
-#include "cmQtAutomoc.h"
+#include "cmQtAutoGenerators.h"
 
 
 static bool requiresMocing(const std::string& text, std::string &macroName)
@@ -113,10 +114,12 @@ static void copyTargetProperty(cmTarget* destinationTarget,
 }
 
 
-cmQtAutomoc::cmQtAutomoc()
+cmQtAutoGenerators::cmQtAutoGenerators()
 :Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0)
 ,ColorOutput(true)
 ,RunMocFailed(false)
+,RunUicFailed(false)
+,RunRccFailed(false)
 ,GenerateAll(false)
 {
 
@@ -135,7 +138,7 @@ cmQtAutomoc::cmQtAutomoc()
     }
 }
 
-bool cmQtAutomoc::InitializeMocSourceFile(cmTarget* target)
+bool cmQtAutoGenerators::InitializeMocSourceFile(cmTarget* target)
 {
   cmMakefile* makefile = target->GetMakefile();
   // don't do anything if there is no Qt4 or Qt5Core (which contains moc):
@@ -149,18 +152,22 @@ bool cmQtAutomoc::InitializeMocSourceFile(cmTarget* target)
     return false;
     }
 
-  std::string automocTargetName = target->GetName();
-  automocTargetName += "_automoc";
-  std::string mocCppFile = makefile->GetCurrentOutputDirectory();
-  mocCppFile += "/";
-  mocCppFile += automocTargetName;
-  mocCppFile += ".cpp";
-  cmSourceFile* mocCppSource = makefile->GetOrCreateSource(mocCppFile.c_str(),
-                                                         true);
-  makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
-                           mocCppFile.c_str(), false);
-
-  target->AddSourceFile(mocCppSource);
+  if (target->GetPropertyAsBool("AUTOMOC"))
+    {
+    std::string automocTargetName = target->GetName();
+    automocTargetName += "_automoc";
+    std::string mocCppFile = makefile->GetCurrentOutputDirectory();
+    mocCppFile += "/";
+    mocCppFile += automocTargetName;
+    mocCppFile += ".cpp";
+    cmSourceFile* mocCppSource = makefile->GetOrCreateSource(
+                                                          mocCppFile.c_str(),
+                                                          true);
+    makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
+                            mocCppFile.c_str(), false);
+
+    target->AddSourceFile(mocCppSource);
+    }
   return true;
 }
 
@@ -201,27 +208,46 @@ static void GetCompileDefinitionsAndDirectories(cmTarget *target,
     }
 }
 
-void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
+void cmQtAutoGenerators::SetupAutoGenerateTarget(cmTarget* target)
 {
   cmMakefile* makefile = target->GetMakefile();
   const char* targetName = target->GetName();
 
-  bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
+  // forget the variables added here afterwards again:
+  cmMakefile::ScopePushPop varScope(makefile);
+  static_cast<void>(varScope);
 
-  // create a custom target for running automoc at buildtime:
-  std::string automocTargetName = targetName;
-  automocTargetName += "_automoc";
+  const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
+  if (!qtVersion)
+    {
+    qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR");
+    }
+  if (const char *targetQtVersion =
+      target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", 0))
+    {
+    qtVersion = targetQtVersion;
+    }
+  if (qtVersion)
+    {
+    makefile->AddDefinition("_target_qt_version", qtVersion);
+    }
+  // create a custom target for running generators at buildtime:
+  std::string autogenTargetName = targetName;
+  autogenTargetName += "_automoc";
+
+  makefile->AddDefinition("_moc_target_name",
+          cmLocalGenerator::EscapeForCMake(autogenTargetName.c_str()).c_str());
 
   std::string targetDir = makefile->GetCurrentOutputDirectory();
   targetDir += makefile->GetCMakeInstance()->GetCMakeFilesDirectory();
   targetDir += "/";
-  targetDir += automocTargetName;
+  targetDir += autogenTargetName;
   targetDir += ".dir/";
 
   cmCustomCommandLine currentLine;
   currentLine.push_back(makefile->GetSafeDefinition("CMAKE_COMMAND"));
   currentLine.push_back("-E");
-  currentLine.push_back("cmake_automoc");
+  currentLine.push_back("cmake_autogen");
   currentLine.push_back(targetDir);
   currentLine.push_back("$<CONFIGURATION>");
 
@@ -232,8 +258,33 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
                                     "", makefile->GetCurrentOutputDirectory());
 
   std::vector<std::string> depends;
-  std::string automocComment = "Automoc for target ";
-  automocComment += targetName;
+  std::vector<std::string> toolNames;
+  if (target->GetPropertyAsBool("AUTOMOC"))
+    {
+    toolNames.push_back("moc");
+    }
+  if (target->GetPropertyAsBool("AUTOUIC"))
+    {
+    toolNames.push_back("uic");
+    }
+  if (target->GetPropertyAsBool("AUTORCC"))
+    {
+    toolNames.push_back("rcc");
+    }
+
+  std::string tools = toolNames[0];
+  toolNames.erase(toolNames.begin());
+  while (toolNames.size() > 1)
+    {
+    tools += ", " + toolNames[0];
+    toolNames.erase(toolNames.begin());
+    }
+  if (toolNames.size() == 1)
+    {
+    tools += " and " + toolNames[0];
+    }
+  std::string autogenComment = "Automatic " + tools + " for target ";
+  autogenComment += targetName;
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
   bool usePRE_BUILD = false;
@@ -256,7 +307,7 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
     // PRE_BUILD will work for an OBJECT_LIBRARY in this specific case.
     std::vector<std::string> no_output;
     cmCustomCommand cc(makefile, no_output, depends,
-                       commandLines, automocComment.c_str(),
+                       commandLines, autogenComment.c_str(),
                        workingDirectory.c_str());
     cc.SetEscapeOldStyle(false);
     cc.SetEscapeAllowMakeVars(true);
@@ -265,27 +316,97 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
   else
 #endif
     {
-    cmTarget* automocTarget = makefile->AddUtilityCommand(
-                                automocTargetName.c_str(), true,
+    cmTarget* autogenTarget = makefile->AddUtilityCommand(
+                                autogenTargetName.c_str(), true,
                                 workingDirectory.c_str(), depends,
-                                commandLines, false, automocComment.c_str());
+                                commandLines, false, autogenComment.c_str());
     // Set target folder
-    const char* automocFolder = makefile->GetCMakeInstance()->GetProperty(
+    const char* autogenFolder = makefile->GetCMakeInstance()->GetProperty(
                                                      "AUTOMOC_TARGETS_FOLDER");
-    if (automocFolder && *automocFolder)
+    if (!autogenFolder)
       {
-      automocTarget->SetProperty("FOLDER", automocFolder);
+      autogenFolder = makefile->GetCMakeInstance()->GetProperty(
+                                                     "AUTOGEN_TARGETS_FOLDER");
+      }
+    if (autogenFolder && *autogenFolder)
+      {
+      autogenTarget->SetProperty("FOLDER", autogenFolder);
       }
     else
       {
       // inherit FOLDER property from target (#13688)
-      copyTargetProperty(automocTarget, target, "FOLDER");
+      copyTargetProperty(autogenTarget, target, "FOLDER");
       }
 
-    target->AddUtility(automocTargetName.c_str());
+    target->AddUtility(autogenTargetName.c_str());
+    }
+
+  std::map<std::string, std::string> configIncludes;
+  std::map<std::string, std::string> configDefines;
+
+  if (target->GetPropertyAsBool("AUTOMOC"))
+    {
+    this->SetupAutoMocTarget(target, autogenTargetName,
+                             configIncludes, configDefines);
+    }
+  if (target->GetPropertyAsBool("AUTOUIC"))
+    {
+    this->SetupAutoUicTarget(target);
+    }
+  if (target->GetPropertyAsBool("AUTORCC"))
+    {
+    this->SetupAutoRccTarget(target);
     }
 
-  // configure a file to get all information to automoc at buildtime:
+  const char* cmakeRoot = makefile->GetSafeDefinition("CMAKE_ROOT");
+  std::string inputFile = cmakeRoot;
+  inputFile += "/Modules/AutogenInfo.cmake.in";
+  std::string outputFile = targetDir;
+  outputFile += "/AutogenInfo.cmake";
+  makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(),
+                          false, true, false);
+
+  if (!configDefines.empty() || !configIncludes.empty())
+    {
+    std::ofstream infoFile(outputFile.c_str(), std::ios::app);
+    if ( !infoFile )
+      {
+      std::string error = "Internal CMake error when trying to open file: ";
+      error += outputFile.c_str();
+      error += " for writing.";
+      cmSystemTools::Error(error.c_str());
+      return;
+      }
+    if (!configDefines.empty())
+      {
+      for (std::map<std::string, std::string>::iterator
+            it = configDefines.begin(), end = configDefines.end();
+            it != end; ++it)
+        {
+        infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first <<
+          " " << it->second << ")\n";
+        }
+      }
+    if (!configIncludes.empty())
+      {
+      for (std::map<std::string, std::string>::iterator
+            it = configIncludes.begin(), end = configIncludes.end();
+            it != end; ++it)
+        {
+        infoFile << "set(AM_MOC_INCLUDES_" << it->first <<
+          " " << it->second << ")\n";
+        }
+      }
+    }
+}
+
+void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget* target,
+                          const std::string &autogenTargetName,
+                          std::map<std::string, std::string> &configIncludes,
+                          std::map<std::string, std::string> &configDefines)
+{
+  cmMakefile* makefile = target->GetMakefile();
+
   std::string _moc_files;
   std::string _moc_headers;
   const char* sepFiles = "";
@@ -293,6 +414,9 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
 
   const std::vector<cmSourceFile*>& srcFiles = target->GetSourceFiles();
 
+  std::string skip_moc;
+  const char *sep = "";
+
   for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
       fileIt != srcFiles.end();
       ++fileIt)
@@ -303,41 +427,46 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
     bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
     bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"));
 
-    if ((skip==false) && (generated == false))
+    if (!generated)
       {
-      std::string ext = sf->GetExtension();
-      cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat(
-                                                                  ext.c_str());
-      if (fileType == cmSystemTools::CXX_FILE_FORMAT)
+      if (skip)
         {
-        _moc_files += sepFiles;
-        _moc_files += absFile;
-        sepFiles = ";";
+        skip_moc += sep;
+        skip_moc += absFile;
+        sep = ";";
         }
-      else if (fileType == cmSystemTools::HEADER_FILE_FORMAT)
+      else
         {
-        _moc_headers += sepHeaders;
-        _moc_headers += absFile;
-        sepHeaders = ";";
+        std::string ext = sf->GetExtension();
+        cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat(
+                                                                ext.c_str());
+        if (fileType == cmSystemTools::CXX_FILE_FORMAT)
+          {
+          _moc_files += sepFiles;
+          _moc_files += absFile;
+          sepFiles = ";";
+          }
+        else if (fileType == cmSystemTools::HEADER_FILE_FORMAT)
+          {
+          _moc_headers += sepHeaders;
+          _moc_headers += absFile;
+          sepHeaders = ";";
+          }
         }
       }
     }
 
   const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
   std::string _moc_options = (tmp!=0 ? tmp : "");
-
-  // forget the variables added here afterwards again:
-  cmMakefile::ScopePushPop varScope(makefile);
-  static_cast<void>(varScope);
-
-  makefile->AddDefinition("_moc_target_name",
-          cmLocalGenerator::EscapeForCMake(automocTargetName.c_str()).c_str());
   makefile->AddDefinition("_moc_options",
           cmLocalGenerator::EscapeForCMake(_moc_options.c_str()).c_str());
   makefile->AddDefinition("_moc_files",
           cmLocalGenerator::EscapeForCMake(_moc_files.c_str()).c_str());
+  makefile->AddDefinition("_skip_moc",
+          cmLocalGenerator::EscapeForCMake(skip_moc.c_str()).c_str());
   makefile->AddDefinition("_moc_headers",
           cmLocalGenerator::EscapeForCMake(_moc_headers.c_str()).c_str());
+  bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
   makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
 
   std::string _moc_incs;
@@ -352,9 +481,6 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
   makefile->AddDefinition("_moc_compile_defs",
           cmLocalGenerator::EscapeForCMake(_moc_compile_defs.c_str()).c_str());
 
-  std::map<std::string, std::string> configIncludes;
-  std::map<std::string, std::string> configDefines;
-
   for (std::vector<std::string>::const_iterator li = configs.begin();
        li != configs.end(); ++li)
     {
@@ -383,33 +509,17 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
       }
     }
 
-  const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
-  if (!qtVersion)
-    {
-    qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR");
-    }
-  if (const char *targetQtVersion =
-      target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", 0))
-    {
-    qtVersion = targetQtVersion;
-    }
-  if (qtVersion)
-    {
-    makefile->AddDefinition("_target_qt_version", qtVersion);
-    }
-
-  {
   const char *qtMoc = makefile->GetSafeDefinition("QT_MOC_EXECUTABLE");
   makefile->AddDefinition("_qt_moc_executable", qtMoc);
-  }
 
+  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
   if (strcmp(qtVersion, "5") == 0)
     {
     cmTarget *qt5Moc = makefile->FindTargetToUse("Qt5::moc");
     if (!qt5Moc)
       {
       cmSystemTools::Error("Qt5::moc target not found ",
-                          automocTargetName.c_str());
+                          autogenTargetName.c_str());
       return;
       }
     makefile->AddDefinition("_qt_moc_executable", qt5Moc->GetLocation(0));
@@ -419,68 +529,338 @@ void cmQtAutomoc::SetupAutomocTarget(cmTarget* target)
     if (strcmp(qtVersion, "4") != 0)
       {
       cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and "
-                          "Qt 5 ", automocTargetName.c_str());
+                          "Qt 5 ", autogenTargetName.c_str());
       }
     }
+}
 
-  const char* cmakeRoot = makefile->GetSafeDefinition("CMAKE_ROOT");
-  std::string inputFile = cmakeRoot;
-  inputFile += "/Modules/AutomocInfo.cmake.in";
-  std::string outputFile = targetDir;
-  outputFile += "/AutomocInfo.cmake";
-  makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(),
-                          false, true, false);
+void cmQtAutoGenerators::MergeUicOptions(std::vector<std::string> &opts,
+                         const std::vector<std::string> &fileOpts,
+                         bool isQt5)
+{
+  static const char* valueOptions[] = {
+    "tr",
+    "translate",
+    "postfix",
+    "generator",
+    "g"
+  };
+  std::vector<std::string> extraOpts;
+  for(std::vector<std::string>::const_iterator it = fileOpts.begin();
+      it != fileOpts.end(); ++it)
+    {
+    std::vector<std::string>::iterator existingIt
+                                  = std::find(opts.begin(), opts.end(), *it);
+    if (existingIt != opts.end())
+      {
+      const char *o = it->c_str();
+      if (*o == '-')
+        {
+        ++o;
+        }
+      if (isQt5 && *o == '-')
+        {
+        ++o;
+        }
+      if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
+                  cmStrCmp(o)) != cmArrayEnd(valueOptions))
+        {
+        assert(existingIt + 1 != opts.end());
+        *(existingIt + 1) = *(it + 1);
+        ++it;
+        }
+      }
+    else
+      {
+      extraOpts.push_back(*it);
+      }
+    }
+  opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
+}
 
-  if (!configDefines.empty() || !configIncludes.empty())
+void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget* target)
+{
+  cmMakefile *makefile = target->GetMakefile();
+
+  const char *qtUic = makefile->GetSafeDefinition("QT_UIC_EXECUTABLE");
+  makefile->AddDefinition("_qt_uic_executable", qtUic);
+
+  const std::vector<cmSourceFile*>& srcFiles = target->GetSourceFiles();
+
+  std::string skip_uic;
+  const char *sep = "";
+
+  bool skip  = target->GetPropertyAsBool("SKIP_AUTOUIC");
+
+  std::set<cmStdString> skipped;
+
+  for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
+      fileIt != srcFiles.end();
+      ++fileIt)
     {
-    std::ofstream infoFile(outputFile.c_str(), std::ios::app);
-    if ( !infoFile )
+    cmSourceFile* sf = *fileIt;
+    std::string absFile = cmsys::SystemTools::GetRealPath(
+                                                    sf->GetFullPath().c_str());
+    if (!skip)
       {
-      std::string error = "Internal CMake error when trying to open file: ";
-      error += outputFile.c_str();
-      error += " for writing.";
-      cmSystemTools::Error(error.c_str());
-      return;
+      skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"));
       }
-    if (!configDefines.empty())
+
+    if (skip)
       {
-      for (std::map<std::string, std::string>::iterator
-            it = configDefines.begin(), end = configDefines.end();
-            it != end; ++it)
+      skip_uic += sep;
+      skip_uic += absFile;
+      sep = ";";
+      skipped.insert(absFile);
+      }
+    }
+
+  makefile->AddDefinition("_skip_uic",
+          cmLocalGenerator::EscapeForCMake(skip_uic.c_str()).c_str());
+
+  std::vector<cmSourceFile*> uiFilesWithOptions
+                                        = makefile->GetQtUiFilesWithOptions();
+
+  std::string uiFileFiles;
+  std::string uiFileOptions;
+  sep = "";
+
+  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
+
+  if (const char* opts = target->GetProperty("AUTOUIC_OPTIONS"))
+    {
+    makefile->AddDefinition("_uic_target_options",
+                            cmLocalGenerator::EscapeForCMake(opts).c_str());
+    }
+
+  for(std::vector<cmSourceFile*>::const_iterator fileIt =
+      uiFilesWithOptions.begin();
+      fileIt != uiFilesWithOptions.end();
+      ++fileIt)
+    {
+    cmSourceFile* sf = *fileIt;
+    std::string absFile = cmsys::SystemTools::GetRealPath(
+                                                    sf->GetFullPath().c_str());
+
+    if (!skipped.insert(absFile).second)
+      {
+      continue;
+      }
+    uiFileFiles += sep;
+    uiFileFiles += absFile;
+    uiFileOptions += sep;
+    std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
+    cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
+    uiFileOptions += opts;
+    sep = ";";
+    }
+
+  makefile->AddDefinition("_qt_uic_options_files",
+              cmLocalGenerator::EscapeForCMake(uiFileFiles.c_str()).c_str());
+  makefile->AddDefinition("_qt_uic_options_options",
+            cmLocalGenerator::EscapeForCMake(uiFileOptions.c_str()).c_str());
+
+  const char* targetName = target->GetName();
+  if (strcmp(qtVersion, "5") == 0)
+    {
+    cmTarget *qt5Uic = makefile->FindTargetToUse("Qt5::uic");
+    if (!qt5Uic)
+      {
+      // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
+      makefile->RemoveDefinition("_qt_uic_executable");
+      }
+    else
+      {
+      makefile->AddDefinition("_qt_uic_executable", qt5Uic->GetLocation(0));
+      }
+    }
+  else
+    {
+    if (strcmp(qtVersion, "4") != 0)
+      {
+      cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
+                          "Qt 5 ", targetName);
+      }
+    }
+}
+
+void cmQtAutoGenerators::MergeRccOptions(std::vector<std::string> &opts,
+                         const std::vector<std::string> &fileOpts,
+                         bool isQt5)
+{
+  static const char* valueOptions[] = {
+    "name",
+    "root",
+    "compress",
+    "threshold"
+  };
+  std::vector<std::string> extraOpts;
+  for(std::vector<std::string>::const_iterator it = fileOpts.begin();
+      it != fileOpts.end(); ++it)
+    {
+    std::vector<std::string>::iterator existingIt
+                                  = std::find(opts.begin(), opts.end(), *it);
+    if (existingIt != opts.end())
+      {
+      const char *o = it->c_str();
+      if (*o == '-')
         {
-        infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first <<
-          " " << it->second << ")\n";
+        ++o;
+        }
+      if (isQt5 && *o == '-')
+        {
+        ++o;
+        }
+      if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
+                  cmStrCmp(o)) != cmArrayEnd(valueOptions))
+        {
+        assert(existingIt + 1 != opts.end());
+        *(existingIt + 1) = *(it + 1);
+        ++it;
         }
       }
-    if (!configIncludes.empty())
+    else
       {
-      for (std::map<std::string, std::string>::iterator
-            it = configIncludes.begin(), end = configIncludes.end();
-            it != end; ++it)
+      extraOpts.push_back(*it);
+      }
+    }
+  opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
+}
+
+void cmQtAutoGenerators::SetupAutoRccTarget(cmTarget* target)
+{
+  std::string _rcc_files;
+  const char* sepRccFiles = "";
+  cmMakefile *makefile = target->GetMakefile();
+
+  std::vector<cmSourceFile*> newFiles;
+
+  const std::vector<cmSourceFile*>& srcFiles = target->GetSourceFiles();
+
+  std::string rccFileFiles;
+  std::string rccFileOptions;
+  const char *sep = "";
+
+  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
+
+  std::vector<std::string> rccOptions;
+  if (const char* opts = target->GetProperty("AUTORCC_OPTIONS"))
+    {
+    cmSystemTools::ExpandListArgument(opts, rccOptions);
+    }
+
+  for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
+      fileIt != srcFiles.end();
+      ++fileIt)
+    {
+    cmSourceFile* sf = *fileIt;
+    std::string ext = sf->GetExtension();
+    if (ext == "qrc")
+      {
+      std::string absFile = cmsys::SystemTools::GetRealPath(
+                                                  sf->GetFullPath().c_str());
+      bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"));
+
+      if (!skip)
         {
-        infoFile << "set(AM_MOC_INCLUDES_" << it->first <<
-          " " << it->second << ")\n";
+        _rcc_files += sepRccFiles;
+        _rcc_files += absFile;
+        sepRccFiles = ";";
+
+        std::string basename = cmsys::SystemTools::
+                                      GetFilenameWithoutLastExtension(absFile);
+
+        std::string rcc_output_file = makefile->GetCurrentOutputDirectory();
+        rcc_output_file += "/qrc_" + basename + ".cpp";
+        makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
+                                rcc_output_file.c_str(), false);
+        cmSourceFile* rccCppSource
+                = makefile->GetOrCreateSource(rcc_output_file.c_str(), true);
+        newFiles.push_back(rccCppSource);
+
+        if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS"))
+          {
+          std::vector<std::string> optsVec;
+          cmSystemTools::ExpandListArgument(prop, optsVec);
+          this->MergeRccOptions(rccOptions, optsVec,
+                                strcmp(qtVersion, "5") == 0);
+          }
+
+        if (!rccOptions.empty())
+          {
+          rccFileFiles += sep;
+          rccFileFiles += absFile;
+          rccFileOptions += sep;
+          }
+        const char *listSep = "";
+        for(std::vector<std::string>::const_iterator it = rccOptions.begin();
+            it != rccOptions.end();
+            ++it)
+          {
+          rccFileOptions += listSep;
+          rccFileOptions += *it;
+          listSep = "@list_sep@";
+          }
+        sep = ";";
         }
       }
     }
-}
 
+  for(std::vector<cmSourceFile*>::const_iterator fileIt = newFiles.begin();
+      fileIt != newFiles.end();
+      ++fileIt)
+    {
+    target->AddSourceFile(*fileIt);
+    }
+
+  makefile->AddDefinition("_rcc_files",
+          cmLocalGenerator::EscapeForCMake(_rcc_files.c_str()).c_str());
 
-bool cmQtAutomoc::Run(const char* targetDirectory, const char *config)
+  makefile->AddDefinition("_qt_rcc_options_files",
+              cmLocalGenerator::EscapeForCMake(rccFileFiles.c_str()).c_str());
+  makefile->AddDefinition("_qt_rcc_options_options",
+            cmLocalGenerator::EscapeForCMake(rccFileOptions.c_str()).c_str());
+
+  const char *qtRcc = makefile->GetSafeDefinition("QT_RCC_EXECUTABLE");
+  makefile->AddDefinition("_qt_rcc_executable", qtRcc);
+
+  const char* targetName = target->GetName();
+  if (strcmp(qtVersion, "5") == 0)
+    {
+    cmTarget *qt5Rcc = makefile->FindTargetToUse("Qt5::rcc");
+    if (!qt5Rcc)
+      {
+      cmSystemTools::Error("Qt5::rcc target not found ",
+                          targetName);
+      return;
+      }
+    makefile->AddDefinition("_qt_rcc_executable", qt5Rcc->GetLocation(0));
+    }
+  else
+    {
+    if (strcmp(qtVersion, "4") != 0)
+      {
+      cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and "
+                          "Qt 5 ", targetName);
+      }
+    }
+}
+
+bool cmQtAutoGenerators::Run(const char* targetDirectory, const char *config)
 {
   bool success = true;
   cmake cm;
   cmGlobalGenerator* gg = this->CreateGlobalGenerator(&cm, targetDirectory);
   cmMakefile* makefile = gg->GetCurrentLocalGenerator()->GetMakefile();
 
-  this->ReadAutomocInfoFile(makefile, targetDirectory, config);
+  this->ReadAutogenInfoFile(makefile, targetDirectory, config);
   this->ReadOldMocDefinitionsFile(makefile, targetDirectory);
 
   this->Init();
 
   if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5")
     {
-    success = this->RunAutomoc(makefile);
+    success = this->RunAutogen(makefile);
     }
 
   this->WriteOldMocDefinitionsFile(targetDirectory);
@@ -492,7 +872,7 @@ bool cmQtAutomoc::Run(const char* targetDirectory, const char *config)
 }
 
 
-cmGlobalGenerator* cmQtAutomoc::CreateGlobalGenerator(cmake* cm,
+cmGlobalGenerator* cmQtAutoGenerators::CreateGlobalGenerator(cmake* cm,
                                                   const char* targetDirectory)
 {
   cmGlobalGenerator* gg = new cmGlobalGenerator();
@@ -509,13 +889,13 @@ cmGlobalGenerator* cmQtAutomoc::CreateGlobalGenerator(cmake* cm,
 }
 
 
-bool cmQtAutomoc::ReadAutomocInfoFile(cmMakefile* makefile,
+bool cmQtAutoGenerators::ReadAutogenInfoFile(cmMakefile* makefile,
                                       const char* targetDirectory,
                                       const char *config)
 {
   std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
-  filename += "/AutomocInfo.cmake";
+  filename += "/AutogenInfo.cmake";
 
   if (!makefile->ReadListFile(0, filename.c_str()))
     {
@@ -530,12 +910,17 @@ bool cmQtAutomoc::ReadAutomocInfoFile(cmMakefile* makefile,
                                      "AM_Qt5Core_VERSION_MAJOR");
     }
   this->Sources = makefile->GetSafeDefinition("AM_SOURCES");
+  this->RccSources = makefile->GetSafeDefinition("AM_RCC_SOURCES");
+  this->SkipMoc = makefile->GetSafeDefinition("AM_SKIP_MOC");
+  this->SkipUic = makefile->GetSafeDefinition("AM_SKIP_UIC");
   this->Headers = makefile->GetSafeDefinition("AM_HEADERS");
   this->IncludeProjectDirsBefore = makefile->IsOn(
                                 "AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
   this->Srcdir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_SOURCE_DIR");
   this->Builddir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_BINARY_DIR");
   this->MocExecutable = makefile->GetSafeDefinition("AM_QT_MOC_EXECUTABLE");
+  this->UicExecutable = makefile->GetSafeDefinition("AM_QT_UIC_EXECUTABLE");
+  this->RccExecutable = makefile->GetSafeDefinition("AM_QT_RCC_EXECUTABLE");
   std::string compileDefsPropOrig = "AM_MOC_COMPILE_DEFINITIONS";
   std::string compileDefsProp = compileDefsPropOrig;
   if(config)
@@ -561,6 +946,53 @@ bool cmQtAutomoc::ReadAutomocInfoFile(cmMakefile* makefile,
   this->ProjectSourceDir = makefile->GetSafeDefinition("AM_CMAKE_SOURCE_DIR");
   this->TargetName = makefile->GetSafeDefinition("AM_TARGET_NAME");
 
+  {
+  const char *uicOptionsFiles
+                        = makefile->GetSafeDefinition("AM_UIC_OPTIONS_FILES");
+  const char *uicTargetOptions
+                        = makefile->GetSafeDefinition("AM_UIC_TARGET_OPTIONS");
+  cmSystemTools::ExpandListArgument(uicTargetOptions, this->UicTargetOptions);
+  const char *uicOptionsOptions
+                      = makefile->GetSafeDefinition("AM_UIC_OPTIONS_OPTIONS");
+  std::vector<std::string> uicFilesVec;
+  cmSystemTools::ExpandListArgument(uicOptionsFiles, uicFilesVec);
+  std::vector<std::string> uicOptionsVec;
+  cmSystemTools::ExpandListArgument(uicOptionsOptions, uicOptionsVec);
+  if (uicFilesVec.size() != uicOptionsVec.size())
+    {
+    return false;
+    }
+  for (std::vector<std::string>::iterator fileIt = uicFilesVec.begin(),
+                                            optionIt = uicOptionsVec.begin();
+                                            fileIt != uicFilesVec.end();
+                                            ++fileIt, ++optionIt)
+    {
+    cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
+    this->UicOptions[*fileIt] = *optionIt;
+    }
+  }
+  {
+  const char *rccOptionsFiles
+                        = makefile->GetSafeDefinition("AM_RCC_OPTIONS_FILES");
+  const char *rccOptionsOptions
+                      = makefile->GetSafeDefinition("AM_RCC_OPTIONS_OPTIONS");
+  std::vector<std::string> rccFilesVec;
+  cmSystemTools::ExpandListArgument(rccOptionsFiles, rccFilesVec);
+  std::vector<std::string> rccOptionsVec;
+  cmSystemTools::ExpandListArgument(rccOptionsOptions, rccOptionsVec);
+  if (rccFilesVec.size() != rccOptionsVec.size())
+    {
+    return false;
+    }
+  for (std::vector<std::string>::iterator fileIt = rccFilesVec.begin(),
+                                            optionIt = rccOptionsVec.begin();
+                                            fileIt != rccFilesVec.end();
+                                            ++fileIt, ++optionIt)
+    {
+    cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
+    this->RccOptions[*fileIt] = *optionIt;
+    }
+  }
   this->CurrentCompileSettingsStr = this->MakeCompileSettingsString(makefile);
 
   this->RelaxedMode = makefile->IsOn("AM_RELAXED_MODE");
@@ -569,7 +1001,7 @@ bool cmQtAutomoc::ReadAutomocInfoFile(cmMakefile* makefile,
 }
 
 
-std::string cmQtAutomoc::MakeCompileSettingsString(cmMakefile* makefile)
+std::string cmQtAutoGenerators::MakeCompileSettingsString(cmMakefile* makefile)
 {
   std::string s;
   s += makefile->GetSafeDefinition("AM_MOC_COMPILE_DEFINITIONS");
@@ -586,7 +1018,7 @@ std::string cmQtAutomoc::MakeCompileSettingsString(cmMakefile* makefile)
 }
 
 
-bool cmQtAutomoc::ReadOldMocDefinitionsFile(cmMakefile* makefile,
+bool cmQtAutoGenerators::ReadOldMocDefinitionsFile(cmMakefile* makefile,
                                             const char* targetDirectory)
 {
   std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
@@ -602,7 +1034,8 @@ bool cmQtAutomoc::ReadOldMocDefinitionsFile(cmMakefile* makefile,
 }
 
 
-void cmQtAutomoc::WriteOldMocDefinitionsFile(const char* targetDirectory)
+void
+cmQtAutoGenerators::WriteOldMocDefinitionsFile(const char* targetDirectory)
 {
   std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
@@ -619,7 +1052,7 @@ void cmQtAutomoc::WriteOldMocDefinitionsFile(const char* targetDirectory)
 }
 
 
-void cmQtAutomoc::Init()
+void cmQtAutoGenerators::Init()
 {
   this->OutMocCppFilename = this->Builddir;
   this->OutMocCppFilename += this->TargetName;
@@ -706,7 +1139,7 @@ void cmQtAutomoc::Init()
 }
 
 
-bool cmQtAutomoc::RunAutomoc(cmMakefile* makefile)
+bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
 {
   if (!cmsys::SystemTools::FileExists(this->OutMocCppFilename.c_str())
     || (this->OldCompileSettingsStr != this->CurrentCompileSettingsStr))
@@ -733,26 +1166,56 @@ bool cmQtAutomoc::RunAutomoc(cmMakefile* makefile)
   const std::vector<std::string>& headerExtensions =
                                                makefile->GetHeaderExtensions();
 
+  std::vector<std::string> includedUis;
+  std::vector<std::string> skippedUis;
+  std::vector<std::string> uicSkipped;
+  cmSystemTools::ExpandListArgument(this->SkipUic, uicSkipped);
+
   for (std::vector<std::string>::const_iterator it = sourceFiles.begin();
        it != sourceFiles.end();
        ++it)
     {
+    const bool skipUic = std::find(uicSkipped.begin(), uicSkipped.end(), *it)
+        != uicSkipped.end();
+    std::vector<std::string>& uiFiles = skipUic ? skippedUis : includedUis;
     const std::string &absFilename = *it;
     if (this->Verbose)
       {
-      std::cout << "AUTOMOC: Checking " << absFilename << std::endl;
+      std::cout << "AUTOGEN: Checking " << absFilename << std::endl;
       }
     if (this->RelaxedMode)
       {
-      this->ParseCppFile(absFilename, headerExtensions, includedMocs);
+      this->ParseCppFile(absFilename, headerExtensions, includedMocs,
+                         uiFiles);
       }
     else
       {
-      this->StrictParseCppFile(absFilename, headerExtensions, includedMocs);
+      this->StrictParseCppFile(absFilename, headerExtensions, includedMocs,
+                               uiFiles);
       }
     this->SearchHeadersForCppFile(absFilename, headerExtensions, headerFiles);
     }
 
+  {
+  std::vector<std::string> mocSkipped;
+  cmSystemTools::ExpandListArgument(this->SkipMoc, mocSkipped);
+  for (std::vector<std::string>::const_iterator it = mocSkipped.begin();
+       it != mocSkipped.end();
+       ++it)
+    {
+    if (std::find(uicSkipped.begin(), uicSkipped.end(), *it)
+        != uicSkipped.end())
+      {
+      const std::string &absFilename = *it;
+      if (this->Verbose)
+        {
+        std::cout << "AUTOGEN: Checking " << absFilename << std::endl;
+        }
+      this->ParseForUic(absFilename, includedUis);
+      }
+    }
+  }
+
   std::vector<std::string> headerFilesVec;
   cmSystemTools::ExpandListArgument(this->Headers, headerFilesVec);
   for (std::vector<std::string>::const_iterator it = headerFilesVec.begin();
@@ -764,7 +1227,7 @@ bool cmQtAutomoc::RunAutomoc(cmMakefile* makefile)
 
   // key = moc source filepath, value = moc output filename
   std::map<std::string, std::string> notIncludedMocs;
-  this->ParseHeaders(headerFiles, includedMocs, notIncludedMocs);
+  this->ParseHeaders(headerFiles, includedMocs, notIncludedMocs, includedUis);
 
   // run moc on all the moc's that are #included in source files
   for(std::map<std::string, std::string>::const_iterator
@@ -774,6 +1237,17 @@ bool cmQtAutomoc::RunAutomoc(cmMakefile* makefile)
     {
     this->GenerateMoc(it->first, it->second);
     }
+  for(std::vector<std::string>::const_iterator it = includedUis.begin();
+      it != includedUis.end();
+      ++it)
+    {
+    this->GenerateUi(*it);
+    }
+
+  if(!this->RccExecutable.empty())
+    {
+    this->GenerateQrc();
+    }
 
   cmsys_ios::stringstream outStream;
   outStream << "/* This file is autogenerated, do not edit*/\n";
@@ -806,6 +1280,17 @@ bool cmQtAutomoc::RunAutomoc(cmMakefile* makefile)
     std::cerr << "moc failed..."<< std::endl;
     return false;
     }
+
+  if (this->RunUicFailed)
+    {
+    std::cerr << "uic failed..."<< std::endl;
+    return false;
+    }
+  if (this->RunRccFailed)
+    {
+    std::cerr << "rcc failed..."<< std::endl;
+    return false;
+    }
   outStream.flush();
   std::string automocSource = outStream.str();
   if (!automocCppChanged)
@@ -830,9 +1315,10 @@ bool cmQtAutomoc::RunAutomoc(cmMakefile* makefile)
 }
 
 
-void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
+void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
                               const std::vector<std::string>& headerExtensions,
-                              std::map<std::string, std::string>& includedMocs)
+                              std::map<std::string, std::string>& includedMocs,
+                              std::vector<std::string> &includedUis)
 {
   cmsys::RegularExpression mocIncludeRegExp(
               "[\n][ \t]*#[ \t]*include[ \t]+"
@@ -841,7 +1327,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
   const std::string contentsString = this->ReadAll(absFilename);
   if (contentsString.empty())
     {
-    std::cerr << "AUTOMOC: warning: " << absFilename << ": file is empty\n"
+    std::cerr << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
               << std::endl;
     return;
     }
@@ -901,7 +1387,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
           }
         else
           {
-          std::cerr << "AUTOMOC: error: " << absFilename << " The file "
+          std::cerr << "AUTOGEN: error: " << absFilename << " The file "
                     << "includes the moc file \"" << currentMoc << "\", "
                     << "but could not find header \"" << basename
                     << '{' << this->Join(headerExtensions, ',') << "}\" ";
@@ -932,7 +1418,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
             fileToMoc = headerToMoc;
             if ((requiresMoc==false) &&(basename==scannedFileBasename))
               {
-              std::cerr << "AUTOMOC: warning: " << absFilename << ": The file "
+              std::cerr << "AUTOGEN: warning: " << absFilename << ": The file "
                             "includes the moc file \"" << currentMoc <<
                             "\", but does not contain a " << macroName
                             << " macro. Running moc on "
@@ -943,7 +1429,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
               }
             else
               {
-              std::cerr << "AUTOMOC: warning: " << absFilename << ": The file "
+              std::cerr << "AUTOGEN: warning: " << absFilename << ": The file "
                             "includes the moc file \"" << currentMoc <<
                             "\" instead of \"moc_" << basename << ".cpp\". "
                             "Running moc on "
@@ -955,7 +1441,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
             }
           else
             {
-            std::cerr <<"AUTOMOC: error: " << absFilename << ": The file "
+            std::cerr <<"AUTOGEN: error: " << absFilename << ": The file "
                         "includes the moc file \"" << currentMoc <<
                         "\", which seems to be the moc file from a different "
                         "source file. CMake also could not find a matching "
@@ -973,6 +1459,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
       matchOffset += mocIncludeRegExp.end();
       } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
     }
+  this->ParseForUic(absFilename, contentsString, includedUis);
 
   // In this case, check whether the scanned file itself contains a Q_OBJECT.
   // If this is the case, the moc_foo.cpp should probably be generated from
@@ -983,7 +1470,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
     if (mocUnderscoreIncluded == true)
       {
       // this is for KDE4 compatibility:
-      std::cerr << "AUTOMOC: warning: " << absFilename << ": The file "
+      std::cerr << "AUTOGEN: warning: " << absFilename << ": The file "
                 << "contains a " << macroName << " macro, but does not "
                 "include "
                 << "\"" << scannedFileBasename << ".moc\", but instead "
@@ -999,7 +1486,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
     else
       {
       // otherwise always error out since it will not compile:
-      std::cerr << "AUTOMOC: error: " << absFilename << ": The file "
+      std::cerr << "AUTOGEN: error: " << absFilename << ": The file "
                 << "contains a " << macroName << " macro, but does not "
                 "include "
                 << "\"" << scannedFileBasename << ".moc\" !\n"
@@ -1011,9 +1498,10 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
 }
 
 
-void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
+void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
                               const std::vector<std::string>& headerExtensions,
-                              std::map<std::string, std::string>& includedMocs)
+                              std::map<std::string, std::string>& includedMocs,
+                              std::vector<std::string>& includedUis)
 {
   cmsys::RegularExpression mocIncludeRegExp(
               "[\n][ \t]*#[ \t]*include[ \t]+"
@@ -1022,7 +1510,7 @@ void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
   const std::string contentsString = this->ReadAll(absFilename);
   if (contentsString.empty())
     {
-    std::cerr << "AUTOMOC: warning: " << absFilename << ": file is empty\n"
+    std::cerr << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
               << std::endl;
     return;
     }
@@ -1069,7 +1557,7 @@ void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
           }
         else
           {
-          std::cerr << "AUTOMOC: error: " << absFilename << " The file "
+          std::cerr << "AUTOGEN: error: " << absFilename << " The file "
                     << "includes the moc file \"" << currentMoc << "\", "
                     << "but could not find header \"" << basename
                     << '{' << this->Join(headerExtensions, ',') << "}\" ";
@@ -1090,7 +1578,7 @@ void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
         {
         if (basename != scannedFileBasename)
           {
-          std::cerr <<"AUTOMOC: error: " << absFilename << ": The file "
+          std::cerr <<"AUTOGEN: error: " << absFilename << ": The file "
                       "includes the moc file \"" << currentMoc <<
                       "\", which seems to be the moc file from a different "
                       "source file. This is not supported. "
@@ -1104,6 +1592,7 @@ void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
       matchOffset += mocIncludeRegExp.end();
       } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
     }
+  this->ParseForUic(absFilename, contentsString, includedUis);
 
   // In this case, check whether the scanned file itself contains a Q_OBJECT.
   // If this is the case, the moc_foo.cpp should probably be generated from
@@ -1114,7 +1603,7 @@ void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
                                                      macroName)))
     {
     // otherwise always error out since it will not compile:
-    std::cerr << "AUTOMOC: error: " << absFilename << ": The file "
+    std::cerr << "AUTOGEN: error: " << absFilename << ": The file "
               << "contains a " << macroName << " macro, but does not include "
               << "\"" << scannedFileBasename << ".moc\" !\n"
               << std::endl;
@@ -1124,7 +1613,63 @@ void cmQtAutomoc::StrictParseCppFile(const std::string& absFilename,
 }
 
 
-void cmQtAutomoc::SearchHeadersForCppFile(const std::string& absFilename,
+void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
+                              std::vector<std::string>& includedUis)
+{
+  if (this->UicExecutable.empty())
+    {
+    return;
+    }
+  const std::string contentsString = this->ReadAll(absFilename);
+  if (contentsString.empty())
+    {
+    std::cerr << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
+              << std::endl;
+    return;
+    }
+  this->ParseForUic(absFilename, contentsString, includedUis);
+}
+
+
+void cmQtAutoGenerators::ParseForUic(const std::string&,
+                                     const std::string& contentsString,
+                                     std::vector<std::string>& includedUis)
+{
+  if (this->UicExecutable.empty())
+    {
+    return;
+    }
+  cmsys::RegularExpression uiIncludeRegExp(
+              "[\n][ \t]*#[ \t]*include[ \t]+"
+              "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
+
+  std::string::size_type matchOffset = 0;
+
+  matchOffset = 0;
+  if ((strstr(contentsString.c_str(), "ui_") != NULL)
+                                    && (uiIncludeRegExp.find(contentsString)))
+    {
+    do
+      {
+      const std::string currentUi = uiIncludeRegExp.match(1);
+
+      std::string basename = cmsys::SystemTools::
+                                  GetFilenameWithoutLastExtension(currentUi);
+
+      // basename should be the part of the ui filename used for
+      // finding the correct header, so we need to remove the ui_ part
+      basename = basename.substr(3);
+
+      includedUis.push_back(basename);
+
+      matchOffset += uiIncludeRegExp.end();
+      } while(uiIncludeRegExp.find(contentsString.c_str() + matchOffset));
+    }
+}
+
+
+void
+cmQtAutoGenerators::SearchHeadersForCppFile(const std::string& absFilename,
                               const std::vector<std::string>& headerExtensions,
                               std::set<std::string>& absHeaders)
 {
@@ -1160,28 +1705,29 @@ void cmQtAutomoc::SearchHeadersForCppFile(const std::string& absFilename,
 }
 
 
-void cmQtAutomoc::ParseHeaders(const std::set<std::string>& absHeaders,
+void cmQtAutoGenerators::ParseHeaders(const std::set<std::string>& absHeaders,
                         const std::map<std::string, std::string>& includedMocs,
-                        std::map<std::string, std::string>& notIncludedMocs)
+                        std::map<std::string, std::string>& notIncludedMocs,
+                        std::vector<std::string>& includedUis)
 {
   for(std::set<std::string>::const_iterator hIt=absHeaders.begin();
       hIt!=absHeaders.end();
       ++hIt)
     {
     const std::string& headerName = *hIt;
+    const std::string contents = this->ReadAll(headerName);
 
     if (includedMocs.find(headerName) == includedMocs.end())
       {
       if (this->Verbose)
         {
-        std::cout << "AUTOMOC: Checking " << headerName << std::endl;
+        std::cout << "AUTOGEN: Checking " << headerName << std::endl;
         }
 
       const std::string basename = cmsys::SystemTools::
                                    GetFilenameWithoutLastExtension(headerName);
 
       const std::string currentMoc = "moc_" + basename + ".cpp";
-      const std::string contents = this->ReadAll(headerName);
       std::string macroName;
       if (requiresMocing(contents, macroName))
         {
@@ -1189,12 +1735,11 @@ void cmQtAutomoc::ParseHeaders(const std::set<std::string>& absHeaders,
         notIncludedMocs[headerName] = currentMoc;
         }
       }
+    this->ParseForUic(headerName, contents, includedUis);
     }
-
 }
 
-
-bool cmQtAutomoc::GenerateMoc(const std::string& sourceFile,
+bool cmQtAutoGenerators::GenerateMoc(const std::string& sourceFile,
                               const std::string& mocFileName)
 {
   const std::string mocFilePath = this->Builddir + mocFileName;
@@ -1260,7 +1805,7 @@ bool cmQtAutomoc::GenerateMoc(const std::string& sourceFile,
     bool result = cmSystemTools::RunSingleCommand(command, &output, &retVal);
     if (!result || retVal)
       {
-      std::cerr << "AUTOMOC: error: process for " << mocFilePath <<" failed:\n"
+      std::cerr << "AUTOGEN: error: process for " << mocFilePath <<" failed:\n"
                 << output << std::endl;
       this->RunMocFailed = true;
       cmSystemTools::RemoveFile(mocFilePath.c_str());
@@ -1270,8 +1815,152 @@ bool cmQtAutomoc::GenerateMoc(const std::string& sourceFile,
   return false;
 }
 
+bool cmQtAutoGenerators::GenerateUi(const std::string& uiFileName)
+{
+  if (!cmsys::SystemTools::FileExists(this->Builddir.c_str(), false))
+    {
+    cmsys::SystemTools::MakeDirectory(this->Builddir.c_str());
+    }
+
+  std::string ui_output_file = "ui_" + uiFileName + ".h";
+  std::string ui_input_file = this->Srcdir + uiFileName + ".ui";
+
+  int sourceNewerThanUi = 0;
+  bool success = cmsys::SystemTools::FileTimeCompare(ui_input_file.c_str(),
+                                    (this->Builddir + ui_output_file).c_str(),
+                                                     &sourceNewerThanUi);
+  if (this->GenerateAll || !success || sourceNewerThanUi >= 0)
+    {
+    std::string msg = "Generating ";
+    msg += ui_output_file;
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
+                                          |cmsysTerminal_Color_ForegroundBold,
+                                      msg.c_str(), true, this->ColorOutput);
+
+    std::vector<cmStdString> command;
+    command.push_back(this->UicExecutable);
+
+    std::string options;
+    std::vector<std::string> opts = this->UicTargetOptions;
+    std::map<std::string, std::string>::const_iterator optionIt
+            = this->UicOptions.find(ui_input_file);
+    if (optionIt != this->UicOptions.end())
+      {
+      std::vector<std::string> fileOpts;
+      cmSystemTools::ExpandListArgument(optionIt->second, fileOpts);
+      this->MergeUicOptions(opts, fileOpts, this->QtMajorVersion == "5");
+      }
+    for(std::vector<std::string>::const_iterator optIt = opts.begin();
+        optIt != opts.end();
+        ++optIt)
+      {
+      command.push_back(*optIt);
+      }
+
+    command.push_back("-o");
+    command.push_back(this->Builddir + ui_output_file);
+    command.push_back(ui_input_file);
+
+    if (this->Verbose)
+      {
+      for(std::vector<cmStdString>::const_iterator cmdIt = command.begin();
+          cmdIt != command.end();
+          ++cmdIt)
+        {
+        std::cout << *cmdIt << " ";
+        }
+      std::cout << std::endl;
+      }
+    std::string output;
+    int retVal = 0;
+    bool result = cmSystemTools::RunSingleCommand(command, &output, &retVal);
+    if (!result || retVal)
+      {
+      std::cerr << "AUTOUIC: error: process for " << ui_output_file <<
+                " failed:\n" << output << std::endl;
+      this->RunUicFailed = true;
+      cmSystemTools::RemoveFile(ui_output_file.c_str());
+      return false;
+      }
+    return true;
+    }
+  return false;
+}
+
+bool cmQtAutoGenerators::GenerateQrc()
+{
+  std::vector<std::string> sourceFiles;
+  cmSystemTools::ExpandListArgument(this->RccSources, sourceFiles);
+
+  for(std::vector<std::string>::const_iterator si = sourceFiles.begin();
+      si != sourceFiles.end(); ++si)
+    {
+    std::string ext = cmsys::SystemTools::GetFilenameLastExtension(*si);
+
+    if (ext != ".qrc")
+      {
+      continue;
+      }
+    std::vector<cmStdString> command;
+    command.push_back(this->RccExecutable);
+
+    std::string basename = cmsys::SystemTools::
+                                  GetFilenameWithoutLastExtension(*si);
+
+    std::string rcc_output_file = this->Builddir + "qrc_" + basename + ".cpp";
+
+    int sourceNewerThanQrc = 0;
+    bool success = cmsys::SystemTools::FileTimeCompare(si->c_str(),
+                                                      rcc_output_file.c_str(),
+                                                      &sourceNewerThanQrc);
+    if (this->GenerateAll || !success || sourceNewerThanQrc >= 0)
+      {
+      std::string options;
+      std::map<std::string, std::string>::const_iterator optionIt
+              = this->RccOptions.find(*si);
+      if (optionIt != this->RccOptions.end())
+        {
+        std::vector<std::string> opts;
+        cmSystemTools::ExpandListArgument(optionIt->second, opts);
+        for(std::vector<std::string>::const_iterator optIt = opts.begin();
+            optIt != opts.end();
+            ++optIt)
+          {
+          command.push_back(*optIt);
+          }
+        }
+
+      command.push_back("-o");
+      command.push_back(rcc_output_file);
+      command.push_back(*si);
+
+      if (this->Verbose)
+        {
+        for(std::vector<cmStdString>::const_iterator cmdIt = command.begin();
+            cmdIt != command.end();
+            ++cmdIt)
+          {
+          std::cout << *cmdIt << " ";
+          }
+        std::cout << std::endl;
+        }
+      std::string output;
+      int retVal = 0;
+      bool result = cmSystemTools::RunSingleCommand(command, &output, &retVal);
+      if (!result || retVal)
+        {
+        std::cerr << "AUTORCC: error: process for " << rcc_output_file <<
+                  " failed:\n" << output << std::endl;
+        this->RunRccFailed = true;
+        cmSystemTools::RemoveFile(rcc_output_file.c_str());
+        return false;
+        }
+      }
+    }
+  return true;
+}
 
-std::string cmQtAutomoc::Join(const std::vector<std::string>& lst,
+std::string cmQtAutoGenerators::Join(const std::vector<std::string>& lst,
                               char separator)
 {
     if (lst.empty())
@@ -1291,13 +1980,15 @@ std::string cmQtAutomoc::Join(const std::vector<std::string>& lst,
 }
 
 
-bool cmQtAutomoc::StartsWith(const std::string& str, const std::string& with)
+bool cmQtAutoGenerators::StartsWith(const std::string& str,
+                                    const std::string& with)
 {
   return (str.substr(0, with.length()) == with);
 }
 
 
-bool cmQtAutomoc::EndsWith(const std::string& str, const std::string& with)
+bool cmQtAutoGenerators::EndsWith(const std::string& str,
+                                  const std::string& with)
 {
   if (with.length() > (str.length()))
     {
@@ -1307,7 +1998,7 @@ bool cmQtAutomoc::EndsWith(const std::string& str, const std::string& with)
 }
 
 
-std::string cmQtAutomoc::ReadAll(const std::string& filename)
+std::string cmQtAutoGenerators::ReadAll(const std::string& filename)
 {
   std::ifstream file(filename.c_str());
   cmsys_ios::stringstream stream;
diff --git a/Source/cmQtAutomoc.h b/Source/cmQtAutoGenerators.h
index ebeeb0e..696abc8 100644
--- a/Source/cmQtAutomoc.h
+++ b/Source/cmQtAutoGenerators.h
@@ -11,26 +11,33 @@
   See the License for more information.
 ============================================================================*/
 
-#ifndef cmQtAutomoc_h
-#define cmQtAutomoc_h
+#ifndef cmQtAutoGenerators_h
+#define cmQtAutoGenerators_h
 
 class cmGlobalGenerator;
 class cmMakefile;
 
-class cmQtAutomoc
+class cmQtAutoGenerators
 {
 public:
-  cmQtAutomoc();
+  cmQtAutoGenerators();
   bool Run(const char* targetDirectory, const char *config);
 
   bool InitializeMocSourceFile(cmTarget* target);
-  void SetupAutomocTarget(cmTarget* target);
+  void SetupAutoGenerateTarget(cmTarget* target);
 
 private:
+  void SetupAutoMocTarget(cmTarget* target,
+                          const std::string &autogenTargetName,
+                          std::map<std::string, std::string> &configIncludes,
+                          std::map<std::string, std::string> &configDefines);
+  void SetupAutoUicTarget(cmTarget* target);
+  void SetupAutoRccTarget(cmTarget* target);
+
   cmGlobalGenerator* CreateGlobalGenerator(cmake* cm,
                                            const char* targetDirectory);
 
-  bool ReadAutomocInfoFile(cmMakefile* makefile,
+  bool ReadAutogenInfoFile(cmMakefile* makefile,
                            const char* targetDirectory,
                            const char *config);
   bool ReadOldMocDefinitionsFile(cmMakefile* makefile,
@@ -39,22 +46,34 @@ private:
 
   std::string MakeCompileSettingsString(cmMakefile* makefile);
 
-  bool RunAutomoc(cmMakefile* makefile);
+  bool RunAutogen(cmMakefile* makefile);
   bool GenerateMoc(const std::string& sourceFile,
                    const std::string& mocFileName);
+  bool GenerateUi(const std::string& uiFileName);
+  bool GenerateQrc();
   void ParseCppFile(const std::string& absFilename,
                     const std::vector<std::string>& headerExtensions,
-                    std::map<std::string, std::string>& includedMocs);
+                    std::map<std::string, std::string>& includedMocs,
+                          std::vector<std::string>& includedUis);
   void StrictParseCppFile(const std::string& absFilename,
                           const std::vector<std::string>& headerExtensions,
-                          std::map<std::string, std::string>& includedMocs);
+                          std::map<std::string, std::string>& includedMocs,
+                          std::vector<std::string>& includedUis);
   void SearchHeadersForCppFile(const std::string& absFilename,
                               const std::vector<std::string>& headerExtensions,
                               std::set<std::string>& absHeaders);
 
   void ParseHeaders(const std::set<std::string>& absHeaders,
                     const std::map<std::string, std::string>& includedMocs,
-                    std::map<std::string, std::string>& notIncludedMocs);
+                    std::map<std::string, std::string>& notIncludedMocs,
+                          std::vector<std::string>& includedUis);
+
+  void ParseForUic(const std::string& fileName,
+                   const std::string& contentsString,
+                   std::vector<std::string>& includedUis);
+
+  void ParseForUic(const std::string& fileName,
+                   std::vector<std::string>& includedUis);
 
   void Init();
 
@@ -63,13 +82,24 @@ private:
   bool StartsWith(const std::string& str, const std::string& with);
   std::string ReadAll(const std::string& filename);
 
+  void MergeUicOptions(std::vector<std::string> &opts,
+                       const std::vector<std::string> &fileOpts, bool isQt5);
+
+  void MergeRccOptions(std::vector<std::string> &opts,
+                       const std::vector<std::string> &fileOpts, bool isQt5);
+
   std::string QtMajorVersion;
   std::string Sources;
+  std::string RccSources;
+  std::string SkipMoc;
+  std::string SkipUic;
   std::string Headers;
   bool IncludeProjectDirsBefore;
   std::string Srcdir;
   std::string Builddir;
   std::string MocExecutable;
+  std::string UicExecutable;
+  std::string RccExecutable;
   std::string MocCompileDefinitionsStr;
   std::string MocIncludesStr;
   std::string MocOptionsStr;
@@ -84,10 +114,15 @@ private:
   std::list<std::string> MocIncludes;
   std::list<std::string> MocDefinitions;
   std::vector<std::string> MocOptions;
+  std::vector<std::string> UicTargetOptions;
+  std::map<std::string, std::string> UicOptions;
+  std::map<std::string, std::string> RccOptions;
 
   bool Verbose;
   bool ColorOutput;
   bool RunMocFailed;
+  bool RunUicFailed;
+  bool RunRccFailed;
   bool GenerateAll;
   bool RelaxedMode;
 
diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx
index d747309..ec98c2c 100644
--- a/Source/cmSourceFile.cxx
+++ b/Source/cmSourceFile.cxx
@@ -287,6 +287,17 @@ void cmSourceFile::SetProperty(const char* prop, const char* value)
     }
 
   this->Properties.SetProperty(prop, value, cmProperty::SOURCE_FILE);
+
+  std::string ext =
+          cmSystemTools::GetFilenameLastExtension(this->Location.GetName());
+  if (ext == ".ui")
+    {
+    cmMakefile* mf = this->Location.GetMakefile();
+    if (strcmp(prop, "AUTOUIC_OPTIONS") == 0)
+      {
+      mf->AddQtUiFileWithOptions(this);
+      }
+    }
 }
 
 //----------------------------------------------------------------------------
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index ea0b504..59c407b 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -274,7 +274,11 @@ void cmTarget::SetMakefile(cmMakefile* mf)
   this->SetPropertyDefault("GNUtoMS", 0);
   this->SetPropertyDefault("OSX_ARCHITECTURES", 0);
   this->SetPropertyDefault("AUTOMOC", 0);
+  this->SetPropertyDefault("AUTOUIC", 0);
+  this->SetPropertyDefault("AUTORCC", 0);
   this->SetPropertyDefault("AUTOMOC_MOC_OPTIONS", 0);
+  this->SetPropertyDefault("AUTOUIC_OPTIONS", 0);
+  this->SetPropertyDefault("AUTORCC_OPTIONS", 0);
   this->SetPropertyDefault("LINK_DEPENDS_NO_SHARED", 0);
   this->SetPropertyDefault("LINK_INTERFACE_LIBRARIES", 0);
   this->SetPropertyDefault("WIN32_EXECUTABLE", 0);
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 9814aea..26251b3 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -13,7 +13,7 @@
 #include "cmMakefile.h"
 #include "cmLocalGenerator.h"
 #include "cmGlobalGenerator.h"
-#include "cmQtAutomoc.h"
+#include "cmQtAutoGenerators.h"
 #include "cmVersion.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
@@ -632,12 +632,12 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
       {
       return cmcmd::ExecuteEchoColor(args);
       }
-    else if (args[1] == "cmake_automoc")
+    else if (args[1] == "cmake_autogen")
       {
-        cmQtAutomoc automoc;
+        cmQtAutoGenerators autogen;
         const char *config = args[3].empty() ? 0 : args[3].c_str();
-        bool automocSuccess = automoc.Run(args[2].c_str(), config);
-        return automocSuccess ? 0 : 1;
+        bool autogenSuccess = autogen.Run(args[2].c_str(), config);
+        return autogenSuccess ? 0 : 1;
       }
 #endif
 
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 5ffd9d7..4b08c88 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -1029,34 +1029,43 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     )
   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt")
 
+  # On Windows there is no RPATH, so while Qt might be available for building,
+  # the required dlls may not be in the PATH, so we can't run the executables
+  # on that platform.
+  if(WIN32)
+    set(run_autogen_test ${CMAKE_CTEST_COMMAND} -V)
+  else()
+    set(run_autogen_test QtAutogen)
+  endif()
+
   find_package(Qt5Widgets QUIET NO_MODULE)
   if(Qt5Widgets_FOUND)
-    add_test(Qt5Automoc ${CMAKE_CTEST_COMMAND}
+    add_test(Qt5Autogen ${CMAKE_CTEST_COMMAND}
       --build-and-test
-      "${CMake_SOURCE_DIR}/Tests/QtAutomoc"
-      "${CMake_BINARY_DIR}/Tests/Qt5Automoc"
+      "${CMake_SOURCE_DIR}/Tests/QtAutogen"
+      "${CMake_BINARY_DIR}/Tests/Qt5Autogen"
       ${build_generator_args}
-      --build-project QtAutomoc
-      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt5Automoc"
+      --build-project QtAutogen
+      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt5Autogen"
       --force-new-ctest-process
       --build-options -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DQT_TEST_VERSION=5
-      --test-command ${CMAKE_CTEST_COMMAND} -V
+      --test-command ${run_autogen_test}
       )
-    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt5Automoc")
+    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt5Autogen")
   endif()
   if(QT4_WORKS AND QT_QTGUI_FOUND)
-    add_test(Qt4Automoc ${CMAKE_CTEST_COMMAND}
+    add_test(Qt4Autogen ${CMAKE_CTEST_COMMAND}
       --build-and-test
-      "${CMake_SOURCE_DIR}/Tests/QtAutomoc"
-      "${CMake_BINARY_DIR}/Tests/Qt4Automoc"
+      "${CMake_SOURCE_DIR}/Tests/QtAutogen"
+      "${CMake_BINARY_DIR}/Tests/Qt4Autogen"
       ${build_generator_args}
-      --build-project QtAutomoc
-      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Automoc"
+      --build-project QtAutogen
+      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Autogen"
       --force-new-ctest-process
       --build-options -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DQT_TEST_VERSION=4
-      --test-command ${CMAKE_CTEST_COMMAND} -V
+      --test-command ${run_autogen_test}
       )
-    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Automoc")
+    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Autogen")
 
     add_test(Qt4Targets ${CMAKE_CTEST_COMMAND}
       --build-and-test
diff --git a/Tests/QtAutomoc/Adir/CMakeLists.txt b/Tests/QtAutogen/Adir/CMakeLists.txt
index a1c36ff..a1c36ff 100644
--- a/Tests/QtAutomoc/Adir/CMakeLists.txt
+++ b/Tests/QtAutogen/Adir/CMakeLists.txt
diff --git a/Tests/QtAutomoc/Adir/libA.cpp b/Tests/QtAutogen/Adir/libA.cpp
index 3968c44..3968c44 100644
--- a/Tests/QtAutomoc/Adir/libA.cpp
+++ b/Tests/QtAutogen/Adir/libA.cpp
diff --git a/Tests/QtAutomoc/Adir/libA.h b/Tests/QtAutogen/Adir/libA.h
index 03ad1e0..03ad1e0 100644
--- a/Tests/QtAutomoc/Adir/libA.h
+++ b/Tests/QtAutogen/Adir/libA.h
diff --git a/Tests/QtAutomoc/Bdir/CMakeLists.txt b/Tests/QtAutogen/Bdir/CMakeLists.txt
index d9d4aa7..d9d4aa7 100644
--- a/Tests/QtAutomoc/Bdir/CMakeLists.txt
+++ b/Tests/QtAutogen/Bdir/CMakeLists.txt
diff --git a/Tests/QtAutomoc/Bdir/libB.cpp b/Tests/QtAutogen/Bdir/libB.cpp
index 72f2cfa..72f2cfa 100644
--- a/Tests/QtAutomoc/Bdir/libB.cpp
+++ b/Tests/QtAutogen/Bdir/libB.cpp
diff --git a/Tests/QtAutomoc/Bdir/libB.h b/Tests/QtAutogen/Bdir/libB.h
index 510c17f..510c17f 100644
--- a/Tests/QtAutomoc/Bdir/libB.h
+++ b/Tests/QtAutogen/Bdir/libB.h
diff --git a/Tests/QtAutomoc/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt
index 8ad693a..7991c4e 100644
--- a/Tests/QtAutomoc/CMakeLists.txt
+++ b/Tests/QtAutogen/CMakeLists.txt
@@ -1,6 +1,6 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 2.8.11)
 
-project(QtAutomoc)
+project(QtAutogen)
 
 if (QT_TEST_VERSION STREQUAL 4)
   find_package(Qt4 REQUIRED)
@@ -35,15 +35,20 @@ add_definitions(-DFOO -DSomeDefine="Barx")
 # enable relaxed mode so automoc can handle all the special cases:
 set(CMAKE_AUTOMOC_RELAXED_MODE TRUE)
 
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
 # create an executable and two library targets, each requiring automoc:
 add_library(codeeditorLib STATIC codeeditor.cpp)
 
 add_library(privateSlot OBJECT private_slot.cpp)
 
-add_executable(foo main.cpp calwidget.cpp foo.cpp blub.cpp bar.cpp abc.cpp
-               xyz.cpp yaf.cpp gadget.cpp $<TARGET_OBJECTS:privateSlot>)
+add_executable(QtAutogen main.cpp calwidget.cpp foo.cpp blub.cpp bar.cpp abc.cpp
+               xyz.cpp yaf.cpp gadget.cpp $<TARGET_OBJECTS:privateSlot>
+               test.qrc resourcetester.cpp
+)
 
-set_target_properties(foo codeeditorLib privateSlot PROPERTIES AUTOMOC TRUE)
+set_target_properties(QtAutogen codeeditorLib privateSlot PROPERTIES AUTOMOC TRUE)
 
 include(GenerateExportHeader)
 # The order is relevant here. B depends on A, and B headers depend on A
@@ -59,7 +64,7 @@ set_target_properties(libC PROPERTIES AUTOMOC TRUE)
 generate_export_header(libC)
 target_link_libraries(libC LINK_PUBLIC libB)
 
-target_link_libraries(foo codeeditorLib ${QT_LIBRARIES} libC)
+target_link_libraries(QtAutogen codeeditorLib ${QT_LIBRARIES} libC)
 
 add_library(empty STATIC empty.cpp)
 set_target_properties(empty PROPERTIES AUTOMOC TRUE)
diff --git a/Tests/QtAutomoc/abc.cpp b/Tests/QtAutogen/abc.cpp
index 4bbc769..4bbc769 100644
--- a/Tests/QtAutomoc/abc.cpp
+++ b/Tests/QtAutogen/abc.cpp
diff --git a/Tests/QtAutomoc/abc.h b/Tests/QtAutogen/abc.h
index d1924b0..d1924b0 100644
--- a/Tests/QtAutomoc/abc.h
+++ b/Tests/QtAutogen/abc.h
diff --git a/Tests/QtAutomoc/abc_p.h b/Tests/QtAutogen/abc_p.h
index 952fff3..952fff3 100644
--- a/Tests/QtAutomoc/abc_p.h
+++ b/Tests/QtAutogen/abc_p.h
diff --git a/Tests/QtAutomoc/bar.cpp b/Tests/QtAutogen/bar.cpp
index 8be4815..8be4815 100644
--- a/Tests/QtAutomoc/bar.cpp
+++ b/Tests/QtAutogen/bar.cpp
diff --git a/Tests/QtAutomoc/blub.cpp b/Tests/QtAutogen/blub.cpp
index bd53972..bd53972 100644
--- a/Tests/QtAutomoc/blub.cpp
+++ b/Tests/QtAutogen/blub.cpp
diff --git a/Tests/QtAutomoc/blub.h b/Tests/QtAutogen/blub.h
index 1967bc1..1967bc1 100644
--- a/Tests/QtAutomoc/blub.h
+++ b/Tests/QtAutogen/blub.h
diff --git a/Tests/QtAutomoc/calwidget.cpp b/Tests/QtAutogen/calwidget.cpp
index cbfa5a8..defde20 100644
--- a/Tests/QtAutomoc/calwidget.cpp
+++ b/Tests/QtAutogen/calwidget.cpp
@@ -49,7 +49,10 @@
 
  #include "calwidget.h"
 
+ #include "ui_calwidget.h"
+
  Window::Window()
+  : ui(new Ui::Window)
  {
      createPreviewGroupBox();
      createGeneralOptionsGroupBox();
diff --git a/Tests/QtAutomoc/calwidget.h b/Tests/QtAutogen/calwidget.h
index 8447389..d21a473 100644
--- a/Tests/QtAutomoc/calwidget.h
+++ b/Tests/QtAutogen/calwidget.h
@@ -52,6 +52,11 @@
  class QGroupBox;
  class QLabel;
 
+ namespace Ui
+ {
+ class Window;
+ }
+
  class Window : public QWidget
  {
      Q_OBJECT
@@ -116,6 +121,8 @@
 
      QCheckBox *firstFridayCheckBox;
      QCheckBox *mayFirstCheckBox;
+
+     Ui::Window *ui;
  };
 
  #endif
diff --git a/Tests/QtAutogen/calwidget.ui b/Tests/QtAutogen/calwidget.ui
new file mode 100644
index 0000000..1c245ca
--- /dev/null
+++ b/Tests/QtAutogen/calwidget.ui
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Window</class>
+ <widget class="QWidget" name="Window">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <widget class="QPushButton" name="pushButton">
+   <property name="geometry">
+    <rect>
+     <x>90</x>
+     <y>180</y>
+     <width>94</width>
+     <height>24</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>PushButton</string>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Tests/QtAutomoc/codeeditor.cpp b/Tests/QtAutogen/codeeditor.cpp
index 01da062..01da062 100644
--- a/Tests/QtAutomoc/codeeditor.cpp
+++ b/Tests/QtAutogen/codeeditor.cpp
diff --git a/Tests/QtAutomoc/codeeditor.h b/Tests/QtAutogen/codeeditor.h
index 56e9e792..56e9e792 100644
--- a/Tests/QtAutomoc/codeeditor.h
+++ b/Tests/QtAutogen/codeeditor.h
diff --git a/Tests/QtAutomoc/defines_test/CMakeLists.txt b/Tests/QtAutogen/defines_test/CMakeLists.txt
index ad4e684..ad4e684 100644
--- a/Tests/QtAutomoc/defines_test/CMakeLists.txt
+++ b/Tests/QtAutogen/defines_test/CMakeLists.txt
diff --git a/Tests/QtAutomoc/defines_test/defines_test.cpp b/Tests/QtAutogen/defines_test/defines_test.cpp
index 2836d35..2836d35 100644
--- a/Tests/QtAutomoc/defines_test/defines_test.cpp
+++ b/Tests/QtAutogen/defines_test/defines_test.cpp
diff --git a/Tests/QtAutomoc/empty.cpp b/Tests/QtAutogen/empty.cpp
index ab32cf6..ab32cf6 100644
--- a/Tests/QtAutomoc/empty.cpp
+++ b/Tests/QtAutogen/empty.cpp
diff --git a/Tests/QtAutomoc/empty.h b/Tests/QtAutogen/empty.h
index 4566142..4566142 100644
--- a/Tests/QtAutomoc/empty.h
+++ b/Tests/QtAutogen/empty.h
diff --git a/Tests/QtAutomoc/foo.cpp b/Tests/QtAutogen/foo.cpp
index 699ba09..699ba09 100644
--- a/Tests/QtAutomoc/foo.cpp
+++ b/Tests/QtAutogen/foo.cpp
diff --git a/Tests/QtAutomoc/foo.h b/Tests/QtAutogen/foo.h
index 32d4c8d..32d4c8d 100644
--- a/Tests/QtAutomoc/foo.h
+++ b/Tests/QtAutogen/foo.h
diff --git a/Tests/QtAutomoc/gadget.cpp b/Tests/QtAutogen/gadget.cpp
index 23d95fa..23d95fa 100644
--- a/Tests/QtAutomoc/gadget.cpp
+++ b/Tests/QtAutogen/gadget.cpp
diff --git a/Tests/QtAutomoc/gadget.h b/Tests/QtAutogen/gadget.h
index 7c688ee..7c688ee 100644
--- a/Tests/QtAutomoc/gadget.h
+++ b/Tests/QtAutogen/gadget.h
diff --git a/Tests/QtAutomoc/libC.cpp b/Tests/QtAutogen/libC.cpp
index 8d61cb1..8d61cb1 100644
--- a/Tests/QtAutomoc/libC.cpp
+++ b/Tests/QtAutogen/libC.cpp
diff --git a/Tests/QtAutomoc/libC.h b/Tests/QtAutogen/libC.h
index 4fb4a2c..4fb4a2c 100644
--- a/Tests/QtAutomoc/libC.h
+++ b/Tests/QtAutogen/libC.h
diff --git a/Tests/QtAutomoc/main.cpp b/Tests/QtAutogen/main.cpp
index bd80180..c8a036e 100644
--- a/Tests/QtAutomoc/main.cpp
+++ b/Tests/QtAutogen/main.cpp
@@ -38,7 +38,8 @@
  **
  ****************************************************************************/
 
-#include <QApplication>
+#include <QCoreApplication>
+#include <QTimer>
 
 #include "codeeditor.h"
 #include "calwidget.h"
@@ -49,17 +50,11 @@
 #include "xyz.h"
 #include "yaf.h"
 #include "libC.h"
+#include "resourcetester.h"
 
 int main(int argv, char **args)
 {
-  QApplication app(argv, args);
-
-  CodeEditor editor;
-  editor.setWindowTitle(QObject::tr("Code Editor Example"));
-  editor.show();
-
-  Window w;
-  w.show();
+  QCoreApplication app(argv, args);
 
   Foo foo;
   foo.doFoo();
@@ -82,5 +77,9 @@ int main(int argv, char **args)
   LibC lc;
   lc.foo();
 
+  ResourceTester rt;
+
+  QTimer::singleShot(0, &rt, SLOT(doTest()));
+
   return app.exec();
 }
diff --git a/Tests/QtAutomoc/private_slot.cpp b/Tests/QtAutogen/private_slot.cpp
index 1387a70..1387a70 100644
--- a/Tests/QtAutomoc/private_slot.cpp
+++ b/Tests/QtAutogen/private_slot.cpp
diff --git a/Tests/QtAutomoc/private_slot.h b/Tests/QtAutogen/private_slot.h
index 28e5448..28e5448 100644
--- a/Tests/QtAutomoc/private_slot.h
+++ b/Tests/QtAutogen/private_slot.h
diff --git a/Tests/QtAutogen/resourcetester.cpp b/Tests/QtAutogen/resourcetester.cpp
new file mode 100644
index 0000000..43314e1
--- /dev/null
+++ b/Tests/QtAutogen/resourcetester.cpp
@@ -0,0 +1,21 @@
+
+#include "resourcetester.h"
+
+#include <QDebug>
+#include <QApplication>
+#include <QFile>
+#include <QTimer>
+
+ResourceTester::ResourceTester(QObject *parent)
+  : QObject(parent)
+{
+
+}
+
+void ResourceTester::doTest()
+{
+  if (!QFile::exists(":/CMakeLists.txt"))
+      qApp->exit(EXIT_FAILURE);
+
+  QTimer::singleShot(0, qApp, SLOT(quit()));
+}
diff --git a/Tests/QtAutogen/resourcetester.h b/Tests/QtAutogen/resourcetester.h
new file mode 100644
index 0000000..b02cb4e
--- /dev/null
+++ b/Tests/QtAutogen/resourcetester.h
@@ -0,0 +1,17 @@
+
+#ifndef RESOURCE_TESTER_H
+#define RESOURCE_TESTER_H
+
+#include <QObject>
+
+class ResourceTester : public QObject
+{
+  Q_OBJECT
+public:
+  explicit ResourceTester(QObject *parent = 0);
+
+private slots:
+  void doTest();
+};
+
+#endif
diff --git a/Tests/QtAutomoc/sub/bar.h b/Tests/QtAutogen/sub/bar.h
index db56b8e..db56b8e 100644
--- a/Tests/QtAutomoc/sub/bar.h
+++ b/Tests/QtAutogen/sub/bar.h
diff --git a/Tests/QtAutogen/test.qrc b/Tests/QtAutogen/test.qrc
new file mode 100644
index 0000000..c3d4e3c
--- /dev/null
+++ b/Tests/QtAutogen/test.qrc
@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file>CMakeLists.txt</file>
+</qresource>
+</RCC>
diff --git a/Tests/QtAutomoc/xyz.cpp b/Tests/QtAutogen/xyz.cpp
index a3562a3..a3562a3 100644
--- a/Tests/QtAutomoc/xyz.cpp
+++ b/Tests/QtAutogen/xyz.cpp
diff --git a/Tests/QtAutomoc/xyz.h b/Tests/QtAutogen/xyz.h
index 8175d37..8175d37 100644
--- a/Tests/QtAutomoc/xyz.h
+++ b/Tests/QtAutogen/xyz.h
diff --git a/Tests/QtAutomoc/yaf.cpp b/Tests/QtAutogen/yaf.cpp
index d278ab4..d278ab4 100644
--- a/Tests/QtAutomoc/yaf.cpp
+++ b/Tests/QtAutogen/yaf.cpp
diff --git a/Tests/QtAutomoc/yaf.h b/Tests/QtAutogen/yaf.h
index 8689f83..8689f83 100644
--- a/Tests/QtAutomoc/yaf.h
+++ b/Tests/QtAutogen/yaf.h
diff --git a/Tests/QtAutomoc/yaf_p.h b/Tests/QtAutogen/yaf_p.h
index f0368ad..f0368ad 100644
--- a/Tests/QtAutomoc/yaf_p.h
+++ b/Tests/QtAutogen/yaf_p.h