Qt Quick Controles - Tutorial de chat
Este tutorial muestra cómo crear una aplicación de chat básica utilizando los controles de Qt Quick. También explica cómo integrar una base de datos SQL en una aplicación Qt.
Capítulo 1: Configuración
A la hora de configurar un nuevo proyecto, lo más sencillo es utilizar Qt Creator. Para este proyecto, hemos elegido la plantilla de aplicación «Qt Quick », que crea una aplicación básica de tipo «Hello World» con los siguientes archivos:
CMakeLists.txt- Indica a CMake cómo debe compilarse nuestro proyectoMain.qml- Proporciona una interfaz de usuario predeterminada que contiene una ventana vacíamain.cpp- Cargamain.qmlqtquickcontrols2.conf- Indica a la aplicación qué estilo debe utilizar
main.cpp
El código predeterminado de main.cpp tiene dos inclusiones:
#include <QGuiApplication>
#include <QQmlApplicationEngine>La primera nos da acceso a ` QGuiApplication`. Todas las aplicaciones Qt requieren un objeto de aplicación, pero el tipo concreto depende de lo que haga la aplicación. ` QCoreApplication ` es suficiente para aplicaciones no gráficas. ` QGuiApplication ` es suficiente para aplicaciones gráficas que no utilizan Qt Widgets, mientras que QApplication es necesario para aquellas que sí lo hacen.
La segunda inclusión hace que QQmlApplicationEngine esté disponible, lo que nos permite cargar nuestro QML.
Dentro de main(), configuramos el objeto de aplicación y el motor QML:
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.loadFromModule("chattutorial", "Main");
return app.exec();
}QQmlApplicationEngine es un práctico envoltorio de QQmlEngine, que proporciona la función loadFromModule para cargar fácilmente el QML de una aplicación. También facilita el uso de los selectores de archivos.
Una vez que hayamos configurado todo en C++, podemos pasar a la interfaz de usuario en QML.
Main.qml
Modifiquemos el código QML predeterminado para adaptarlo a nuestras necesidades.
import QtQuick
import QtQuick.ControlsVerás que el Qt Quick módulo ya se ha importado. Esto nos da acceso a primitivas gráficas como Item, Rectangle, Text, etc. Para ver la lista completa de tipos, consulta la Qt Quick QML Types documentación.
Añade una importación del módulo « Qt Quick Controls». Entre otras cosas, esto proporciona acceso a ` ApplicationWindow`, que sustituirá al tipo raíz existente, ` Window`:
ApplicationWindow {
width: 540
height: 960
visible: true
...
}ApplicationWindow es un ` Window ` con algunas funciones adicionales que facilitan la creación de un ` header ` y un ` footer`. También proporciona la base para ` popups ` y admite algunos estilos básicos, como el fondo ` color`.
Hay tres propiedades que casi siempre se configuran al utilizar ApplicationWindow: width, height y visible. Una vez configuradas, disponemos de una ventana vacía con el tamaño adecuado, lista para ser rellenada con contenido.
Nota: Se ha eliminadola propiedad title del código predeterminado.
La primera «pantalla» de nuestra aplicación será una lista de contactos. Sería conveniente incluir algún texto en la parte superior de cada pantalla que describa su finalidad. Las propiedades header y footer de ApplicationWindow podrían servir en este caso. Tienen algunas características que las hacen ideales para elementos que deben mostrarse en todas las pantallas de una aplicación:
- Están ancladas a la parte superior e inferior de la ventana, respectivamente.
- Ocupan todo el ancho de la ventana.
Sin embargo, cuando el contenido del encabezado y el pie de página varía en función de la pantalla que esté viendo el usuario, resulta mucho más sencillo utilizar Page. Por ahora, solo añadiremos una página, pero en el siguiente capítulo mostraremos cómo navegar entre varias páginas.
Page {
anchors.fill: parent
header: Label {
padding: 10
text: qsTr("Contacts")
font.pixelSize: 20
horizontalAlignment: Text.AlignHCenter
verticalAlignment: Text.AlignVCenter
}
}En primer lugar, añadimos una página (Page), cuyo tamaño se ajusta para ocupar todo el espacio de la ventana mediante la propiedad anchors.fill.
A continuación, asignamos un valor a la propiedad ` Label ` de su propiedad ` header `. La clase `Label` hereda del elemento primitivo ` Text ` del módulo ` Qt Quick `, añadiéndole estilos y herencia ` font `. Esto significa que una etiqueta (`Label`) puede tener un aspecto diferente en función del estilo que se utilice, y también puede propagar su tamaño en píxeles a sus elementos hijos.
Queremos que haya cierta distancia entre la parte superior de la ventana de la aplicación y el texto, por lo que configuramos la propiedad ` padding `. Esto asigna espacio adicional a cada lado de la etiqueta (dentro de sus límites). También podemos configurar explícitamente las propiedades ` topPadding ` y ` bottomPadding ` en su lugar.
Configuramos el texto de la etiqueta mediante la función qsTr(), lo que garantiza que el texto pueda ser traducido por el sistema de traducción de Qt. Es una buena práctica a seguir para el texto que es visible para los usuarios finales de tu aplicación.
Por defecto, el texto se alinea verticalmente en la parte superior de sus límites, mientras que la alineación horizontal depende de la dirección natural del texto; por ejemplo, el texto que se lee de izquierda a derecha se alineará a la izquierda. Si utilizáramos estos valores predeterminados, nuestro texto quedaría en la esquina superior izquierda de la ventana. Esto no es lo más adecuado para un encabezado, por lo que alineamos el texto al centro de sus límites, tanto horizontal como verticalmente.
El archivo del proyecto
El archivo CMakeLists.txt contiene toda la información que necesita CMake para compilar nuestro proyecto en un ejecutable que podamos ejecutar.
Para obtener una explicación detallada de este archivo, consulta «Compilación de una aplicación QML».
Así es como se ve actualmente nuestra aplicación al ejecutarla:

