Está en la página 1de 26

Programacion en C++ con QT 4

Los autores
Fecha
Índice general

I Basico 3
1. Primeros pasos 4
1.1. Hola Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Haciendo conexiones . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. Sincronizando Widgets . . . . . . . . . . . . . . . . . . . . . . 7
1.4. Documentacion en linea . . . . . . . . . . . . . . . . . . . . . 10

2. Cuadros de diálogos 13
2.1. Subclase QDialog . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2. Señales y slots en profundidad . . . . . . . . . . . . . . . . . . 18
2.3. Diseño rápido de formularios . . . . . . . . . . . . . . . . . . . 20
2.4. Cambiando nuestros formularios . . . . . . . . . . . . . . . . . 20
2.5. Formularios dinámico . . . . . . . . . . . . . . . . . . . . . . . 20
2.6. Las clases Widget y cuadros de diálogo. . . . . . . . . . . . . . 20

3. Formulario principal 21
3.1. Clasicación QMainWindow . . . . . . . . . . . . . . . . . . . 21
3.2. Creación de menús y barras de herramientas . . . . . . . . . . 21
3.3. Conguración de la barra de estado . . . . . . . . . . . . . . . 21
3.4. Aplicación del menú Archivo . . . . . . . . . . . . . . . . . . . 21
3.5. Uso de cuadros de diálogo . . . . . . . . . . . . . . . . . . . . 21
3.6. Conguración de almacenamiento . . . . . . . . . . . . . . . . 21
3.7. Múltiples documentos . . . . . . . . . . . . . . . . . . . . . . . 21
3.8. Pantallas de inicio . . . . . . . . . . . . . . . . . . . . . . . . . 21

4. Implementando aplicaciones 22
4.1. El Widget central . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.2. Subclasicación QTableWidget . . . . . . . . . . . . . . . . . 22
4.3. Cargar y guardar . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.4. Aplicación del menú Editar . . . . . . . . . . . . . . . . . . . 22
4.5. Implementar los otros menús . . . . . . . . . . . . . . . . . . . 22

1
ÍNDICE GENERAL ÍNDICE GENERAL

4.6. Subclasicación QTableWidgetItem . . . . . . . . . . . . . . . 22

5. Creación de widgets personalizados 23


5.1. Personalización de widget . . . . . . . . . . . . . . . . . . . . 23
5.2. Subclasicación qwidget . . . . . . . . . . . . . . . . . . . . . 23
5.3. Integración de los Widgets con Qt Designer . . . . . . . . . . 23
5.4. Doble bufer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

II Intermedio 24
6. Los layout 25
6.1. Diseño de Widgets en un formulario . . . . . . . . . . . . . . . 25
6.2. Mas sobre layout . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.3. Los splitter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.4. Áreas de desplazamiento . . . . . . . . . . . . . . . . . . . . . 25
6.5. Dock y barras de herramientas . . . . . . . . . . . . . . . . . . 25
6.6. Interfaz de múltiples documentos . . . . . . . . . . . . . . . . 25

2
Parte I
Basico

3
Capítulo 1
Primeros pasos

En este capítulo se muestra cómo combinar C + + con la funcionalidad


proporcionada por Qt para crear un interfaz gráco de usuario (GUI).
También introduce dos ideas clave de Qt: "señales y slots" que en el
capítulo 2, veremos con más profundidad, en el capítulo 3 vamos a empezar
a construir una aplicación más realista.

1.1. Hola Qt
Vamos a empezar con un programa muy simple. En primer lugar, lo es-
tudiaremos línea por línea, como compilar y ejecutar las aplicaciones de Qt,
se sale del ámbito de este libro.

001 #include <QApplication>


002 #include <QLabel>
003 int main(int argc, char *argv[])
004 {
005 QApplication app(argc, argv);
006 QLabel *label = new QLabel("Hello Qt!");
007 label->show(); 008 return app.exec();
009 }

Las líneas 1 y 2 incluyen las deniciones de las clases QApplication y


QLabel. Para todas las clases de Qt, existe un archivo de cabecera con el
mismo nombre.

Línea 5 crea un objeto QApplication que gestionar los recursos de toda la


aplicación. El constructor tiene dos argumentos: argc y argv, Qt soporta
argumentos de línea de comandos.

