En esta página

Ejemplo de Scribble

El ejemplo «Scribble» muestra cómo reimplementar algunos de los controladores de eventos de QWidget para recibir los eventos generados por los widgets de la aplicación.

Reimplementamos los controladores de eventos del ratón para implementar el dibujo, el controlador de eventos «paint» para actualizar la aplicación y el controlador de eventos «resize» para optimizar el aspecto de la aplicación. Además, reimplementamos el controlador de eventos «close» para interceptar los eventos de cierre antes de terminar la aplicación.

El ejemplo también muestra cómo utilizar QPainter para dibujar una imagen en tiempo real, así como para volver a pintar los widgets.

Captura de pantalla del ejemplo «Scribble»

Con la aplicación Scribble, los usuarios pueden dibujar una imagen. El menú « File » ofrece a los usuarios la posibilidad de abrir y editar un archivo de imagen existente, guardar una imagen y salir de la aplicación. Mientras se dibuja, el menú « Options » permite a los usuarios elegir el color y el grosor del lápiz, así como borrar la pantalla. Además, el menú « Help » proporciona a los usuarios información sobre el ejemplo Scribble en particular y sobre Qt en general.

El ejemplo consta de dos clases:

  • ScribbleArea es un widget personalizado que muestra un « QImage » y permite al usuario dibujar sobre él.
  • MainWindow proporciona un menú situado encima del « ScribbleArea ».

Comenzaremos por repasar la clase « ScribbleArea ». A continuación, repasaremos la clase « MainWindow », que utiliza « ScribbleArea ».

Definición de la clase ScribbleArea

class ScribbleArea : public QWidget
{
    Q_OBJECT

public:
    ScribbleArea(QWidget *parent = nullptr);

    bool openImage(const QString &fileName);
    bool saveImage(const QString &fileName, const char *fileFormat);
    void setPenColor(const QColor &newColor);
    void setPenWidth(int newWidth);

    bool isModified() const { return modified; }
    QColor penColor() const { return myPenColor; }
    int penWidth() const { return myPenWidth; }

public slots:
    void clearImage();
    void print();

protected:
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void paintEvent(QPaintEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;

private:
    void drawLineTo(const QPoint &endPoint);
    void resizeImage(QImage *image, const QSize &newSize);

    bool modified = false;
    bool scribbling = false;
    int myPenWidth = 1;
    QColor myPenColor = Qt::blue;
    QImage image;
    QPoint lastPoint;
};

La clase ` ScribbleArea ` hereda de ` QWidget`. Reimplementamos las funciones ` mousePressEvent()`, ` mouseMoveEvent() ` y ` mouseReleaseEvent() ` para implementar el dibujo. Reimplementamos la función ` paintEvent() ` para actualizar el área de dibujo, y la función ` resizeEvent() ` para garantizar que el ` QImage ` sobre el que dibujamos sea, en todo momento, al menos tan grande como el widget.

Necesitamos varias funciones públicas: openImage() carga una imagen desde un archivo en el área de dibujo, lo que permite al usuario editar la imagen; save() guarda la imagen mostrada actualmente en un archivo; la ranura clearImage() borra la imagen mostrada en el área de dibujo. Necesitamos la función privada drawLineTo() para realizar el dibujo propiamente dicho, y resizeImage() para cambiar el tamaño de un QImage. La ranura print() se encarga de la impresión.

También necesitamos las siguientes variables privadas:

  • modified true si hay cambios sin guardar en la imagen mostrada en el área de dibujo.
  • scribbling true mientras el usuario mantiene pulsado el botón izquierdo del ratón dentro del área de garabatos.
  • penWidth y ` penColor ` contienen el ancho y el color actualmente establecidos para el lápiz utilizado en la aplicación.
  • image almacena la imagen dibujada por el usuario.
  • lastPoint almacena la posición del cursor en el último evento de pulsación o movimiento del ratón.

Implementación de la clase `ScribbleArea`

ScribbleArea::ScribbleArea(QWidget *parent)
    : QWidget(parent)
{
    setAttribute(Qt::WA_StaticContents);
}

En el constructor, establecemos el atributo ` Qt::WA_StaticContents ` del widget, indicando que el contenido del widget está anclado a la esquina superior izquierda y no cambia cuando se redimensiona el widget. Qt utiliza este atributo para optimizar los eventos de dibujo al cambiar el tamaño. Se trata de una mera optimización y solo debe utilizarse para widgets cuyo contenido sea estático y esté anclado a la esquina superior izquierda.

bool ScribbleArea::openImage(const QString &fileName)
{
    QImage loadedImage;
    if (!loadedImage.load(fileName))
        return false;

    QSize newSize = loadedImage.size().expandedTo(size());
    resizeImage(&loadedImage, newSize);
    image = loadedImage;
    modified = false;
    update();
    return true;
}

En la función ` openImage() `, cargamos la imagen especificada. A continuación, redimensionamos el objeto ` QImage ` cargado para que sea, como mínimo, tan grande como el widget en ambas direcciones utilizando la función privada ` resizeImage() `, y establecemos la variable miembro ` image ` para que contenga la imagen cargada. Al final, llamamos a ` QWidget::update()` para programar un repintado.

bool ScribbleArea::saveImage(const QString &fileName, const char *fileFormat)
{
    QImage visibleImage = image;
    resizeImage(&visibleImage, size());

    if (visibleImage.save(fileName, fileFormat)) {
        modified = false;
        return true;
    }
    return false;
}

La función saveImage() crea un objeto QImage que cubre únicamente la sección visible de la imagen image y la guarda mediante QImage::save(). Si la imagen se guarda correctamente, establecemos la variable modified del área de garabatos en false, ya que no hay datos sin guardar.

void ScribbleArea::setPenColor(const QColor &newColor)
{
    myPenColor = newColor;
}

void ScribbleArea::setPenWidth(int newWidth)
{
    myPenWidth = newWidth;
}

Las funciones setPenColor() y setPenWidth() establecen el color y el grosor actuales del lápiz. Estos valores se utilizarán para futuras operaciones de dibujo.

void ScribbleArea::clearImage()
{
    image.fill(qRgb(255, 255, 255));
    modified = true;
    update();
}

La ranura pública clearImage() borra la imagen mostrada en el área de garabatos. Simplemente rellenamos toda la imagen con blanco, lo que se corresponde con el valor RGB (255, 255, 255). Como es habitual cuando modificamos la imagen, establecemos modified en true y programamos un repintado.

void ScribbleArea::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        lastPoint = event->position().toPoint();
        scribbling = true;
    }
}

void ScribbleArea::mouseMoveEvent(QMouseEvent *event)
{
    if ((event->buttons() & Qt::LeftButton) && scribbling)
        drawLineTo(event->position().toPoint());
}

void ScribbleArea::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton && scribbling) {
        drawLineTo(event->position().toPoint());
        scribbling = false;
    }
}

Para los eventos de pulsación y liberación del ratón, utilizamos la función QMouseEvent::button() para averiguar qué botón ha provocado el evento. Para los eventos de movimiento del ratón, utilizamos QMouseEvent::buttons() para determinar qué botones están pulsados en ese momento (como una combinación OR).

Si el usuario pulsa el botón izquierdo del ratón, almacenamos la posición del cursor del ratón en ` lastPoint`. También tomamos nota de que el usuario está garabateando en ese momento. (La variable ` scribbling ` es necesaria porque no podemos dar por sentado que un evento de movimiento o de suelta del ratón vaya siempre precedido de un evento de pulsación del ratón en el mismo widget).

Si el usuario mueve el ratón con el botón izquierdo pulsado o suelta el botón, llamamos a la función privada ` drawLineTo() ` para dibujar.

