KDevelop -Programación en XWindow de Linux

Programación en Linux con KDevelop 1.0

Autor: Guillermo 'guille' Som
Inicio: Viernes, 15 de Octubre de 1999
Actualizado: 17/Jun/03 (17/Oct/99)

Introducción

Este "mini-cursillo" es para que te puedas enfrentar a la programación para Linux en entorno gráfico XWindow usando el administrador de ventanas KDE, el que más me gusta de los varios entornos que he probado en Linux, que la verdad no han sido demasiados, seguramente será porque es el que más se parece al Windows...
Para crear los programas voy a usar el entorno de desarrollo KDevelop, la versión 1.0 que es la que por ahora es más estable, en cuanto pueda conseguir la versión 2.0 seguramente veremos algunas cosillas que esa nueva versión pueda aportar... si es que lo resisto, ya que esto del Linux lo estoy haciendo, entre otras cosas, para "obligarme" a programar en C++, ya que no existe ninguna versión de Visual Basic ni Delphi para este sistema operativo, aunque creo que Borland está preparando una versión del C++Builder para Linux... a ver...

Mientras tanto, vamos a ver si soy capaz de explicarte, de forma simple, cómo escribir algunas cosillas para XWindow usando el entorno de desarrollo de los autores del entorno KDE.
La versión del entorno, (que en el momento de escribir estas líneas, 15 de Octubre), estoy usando es la 1.0 beta 3 (19991009-A) con las librerías de QT versión 1.44.
QT es una serie de clases para el entorno XWindow, en la que se incluyen botones, cuadros de texto, etc. El nombre que le dan esta gente es el de widgets, pero para que nos entendamos, es como los controles que usamos en Visual Basic y otros entornos de Windows.

Lo que veremos en estas entregas serán las cosillas que creo son interesantes de saber si es que esto de programar en C++ te resulta del todo nuevo... así que no te asustes si es demasiado básico... además debes tener en cuenta que el lenguaje al que estoy habituado es el Visual Basic, por tanto puede que incluso encuentres alguna que otra "palabreja" que se use de forma habitual en ese enorno y que a lo mejor los programadores más experimentados de C++ llamen de otra forma...
También puede que algunas cosas que explico te resulten demasiado obvias, pero que a mi me parece deben saberse... para eso soy yo el que escribe esto y por tanto tengo el "derecho" de decir lo que me plazca... ;-)

Tengo que advertir que mi "tutor" en este mundillo de la programación con el Kdevelop han sido los manuales que se acompañan al propio entorno y los que vienen con el QT, aunque al principio no sabía cómo meterle mano para poder probar los ejemplos... es que, como a muchos le pasa, empecé a usar el entorno sin leer nada de la ayuda... así que, si lo tienes instalado, leete la ayuda, que aunque esté en inglés... te será de utilidad.

Espero que no te aburras y que yo aguante lo suficiente...

Nos vemos.
Guillermo

Nerja, viernes 15 de Octubre de 1999

Instalar el KDevelop y los extras necesarios