Capítulo 2: Listas
En este capítulo, explicaremos cómo crear una lista de elementos interactivos utilizando ListView y ItemDelegate.
ListView Qt Quick procede del módulo y muestra una lista de elementos rellenada a partir de un modelo. procede del módulo Controls y proporciona un elemento de vista estándar para su uso en vistas y controles como y . Por ejemplo, cada puede mostrar texto, marcarse o desmarcarse y reaccionar a los clics del ratón. ItemDelegate Qt Quick ListView ComboBox ItemDelegate
Este es nuestro ListView:
...
ListView {
id: listView
anchors.fill: parent
topMargin: 48
leftMargin: 48
bottomMargin: 48
rightMargin: 48
spacing: 20
model: ["Albert Einstein", "Ernest Hemingway", "Hans Gude"]
delegate: ItemDelegate {
id: contactDelegate
text: modelData
width: listView.width - listView.leftMargin - listView.rightMargin
height: avatar.implicitHeight
leftPadding: avatar.implicitWidth + 32
required property string modelData
Image {
id: avatar
source: "images/" + contactDelegate.modelData.replace(" ", "_") + ".png"
}
}
}
...Tamaño y posición
Lo primero que hacemos es establecer un tamaño para la vista. Debe ocupar todo el espacio disponible en la página, por lo que utilizamos anchors.fill. Ten en cuenta que Page se asegura de que su cabecera y su pie de página tengan suficiente espacio reservado, por lo que, en este caso, la vista se situará debajo de la cabecera, por ejemplo.
A continuación, establecemos ` margins ` alrededor del ` ListView ` para dejar algo de distancia entre este y los bordes de la ventana. Las propiedades de margen reservan espacio dentro de los límites de la vista, lo que significa que el usuario aún puede «deslizar» el dedo por las áreas vacías.
Los elementos deben estar bien espaciados dentro de la vista, por lo que la propiedad ` spacing ` se establece en ` 20`.
Modelo
Para rellenar rápidamente la vista con algunos elementos, hemos utilizado una matriz de JavaScript como modelo. Uno de los mayores puntos fuertes de QML es su capacidad para crear prototipos de aplicaciones con extrema rapidez, y este es un ejemplo de ello. También es posible asignar simplemente un número a la propiedad del modelo para indicar cuántos elementos se necesitan. Por ejemplo, si se asigna « 10 » a la propiedad « model », el texto que se mostrará para cada elemento será un número comprendido entre « 0 » y « 9 ».
Sin embargo, una vez que la aplicación supera la fase de prototipo, pronto se hace necesario utilizar datos reales. Para ello, lo mejor es utilizar un modelo adecuado en C++ de subclassing QAbstractItemModel.
Delegado
Pasemos a delegate. Asignamos el texto correspondiente del modelo a la propiedad text de ItemDelegate. La forma exacta en que los datos del modelo se ponen a disposición de cada delegado depende del tipo de modelo utilizado. Consulta «Modelos y vistas» en Qt Quick para obtener más información.
En nuestra aplicación, el ancho de cada elemento de la vista debe ser el mismo que el ancho de la vista. Esto garantiza que el usuario disponga de mucho espacio para seleccionar un contacto de la lista, lo cual es un factor importante en dispositivos con pantallas táctiles pequeñas, como los teléfonos móviles. Sin embargo, el ancho de la vista incluye nuestros márgenes de píxeles « 48 », por lo que debemos tenerlo en cuenta al asignar el valor a la propiedad «width».
A continuación, definimos un Image. Este mostrará una imagen del contacto del usuario. La imagen tendrá un 40 píxeles de ancho y 40 píxeles de alto. Basaremos la altura del delegado en la altura de la imagen, para que no quede ningún espacio vertical vacío.