void ScribbleArea::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    QRect dirtyRect = event->rect();
    painter.drawImage(dirtyRect, image, dirtyRect);
}

En la reimplementación de la función paintEvent(), simplemente creamos un QPainter para el área de garabatos y dibujamos la imagen.

Llegados a este punto, quizá te preguntes por qué no dibujamos directamente sobre el widget en lugar de dibujar en un ` QImage ` y copiar el ` QImage ` a la pantalla en ` paintEvent()`. Hay al menos tres buenas razones para ello:

  • El sistema de ventanas nos exige que podamos redibujar el widget en cualquier momento. Por ejemplo, si la ventana se minimiza y se restaura, es posible que el sistema de ventanas haya olvidado el contenido del widget y nos envíe un evento de pintura. En otras palabras, no podemos confiar en que el sistema de ventanas recuerde nuestra imagen.
  • Normalmente, Qt no nos permite dibujar fuera de ` paintEvent()`. En concreto, no podemos dibujar desde los controladores de eventos del ratón. (Aunque este comportamiento se puede modificar utilizando el atributo del widget ` Qt::WA_PaintOnScreen `).
  • Si se inicializa correctamente, se garantiza que un ` QImage ` utilice 8 bits para cada canal de color (rojo, verde, azul y alfa), mientras que un ` QWidget ` podría tener una profundidad de color menor, dependiendo de la configuración del monitor. Esto significa que, si cargamos una imagen de 24 o 32 bits y la dibujamos en un ` QWidget`, para luego copiar el ` QWidget ` de nuevo en un ` QImage `, podríamos perder parte de la información.
void ScribbleArea::resizeEvent(QResizeEvent *event)
{
    if (width() > image.width() || height() > image.height()) {
        int newWidth = qMax(width() + 128, image.width());
        int newHeight = qMax(height() + 128, image.height());
        resizeImage(&image, QSize(newWidth, newHeight));
        update();
    }
    QWidget::resizeEvent(event);
}

Cuando el usuario inicia la aplicación Scribble, se genera un evento de cambio de tamaño y se crea una imagen que se muestra en el área de dibujo. Hacemos que esta imagen inicial sea ligeramente más grande que la ventana principal de la aplicación y el área de garabatos, para evitar tener que redimensionar siempre la imagen cada vez que el usuario cambie el tamaño de la ventana principal (lo cual sería muy ineficiente). Pero cuando la ventana principal supera este tamaño inicial, es necesario redimensionar la imagen.

void ScribbleArea::drawLineTo(const QPoint &endPoint)
{
    QPainter painter(&image);
    painter.setPen(QPen(myPenColor, myPenWidth, Qt::SolidLine, Qt::RoundCap,
                        Qt::RoundJoin));
    painter.drawLine(lastPoint, endPoint);
    modified = true;

    int rad = (myPenWidth / 2) + 2;
    update(QRect(lastPoint, endPoint).normalized()
                                     .adjusted(-rad, -rad, +rad, +rad));
    lastPoint = endPoint;
}

En ` drawLineTo()`, trazamos una línea desde el punto en el que se encontraba el ratón cuando se produjo la última pulsación o movimiento del ratón, establecemos ` modified ` en `true`, generamos un evento de repintado y actualizamos ` lastPoint ` para que, la próxima vez que se llame a ` drawLineTo() `, continuemos dibujando desde donde lo dejamos.

Podríamos llamar a la función update() sin ningún parámetro, pero como optimización sencilla pasamos un QRect que especifica el rectángulo dentro del área de garabatos que necesita actualizarse, para evitar un redibujado completo del widget.

void ScribbleArea::resizeImage(QImage *image, const QSize &newSize)
{
    if (image->size() == newSize)
        return;

    QImage newImage(newSize, QImage::Format_RGB32);
    newImage.fill(qRgb(255, 255, 255));
    QPainter painter(&newImage);
    painter.drawImage(QPoint(0, 0), *image);
    *image = newImage;
}

