QPixmap Class

Documentation des fonctions membres

QPixmap::QPixmap()

Crée une image pixel nulle.

Voir aussi isNull().

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

Crée une image pixmap à partir des données fournies par ` xpm `, qui doivent correspondre à une image XPM valide.

Les erreurs sont ignorées sans message d'avertissement.

Notez qu’il est possible de réduire légèrement la taille de la variable XPM en utilisant une déclaration inhabituelle :

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

L’ const supplémentaire rend l’ensemble de la définition en lecture seule, ce qui est légèrement plus efficace (par exemple, lorsque le code se trouve dans une bibliothèque partagée) et permet de l’intégrer en ROM lorsque l’application doit être stockée en ROM.

QPixmap::QPixmap(int width, int height)

Crée un pixmap avec les paramètres ` width ` et ` height` fournis. Si ` width ` ou ` height ` est égal à zéro, un pixmap nul est créé.

Voir également isNull().

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

Crée une image à partir du fichier dont l’ fileName est indiquée. Si le fichier n’existe pas ou est d’un format inconnu, l’image devient une image nulle.

Le chargeur tente de lire la carte de pixels à l’aide de l’ format spécifiée. Si l’ format n’est pas spécifiée (ce qui est le cas par défaut), le chargeur analyse le fichier à la recherche d’un en-tête afin de deviner le format du fichier.

Le nom de fichier peut faire référence soit à un fichier réel sur le disque, soit à l’une des ressources intégrées de l’application. Consultez la présentation du système de ressources pour plus de détails sur la manière d’intégrer des images et d’autres fichiers de ressources dans l’exécutable de l’application.

Si l’image doit être modifiée pour s’adapter à un résultat de résolution inférieure (par exemple, conversion de 32 bits à 8 bits), utilisez l’ flags pour contrôler la conversion.

Les paramètres ` fileName`, ` format ` et ` flags ` sont transmis à la fonction ` load()`. Cela signifie que les données contenues dans ` fileName ` ne sont pas compilées dans le binaire. Si ` fileName ` contient un chemin relatif (par exemple, le nom de fichier uniquement), le fichier correspondant doit être recherché par rapport au répertoire de travail d’exécution.

Voir également Reading and Writing Image Files.

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

Crée une image bitmap à partir de l'size fournie.

QPixmap::QPixmap(const QPixmap &pixmap)

Crée une image bitmap qui est une copie de l'pixmap fournie.

Voir aussi copy().

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

Crée par « move » une instance de QPixmap à partir de other.

Voir également swap() et operator=(QPixmap&&).

[virtual noexcept] QPixmap::~QPixmap()

Supprime la carte d'images.

qint64 QPixmap::cacheKey() const

Renvoie un nombre identifiant cet objet ` QPixmap`. Des objets ` QPixmap ` distincts ne peuvent avoir la même clé de cache que s'ils font référence au même contenu.

La valeur de cacheKey() change lorsque la pixmap est modifiée.

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

Remplace les données de cette image pixel par l'image fournie en utilisant l'flags spécifié pour contrôler la conversion. L'argument flags correspond à un OU binaire de l'Qt::ImageConversionFlags. En passant 0 pour flags, toutes les options par défaut sont activées. Renvoie true si le résultat est que cette image pixel n'est pas nulle.

Voir également fromImage().

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

Renvoie une copie profonde du sous-ensemble de la carte de pixels spécifié par l'rectangle donnée. Pour plus d'informations sur les copies profondes, consultez la documentation relative au partage implicite des données.

Si l'rectangle fournie est vide, l'image entière est copiée.

Voir également ` operator=()`, ` QPixmap()` et ` Pixmap Transformations`.

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

Renvoie une copie profonde du sous-ensemble de la carte de pixels défini par le rectangle QRect( x, y, width, height).

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

Crée et renvoie un masque heuristique pour cette image.

La fonction fonctionne en sélectionnant une couleur dans l’un des coins, puis en supprimant les pixels de cette couleur, en commençant par tous les bords. Si ` clipTight ` est vrai (valeur par défaut), le masque est juste assez grand pour recouvrir les pixels ; sinon, le masque est plus grand que les pixels de données.