Capítulo 3: Navegación
En este capítulo, aprenderás a utilizar StackView para navegar entre páginas de una aplicación. Aquí tienes el código revisado de main.qml:
import QtQuick.Controls
ApplicationWindow {
id: window
width: 540
height: 960
visible: true
StackView {
id: stackView
anchors.fill: parent
initialItem: ContactPage {}
}
}Navegación con StackView
Como su nombre indica, StackView proporciona una navegación basada en una pila. El último elemento que se «empuja» a la pila es el primero en ser extraído, y el elemento situado en la parte superior es siempre el que está visible.
Del mismo modo que hicimos con `Page`, le indicamos a ` StackView ` que ocupe toda la ventana de la aplicación. Lo único que queda por hacer después es proporcionarle un elemento para mostrar, mediante ` initialItem`. ` StackView ` acepta ` items`, ` components ` y ` URLs`.
Verás que hemos trasladado el código de la lista de contactos a ContactPage.qml. Es recomendable hacerlo en cuanto tengas una idea general de las pantallas que incluirá tu aplicación. De este modo, no solo se facilita la lectura del código, sino que se garantiza que los elementos solo se instancien desde un componente determinado cuando sea absolutamente necesario, lo que reduce el consumo de memoria.
Nota: Qt Creator ofrece varias soluciones rápidas y prácticas para QML, una de las cuales te permite trasladar un bloque de código a un archivo independiente (Alt + Enter > Move Component into Separate File).
Otro aspecto a tener en cuenta al utilizar ListView es si referirnos a él mediante id o utilizar la propiedad adjunta ListView.view. El mejor enfoque depende de varios factores. Asignar un identificador a la vista dará lugar a expresiones de enlace más cortas y eficientes, ya que la propiedad adjunta tiene una sobrecarga muy pequeña. Sin embargo, si tienes pensado reutilizar el delegado en otras vistas, es mejor utilizar las propiedades adjuntas para evitar vincular el delegado a una vista concreta. Por ejemplo, utilizando las propiedades adjuntas, la asignación width en nuestro delegado queda así:
width: ListView.view.width - ListView.view.leftMargin - ListView.view.rightMarginEn el capítulo 2, añadimos un ` ListView ` debajo del encabezado. Si ejecutas la aplicación de ese capítulo, verás que el contenido de la vista se puede desplazar por encima del encabezado:
Esto no queda muy bien, sobre todo si el texto de los delegados es lo suficientemente largo como para llegar al texto del encabezado. Lo ideal sería tener un bloque de color sólido debajo del texto del encabezado, pero por encima de la vista. Esto garantiza que el contenido de la vista de lista no interfiera visualmente con el contenido del encabezado. Ten en cuenta que también es posible conseguirlo estableciendo la propiedad ` clip ` de la vista en ` true`, pero al hacerlo, can affect performance.
ToolBar es la herramienta adecuada para esta tarea. Se trata de un contenedor de acciones y controles tanto de toda la aplicación como sensibles al contexto, tales como botones de navegación y campos de búsqueda. Lo mejor de todo es que tiene un color de fondo que, como es habitual, proviene del estilo de la aplicación. Aquí lo vemos en acción:
No tiene un diseño propio, así que nosotros mismos centramos la etiqueta en su interior.
El resto del código es el mismo que en el capítulo 2, salvo que hemos aprovechado la señal « clicked » para añadir la página siguiente a la «stackview»:
onClicked: root.StackView.view.push("ConversationPage.qml", { inConversationWith: modelData })Al insertar un ` Component ` o un ` url ` en ` StackView`, a menudo es necesario inicializar el elemento (que eventualmente se instanciará) con algunas variables. La función ` push()` de ` StackView` tiene esto en cuenta, al aceptar un objeto JavaScript como segundo argumento. Utilizamos esto para proporcionar a la página siguiente el nombre de un contacto, que luego utiliza para mostrar la conversación correspondiente. Fíjate en la sintaxis root.StackView.view.push; esto es necesario debido al funcionamiento de las propiedades adjuntas.
Repasemos el archivo ` ConversationPage.qml`, empezando por las importaciones:
import QtQuick
import QtQuick.Layouts
import QtQuick.ControlsSon las mismas que antes, salvo por la incorporación de la importación de ` QtQuick.Layouts `, que veremos en breve.
Page {
id: root
property string inConversationWith
header: ToolBar {
ToolButton {
text: qsTr("Back")
anchors.left: parent.left
anchors.leftMargin: 10
anchors.verticalCenter: parent.verticalCenter
onClicked: root.StackView.view.pop()
}
Label {
id: pageTitle
text: root.inConversationWith
font.pixelSize: 20
anchors.centerIn: parent
}
}
...El elemento raíz de este componente es otra página (Page), que tiene una propiedad personalizada llamada inConversationWith. Por ahora, esta propiedad simplemente determinará qué texto se muestra en la etiqueta del encabezado. Más adelante, la utilizaremos en la consulta SQL que rellena la lista de mensajes de la conversación.
Para que el usuario pueda volver a la página de Contactos, añadimos un « ToolButton » que, al hacer clic en él, llama a ` pop()`. Un « ToolButton » es funcionalmente similar a ` Button`, pero ofrece un aspecto más adecuado dentro de un « ToolBar ».
Hay dos formas de distribuir elementos en QML: los posicionadores de elementos (Item Positioners ) y los diseños de posición (Qt Quick ). Los posicionadores de elementos (Row, Column, etc.) resultan útiles en situaciones en las que se conoce o es fijo el tamaño de los elementos, y lo único que se necesita es colocarlos de forma ordenada en una determinada formación. Los diseños de Qt Quick permiten tanto colocar como redimensionar los elementos, lo que los hace muy adecuados para interfaces de usuario redimensionables. A continuación, utilizamos ColumnLayout para distribuir verticalmente un ListView y un Pane:
ColumnLayout {
anchors.fill: parent
ListView {
id: listView
Layout.fillWidth: true
Layout.fillHeight: true
...
}
...
Pane {
id: pane
Layout.fillWidth: true
...
}Un «pane» es, básicamente, un rectángulo cuyo color se deriva del estilo de la aplicación. Es similar a « Frame », con la única diferencia de que no tiene trazo alrededor del borde.
Los elementos que son hijos directos de un diseño tienen varios « attached properties » a su disposición. Utilizamos « Layout.fillWidth » y « Layout.fillHeight » en el « ListView » para asegurarnos de que ocupe todo el espacio posible dentro del « ColumnLayout ». Lo mismo se hace con el «Pane». Como « ColumnLayout » es un diseño vertical, no hay elementos a la izquierda ni a la derecha de cada elemento secundario, por lo que cada elemento ocupará todo el ancho del diseño.
Por otro lado, la instrucción « Layout.fillHeight » en el « ListView » le permitirá ocupar el espacio restante que queda tras acomodar el «Pane».
Veamos la vista de lista con más detalle:
ListView {
id: listView
Layout.fillWidth: true
Layout.fillHeight: true
Layout.margins: pane.leftPadding + messageField.leftPadding
displayMarginBeginning: 40
displayMarginEnd: 40
verticalLayoutDirection: ListView.BottomToTop
spacing: 12
model: 10
delegate: Row {
id: messageDelegate
anchors.right: sentByMe ? listView.contentItem.right : undefined
spacing: 6
required property int index
readonly property bool sentByMe: index % 2 == 0
Rectangle {
id: avatar
width: height
height: parent.height
color: "grey"
visible: !messageDelegate.sentByMe
}
Rectangle {
width: 80
height: 40
color: messageDelegate.sentByMe ? "lightgrey" : "steelblue"
Label {
anchors.centerIn: parent
text: messageDelegate.index
color: messageDelegate.sentByMe ? "black" : "white"
}
}
}
ScrollBar.vertical: ScrollBar {}
}Tras ajustar el ancho y la altura a los de su elemento padre, también hemos establecido algunos márgenes en la vista. Esto nos proporciona una buena alineación con el texto de marcador de posición del campo «redactar mensaje»:

A continuación, establecemos ` displayMarginBeginning ` y ` displayMarginEnd`. Estas propiedades garantizan que los delegados situados fuera de los límites de la vista no desaparezcan al desplazarse por los bordes de la misma. La forma más fácil de entenderlo es comentar estas propiedades y observar qué ocurre al desplazarse por la vista.
A continuación, invertimos la dirección vertical de la vista, de modo que los primeros elementos queden en la parte inferior. Los delegados están separados entre sí por 12 píxeles, y se asigna un modelo «ficticio» con fines de prueba, hasta que implementemos el modelo real en el capítulo 4.
Dentro del delegado, declaramos un ` Row ` como elemento raíz, ya que queremos que el avatar vaya seguido del contenido del mensaje, tal y como se muestra en la imagen anterior.
Los mensajes enviados por el usuario deben distinguirse de los enviados por un contacto. Por ahora, establecemos una propiedad ficticia ` sentByMe`, que simplemente utiliza el índice del delegado para alternar entre los diferentes autores. Mediante esta propiedad, distinguimos entre los diferentes autores de tres maneras:
- Los mensajes enviados por el usuario se alinean a la derecha de la pantalla estableciendo
anchors.rightenlistView.contentItem.right. - Al establecer la propiedad `
visible` del avatar (que, por ahora, es simplemente un `Rectangle`) en función de `sentByMe`, solo lo mostramos si el mensaje lo ha enviado un contacto. - Cambiamos el color del rectángulo en función del autor. Como no queremos mostrar texto oscuro sobre un fondo oscuro, y viceversa, también establecemos el color del texto en función de quién sea el autor. En el capítulo 5 veremos cómo los estilos se encargan de aspectos como este por nosotros.
En la parte inferior de la pantalla, colocamos un elemento « TextArea » para permitir la introducción de texto de varias líneas y un botón para enviar el mensaje. Utilizamos «Pane» para cubrir el área situada debajo de estos dos elementos, del mismo modo que utilizamos « ToolBar » para evitar que el contenido de la vista de lista interfiera con el encabezado de la página:
Pane {
id: pane
Layout.fillWidth: true
Layout.fillHeight: false
RowLayout {
width: parent.width
TextArea {
id: messageField
Layout.fillWidth: true
placeholderText: qsTr("Compose message")
wrapMode: TextArea.Wrap
}
Button {
id: sendButton
text: qsTr("Send")
enabled: messageField.length > 0
Layout.fillWidth: false
}
}
}El « TextArea » debe ocupar todo el ancho disponible de la pantalla. Asignamos un texto de relleno para indicar visualmente al usuario dónde debe empezar a escribir. El texto dentro del área de entrada se ajusta para garantizar que no se salga de la pantalla.
Por último, el botón solo está habilitado cuando realmente hay un mensaje que enviar.
Capítulo 4: Modelos
En el capítulo 4, te guiaremos a través del proceso de creación de modelos SQL de solo lectura y de lectura y escritura en C++, y de cómo exponerlos a QML para rellenar las vistas.
QSqlQueryModel
Para que el tutorial resulte sencillo, hemos optado por que la lista de contactos del usuario no sea editable. QSqlQueryModel es la opción más lógica para este fin, ya que proporciona un modelo de datos de solo lectura para conjuntos de resultados SQL.
Echemos un vistazo a nuestra clase ` SqlContactModel `, que deriva de ` QSqlQueryModel`:
#include <QQmlEngine>
#include <QSqlQueryModel>
class SqlContactModel : public QSqlQueryModel
{
Q_OBJECT
QML_ELEMENT
public:
SqlContactModel(QObject *parent = nullptr);
};Aquí no hay mucho que ver, así que pasemos al archivo ` .cpp `:
#include "sqlcontactmodel.h"
#include <QDebug>
#include <QSqlError>
#include <QSqlQuery>
static void createTable()
{
if (QSqlDatabase::database().tables().contains(QStringLiteral("Contacts"))) {
// La tabla ya existe; no hace falta hacer nada.
return;
}
QSqlQuery query;
if (!query.exec(
"CREATE TABLE IF NOT EXISTS 'Contacts' ("
" 'name' TEXT NOT NULL,"
" PRIMARY KEY(name)"
")")) {
qFatal("Failed to query database: %s", qPrintable(query.lastError().text()));
}
query.exec("INSERT INTO Contacts VALUES('Albert Einstein')");
query.exec("INSERT INTO Contacts VALUES('Ernest Hemingway')");
query.exec("INSERT INTO Contacts VALUES('Hans Gude')");
}Incluimos el archivo de cabecera de nuestra clase y los que necesitamos de Qt. A continuación, definimos una función estática llamada createTable() que utilizaremos para crear la tabla SQL (si aún no existe) y, después, la rellenamos con algunos contactos ficticios.
La llamada a database() puede parecer un poco confusa porque aún no hemos configurado una base de datos específica. Si no se pasa ningún nombre de conexión a esta función, devolverá una «conexión por defecto», cuya creación veremos en breve.
SqlContactModel::SqlContactModel(QObject*parent) :
QSqlQueryModel(parent)
{
createTable();
QSqlQuery query;
if (!query.exec("SELECT * FROM Contacts"))
qFatal("Contacts SELECT query failed: %s", qPrintable(query.lastError().text()));
setQuery(std::move(query));
if (lastError().isValid())
qFatal("Cannot set query on SqlContactModel: %s", qPrintable(lastError().text()));
}En el constructor, llamamos a createTable(). A continuación, creamos una consulta que se utilizará para rellenar el modelo. En este caso, simplemente nos interesan todas las filas de la tabla Contacts.
QSqlTableModel
SqlConversationModel es más complejo:
#include <QQmlEngine>
#include <QSqlTableModel>
class SqlConversationModel : public QSqlTableModel
{
Q_OBJECT
QML_ELEMENT
Q_PROPERTY(QString recipient READ recipient WRITE setRecipient NOTIFY recipientChanged)
public:
SqlConversationModel(QObject *parent = nullptr);
QString recipient() const;
void setRecipient(const QString &recipient);
QVariant data(const QModelIndex &index, int role) const override;
QHash<int, QByteArray> roleNames() const override;
Q_INVOKABLE void sendMessage(const QString &recipient, const QString &message);
signals:
void recipientChanged();
private:
QString m_recipient;
};Utilizamos tanto la macro « Q_PROPERTY » como la macro « Q_INVOKABLE », por lo que debemos indicárselo a moc mediante la macro « Q_OBJECT ».
La propiedad recipient se establecerá desde QML para indicar al modelo de qué conversación debe recuperar los mensajes.
Sobrescribimos las funciones data() y roleNames() para poder utilizar nuestros roles personalizados en QML.
También definimos la función ` sendMessage() ` que queremos llamar desde QML, de ahí la macro ` Q_INVOKABLE `.
Echemos un vistazo al archivo .cpp:
#include "sqlconversationmodel.h"
#include <QDateTime>
#include <QDebug>
#include <QSqlError>
#include <QSqlRecord>
#include <QSqlQuery>
static const char *conversationsTableName = "Conversations";
static void createTable()
{
if (QSqlDatabase::database().tables().contains(conversationsTableName)) {
// La tabla ya existe; no hace falta hacer nada.
return;
}
QSqlQuery query;
if (!query.exec(
"CREATE TABLE IF NOT EXISTS 'Conversations' ("
"'author' TEXT NOT NULL,"
"'recipient' TEXT NOT NULL,"
"'timestamp' TEXT NOT NULL,"
"'message' TEXT NOT NULL,"
"FOREIGN KEY('author') REFERENCES Contacts ( name ),"
"FOREIGN KEY('recipient') REFERENCES Contacts ( name )"
")")) {
qFatal("Failed to query database: %s", qPrintable(query.lastError().text()));
}
query.exec("INSERT INTO Conversaciones VALUES('Yo', 'Ernest Hemingway', '2016-01-07T14:36:06', '¡Hola!')");
query.exec("INSERT INTO Conversaciones VALUES('Ernest Hemingway', 'Yo', '2016-01-07T14:36:16', 'Buenas tardes.')");
query.exec("INSERT INTO Conversaciones VALUES('Yo', 'Albert Einstein', '2016-01-01T11:24:53', '¡Hola!')");
query.exec("INSERT INTO Conversaciones VALUES('Albert Einstein', 'Yo', '2016-01-07T14:36:16', 'Buenos días.')");
query.exec("INSERT INTO Conversaciones VALUES('Hans Gude', 'Yo', '2015-11-20T06:30:02', 'God morgen. ¿Has recibido mi cuadro?')");
query.exec("INSERT INTO Conversaciones VALUES('Yo', 'Hans Gude', '2015-11-20T08:21:03', 'Buenos días, Hans. Sí, es muy bonito. ¡Muchísimas gracias! "
"¿Cuántas horas le has dedicado?")");
}Esto es muy similar a sqlcontactmodel.cpp, con la excepción de que ahora estamos trabajando con la tabla « Conversations ». También definimos « conversationsTableName » como una variable constante estática, ya que la utilizamos en varios puntos a lo largo del archivo.
SqlConversationModel::SqlConversationModel(QObject *parent) :
QSqlTableModel(parent)
{
createTable();
setTable(conversationsTableName);
setSort(2, Qt::DescendingOrder);
// Ensures that the model is sorted correctly after submitting a new row.
setEditStrategy(QSqlTableModel::OnManualSubmit);
}Al igual que en SqlContactModel, lo primero que hacemos en el constructor es crear la tabla. Le indicamos a QSqlTableModel el nombre de la tabla que vamos a utilizar mediante la función setTable(). Para garantizar que los mensajes más recientes de la conversación se muestren en primer lugar, ordenamos los resultados de la consulta por el campo timestamp en orden descendente. Esto va de la mano con la configuración de la propiedad verticalLayoutDirection de ListView en ListView.BottomToTop (lo cual ya tratamos en el capítulo 3).
QString SqlConversationModel::recipient() const
{
return m_recipient;
}
void SqlConversationModel::setRecipient(const QString &recipient)
{
if (recipient == m_recipient)
return;
m_recipient = recipient;
const QString filterString = QString::fromLatin1(
"(recipient = '%1' AND author = 'Me') OR (recipient = 'Me' AND author='%1')").arg(m_recipient);
setFilter(filterString);
select();
emit recipientChanged();
}En setRecipient(), aplicamos un filtro a los resultados devueltos por la base de datos.
QVariant SqlConversationModel::data(const QModelIndex &index, int role) const
{
if (role < Qt::UserRole)
return QSqlTableModel::data(index, role);
const QSqlRecord sqlRecord = record(index.row());
return sqlRecord.value(role - Qt::UserRole);
}La función data() recurre a la implementación de QSqlTableModel si el rol no es un rol de usuario personalizado. Si el rol es un rol de usuario, podemos restarle Qt::UserRole para obtener el índice de ese campo y, a continuación, utilizarlo para encontrar el valor que necesitamos devolver.
QHash<int, QByteArray> SqlConversationModel::roleNames() const
{
QHash<int, QByteArray> names;
names[Qt::UserRole] = "author";
names[Qt::UserRole + 1] = "recipient";
names[Qt::UserRole + 2] = "timestamp";
names[Qt::UserRole + 3] = "message";
return names;
}En roleNames(), devolvemos una correspondencia entre los valores de nuestros roles personalizados y los nombres de los roles. Esto nos permite utilizar estos roles en QML. Puede resultar útil declarar una enumeración que contenga todos los valores de los roles, pero, dado que no hacemos referencia a ningún valor específico en el código fuera de esta función, no nos molestamos en hacerlo.
void SqlConversationModel::sendMessage(const QString&recipient, const QString&message)
{
const QString timestamp = QDateTime::currentDateTime().toString(Qt::ISODate);
QSqlRecord newRecord = record();
newRecord.setValue("author", "Yo");
newRecord.setValue("recipient", recipient);
newRecord.setValue("timestamp", timestamp);
newRecord.setValue("message", message);
if (!insertRecord(rowCount(), newRecord)) {
qWarning() << "Failed to send message:" << lastError().text();
return;
}La función ` sendMessage() ` utiliza el ` recipient ` proporcionado y un ` message ` para insertar un nuevo registro en la base de datos. Debido a que utilizamos ` QSqlTableModel::OnManualSubmit`, debemos llamar manualmente a ` submitAll()`.
Conexión a la base de datos y registro de tipos con QML
Ahora que hemos establecido las clases del modelo, echemos un vistazo a main.cpp:
#include <QtCore>
#include <QGuiApplication>
#include <QSqlDatabase>
#include <QSqlError>
#include <QtQml>
static void connectToDatabase()
{
QSqlDatabase database = QSqlDatabase::database();
if (!database.isValid()) {
database = QSqlDatabase::addDatabase("QSQLITE");
if (!database.isValid())
qFatal("Cannot add database: %s", qPrintable(database.lastError().text()));
}
const QDir writeDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
if (!writeDir.mkpath("."))
qFatal("Failed to create writable directory at %s", qPrintable(writeDir.absolutePath()));
// Asegurarnos de que disponemos de una ubicación en la que se pueda escribir en todos los dispositivos.
const QString nombreArchivo = rutaAbsoluta.absolutePath() + "/chat-database.sqlite3";
// Al utilizar el controlador SQLite, la función open() creará la base de datos SQLite si aún no existe.
database.setDatabaseName(fileName);
if (!database.open()) {
qFatal("Cannot open database: %s", qPrintable(database.lastError().text()));
QFile::remove(nombreArchivo);
}
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
connectToDatabase();
QQmlApplicationEngine engine;
engine.loadFromModule("chattutorial", "Main");
if (engine.rootObjects().isEmpty())
return-1;
return app.exec();
}connectToDatabase() establece la conexión con la base de datos SQLite, creando el archivo si aún no existe.
Dentro de ` main()`, llamamos a ` qmlRegisterType()` para registrar nuestros modelos como tipos en QML.
Uso de los modelos en QML
Ahora que disponemos de los modelos como tipos de QML, hay que realizar algunos pequeños cambios en ContactPage.qml. Para poder utilizar los tipos, primero debemos importarlos utilizando el URI que hemos establecido en main.cpp:
import chattutorialA continuación, sustituimos el modelo ficticio por el correcto:
model: SqlContactModel {}Dentro del delegado, utilizamos una sintaxis diferente para acceder a los datos del modelo:
text: model.displayEn ` ConversationPage.qml`, añadimos la misma importación ` chattutorial ` y sustituimos el modelo ficticio:
model: SqlConversationModel {
recipient: root.inConversationWith
}Dentro del modelo, establecemos la propiedad recipient con el nombre del contacto para el que se está mostrando la página.
El elemento delegado raíz cambia de «Row» a «Column», para dar cabida a la marca de tiempo que queremos mostrar debajo de cada mensaje:
delegate: Column {
id: conversationDelegate
anchors.right: sentByMe ? listView.contentItem.right : undefined
spacing: 6
required property string author
required property string recipient
required property date timestamp
required property string message
readonly property bool sentByMe: recipient !== "Me"
Row {
id: messageRow
spacing: 6
anchors.right: conversationDelegate.sentByMe ? parent.right : undefined
Image {
id: avatar
source: !conversationDelegate.sentByMe
? "images/" + conversationDelegate.author.replace(" ", "_") + ".png" : ""
}
Rectangle {
width: Math.min(messageText.implicitWidth + 24,
listView.width - (!conversationDelegate.sentByMe ? avatar.width + messageRow.spacing : 0))
height: messageText.implicitHeight + 24
color: conversationDelegate.sentByMe ? "lightgrey" : "steelblue"
Label {
id: messageText
text: conversationDelegate.message
color: conversationDelegate.sentByMe ? "black" : "white"
anchors.fill: parent
anchors.margins: 12
wrapMode: Label.Wrap
}
}
}
Label {
id: timestampText
text: Qt.formatDateTime(conversationDelegate.timestamp, "d MMM hh:mm")
color: "lightgrey"
anchors.right: conversationDelegate.sentByMe ? parent.right : undefined
}
}
Ahora que disponemos de un modelo adecuado, podemos utilizar su función « recipient » en la expresión de la propiedad « sentByMe ».
El «Rectangle» que se utilizaba para el avatar se ha convertido en un «Image». La imagen tiene su propio tamaño implícito, por lo que no es necesario especificarlo explícitamente. Al igual que antes, solo mostramos el avatar cuando el autor no es el usuario, salvo que en esta ocasión establecemos el « source » de la imagen en una URL vacía en lugar de utilizar la propiedad « visible ».
Queremos que el fondo de cada mensaje sea ligeramente más ancho (12 píxeles a cada lado) que su texto. Sin embargo, si es demasiado largo, queremos limitar su anchura al borde de la vista de lista, de ahí el uso de ` Math.min()`. Cuando el mensaje no lo hemos enviado nosotros, siempre aparecerá un avatar delante, así que lo tenemos en cuenta restando la anchura del avatar y el espaciado entre filas.
Por ejemplo, en la imagen de arriba, el ancho implícito del texto del mensaje es el valor más pequeño. Sin embargo, en la imagen de abajo, el texto del mensaje es bastante largo, por lo que se elige el valor más pequeño (el ancho de la vista), lo que garantiza que el texto termine en el borde opuesto de la pantalla:

Para mostrar la marca de tiempo de cada mensaje, tal y como hemos comentado anteriormente, utilizamos una etiqueta (Label). La fecha y la hora se formatean con Qt.formatDateTime(), utilizando un formato personalizado.
Ahora, el botón «enviar» debe reaccionar al hacer clic en él:
Button {
id: sendButton
text: qsTr("Send")
enabled: messageField.length > 0
Layout.fillWidth: false
onClicked: {
listView.model.sendMessage(root.inConversationWith, messageField.text)
messageField.text = ""
}
}En primer lugar, llamamos a la función invocable sendMessage() del modelo, que inserta una nueva fila en la tabla de la base de datos «Conversations». A continuación, borramos el campo de texto para dejar espacio para futuras entradas.
Capítulo 5: Estilo
Los estilos de los controles de Qt Quick están diseñados para funcionar en cualquier plataforma. En este capítulo, realizaremos algunos pequeños ajustes visuales para asegurarnos de que nuestra aplicación tenga un buen aspecto cuando se ejecute con los estilos «Basic», «Material» y «Universal ».
Hasta ahora, solo hemos probado la aplicación con el estilo «Basic». Si la ejecutamos con el estilo «Material», por ejemplo, veremos inmediatamente algunos problemas. Aquí está la página «Contactos»:

El texto del encabezado es negro sobre un fondo azul oscuro, lo que dificulta mucho la lectura. Lo mismo ocurre con la página «Conversaciones»:

La solución consiste en indicar a la barra de herramientas que utilice el tema «Dark», de modo que esta información se transmita a sus elementos secundarios, lo que les permitirá cambiar el color del texto a uno más claro. La forma más sencilla de hacerlo es importar directamente el estilo «Material» y utilizar la propiedad adjunta «Material»:
import QtQuick.Controls.Material 2.12
// ...
header: ToolBar {
Material.theme: Material.Dark
// ...
}Sin embargo, esto conlleva una dependencia rígida del estilo Material; el complemento de estilo Material debe implementarse junto con la aplicación, incluso si el dispositivo de destino no lo utiliza, ya que, de lo contrario, el motor QML no encontrará la importación.
En su lugar, es mejor recurrir a la compatibilidad integrada de Qt Quick Controls con los selectores de archivos basados en estilos. Para ello, debemos trasladar el archivo « ToolBar » a un archivo independiente. Lo llamaremos « ChatToolBar.qml ». Esta será la versión «predeterminada» del archivo, lo que significa que se utilizará cuando se emplee el estilo «Basic» (que es el estilo que se utiliza cuando no se especifica ninguno). Aquí está el nuevo archivo:
import QtQuick.Controls
ToolBar {
}Como en este archivo solo utilizamos el tipo « ToolBar », solo necesitamos la importación « Qt Quick Controls». El código en sí no ha cambiado con respecto a cómo estaba en ContactPage.qml, que es como debe ser; para la versión por defecto del archivo, no es necesario que haya ninguna diferencia.
De vuelta en ContactPage.qml, actualizamos el código para utilizar el nuevo tipo:
header: ChatToolBar {
Label {
text: qsTr("Contacts")
font.pixelSize: 20
anchors.centerIn: parent
}
}Ahora tenemos que añadir la versión «Material» de la barra de herramientas. Los selectores de archivos esperan que las variantes de un archivo se encuentren en directorios con nombres adecuados que coexistan con la versión predeterminada del archivo. Esto significa que tenemos que añadir una carpeta llamada «+Material» en el mismo directorio en el que se encuentra ChatToolBar.qml: la carpeta raíz. El símbolo «+» es obligatorio en QFileSelector para garantizar que la función de selección no se active accidentalmente.
Aquí está +Material/ChatToolBar.qml:
import QtQuick.Controls
import QtQuick.Controls.Material
ToolBar {
Material.theme: Material.Dark
}Realizaremos los mismos cambios en ConversationPage.qml:
header: ChatToolBar {
ToolButton {
text: qsTr("Back")
anchors.left: parent.left
anchors.leftMargin: 10
anchors.verticalCenter: parent.verticalCenter
onClicked: root.StackView.view.pop()
}
Label {
id: pageTitle
text: root.inConversationWith
font.pixelSize: 20
anchors.centerIn: parent
}
}Ahora ambas páginas se ven correctamente:


Probemos el estilo «Universal»:


No hay ningún problema. En una aplicación relativamente sencilla como esta, apenas debería ser necesario realizar ajustes al cambiar de estilo.
Ahora probemos el tema oscuro de cada estilo. El estilo «Básico» no tiene tema oscuro, ya que supondría una ligera sobrecarga para un estilo diseñado para ofrecer el máximo rendimiento posible. Probaremos primero el estilo «Material», así que añade una entrada en qtquickcontrols2.conf que le indique que utilice su tema oscuro:
[Material]
Primary=Indigo
Accent=Indigo
Theme=DarkUna vez hecho esto, compila y ejecuta la aplicación. Esto es lo que deberías ver:


Ambas páginas se ven bien. Ahora añade una entrada para el estilo «Universal»:
[universal]
Theme=DarkTras compilar y ejecutar la aplicación, deberías ver estos resultados:


Resumen
En este tutorial, te hemos guiado a través de los siguientes pasos para escribir una aplicación básica utilizando los controles de Qt Quick:
- Creación de un nuevo proyecto con Qt Creator.
- Configuración de una página básica de ApplicationWindow.
- Definición de encabezados y pies de página con Page.
- Mostrar contenido en un « ListView ».
- Reestructuración de componentes en sus propios archivos.
- Navegación entre pantallas con « StackView ».
- Uso de diseños para permitir que una aplicación se adapte correctamente a diferentes tamaños de pantalla.
- Implementación de modelos personalizados, tanto de solo lectura como de lectura y escritura, que integran una base de datos SQL en la aplicación.
- Integrar C++ con QML mediante Q_PROPERTY, Q_INVOKABLE y qmlRegisterType().
- Probar y configurar varios estilos.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.