QImage no dispone de una API adecuada para cambiar el tamaño de una imagen. Existe una función QImage::copy() que podría servir, pero cuando se utiliza para ampliar una imagen, rellena las nuevas áreas con negro, mientras que nosotros queremos blanco.

Así que el truco consiste en crear un ` QImage ` completamente nuevo con el tamaño adecuado, rellenarlo de blanco y dibujar la imagen antigua sobre él utilizando ` QPainter`. A la nueva imagen se le asigna el formato « QImage::Format_RGB32 », lo que significa que cada píxel se almacena como 0xffRRGGBB (donde RR, GG y BB son los canales de color rojo, verde y azul, y ff es el valor hexadecimal 255).

La impresión se gestiona mediante la ranura « print() »:

void ScribbleArea::print()
{
#if defined(QT_PRINTSUPPORT_LIB) && QT_CONFIG(printdialog)
    QPrinter printer(QPrinter::HighResolution);

    QPrintDialog printDialog(&printer, this);

Creamos un objeto QPrinter de alta resolución para el formato de salida requerido, utilizando un QPrintDialog para pedir al usuario que especifique el tamaño de la página e indique cómo debe formatearse la salida en la misma.

Si se acepta el cuadro de diálogo, llevamos a cabo la tarea de impresión en el dispositivo de dibujo:

    if (printDialog.exec() == QDialog::Accepted) {
        QPainter painter(&printer);
        QRect rect = painter.viewport();
        QSize size = image.size();
        size.scale(rect.size(), Qt::KeepAspectRatio);
        painter.setViewport(rect.x(), rect.y(), size.width(), size.height());
        painter.setWindow(image.rect());
        painter.drawImage(0, 0, image);
    }
#endif // QT_CONFIG(printdialog)
}

Imprimir una imagen en un archivo de esta manera es simplemente cuestión de dibujarla en el QPrinter. Escalamos la imagen para que quepa en el espacio disponible de la página antes de dibujarla en el dispositivo de dibujo.

Definición de la clase MainWindow

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);

protected:
    void closeEvent(QCloseEvent *event) override;

private slots:
    void open();
    void save();
    void penColor();
    void penWidth();
    void about();

private:
    void createActions();
    void createMenus();
    bool maybeSave();
    bool saveFile(const QByteArray &fileFormat);

    ScribbleArea *scribbleArea;

    QMenu *saveAsMenu;
    QMenu *fileMenu;
    QMenu *optionMenu;
    QMenu *helpMenu;

    QAction *openAct;
    QList<QAction *> saveAsActs;
    QAction *exitAct;
    QAction *penColorAct;
    QAction *penWidthAct;
    QAction *printAct;
    QAction *clearScreenAct;
    QAction *aboutAct;
    QAction *aboutQtAct;
};

La clase ` MainWindow ` hereda de ` QMainWindow`. Reimplementamos el controlador ` closeEvent()` de ` QWidget`. Las ranuras ` open()`, ` save()`, ` penColor() ` y ` penWidth() ` corresponden a las entradas del menú. Además, creamos cuatro funciones privadas.

Utilizamos la función booleana « maybeSave() » para comprobar si hay cambios sin guardar. Si hay cambios sin guardar, ofrecemos al usuario la oportunidad de guardarlos. La función devuelve « false » si el usuario hace clic en « Cancel ». Utilizamos la función « saveFile() » para permitir al usuario guardar la imagen que se muestra actualmente en el área de garabatos.

Implementación de la clase MainWindow

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), scribbleArea(new ScribbleArea(this))
{
    setCentralWidget(scribbleArea);

    createActions();
    createMenus();

    setWindowTitle(tr("Scribble"));
    resize(500, 500);
}

En el constructor, creamos un área de dibujo que convertimos en el widget central del widget MainWindow. A continuación, creamos las acciones y los menús asociados.

