QPixmap Class

Documentation des fonctions membres

QPixmap::QPixmap()

Construit un pixmap nul.

Voir aussi isNull().

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

Construit une pixmap à partir des données fournies par xpm, qui doit être une image XPM valide.

Les erreurs sont ignorées silencieusement.

Notez qu'il est possible de réduire un peu 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.
};

Le const supplémentaire rend la définition entière en lecture seule, ce qui est légèrement plus efficace (par exemple, lorsque le code est dans une bibliothèque partagée) et ROMable lorsque l'application doit être stockée en ROM.

QPixmap::QPixmap(int width, int height)

Construit un pixmap avec les données width et height. Si width ou height est zéro, un pixmap nul est construit.

Voir aussi isNull().

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

Construit un pixmap à partir du fichier avec l'adresse fileName. Si le fichier n'existe pas ou est d'un format inconnu, la pixmap devient une pixmap nulle.

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

Le nom du 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. Voir la vue d'ensemble 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 le site flags pour contrôler la conversion.

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

Voir également Reading and Writing Image Files.

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

Construit une pixmap à partir de size.

QPixmap::QPixmap(const QPixmap &pixmap)

Construit une pixmap qui est une copie de l'image donnée pixmap.

Voir aussi copy().

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

Move-construit une instance de QPixmap à partir de other.

Voir aussi swap() et operator=(QPixmap&&).

[virtual noexcept] QPixmap::~QPixmap()

Détruit la pixmap.

qint64 QPixmap::cacheKey() const

Renvoie un numéro qui identifie 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 clé de cache() changera lorsque la pixmap sera modifiée.

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

Remplace les données de ce pixmap par celles de image en utilisant flags pour contrôler la conversion. L'argument flags est un OU bit à bit de l'argument Qt::ImageConversionFlags. Passer 0 pour flags définit toutes les options par défaut. Retourne true si le résultat est que cette pixmap n'est pas nulle.

Voir aussi fromImage().

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

Renvoie une copie profonde du sous-ensemble de la pixmap spécifié par l'adresse rectangle. Pour plus d'informations sur les copies profondes, voir la documentation sur le partage implicite de données.

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

Voir aussi 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 pixmap spécifié par le rectangle QRect( x, y, width, height).

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

Crée et renvoie un masque heuristique pour ce pixmap.

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

Le masque peut ne pas être parfait, mais il doit être raisonnable, de sorte que vous puissiez faire des choses comme celles qui suivent :

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

Cette fonction est lente car elle implique une conversion vers/depuis QImage, ainsi que des calculs non triviaux.

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 pixmap en fonction de l'adresse maskColor. Si mode est Qt::MaskInColor, tous les pixels correspondant à maskColor seront transparents. Si mode est Qt::MaskOutColor, tous les pixels correspondant à la couleur du masque seront opaques.

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

Voir aussi createHeuristicMask() et QImage::createMaskFromColor().

[static] int QPixmap::defaultDepth()

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

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

Voir également depth() et Pixmap Information.

int QPixmap::depth() const

Renvoie la profondeur de la pixmap.

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

Voir aussi defaultDepth() et Pixmap Information.

void QPixmap::detach()

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

Une pixmap est automatiquement détachée par Qt lorsque son contenu est sur le point de changer. Cela se fait dans presque toutes les fonctions membres de QPixmap qui modifient la pixmap (fill(), fromImage(), load(), etc.), et dans QPainter::begin() sur une pixmap.

Il y a deux exceptions pour lesquelles detach() doit être appelé explicitement, à savoir lors de l'appel de la fonction handle() ou de la fonction x11PictureHandle() (uniquement disponible sur X11). Sinon, toute modification effectuée à l'aide des appels système sera effectuée sur les données partagées.

La fonction detach() retourne immédiatement s'il n'y a qu'une seule référence ou si la pixmap n'a pas encore été initialisée.

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

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

Cette valeur doit être utilisée lorsque la taille du pixmap est utilisée pour calculer la taille de l'interface utilisateur.

La valeur de retour est équivalente à pixmap.size() / pixmap.devicePixelRatio().

Cette fonction a été introduite dans Qt 6.2.

qreal QPixmap::devicePixelRatio() const

Renvoie le rapport entre les pixels du périphérique et les pixels indépendants du périphérique pour la table des matières. Il s'agit du rapport entre les pixels du périphérique et les pixels indépendants du périphérique.

Utilisez cette fonction pour calculer la géométrie de la disposition en fonction de la taille de la pixmap : 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 pixmap avec la valeur donnée color.

L'effet de cette fonction est indéfini lorsque la pixmap est peinte.

Voir aussi Pixmap Transformations.

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

