qbitmap.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qbitmap.h"
#include <qpa/qplatformpixmap.h>
#include <qpa/qplatformintegration.h>
#include "qimage.h"
#include "qscreen.h"
#include "qvariant.h"
#include <qpainter.h>
#include <private/qguiapplication_p.h>
 
#include <memory>
 
QT_BEGIN_NAMESPACE
 
QBitmap::QBitmap()
    : QPixmap(QSize(0, 0), QPlatformPixmap::BitmapType)
{
}
 
QBitmap::QBitmap(int w, int h)
    : QPixmap(QSize(w, h), QPlatformPixmap::BitmapType)
{
}
 
QBitmap::QBitmap(const QSize &size)
    : QPixmap(size, QPlatformPixmap::BitmapType)
{
}
 
QBitmap::~QBitmap() = default;
 
QBitmap::QBitmap(const QString& fileName, const char *format)
    : QPixmap(QSize(0, 0), QPlatformPixmap::BitmapType)
{
    load(fileName, format, Qt::MonoOnly);
}
 
QBitmap::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
 
static QBitmap makeBitmap(QImage &&image, Qt::ImageConversionFlags flags)
{
    // make sure image.color(0) == Qt::color0 (white)
    // and image.color(1) == Qt::color1 (black)
    const QRgb c0 = QColor(Qt::black).rgb();
    const QRgb c1 = QColor(Qt::white).rgb();
    if (image.color(0) == c0 && image.color(1) == c1) {
        image.invertPixels();
        image.setColor(0, c1);
        image.setColor(1, c0);
    }
 
    std::unique_ptr<QPlatformPixmap> data(QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(QPlatformPixmap::BitmapType));
 
    data->fromImageInPlace(image, flags | Qt::MonoOnly);
    return QBitmap::fromPixmap(QPixmap(data.release()));
}
 
QBitmap QBitmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
{
    if (image.isNull())
        return QBitmap();
 
    return makeBitmap(image.convertToFormat(QImage::Format_MonoLSB, flags), flags);
}
 
QBitmap QBitmap::fromImage(QImage &&image, Qt::ImageConversionFlags flags)
{
    if (image.isNull())
        return QBitmap();
 
    return makeBitmap(std::move(image).convertToFormat(QImage::Format_MonoLSB, flags), flags);
}
 
QBitmap QBitmap::fromData(const QSize &size, const uchar *bits, QImage::Format monoFormat)
{
    Q_ASSERT(monoFormat == QImage::Format_Mono || monoFormat == QImage::Format_MonoLSB);
 
    QImage image(size, monoFormat);
    image.setColor(0, QColor(Qt::color0).rgb());
    image.setColor(1, QColor(Qt::color1).rgb());
 
    // Need to memcpy each line separately since QImage is 32bit aligned and
    // this data is only byte aligned...
    int bytesPerLine = (size.width() + 7) / 8;
    for (int y = 0; y < size.height(); ++y)
        memcpy(image.scanLine(y), bits + bytesPerLine * y, bytesPerLine);
    return QBitmap::fromImage(std::move(image));
}
 
QBitmap QBitmap::fromPixmap(const QPixmap &pixmap)
{
    if (pixmap.isNull()) {                        // a null pixmap
        return QBitmap(0, 0);
    } else if (pixmap.depth() == 1) {             // 1-bit pixmap
        QBitmap bm;
        if (pixmap.paintingActive()) {            // make a deep copy
            pixmap.copy().swap(bm);
        } else {
            bm.data = pixmap.data;                // shallow assignment
        }
        return bm;
    }
    // n-bit depth pixmap, will dither image
    return fromImage(pixmap.toImage());
}
 
#if QT_DEPRECATED_SINCE(6, 0)
QBitmap::QBitmap(const QPixmap &pixmap)
{
    *this = QBitmap::fromPixmap(pixmap);
}
 
QBitmap &QBitmap::operator=(const QPixmap &pixmap)
{
    *this = QBitmap::fromPixmap(pixmap);
    return *this;
}
#endif
 
QBitmap QBitmap::transformed(const QTransform &matrix) const
{
    return QBitmap::fromPixmap(QPixmap::transformed(matrix));
}
 
QT_END_NAMESPACE