4
1.1. HOLA QT CAPÍTULO 1. PRIMEROS PASOS

La línea 6 crea un widget QLabel que muestra "Hello Qt!". En terminología


Unix, un widget es un elemento visual en una interfaz de usuario.

El término se deriva de "Gadget ventana" y es el equivalente a "control" y


"contenedor", en Windows los botones, menús, barras de desplazamiento, y
los marcos son todos ejemplos de widgets.

Widgets pueden contener otros widgets, por ejemplo, el formulario de la


aplicación suele ser un widget que contiene QMenuBar, QToolBars,
QStatusBar, etc. La mayoría de las aplicaciones utilizan un QMainWindow
o un QDialog como formulario principal de la aplicación, pero Qt es tan
exible que cualquier widget puede ser un formulario. En este ejemplo, el
widget QLabel es el formulario de la aplicación.

La línea 7 hace visible el label, los objetos siempre se crean ocultos, por lo
que pueden personalizarse antes de mostrarlos, evitando así el parpadeo.

La línea 8 pasa el control a Qt. En este punto, el programa entra el bucle


de eventos. Esta es una especie de modo stand-by, el programa espera
acciones del usuario, como los clics de ratón o pulsaciones de teclas. Las
acciones del usuario generar eventos (también llamados "mensajes") que el
programa puede responder llamando a una o más funciones. Para
simplicar, no se llamo a delete en el objeto QLabel al nal de la función
main (). Pero esto es una malapraxis que no se recomienda.

Figura 1.1:

Antes de pasar a la siguiente ejemplo, vamos Reemplacemos la línea

QLabel *label = new QLabel("Hello Qt!");

por

QLabel *label = new QLabel("<h2><i>Hello</i>"


"<font color=red>Qt!</font></h2>");

Como ilustra el ejemplo, es fácil implementar una aplicación Qt utilizando


algún formato HTML.

5
1.2. HACIENDO CONEXIONES CAPÍTULO 1. PRIMEROS PASOS

Figura 1.2:

1.2. Haciendo conexiones


El segundo ejemplo muestra cómo responder a las acciones del usuario. La
aplicación consiste en un botón que el usuario puede pulsar para terminar.
El código fuente es muy similar al anterior, salvo que estamos utilizando un
QPushButton en lugar de una Qlabel como widget principal, y estamos
conectando una acción del usuario (haciendo clic en un botón) con una
función.

001 #include <QApplication>


002 #include <QPushButton>
003 int main(int argc, char *argv[])
004 {
005 QApplication app(argc, argv);
006 QPushButton *button = new QPushButton("Quit");
007 QObject::connect(button, SIGNAL(clicked()),
008 &app, SLOT(quit()));
009 button->show();
010 return app.exec();
011 }

Los widgets emiten señales para indicar que una acción del usuario o un
cambio de estado ha ocurrido.Por ejemplo, QPushButton emite una señal
 clicked() cuando el usuario hace clic en el ratón. Una señal se puede
conectar a una función (llamada slot), de modo, que cuando la señal es
emitida, se ejecuta automáticamente la función. En nuestro ejemplo,
conectamos la señal  clicked() del QPushButton a la función quit() , que
hace terminar nuestra aplicación.

007 QObject::connect(button, SIGNAL(clicked()), &app, SLOT(quit()));

6
1.3. SINCRONIZANDO WIDGETS CAPÍTULO 1. PRIMEROS PASOS

Figura 1.3:

1.3. Sincronizando Widgets


En esta sección vamos a crear una aplicación que demuestra cómo usar
señales y slots para sincronizar dos objetos.

Se le solicita la edad al usuario, el usuario puede introducir mediante la


manipulación de un cuadro de echa o un control deslizante.

La aplicación consta de tres widgets: un QSpinBox, un QSlider y un


QWidget. El QWidget es la ventana principal de la aplicación.

El QSpinBox y la QSlider se representan dentro de la QWidget, son hijos


de la QWidget. Por otra parte, podemos decir que el QWidget es el padre
de QSpinBox y la QSlider.

El constructor de QWidget tiene un parámetro QWidget que especica el


widget padre.

Figura 1.4:

001 #include <QApplication>


