Repository: conan-io/conan-center-index

Issue:
[package] <Qt/5>: Components support
Now we have a recipe for Qt5 (and Qt6 is on the way!) :partying_face: 
Unfortunately there is no support for components in them.
I'm not familiar enough with components & Qt to drive this so I'm leaving this request here hoping that someone from the community takes it.

Keep up the good work!
[package] <Qt/5>: Components support
Now we have a recipe for Qt5 (and Qt6 is on the way!) :partying_face: 
Unfortunately there is no support for components in them.
I'm not familiar enough with components & Qt to drive this so I'm leaving this request here hoping that someone from the community takes it.

Keep up the good work!


Discussion:
This is a must have for production use. Qt is very popular library and I think this should be given higher priority
Indeed, our team will continue to use the bincrafters recipe until this is resolved.
I can just agree with all the things that were said before me. 
Not having components support makes it impossible to use : 
```
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
```

I get these errors when I try to use them :  
```
  AUTOGEN: No valid Qt version found for target <masked>.
  AUTOMOC, AUTOUIC and AUTORCC disabled.  Consider adding:

    find_package(Qt<QTVERSION> COMPONENTS Widgets)

  to your CMakeLists.txt file.
```
These error messages are originating from CMake itself : 
https://github.com/Kitware/CMake/blob/master/Source/cmQtAutoGenGlobalInitializer.cxx#L138
https://github.com/Kitware/CMake/blob/master/Source/cmQtAutoGenGlobalInitializer.cxx#L140
if you have working projects on qt6, I'll happily take some feedback on https://github.com/conan-io/conan-center-index/pull/4763. I'll start the work on qt5 when qt6 is merged.
It is a shame that this still hasn't been addressed. We are going to continue to use the bintray copy in my company's artifactory instance until this is resolved. Qt6 is not going to happen until 2022 at the earliest -- enterprise software doesn't move as quickly as one might like.
Hi, any update on this?
We are looking into getting qt5 via Conan, but the lack of components support make it not possible 
This is a must have for production use. Qt is very popular library and I think this should be given higher priority
Indeed, our team will continue to use the bincrafters recipe until this is resolved.
I can just agree with all the things that were said before me. 
Not having components support makes it impossible to use : 
```
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
```

I get these errors when I try to use them :  
```
  AUTOGEN: No valid Qt version found for target <masked>.
  AUTOMOC, AUTOUIC and AUTORCC disabled.  Consider adding:

    find_package(Qt<QTVERSION> COMPONENTS Widgets)

  to your CMakeLists.txt file.
```
These error messages are originating from CMake itself : 
https://github.com/Kitware/CMake/blob/master/Source/cmQtAutoGenGlobalInitializer.cxx#L138
https://github.com/Kitware/CMake/blob/master/Source/cmQtAutoGenGlobalInitializer.cxx#L140
if you have working projects on qt6, I'll happily take some feedback on https://github.com/conan-io/conan-center-index/pull/4763. I'll start the work on qt5 when qt6 is merged.
It is a shame that this still hasn't been addressed. We are going to continue to use the bintray copy in my company's artifactory instance until this is resolved. Qt6 is not going to happen until 2022 at the earliest -- enterprise software doesn't move as quickly as one might like.
Hi, any update on this?
We are looking into getting qt5 via Conan, but the lack of components support make it not possible 

Resolving patch:
diff --git a/recipes/qt/5.x.x/conanfile.py b/recipes/qt/5.x.x/conanfile.py
--- a/recipes/qt/5.x.x/conanfile.py
+++ b/recipes/qt/5.x.x/conanfile.py
@@ -81,7 +81,7 @@ class QtConan(ConanFile):
         "cross_compile": "ANY",
         "sysroot": "ANY",
         "config": "ANY",
-        "multiconfiguration": [True, False],
+        "multiconfiguration": [True, False]
     }
     options.update({module: [True, False] for module in _submodules})
 
@@ -117,7 +117,7 @@ class QtConan(ConanFile):
         "cross_compile": None,
         "sysroot": None,
         "config": None,
-        "multiconfiguration": False,
+        "multiconfiguration": False
     }
     default_options.update({module: False for module in _submodules})
 
@@ -148,10 +148,11 @@ def build_requirements(self):
                 msg = ("Python2 must be available in PATH "
                        "in order to build Qt WebEngine")
                 raise ConanInvalidConfiguration(msg)
+
             # In any case, check its actual version for compatibility
             from six import StringIO  # Python 2 and 3 compatible
             mybuf = StringIO()