Convertit le fichier image en pixmap en utilisant l'argument flags pour contrôler la conversion. L'argument flags est un OU bit à bit de l'argument Qt::ImageConversionFlags. En passant 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 pixmap 32 bits, puis remplie avec les couleurs de la table des couleurs. Si cette opération est 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 le fichier image en pixmap sans le copier si possible.

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

Créer un QPixmap à partir d'une image lue directement sur imageReader. L'argument flags est un OU bit à bit de Qt::ImageConversionFlags. Passer 0 pour flags définit toutes les options par défaut.

Sur certains systèmes, la lecture d'une image directement à QPixmap peut utiliser moins de mémoire que la lecture d'une image à QImage pour la convertir à QPixmap.

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

bool QPixmap::hasAlpha() const

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

Voir aussi hasAlphaChannel() et mask().

bool QPixmap::hasAlphaChannel() const

Renvoie true si la pixmap a un format qui respecte le canal alpha, sinon renvoie false.

Voir aussi hasAlpha().

int QPixmap::height() const

Renvoie la hauteur de la pixmap.

Voir aussi size() et Pixmap Information.

bool QPixmap::isNull() const

Renvoie true s'il s'agit d'une pixmap nulle ; sinon, il renvoie false.

Un pixmap nul a une largeur et une hauteur nulles et n'a pas de contenu. Vous ne pouvez pas dessiner dans une pixmap 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 un pixmap à partir du fichier avec l'adresse fileName. Retourne vrai si la pixmap a été chargée avec succès ; sinon, invalide la pixmap et retourne false.

Le chargeur tente de lire la pixmap à l'aide de l'adresse format. Si format n'est pas spécifié (ce qui est le cas par défaut), le chargeur recherche dans le fichier un en-tête permettant de deviner le format du fichier.

Le nom du 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. Voir la vue d'ensemble du système de ressources pour plus de détails sur la manière d'incorporer des pixmaps et d'autres fichiers de ressources dans l'exécutable de l'application.

Si les données doivent être modifiées pour s'intégrer dans un résultat de résolution inférieure (par exemple, conversion de 32 bits en 8 bits), utilisez le site flags pour contrôler la conversion.

Notez que les QPixmaps sont automatiquement ajoutées à 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 acquise.

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 un pixmap à partir des len premiers octets du fichier binaire donné data. Retourne true si la pixmap a été chargée avec succès ; sinon, invalide la pixmap et retourne false.

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

Si les données doivent être modifiées pour être intégrées dans un résultat de résolution inférieure (par exemple, conversion de 32 bits en 8 bits), utilisez 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 un pixmap à partir du fichier binaire data en utilisant le fichier spécifié format et la conversion flags.

QBitmap QPixmap::mask() const

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

Voir aussi setMask() et Pixmap Information.

QRect QPixmap::rect() const

Renvoie le rectangle englobant de la pixmap.

Voir aussi Pixmap Information.

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

Enregistre la pixmap dans le fichier avec l'adresse fileName en utilisant le fichier image spécifié format et le facteur quality. Renvoie true en cas de succès, sinon false.

Le facteur quality doit être compris dans l'intervalle [0,100] ou -1. Spécifiez 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 nullptr, un format d'image sera choisi à partir du suffixe fileName.

Voir aussi Reading and Writing Image Files.

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

Cette fonction écrit un QPixmap dans le device donné en utilisant le fichier image spécifié format et le facteur quality. Elle peut être utilisée, par exemple, pour enregistrer une image 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

Met à l'échelle la pixmap en fonction de l'adresse size, en utilisant le rapport d'aspect et les modes de transformation spécifiés par aspectRatioMode et transformMode.

• Si aspectRatioMode est Qt::IgnoreAspectRatio, la pixmap est mise à l'échelle de size.
• Si aspectRatioMode est Qt::KeepAspectRatio, la pixmap est mise à l'échelle d'un rectangle aussi grand que possible à l'intérieur de size, en préservant le rapport hauteur/largeur.
• Si aspectRatioMode est Qt::KeepAspectRatioByExpanding, la pixmap est redimensionnée en un rectangle aussi petit que possible à l'extérieur de size, en préservant le rapport hauteur/largeur.

Si size est vide, cette fonction renvoie une pixmap nulle.

Dans certains cas, il peut être plus avantageux de dessiner la pixmap vers un peintre avec une échelle définie plutôt que de mettre la pixmap à l'échelle. C'est le cas lorsque le peintre est par exemple basé sur OpenGL ou lorsque le facteur d'échelle change rapidement.

Voir aussi 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 pixmap mise à l'échelle d'un rectangle avec les données width et height selon les données aspectRatioMode et transformMode.

Si width ou height est nul ou négatif, cette fonction renvoie une pixmap nulle.

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

Renvoie une copie à l'échelle de l'image. L'image renvoyée est mise à l'échelle sur le site height à l'aide de la transformation spécifiée mode. La largeur de la pixmap est automatiquement calculée afin que le rapport hauteur/largeur de la pixmap soit préservé.

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

