QPixmap Class

Documentación de las funciones miembro

QPixmap::QPixmap()

Construye un pixmap nulo.

Véase también isNull().

[explicit] QPixmap::QPixmap(const char *const[] xpm)

Construye un mapa de píxeles a partir de los datos de xpm, que deben ser una imagen XPM válida.

Los errores se ignoran silenciosamente.

Tenga en cuenta que es posible exprimir un poco la variable XPM utilizando una declaración inusual:

static const char * const start_xpm[] = {
    "16 15 8 1",
    "a c #cec6bd",
    // etc.
};

El extra const hace que toda la definición sea de sólo lectura, lo que es ligeramente más eficiente (por ejemplo, cuando el código está en una biblioteca compartida) y ROMable cuando la aplicación va a ser almacenada en ROM.

QPixmap::QPixmap(int width, int height)

Construye un mapa de píxeles con los valores width y height. Si width o height son cero, se construye un mapa de píxeles nulo.

Ver también isNull().

QPixmap::QPixmap(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Construye un mapa de píxeles a partir del archivo con la dirección fileName. Si el archivo no existe o tiene un formato desconocido, el mapa de píxeles se convierte en un mapa de píxeles nulo.

El cargador intenta leer el mapa de píxeles utilizando la dirección format especificada. Si no se especifica format (que es el valor predeterminado), el cargador sondea el archivo en busca de una cabecera para adivinar el formato del archivo.

El nombre del archivo puede referirse a un archivo real en disco o a uno de los recursos incrustados de la aplicación. Consulte la descripción general del sistema de recursos para obtener más información sobre cómo incrustar imágenes y otros archivos de recursos en el ejecutable de la aplicación.

Si es necesario modificar la imagen para que se ajuste a un resultado de menor resolución (por ejemplo, convertirla de 32 bits a 8 bits), utiliza flags para controlar la conversión.

Los parámetros fileName, format y flags se pasan a load(). Esto significa que los datos de fileName no se compilan en el binario. Si fileName contiene una ruta relativa (por ejemplo, sólo el nombre del archivo), el archivo correspondiente debe encontrarse en relación con el directorio de trabajo en tiempo de ejecución.

Véase también Reading and Writing Image Files.

[explicit] QPixmap::QPixmap(const QSize &size)

Construye un pixmap de la dirección size.

QPixmap::QPixmap(const QPixmap &pixmap)

Construye un pixmap que es una copia del pixmap dado.

Véase también copy().

[noexcept] QPixmap::QPixmap(QPixmap &&other)

Move-construye una instancia de QPixmap a partir de other.

Véase también swap() y operator=(QPixmap&&).

[virtual noexcept] QPixmap::~QPixmap()

Destruye el mapa de píxeles.

qint64 QPixmap::cacheKey() const

Devuelve un número que identifica a este QPixmap. Objetos QPixmap distintos sólo pueden tener la misma clave de caché si se refieren al mismo contenido.

La cacheKey() cambiará cuando se modifique el mapa de píxeles.

bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor)

Reemplaza los datos de este mapa de píxeles con el image dado utilizando el flags especificado para controlar la conversión. El argumento flags es un bitwise-OR de Qt::ImageConversionFlags. Pasando 0 para flags se establecen todas las opciones por defecto. Devuelve true si el resultado es que este pixmap no es nulo.

Véase también fromImage().

QPixmap QPixmap::copy(const QRect &rectangle = QRect()) const

Devuelve una copia en profundidad del subconjunto del mapa de píxeles especificado en rectangle. Para obtener más información sobre las copias profundas, consulte la documentación sobre la compartición implícita de datos.

Si rectangle está vacío, se copiará la imagen completa.

Véase también operator=(), QPixmap() y Pixmap Transformations.

QPixmap QPixmap::copy(int x, int y, int width, int height) const

Devuelve una copia en profundidad del subconjunto del mapa de píxeles especificado por el rectángulo QRect( x, y, width, height).

QBitmap QPixmap::createHeuristicMask(bool clipTight = true) const

Crea y devuelve una máscara heurística para este mapa de píxeles.

