creator - qt full

¿Cómo incluir una cierta instalación de Qt usando CMake?

Question

Tenemos muchas copias de Qt en cada PC de desarrollo: cada proyecto tiene su propia copia de Qt en el directorio de terceros. Eso se hace debido a que cada proyecto se desarrolla y prueba con su propio Qt; un caso frecuente es que necesitamos una compilación personalizada de Qt para algún proyecto. Por lo tanto, debido a lo mencionado anteriormente, tenemos un repositorio de SVN separado para mantener varias compilaciones de Qt y una externa en cada proyecto de Qt, que se refiere a una de esas compilaciones.

El problema es que, al usar CMake, solo podemos seleccionar una versión de Qt y el buscador de Qt4 decide qué Qt usar por sí mismo. Y esa no es la correcta. Necesitamos redireccionar el buscador para configurar todo para una copia particular de Qt en el directorio de terceros del proyecto.

Intenté especificar la opción PATHS para FIND_PACKAGE esa manera: FIND_PACKAGE( Qt4 REQUIRED PATHS "thirdparty/Qt" ) pero eso no ayudó. Intenté establecer la variable QT_QMAKE_EXECUTABLE , pero eso no funcionó. Intenté agregar la ruta requerida de QMake (la utiliza FindQt4.cmake para determinar todos los directorios) a la variable PATH anterior a la instalada, pero eso tampoco ayudó.

¿Hay alguna manera de usar todo lo que proporciona el FIND_PACKAGE pero para una cierta copia de Qt? Realmente no quiero implementar todos los wrappers de Qt, establecer manualmente todas las definiciones, includes, dirs, etc.

Aquí está mi proyecto CMake. Tal vez eso ayude:

CMAKE_MINIMUM_REQUIRED( VERSION 2.8 )

#############################################################################

MACRO( ADD_FILES_TO_FILTER rootFilterName rootFilterPath files )
    FOREACH( curFile ${files} )
        FILE( RELATIVE_PATH curFilter "${CMAKE_CURRENT_SOURCE_DIR}/${rootFilterPath}" "${CMAKE_CURRENT_SOURCE_DIR}/${curFile}" )
        FILE( RELATIVE_PATH test "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${curFile}" )
        GET_FILENAME_COMPONENT( curFilter ${curFilter} PATH )
        SET( curFilter "${rootFilterName}/${curFilter}" )
        STRING( REPLACE "/" "////" curFilter ${curFilter} )
        SOURCE_GROUP( ${curFilter} FILES ${curFile} )
    ENDFOREACH( curFile )
ENDMACRO( ADD_FILES_TO_FILTER rootFilterName rootFilterPath files )

MACRO( TO_RELATIVE_PATHS filePaths )
    SET( resPaths "" )
    FOREACH( curPath ${${filePaths}} )
        FILE( RELATIVE_PATH relPath ${CMAKE_CURRENT_SOURCE_DIR} ${curPath} )
        SET( resPaths ${resPaths} ${relPath} )
    ENDFOREACH( curPath )
    SET( ${filePaths} ${resPaths} )
ENDMACRO( TO_RELATIVE_PATHS filePaths )

######################################################################

# Define project settings
PROJECT( RealTimeCapture )
FIND_PACKAGE( Qt4 REQUIRED PATHS "thirdparty/Qt" )
SET( BOOST_ROOT "thirdparty/boost" )
FIND_PACKAGE( Boost REQUIRED )