-            cmd_v = "{} --version".format(python_exe)
+            cmd_v = "\"{}\" --version".format(python_exe)
             self.run(cmd_v, output=mybuf)
             verstr = mybuf.getvalue().strip().split("Python ")[1]
             if verstr.endswith("+"):
@@ -167,7 +168,8 @@ def build_requirements(self):
             else:
                 msg = ("Found Python 2 in path, but with invalid version {}"
                        " (QtWebEngine requires >= {} & < "
-                       "{})".format(verstr, v_min, v_max))
+                       "{})\nIf you have both Python 2 and 3 installed, copy the python 2 executable to"
+                       "python2(.exe)".format(verstr, v_min, v_max))
                 raise ConanInvalidConfiguration(msg)
 
     def config_options(self):
@@ -191,9 +193,6 @@ def configure(self):
         #if self.settings.os != "Linux":
         #         self.options.with_libiconv = False # QTBUG-84708
 
-        if self.options.widgets and not self.options.gui:
-            raise ConanInvalidConfiguration("using option qt:widgets without option qt:gui is not possible. "
-                                            "You can either disable qt:widgets or enable qt:gui")
         if not self.options.gui:
             del self.options.opengl
             del self.options.with_vulkan
@@ -207,38 +206,12 @@ def configure(self):
             del self.options.with_libalsa
             del self.options.with_openal
 
-        if self.options.qtwebengine:
-            if not self.options.shared:
-                raise ConanInvalidConfiguration("Static builds of Qt Webengine are not supported")
-
-            if tools.cross_building(self.settings, skip_x64_x86=True):
-                raise ConanInvalidConfiguration("Cross compiling Qt WebEngine is not supported")
-
-            if self.settings.compiler == "gcc" and tools.Version(self.settings.compiler.version) < "5":
-                raise ConanInvalidConfiguration("Compiling Qt WebEngine with gcc < 5 is not supported")
-
-        if self.settings.os == "Android" and self.options.get_safe("opengl", "no") == "desktop":
-            raise ConanInvalidConfiguration("OpenGL desktop is not supported on Android. Consider using OpenGL es2")
-
-        if self.settings.os != "Windows" and self.options.get_safe("opengl", "no") == "dynamic":
-            raise ConanInvalidConfiguration("Dynamic OpenGL is supported only on Windows.")
-
-        if self.options.get_safe("with_fontconfig", False) and not self.options.get_safe("with_freetype", False):
-            raise ConanInvalidConfiguration("with_fontconfig cannot be enabled if with_freetype is disabled.")
-
-        if self.options.multiconfiguration:
-            del self.settings.build_type
-
-        if not self.options.with_doubleconversion and str(self.settings.compiler.libcxx) != "libc++":
-            raise ConanInvalidConfiguration("Qt without libc++ needs qt:with_doubleconversion. "
-                                            "Either enable qt:with_doubleconversion or switch to libc++")
-
         if tools.os_info.is_linux:
             if self.options.qtwebengine:
                 self.options.with_fontconfig = True
 
-        if "MT" in self.settings.get_safe("compiler.runtime", default="") and self.options.shared:
-            raise ConanInvalidConfiguration("Qt cannot be built as shared library with static runtime")
+        if self.options.multiconfiguration:
+            del self.settings.build_type
 
         config = configparser.ConfigParser()
         config.read(os.path.join(self.recipe_folder, "qtmodules%s.conf" % self.version))
@@ -272,15 +245,56 @@ def _enablemodule(mod):
             if self.options.get_safe(module):
                 _enablemodule(module)
 