002 #include <QHBoxLayout>
003 #include <QSlider>
004 #include <QSpinBox>
005 int main(int argc, char *argv[])
006 {
007 QApplication app(argc, argv);
008 QWidget *window = new QWidget;
009 window->setWindowTitle("Enter Your Age");

7
1.3. SINCRONIZANDO WIDGETS CAPÍTULO 1. PRIMEROS PASOS

010 QSpinBox *spinBox = new QSpinBox;


011 QSlider *slider = new QSlider(Qt::Horizontal);
012 spinBox->setRange(0, 130);
013 slider->setRange(0, 130);
014 QObject::connect(spinBox, SIGNAL(valueChanged(int)),
015 slider, SLOT(setValue(int)));
016 QObject::connect(slider, SIGNAL(valueChanged(int)),
017 spinBox, SLOT(setValue(int)));
018 spinBox->setValue(35);
019 QHBoxLayout *layout = new QHBoxLayout;
020 layout->addWidget(spinBox);
021 layout->addWidget(slider);
022 window->setLayout(layout);
023 window->show();
024 return app.exec();
025 }

Las líneas 8 y 9 creamos el QWidget que servirá como ventana principal y


hacemos una llamada setWindowTitle () para establecer el texto en la
ventana.

Las líneas 10 y 11 crear un QSpinBox y el QSlider, las líneas 12 y 13


establecen sus rangos válidos.

Podemos asumir con seguridad que el usuario no tendra más de 130 años de
edad.

Las conexiones de los dos objetos están en las líneas de la 14 a 17 nos


asegura que ambos objetos están sincronizados de manera que siempre
muestran el mismo valor.

Cada vez que el valor de un widget cambia, su valueChanged (int) emite


una señal, y el setValue (int) del otro widget es llamado con el nuevo valor.

QObject::connect(spinBox, SIGNAL(valueChanged(int)),
slider, SLOT(setValue(int)));
QObject::connect(slider, SIGNAL(valueChanged(int)),
spinBox, SLOT(setValue(int)));

La línea 18 establece el valor a 35. Cuando esto sucede, el QSpinBox emite


la señal valueChanged con un argumento de 35 años.

8
1.3. SINCRONIZANDO WIDGETS CAPÍTULO 1. PRIMEROS PASOS

Este argumento es pasado a setValue QSlider, que establece el valor del


control deslizante a 35.

A continuación, emite una señal el control deslizante valueChanged, debido


a que su propio valor a cambiado, dispara setValue en cuadro de selección.

Pero en este punto, setValue no emite ninguna señal, ya que el valor del
cuadro ya está a 35.

Esto evita la recursividad innita. También, se ha introducido un nuevo


objeto los Layout que veremos en el siguiente capitulo.

Figura 1.5:

Las lneas 19 a 22 colocan los widgets QSpinBox y QSlider usando un gestor


de posicionamiento (layout manager).

Un Layout es un objeto que dene el tamaño y la posición de los widgets


que contiene.

Qt tiene tres tipos de Layout:

ˆ QHBoxLayout establece widgets horizontalmente de izquierda a derecha


(de derecha a izquierda algunas culturas).
ˆ QVBoxLayout establece widgets verticalmente de arriba hacia abajo.
ˆ QGridLayout establece widgets en una cuadrícula.

La linea 22, a parte de instalar el gestor de posicionamiento en la ventana,


hace que los widgets QSpinBox y QSlider se hagan hijos del widget de la
ventana (window)

9
1.4. DOCUMENTACION EN LINEA CAPÍTULO 1. PRIMEROS PASOS

Figura 1.6:

Como puede comprobar tanto el QSpinBox como QSlider aparecen


perfectamente justicado de lado a lado. Esto se debe al QHBoxLayout,
asigna automáticamente las posiciones y el tamaño a los widgets que
contiene, basado en sus necesidades. Los gestores de posicionamiento nos
facilitan muchisimo las cosas, puesto que gestionan de forma automatica
tanto la posicion como el tamaño de los widget. Este enfoque de Qt para
construir interfaces es fácil de entender y muy exible.

La forma más común que utilizan los programadores es crear instancias a


los layout necesarios y establezca sus propiedades según sea necesario.

1.4. Documentacion en linea


La documentación de referencia de Qt es una herramienta esencial para
cualquier desarrollador de Qt, ya que que abarca todas las clases y la
función en Qt.