void MainWindow::closeEvent(QCloseEvent *event)
{
    if (maybeSave())
        event->accept();
    else
        event->ignore();
}

Los eventos de cierre se envían a los widgets que los usuarios desean cerrar, normalmente haciendo clic en « File|Exit » o en el botón de la barra de título « X ». Al reimplementar el controlador de eventos, podemos interceptar los intentos de cerrar la aplicación.

En este ejemplo, utilizamos el evento de cierre para pedir al usuario que guarde los cambios que no haya guardado aún. La lógica para ello se encuentra en la función « maybeSave() ». Si « maybeSave() » devuelve «true», significa que no hay modificaciones o que el usuario las ha guardado correctamente, y aceptamos el evento. La aplicación puede entonces cerrarse con normalidad. Si maybeSave() devuelve «false», el usuario ha hecho clic en « Cancel », por lo que «ignoramos» el evento, sin que la aplicación se vea afectada por él.

void MainWindow::open()
{
    if (maybeSave()) {
        QString fileName = QFileDialog::getOpenFileName(this,
                                   tr("Open File"), QDir::currentPath());
        if (!fileName.isEmpty())
            scribbleArea->openImage(fileName);
    }
}

En la ranura « open() », primero ofrecemos al usuario la oportunidad de guardar cualquier modificación realizada en la imagen que se muestra actualmente, antes de que se cargue una nueva imagen en el área de dibujo. A continuación, le pedimos que elija un archivo y lo cargamos en la ranura « ScribbleArea ».

void MainWindow::save()
{
    QAction *action = qobject_cast<QAction *>(sender());
    QByteArray fileFormat = action->data().toByteArray();
    saveFile(fileFormat);
}

La ranura « save() » se invoca cuando los usuarios seleccionan la entrada de menú « Save As » y, a continuación, eligen una opción del menú «Formato». Lo primero que debemos hacer es averiguar qué acción envió la señal utilizando « QObject::sender()». Esta función devuelve el remitente como un puntero « QObject ». Como sabemos que el remitente es un objeto de acción, podemos realizar el casting de forma segura a « QObject ». Podríamos haber utilizado un casting al estilo C o un ` static_cast<>()` de C++, pero como técnica de programación defensiva utilizamos ` qobject_cast()`. La ventaja es que, si el objeto es de un tipo incorrecto, se devuelve un puntero nulo. Los fallos debidos a punteros nulos son mucho más fáciles de diagnosticar que los debidos a castings inseguros.

Una vez que tenemos la acción, extraemos el formato elegido utilizando QAction::data(). (Al crear las acciones, utilizamos QAction::setData() para establecer nuestros propios datos personalizados asociados a la acción, como un QVariant. Hablaremos más sobre esto cuando repasemos createActions().)

Ahora que conocemos el formato, llamamos a la función privada saveFile() para guardar la imagen que se muestra actualmente.

void MainWindow::penColor()
{
    QColor newColor = QColorDialog::getColor(scribbleArea->penColor());
    if (newColor.isValid())
        scribbleArea->setPenColor(newColor);
}

Utilizamos la ranura penColor() para obtener un nuevo color del usuario mediante QColorDialog. Si el usuario elige un nuevo color, lo establecemos como el color del área de garabatos.

void MainWindow::penWidth()
{
    bool ok;
    int newWidth = QInputDialog::getInt(this, tr("Scribble"),
                                        tr("Select pen width:"),
                                        scribbleArea->penWidth(),
                                        1, 50, 1, &ok);
    if (ok)
        scribbleArea->setPenWidth(newWidth);
}