+    def validate(self):
+        if self.options.widgets and not self.options.gui:
+            raise ConanInvalidConfiguration("using option qt:widgets without option qt:gui is not possible. "
+                                            "You can either disable qt:widgets or enable qt:gui")
+
+        if self.options.qtwebengine:
+            if not self.options.shared:
+                raise ConanInvalidConfiguration("Static builds of Qt WebEngine are not supported")
+
+            if not (self.options.gui and self.options.qtdeclarative and self.options.qtlocation and self.options.qtwebchannel):
+                raise ConanInvalidConfiguration("option qt:qtwebengine requires also qt:gui, qt:qtdeclarative, qt:qtlocation and qt:qtwebchannel")
+
+            if tools.cross_building(self.settings, skip_x64_x86=True):
+                raise ConanInvalidConfiguration("Cross compiling Qt WebEngine is not supported")
+
+            if self.settings.compiler == "gcc" and tools.Version(self.settings.compiler.version) < "5":
+                raise ConanInvalidConfiguration("Compiling Qt WebEngine with gcc < 5 is not supported")
+
+        if self.settings.os == "Android" and self.options.get_safe("opengl", "no") == "desktop":
+            raise ConanInvalidConfiguration("OpenGL desktop is not supported on Android. Consider using OpenGL es2")
+
+        if self.settings.os != "Windows" and self.options.get_safe("opengl", "no") == "dynamic":
+            raise ConanInvalidConfiguration("Dynamic OpenGL is supported only on Windows.")
+
+        if self.options.get_safe("with_fontconfig", False) and not self.options.get_safe("with_freetype", False):
+            raise ConanInvalidConfiguration("with_fontconfig cannot be enabled if with_freetype is disabled.")
+
+        if not self.options.with_doubleconversion and str(self.settings.compiler.libcxx) != "libc++":
+            raise ConanInvalidConfiguration("Qt without libc++ needs qt:with_doubleconversion. "
+                                            "Either enable qt:with_doubleconversion or switch to libc++")
+
+        if "MT" in self.settings.get_safe("compiler.runtime", default="") and self.options.shared:
+            raise ConanInvalidConfiguration("Qt cannot be built as shared library with static runtime")
+
+        if self.settings.compiler == "apple-clang":
+            if tools.Version(self.settings.compiler.version) < "10.0":
+                raise ConanInvalidConfiguration("Old versions of apple sdk are not supported by Qt (QTBUG-76777)")
+        if self.settings.compiler in ["gcc", "clang"]:
+            if tools.Version(self.settings.compiler.version) < "5.0":
+                raise ConanInvalidConfiguration("qt 5.15.X does not support GCC or clang before 5.0")
+
     def requirements(self):
         self.requires("zlib/1.2.11")
         if self.options.openssl:
             self.requires("openssl/1.1.1k")
         if self.options.with_pcre2:
-            self.requires("pcre2/10.36")
+            self.requires("pcre2/10.37")
 
         if self.options.with_glib:
-            self.requires("glib/2.68.1")
+            self.requires("glib/2.68.3")
         # if self.options.with_libiconv: # QTBUG-84708
         #     self.requires("libiconv/1.16")# QTBUG-84708
         if self.options.with_doubleconversion and not self.options.multiconfiguration:
@@ -290,7 +304,7 @@ def requirements(self):
         if self.options.get_safe("with_fontconfig", False):
             self.requires("fontconfig/2.13.93")
         if self.options.get_safe("with_icu", False):
-            self.requires("icu/68.2")
+            self.requires("icu/69.1")
         if self.options.get_safe("with_harfbuzz", False) and not self.options.multiconfiguration:
             self.requires("harfbuzz/2.8.1")
         if self.options.get_safe("with_libjpeg", False) and not self.options.multiconfiguration:
@@ -304,7 +318,7 @@ def requirements(self):
             self.requires("sqlite3/3.35.5")
             self.options["sqlite3"].enable_column_metadata = True
         if self.options.get_safe("with_mysql", False):
-            self.requires("libmysqlclient/8.0.17")
+            self.requires("libmysqlclient/8.0.25")
         if self.options.with_pq:
             self.requires("libpq/13.2")
         if self.options.with_odbc:
@@ -317,13 +331,13 @@ def requirements(self):
         if self.options.gui and self.settings.os == "Linux":
             self.requires("xorg/system")
             if not tools.cross_building(self, skip_x64_x86=True):
-                self.requires("xkbcommon/1.2.1")
+                self.requires("xkbcommon/1.3.0")
         if self.options.get_safe("opengl", "no") != "no":
             self.requires("opengl/system")
         if self.options.with_zstd:
             self.requires("zstd/1.5.0")
         if self.options.qtwebengine and self.settings.os == "Linux":
-            self.requires("expat/2.3.0")
+            self.requires("expat/2.4.1")
             self.requires("opus/1.3.1")
 
     def source(self):
@@ -730,37 +744,299 @@ def package_id(self):
                 self.info.settings.compiler.runtime = "MT/MTd"
 
     def package_info(self):
-        # FIXME add components
-        self.cpp_info.libs = tools.collect_libs(self)
+        self.cpp_info.names["cmake_find_package"] = "Qt5"
+        self.cpp_info.names["cmake_find_package_multi"] = "Qt5"
 