Si no tienes ya instalado el entorno de desarrollo KDevelop, puedes hacerlo si te bajas los siguientes ficheros que puedes conseguir del sitio de KDE (http://www.kde.org y http://developer.kde.org ) Por supuesto deberás tener el entorno KDE, ya que que el KDevelop funciona en ese entorno de ventanas.

Las cosillas que necesitarás serán:

kdedoc.tar.gz
kdoc-sanapshot.tar.gz
kdelibsdoc.tar.gz
kdbg-1.0beta3.tar.gz
kdevelopYYYYMMDD.tar.gz
(la que yo instalé, al menos antes de escribir esto, fue: kdevelop19991009.tar.gz, pero cuando leas esto, seguramente ya habrá alguna nueva revisión, la numeración indica la fecha en formato año-mes-dia, debes tener cuidado, ya que en el mismo directorio del ftp están las versiones para el QT 1.44 y KDE 1.1.x así como el KDevelop para QT 2.0.1 y KDE 2.x y el nombre es el mismo, lo único es que la versión para el KDE 1.1x está en la carpeta FINAL-1.0-BRANCH. La versión de KDE se refiere a la versión del gestor de ventanas; la versión de KDevelop es la 1.0 beta 3.)

También necesitarás las librerías de QT 1.44, éstas están también accesibles desde la página de developer.kde, la dirección de la web de QT es: http://www.troll.no, recuerda que debes usar la versión 1.44 si tienes KDE 1.1.x

Casi con seguridad necesitarás estos otros "paquetes":
autoconf-2.13.tar.gz
automake-1.4.tar.gz

De todas formas, en la página de KDevelop te indica los "requisitos" y los links de dónde puedes conseguir los ficheros.

¿Cómo instalar los paquetes?

El procedimiento para casi todos estos ficheros es el mismo, sólo hay uno de los mencionados que no es necesario instalar ni hay que compilar/montar nada, simplemente se extraen los ficheros en una carpeta y se copian en el directorio de destino, creo que era el fichero kdoc-sanapshot, pero ahora no lo recuerdo bien...

Estos son los pasos a seguir:

Extraer los ficheros para poder compilarlos:
tar xvfz nombre_del_fichero.tar.gz

Cambiar a la carpeta creada al extraer los ficheros:
cd nombre_carpeta

Configurar el "enlazador"
En casi todos los casos es necesario hacer esto:
make -f Makefile.cvs
./configure
make
make install
También puedes escribirlo en una sola línea, separando los comandos con un punto y coma:
./configure; make; make install
./configure es: "punto" "barra de dividir" "configure"
El make install sólo puedes hacerlo si has entrado en linux como "root"
En caso de que te de error al intentar hacer el Makefile.cvs, (porque no exista el fichero, por ejemplo), pasa al siguiente paso.
Una vez terminado estos pasos puedes borrar los directorios creados, ya que los ficheros se suelen instalar en los directorios adecuados.

Algunos de estos procesos se toman su tiempo, dependiendo del equipo que tengas tardará más o menos... en el caso de kdevelop, puede que se demore más de 15 minutos... la verdad es que no cronometé el tiempo que tardó... lo dejé haciendolo, usando los tres últimos comandos en una sola línea...

Por último te recomiendo que NO crees proyectos como usuario "root", ya que no te permitirá usar esos proyectos si has entrado como otro usuario. En caso de que hayas creado algún proyecto como root, puedes copiar las carpetas creadas por el entorno de desarrollo en el directorio \home (que es en el que se crean las carpetas de cada usuario y por tanto tiene permisos para poder escribir y ejecutar desde él) o en el del usuario con el que vayas a entrar en linux. Una vez copiada o movida la carpeta con el proyecto, deberas cambiar los atributos de los ficheros, (esto sólo podrás hacerlo entrando como root), para cambiar los atributos de una carpeta y todo su contenido, escribe:
chmod -R a+w+r+x *
La -R es para que trabaje de forma recursiva, la "a" le indica que quieres permitir que "todos" puedan acceder a esa carpeta y ficheros, +w indica que quieres permitir la escritura, +r la lectura y +x que se puedan ejecutar, (leete la ayuda de chmod si quieres saber cómo funciona esa orden: man chmod).

Normalmente en los directorios creados con la orden tar xxx existe un fichero README que tiene información de cómo extraer y "montar" los paquetes...

Por supuesto, todas estas instrucciones deben ejecutarse en una "consola" o terminal, algo así como una ventana de DOS...

Espero que no tengas problemas con todo esto... de todas formas, seguramente no será necesario que lo hagas, si la distribución de Linux que has instalado es de las ultimitas, ya que suelen incorporarla... la que yo tengo instalada es la Mandrake 6.1 (beta) que venía en un CD de LINUX Actual, y tenía la versión 1.0 beta 2 del KDevelop, pero no tenía toda la documentación del KDevelop ni algunas de las utilidades... Anteriormente había instalado el RedHat 6.0 que se incluía en PC-World, pero esa distribución de Linux no incluía el entorno de desarrollo.
Por suerte todo esto de Linux está disponible en la red... y de forma gratuita... incluso el StarOffice, que es con lo que estoy escribiendo estas págianas HTML, que es una especie de Office para Linux y ¡gratis!, al menos si el uso que quieres darle es privado, ya que este tipo de programas gratuitos suelen serlo para uso privado, y no para uso comercial...

La verdad es que... (seguramente algunos "forofos" del Linux me odiarán por esto que voy a decir, pero... ) todos estos entornos y programas se "basan" en un look muy parecido al Windows... ¿será por eso por lo que no me encuentro desplazado?
Y para meter un poco de "caña", decir que no son programas tan estables como se suponen que deberían ser... ya que el KDevelop "peta" más que una escopeta de plomo... sí, ya sé que es una versión beta, pero... el StarOffice no es beta y sin embargo también se le va la olla de vez en cuando... en fin... tenía que decirlo y lo he dicho... ya que se suele decir que el LINUX NUNCA SE CUELGA... puede que el kernel del Linux sea superestable, pero las aplicaciones que trabajan en Linux no son tan perfectas como las quieren pintar... recuerda que detrás de cada programa hay como mínimo un programador y no todos los programadores son "perfectos"...
¿Cómo dices? que tu si que eres perfecto... pues me parece muy bien... mejor para tí...

Nos vemos.
Guillermo

Nerja, 16 de Octubre de 1999

El entorno de KDevelop (crear un nuevo proyecto)

Aunque me imagino que si te has leido la introducción habrás hecho lo que hay que hacer... es decir leerte la ayuda, ya sabrás cómo crear un nuevo proyecto y empezar a hacer cosillas... pero como me imagino que si estás leyendo esto es porque no te habrás aclarado demasiado, te voy a explicar de forma simple cómo crear el "esqueleto" para una nueva apliación y así de paso aprenderemos algunas cosillas que no son tan "básicas" ni intuitivas como pueden serlo en entornos de desarrollo del Windows de Microsoft.

Empecemos creando un nuevo proyecto. (Doy por supuesto que el idioma usado es el inglés, aunque KDE permite la configuración en otros idiomas y el entorno de desarrollo cambia los nombres de los menús al idioma seleccionado, prefiero usar los nombres "originales" en inglés, espero que esta decisión no sea un inconveniente)
En el menú Project, selecciona New...
Te mostrará un cuadro de diálogo (KDE Application Wizard), para ayudarte a seleccionar el tipo de proyecto, en otra ocasión puedes probar con otros tipos de proyectos, pero para la mayoría de las cosas que veremos aquí con seleccionar el tipo "KDE-Mini" será más que suficiente.
Selecciona KDE-Mini y pulsa en Next>>
La segunda página del asistente te pedirá el nombre del proyecto (Projectname), además de otros datos, sólo es necesario que rellenes el nombre del proyecto, (automáticamente generará el path en el que se alamacenará), tu nombre y el e-mail.

Para este ejemplo, llamalo KPrueba01, (K y P en mayúsculas, el resto en minúsculas, es que el editor que estoy usando es el del StarOffice 5.1 y el corrector me cambia el estado de las letras, intentando corregirlas y puede que no me de cuenta de poenrlas como las he escrito en el diálogo), fíjate que aunque quieras escribir en minúsculas la primera letra, el asistente la pone en mayúsculas. Una cosa que tienes que tener MUY en cuenta, es que en C++, (no solamente en Linux), se diferencian las minúsculas de las mayúsculas, es decir que Kprueba no es lo mismo que kprueba, aunque para el nombre del proyecto es lo mismo, se creará una clase con ese nombre y con el "estado" de letras según las hayas escrito.

En las siguientes páginas pulsa Next>> y en la última, en la que habrá tres botones, pulsa en Create para generar todos los ficheros necesarios, puede que te muestre algún mensaje de error, pero, salvo que sean demasiados, no es necesario prestarle atención...
Una vez que haya terminado de hacer sus "preparativos", te lo indicará con un READY y verás que el botón del centro ha cambiado a Exit, púlsalo y ya tendrás el proyecto terminado.

Para probar el programa y ejecutarlo, pulsa F9 o bien en el menú Build selecciona la opción Execute, también puedes darle al botón con forma de rueda de engranaje que está en la barra de herramientas junto a la rueda con gafas oscuras...
Tienes que saber que cada vez que pulsas F9 se guardan los ficheros y, salvo que lo hayas modificado, estos se "autoguardan" cada 5 minutos...
Después de un ratillo, recuerda que estás trabajando con un compilador real y se debe compilar todo el proyecto antes de ejecutarse... verás que sólo se muestra una ventana vacía con el título, que no es ni mas ni menos que el nombre del proyecto, (todo en minúsculas), pero no hay nada más, ni botones ni etiquetas, ni nada de nada... sólo tenemos los botones habituales en cualquier ventana de este entorno.
Pulsa en la X para cerrar la ventana y finalizar el proyecto.

Fíjate que existen una serie de ficheros, dos con la extensión .cpp y uno con la extensión .h, además de otros, que no tienen ningún contenido... ahora mismo sólo nos interesan los ficheros propios del programa. El fichero con la extensión .h es el de cabecera y en él está la declaración de la clase. Los otros dos con extesión .cpp (de C++), tienen la implementación de dicha clase, es decir, el código que le dice al compilador lo que esa clase debe hacer y el otro es main.cpp que es el que tiene la función main, que es la función que se usará para empezar el "espectáculo".

Ahora vamos a añadir código para cambiarle el "caption" a nuestro programa, para que muestre otra cosa que no sea el nombre del proyecto, para eso tendremos que modificar la función main.

Selecciona el fichero con la función main.
En el panel de la izquierda tienes varias solapas. Pulsa en la segunda (LFV), de las carpetas que muestra, selecciona la que pone "Sources", (pulsando en la flechita de la izquierda se muestra el contenido de la carpeta), te mostrará dos ficheros: main.cpp y kprueba01.cpp, pulsa en main.cpp y verás que te muestra el código contenido de ese fichero.

Añade la siguiente línea:

kprueba01->setCaption("Prueba de KDE");

antes de kprueba01->show();, aunque realmente no importa si lo pones después, pero lo que si que debes hacer es ponerlo antes de: return a.exec(); ya que a.exec() es la que se encarga de ejecutar la aplicación.

Bueno, esto es todo.
En otra ocasión veremos cómo crear nuestros propios diálogos... o formularios, con los que podremos interactuar, para que nos avise de las diferentes cosas que van ocurriendo... ya que, este entorno de desarrollo no te ofrece la facilidad del de Visual Basic o los de Borland, en los que son relativamente simple codificar para gestionar los diferentes eventos, pero eso será en otra ocasión.

Nos vemos.
Guillermo

Nerja, 15 de Octubre de 1999

Añadir widgets (controles) a una aplicación.

Vamos a continuar con el proyecto que creamos en el punto anterior, en este caso vamos a añadirle un botón para que no sea sólo una ventana sin nada más.

El botón en cuestión lo vamos a añadir usando código a "pelo", es decir, sin ningún tipo de "diseñador" de formularios o ventanas o diálogos, como prefieras llamarlo.

Esto que queremos hacer, mostrar un botón dentro de la ventana, se puede hacer tanto dentro de la función main, como dentro del contructor de la clase KPrueba01.
Primero veremos cómo habría que hacerlo en la función main, aunque lo más lógico y recomendable sería hacerlo en el constructor de la clase. De todas formas, el código a usar sería el mismo (o casi) en ambos casos.

Veamos. Abre el código de main.cpp y antes de la declaración de la función main, añada esta línea:

#include <qpushbutton.h>

Esto es necesario, ya que este fichero de cabecera contiene las declaraciones necesarias para poder usar un objeto del tipo QPushButton, que es el objeto que tenemos que usar para mostrar un botón.

Añade la siguiente línea:

QPushButton *salir = new QPushButton("Terminar", kprueba01);

después de la declaración de la variable de la clase KPrueba01:

KPrueba01 *kprueba01 = new KPrueba01();

ya que en la creación del botón se usa la variable que representa a la clase principal de nuestro proyecto.

Te explico que es lo que se ha hecho:
Se ha declarado una variable del tipo QPushButton (QPushButton *salir, esto es lo mismo que si en Visual Basic se hiciera: Dim salir As QPushButton)
Después se crea un nuevo objeto (= new QPushButton),
se le da el valor del texto a mostrar ("Terminar")
y se le dice quién es el "padre" de ese botón, es decir, en que objeto debe estar colocado (kprueba01)

Pulsa F9 y verás que se muestra un botón en la esquina superior izquierda de la ventana y que el texto que muestra es: Terminar.

Cambiar la posición y el tamaño de un control

Si quieres que tenga un tamaño diferente, puedes usar el método resize(ancho, alto) para cambiar el tamaño.
Como habrás podido observar, los "métodos" de las clases en C++ se llaman usando -> entre el nombre de la variable de la clase y el método. Recuerda que un método no es más que un procedimiento (o función) de la clase.
Por tanto, si escribes esto, (después de la línea que acabamos de añadir):

salir->resize(200, 60);

El botón se mostrará con un tamaño de 200x60 puntos, pero seguirá estando en la esquina superior izquierda.

Pulsa F9 para ejecutar el programa y pulsa en el botón, verás que no hace nada, salvo el efecto de pulsación...

Antes de hacer que el botón sirva para algo, vamos a usar otro "método", (en C++ realmente son funciones, tanto si devuelven o no un valor, por tanto, si en adelante uso la palabra función, método o procedimiento, me estaré refiriendo a una función de la clase), en esta ocasión para posicionar el control: move(x, y)

salir->move(50, 90);

Si queremos posicionar el botón y al mismo tiempo cambiarle el tamaño, en lugar de las dos llamadas anteriores, podemos usar una sola, usando setGeometry(x, y, ancho, alto):

salir->setGeometry(50, 90, 200, 60);

Recuerda que en C++ se diferencian las mayúsculas de las minúsculas, por tanto setGeometry debes escribirlo tal y como está aquí, es decir todas las letras en minúsculas salvo la G.

Añadir un evento a un control

Ahora vamos a hacer que este botón tenga alguna utilidad, como mínimo que cumpla lo que dice que debe hacer: terminar el programa. En los lenguajes "visuales" de Windows, (Visual Basic, Delphi, etc.), es fácil escribir código para que al pulsar en un botón se haga algo... normalmente esto se hace mediante el evento "Click" del botón, ese evento se produce siempre que se pulsa con el ratón o bién, si el botón tiene el foco, si se pulsa intro e incluso la barra espaciadora. Pero en el entorno QT/KDE es otra historia... tenemos que indicarle "explícitamente" que es lo que queremos que haga cuando se produzca que evento. En este sistema de ventanas a los eventos se les llama signal (señal).
Te recuerdo que todo esto en nuevo para mi y puede que a ti te sea familiar esta nomenclatura, pero yo llevo varios años llamando eventos a estas señales...

Antes de mostrar el código que se necesita para hacer que un botón responda con algo a la acción de pulsar sobre él, vamos a hacer las cosas "bien". Así que vamos a codificar todo el tema del manejo del botón dentro de la clase que hemos creado.
Por tanto, borra las líneas que hemos añadido a la función main y escribelas en el fichero kprueba01.cpp, dentro de la declaración del constructor de la clase. Recuerda poner también la línea con el fichero de cabecera, ya que sin él, el compilador no sabrá nada de la existencia de una clase llamada QPushButton.

El código de la clase kprueba01.cpp será este:

#include "kprueba01.h"
#include <qpushbutton.h>

KPrueba01::KPrueba01(QWidget *parent, const char *name) : QWidget(parent, name)
{
QPushButton *salir = new QPushButton("Terminar", this);
salir->setGeometry(50, 90, 200, 60);
}

KPrueba01::~KPrueba01()
{
}

Fíjate en el "pequeño" cambio en lo que está después del "caption", antes usamos la variable kprueba01, pero en esta ocasión usamos this. El constructor del objeto QPushButton, (o mejor dicho, uno de los posibles constructores), requiere como parámetros el texto a mostrar en el botón y un objeto, (clase), que será el que contenga el botón. Cuando se creó el botón en la función main, el objeto en el que queríamos que contuviese el botón estaba referenciado por la variable kprueba01, pero como ahora creamos el botón "dentro" de la propia clase que hará de contenedor, usamos this para indicar "yo", (Me en el caso de Visual Basic, creo que también es this en el caso de Java). Si no indicasemos el objeto o clase padre, el botón no se mostraría.

Bueno, después de esta pequeña aclaración de conceptos, pasemos a agregar el esperado evento.

No se porqué pero esto lo estoy escribiendo como si estuviese dirigido a gente que "vienen" de Visual Basic... ¿será porque ese es mi caso? ¿será porque posiblemente hayas entrado en estas páginas desde mi sitio dedicado, sobre todo, al Visual Basic? sea lo que sea... espero que no te molesten las comparaciones con mi "querido" y no muy bien visto Visual Basic...

Para que la aplicación acabe cuando se pulse en el botón, tenemos que indicarle al compilador que cuando se produzca la pulsación en el botón acabe el programa.
La señal de que se ha pulsado en el botón la produce: clicked(), ahora lo que tenemos que hacer es indicarle que cuando se produzca ese evento (signal), se acabe el programa. Para esto de conectar un evento con una acción se usa: connect acompañado de unas macros... no necesitamos saber más, simplemente que parámetros espera esa "instrucción", antes veamos que tendríamos que hacer para lo que nosotros queremos, añade la siguiente línea antes del cierre de la función en la que se ha declarado el botón salir:

connect( salir, SIGNAL(clicked()), qApp, SLOT(quit()) );

Pulsa F9 y cuando pulses en el botón, esta vez sí que acabará el programa.

Esto es parte de lo que la ayuda de QT dice sobre connect:

bool QObject::connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member ) [static]

