últimos mensajes de: paju1986

Hola a todos.
Estoy haciendo un pequeño tutorial de programación con las librerias Qt4 que iré poniendo poco a poco en mi blog.
Actualmente ando un poco liado en mi propio proyecto de un troyano y con las clases de DAI pero intentaré hacer por lo menos un post del tutorial a la semana.
Espero que les sirva y perdonad si alguna semana estoy demasiado ocupado como para publicar la nueva entrega
------------------------------------------------------------------------------
Bueno, voy a ir haciendo poco a poco un pequeño curso de programación con las librerias Qt4 ya que parece que hay poco al respecto en español.
Voy a suponer que ya se poseen conocimientos de programación en C++ en general y de programación orientada a objetos.
Lo primero que voy a enseñar es como crear una aplicación simple que mue
stre una ventana.

#include <QtGui/QApplication>
#include <QMainWindow>
int main(int argc, char *argv[])
{
   QApplication app(argc, argv);
   QMainWindow ventana;
   ventana.show();
   return app.exec();

}

Bueno, como veis el código es bastante simple, primero tenemos que incluir la clase QApplication que es la encargada de todo lo referente a nuestra aplicación y la clase QMainWindow que es la que representa la ventana principal de nuestro programa.
Luego en la típica función main declaramos dos objetos:
app de tipo QApplication que será el que contiene las funcionalidades básicas del programa y una ventana principal llamada ventana.

Con ventana.show() le decimos que queremos mostrar la ventana en pantalla y luego
llamamos a app.exec() que es un bucle donde permanecerá la aplicación recibiendo y respondiendo a los eventos del usuario hasta que se le de la orden de cerrar la aplicación, en cuyo caso devolverá el código de salida 0 si todo ha ido bien y saldrá del programa.

Más adelante en próximos post explicaré como incluir botones y el mecanismo de signals y slots típico de la programación en Qt.
Hasta la próxima.
--------------------------------------------------------------------------------
Bueno ya que estaba un poco aburrido hoy voy a continuar con la segunda entrega de mi tutorial de programación en Qt4.
En esta ocasión voy a explicar como añadir botones y hacer que al pulsarlos hagan cosas.
Para añadir un botón a nuestro anterior programa lo primero es incluir un nuevo archivo de cabecera que contiene la clase que maneja nuestro botón, en este caso la clase QPushButton (Nota que todas las clases en Qt empiezan por Q).
Las cabeceras quedarían así:

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>

Luego bastará con crear un nuevo objeto de esa clase y para que esté incluido en el formulario le pasaremos una referencia a él.
Esto lo haremos de la siguiente forma:
QPushButton *boton = new QPushButton(&ventana);

Con lo que nuestro código completo que añade un botón a la ventana principal queda asi:
#include <QtGui/QApplication>

#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   QMainWindow ventana;
   QPushButton *boton = new QPushButton(&ventana);
   ventana.show();
   return a.exec();
}

Si te fijas verás que el botón que hemos incluido no tiene ningún texto, para ponerle un texto usaremos el método
QPushButton::setText([texto que le queramos poner]);
Aprovecho para explicar algo sobre los métodos en Qt.
Los métodos que sirven para establecer parámetros de los objetos normalmente son los mismos que los que se usan para leerlos pero empezando por set.
Ejemplo:
QPushButton::text() nos devolvería el texto del boton y QPushButton::setText([algun texto]); pondría el texto del botón.

Concluyendo nuestro programita anterior quedaría algo mejor de la siguiente forma:

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   QMainWindow ventana;
   QPushButton *boton = new QPushButton(&ventana);
   boton->setText("Boton de prueba");
   ventana.show();
   return a.exec();
}
Bueno ahora que tenemos un botón querremos que haga algo al pulsarlo ¿no?

En Qt4 la forma de manejar los eventos como pulsación de un botón, rellenar un formulario, etc. se manejan con el sistema de signals y slots.
Esto consiste en que el objeto que recibe la acción (por ejemplo, un botón al ser pulsado), envia una señal (signal) a otro objeto (por ejemplo, la ventana principal), y este objeto receptor tratará esa señal ejecutando uno de sus métodos (slots).
El método que conecta signals y slots es el método connect de la clase QApplication y se usa de la siguiente manera:

QApplication::connect([objeto emisor],SIGNAL([señal]),[objeto receptor],SLOT([método receptor]));

Veamos como haríamos para que, por ejemplo, al pulsar el botón la aplicación se cerrase.

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   QMainWindow ventana;
   QPushButton *boton = new QPushButton(&ventana);
   boton->setText("Boton de prueba");
   a.connect(boton,SIGNAL(clicked()),&ventana,SLOT(close()));
   ventana.show();
   return a.exec();
}

Como se puede ver en el ejemplo, conectamos la señal clicked() del botón con el slot close() de la ventana principal, lo que hace que al pulsar el botón la aplicación se cierre.

Bueno esto es todo por ahora, en próximas entregas profundizaremos un poco más en el mecanismo de signals y slots.

HASTA LA PRÓXIMA.
-------------------------------------------------------------------------------------------------Bueno, vamos a continuar con el tutorial.
En esta ocasión voy a hablar de como crear signals y slots personalizados para un determinado widget.
Para eso tendremos que crear una clase que herede de la clase a la que queremos añadir signals y/o slots definidos por nosotros donde los declararemos.
Veamos como se hace modificando nuestro programa anterior para que muestre un mensaje emergente al pulsar el botón.

Primero creamos un archivo de cabecera ventanaPrincipal.h y otro archivo ventanaPrincipal.cpp donde implementaremos sus métodos.
El fichero de cabecera quedaria así:

#include <QMainWindow>

class ventanaPrincipal : public QMainWindow
{
   Q_OBJECT
public:
   explicit ventanaPrincipal(QWidget *parent = 0);
   ~ventanaPrincipal();
public slots:
   void mostrarVentanaEmergente();
private:
};

y el fichero cpp asi:

#include <ventanaPrincipal.h>
#include <QMessageBox>
ventanaPrincipal::ventanaPrincipal(QWidget *parent) : QMainWindow(parent)
{

}
ventanaPrincipal::~ventanaPrincipal()
{

}
void ventanaPrincipal::mostrarVentanaEmergente()
{
   QMessageBox mensaje;
   mensaje.setText("Hola mundo!");
   mensaje.show();
}

Como se puede ver en el ejemplo, declaramos una clase ventanaPrincipal que hereda de QMainWindow y en public slots: definimos el lugar donde pondremos nuestros propios slots personalizados.
Los slots se declaran como cualquier método normal de la clase, en nuestro ejemplo he creado el slot mostrarVentanaEmergente() que mostrará una ventana emergente con el texto "Hola mundo!"
Con todo esto nuestro programa principal quedaria así:
#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
#include <ventanaPrincipal.h>
int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   ventanaPrincipal ventana;
   QPushButton *boton = new QPushButton(&ventana);
   boton->setText("Boton de prueba");
   a.connect(boton,SIGNAL(clicked()),&ventana,SLOT(mostrarVentanaEmergente()));
   ventana.show();
   return a.exec();
}
Lo único que hemos hecho es cambiar el tipo de ventana de QMainWindow a nuestra clase personalizada ventanaPrincipal y conectar el botón a nuestro recién creado slot.
Bueno hasta aquí por hoy, en próximas entregas enseñare como crear signals personalizados.
¡HASTA LA PRÓXIMA!
fuente original: http:\\albertopajuelo.blogspot.com
SALUDOS!