Este libro hace uso de muchas clases y funciones, pero no cubre todos ellos,
ni proporciona todos los detalles. Para obtener mas informacion de Qt,
debe familiarizarse con la documentación de referencia lo antes posible.

La documentación está disponible en formato HTML en el documento de


Qt / html y se pueden leer con cualquier navegador web. También puede
usar Qt Assistant, el Qt navegador de ayuda, que tiene una potente
búsqueda e indización características que hacen que sea más rápido y fácil
que un navegador web. Para iniciar Qt Assistant, haga clic en 10 1.
Primeros pasos Qt de Trolltech v4.xy | Asistente en el menú Inicioen
Windows, o en la línea de comandos en Unix, o haga doble clic en Asistente
en el Mac OS X Finder.

Los enlaces en la sección "Referencia de la API" en la página principal


proporcionan diferentes maneras de navegar por las clases de Qt.

10
1.4. DOCUMENTACION EN LINEA CAPÍTULO 1. PRIMEROS PASOS

Figura 1.7:

Tenga en cuenta las funciones heredadas de las clases bases, por ejemplo,
QPushButton no tiene una funcion show () , sino que es heredada de
QWidget. La gura 1.8 muestra las clases que hemos visto hasta ahora y
como se relacionan.

Figura 1.8:

La documentación de referencia para la versión actual de Qt y para


versiones anteriores está disponible en http://doc.trolltech.com/. Este
sitio también tiene artículos y diferentes recursos.

11
1.4. DOCUMENTACION EN LINEA CAPÍTULO 1. PRIMEROS PASOS

Tambien le sugerimos que visite http://www.zonaqt.com/ el objetivo de


este sitio es proporcionar un espacio para que los usuarios de Qt que
hablamos español, podamos conocernos, comunicarnos, apoyarnos y
mantenernos informados.

Pretendemos que este sitio sea el punto central de encuentro para los
desarrolladores de Qt de habla hispana, por ello publicaremos y ofreceremos
distintos tipos de información y herramientas con el n de que puedas
aprender, ayudar y mantenerte informado, con sólo visitar este sitio y sin
tener que estar buscando en toda la red. Para ello, Zona Qt contará con las
siguientes secciones:

Foros de discusión: Aquí podrás conocer y conversar directamente con


otros usuarios de Qt que hablan tu idioma, solicitar su ayuda para
resolver un problema, buscar colaboradores para un proyecto, pedir
opiniones y muchas cosas más.

Tutoriales: Los colaboradores del sitio publicaremos tutoriales y


howtos sobre Qt, de todos los temas y niveles y en varios formatos,
como texto y video. Actualmente estamos trabajando en un tutorial
basado en los temas del examen de certicación en Qt :

Noticias: Publicaremos traducciones de las noticias y anuncios


ociales por parte de Nokia (compañia propietaria de Qt) y los
desarrolladores de Qt. También buscaremos información adicional,
como la revisión de nuevas e impresionantes aplicaciones desarrolladas
con Qt o información sobre eventos relacionados con Qt como talleres
y conferencias.

Galería de Proyectos: Todos los usuarios del sitio están invitados


publicar un proyecto que hayan creado o a crear uno nuevo para
compartirlo con la comunidad, puede ser un proyecto realizado sólo
para aprender o un proyecto grande con el objetivo de ser lanzado.
Esto lo hacemos con el n de mostrar a los usuarios nuevos de Qt
todas las cosas interesantes que se pueden crear, de manera muy
sencilla, con este framework.

12
Capítulo 2
Cuadros de diálogos

Este capítulo le enseñará cómo crear cuadros de diálogo utilizando Qt.


Los cuadros de dialogo nos permiten establecer opciones, denir valores o
elegir entre distintas opciones.
Se les llama cuadros de diálogo, o simplemente "diálogos", porque propor-
cionan un medio por el cual los usuarios y las aplicaciones pueden interactuar
entre sí.
La mayoría de aplicaciones grácas consisten en una ventana principal
con una barra de menús y barra de herramientas, junto con docenas de diál-
ogos que complementan la ventana principal. También es posible la creación
de aplicaciones de diálogo que respondan directamente a las elecciones del
usuario realizando las acciones apropiadas (por ejemplo, una aplicación cal-
culadora).
Vamos a crear nuestro primer cuadro de diálogo, lo haremos mediante
código para mostrar cómo se hace. A continuación veremos cómo crear cuadros
de diálogo utilizando Qt Designer, la herramienta de diseño visual de Qt. Us-
ando Qt Designer es más rápido que la codicación manual y es mas fácil
para probar diversos diseños y para cambiar los diseños nales.