-        # Add top level include directory, so code compile if someone uses
-        # includes with prefixes (e.g. "#include <QtCore/QString>")
-        self.cpp_info.includedirs = ["include"]
+        libsuffix = ""
+        if self.settings.build_type == "Debug":
+            if self.settings.os == "Windows":
+                libsuffix = "d"
+            elif tools.is_apple_os(self.settings.os):
+                libsuffix = "_debug"
+
+        def _get_corrected_reqs(requires):
+            reqs = []
+            for r in requires:
+                reqs.append(r if "::" in r else "qt%s" % r)
+            return reqs
+
+        def _create_module(module, requires=[]):
+            componentname = "qt%s" % module
+            assert componentname not in self.cpp_info.components, "Module %s already present in self.cpp_info.components" % module
+            self.cpp_info.components[componentname].names["cmake_find_package"] = module
+            self.cpp_info.components[componentname].names["cmake_find_package_multi"] = module
+            self.cpp_info.components[componentname].libs = ["Qt5%s%s" % (module, libsuffix)]
+            self.cpp_info.components[componentname].includedirs = ["include", os.path.join("include", "Qt%s" % module)]
+            self.cpp_info.components[componentname].defines = ["QT_%s_LIB" % module.upper()]
+            if module != "Core" and "Core" not in requires:
+                requires.append("Core")
+            self.cpp_info.components[componentname].requires = _get_corrected_reqs(requires)
+
+        def _create_plugin(pluginname, libname, type, requires):
+            componentname = "qt%s" % pluginname
+            assert componentname not in self.cpp_info.components, "Plugin %s already present in self.cpp_info.components" % pluginname
+            self.cpp_info.components[componentname].names["cmake_find_package"] = pluginname
+            self.cpp_info.components[componentname].names["cmake_find_package_multi"] = pluginname
+            if not self.options.shared:
+                self.cpp_info.components[componentname].libs = [libname + libsuffix]
+            self.cpp_info.components[componentname].libdirs = [os.path.join("bin", "archdatadir", "plugins", type)]
+            self.cpp_info.components[componentname].includedirs = []
+            if "Core" not in requires:
+                requires.append("Core")
+            self.cpp_info.components[componentname].requires = _get_corrected_reqs(requires)
+
+        core_reqs = ["zlib::zlib"]
+        if self.options.with_pcre2:
+            core_reqs.append("pcre2::pcre2")
+        if self.options.with_doubleconversion:
+            core_reqs.append("double-conversion::double-conversion")
+        if self.options.get_safe("with_icu", False):
+            core_reqs.append("icu::icu")
+        if self.options.with_zstd:
+            core_reqs.append("zstd::zstd")
+
+        _create_module("Core", core_reqs)
+        if self.options.gui:
+            gui_reqs = ["DBus"]
+            if self.options.with_freetype:
+                gui_reqs.append("freetype::freetype")
+            if self.options.with_libpng:
+                gui_reqs.append("libpng::libpng")
+            if self.options.get_safe("with_fontconfig", False):
+                gui_reqs.append("fontconfig::fontconfig")
+            if self.settings.os in ["Linux", "FreeBSD"]:
+                gui_reqs.append("xorg::xorg")
+                if not tools.cross_building(self, skip_x64_x86=True):
+                    gui_reqs.append("xkbcommon::xkbcommon")
+            if self.options.get_safe("opengl", "no") != "no":
+                gui_reqs.append("opengl::opengl")
+            if self.options.with_harfbuzz:
+                gui_reqs.append("harfbuzz::harfbuzz")
+            if self.options.with_libjpeg == "libjpeg-turbo":
+                gui_reqs.append("libjpeg-turbo::libjpeg-turbo")
+            if self.options.with_libjpeg == "libjpeg":
+                gui_reqs.append("libjpeg::libjpeg")
+            _create_module("Gui", gui_reqs)
+        if self.options.with_sqlite3:
+            _create_plugin("QSQLiteDriverPlugin", "qsqlite", "sqldrivers", ["sqlite3::sqlite3"])
+        if self.options.with_pq:
+            _create_plugin("QPSQLDriverPlugin", "qsqlpsql", "sqldrivers", ["libpq::libpq"])
+        if self.options.get_safe("with_mysql", False):
+            _create_plugin("QMySQLDriverPlugin", "qsqlmysql", "sqldrivers", ["libmysqlclient::libmysqlclient"])
+        if self.options.with_odbc:
+            if self.settings.os != "Windows":
+                _create_plugin("QODBCDriverPlugin", "qsqlodbc", "sqldrivers", ["odbc::odbc"])
+        networkReqs = []
+        if self.options.openssl:
+            networkReqs.append("openssl::openssl")
+        _create_module("Network", networkReqs)
+        _create_module("Sql")
+        _create_module("Test")
+        if self.options.widgets:
+            _create_module("Widgets", ["Gui"])
+        if self.options.gui and self.options.widgets:
+            _create_module("PrintSupport", ["Gui", "Widgets"])
+        if self.options.get_safe("opengl", "no") != "no" and self.options.gui:
+            _create_module("OpenGL", ["Gui"])
+        if self.options.widgets and self.options.get_safe("opengl", "no") != "no":
+            _create_module("OpenGLExtensions", ["Gui"])
+        _create_module("DBus")
+        _create_module("Concurrent")
+        _create_module("Xml")
+
+        if self.options.qtdeclarative:
+            _create_module("Qml", ["Network"])
+            _create_module("QmlModels", ["Qml"])
+            self.cpp_info.components["qtQmlImportScanner"].names["cmake_find_package"] = "QmlImportScanner" # this is an alias for Qml and there to integrate with existing consumers
+            self.cpp_info.components["qtQmlImportScanner"].names["cmake_find_package_multi"] = "QmlImportScanner"
+            self.cpp_info.components["qtQmlImportScanner"].requires = _get_corrected_reqs(["Qml"])
+            if self.options.gui:
+                _create_module("Quick", ["Gui", "Qml", "QmlModels"])
+                if self.options.widgets:
+                    _create_module("QuickWidgets", ["Gui", "Qml", "Quick", "Widgets"])
+                _create_module("QuickShapes", ["Gui", "Qml", "Quick"])
+            _create_module("QmlWorkerScript", ["Qml"])
+            _create_module("QuickTest", ["Test"])
+
+        if self.options.qttools and self.options.gui and self.options.widgets:
+            _create_module("UiPlugin", ["Gui", "Widgets"])
+            self.cpp_info.components["qtUiPlugin"].libs = [] # this is a collection of abstract classes, so this is header-only
+            self.cpp_info.components["qtUiPlugin"].libdirs = []
+            _create_module("UiTools", ["UiPlugin", "Gui", "Widgets"])
+            _create_module("Designer", ["Gui", "UiPlugin", "Widgets", "Xml"])
+            _create_module("Help", ["Gui", "Sql", "Widgets"])
+
+        if self.options.qtquick3d and self.options.gui:
+            _create_module("Quick3DUtils", ["Gui"])
+            _create_module("Quick3DAssetImport", ["Gui", "Qml", "Quick3DUtils"])
+            _create_module("Quick3DRuntimeRender", ["Gui", "Quick", "Quick3DAssetImport", "Quick3DUtils", "ShaderTools"])
+            _create_module("Quick3D", ["Gui", "Qml", "Quick", "Quick3DRuntimeRender"])
+
+        if self.options.qtquickcontrols2 and self.options.gui:
+            _create_module("QuickControls2", ["Gui", "Quick"])
+            _create_module("QuickTemplates2", ["Gui", "Quick"])
+
+        if self.options.qtsvg and self.options.gui:
+            _create_module("Svg", ["Gui"])
+            if self.options.widgets:
+                _create_module("SvgWidgets", ["Gui", "Svg", "Widgets"])
+
+        if self.options.qtwayland and self.options.gui:
+            _create_module("WaylandClient", ["Gui", "wayland::wayland-client"])
+            _create_module("WaylandCompositor", ["Gui", "wayland::wayland-server"])
+
+        if self.options.qtlocation:
+            _create_module("Positioning")
+            _create_module("Location", ["Gui", "Quick"])
+            _create_plugin("QGeoServiceProviderFactoryMapbox", "qtgeoservices_mapbox", "geoservices", [])
+            _create_plugin("QGeoServiceProviderFactoryMapboxGL", "qtgeoservices_mapboxgl", "geoservices", [])
+            _create_plugin("GeoServiceProviderFactoryEsri", "qtgeoservices_esri", "geoservices", [])
+            _create_plugin("QGeoServiceProviderFactoryItemsOverlay", "qtgeoservices_itemsoverlay", "geoservices", [])
+            _create_plugin("QGeoServiceProviderFactoryNokia", "qtgeoservices_nokia", "geoservices", [])
+            _create_plugin("QGeoServiceProviderFactoryOsm", "qtgeoservices_osm", "geoservices", [])
+            _create_plugin("QGeoPositionInfoSourceFactoryGeoclue", "qtposition_geoclue", "position", [])
+            _create_plugin("QGeoPositionInfoSourceFactoryGeoclue2", "qtposition_geoclue2", "position", [])
+            _create_plugin("QGeoPositionInfoSourceFactoryPoll", "qtposition_positionpoll", "position", [])
+            _create_plugin("QGeoPositionInfoSourceFactorySerialNmea", "qtposition_serialnmea", "position", [])
+
+        if self.options.qtwebchannel:
+            _create_module("WebChannel", ["Qml"])
 