Le masque n’est peut-être pas parfait, mais il devrait être raisonnable, ce qui vous permet d’effectuer des opérations telles que celles-ci :

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

Cette fonction est lente car elle implique une conversion vers/depuis une valeur « QImage », ainsi que des calculs non négligeables.

Voir également ` QImage::createHeuristicMask()` et ` createMaskFromColor()`.

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

Crée et renvoie un masque pour cette image pixel par pixel (pixmap) en fonction de l'maskColor fournie. Si l'mode est Qt::MaskInColor, tous les pixels correspondant à la couleur du masque (maskColor) seront transparents. Si mode est Qt::MaskOutColor, tous les pixels correspondant à la couleur du masque (maskColor) seront opaques.

Cette fonction est lente car elle implique une conversion vers/depuis un « QImage ».

Voir également createHeuristicMask() et QImage::createMaskFromColor().

[static] int QPixmap::defaultDepth()

Renvoie la profondeur par défaut du pixmap utilisée par l'application.

Sur toutes les plateformes, c'est la profondeur de l'écran principal qui sera renvoyée.

Voir également depth() et Pixmap Information.

int QPixmap::depth() const

Renvoie la profondeur de la carte de pixels.

La profondeur d'une carte de pixels est également appelée « bits par pixel » (bpp) ou « plans de bits » d'une carte de pixels. Une carte de pixels nulle a une profondeur de 0.

Voir également defaultDepth() et Pixmap Information.

void QPixmap::detach()

Détache le pixmap des données de pixmap partagées.

Un pixmap est automatiquement détaché par Qt dès que son contenu est sur le point de changer. Cela se produit dans presque toutes les fonctions membres d'QPixmap qui modifient le pixmap (fill(), fromImage(), load(), etc.), ainsi que dans la fonction QPainter::begin() appliquée à un pixmap.

Il existe deux cas d’exception dans lesquels la fonction detach() doit être appelée explicitement : lors de l’appel de la fonction handle() ou de la fonction x11PictureHandle() (disponible uniquement sous X11). Dans le cas contraire, toute modification effectuée à l’aide d’appels système sera appliquée aux données partagées.

La fonction detach() retourne immédiatement si elle n'a qu'une seule référence ou si le pixmap n'a pas encore été initialisé.

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

Renvoie la taille de la carte de pixels en pixels indépendants du périphérique.

Cette valeur doit être utilisée lorsque la taille de la carte de pixels est prise en compte dans les calculs de taille de l'interface utilisateur.

La valeur renvoyée est équivalente à pixmap.size() / pixmap.devicePixelRatio().

Cette fonction a été introduite dans Qt 6.2.

qreal QPixmap::devicePixelRatio() const

Renvoie le rapport de pixels de l'appareil pour la carte de pixels. Il s'agit du rapport entre les pixels de l'appareil et les pixels indépendants de l'appareil.

Utilisez cette fonction pour calculer la géométrie de la mise en page en fonction de la taille de l'image : ` QSize layoutSize = image.size() / image.devicePixelRatio()`

La valeur par défaut est 1,0.

Voir également setDevicePixelRatio() et QImageReader.

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

Remplit la carte d'images avec l'color on fournie.

Le comportement de cette fonction est indéfini lorsque la carte de pixels est en cours de dessin.

Voir également Pixmap Transformations.

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

Convertit l'image on fournie en une image pixel (pixmap) en utilisant l'flags spécifiée pour contrôler la conversion. L'argument flags correspond à un OU binaire des Qt::ImageConversionFlags. En passant la valeur 0 pour flags, toutes les options par défaut sont activées.

Dans le cas d’images monochromes et 8 bits, l’image est d’abord convertie en image de 32 bits, puis remplie avec les couleurs de la table de couleurs. Si cette opération s’avère trop coûteuse, vous pouvez utiliser QBitmap::fromImage() à la place.

