Arriba

Esquema básico modificado de una aplicación KDE

Una vez que hemos visto como crear una aplicación sencilla para KDE empezaremos a modificarla puesto que la ventana que creamos anteriormente no sirve de nada si no derivamos de ella una clase donde la personalicemos. Ahora veremos como crear una nueva clase derivada de KMainWindow y que llamaremos KMiMainWindow. Para ello creamos un archivo llamado KMiMainWindow.h con la declaración de la clase que tendrá el siguiente contenido:

#include <kmainwindow.h>

class KMiMainWindow : public KMainWindow {
  Q_OBJECT
  
  public:
    KMiMainWindow(QWidget *parent = 0, const char *name = 0);
        
};

Aquí vemos como derivamos nuestra clase de KMainWindow. Algo importante es el uso de Q_OBJECT, que es una macro usada por Qt para expandir algunas cosas entre ellas el manejo de SIGNAL y SLOT. Se debe incluir esta macro en las aplicaciones para KDE/Qt. Ahora creamos un archivo que contendrá el código de la clase creada y que llamaremos KMiMainWindow.cpp con el siguiente código:

#include "KMiMainWindow.h"

KMiMainWindow::KMiMainWindow(QWidget *parent, const char *name) :
               KMainWindow(parent, name) {
  // Le decimos que coloque la ventana en la posición (0,0)
  // Con un tamaño de 400x400 pixeles.
  setGeometry(0,0,400,400);
  // Ahora le ponemos de título MiMainWindow
  setCaption("MiMainWindow");
}

Ahora modificamos el archivo principal de la aplicación para que quede de la siguiente manera:

#include <kapp.h>
#include "KMiMainWindow.h"

int main( int argc, char **argv ) {
  KApplication kaplicacion(argc, argv, "Esquema Básico");
  // Creamos nuestro nuevo objeto y le damos un nombre
  // al objeto por medio del constructor
  KMiMainWindow *mw = new KMiMainWindow(0, "KMiMainWindow");
  kaplicacion.setMainWidget(mw);
  // Mostramos la ventana
  mw->show();
  return kaplicacion.exec();
}

Por último debemos crear un nuevo Makefile que incluya los archivos recién añadidos. Para ello modificaremos el archivo kapp.pro y dejamos que qmake genere el Makefile. Nuestro archivo de proyecto ahora quedará así:

INCLUDEPATH = /usr/kde/3.5/include/
LIBS = -lkdeui -L/usr/kde/3.5/lib
TEMPLATE = app
TARGET = kaplicacion
DEPENDPATH = .

HEADERS += KMiMainWindow.h
SOURCES += KMiMainWindow.cpp kapp.cpp

Hechas estas modificaciones, solo queda generar el Makefile y compilar el programa. Para ello ejecutamos:

$ qmake
$ make
$ ./kaplicacion

Una vez hecho esto veremos una ventana ubicada en la parte superior izquierda de nuestra pantalla, con un tamaño de 400x400 y con MiMainWindow como título.

Aplicación básica en KDE

Llegados a este punto tenemos lo básico para realizar programas en KDE: un archivo que contiene la rutina main y una clase derivada de KMainWindow. A partir de acá empezaremos a modificar esta estructura básica para ir añadiendo otros widgets a nuestro programa. En la próxima entrega veremos como añadir un menú con algunos items a nuestra aplicación. Hasta la próxima.

Arriba

Esquema Básico De Una Aplicación KDE

Para poder empezar a programar en KDE crearemos una simple aplicación, la más básica que se puede hacer, para luego ir añadiendo otros elementos posteriormente. El programa más básico es una simple ventana que se abrirá al ejecutarse, luego en otros posts iremos añadiendo los menúes, barra de botones, etc.

Primero creamos un directorio llamado kapp y luego creamos un archivo llamado kapp.cpp y le colocamos el código siguiente:

#include <kapp.h>
#include <kmainwindow.h>

int main( int argc, char **argv ) {
  KApplication kaplicacion(argc, argv, "Esquema Básico");
  KMainWindow *mw = new KMainWindow(0, "KMainWindow");
  kaplicacion.setMainWidget(mw);
  mw->show();
  return kaplicacion.exec();
}

Para poder compilar el código necesitamos crear el Makefile del proyecto. Siendo un código tan sencillo podríamos compilarlo simplemente escribiendo:

$ g++ -I/usr/kde/3.5/include -I/usr/qt/3/include/ -L/usr/kde/3.5/lib/ \ 
-L/usr/qt/3/lib/ -lkdeui -o kapp kapp.cpp

La biblioteca libkdeui es la que tiene el código de todos los widgets usados en KDE. Las opciones -I y -L le indican al compilador donde buscar los encabezados y las bibliotecas respectivamente, mientras que la -l le dice que enlace dinámicamente el binario con esa biblioteca. Para aprender un poco más usaremos qmake dentro del directorio para crear el archivo de proyecto. Para ello ejecutamos lo siguiente:

$ qmake -project

Si probamos a crear el Makefile con las opciones del archivo kapp.pro y luego compilar tendremos varios errores debido a que qmake no sabe nada de las bibliotecas y encabezados de KDE por lo que no añadió las rutas ni las bibliotecas necesarias. Por lo tanto debemos editar el archivo kapp.pro para que quede de la siguiente manera:

INCLUDEPATH = /usr/kde/3.5/include/
LIBS = -lkdeui -L/usr/kde/3.5/lib
TEMPLATE = app
TARGET = kaplicacion
DEPENDPATH = .
SOURCES += kapp.cpp

Ahora sí ejecutamos:

$ qmake
$ make

Una vez finalizado el proceso de compilación habrá sido creado un archivo binario llamado kaplicacion el cual al ser ejecutado abre una ventana vacía como la siguiente:

Ventana sencilla en KDE

Una pequeña explicación del código anterior sería la siguiente:

#include <kapp.h>
#include <kmainwindow.h>

kapp.h tiene las declaraciones para las aplicaciones KDE mientras que kmainwindow.h tiene las declaraciones para la ventana principal usada por una aplicación.

KApplication kaplicacion(argc, argv, "kaplicacion");

Con esto creamos una aplicación llamada kaplicacion y le pasamos los parámetros de la línea de comandos.

KMainWindow *mw =new KMainWindow;
kaplicacion.setMainWidget(mw);

Ahora creamos una ventana principal y la asignamos como widget principal de la aplicación.

mw->show();
return kaplicacion.exec()

Una vez creada la mostramos y esperamos que retorne.

En el próximo artículo veremos como crear un esquema básico pero creando una subclase de KMainWindow para poder añadir funcionalidades más adelante.

Arriba

QMake

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.