-        # Add all Qt module directories (QtCore, QtGui, QtWidgets and so on), so prefix
-        # can be omited in includes (e.g. "#include <QtCore/QString>" => "#include <QString>")
-        fu = ["include/" + f.name for f in os.scandir("include") if f.is_dir()]
-        self.cpp_info.includedirs.extend(fu)
+        if self.options.qtwebengine:
+            _create_module("WebEngineCore", ["Gui", "Quick", "WebChannel", "Positioning", "expat::expat", "opus::libopus"])
+            _create_module("WebEngine", ["WebEngineCore"])
+            _create_module("WebEngineWidgets", ["WebEngineCore", "Quick", "PrintSupport", "Widgets", "Gui", "Network"])
+
+        if self.options.qtserialport:
+            _create_module("SerialPort")
+
+        if self.options.qtserialbus:
+            _create_module("SerialBus", ["SerialPort"])
+            _create_plugin("PassThruCanBusPlugin", "qtpassthrucanbus", "canbus", [])
+            _create_plugin("PeakCanBusPlugin", "qtpeakcanbus", "canbus", [])
+            _create_plugin("SocketCanBusPlugin", "qtsocketcanbus", "canbus", [])
+            _create_plugin("TinyCanBusPlugin", "qttinycanbus", "canbus", [])
+            _create_plugin("VirtualCanBusPlugin", "qtvirtualcanbus", "canbus", [])
+
+        if self.options.qtsensors:
+            _create_module("Sensors")
+            _create_plugin("genericSensorPlugin", "qtsensors_generic", "sensors", [])
+            _create_plugin("IIOSensorProxySensorPlugin", "qtsensors_iio-sensor-proxy", "sensors", [])
+            if self.settings.os == "Linux":
+                _create_plugin("LinuxSensorPlugin", "qtsensors_linuxsys", "sensors", [])
+            _create_plugin("QtSensorGesturePlugin", "qtsensorgestures_plugin", "sensorgestures", [])
+            _create_plugin("QShakeSensorGesturePlugin", "qtsensorgestures_shakeplugin", "sensorgestures", [])
+
+        if self.options.qtscxml:
+            _create_module("Scxml", ["Qml"])
+
+        if self.options.qtpurchasing:
+            _create_module("Purchasing")
+
+        if self.options.qtcharts:
+            _create_module("Charts", ["Gui", "Widgets"])
+
+        if self.options.qt3d:
+            _create_module("3DCore", ["Gui", "Network"])
+
+            _create_module("3DRender", ["3DCore"])
+            _create_plugin("DefaultGeometryLoaderPlugin", "defaultgeometryloader", "geometryloaders", [])
+            _create_plugin("GLTFGeometryLoaderPlugin", "gltfgeometryloader", "geometryloaders", [])
+            _create_plugin("GLTFSceneExportPlugin", "gltfsceneexport", "sceneparsers", [])
+            _create_plugin("GLTFSceneImportPlugin", "gltfsceneimport", "sceneparsers", [])
+            _create_plugin("OpenGLRendererPlugin", "openglrenderer", "renderers", [])
+            _create_plugin("Scene2DPlugin", "scene2d", "renderplugins", [])
+
+            _create_module("3DAnimation", ["3DRender", "3DCore", "Gui"])
+            _create_module("3DInput", ["3DCore", "GamePad", "Gui"])
+            _create_module("3DLogic", ["3DCore", "Gui"])
+            _create_module("3DExtras", ["3DRender", "3DInput", "3DLogic", "3DCore", "Gui"])
+            _create_module("3DQuick", ["3DCore", "Quick", "Gui", "Qml"])
+            _create_module("3DQuickAnimation", ["3DAnimation", "3DRender", "3DQuick", "3DCore", "Gui", "Qml"])
+            _create_module("3DQuickExtras", ["3DExtras", "3DInput", "3DQuick", "3DRender", "3DLogic", "3DCore", "Gui", "Qml"])
+            _create_module("3DQuickInput", ["3DInput", "3DQuick", "3DCore", "Gui", "Qml"])
+            _create_module("3DQuickRender", ["3DRender", "3DQuick", "3DCore", "Gui", "Qml"])
+            _create_module("3DQuickScene2D", ["3DRender", "3DQuick", "3DCore", "Gui", "Qml"])
+
+        if self.options.qtgamepad:
+            _create_module("Gamepad", ["Gui"])
+            if self.settings.os == "Linux":
+                _create_plugin("QEvdevGamepadBackendPlugin", "evdevgamepad", "gamepads", [])
+            if self.settings.os == "Macos":
+                _create_plugin("QDarwinGamepadBackendPlugin", "darwingamepad", "gamepads", [])
+            if self.settings.os =="Windows":
+                _create_plugin("QXInputGamepadBackendPlugin", "xinputgamepad", "gamepads", [])
+
+        if self.options.qtmultimedia:
+            _create_module("Multimedia", ["Network", "Gui"])
+            _create_module("MultimediaWidgets", ["Multimedia", "Widgets", "Gui"])
+            _create_module("MultimediaQuick", ["Multimedia", "Quick"])
+            _create_plugin("QM3uPlaylistPlugin", "qtmultimedia_m3u", "playlistformats", [])
+            if self.settings.os == "Linux":
+                _create_module("MultimediaGstTools", ["Multimedia", "MultimediaWidgets", "Gui"])
+                _create_plugin("CameraBinServicePlugin", "gstcamerabin", "mediaservice", [])
+                _create_plugin("QAlsaPlugin", "qtaudio_alsa", "audio", [])
+                _create_plugin("QGstreamerAudioDecoderServicePlugin", "gstaudiodecoder", "mediaservice", [])
+                _create_plugin("QGstreamerCaptureServicePlugin", "gstmediacapture", "mediaservice", [])
+                _create_plugin("QGstreamerPlayerServicePlugin", "gstmediaplayer", "mediaservice", [])
+            if self.settings.os == "Windows":
+                _create_plugin("AudioCaptureServicePlugin", "qtmedia_audioengine", "mediaservice", [])
+                _create_plugin("DSServicePlugin", "dsengine", "mediaservice", [])
+                _create_plugin("QWindowsAudioPlugin", "qtaudio_windows", "audio", [])
+            if self.settings.os == "Macos":
+                _create_plugin("AudioCaptureServicePlugin", "qtmedia_audioengine", "mediaservice", [])
+                _create_plugin("AVFMediaPlayerServicePlugin", "qavfmediaplayer", "mediaservice", [])
+                _create_plugin("AVFServicePlugin", "qavfcamera", "mediaservice", [])
+                _create_plugin("CoreAudioPlugin", "qtaudio_coreaudio", "audio", [])
+
+        if self.options.qtwebsockets:
+            _create_module("WebSockets", ["Network"])
+
+        if self.options.qtconnectivity:
+            _create_module("Bluetooth", ["Network"])
+            _create_module("Nfc", [])
+
+        if self.options.qtdatavis3d:
+            _create_module("DataVisualization", ["Gui"])
+
+        if self.options.qtnetworkauth:
+            _create_module("NetworkAuth", ["Network"])
 
         if not self.options.shared:
             if self.settings.os == "Windows":