Voir également fromImageReader(), toImage() et Pixmap Conversion.

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

Convertit l'image on fournie en une image pixmap sans copie, si possible.

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

Crée un ` QPixmap ` à partir d’une image lue directement depuis un ` imageReader`. L’argument ` flags ` correspond à un OU binaire des ` Qt::ImageConversionFlags`. En passant la valeur 0 à ` flags `, toutes les options par défaut sont activées.

Sur certains systèmes, la lecture directe d’une image au format QPixmap peut nécessiter moins de mémoire que la lecture d’un fichier QImage pour le convertir au format QPixmap.

Voir également fromImage(), toImage() et Pixmap Conversion.

bool QPixmap::hasAlpha() const

Renvoie « true » si cette image pixmap possède un canal alpha ou un masque ; sinon, renvoie « false ».

Voir également hasAlphaChannel() et mask().

bool QPixmap::hasAlphaChannel() const

Renvoie « true » si le pixmap a un format prenant en charge le canal alpha ; sinon, renvoie « false ».

Voir aussi hasAlpha().

int QPixmap::height() const

Renvoie la hauteur de l'image bitmap.

Voir également size() et Pixmap Information.

bool QPixmap::isNull() const

Renvoie « true » s'il s'agit d'une image pixel nulle ; sinon, renvoie « false ».

Une image nulle a une largeur et une hauteur égales à zéro et ne contient aucun contenu. Il n'est pas possible de dessiner dans une image nulle.

bool QPixmap::isQBitmap() const

Renvoie « true » s'il s'agit d'un « QBitmap » ; sinon, renvoie « false ».

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

Charge une image à partir du fichier dont l'fileName est indiquée. Renvoie `true` si l'image a été chargée avec succès ; sinon, invalide l'image et renvoie ` false`.

Le chargeur tente de lire l’image à l’aide de l’ format spécifiée. Si l’ format n’est pas spécifiée (ce qui est le cas par défaut), le chargeur analyse le fichier à la recherche d’un en-tête afin de deviner le format du fichier.

Le nom de fichier peut faire référence soit à un fichier réel sur le disque, soit à l’une des ressources intégrées de l’application. Reportez-vous à la présentation du système de ressources pour plus de détails sur la manière d’intégrer des images et d’autres fichiers de ressources dans l’exécutable de l’application.

Si les données doivent être modifiées pour s'adapter à un résultat de résolution inférieure (par exemple, conversion de 32 bits à 8 bits), utilisez l'flags pour contrôler la conversion.

Notez que les QPixmaps sont automatiquement ajoutées à l’ QPixmapCache lorsqu’elles sont chargées à partir d’un fichier dans le thread principal ; la clé utilisée est interne et ne peut pas être récupérée.

Voir également loadFromData() et Reading and Writing Image Files.

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

Charge une image à partir des premiers octets de l'len du fichier binaire data. Renvoie true si l'image a été chargée avec succès ; sinon, invalide l'image et renvoie false.

Le chargeur tente de lire la carte de pixels à l’aide de l’ format spécifiée. Si l’ format n’est pas spécifiée (ce qui est le cas par défaut), le chargeur analyse le fichier à la recherche d’un en-tête afin de deviner le format du fichier.

Si les données doivent être modifiées pour s'adapter à un résultat de résolution inférieure (par exemple, conversion de 32 bits à 8 bits), utilisez l’ flags pour contrôler la conversion.

Voir également load() et Reading and Writing Image Files.

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

Charge une image (pixmap) à partir du fichier binaire data en utilisant l'format et les paramètres de conversion flags spécifiés.

QBitmap QPixmap::mask() const

Extrait un masque bitmap à partir du canal alpha de la carte de pixels.

Voir également setMask() et Pixmap Information.

QRect QPixmap::rect() const

Renvoie le rectangle englobant la carte de pixels.

Voir aussi Pixmap Information.

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

Enregistre la carte de pixels dans le fichier dont l'fileName est indiquée, en utilisant l'format de fichier image et le facteur de quality spécifiés. Renvoie « true » en cas de réussite ; sinon, renvoie « false ».