2.1. Subclase QDialog


Nuestro primer ejemplo es un cuadro de diálogo Find buscar escrito
enteramente en C + +. Implementaremos el diálogo como una clase inde-
pendiente. Esto proporciona una organización independiente y autónoma de
los componentes, con sus propias señales y slots.

13
2.1. SUBCLASE QDIALOG CAPÍTULO 2. CUADROS DE DIÁLOGOS

Figura 2.1:

El código fuente se distribuye a través de dos archivos: nddialog.h y


nddialog.cpp.

nddialog.h.

001 #ifndef FINDDIALOG_H


002 #define FINDDIALOG_H
003 #include <QDialog>
004 class QCheckBox;
005 class QLabel;
006 class QLineEdit;
007 class QPushButton;

Las lneas 1, 2 y 27 impiden que el chero de cabecera pueda ser incluido


varias veces.

La lnea 3 incluye la clase base para los dialogos Qt: QDialog (que es
subclase de QWidget).

Las lneas 4 a 7 son declaraciones adelantadas (forward declarations) de las


clases que se usaran mas adelante.

008 class FindDialog : public QDialog


009 {
010 Q_OBJECT
011 public:
012 FindDialog(QWidget *parent = 0);

La linea 8 dene la clase FindDialog como subclase de QDialog:


En la lnea 10 se incluye la macro Q_OBJECT, que es necesaria en todas
las clases que denen sus propias señales o slots.

14
2.1. SUBCLASE QDIALOG CAPÍTULO 2. CUADROS DE DIÁLOGOS

Esto hara que el makele generado por qmake incluya reglas especiales
para ejecutar moc (el compilador de meta-objetos) Para que moc funcione
correctamente, es necesario que pongamos la denicion de la clase en un chero
.h separado del chero de implementacion. moc genera codigo C++ que incluye
este chero .h.
La denicion del constructor de FindDialog es tpico en clases de widgets
Qt: parent especica el widget padre. parent es por defecto un puntero nulo,
que signica que el dialogo no tiene ningun padre

013 signals:
014 void findNext(const QString &str, Qt::CaseSensitivity cs);
015 void findPrevious(const QString &str, Qt::CaseSensitivity cs);

La seccion signals de la lnea 13 a 15 declara dos señales que el dialogo emite


cuando el usuario pincha el boton Find.
Si esta seleccionada la opcion Search backward, se emite ndPrevious().
En caso contrario se emite ndNext()
La palabra signals es una macro que el preprocesador de C++ convertira
en codigo C++.
Qt::CaseSensitivity es un tipo enumerado (enum) que puede tomar los
valores Qt::CaseSensitive y Qt::CaseInsensitive.

016 private slots:


017 void findClicked();
018 void enableFindButton(const QString &text);
019 private:
020 QLabel *label;
021 QLineEdit *lineEdit;
022 QCheckBox *caseCheckBox;
023 QCheckBox *backwardCheckBox;
024 QPushButton *findButton;
025 QPushButton *closeButton;
026 };
027 #endif

En las lneas 16 a 18 se declaran dos slots (en la seccion privada de la clase).

La palabra slots es tambien una macro.

En las lineas 19 a 25 se declaran punteros a los widgets hijos del dialogo


para usarlos luego en los slots.

15
2.1. SUBCLASE QDIALOG CAPÍTULO 2. CUADROS DE DIÁLOGOS

Finddialog.cpp

001 #include <QtGui>


002 #include "finddialog.h"

Qt contiene varios modulos, cada uno en su propia librera: QtCore, QtGui,


QtNetwork, QtOpenGL, QtSql, QtSvg, QtXml, etc.

El chero de cabecera <QtGui> contiene la denicion de todas las clases de


QtCore y QtGui. Su inclusion evita tener que incluir cada clase
individualmente.

003 FindDialog::FindDialog(QWidget *parent)


