Ejemplo de desglose
El ejemplo de desglose muestra cómo leer datos de una base de datos y enviar cambios utilizando las clases ` QSqlRelationalTableModel ` y ` QDataWidgetMapper `.

Al ejecutar la aplicación de ejemplo, el usuario puede recuperar información sobre cada elemento haciendo clic en la imagen correspondiente. La aplicación muestra una ventana emergente con los datos y permite a los usuarios modificar tanto la descripción como la imagen. La vista principal se actualizará cuando los usuarios envíen sus cambios.
El ejemplo consta de tres clases:
ImageItemes una clase de elemento gráfico personalizada que se utiliza para mostrar las imágenes.Viewes el widget principal de la aplicación que permite al usuario navegar por los distintos elementos.InformationWindowmuestra la información solicitada, permitiendo a los usuarios modificarla y enviar sus cambios a la base de datos.
En primer lugar, analizaremos la clase « InformationWindow » para ver cómo se pueden leer y modificar datos de una base de datos. A continuación, revisaremos el widget principal de la aplicación, es decir, la clase « View », y la clase asociada « ImageItem ».
Definición de la clase `InformationWindow`
La clase ` InformationWindow ` es un widget personalizado que hereda de ` QWidget`:
class InformationWindow : public QDialog
{
Q_OBJECT
public:
InformationWindow(int id, QSqlRelationalTableModel *items,
QWidget *parent = nullptr);
int id() const;
Q_SIGNALS:
void imageChanged(int id, const QString &fileName);Al crear una ventana de información, pasamos al constructor el ID del elemento asociado, un puntero al modelo y un elemento padre. Utilizaremos el puntero al modelo para rellenar nuestra ventana con datos, mientras que pasaremos el parámetro «parent» a la clase base. El ID se almacena para futuras consultas.
Una vez creada la ventana, utilizaremos la función pública ` id() ` para localizarla cada vez que se solicite información sobre la ubicación indicada. También utilizaremos el ID para actualizar el widget principal de la aplicación cuando los usuarios envíen sus cambios a la base de datos; es decir, emitiremos una señal que incluya el ID y el nombre del archivo como parámetros cada vez que los usuarios modifiquen la imagen asociada.
private Q_SLOTS:
void revert();
void submit();
void enableButtons(bool enable);Dado que permitimos a los usuarios modificar algunos de los datos, debemos proporcionar funcionalidad para revertir y enviar sus cambios. La ranura ` enableButtons() ` se proporciona para facilitar la activación y desactivación de los distintos botones cuando sea necesario.
private:
void createButtons();
int itemId;
QString displayedImage;
QComboBox *imageFileEditor = nullptr;
QLabel *itemText = nullptr;
QTextEdit *descriptionEditor = nullptr;
QPushButton *closeButton = nullptr;
QPushButton *submitButton = nullptr;
QPushButton *revertButton = nullptr;
QDialogButtonBox *buttonBox = nullptr;
QDataWidgetMapper *mapper = nullptr;
};La función ` createButtons() ` es también una función de conveniencia, proporcionada para simplificar el constructor. Como se ha mencionado anteriormente, almacenamos el ID del elemento para futuras consultas. También almacenamos el nombre del archivo de imagen que se muestra actualmente para poder determinar cuándo emitir la señal ` imageChanged() `.
La ventana de información utiliza la clase ` QLabel ` para mostrar el nombre de un elemento. El archivo de imagen asociado se muestra mediante una instancia de ` QComboBox `, mientras que la descripción se muestra mediante ` QTextEdit`. Además, la ventana cuenta con tres botones para controlar el flujo de datos y si la ventana se muestra o no.
Por último, declaramos un mapeador. La clase QDataWidgetMapper proporciona la correspondencia entre una sección de un modelo de datos y los widgets. Utilizaremos el mapeador para extraer datos de la base de datos indicada, actualizando la base de datos cada vez que el usuario modifique los datos.
Implementación de la clase `InformationWindow`
El constructor toma tres argumentos: un ID de elemento, un puntero a la base de datos y un widget padre. El puntero a la base de datos es, en realidad, un puntero a un objeto ` QSqlRelationalTableModel ` que proporciona un modelo de datos editable (con soporte para claves externas) para nuestra tabla de la base de datos.
InformationWindow::InformationWindow(int id, QSqlRelationalTableModel *items,
QWidget *parent)
: QDialog(parent)
{
QLabel *itemLabel = new QLabel(tr("Item:"));
QLabel *descriptionLabel = new QLabel(tr("Description:"));
QLabel *imageFileLabel = new QLabel(tr("Image file:"));
createButtons();
itemText = new QLabel;
descriptionEditor = new QTextEdit;En primer lugar, creamos los distintos widgets necesarios para mostrar los datos contenidos en la base de datos. La mayoría de los widgets se crean de forma sencilla. Pero fíjate en el cuadro combinado que muestra el nombre del archivo de imagen:
imageFileEditor = new QComboBox;
imageFileEditor->setModel(items->relationModel(1));
imageFileEditor->setModelColumn(items->relationModel(1)->fieldIndex("file"));En este ejemplo, la información sobre los elementos se almacena en una tabla de la base de datos llamada «items». Al crear el modelo, utilizaremos una clave foránea para establecer una relación entre esta tabla y una segunda tabla de la base de datos, «images», que contiene los nombres de los archivos de imagen disponibles. Volveremos sobre cómo se hace esto cuando repasemos la clase View. La razón para crear dicha relación es que queremos asegurarnos de que el usuario solo pueda elegir entre archivos de imagen predefinidos.
El modelo correspondiente a la tabla de la base de datos «images» está disponible a través de la función relationModel() de QSqlRelationalTableModel, que requiere la clave externa (en este caso, el número de la columna «imagefile») como argumento. Utilizamos la función setModel() de QComboBox para que el cuadro combinado utilice el modelo «images». Y, dado que este modelo tiene dos columnas («itemid» y «file»), también especificamos qué columna queremos que sea visible mediante la función QComboBox::setModelColumn().
mapper = new QDataWidgetMapper(this);
mapper->setModel(items);
mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
mapper->setItemDelegate(new QSqlRelationalDelegate(mapper));
mapper->addMapping(imageFileEditor, 1);
mapper->addMapping(itemText, 2, "text");
mapper->addMapping(descriptionEditor, 3);
mapper->setCurrentIndex(id);A continuación, creamos el mapeador. La clase QDataWidgetMapper nos permite crear widgets sensibles a los datos asignándolos a secciones de un modelo de elementos.
La función addMapping() establece una correspondencia entre el widget dado y la sección especificada del modelo. Si la orientación del mapeador es horizontal (por defecto), la sección es una columna del modelo; en caso contrario, es una fila. Llamamos a la función ` setCurrentIndex()` para inicializar los widgets con los datos asociados al ID de elemento dado. Cada vez que cambia el índice actual, todos los widgets se actualizan con el contenido del modelo.
También configuramos la política de envío del mapeador como « QDataWidgetMapper::ManualSubmit ». Esto significa que no se envían datos a la base de datos hasta que el usuario solicite explícitamente un envío (la alternativa es « QDataWidgetMapper::AutoSubmit », que envía automáticamente los cambios cuando el widget correspondiente pierde el foco). Por último, especificamos el delegado de elementos que la vista del mapeador debe utilizar para sus elementos. La clase QSqlRelationalDelegate representa un delegado que, a diferencia del delegado predeterminado, habilita la funcionalidad de cuadro combinado para los campos que son claves externas en otras tablas (como «imagefile» en nuestra tabla «items»).
connect(descriptionEditor, &QTextEdit::textChanged, this, [this]() { enableButtons(true); });
connect(imageFileEditor, &QComboBox::currentIndexChanged, this, [this]() { enableButtons(true); });
QFormLayout *formLayout = new QFormLayout;
formLayout->addRow(itemLabel, itemText);
formLayout->addRow(imageFileLabel, imageFileEditor);
formLayout->addRow(descriptionLabel, descriptionEditor);
QVBoxLayout *layout = new QVBoxLayout;
layout->addLayout(formLayout);
layout->addWidget(buttonBox);
setLayout(layout);
itemId = id;
displayedImage = imageFileEditor->currentText();
setWindowFlags(Qt::Window);
enableButtons(false);
setWindowTitle(itemText->text());
}Por último, conectamos las señales de «algo ha cambiado» de los editores a nuestra ranura personalizada enableButtons, lo que permite a los usuarios enviar o revertir sus cambios. Necesitamos utilizar lambdas para conectar la ranura enableButtons porque su firma no coincide con QTextEdit::textChanged ni con QComboBox::currentIndexChanged.
Añadimos todos los widgets a un diseño, almacenamos el ID del elemento y el nombre del archivo de imagen mostrado para futuras consultas, y configuramos el título de la ventana y su tamaño inicial.
Ten en cuenta que también establecemos el indicador de ventana « Qt::Window » para indicar que nuestro widget es, de hecho, una ventana, con un marco del sistema de ventanas y una barra de título.
int InformationWindow::id() const
{
return itemId;
}Cuando se crea una ventana, esta no se elimina hasta que la aplicación principal se cierra (es decir, si el usuario cierra la ventana de información, esta solo se oculta). Por este motivo, no queremos crear más de un objeto ` InformationWindow ` para cada elemento, y proporcionamos la función pública ` id() ` para poder determinar si ya existe una ventana para una ubicación determinada cuando el usuario solicita información sobre ella.
void InformationWindow::revert()
{
mapper->revert();
enableButtons(false);
}La ranura « revert() » se activa cada vez que el usuario pulsa el botón « Revert ».
Dado que hemos establecido la política de envío « QDataWidgetMapper::ManualSubmit », ninguno de los cambios del usuario se guarda en el modelo a menos que el usuario elija explícitamente enviarlos todos. No obstante, podemos utilizar la ranura « revert()» de « QDataWidgetMapper » para restablecer los widgets del editor, rellenando todos los widgets con los datos actuales del modelo.
void InformationWindow::submit()
{
QString newImage(imageFileEditor->currentText());
if (displayedImage != newImage) {
displayedImage = newImage;
emit imageChanged(itemId, newImage);
}
mapper->submit();
mapper->setCurrentIndex(itemId);
enableButtons(false);
}Del mismo modo, la ranura submit() se activa cada vez que los usuarios deciden enviar sus cambios pulsando el botón Submit.
Utilizamos el slot submit() de QDataWidgetMapper para enviar todos los cambios de los widgets asignados al modelo, es decir, a la base de datos. Para cada sección asignada, el delegado del elemento leerá entonces el valor actual del widget y lo establecerá en el modelo. Por último, se invoca la función ` submit()` del modelo para indicarle que debe enviar todo lo que tenga almacenado en caché al almacenamiento permanente.
Ten en cuenta que, antes de enviar ningún dato, comprobamos si el usuario ha elegido otro archivo de imagen utilizando como referencia la variable ` displayedImage ` almacenada previamente. Si los nombres de los archivos actual y almacenado difieren, almacenamos el nuevo nombre de archivo y emitimos la señal ` imageChanged() `.
void InformationWindow::createButtons()
{
closeButton = new QPushButton(tr("&Close"));
revertButton = new QPushButton(tr("&Revert"));
submitButton = new QPushButton(tr("&Submit"));
closeButton->setDefault(true);
connect(closeButton, &QPushButton::clicked, this, &InformationWindow::close);
connect(revertButton, &QPushButton::clicked, this, &InformationWindow::revert);
connect(submitButton, &QPushButton::clicked, this, &InformationWindow::submit);La función createButtons() se proporciona por comodidad, es decir, para simplificar el constructor.
Establecemos el botón « Close » como botón por defecto, es decir, el botón que se activa cuando el usuario pulsa « Enter », y conectamos su señal « clicked()» a la ranura « close()» del widget. Como se ha mencionado anteriormente, al cerrar la ventana solo se oculta el widget; no se elimina. También conectamos los botones « Submit » y « Revert » a las ranuras correspondientes « submit() » y « revert() ».
buttonBox = new QDialogButtonBox(this);
buttonBox->addButton(submitButton, QDialogButtonBox::AcceptRole);
buttonBox->addButton(revertButton, QDialogButtonBox::ResetRole);
buttonBox->addButton(closeButton, QDialogButtonBox::RejectRole);
}La clase QDialogButtonBox es un widget que presenta botones en un diseño adecuado al estilo actual del widget. Los cuadros de diálogo, como nuestra ventana de información, suelen presentar los botones en un diseño que se ajusta a las directrices de interfaz de esa plataforma. Inevitablemente, las distintas plataformas tienen diseños diferentes para sus cuadros de diálogo. QDialogButtonBox nos permite añadir botones utilizando automáticamente el diseño adecuado para el entorno de escritorio del usuario.
La mayoría de los botones de un cuadro de diálogo siguen determinadas funciones. Asignamos a los botones « Submit » y « Revert » la función « reset », es decir, indicamos que al pulsar el botón los campos se restablecen a los valores por defecto (en nuestro caso, la información contenida en la base de datos). La función « reject » indica que al hacer clic en el botón se rechaza el cuadro de diálogo. Por otro lado, dado que solo ocultamos la ventana de información, cualquier cambio que haya realizado el usuario se conservará hasta que este lo revierta o lo envíe explícitamente.
void InformationWindow::enableButtons(bool enable)
{
revertButton->setEnabled(enable);
submitButton->setEnabled(enable);
}La ranura « enableButtons() » se invoca para habilitar los botones cada vez que el usuario modifica los datos mostrados. Del mismo modo, cuando el usuario decide enviar los cambios, los botones se deshabilitan para indicar que los datos actuales se han almacenado en la base de datos.
Con esto queda completada la clase ` InformationWindow `. Veamos cómo la hemos utilizado en nuestra aplicación de ejemplo.
Definición de la clase View
La clase ` View ` representa la ventana principal de la aplicación y hereda de ` QGraphicsView`:
class View : public QGraphicsView
{
Q_OBJECT
public:
View(const QString &items, const QString &images, QWidget *parent = nullptr);
protected:
void mouseReleaseEvent(QMouseEvent *event) override;
private Q_SLOTS:
void updateImage(int id, const QString &fileName);La clase ` QGraphicsView ` forma parte del Graphics View Framework, que utilizaremos para mostrar las imágenes. Para poder responder a la interacción del usuario mostrando la ventana de información adecuada al hacer clic en la imagen, reimplementamos la función ` mouseReleaseEvent()` de ` QGraphicsView`.
Ten en cuenta que el constructor espera los nombres de dos tablas de la base de datos: una que contenga la información detallada sobre los elementos y otra que contenga los nombres de los archivos de imagen disponibles. También proporcionamos una ranura privada de ` updateImage() ` para capturar la señal ` imageChanged() ` de ` InformationWindow`, que se emite cada vez que el usuario cambia una imagen asociada al elemento.
private:
void addItems();
InformationWindow *findWindow(int id) const;
void showInformation(ImageItem *image);
QGraphicsScene *scene;
QList<InformationWindow *> informationWindows;La función ` addItems() ` es una función de conveniencia que se proporciona para simplificar el constructor. Se llama una sola vez, creando los distintos elementos y añadiéndolos a la vista.
La función ` findWindow() `, por su parte, se utiliza con frecuencia. Se invoca desde la función ` showInformation() ` para determinar si ya se ha creado una ventana para el elemento dado (cada vez que creamos un objeto ` InformationWindow `, almacenamos una referencia al mismo en la lista ` informationWindows `). Esta última función, a su vez, se invoca desde nuestra implementación personalizada de ` mouseReleaseEvent() `.
QSqlRelationalTableModel *itemTable;
};Por último, declaramos un puntero de tipo ` QSqlRelationalTableModel `. Como se ha mencionado anteriormente, la clase ` QSqlRelationalTableModel ` proporciona un modelo de datos editable con soporte para claves externas. Hay un par de cosas que debes tener en cuenta al utilizar la clase ` QSqlRelationalTableModel `: la tabla debe tener declarada una clave primaria y esta clave no puede contener una relación con otra tabla, es decir, no puede ser una clave externa. Ten en cuenta también que, si una tabla relacional contiene claves que hacen referencia a filas inexistentes en la tabla a la que se hace referencia, las filas que contengan las claves no válidas no se mostrarán a través del modelo. Es responsabilidad del usuario o de la base de datos mantener la integridad referencial.
Implementación de la clase `View`
Aunque el constructor solicita los nombres tanto de la tabla que contiene los detalles de la oficina como de la tabla que contiene los nombres de los archivos de imagen disponibles, solo tenemos que crear un objeto ` QSqlRelationalTableModel ` para la tabla «items»:
View::View(const QString &items, const QString &images, QWidget *parent)
: QGraphicsView(parent)
{
itemTable = new QSqlRelationalTableModel(this);
itemTable->setTable(items);
itemTable->setRelation(1, QSqlRelation(images, "itemid", "file"));
itemTable->select();El motivo es que, una vez que tengamos un modelo con los detalles del artículo, podemos crear una relación con los archivos de imagen disponibles utilizando la función ` setRelation()` de ` QSqlRelationalTableModel`. Esta función crea una clave externa para la columna del modelo indicada. La clave se especifica mediante el objeto ` QSqlRelation ` proporcionado, construido a partir del nombre de la tabla a la que hace referencia la clave, el campo al que se asigna la clave y el campo que debe mostrarse al usuario.
Ten en cuenta que al establecer la tabla solo se especifica en qué tabla opera el modelo; es decir, debemos llamar explícitamente a la función ` select()` del modelo para rellenar nuestro modelo.
scene = new QGraphicsScene(this);
scene->setSceneRect(0, 0, 465, 365);
setScene(scene);
addItems();
setMinimumSize(470, 370);
setMaximumSize(470, 370);
QLinearGradient gradient(QPointF(0, 0), QPointF(0, 370));
gradient.setColorAt(0, QColor("#868482"));
gradient.setColorAt(1, QColor("#5d5b59"));
setBackgroundBrush(gradient);
}A continuación, creamos el contenido de nuestra vista, es decir, la escena y sus elementos. Las etiquetas son objetos ` QGraphicsTextItem ` normales, mientras que las imágenes son instancias de la clase ` ImageItem `, derivada de ` QGraphicsPixmapItem`. Volveremos sobre esto en breve al repasar la función ` addItems() `.
Por último, establecemos las restricciones de tamaño y el título de la ventana del widget principal de la aplicación.
void View::addItems()
{
int itemCount = itemTable->rowCount();
int imageOffset = 150;
int leftMargin = 70;
int topMargin = 40;
for (int i = 0; i < itemCount; i++) {
QSqlRecord record = itemTable->record(i);
int id = record.value("id").toInt();
QString file = record.value("file").toString();
QString item = record.value("itemtype").toString();
int columnOffset = ((i % 2) * 37);
int x = ((i % 2) * imageOffset) + leftMargin + columnOffset;
int y = ((i / 2) * imageOffset) + topMargin;
ImageItem *image = new ImageItem(id, QPixmap(":/" + file));
image->setData(0, i);
image->setPos(x, y);
scene->addItem(image);
QGraphicsTextItem *label = scene->addText(item);
label->setDefaultTextColor(QColor("#d7d6d5"));
QPointF labelOffset((120 - label->boundingRect().width()) / 2, 120.0);
label->setPos(QPointF(x, y) + labelOffset);
}
}La función ` addItems() ` se invoca únicamente una vez al crear la ventana principal de la aplicación. Para cada fila de la tabla de la base de datos, primero extraemos el registro correspondiente utilizando la función ` record()` del modelo. La clase ` QSqlRecord ` encapsula tanto la funcionalidad como las características de un registro de la base de datos, y permite añadir y eliminar campos, así como establecer y recuperar valores de campo. La función ` QSqlRecord::value()` devuelve el valor del campo con el nombre o índice indicado como un objeto ` QVariant `.
Para cada registro, creamos un elemento de etiqueta y un elemento de imagen, calculamos su posición y los añadimos a la escena. Los elementos de imagen están representados por instancias de la clase ` ImageItem `. La razón por la que debemos crear una clase de elemento personalizada es que queremos capturar los eventos de paso del cursor sobre el elemento, animándolo cuando el cursor del ratón se sitúe sobre la imagen (por defecto, ningún elemento acepta eventos de paso del cursor). Consulte la documentación de Graphics View Framework y los ejemplos de Graphics View para obtener más detalles.
void View::mouseReleaseEvent(QMouseEvent *event)
{
if (QGraphicsItem *item = itemAt(event->position().toPoint())) {
if (ImageItem *image = qgraphicsitem_cast<ImageItem *>(item))
showInformation(image);
}
QGraphicsView::mouseReleaseEvent(event);
}Reimplementamos el controlador de eventos mouseReleaseEvent() de QGraphicsView para responder a la interacción del usuario. Si el usuario hace clic en cualquiera de los elementos de imagen, esta función llama a la función privada showInformation() para que se abra la ventana de información asociada.
El Graphics View Framework proporciona la función ` qgraphicsitem_cast()` para determinar si una instancia dada de ` QGraphicsItem ` es de un tipo determinado. Tenga en cuenta que, si el evento no está relacionado con ninguno de nuestros elementos de imagen, lo pasamos a la implementación de la clase base.
void View::showInformation(ImageItem *image)
{
int id = image->id();
if (id < 0 || id >= itemTable->rowCount())
return;
InformationWindow *window = findWindow(id);
if (!window) {
window = new InformationWindow(id, itemTable, this);
connect(window, &InformationWindow::imageChanged,
this, &View::updateImage);
window->move(pos() + QPoint(20, 40));
window->show();
informationWindows.append(window);
}
if (window->isVisible()) {
window->raise();
window->activateWindow();
} else
window->show();
}A la función ` showInformation() ` se le pasa como argumento un objeto ` ImageItem `, y comienza extrayendo el ID del elemento.
A continuación, determina si ya existe una ventana de información para esta ubicación. Si no existe ninguna ventana para la ubicación dada, creamos una pasando el ID del elemento, un puntero al modelo y nuestra vista como padre al constructor de ` InformationWindow `. Obsérvese que conectamos la señal « imageChanged() » de la ventana de información a la ranura « updateImage() » de este widget, antes de asignarle una posición adecuada y añadirla a la lista de ventanas existentes. Si ya existe una ventana para la ubicación indicada y dicha ventana está visible, nos aseguramos de que la ventana pase a la parte superior de la pila de widgets y quede activada. Si está oculta, llamar a su ranura show() da el mismo resultado.
void View::updateImage(int id, const QString &fileName)
{
QList<QGraphicsItem *> items = scene->items();
while(!items.empty()) {
QGraphicsItem *item = items.takeFirst();
if (ImageItem *image = qgraphicsitem_cast<ImageItem *>(item)) {
if (image->id() == id){
image->setPixmap(QPixmap(":/" +fileName));
image->adjust();
break;
}
}
}
}La ranura updateImage() toma como argumentos un ID de elemento y el nombre de un archivo de imagen. Filtra los elementos de imagen y actualiza el que corresponde al ID de elemento dado con el archivo de imagen proporcionado.
InformationWindow *View::findWindow(int id) const
{
for (auto window : informationWindows) {
if (window && (window->id() == id))
return window;
}
return nullptr;
}La función ` findWindow() ` simplemente busca en la lista de ventanas existentes y devuelve un puntero a la ventana que coincide con el ID de elemento dado, o ` nullptr ` si la ventana no existe.
Por último, echemos un vistazo rápido a nuestra clase personalizada ImageItem:
Definición de la clase `ImageItem`
La clase ` ImageItem ` se proporciona para facilitar la animación de los elementos de imagen. Hereda de ` QGraphicsPixmapItem ` y reimplementa sus controladores de eventos de desplazamiento:
class ImageItem : public QObject, public QGraphicsPixmapItem
{
Q_OBJECT
public:
enum { Type = UserType + 1 };
ImageItem(int id, const QPixmap &pixmap, QGraphicsItem *parent = nullptr);
int type() const override { return Type; }
void adjust();
int id() const;
protected:
void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override;
void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;
private Q_SLOTS:
void setFrame(int frame);
void updateItemPosition();
private:
QTimeLine timeLine;
int recordId;
double z;
};Declaramos un valor de enumeración ` Type ` para nuestro elemento personalizado y reimplementamos ` type()`. Esto se hace para poder utilizar de forma segura ` qgraphicsitem_cast()`. Además, implementamos una función pública ` id() ` para poder identificar la ubicación asociada y una función pública ` adjust() ` a la que se puede llamar para garantizar que al elemento de imagen se le asigne el tamaño preferido, independientemente del archivo de imagen original.
La animación se implementa utilizando la clase QTimeLine junto con los controladores de eventos y la ranura privada setFrame(): el elemento de imagen se ampliará cuando el cursor del ratón se sitúe sobre él, volviendo a su tamaño original cuando el cursor salga de sus bordes.
Por último, almacenamos el identificador del elemento al que está asociado este registro concreto, así como un valor z. En el Graphics View Framework, el valor z de un elemento determina su posición en la pila de elementos. Un elemento con un valor z alto se dibujará encima de otro con un valor z menor si comparten el mismo elemento padre. También proporcionamos una función ` updateItemPosition() ` para actualizar la vista cuando sea necesario.
Implementación de la clase `ImageItem`
La clase ` ImageItem ` no es más que una clase ` QGraphicsPixmapItem ` con algunas características adicionales; es decir, podemos pasar la mayoría de los argumentos del constructor (el mapa de píxeles, el elemento padre y la escena) al constructor de la clase base:
ImageItem::ImageItem(int id, const QPixmap &pixmap, QGraphicsItem *parent)
: QGraphicsPixmapItem(pixmap, parent)
{
recordId = id;
setAcceptHoverEvents(true);
timeLine.setDuration(150);
timeLine.setFrameRange(0, 150);
connect(&timeLine, &QTimeLine::frameChanged, this, &ImageItem::setFrame);
connect(&timeLine, &QTimeLine::finished, this, &ImageItem::updateItemPosition);
adjust();
}A continuación, almacenamos el ID para futuras consultas y nos aseguramos de que nuestro elemento de imagen acepte eventos de desplazamiento del cursor. Los eventos de desplazamiento del cursor se producen cuando no hay ningún elemento que haya capturado el ratón en ese momento. Se envían cuando el cursor del ratón entra en un elemento, cuando se desplaza por su interior y cuando sale de él. Como hemos mencionado anteriormente, ninguno de los elementos del Graphics View Framework acepta eventos de paso del ratón de forma predeterminada.
La clase « QTimeLine » proporciona una línea de tiempo para controlar las animaciones. Su propiedad « duration » contiene la duración total de la línea de tiempo en milisegundos. Por defecto, la línea de tiempo se ejecuta una vez desde el principio hasta el final. La función « QTimeLine::setFrameRange()» establece el contador de fotogramas de la línea de tiempo; cuando la línea de tiempo está en ejecución, se emite la señal « frameChanged()» cada vez que cambia el fotograma. Establecemos la duración y el rango de fotogramas de nuestra animación, y conectamos las señales « frameChanged()» y « finished()» de la línea de tiempo a nuestras ranuras privadas « setFrame() » y « updateItemPosition() ».
Por último, llamamos a ` adjust() ` para asegurarnos de que el elemento adquiera el tamaño deseado.
void ImageItem::hoverEnterEvent(QGraphicsSceneHoverEvent * /*event*/)
{
timeLine.setDirection(QTimeLine::Forward);
if (z != 1.0) {
z = 1.0;
updateItemPosition();
}
if (timeLine.state() == QTimeLine::NotRunning)
timeLine.start();
}
void ImageItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/)
{
timeLine.setDirection(QTimeLine::Backward);
if (z != 0.0)
z = 0.0;
if (timeLine.state() == QTimeLine::NotRunning)
timeLine.start();
}Cada vez que el cursor del ratón entra o sale del elemento de imagen, se activan los controladores de eventos correspondientes: primero establecemos la dirección de la línea temporal, haciendo que el elemento se expanda o se contraiga, respectivamente. A continuación, modificamos el valor z del elemento si aún no está establecido en el valor esperado.
En el caso de los eventos de entrada al pasar el ratón por encima, actualizamos inmediatamente la posición del elemento, ya que queremos que este aparezca por encima de todos los demás elementos tan pronto como empiece a expandirse. En el caso de los eventos de salida al pasar el ratón por encima, por el contrario, posponemos la actualización real para lograr el mismo resultado. Pero recuerda que, al crear nuestro elemento, conectamos la señal « finished()» de la línea de tiempo a la ranura « updateItemPosition() ». De esta forma, el elemento ocupa la posición correcta en la pila de elementos una vez finalizada la animación. Por último, si la línea de tiempo aún no se está ejecutando, la iniciamos.
void ImageItem::setFrame(int frame)
{
adjust();
QPointF center = boundingRect().center();
setTransform(QTransform::fromTranslate(center.x(), center.y()), true);
setTransform(QTransform::fromScale(1 + frame / 300.0, 1 + frame / 300.0), true);
setTransform(QTransform::fromTranslate(-center.x(), -center.y()), true);
}Cuando la línea de tiempo está en marcha, activa la ranura « setFrame() » cada vez que cambia el fotograma actual debido a la conexión que creamos en el constructor del elemento. Es esta ranura la que controla la animación, ampliando o reduciendo el elemento de imagen paso a paso.
En primer lugar, llamamos a la función ` adjust() ` para asegurarnos de que partimos del tamaño original del elemento. A continuación, escalamos el elemento con un factor que depende del progreso de la animación (utilizando el parámetro ` frame `). Ten en cuenta que, por defecto, la transformación se realizará con respecto a la esquina superior izquierda del elemento. Como queremos que el elemento se transforme con respecto a su centro, debemos desplazar el sistema de coordenadas antes de escalar el elemento.
Al final, solo quedan las siguientes funciones de conveniencia:
void ImageItem::adjust()
{
setTransform(QTransform::fromScale(120.0 / boundingRect().width(),
120.0 / boundingRect().height()));
}
int ImageItem::id() const
{
return recordId;
}
void ImageItem::updateItemPosition()
{
setZValue(z);
}La función ` adjust() ` define y aplica una matriz de transformación, lo que garantiza que nuestro elemento de imagen se muestre con el tamaño deseado, independientemente del tamaño de la imagen original. La función ` id() ` es muy sencilla y se incluye únicamente para poder identificar el elemento. En la ranura ` updateItemPosition() ` llamamos a la función ` QGraphicsItem::setZValue()`, estableciendo la elevación del elemento.
© 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.