Le facteur quality doit être compris dans l’intervalle [0,100] ou égal à -1. Indiquez 0 pour obtenir de petits fichiers compressés, 100 pour de grands fichiers non compressés et -1 pour utiliser les paramètres par défaut.

Si format est défini sur nullptr, un format d’image sera choisi parmi les suffixes de fileName.

Voir également Reading and Writing Image Files.

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

Cette fonction écrit une image de type « QPixmap » dans le fichier « device » donné, en utilisant le fichier image spécifié « format » et le facteur « quality ». Cela peut servir, par exemple, à enregistrer une image « pixmap » directement dans un fichier « 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

Redimensionne l'image pixmap à l'size spécifiée, en utilisant le rapport d'aspect et les modes de transformation définis par aspectRatioMode et transformMode.

• Si aspectRatioMode est Qt::IgnoreAspectRatio, l'image bitmap est redimensionnée selon size.
• Si aspectRatioMode vaut Qt::KeepAspectRatio, la carte de pixels est redimensionnée en un rectangle aussi grand que possible à l’intérieur de size, tout en conservant le rapport d’aspect.
• Si aspectRatioMode est Qt::KeepAspectRatioByExpanding, la carte de pixels est redimensionnée en un rectangle aussi petit que possible à l'extérieur de size, en conservant le rapport d'aspect.

Si l'size fournie est vide, cette fonction renvoie un pixmap nul.

Dans certains cas, il peut être plus avantageux de dessiner la carte de pixels sur un « painter » dont l'échelle est prédéfinie plutôt que de redimensionner la carte de pixels. C'est le cas, par exemple, lorsque le « painter » est basé sur OpenGL ou lorsque le facteur d'échelle change rapidement.

Voir également isNull() et Pixmap Transformations.

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

Renvoie une copie de la carte de pixels redimensionnée en un rectangle dont les dimensions sont définies par les paramètres « width » et « height », conformément aux paramètres « aspectRatioMode » et « transformMode ».

Si l'width ou l'height est égal à zéro ou négatif, cette fonction renvoie une image pixel nulle.

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

Renvoie une copie redimensionnée de l'image. L'image renvoyée est redimensionnée à l'height indiquée à l'aide de la transformation spécifiée mode. La largeur de la carte de pixels est calculée automatiquement de manière à préserver son rapport d'aspect.

Si height est égal à 0 ou négatif, une image nulle est renvoyée.

Voir également isNull() et Pixmap Transformations.

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

Renvoie une copie redimensionnée de l'image. L'image renvoyée est redimensionnée à l'width indiquée à l'aide de la transformation spécifiée mode. La hauteur de la carte de pixels est calculée automatiquement de manière à préserver son rapport d'aspect.

Si width est égal à 0 ou négatif, une image nulle est renvoyée.

Voir également isNull() et Pixmap Transformations.

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

Fait défiler la zone rect de cette image pixel par (dx, dy). La région exposée reste inchangée. Vous pouvez, si vous le souhaitez, passer un pointeur vers une structure vide de type QRegion afin d’obtenir la région qui est exposed par l’opération de défilement.

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

Vous ne pouvez pas faire défiler la pixmap tant qu’un peintre est actif sur celle-ci.

Voir également QWidget::scroll() et QGraphicsItem::scroll().

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

Cette fonction pratique équivaut à appeler QPixmap::scroll(dx, dy, QRect(x, y, width, height), exposed).

Voir également QWidget::scroll() et QGraphicsItem::scroll().

void QPixmap::setDevicePixelRatio(qreal scaleFactor)

Définit le rapport de pixels de l'appareil pour la carte de pixels. Il s'agit du rapport entre les pixels de l'image et les pixels indépendants de l'appareil.

L'scaleFactor e par défaut est 1,0. Le fait de définir une autre valeur a deux effets :

Les QPainters ouverts sur la carte de pixels seront mis à l'échelle. Par exemple, dessiner sur une image de 200x200 avec un rapport de 2,0 donnera des limites de dessin effectives (indépendantes du périphérique) de 100x100.