004 : QDialog(parent)
005 {
006 label = new QLabel(tr("Find &what:"));
007 lineEdit = new QLineEdit;
008 label->setBuddy(lineEdit);
009 caseCheckBox = new QCheckBox(tr("Match &case"));
010 backwardCheckBox = new QCheckBox(tr("Search &backward"));
011 findButton = new QPushButton(tr("&Find"));
012 findButton->setDefault(true);
013 findButton->setEnabled(false);
014 closeButton = new QPushButton(tr("Close"));

En la lnea 4 se pasa el parametro parent al constructor de la clase base.

La funcion tr(cadena) marca la cadena para ser traducida al lenguaje


nativo. (esta declarada en la clase QObject y todas las clases que contengan
la macro Q_OBJECT)

En la cadena usada al crear algunos objetos (lineas 6, 9, 10, 11) se usa el


caracter '&' para denir una tecla aceleradora: Alt+tecla.

La linea 8 hace que lineEdit sea el amigote (buddy) de label: al pulsar


Alt+W el foco del teclado lo obtiene lineEdit.

En la lnea 12, el boton Find se hace el boton por defecto (es aquel que se
ejecuta al pulsar la tecla Enter).

La lnea 13 desactiva el boton Find (aparece en grisaceo y no responde a los


clicks)

16
2.1. SUBCLASE QDIALOG CAPÍTULO 2. CUADROS DE DIÁLOGOS

015 connect(lineEdit, SIGNAL(textChanged(const QString &)),


016 this, SLOT(enableFindButton(const QString &)));
017 connect(findButton, SIGNAL(clicked()),
018 this, SLOT(findClicked()));
019 connect(closeButton, SIGNAL(clicked()),
020 this, SLOT(close()));

Las lineas 15 a 20 conectan señales con slots:

Fijarse que no es necesario poner QObject:: delante de las llamadas a


connect() ya que QObject es una clase ancestral de FindDialog.

El slot enableFindButton(const QString &) se llama cuando cambia el


texto de lineEdit.

El slot ndClicked(const QString &) se llama cuando el usuario pincha el


boton Find.

El slot close() (heredado de QWidget, oculta el widget sin borrarlo) se


llama cuando el usuario pincha el boton Close.

021 QHBoxLayout *topLeftLayout = new QHBoxLayout;


022 topLeftLayout->addWidget(label);
023 topLeftLayout->addWidget(lineEdit);
024 QVBoxLayout *leftLayout = new QVBoxLayout;
025 leftLayout->addLayout(topLeftLayout);
026 leftLayout->addWidget(caseCheckBox);
027 leftLayout->addWidget(backwardCheckBox);
028 QVBoxLayout *rightLayout = new QVBoxLayout;
029 rightLayout->addWidget(findButton);
030 rightLayout->addWidget(closeButton);
031 rightLayout->addStretch();
032 QHBoxLayout *mainLayout = new QHBoxLayout;
033 mainLayout->addLayout(leftLayout);
034 mainLayout->addLayout(rightLayout);
035 setLayout(mainLayout);

Las lneas 21 a 35 colocan los widgets hijos usando gestores de


posicionamiento.

Layouts pueden contener widgets y otros layouts.

17
2.2. SEÑALES Y SLOTS EN CAPÍTULO
PROFUNDIDAD
2. CUADROS DE DIÁLOGOS

Combinando QHBoxLayouts, QVBoxLayouts y QGridLayouts podemos


construir dialogos muy sosticados.

Figura 2.2:

Los layouts no son widgets (heredan de QLayout que a su vez hereda de


QObject) Al incluir un layout en otro (lneas 25, 33 y 34), los sublayouts se
hacen sus hijos.

Al instalar en el dialogo (lnea 35) el layout principal, este y todos los


widgets de la jerarqua de layouts se hacen hijos del dialogo.

2.2. Señales y slots en profundidad


El mecanismo de señales y slots en Qt son fundamentales para la
programación y es en este capitulo donde se trata en profundidad.

Ya hemos conectado algunas señales y slots, declarandolas e


implementadolas.

Recordemos como funcionan. Los slots son casi idénticos a las funciones
miembro de C + +. Pueden ser virtual, se puede sobrecargar, pueden ser
públicas, protegidas o privadas, y pueden ser llamadas como otra funcion de
C + +, y sus parámetros pueden ser de cualquier tipo valido.

La diferencia es que un slot se puede conectar a un señal, en cuyo caso se


llama automáticamente cada vez que se emite la señal.

La sentencia connect() tiene la siguiente forma:

18
2.2. SEÑALES Y SLOTS EN CAPÍTULO
PROFUNDIDAD
2. CUADROS DE DIÁLOGOS

connect(sender, SIGNAL(signal), receiver, SLOT(slot));

Donde sender y receiver son punteros a QObjects.

Las macros SIGNAL() y SLOT() convierten su argumento en un string.

Una señal puede conectarse a varios slots:

connect(slider, SIGNAL(valueChanged(int)), spinBox, SLOT(setValue(int)));


connect(slider, SIGNAL(valueChanged(int)), this,
SLOT(updateStatusBarIndicator(int)));

Varias señales pueden conectarse al mismo slot:

connect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));