La función trabaja seleccionando un color de una de las esquinas y luego recortando píxeles de ese color, empezando por todos los bordes. Si clipTight es verdadero (por defecto) la máscara es lo suficientemente grande como para cubrir los píxeles; de lo contrario, la máscara es más grande que los píxeles de datos.

La máscara puede no ser perfecta pero debería ser razonable, por lo que se pueden hacer cosas como las siguientes:

QPixmap myPixmap;
myPixmap.setMask(myPixmap.createHeuristicMask());

Esta función es lenta porque implica convertir a/desde un QImage, y cálculos no triviales.

Véase también QImage::createHeuristicMask() y createMaskFromColor().

QBitmap QPixmap::createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode = Qt::MaskInColor) const

Crea y devuelve una máscara para este mapa de píxeles basada en maskColor. Si mode es Qt::MaskInColor, todos los píxeles que coincidan con maskColor serán transparentes. Si mode es Qt::MaskOutColor, todos los píxeles que coincidan con maskColor serán opacos.

Esta función es lenta porque implica la conversión a/desde QImage.

Véase también createHeuristicMask() y QImage::createMaskFromColor().

[static] int QPixmap::defaultDepth()

Devuelve la profundidad de pixmap por defecto utilizada por la aplicación.

En todas las plataformas se devolverá la profundidad de la pantalla primaria.

Véase también depth() y Pixmap Information.

int QPixmap::depth() const

Devuelve la profundidad del mapa de píxeles.

La profundidad del mapa de píxeles también se denomina bits por píxel (bpp) o planos de bits de un mapa de píxeles. Un pixmap nulo tiene profundidad 0.

Véase también defaultDepth() y Pixmap Information.

void QPixmap::detach()

Desvincula el mapa de píxeles de los datos compartidos.

Qt separa automáticamente un mapa de píxeles cuando su contenido está a punto de cambiar. Esto se hace en casi todas las funciones miembro de QPixmap que modifican el pixmap (fill(), fromImage(), load(), etc.), y en QPainter::begin() sobre un pixmap.

Hay dos excepciones en las que se debe llamar explícitamente a detach(), es decir, cuando se llama a la función handle() o a la función x11PictureHandle() (sólo disponible en X11). En caso contrario, cualquier modificación realizada mediante llamadas al sistema, se realizará sobre los datos compartidos.

La función detach() retorna inmediatamente si sólo hay una referencia o si el pixmap no ha sido inicializado todavía.

[since 6.2] QSizeF QPixmap::deviceIndependentSize() const

Devuelve el tamaño del mapa de píxeles en píxeles independientes del dispositivo.

Este valor debe utilizarse cuando se utilice el tamaño del mapa de píxeles en los cálculos de tamaño de la interfaz de usuario.

El valor devuelto es equivalente a pixmap.size() / pixmap.devicePixelRatio().

Esta función se introdujo en Qt 6.2.

qreal QPixmap::devicePixelRatio() const

Devuelve la proporción de píxeles del dispositivo para el mapa de píxeles. Es la relación entre los píxeles del dispositivo y los píxeles independientes del dispositivo.

Utilice esta función cuando calcule la geometría del diseño basándose en el tamaño del mapa de píxeles: QSize layoutSize = image.size() / image.devicePixelRatio()

El valor por defecto es 1.0.

Véase también setDevicePixelRatio() y QImageReader.

void QPixmap::fill(const QColor &color = Qt::white)

Rellena el mapa de píxeles con la dirección color.

El efecto de esta función es indefinido cuando el pixmap está siendo pintado.

Véase también Pixmap Transformations.

[static] QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor)

Convierte el image dado en un mapa de píxeles utilizando el flags especificado para controlar la conversión. El argumento flags es un bitwise-OR de Qt::ImageConversionFlags. Si se pasa 0 por flags se establecen todas las opciones por defecto.

En el caso de imágenes monocromas y de 8 bits, la imagen se convierte primero en un mapa de píxeles de 32 bits y luego se rellena con los colores de la tabla de colores. Si esta operación es demasiado costosa, puede utilizar QBitmap::fromImage() en su lugar.

Véase también fromImageReader(), toImage() y Pixmap Conversion.