-                self.cpp_info.system_libs.append("Version")   # "Qt5Cored.lib" require "GetFileVersionInfoW" and "VerQueryValueW" which are in "Version.lib" library
-                self.cpp_info.system_libs.append("Winmm")     # "Qt5Cored.lib" require "__imp_timeSetEvent" which is in "Winmm.lib" library
-                self.cpp_info.system_libs.append("Netapi32")  # "Qt5Cored.lib" require "NetApiBufferFree" which is in "Netapi32.lib" library
-                self.cpp_info.system_libs.append("UserEnv")   # "Qt5Cored.lib" require "__imp_GetUserProfileDirectoryW " which is in "UserEnv.Lib" library
+                self.cpp_info.components["qtCore"].system_libs.append("version")  # qtcore requires "GetFileVersionInfoW" and "VerQueryValueW" which are in "Version.lib" library
+                self.cpp_info.components["qtCore"].system_libs.append("winmm")    # qtcore requires "__imp_timeSetEvent" which is in "Winmm.lib" library
+                self.cpp_info.components["qtCore"].system_libs.append("netapi32") # qtcore requires "NetApiBufferFree" which is in "Netapi32.lib" library
+                self.cpp_info.components["qtCore"].system_libs.append("userenv")  # qtcore requires "__imp_GetUserProfileDirectoryW " which is in "UserEnv.Lib" library
+                self.cpp_info.components["qtCore"].system_libs.append("ws2_32")  # qtcore requires "WSAStartup " which is in "Ws2_32.Lib" library
+                self.cpp_info.components["qtNetwork"].system_libs.append("DnsApi")  # qtnetwork from qtbase requires "DnsFree" which is in "Dnsapi.lib" library
 
             if self.settings.os == "Macos":
