En esta página

Cómo hacer una captura de pantalla

El ejemplo «Captura de pantalla» muestra cómo realizar una captura de pantalla del escritorio.

Aplicación con opciones para realizar capturas de pantalla del escritorio

Con esta aplicación, los usuarios pueden hacer una captura de pantalla de su escritorio. Disponen de varias opciones:

  • Retrasar la captura de pantalla, lo que les da tiempo para reorganizar el escritorio.
  • Ocultar la ventana de la aplicación mientras se realiza la captura de pantalla.

Además, la aplicación permite a los usuarios guardar la captura de pantalla si lo desean.

Definición de la clase Screenshot

class Screenshot : public QWidget
{
    Q_OBJECT

public:
    Screenshot();

protected:
    void resizeEvent(QResizeEvent *event) override;

private slots:
    void newScreenshot();
    void saveScreenshot();
    void shootScreen();
    void updateCheckBox();

private:
    void updateScreenshotLabel();

    QPixmap originalPixmap;

    QLabel *screenshotLabel;
    QSpinBox *delaySpinBox;
    QCheckBox *hideThisWindowCheckBox;
    QPushButton *newScreenshotButton;
    QPushButton *saveScreenshotButton;
};

La clase ` Screenshot ` hereda de ` QWidget ` y es el widget principal de la aplicación. Muestra las opciones de la aplicación y una vista previa de la captura de pantalla.

Reimplementamos la función ` QWidget::resizeEvent()` para asegurarnos de que la vista previa de la captura de pantalla se escala correctamente cuando el usuario cambia el tamaño del widget de la aplicación. También necesitamos varias ranuras privadas para gestionar las opciones:

  • La ranura newScreenshot() prepara una nueva captura de pantalla.
  • La ranura « saveScreenshot() » guarda la última captura de pantalla.
  • La ranura « shootScreen() » realiza la captura de pantalla.
  • La ranura updateCheckBox() activa o desactiva la opción « Hide This Window ».

También declaramos la función privada ` updateScreenshotLabel() `, que se invoca cada vez que se realiza una nueva captura de pantalla o cuando un evento de redimensionamiento cambia el tamaño de la etiqueta de vista previa de la captura.

Además, necesitamos almacenar el mapa de píxeles original de la captura de pantalla. El motivo es que, al mostrar la vista previa de la captura de pantalla, necesitamos escalar su mapa de píxeles; al almacenar el original, nos aseguramos de que no se pierdan datos en ese proceso.

Implementación de la clase Screenshot

Screenshot::Screenshot()
    :  screenshotLabel(new QLabel(this))
{
    screenshotLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    screenshotLabel->setAlignment(Qt::AlignCenter);

    const QRect screenGeometry = screen()->geometry();
    screenshotLabel->setMinimumSize(screenGeometry.width() / 8, screenGeometry.height() / 8);
    screenshotLabel->setFrameShape(QFrame::Box);

    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(screenshotLabel);

    QGroupBox *optionsGroupBox = new QGroupBox(tr("Options"), this);
    delaySpinBox = new QSpinBox(optionsGroupBox);
    delaySpinBox->setSuffix(tr(" s"));
    delaySpinBox->setMaximum(60);

    connect(delaySpinBox, &QSpinBox::valueChanged,
            this, &Screenshot::updateCheckBox);

    hideThisWindowCheckBox = new QCheckBox(tr("Hide This Window"), optionsGroupBox);

    QGridLayout *optionsGroupBoxLayout = new QGridLayout(optionsGroupBox);
    optionsGroupBoxLayout->addWidget(new QLabel(tr("Screenshot Delay:"), this), 0, 0);
    optionsGroupBoxLayout->addWidget(delaySpinBox, 0, 1);
    optionsGroupBoxLayout->addWidget(hideThisWindowCheckBox, 1, 0, 1, 2);

    mainLayout->addWidget(optionsGroupBox);

    QHBoxLayout *buttonsLayout = new QHBoxLayout;
    newScreenshotButton = new QPushButton(tr("New Screenshot"), this);
    connect(newScreenshotButton, &QPushButton::clicked, this, &Screenshot::newScreenshot);
    buttonsLayout->addWidget(newScreenshotButton);
    saveScreenshotButton = new QPushButton(tr("Save Screenshot"), this);
    connect(saveScreenshotButton, &QPushButton::clicked, this, &Screenshot::saveScreenshot);
    buttonsLayout->addWidget(saveScreenshotButton);
    QPushButton *quitScreenshotButton = new QPushButton(tr("Quit"), this);
    quitScreenshotButton->setShortcut(Qt::CTRL | Qt::Key_Q);
    connect(quitScreenshotButton, &QPushButton::clicked, this, &QWidget::close);
    buttonsLayout->addWidget(quitScreenshotButton);
    buttonsLayout->addStretch();
    mainLayout->addLayout(buttonsLayout);

    shootScreen();
    delaySpinBox->setValue(5);

    setWindowTitle(tr("Screenshot"));
    resize(300, 200);
}