[static] QPixmap QPixmap::fromImage(QImage &&image, Qt::ImageConversionFlags flags = Qt::AutoColor)

Convierte el image dado en un pixmap sin copiar si es posible.

[static] QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor)

Crea un QPixmap a partir de una imagen leída directamente de un imageReader. El argumento flags es un bitwise-OR del Qt::ImageConversionFlags. Pasar 0 para flags fija todas las opciones por defecto.

En algunos sistemas, leer una imagen directamente a QPixmap puede utilizar menos memoria que leer una QImage para convertirla a QPixmap.

Véase también fromImage(), toImage() y Pixmap Conversion.

bool QPixmap::hasAlpha() const

Devuelve true si este pixmap tiene un canal alfa, o tiene una máscara, en caso contrario devuelve false.

Véase también hasAlphaChannel() y mask().

bool QPixmap::hasAlphaChannel() const

Devuelve true si el pixmap tiene un formato que respeta el canal alfa, en caso contrario devuelve false.

Véase también hasAlpha().

int QPixmap::height() const

Devuelve la altura del pixmap.

Véase también size() y Pixmap Information.

bool QPixmap::isNull() const

Devuelve true si se trata de un mapa de píxeles nulo; en caso contrario, devuelve false.

Un mapa de píxeles nulo tiene anchura cero, altura cero y ningún contenido. No se puede dibujar en un mapa de píxeles nulo.

bool QPixmap::isQBitmap() const

Devuelve true si se trata de un QBitmap; en caso contrario devuelve false.