-                self.cpp_info.frameworks.extend(["IOKit"])    # "libQt5Core.a" require "_IORegistryEntryCreateCFProperty", "_IOServiceGetMatchingService" and much more which are in "IOKit" framework
-                self.cpp_info.frameworks.extend(["Cocoa"])    # "libQt5Core.a" require "_OBJC_CLASS_$_NSApplication" and more, which are in "Cocoa" framework
-                self.cpp_info.frameworks.extend(["Security"]) # "libQt5Core.a" require "_SecRequirementCreateWithString" and more, which are in "Security" framework
+                self.cpp_info.components["qtCore"].frameworks.append("IOKit")     # qtcore requires "_IORegistryEntryCreateCFProperty", "_IOServiceGetMatchingService" and much more which are in "IOKit" framework
+                self.cpp_info.components["qtCore"].frameworks.append("Cocoa")     # qtcore requires "_OBJC_CLASS_$_NSApplication" and more, which are in "Cocoa" framework
+                self.cpp_info.components["qtCore"].frameworks.append("Security")  # qtcore requires "_SecRequirementCreateWithString" and more, which are in "Security" framework
+
+        self.cpp_info.components["qtCore"].builddirs.append(os.path.join("bin","archdatadir","bin"))
+        self.cpp_info.components["qtCore"].build_modules["cmake_find_package"].append(self._cmake_executables_file)
+        self.cpp_info.components["qtCore"].build_modules["cmake_find_package_multi"].append(self._cmake_executables_file)
 
         for m in os.listdir(os.path.join("lib", "cmake")):
             module = os.path.join("lib", "cmake", m, "%sMacros.cmake" % m)
