qbitmap.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#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