connect(calculator, SIGNAL(divisionByZero()), this,
SLOT(handleMathError()));

Una señal puede conectarse a otra señal:

connect(lineEdit, SIGNAL(textChanged(const QString &)), this,


SIGNAL(updateRecord(const QString &)));

Las conexiones pueden borrarse (aunque no se usa demasiado):

disconnect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));

Para conectar una señnal con un slot u otra señal, ambos deben tener los
mismos tipos de parametros y en el mismo orden:

connect(ftp, SIGNAL(rawCommandReply(int, const QString &)), this,


SLOT(processReply(int, const QString &)));

Como excepcion, si una señal tiene mas parametros que el slot, se ignoran
los parametros adicionales:

connect(ftp, SIGNAL(rawCommandReply(int, const QString &)), this,


SLOT(checkErrorCode(int)));

19
2.3. DISEÑO RÁPIDO DE FORMULARIOS
CAPÍTULO 2. CUADROS DE DIÁLOGOS

No deben incluirse los nombres de los parametros de las señales o


slots al usar connect.

2.3. Diseño rápido de formularios


Hay muchos programadores que desarrollan toda la interface mediante lin-
eas de codigo, que es una forma muy extendida, sin embargo, otros preeren
usar un en foque visual, resulta más natural y rápido que a mano, además,
es una forma más logica por que siempre vamos viendo como va nuestro dis-
eño. Qt Designer amplía las opciones disponibles para los programadores,
proporcionando una herramienta de diseño visual. Qt Designer se puede usar
para desarrollar toda o parte de la aplicación. En esta sección, vamos a usar
Qt Designer para crear nuestros formularios, tanto si lo hacemos mediante
codigo o usando el diseñador, debemos tener tres reglas fundamentales:
ˆ Crear e inicializar los widgets hijos.
ˆ Añadir los widgets en lo layouts.
ˆ Establecer el orden de tabulacion.
ˆ Establecer las conexiones de señales y slot.
ˆ Implementar los slot del formulario.

2.4. Cambiando nuestros formularios


2.5. Formularios dinámico
2.6. Las clases Widget y cuadros de diálogo.

20
Capítulo 3
Formulario principal

3.1. Clasicación QMainWindow


3.2. Creación de menús y barras de herramien-
tas
3.3. Conguración de la barra de estado
3.4. Aplicación del menú Archivo
3.5. Uso de cuadros de diálogo
3.6. Conguración de almacenamiento
3.7. Múltiples documentos
3.8. Pantallas de inicio

21
Capítulo 4
Implementando aplicaciones

4.1. El Widget central


4.2. Subclasicación QTableWidget
4.3. Cargar y guardar
4.4. Aplicación del menú Editar
4.5. Implementar los otros menús
4.6. Subclasicación QTableWidgetItem

22
Capítulo 5
Creación de widgets
personalizados

5.1. Personalización de widget


5.2. Subclasicación qwidget
5.3. Integración de los Widgets con Qt Design-
er
5.4. Doble bufer

23
Parte II
Intermedio

24
Capítulo 6
Los layout

6.1. Diseño de Widgets en un formulario


6.2. Mas sobre layout
6.3. Los splitter
6.4. Áreas de desplazamiento
6.5. Dock y barras de herramientas
6.6. Interfaz de múltiples documentos

25