Para obtener un nuevo grosor de trazo en el slot « penWidth() », utilizamos « QInputDialog ». La clase « QInputDialog » proporciona un sencillo cuadro de diálogo para obtener un único valor del usuario. Utilizamos la función estática « QInputDialog::getInt()», que combina un « QLabel » y un « QSpinBox ». El « QSpinBox » se inicializa con el grosor del lápiz del área de garabatos y admite un rango de 1 a 50, con un incremento de 1 (lo que significa que las flechas arriba y abajo incrementan o disminuyen el valor en 1).

La variable booleana ` ok ` se establecerá en ` true ` si el usuario ha hecho clic en ` OK ` y en ` false ` si ha pulsado ` Cancel`.

void MainWindow::about()
{
    QMessageBox::about(this, tr("About Scribble"),
            tr("<p>The <b>Scribble</b> example shows how to use QMainWindow as the "
               "base widget for an application, and how to reimplement some of "
               "QWidget's event handlers to receive the events generated for "
               "the application's widgets:</p><p> We reimplement the mouse event "
               "handlers to facilitate drawing, the paint event handler to "
               "update the application and the resize event handler to optimize "
               "the application's appearance. In addition we reimplement the "
               "close event handler to intercept the close events before "
               "terminating the application.</p><p> The example also demonstrates "
               "how to use QPainter to draw an image in real time, as well as "
               "to repaint widgets.</p>"));
}

Implementamos la ranura « about() » para crear un cuadro de mensaje que describa lo que el ejemplo está diseñado para mostrar.

void MainWindow::createActions()
{
    openAct = new QAction(tr("&Open..."), this);
    openAct->setShortcuts(QKeySequence::Open);
    connect(openAct, &QAction::triggered, this, &MainWindow::open);

    const QList<QByteArray> imageFormats = QImageWriter::supportedImageFormats();
    for (const QByteArray &format : imageFormats) {
        QString text = tr("%1...").arg(QString::fromLatin1(format).toUpper());

        QAction *action = new QAction(text, this);
        action->setData(format);
        connect(action, &QAction::triggered, this, &MainWindow::save);
        saveAsActs.append(action);
    }

    printAct = new QAction(tr("&Print..."), this);
    connect(printAct, &QAction::triggered, scribbleArea, &ScribbleArea::print);

    exitAct = new QAction(tr("E&xit"), this);
    exitAct->setShortcuts(QKeySequence::Quit);
    connect(exitAct, &QAction::triggered, this, &MainWindow::close);

    penColorAct = new QAction(tr("&Pen Color..."), this);
    connect(penColorAct, &QAction::triggered, this, &MainWindow::penColor);

    penWidthAct = new QAction(tr("Pen &Width..."), this);
    connect(penWidthAct, &QAction::triggered, this, &MainWindow::penWidth);

    clearScreenAct = new QAction(tr("&Clear Screen"), this);
    clearScreenAct->setShortcut(tr("Ctrl+L"));
    connect(clearScreenAct, &QAction::triggered,
            scribbleArea, &ScribbleArea::clearImage);

    aboutAct = new QAction(tr("&About"), this);
    connect(aboutAct, &QAction::triggered, this, &MainWindow::about);

    aboutQtAct = new QAction(tr("About &Qt"), this);
    connect(aboutQtAct, &QAction::triggered, qApp, &QApplication::aboutQt);
}

En la función ` createAction() ` creamos las acciones que representan las entradas del menú y las conectamos a las ranuras correspondientes. En concreto, creamos las acciones que se encuentran en el submenú « Save As ». Utilizamos ` QImageWriter::supportedImageFormats()` para obtener una lista de los formatos compatibles (como un ` QList<QByteArray>`).

A continuación, recorremos la lista, creando una acción para cada formato. Llamamos a ` QAction::setData()` con el formato de archivo, para poder recuperarlo más tarde como ` QAction::data()`. También podríamos haber deducido el formato de archivo a partir del texto de la acción, truncando el «...», pero eso habría resultado poco elegante.