bool QPixmap::load(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Carga un mapa de píxeles desde el archivo con la dirección fileName. Devuelve true si el mapa de píxeles se ha cargado correctamente; en caso contrario, invalida el mapa de píxeles y devuelve false.

El cargador intenta leer el mapa de píxeles utilizando la dirección format especificada. Si no se especifica format (que es el valor predeterminado), el cargador sondea el archivo en busca de una cabecera para adivinar el formato del archivo.

El nombre del archivo puede referirse a un archivo real en disco o a uno de los recursos incrustados de la aplicación. Consulte la descripción general del sistema de recursos para obtener más información sobre cómo incrustar mapas de píxeles y otros archivos de recursos en el ejecutable de la aplicación.

Si es necesario modificar los datos para que quepan en un resultado de menor resolución (por ejemplo, convertir de 32 bits a 8 bits), utilice flags para controlar la conversión.

Tenga en cuenta que los QPixmaps se añaden automáticamente a QPixmapCache cuando se cargan desde un archivo en el hilo principal; la clave utilizada es interna y no puede adquirirse.

Véase también loadFromData() y Reading and Writing Image Files.

bool QPixmap::loadFromData(const uchar *data, uint len, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Carga un mapa de píxeles a partir de los len primeros bytes del binario dado data. Devuelve true si el mapa de píxeles se ha cargado correctamente; en caso contrario, invalida el mapa de píxeles y devuelve false.

El cargador intenta leer el mapa de píxeles utilizando el format especificado. Si no se especifica format (que es el valor predeterminado), el cargador sondea el archivo en busca de una cabecera para adivinar el formato del archivo.

Si es necesario modificar los datos para que quepan en un resultado de menor resolución (por ejemplo, convertir de 32 bits a 8 bits), utilice flags para controlar la conversión.

Véase también load() y Reading and Writing Image Files.

bool QPixmap::loadFromData(const QByteArray &data, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)

Carga un mapa de píxeles desde el binario data utilizando el format especificado y la conversión flags.

QBitmap QPixmap::mask() const

Extrae una máscara de mapa de bits del canal alfa del mapa de píxeles.

Véase también setMask() y Pixmap Information.

QRect QPixmap::rect() const

Devuelve el rectángulo que rodea al mapa de píxeles.

Véase también Pixmap Information.

bool QPixmap::save(const QString &fileName, const char *format = nullptr, int quality = -1) const

Guarda el mapa de píxeles en el archivo con el valor fileName utilizando el archivo de imagen format y el factor quality especificados. Devuelve true si tiene éxito; en caso contrario devuelve false.

El factor quality debe estar en el rango [0,100] o -1. Especifique 0 para obtener archivos comprimidos pequeños, 100 para archivos grandes sin comprimir y -1 para utilizar la configuración predeterminada.

Si format es nullptr, se elegirá un formato de imagen a partir del sufijo de fileName.

Véase también Reading and Writing Image Files.

bool QPixmap::save(QIODevice *device, const char *format = nullptr, int quality = -1) const

Esta función escribe un QPixmap en el device dado utilizando el archivo de imagen format y el factor quality especificados. Puede utilizarse, por ejemplo, para guardar un mapa de píxeles directamente en QByteArray:

QPixmap pixmap;
QByteArray bytes;
QBuffer buffer(&bytes);
buffer.open(QIODevice::WriteOnly);
pixmap.save(&buffer, "PNG"); // writes pixmap into bytes in PNG format

QPixmap QPixmap::scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const

Escala el mapa de píxeles al valor size, utilizando la relación de aspecto y los modos de transformación especificados en aspectRatioMode y transformMode.

• Si aspectRatioMode es Qt::IgnoreAspectRatio, el mapa de píxeles se escala a size.
• Si aspectRatioMode es Qt::KeepAspectRatio, el mapa de píxeles se escala a un rectángulo lo más grande posible dentro de size, conservando la relación de aspecto.
• Si aspectRatioMode es Qt::KeepAspectRatioByExpanding, el mapa de píxeles se escala a un rectángulo lo más pequeño posible fuera de size, preservando la relación de aspecto.

Si size está vacío, esta función devuelve un mapa de píxeles nulo.

En algunos casos puede ser más beneficioso dibujar el pixmap a un pintor con una escala establecida en lugar de escalar el pixmap. Este es el caso cuando el pintor se basa, por ejemplo, en OpenGL o cuando el factor de escala cambia rápidamente.

Véase también isNull() y Pixmap Transformations.

QPixmap QPixmap::scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const

Devuelve una copia del mapa de píxeles escalado a un rectángulo con los valores width y height según los valores aspectRatioMode y transformMode.

Si width o height son cero o negativos, esta función devuelve un pixmap nulo.

QPixmap QPixmap::scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const

Devuelve una copia escalada de la imagen. La imagen devuelta se escala al height dado utilizando la transformación especificada mode. La anchura del mapa de píxeles se calcula automáticamente para que se mantenga la relación de aspecto del mapa de píxeles.

Si height es 0 o negativo, se devuelve un mapa de píxeles nulo.

Véase también isNull() y Pixmap Transformations.

QPixmap QPixmap::scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const

Devuelve una copia escalada de la imagen. La imagen devuelta se escala al width dado utilizando la transformación especificada mode. La altura del mapa de píxeles se calcula automáticamente para conservar la relación de aspecto del mapa de píxeles.

Si width es 0 o negativo, se devuelve un pixmap nulo.

Véase también isNull() y Pixmap Transformations.

void QPixmap::scroll(int dx, int dy, const QRect &rect, QRegion *exposed = nullptr)

Desplaza el área rect de este mapa de píxeles por (dx, dy). La región expuesta se deja sin cambios. Puede pasar opcionalmente un puntero a un QRegion vacío para obtener la región que es exposed por la operación de desplazamiento.

QPixmap pixmap("background.png");
QRegion exposed;
pixmap.scroll(10, 10, pixmap.rect(), &exposed);

No puedes desplazarte mientras haya un pintor activo en el pixmap.

Véase también QWidget::scroll() y QGraphicsItem::scroll().

void QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = nullptr)

Esta función es equivalente a llamar a QPixmap::scroll(dx, dy, QRect(x, y, width, height), exposed).

Véase también QWidget::scroll() y QGraphicsItem::scroll().

void QPixmap::setDevicePixelRatio(qreal scaleFactor)

Establece la proporción de píxeles del dispositivo para el mapa de píxeles. Es la relación entre los píxeles de la imagen y los píxeles independientes del dispositivo.

Por defecto scaleFactor es 1.0. Establecerlo a otro valor tiene dos efectos:

Los QPainters que se abran sobre el pixmap serán escalados. Por ejemplo, pintar sobre una imagen de 200x200 con un ratio de 2.0 resultará en unos límites de pintura efectivos (independientes del dispositivo) de 100x100.

Las rutas de código en Qt que calculan la geometría del diseño basándose en el tamaño del mapa de píxeles tendrán en cuenta la relación: QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio() El efecto neto de esto es que el mapa de píxeles se muestra como un mapa de píxeles de alto PPP en lugar de un mapa de píxeles grande (véase Drawing High Resolution Versions of Pixmaps and Images).

Véase también devicePixelRatio() y deviceIndependentSize().

void QPixmap::setMask(const QBitmap &mask)

Establece una máscara de mapa de bits.

Esta función fusiona el mask con el canal alfa del mapa de píxeles. Un valor de píxel de 1 en la máscara significa que el píxel del mapa de píxeles no cambia; un valor de 0 significa que el píxel es transparente. La máscara debe tener el mismo tamaño que el mapa de píxeles.

Establecer una máscara nula reinicia la máscara, dejando los píxeles previamente transparentes en negro. El efecto de esta función es indefinido cuando el pixmap está siendo pintado.

Véase también mask(), Pixmap Transformations, y QBitmap.

QSize QPixmap::size() const

Devuelve el tamaño del mapa de píxeles.

Véase también width(), height(), y Pixmap Information.

[noexcept] void QPixmap::swap(QPixmap &other)

Intercambia este pixmap con other. Esta operación es muy rápida y nunca falla.

QImage QPixmap::toImage() const

Convierte el mapa de píxeles en QImage. Devuelve una imagen nula si la conversión falla.

Si el mapa de píxeles tiene una profundidad de 1 bit, la imagen devuelta también tendrá una profundidad de 1 bit. Las imágenes con más bits se devolverán en un formato que represente fielmente el sistema subyacente. Normalmente será QImage::Format_ARGB32_Premultiplied para pixmaps con alfa y QImage::Format_RGB32 o QImage::Format_RGB16 para pixmaps sin alfa.

Tenga en cuenta que, por el momento, se ignoran las máscaras alfa de las imágenes monocromas.

Véase también fromImage() y Image Formats.

QPixmap QPixmap::transformed(const QTransform &transform, Qt::TransformationMode mode = Qt::FastTransformation) const

Devuelve una copia del mapa de píxeles transformado utilizando la transformación transform y la transformación mode dadas. El mapa de píxeles original no se modifica.

La transformación transform se ajusta internamente para compensar la traslación no deseada; es decir, el mapa de píxeles producido es el mapa de píxeles más pequeño que contiene todos los puntos transformados del mapa de píxeles original. Utilice la función trueMatrix() para recuperar la matriz real utilizada para transformar el mapa de píxeles.

Esta función es lenta porque implica la transformación a un QImage, cálculos no triviales y una transformación de vuelta a un QPixmap.

Véase también trueMatrix() y Pixmap Transformations.

[static] QTransform QPixmap::trueMatrix(const QTransform &matrix, int width, int height)

Devuelve la matriz real utilizada para transformar un mapa de píxeles con los valores width, height y matrix.

Cuando se transforma un mapa de píxeles utilizando la función transformed(), la matriz de transformación se ajusta internamente para compensar la traslación no deseada, es decir, transformed() devuelve el mapa de píxeles más pequeño que contiene todos los puntos transformados del mapa de píxeles original. Esta función devuelve la matriz modificada, que mapea correctamente los puntos del pixmap original en el nuevo pixmap.

Véase también transformed() y Pixmap Transformations.

int QPixmap::width() const

Devuelve la anchura del pixmap.

Véase también size() y Pixmap Information.

QPixmap::operator QVariant() const

Devuelve el mapa de píxeles como QVariant.

bool QPixmap::operator!() const

Devuelve true si se trata de un pixmap nulo; en caso contrario devuelve false.

Véase también isNull().

[noexcept] QPixmap &QPixmap::operator=(QPixmap &&other)

Mover-asigna other a esta instancia QPixmap.

QPixmap &QPixmap::operator=(const QPixmap &pixmap)

Asigna el pixmap dado a este pixmap y devuelve una referencia a este pixmap.

Véase también copy() y QPixmap().