QMake es una de las herramientas que se incluyen en el toolkit Qt. Ella nos permite crear un archivo Makefile que luego será usado para compilar nuestro proyecto. Para ello basta con ejecutar qmake dentro del directorio principal del proyecto y él buscará todos los archivos de código fuente existentes en los subdirectorios de manera recursiva.
QMake tiene dos posibles uso, uno para generar el archivo del proyecto y otra para generar el Makefile a partir del archivo de proyecto creado previamente. Para llevar a cabo el primer paso se ejecuta:
$ qmake -project
Suponiendo que estamos dentro de un directorio llamado miprograma, ésto generará el archivo miprograma.pro con una serie de parámetros que luego usará qmake para generar el Makefile necesario para compilar el proyecto usando make.
El archivo .pro generado tiene las etiquetas mínimas necesarias para compilar el proyecto pero a veces suele ser necesario añadir algunas rutas a bibliotecas, decidir dónde colocar cada archivo generado, bibliotecas a enlazarse con el binario, etc. Las opciones más útiles son:
CONFIG - Dentro de esta declaración se especifican algunas opciones de configuración y compilación.
- releaseCompila para generar el archivo binario final, es ignorada si se especifica debug también.
- debugCompila con las opciones de depurado activadas.
- warn_onCon esta opción el compilador emitirá más avisos de lo normal y se ignora si se incluye también warn_off.
- warn_offEl compilador solo emitirá avisos de errores severos.
- qtIndica que el destino es una aplicación Qt y que requiere los encabezados y bibliotecas Qt. Por ello las rutas a estos archivos serán incluidas en el Makefile.
- openglEl binario requiere los archivos de OpenGL (o Mesa). Esta opción incluirá las rutas a estos archivos.
- threadLa aplicación es multi hilo, lo que añadirá las opciones necesarias para indicar ésto al compilador.
- x11El destino es una aplicación para X11 haciendo que se incluyan las rutas a los encabezados y bibliotecas de las X.
- windowsLa aplicación es para Windows en modo gráfico.
- consoleLa aplicación es para Windows en modo cónsola.
- dllEl destino es una biblioteca dinámica DLL.
- staticlibEl destino es una biblioteca estática.
- pluginEl destino es un plugin. Probablemente se activará la opción dll también.
DEFINES - Aquí se colocan todos los defines que serán pasados al compilador.
DESTDIR - Especifica el directorio donde colocar el binario una vez generado.
HEADERS - Especifica los archivos de encabezados a incluir en el proceso de compilación.
INCLUDEPATH - Especifica los directorios donde el compilador buscará los archivos de encabezados adicionales al proyecto.
LIBS - Especifica las bibliotecas a incluir durante el enlazado del binario.
MOC_DIR - Especifica el directorio donde colocar los archivos moc generados durante la expansión de las macros Q_OBJECT.
OBJECTS_DIR - Especifica el directorio donde colocar los archivos objetos generados durante la compilación.
SOURCES - Indica los archivos fuentes a compilar para generar el binario del proyecto.
SUBDIR - Contiene los nombres de subdirectorios donde buscar archivos de proyectos (.pro).
TARGET - Nombre del archivo binario a generar.
Además de estas opciones existen otras menos usadas (al menos yo nunca las he necesitado) y que pueden ser consultadas en la ayuda de qmake. Un ejemplo de un archivo de uno de mis proyectos es el siguiente:
# Subdirectorio relativo al directorio principal del proyecto:
HEADERS += src/CMainWindow.h \
src/CWDialogo.h \
src/Definiciones.h \
src/CEstadisticas.h
SOURCES += src/CMainWindow.cpp \
src/CWDialogo.cpp \
src/main.cpp \
src/CEstadisticas.cpp TEMPLATE = app TARGET = proyecto DEPENDPATH += . src INCLUDEPATH += . src /usr/include/qt4/QtSql LIBS = -lQtSql MOC_DIR = ./moc OBJECTS_DIR = ./obj DESTDIR = ./bin
Con este archivo de proyecto se le indica a qmake que cree un Makefile para generar un binario llamado proyecto, que busque los archivos .h en los directorios actual, src y /usr/include/qt4/QtSql, que enlace con la biblioteca libQtSql, que coloque los archivos moc dentro del directorio moc, los .o dentro del directorio obj y el binario generado dentro del directorio bin.
La versión de qmake usada al momento de escribir estas líneas era la 4.1.
Hola, un sencillo comentario. En el siguiente código me resulta extraño los tipos KAction en vez de QAction y funciones con argumentos (void) en vez de sin arguementos (). Por lo demás sensacional tu blog y se echaba de menos algo así en Español:
lass KMiMainWindow : public KMainWindow {
Q_OBJECT
public:
KMiMainWindow(QWidget *parent = 0, const char *name = 0);
private:
// Variables privadas
KAction *actAbrir;
KAction *actCopiar;
KAction *actCortar;
KAction *actPegar;
KAction *actSalir;
// Funciones Privadas
void CrearAcciones(void);
void CrearMenu(void);
void CrearToolbar(void);
private slots:
void slotAbrir(void);
void slotCopiar(void);
void slotCortar(void);
void slotPegar(void);
void slotSalir(void);
Saludos. Ubaloie.
Este comentario corresponde más bien a otro de los artículos, no al de qmake. Ya que estoy haciendo una aplicación KDE prefiero usar las clases de KDE, por eso uso KAction en lugar de QAction. La clase KStdAction que menciono en el artículo retorna un KAction en lugar de QAction, así que prefiero mantener el mismo tipo también por esta razón.
Con respecto al void, me gusta mucho la claridad cuando escribo código así que prefiero hacer:
void slotAbrir(void)
que
void slotAbrir()
Pues le indico al compilador explícitamente el tipo de datos que recibirá la función.