Les chemins de code dans Qt qui calculent la géométrie de mise en page en fonction de la taille de la carte de pixels prendront ce rapport en compte : QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio() Cela a pour effet que la carte de pixels s’affiche comme une carte de pixels à haute résolution (DPI) plutôt que comme une grande carte de pixels (voir Drawing High Resolution Versions of Pixmaps and Images).

Voir également devicePixelRatio() et deviceIndependentSize().

void QPixmap::setMask(const QBitmap &mask)

Définit un bitmap de masque.

Cette fonction fusionne l'mask e avec le canal alpha de l'image. Une valeur de 1 pour un pixel du masque signifie que le pixel correspondant de l'image reste inchangé ; une valeur de 0 signifie que le pixel est transparent. Le masque doit avoir la même taille que cette image.

La définition d’un masque nul réinitialise le masque, laissant noirs les pixels précédemment transparents. L’effet de cette fonction est indéfini lorsque le pixmap est en cours de dessin.

Voir également mask(), Pixmap Transformations et QBitmap.

QSize QPixmap::size() const

Renvoie la taille de la carte de pixels.

Voir également width(), height() et Pixmap Information.

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

Permute cette image pixel par pixel avec other. Cette opération est très rapide et ne rencontre jamais d'échec.

QImage QPixmap::toImage() const

Convertit la carte de pixels en une image de type « QImage ». Renvoie une image nulle si la conversion échoue.

Si la carte de pixels a une profondeur de 1 bit, l’image renvoyée aura également une profondeur de 1 bit. Les images comportant davantage de bits seront renvoyées dans un format proche de celui du système sous-jacent. Il s’agira généralement d’ QImage::Format_ARGB32_Premultiplied pour les cartes de pixels avec canal alpha, et d’ QImage::Format_RGB32 ou QImage::Format_RGB16 pour celles sans canal alpha.

Notez que, pour l’instant, les masques alpha sur les images monochromes sont ignorés.

Voir également fromImage() et Image Formats.

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

Renvoie une copie de la carte de pixels transformée à l’aide de l’ transform de transformation et de l’ mode de transformation fournis. La carte de pixels d’origine n’est pas modifiée.

L’ transform de transformation est ajustée en interne pour compenser toute translation indésirable ; c’est-à-dire que la carte de pixels produite est la plus petite carte de pixels contenant tous les points transformés de la carte de pixels d’origine. Utilisez la fonction trueMatrix() pour récupérer la matrice réelle utilisée pour transformer la carte de pixels.

Cette fonction est lente car elle implique une transformation en QImage, des calculs non triviaux et une transformation inverse vers QPixmap.

Voir également trueMatrix() et Pixmap Transformations.

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

Renvoie la matrice effective utilisée pour transformer une image pixel par pixel (pixmap) à l'aide des paramètres ` width`, ` height ` et ` matrix` fournis.

Lors de la transformation d’une image à l’aide de la fonction ` transformed()`, la matrice de transformation est ajustée en interne pour compenser toute translation indésirable ; en d’autres termes, la fonction ` transformed()` renvoie la plus petite image contenant tous les points transformés de l’image d’origine. Cette fonction renvoie la matrice modifiée, qui mappe correctement les points de l’image d’origine vers la nouvelle image.

Voir également transformed() et Pixmap Transformations.

int QPixmap::width() const

Renvoie la largeur de l'image.

Voir également size() et Pixmap Information.

QPixmap::operator QVariant() const

Renvoie la carte de pixels sous forme de ` QVariant`.

bool QPixmap::operator!() const

Renvoie ` true ` s'il s'agit d'une image pixel nulle ; sinon, renvoie ` false`.

Voir aussi isNull().

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

Cette opération attribue l'other à cette instance QPixmap.

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

Attribue l'pixmap on indiquée à cette image matricielle et renvoie une référence à celle-ci.

Voir également ` copy()` et ` QPixmap()`.