Voir aussi isNull() et Pixmap Transformations.

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

Renvoie une copie à l'échelle de l'image. L'image renvoyée est mise à l'échelle sur le site width à l'aide de la transformation spécifiée mode. La hauteur de la pixmap est automatiquement calculée afin que le rapport hauteur/largeur de la pixmap soit préservé.

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

Voir aussi 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 pixmap de (dx, dy). La région exposée reste inchangée. Vous pouvez optionnellement passer un pointeur sur un QRegion vide pour 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);

Il n'est pas possible de faire défiler une image lorsqu'un peintre est actif sur la pixmap.

Voir aussi 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 de commodité équivaut à appeler QPixmap::scroll(dx, dy, QRect(x, y, width, height), exposed).

Voir aussi QWidget::scroll() et QGraphicsItem::scroll().

void QPixmap::setDevicePixelRatio(qreal scaleFactor)

Définit le ratio de pixels du périphérique pour la pixmap. Il s'agit du rapport entre les pixels de l'image et les pixels indépendants du périphérique.

La valeur par défaut de scaleFactor est 1,0. La définition d'une autre valeur a deux effets :

Les QPainters ouverts sur la pixmap seront mis à l'échelle. Par exemple, peindre sur une image de 200x200 avec un ratio de 2.0 donnera des limites de peinture effectives (indépendantes du périphérique) de 100x100.

Les chemins de code dans Qt XML qui calculent la géométrie de la disposition en fonction de la taille de la pixmap prendront le ratio en compte : QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio() L'effet net de ceci est que la pixmap est affichée en tant que pixmap à haut DPI plutôt qu'en tant que pixmap de grande taille (voir Drawing High Resolution Versions of Pixmaps and Images).

Voir également devicePixelRatio() et deviceIndependentSize().

void QPixmap::setMask(const QBitmap &mask)

Définit un masque bitmap.

Cette fonction fusionne le site mask avec le canal alpha du pixmap. Une valeur de 1 sur le masque signifie que le pixel de la pixmap est inchangé ; une valeur de 0 signifie que le pixel est transparent. Le masque doit avoir la même taille que la pixmap.

La définition d'un masque nul réinitialise le masque, laissant les pixels précédemment transparents en noir. L'effet de cette fonction n'est pas défini lorsque la pixmap est peinte.

Voir aussi mask(), Pixmap Transformations, et QBitmap.

QSize QPixmap::size() const

Renvoie la taille de la pixmap.

Voir aussi width(), height(), et Pixmap Information.

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

Remplace cette image par other. Cette opération est très rapide et n'échoue jamais.

QImage QPixmap::toImage() const

Convertit la pixmap en QImage. Renvoie une image nulle si la conversion échoue.

Si la pixmap a une profondeur de 1 bit, l'image renvoyée aura également une profondeur de 1 bit. Les images comportant plus de bits seront renvoyées dans un format représentant étroitement le système sous-jacent. En général, il s'agira de QImage::Format_ARGB32_Premultiplied pour les pixmaps avec un alpha et de QImage::Format_RGB32 ou QImage::Format_RGB16 pour les pixmaps sans alpha.

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

Voir aussi fromImage() et Image Formats.

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

Renvoie une copie de la pixmap transformée à l'aide de la transformation transform et de la transformation mode. La pixmap d'origine n'est pas modifiée.

La transformation transform est ajustée en interne pour compenser les translations non désirées ; c'est-à-dire que la pixmap produite est la plus petite pixmap qui contient tous les points transformés de la pixmap d'origine. Utilisez la fonction trueMatrix() pour récupérer la matrice réelle utilisée pour transformer la pixmap.

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

Voir également trueMatrix() et Pixmap Transformations.

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

Renvoie la matrice utilisée pour la transformation d'une image de pixel avec les données width, height et matrix.

Lors de la transformation d'une image de pixel à l'aide de la fonction transformed(), la matrice de transformation est ajustée en interne pour compenser les translations indésirables, c'est-à-dire que transformed() renvoie la plus petite image de pixel contenant tous les points transformés de l'image de pixel d'origine. Cette fonction renvoie la matrice modifiée, qui traduit correctement les points de la pixmap d'origine dans la nouvelle pixmap.

Voir également transformed() et Pixmap Transformations.

int QPixmap::width() const

Renvoie la largeur de la pixmap.

Voir aussi size() et Pixmap Information.

QPixmap::operator QVariant() const

Retourne la pixmap sous forme de QVariant.

bool QPixmap::operator!() const

Renvoie true s'il s'agit d'une pixmap nulle ; sinon, renvoie false.

Voir aussi isNull().

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

Move-assigne other à cette instance QPixmap.

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

Attribue la valeur pixmap à ce pixmap et renvoie une référence à ce pixmap.

Voir aussi copy() et QPixmap().