# Collect all required files for build
FILE( GLOB_RECURSE headers RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/RTCF/include/*.h" )
FILE( GLOB_RECURSE sources RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/RTCF/src/*.cpp" )
FILE( GLOB_RECURSE resources RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.qrc" )
FILE( GLOB_RECURSE forms RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "src/*.ui" )

# Preprocess all Qt files
QT4_WRAP_CPP( header_mocs ${headers} )
QT4_WRAP_UI( form_headers ${forms} )
QT4_ADD_RESOURCES( resources_rcc ${resources} )

# Convert all generated files paths to relative ones
TO_RELATIVE_PATHS( header_mocs )
TO_RELATIVE_PATHS( form_headers )
TO_RELATIVE_PATHS( resources_rcc )

# Create executable
ADD_EXECUTABLE( RealTimeCapture ${headers} ${sources} ${header_mocs} ${form_headers} ${resources_rcc} )
SET_TARGET_PROPERTIES( RealTimeCapture PROPERTIES COMPILE_FLAGS "/Zc:wchar_t-" )

# Set filters for project according to its namespaces
FILE( RELATIVE_PATH buildDir ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} )
ADD_FILES_TO_FILTER( "Headers" "src/RTCF/include" "${headers}" )
ADD_FILES_TO_FILTER( "Sources" "src/RTCF/src" "${sources}" )
ADD_FILES_TO_FILTER( "Generated" "${buildDir}/src/RTCF/include" "${header_mocs}" )
ADD_FILES_TO_FILTER( "Forms" "${buildDir}/src/RTCF/include" "${form_headers}" )
ADD_FILES_TO_FILTER( "Resources" "${buildDir}" "${resources_rcc}" )

# Set additional include directories
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR} )
INCLUDE_DIRECTORIES( "src" )
INCLUDE_DIRECTORIES( "src/RTCF/include" )
INCLUDE_DIRECTORIES( "thirdparty" )

# Configure Qt
SET( QT_USE_QTNETWORK TRUE )
SET( QT_USE_QTSQL TRUE )
SET( QT_USE_QTSCRIPT TRUE )
SET( QT_USE_QTXML TRUE )
SET( QT_USE_QTWEBKIT TRUE )
INCLUDE( ${QT_USE_FILE} )
ADD_DEFINITIONS( ${QT_DEFINITIONS} )
TARGET_LINK_LIBRARIES( RealTimeCapture ${QT_LIBRARIES} )

# Add boost support
INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIR} )
TARGET_LINK_LIBRARIES( RealTimeCapture ${Boost_LIBRARIES} )

# Add other libs include dirs
INCLUDE_DIRECTORIES( "thirdparty/SimpleCrypt" )
INCLUDE_DIRECTORIES( "thirdparty/id3lib/include" )
INCLUDE_DIRECTORIES( "thirdparty/libtwitcurl" )
INCLUDE_DIRECTORIES( "thirdparty/curl-7.24.0/curl/include" )
INCLUDE_DIRECTORIES( "thirdparty/log4qt/include" )
INCLUDE_DIRECTORIES( "thirdparty/fervor-auto" )

# Add defines
ADD_DEFINITIONS( RealTimeCapture -DQUAZIP_STATIC )
ADD_DEFINITIONS( RealTimeCapture -DBUILDING_LIBCURL )
ADD_DEFINITIONS( RealTimeCapture -DID3LIB_LINKOPTION=1 )
ADD_DEFINITIONS( -DUNICODE -D_UNICODE ) #enable unicode support

ACTUALIZAR

Como se menciona en los comentarios a la respuesta aceptada, he logrado establecer un qmake.exe personalizado (diferente del que se agregó a la variable PATH del SO) al establecer la variable QT_QMAKE_EXECUTABLE CMake. Pero el problema era que el ejecutable qmake tiene rutas codificadas en todos los módulos de Qt. Así que lo he solucionado proporcionando un archivo qt.conf personalizado (como se menciona en la respuesta). No he encontrado ejemplos de esto en Internet, así que aquí está, tal vez ayude a alguien:

[Paths]
Prefix=..
Documentation=doc
Headers=include
Libraries=lib
Binaries=bin
Plugins=plugins
Imports=imports
Data=
Translations=
Settings=
Examples=
Demos=

Usé exactamente esto. Sin embargo, puede considerar especificar una ruta de acceso absoluta a la instalación de Qt en el prefijo. Simplemente no quería utilizar una ruta absoluta en un repositorio, que puede clonarse en una ubicación arbitraria. Vea this enlace sobre los detalles sobre el uso de qt.conf .

Answer 1

Estás en el camino correcto con QT_QMAKE_EXECUTABLE . Esa variable es una variable de caché, por lo que simplemente establecerlo no funcionará ... el valor en caché se mantendrá a menos que lo cambie a través de la GUI, o antes de ejecutar cmake la primera vez, o en CMakeCache.txt, o con CACHE y FORCE opciones para SET .

Aquí está el modismo que uso, ya que tengo la lógica fija para elegir mi directorio QT basado en variables conocidas en el momento de configurar. Aquí, configuro la variable antes de ejecutar FIND_PACKAGE, por lo que no hay problemas de caché.

IF(WIN32 AND ${CMAKE_SIZEOF_VOID_P} MATCHES 8)
  # Hardcode a location for a QT toolkit compiled for Win64.  By overriding QT_QMAKE, all the rest is found
  # Choose any version of QT found in the 64-bit tools area
  FILE(GLOB QTROOTS c:/Tools_x64/Qt/*/bin)     # */
  FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 qmake-mac PATHS ${QTROOTS})
