Uso Avanzado

Añadir nuevas características de configuración

qmake le permite crear su propio features que se puede incluir en los archivos del proyecto mediante la adición de sus nombres a la lista de valores especificados por la variable CONFIG. Las características son colecciones de funciones personalizadas y definiciones en archivos .prf que pueden residir en uno de los muchos directorios estándar. Las ubicaciones de estos directorios se definen en varios lugares, y qmake comprueba cada uno de ellos en el siguiente orden cuando busca archivos .prf:

1. En un directorio listado en la variable de entorno QMAKEFEATURES que contiene una lista de directorios delimitados por el separador de lista de rutas de la plataforma (dos puntos para Unix, punto y coma para Windows).
2. En un directorio listado en la variable de entorno QMAKEFEATURES que contiene una lista de directorios delimitados por el separador de la lista de rutas de la plataforma.
3. En un directorio de características que resida dentro de un directorio mkspecs. Los directorios mkspecs pueden estar situados debajo de cualquiera de los directorios enumerados en la variable de entorno QMAKEPATH que contiene una lista de directorios delimitada por el separador de la lista de rutas de la plataforma. Por ejemplo: $QMAKEPATH/mkspecs/<features>.
4. En un directorio de características situado bajo el directorio proporcionado por la variable de entorno QMAKESPEC. Por ejemplo: $QMAKESPEC/<features>.
5. En un directorio de funciones situado en el directorio data_install/mkspecs. Por ejemplo: data_install/mkspecs/<features>.
6. En un directorio de funciones que exista como hermano del directorio especificado por la variable de entorno QMAKESPEC. Por ejemplo: $QMAKESPEC/../<features>.

Se buscan archivos features en los siguientes directorios features:

1. features/unix, features/win32, o features/macx, dependiendo de la plataforma en uso.
2. features/

Por ejemplo, considere la siguiente asignación en un archivo de proyecto:

CONFIG += myfeatures

Con esta adición a la variable CONFIG, qmake buscará el archivo myfeatures.prf en las ubicaciones indicadas anteriormente una vez que haya terminado de analizar el archivo de proyecto. En sistemas Unix, buscará el siguiente archivo:

1. $QMAKEFEATURES/myfeatures.prf (para cada directorio listado en la variable de entorno QMAKEFEATURES )
2. $$QMAKEFEATURES/myfeatures.prf (para cada directorio indicado en la variable de propiedad QMAKEFEATURES )
3. myfeatures.prf (en el directorio raíz del proyecto). La raíz del proyecto viene determinada por el archivo de nivel superior .pro. Sin embargo, si coloca el archivo .qmake.cache en un subdirectorio o en el directorio de un subproyecto, la raíz del proyecto pasa a ser el propio subdirectorio.
4. $QMAKEPATH/mkspecs/features/unix/myfeatures.prf y $QMAKEPATH/mkspecs/features/myfeatures.prf (para cada directorio enumerado en la variable de entorno QMAKEPATH )
5. $QMAKESPEC/features/unix/myfeatures.prf y $QMAKESPEC/features/myfeatures.prf
6. data_install/mkspecs/features/unix/myfeatures.prf y data_install/mkspecs/features/myfeatures.prf
7. $QMAKESPEC/../features/unix/myfeatures.prf y $QMAKESPEC/../features/myfeatures.prf

Instalación de archivos

Es común en Unix utilizar también la herramienta de compilación para instalar aplicaciones y librerías; por ejemplo, invocando a make install. Por esta razón, qmake tiene el concepto de un install set, un objeto que contiene instrucciones sobre la forma en que una parte de un proyecto debe ser instalado. Por ejemplo, una colección de archivos de documentación se puede describir de la siguiente manera:

documentation.path = /usr/local/program/doc
documentation.files = docs/*

El miembro path informa a qmake que los archivos deben ser instalados en /usr/local/program/doc (el miembro path), y el miembro files especifica los archivos que deben ser copiados al directorio de instalación. En este caso, todo lo que se encuentre en el directorio docs se copiará en /usr/local/program/doc.

Una vez que un conjunto de instalación ha sido completamente descrito, puede añadirlo a la lista de instalación con una línea como esta:

INSTALLS += documentation

qmake se asegurará de que los archivos especificados se copien en el directorio de instalación. Si necesita más control sobre este proceso, también puede proporcionar una definición para el miembro extra del objeto. Por ejemplo, la siguiente línea indica a qmake que ejecute una serie de comandos para este conjunto de instalación:

unix:documentation.extra = create_docs; mv master.doc toc.doc

El ámbito unix garantiza que estos comandos concretos sólo se ejecuten en plataformas Unix. Los comandos apropiados para otras plataformas pueden definirse utilizando otras reglas de ámbito.

Los comandos especificados en el miembro extra se ejecutan antes de que se realicen las instrucciones de los demás miembros del objeto.

Si anexa un conjunto de instalación incorporado a la variable INSTALLS y no especifica los miembros files o extra, qmake decidirá qué debe copiarse por usted. Actualmente, se admiten los conjuntos de instalación target y dlltarget. Por ejemplo:

target.path = /usr/local/myprogram
INSTALLS += target

En las líneas anteriores, qmake sabe lo que necesita ser copiado, y manejará el proceso de instalación automáticamente.

Añadir objetivos personalizados

qmake intenta hacer todo lo que se espera de una herramienta de compilación multiplataforma. Esto es a menudo menos que ideal cuando realmente necesita ejecutar comandos especiales dependientes de la plataforma. Esto se puede lograr con instrucciones específicas a los diferentes backends de qmake.

La personalización de la salida Makefile se realiza a través de una API de estilo objeto como se encuentra en otros lugares en qmake. Los objetos se definen automáticamente especificando sus miembros. Por ejemplo:

mytarget.target = .buildfile
mytarget.commands = touch $$mytarget.target
mytarget.depends = mytarget2

mytarget2.commands = @echo Building $$mytarget.target

Las definiciones anteriores definen un objetivo qmake llamado mytarget, que contiene un objetivo Makefile llamado .buildfile que a su vez se genera con el comando touch. Finalmente, el miembro .depends especifica que mytarget depende de mytarget2, otro objetivo que se define posteriormente. mytarget2 es un objetivo ficticio. Sólo se define para enviar algún texto a la consola.

El paso final es utilizar la variable QMAKE_EXTRA_TARGETS para indicar a qmake que este objeto es un objetivo a construir:

QMAKE_EXTRA_TARGETS += mytarget mytarget2

Esto es todo lo que necesitas hacer para construir objetivos personalizados. Por supuesto, es posible que desee vincular uno de estos objetivos a la meta de construcción qmake. Para ello, sólo tiene que incluir su objetivo Makefile en la lista de PRE_TARGETDEPS.

Las especificaciones de objetivos personalizados admiten los siguientes miembros:

Añadir compiladores

Es posible personalizar qmake para soportar nuevos compiladores y preprocesadores:

new_moc.output  = moc_${QMAKE_FILE_BASE}.cpp
new_moc.commands = moc ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT}
new_moc.depend_command = g++ -E -M ${QMAKE_FILE_NAME} | sed "s,^.*: ,,"
new_moc.input = NEW_HEADERS
QMAKE_EXTRA_COMPILERS += new_moc

Con las definiciones anteriores, puede utilizar un reemplazo directo para moc si hay uno disponible. El comando se ejecuta en todos los argumentos dados a la variable NEW_HEADERS (desde el miembro input ), y el resultado se escribe en el archivo definido por el miembro output. Este archivo se añade a los demás archivos fuente del proyecto. Además, qmake ejecutará depend_command para generar información de dependencia, y colocar esta información en el proyecto también.

Las especificaciones personalizadas del compilador admiten los siguientes miembros:

El miembro CONFIG admite las siguientes opciones:

Dependencias de bibliotecas

A menudo, cuando se vincula con una biblioteca, qmake confía en la plataforma subyacente para saber con qué otras bibliotecas se vincula esta biblioteca, y deja que la plataforma las introduzca. En muchos casos, sin embargo, esto no es suficiente. Por ejemplo, cuando se enlaza estáticamente una biblioteca, no se enlazan otras bibliotecas, y por lo tanto no se crean dependencias con esas bibliotecas. Sin embargo, una aplicación que más tarde se vincula con esta biblioteca tendrá que saber dónde encontrar los símbolos que la biblioteca estática requerirá. qmake intenta realizar un seguimiento de las dependencias de una biblioteca, en su caso, si se habilita explícitamente el seguimiento.

El primer paso es habilitar el seguimiento de dependencias en la propia biblioteca. Para ello debe decirle a qmake que guarde información sobre la biblioteca:

CONFIG += create_prl

Esto sólo es relevante para la plantilla lib, y será ignorado para todos los demás. Cuando esta opción está activada, qmake creará un archivo terminado en .prl que guardará alguna meta-información sobre la biblioteca. Este metafile es como un archivo de proyecto ordinario, pero sólo contiene declaraciones de variables internas. Al instalar esta librería, especificándola como objetivo en una declaración INSTALLS, qmake copiará automáticamente el archivo .prl a la ruta de instalación.

El segundo paso en este proceso es habilitar la lectura de esta meta información en las aplicaciones que utilizan la biblioteca estática:

CONFIG += link_prl

Cuando esto está habilitado, qmake procesará todas las bibliotecas vinculadas a la aplicación y encontrar su meta-información. qmake utilizará esto para determinar la información de vinculación pertinentes, en concreto la adición de valores a la lista del archivo de proyecto de aplicación de DEFINES, así como LIBS. Una vez qmake haya procesado este archivo, buscará las bibliotecas recién introducidas en la variable LIBS, y encontrará sus archivos .prl dependientes, continuando hasta que todas las bibliotecas hayan sido resueltas. En este punto, el Makefile se crea como de costumbre, y las bibliotecas se vinculan explícitamente contra la aplicación.

Los archivos .prl deben ser creados sólo por qmake, y no deben ser transferidos entre sistemas operativos, ya que pueden contener información dependiente de la plataforma.