-            self.cpp_info.build_modules["cmake_find_package"].append(module)
-            self.cpp_info.build_modules["cmake_find_package_multi"].append(module)
-            self.cpp_info.builddirs.append(os.path.join("lib", "cmake", m))
-        self.cpp_info.build_modules["cmake_find_package"].append(self._cmake_executables_file)
-        self.cpp_info.build_modules["cmake_find_package_multi"].append(self._cmake_executables_file)
+            component_name = m.replace("Qt5", "qt")
+            self.cpp_info.components[component_name].build_modules["cmake_find_package"].append(module)
+            self.cpp_info.components[component_name].build_modules["cmake_find_package_multi"].append(module)
+            self.cpp_info.components[component_name].builddirs.append(os.path.join("lib", "cmake", m))
+
+        objects_dirs = glob.glob(os.path.join(self.package_folder, "lib", "objects-*/"))
+        for object_dir in objects_dirs:
+            for m in os.listdir(object_dir):
+                submodules_dir = os.path.join(object_dir, m)
+                component = "qt" + m[:m.find("_")]
+                for sub_dir in os.listdir(submodules_dir):
+                    submodule_dir = os.path.join(submodules_dir, sub_dir)
+                    obj_files = [os.path.join(submodule_dir, file) for file in os.listdir(submodule_dir)]
+                    self.cpp_info.components[component].exelinkflags.extend(obj_files)
+                    self.cpp_info.components[component].sharedlinkflags.extend(obj_files)
 
 
     @staticmethod


Test patch:
diff --git a/recipes/qt/5.x.x/test_package/CMakeLists.txt b/recipes/qt/5.x.x/test_package/CMakeLists.txt
--- a/recipes/qt/5.x.x/test_package/CMakeLists.txt
+++ b/recipes/qt/5.x.x/test_package/CMakeLists.txt
@@ -9,7 +9,7 @@ conan_set_vs_runtime()
 conan_set_libcxx()
 conan_output_dirs_setup()
 
-find_package(qt REQUIRED CONFIG)
+find_package(Qt5 COMPONENTS Core REQUIRED CONFIG)
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
@@ -20,4 +20,4 @@ add_executable(${PROJECT_NAME} ${SOURCES})
 # Must compile with "-fPIC" since Qt was built with -reduce-relocations.
 target_compile_options(${PROJECT_NAME} PRIVATE -fPIC)
 
-target_link_libraries(${PROJECT_NAME} qt::qt)
+target_link_libraries(${PROJECT_NAME} Qt5::Core)