Connects signal from the sender object to member in object receiver.
You must use the SIGNAL() and SLOT() macros when specifying the signal and the member.

Es decir, conecta el evento signal del objeto sender a la función (o método) member del objeto receiver, (en negrita están los parámetros que recibe connect).
La traducción más o menos literal sería:
Conecta la señal del objeto remitente al miembro del objeto receptor.
La ayuda nos recuerda que debemos usar las macros SIGNAL() y SLOT() para especificar signal y member.
Osease, señal (signal) será el evento que queremos interceptar y miembro (member) es el procedimiento o función a la que el compilador llamará cuando se produzca dicho evento.
En este ejemplo el evento del botón salir es clicked() y la función que se llamará será quit()...
Pero ¿dónde está esa función quit()?
quit() es un método o miembro de la aplicación, (realmente debería decir del objeto o clase aplicación), qApp realmente es un puntero que hace referencia a la aplicación creada en la función main().

Crear una función que intercepte eventos

Pero ¿que tendríamos que hacer si lo que queremos es tener una función que haga algo más que simplemente acabar el programa?
Es decir, que cuando se produzca ese evento o señal, se llame a una función creada por nosotros.

Es fácil... dirás... creamos una función y ponemos esa función en lugar de quit()
Sí... es cierto, pero...
Veamos lo que habría que hacer para añadir una nueva función a nuestra clase.
La función en cuestión se llamará: salir_click()
Cuando se añade una función a una clase, hay que indicar de su existencia en el fichero de cabecera, ya que es ahí donde reside la "plantilla" con las funciones y demás integrantes de esa clase, además de indicarle el "grado" de visibilidad para con el mundo exterior, es decir si la función será privada, pública o protegida. Privada (private) es para los miembros de la clase que sólo serán visibles para funciones de esa clase, pública (public) permite que cualquier objeto creado de esa clase pueda usarla y por último protegida (protected) será sólo visible en la propia clase y en las clases derivadas de esa clase. En nuestro caso la vamos a declarar private, ya que sólo nos interesa usarla desde la propia clase. Por tanto hay que modificar el fichero kprueba01.h para que contenga el siguiente código:

#ifndef KPRUEBA01_H
#define KPRUEBA01_H

#include <kapp.h>
#include <qwidget.h>

class KPrueba01 : public QWidget
{
Q_OBJECT
public:
/** construtor */
KPrueba01(QWidget* parent=0, const char *name=0);
/** destructor */
~KPrueba01();
private:
void salir_click();
};

#endif

Es decir, añadimos la sección private: y declaramos la función salir_click(), que no devolverá ningún valor (void) y tampoco recibirá parémtros.

Ahora cambia la "conexión" para que haga referencia a esta función:

connect( salir, SIGNAL(clicked()), SLOT(salir_click()) );

Fíjate que en esta ocasión no hemos usado qApp, pero tampoco hemos indicado cual es el objeto que contiene la función a la que se llamará cuando se produzca el evento clicked(). Esto es porque connect "entiende" que si no se especifica el objeto receptor, es como si se indicase this, por tanto esto otro también sería lo mismo:

connect( salir, SIGNAL(clicked()), this, SLOT(salir_click()) );

Ahora pulsa F9 y fíjate en el mensaje que te muestra en la ventana inferior:

QObject::connect No such slot KPrueba01::salir_click()

Pero la ventana se muestra, sólo que al ahcer click en el botón no se cierra la aplicación.

¿Que ha ocurrido?
Que hemos declarado una función "normal", no le hemos indicado que esa función debe hacer de "receptora" de eventos.
Para que podamos recibir eventos en una función hay que declararla como slots. Por tanto cambia la declaración del fichero de cabecera para que ponga lo siguiente:

private slots:
void salir_click();

Pulsa F9 y... ¡esta vez sí!

Es decir, hay que indicarle explícitamente que queremos usar una función para recibir los eventos producidos por otras clases.

Bueno, bueno... que follón ¿verdad? con lo fácil que es hacer esto mismo en Visual Basic... Pues espera a que creemos un formulario o ventana tipo diálogo... pero eso será en otra ocasión...

Nos vemos.
Guillermo

Nerja, 16 de Octubre de 1999

Volver a la sección de Linux