ENDIF()

Pon esto antes de FIND_PACKAGE (Qt4)

EDICIÓN basada en nueva información en comentarios:

Oh, estoy contigo ahora. Usted tiene lo que equivale a instalaciones Qt rotas. El módulo FindQt siempre usará el ejecutable qmake para descubrir la configuración del árbol de Qt. Qmake almacena esta información en un conjunto de "propiedades persistentes", que pueden consultarse con qmake -query y establecerse con qmake -set . Para que pueda "arreglar" una instalación de Qt ejecutando su qmake y estableciendo la propiedad QT_INSTALL_PREFIX, como se documenta aquí: http://doc.qt.digia.com/4.7-snapshot/qmake-environment-reference.html

qmake -set "QT_INSTALL_PREFIX" /path/to/qt/

O bien, en una vieja pregunta de SO qmake y QT_INSTALL_PREFIX. ¿Cómo puedo seleccionar una nueva ubicación para la biblioteca de Qt? , una respuesta no aceptada utiliza qt.conf para anular el prefijo QT.

Ambas soluciones implican modificar la instalación de Qt. No estoy seguro de que haya alguna forma de evitar esto, pero cómo encaja esto en su repositorio y sistema de compilación está fuera de alcance aquí.

Answer 2

Esto es lo que funcionó para mí:

set( QT_ROOT /opt/myqt/ )
set( ENV(CMAKE_PREFIX_PATH) ${QT_ROOT} )
FIND_PACKAGE( Qt4 COMPONENTS QtCore QtGui QtDBUS REQUIRED )

Esto va a cambiar la variable de entorno PATH, pero no he encontrado otra manera. Otras respuestas no funcionaron para mí.

Answer 3

Estoy usando el indicador de configuración de -DQt5_DIR=/usr/lib/x86_64-linux-gnu/cmake/Qt5 y parece funcionar bien.

Editar: este método funciona con un directorio de compilación vacío. Sin embargo, si existe un CMakeCache.txt anterior, las variables por componente (es decir, Qt5Core_DIR ) no se actualizan configurando un nuevo Qt5_DIR . La manera más fácil de solucionar eso es eliminar CMakeCache.txt y configurar nuevamente.

Answer 4

Si es posible, me gustaría completar / confirmar cierta información aquí y dar un ejemplo completo.

Al igual que Occulta, tengo un entorno de Qt personalizado que debo usar para mi proyecto. Estos son los pasos que reproduje para hacer que el proyecto se compile:

1. El CMakeLists.txt de mi proyecto, que ya posee todas las cosas de CMake, solo incluye un archivo ''qt.cmake''

   include(qt)

2. El archivo qt.cmake contiene la solución de Peter, decorada con cosas adicionales. Con esta configuración, puedo usar moc, uic y rcc para administrar archivos UI, recursos, etc. Aquí está mi archivo con algunos comentarios. No dude en corregirlos si no son estrictamente correctos (la forma en que CMake funciona aún está nublado para mí):

   # The path where Qt is.
   SET(QT_ROOT_DIR "path/to/qt")
   
   set(QT_QMAKE_EXECUTABLE ${QT_ROOT_DIR}/osx/bin/qmake)
   
   # Loads CMake macros bound to Qt.
   find_package(Qt4 REQUIRED)
   # Includes used Qt headers.
   include(${QT_USE_FILE})

3. También agregué el archivo qt.conf de Occulta al mismo nivel que el ejecutable qmake.

Todo fue bien una vez que se realizaron estos tres pasos. Espero que este completo ejemplo ayude a alguien.

Gracias chicos, ¡claramente me ayudaste aquí!