void MainWindow::createMenus()
{
    saveAsMenu = new QMenu(tr("&Save As"), this);
    for (QAction *action : std::as_const(saveAsActs))
        saveAsMenu->addAction(action);

    fileMenu = new QMenu(tr("&File"), this);
    fileMenu->addAction(openAct);
    fileMenu->addMenu(saveAsMenu);
    fileMenu->addAction(printAct);
    fileMenu->addSeparator();
    fileMenu->addAction(exitAct);

    optionMenu = new QMenu(tr("&Options"), this);
    optionMenu->addAction(penColorAct);
    optionMenu->addAction(penWidthAct);
    optionMenu->addSeparator();
    optionMenu->addAction(clearScreenAct);

    helpMenu = new QMenu(tr("&Help"), this);
    helpMenu->addAction(aboutAct);
    helpMenu->addAction(aboutQtAct);

    menuBar()->addMenu(fileMenu);
    menuBar()->addMenu(optionMenu);
    menuBar()->addMenu(helpMenu);
}

En la función ` createMenu() `, añadimos las acciones de formato creadas anteriormente a ` saveAsMenu`. A continuación, añadimos el resto de las acciones, así como el submenú « saveAsMenu », a los menús « File », « Options » y « Help ».

La clase « QMenu » proporciona un control de menú para su uso en barras de menú, menús contextuales y otros menús emergentes. La clase « QMenuBar » proporciona una barra de menú horizontal con una lista de menús desplegables « QMenu». Al final, colocamos los menús « File » y « Options » en la barra de menú de « MainWindow », que recuperamos mediante la función « QMainWindow::menuBar()».

bool MainWindow::maybeSave()
{
    if (scribbleArea->isModified()) {
       QMessageBox::StandardButton ret;
       ret = QMessageBox::warning(this, tr("Scribble"),
                          tr("The image has been modified.\n"
                             "Do you want to save your changes?"),
                          QMessageBox::Save | QMessageBox::Discard
                          | QMessageBox::Cancel);
        if (ret == QMessageBox::Save)
            return saveFile("png");
        else if (ret == QMessageBox::Cancel)
            return false;
    }
    return true;
}

En mayBeSave(), comprobamos si hay cambios sin guardar. Si los hay, utilizamos QMessageBox para avisar al usuario de que la imagen se ha modificado y ofrecerle la oportunidad de guardar los cambios.

Al igual que con QColorDialog y QFileDialog, la forma más sencilla de crear un QMessageBox es utilizar sus funciones estáticas. QMessageBox ofrece una variedad de mensajes diferentes organizados en dos ejes: gravedad (pregunta, información, advertencia y crítico) y complejidad (el número de botones de respuesta necesarios). Aquí utilizamos la función warning(), ya que el mensaje es bastante importante.

Si el usuario decide guardar el archivo, llamamos a la función privada saveFile(). Por simplicidad, utilizamos PNG como formato de archivo; el usuario siempre puede pulsar Cancel y guardar el archivo en otro formato.

La función maybeSave() devuelve false si el usuario hace clic en Cancel; en caso contrario, devuelve true.

bool MainWindow::saveFile(const QByteArray &fileFormat)
{
    QString initialPath = QDir::currentPath() + "/untitled." + fileFormat;

    QString fileName = QFileDialog::getSaveFileName(this, tr("Save As"),
                               initialPath,
                               tr("%1 Files (*.%2);;All Files (*)")
                               .arg(QString::fromLatin1(fileFormat.toUpper()))
                               .arg(QString::fromLatin1(fileFormat)));
    if (fileName.isEmpty())
        return false;
    return scribbleArea->saveImage(fileName, fileFormat.constData());
}

En saveFile(), mostramos un cuadro de diálogo de archivo con una sugerencia de nombre de archivo. La función estática QFileDialog::getSaveFileName() devuelve el nombre de archivo seleccionado por el usuario. No es necesario que el archivo exista.

Proyecto de ejemplo en @ code.qt.io

© 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.