En el constructor, primero creamos el objeto ` QLabel ` que muestra la vista previa de la captura de pantalla.

Establecemos la política de tamaño del « QLabel » para que sea « QSizePolicy::Expanding » tanto en horizontal como en vertical. Esto significa que la sugerencia de tamaño del « QLabel » es un tamaño razonable, pero el widget puede reducirse y seguir siendo útil. Además, el widget puede aprovechar el espacio adicional, por lo que debería ocupar todo el espacio posible. A continuación, nos aseguramos de que el QLabel esté alineado en el centro del widget Screenshot y establecemos su tamaño mínimo.

A continuación, creamos un cuadro de grupo que contendrá todos los widgets de las opciones. Después, creamos un « QSpinBox » y un « QLabel » para la opción « Screenshot Delay », y conectamos el «spinbox» a la ranura « updateCheckBox() ». Por último, creamos un « QCheckBox » para la opción « Hide This Window », añadimos todos los widgets de las opciones a un « QGridLayout » instalado en el cuadro de grupo.

Creamos los botones de la aplicación y el cuadro de grupo que contiene las opciones de la misma, y lo colocamos todo en un diseño principal. Por último, tomamos la captura de pantalla inicial y configuramos el retraso inicial y el título de la ventana, antes de ajustar el tamaño del widget a unas dimensiones adecuadas en función de la geometría de la pantalla.

void Screenshot::resizeEvent(QResizeEvent * /* event */)
{
    if (!originalPixmap.isNull()) {
        QSize scaledSize = originalPixmap.size();
        scaledSize.scale(screenshotLabel->size(), Qt::KeepAspectRatio);
        if (scaledSize != screenshotLabel->pixmap().size())
            updateScreenshotLabel();
    }
}

La función ` resizeEvent() ` se reimplementa para recibir los eventos de cambio de tamaño enviados al widget. El objetivo es escalar el mapa de píxeles de la captura de pantalla de vista previa sin deformar su contenido, así como garantizar que el tamaño de la aplicación se pueda ajustar con fluidez.

Para lograr el primer objetivo, escalamos la imagen de la captura de pantalla mediante Qt::KeepAspectRatio. Escalamos la imagen a un rectángulo lo más grande posible dentro del tamaño actual de la etiqueta de vista previa de la captura de pantalla, conservando la relación de aspecto. Esto significa que, si el usuario cambia el tamaño de la ventana de la aplicación en una sola dirección, la captura de pantalla de vista previa mantiene el mismo tamaño.

Para alcanzar nuestro segundo objetivo, nos aseguramos de que la captura de pantalla de vista previa solo se vuelva a dibujar (utilizando la función privada ` updateScreenshotLabel() `) cuando realmente cambie de tamaño.

void Screenshot::newScreenshot()
{
    if (hideThisWindowCheckBox->isChecked())
        hide();
    newScreenshotButton->setDisabled(true);

    QTimer::singleShot(delaySpinBox->value() * 1000, this, &Screenshot::shootScreen);
}

La ranura privada ` newScreenshot() ` se invoca cuando el usuario solicita una nueva captura de pantalla; sin embargo, esta ranura solo se encarga de preparar una nueva captura de pantalla.

Primero comprobamos si la opción « Hide This Window » está marcada; si lo está, ocultamos el widget « Screenshot ». A continuación, desactivamos el botón « New Screenshot », para asegurarnos de que el usuario solo pueda solicitar una captura de pantalla cada vez.

Creamos un temporizador utilizando la clase ` QTimer `, que ofrece temporizadores repetitivos y de una sola vez. Configuramos el temporizador para que expire una sola vez, utilizando la función estática ` QTimer::singleShot()`. Esta función llama al slot privado ` shootScreen() ` tras el intervalo de tiempo especificado por la opción ` Screenshot Delay `. Es ` shootScreen() ` el que realmente realiza la captura de pantalla.

void Screenshot::saveScreenshot()
{
    const QString format = "png";
    QString initialPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
    if (initialPath.isEmpty())
        initialPath = QDir::currentPath();
    initialPath += tr("/untitled.") + format;

    QFileDialog fileDialog(this, tr("Save As"), initialPath);
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    fileDialog.setFileMode(QFileDialog::AnyFile);
    fileDialog.setDirectory(initialPath);
    QStringList mimeTypes;
    const QList<QByteArray> baMimeTypes = QImageWriter::supportedMimeTypes();
    for (const QByteArray &bf : baMimeTypes)
        mimeTypes.append(QLatin1String(bf));
    fileDialog.setMimeTypeFilters(mimeTypes);
    fileDialog.selectMimeTypeFilter("image/" + format);
    fileDialog.setDefaultSuffix(format);
    if (fileDialog.exec() != QDialog::Accepted)
        return;
    const QString fileName = fileDialog.selectedFiles().first();
    if (!originalPixmap.save(fileName)) {
        QMessageBox::warning(this, tr("Save Error"), tr("The image could not be saved to \"%1\".")
                             .arg(QDir::toNativeSeparators(fileName)));
    }
}

La ranura saveScreenshot() se invoca cuando el usuario pulsa el botón Save, y muestra un cuadro de diálogo de archivos utilizando la clase QFileDialog.

QFileDialog permite al usuario navegar por el sistema de archivos para seleccionar uno o varios archivos o un directorio. La forma más sencilla de crear un QFileDialog es utilizar las funciones estáticas de conveniencia. Aquí, instanciamos el cuadro de diálogo en la pila para poder configurar los tipos MIME admitidos por QImageWriter, lo que permite al usuario guardar en diversos formatos.

Definimos el formato de archivo predeterminado como png y establecemos la ruta inicial del cuadro de diálogo de archivo en la ubicación de las imágenes obtenida de QStandardPaths, que por defecto es la ruta desde la que se ejecuta la aplicación.

Ejecutamos el cuadro de diálogo llamando a ` QDialog::exec()` y salimos si el usuario ha cancelado el cuadro de diálogo. Si se ha aceptado el cuadro de diálogo, obtenemos un nombre de archivo llamando a ` QFileDialog::selectedFiles()`. No es necesario que el archivo exista. Si el nombre de archivo es válido, utilizamos la función ` QPixmap::save()` para guardar el mapa de píxeles original de la captura de pantalla en ese archivo.

void Screenshot::shootScreen()
{
    if (delaySpinBox->value() != 0)
        QApplication::beep();

    originalPixmap = screen()->grabWindow(0);
    updateScreenshotLabel();

    newScreenshotButton->setDisabled(false);
    if (hideThisWindowCheckBox->isChecked())
        show();
}

Se invoca la ranura shootScreen() para realizar la captura de pantalla.

Si el usuario ha optado por retrasar la captura de pantalla, hacemos que la aplicación emita un pitido cuando se realiza la captura mediante la función estática QApplication::beep().

A continuación, tomamos la captura de pantalla utilizando la función ` QScreen::grabWindow()` sobre la pantalla devuelta por ` QWidget::screen()`. La función captura el contenido de la ventana pasada como argumento, crea un mapa de píxeles a partir de él y devuelve dicho mapa. El identificador de la ventana se puede obtener con QWidget::winId() o QWindow::winId(). Sin embargo, en este caso simplemente pasamos 0 como identificador de ventana, lo que indica que queremos capturar toda la pantalla.

Actualizamos la etiqueta de vista previa de la captura de pantalla utilizando la función privada ` updateScreenshotLabel() `. A continuación, activamos el botón « New Screenshot » y, por último, hacemos visible el widget ` Screenshot ` si se había ocultado durante la captura de pantalla.

void Screenshot::updateCheckBox()
{
    if (delaySpinBox->value() == 0) {
        hideThisWindowCheckBox->setDisabled(true);
        hideThisWindowCheckBox->setChecked(false);
    } else {
        hideThisWindowCheckBox->setDisabled(false);
    }
}

La opción « Hide This Window » se activa o desactiva en función del retraso de la captura de pantalla. Si no hay retraso, la ventana de la aplicación no se puede ocultar y la casilla de verificación de la opción queda desactivada.

La ranura « updateCheckBox() » se invoca cada vez que el usuario cambia el retraso mediante la opción « Screenshot Delay ».

void Screenshot::updateScreenshotLabel()
{
    if (originalPixmap.isNull()) {
        saveScreenshotButton->setEnabled(false);
        screenshotLabel->setText(tr("Grabbing \"%1\" failed.").arg(screen()->name()));
    } else {
        saveScreenshotButton->setEnabled(true);
        screenshotLabel->setPixmap(originalPixmap.scaled(screenshotLabel->size(),
                                                         Qt::KeepAspectRatio,
                                                         Qt::SmoothTransformation));
    }
}

La función privada ` updateScreenshotLabel() ` se invoca cada vez que cambia la captura de pantalla, o cuando un evento de redimensionamiento modifica el tamaño de la etiqueta de vista previa de la captura de pantalla.

En primer lugar, gestionamos el caso de fallo. En algunas plataformas, concretamente en Wayland, no es posible recuperar el contenido de la pantalla. En este caso, el mapa de píxeles está vacío, tal y como indica QPixmap::isNull(). Establecemos una cadena de error en la etiqueta y desactivamos el botón para guardar.

Si se ha obtenido un mapa de píxeles, actualizamos la etiqueta de la vista previa de la captura de pantalla utilizando las funciones ` QLabel::setPixmap()` y ` QPixmap::scaled()`.

QPixmap::scaled() devuelve una copia del mapa de píxeles dado, escalado a un rectángulo del tamaño especificado según los parámetros Qt::AspectRatioMode y Qt::TransformationMode.

Escalamos el mapa de píxeles original para que se ajuste al tamaño de la etiqueta de la captura de pantalla actual, conservando la relación de aspecto y suavizando los bordes del mapa de píxeles resultante.

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.