Mac-4.7.4/src/gui/image/qpixmapdata.cpp - platform/external/qt - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** GNU Lesser General Public License Usage
 ** This file may be used under the terms of the GNU Lesser General Public
 ** License version 2.1 as published by the Free Software Foundation and
 ** appearing in the file LICENSE.LGPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU Lesser
 ** General Public License version 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights. These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU General
 ** Public License version 3.0 as published by the Free Software Foundation
 ** and appearing in the file LICENSE.GPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU General
 ** Public License version 3.0 requirements will be met:
 ** http://www.gnu.org/copyleft/gpl.html.
 **
 ** Other Usage
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "qpixmapdata_p.h"
 #include <QtCore/qbuffer.h>
 #include <QtGui/qbitmap.h>
 #include <QtGui/qimagereader.h>
 #include <private/qgraphicssystem_p.h>
 #include <private/qapplication_p.h>
 #include <private/qimagepixmapcleanuphooks_p.h>

 QT_BEGIN_NAMESPACE

 const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
                                      0x10, 0x20, 0x40, 0x80 };

 QPixmapData *QPixmapData::create(int w, int h, PixelType type)
 {
     QPixmapData *data;
     QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
     if (gs)
         data = gs->createPixmapData(static_cast<QPixmapData::PixelType>(type));
     else
         data = QGraphicsSystem::createDefaultPixmapData(static_cast<QPixmapData::PixelType>(type));
     data->resize(w, h);
     return data;
 }


 QPixmapData::QPixmapData(PixelType pixelType, int objectId)
     : w(0),
       h(0),
       d(0),
       is_null(true),
       ref(0),
       detach_no(0),
       type(pixelType),
       id(objectId),
       ser_no(0),
       is_cached(false)
 {
 }

 QPixmapData::~QPixmapData()
 {
     // Sometimes the pixmap cleanup hooks will be called from derrived classes, which will
     // then set is_cached to false. For example, on X11 QtOpenGL needs to delete the GLXPixmap
     // or EGL Pixmap Surface for a given pixmap _before_ the native X11 pixmap is deleted,
     // otherwise some drivers will leak the GL surface. In this case, QX11PixmapData will
     // call the cleanup hooks itself before deleting the native pixmap and set is_cached to
     // false.
     if (is_cached) {
         QImagePixmapCleanupHooks::executePixmapDataDestructionHooks(this);
         is_cached = false;
     }
 }

 QPixmapData *QPixmapData::createCompatiblePixmapData() const
 {
     QPixmapData *d;
     QGraphicsSystem *gs = QApplicationPrivate::graphicsSystem();
     if (gs)
         d = gs->createPixmapData(pixelType());
     else
         d = QGraphicsSystem::createDefaultPixmapData(pixelType());
     return d;
 }

 static QImage makeBitmapCompliantIfNeeded(QPixmapData *d, const QImage &image, Qt::ImageConversionFlags flags)
 {
     if (d->pixelType() == QPixmapData::BitmapType) {
         QImage img = image.convertToFormat(QImage::Format_MonoLSB, 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 (img.color(0) == c0 && img.color(1) == c1) {
             img.invertPixels();
             img.setColor(0, c1);
             img.setColor(1, c0);
         }
         return img;
     }

     return image;
 }

 void QPixmapData::fromImageReader(QImageReader *imageReader,
                                   Qt::ImageConversionFlags flags)
 {
     const QImage image = imageReader->read();
     fromImage(image, flags);
 }

 bool QPixmapData::fromFile(const QString &fileName, const char *format,
                            Qt::ImageConversionFlags flags)
 {
     QImage image = QImageReader(fileName, format).read();
     if (image.isNull())
         return false;
     fromImage(makeBitmapCompliantIfNeeded(this, image, flags), flags);
     return !isNull();
 }

 bool QPixmapData::fromData(const uchar *buf, uint len, const char *format, Qt::ImageConversionFlags flags)
 {
     QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buf), len);
     QBuffer b(&a);
     b.open(QIODevice::ReadOnly);
     QImage image = QImageReader(&b, format).read();
     fromImage(makeBitmapCompliantIfNeeded(this, image, flags), flags);
     return !isNull();
 }

 void QPixmapData::copy(const QPixmapData *data, const QRect &rect)
 {
     fromImage(data->toImage(rect), Qt::NoOpaqueDetection);
 }

 bool QPixmapData::scroll(int dx, int dy, const QRect &rect)
 {
     Q_UNUSED(dx);
     Q_UNUSED(dy);
     Q_UNUSED(rect);
     return false;
 }

 void QPixmapData::setMask(const QBitmap &mask)
 {
     if (mask.size().isEmpty()) {
         if (depth() != 1)
             fromImage(toImage().convertToFormat(QImage::Format_RGB32),
                       Qt::AutoColor);
     } else {
         QImage image = toImage();
         const int w = image.width();
         const int h = image.height();

         switch (image.depth()) {
         case 1: {
             const QImage imageMask = mask.toImage().convertToFormat(image.format());
             for (int y = 0; y < h; ++y) {
                 const uchar *mscan = imageMask.scanLine(y);
                 uchar *tscan = image.scanLine(y);
                 int bytesPerLine = image.bytesPerLine();
                 for (int i = 0; i < bytesPerLine; ++i)
                     tscan[i] &= mscan[i];
             }
             break;
         }
         default: {
             const QImage imageMask = mask.toImage().convertToFormat(QImage::Format_MonoLSB);
             image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
             for (int y = 0; y < h; ++y) {
                 const uchar *mscan = imageMask.scanLine(y);
                 QRgb *tscan = (QRgb *)image.scanLine(y);
                 for (int x = 0; x < w; ++x) {
                     if (!(mscan[x>>3] & qt_pixmap_bit_mask[x&7]))
                         tscan[x] = 0;
                 }
             }
             break;
         }
         }
         fromImage(image, Qt::AutoColor);
     }
 }

 QBitmap QPixmapData::mask() const
 {
     if (!hasAlphaChannel())
         return QBitmap();

     const QImage img = toImage();
     const QImage image = (img.depth() < 32 ? img.convertToFormat(QImage::Format_ARGB32_Premultiplied) : img);
     const int w = image.width();
     const int h = image.height();

     QImage mask(w, h, QImage::Format_MonoLSB);
     if (mask.isNull()) // allocation failed
         return QBitmap();

     mask.setColorCount(2);
     mask.setColor(0, QColor(Qt::color0).rgba());
     mask.setColor(1, QColor(Qt::color1).rgba());

     const int bpl = mask.bytesPerLine();

     for (int y = 0; y < h; ++y) {
         const QRgb *src = reinterpret_cast<const QRgb*>(image.scanLine(y));
         uchar *dest = mask.scanLine(y);
         memset(dest, 0, bpl);
         for (int x = 0; x < w; ++x) {
             if (qAlpha(*src) > 0)
                 dest[x >> 3] |= qt_pixmap_bit_mask[x & 7];
             ++src;
         }
     }

     return QBitmap::fromImage(mask);
 }

 QPixmap QPixmapData::transformed(const QTransform &matrix,
                                  Qt::TransformationMode mode) const
 {
     return QPixmap::fromImage(toImage().transformed(matrix, mode));
 }

 void QPixmapData::setAlphaChannel(const QPixmap &alphaChannel)
 {
     QImage image = toImage();
     image.setAlphaChannel(alphaChannel.toImage());
     fromImage(image, Qt::AutoColor);
 }

 QPixmap QPixmapData::alphaChannel() const
 {
     return QPixmap::fromImage(toImage().alphaChannel());
 }

 void QPixmapData::setSerialNumber(int serNo)
 {
     ser_no = serNo;
 }

 QImage QPixmapData::toImage(const QRect &rect) const
 {
     if (rect.contains(QRect(0, 0, w, h)))
         return toImage();
     else
         return toImage().copy(rect);
 }

 QImage* QPixmapData::buffer()
 {
     return 0;
 }

 #if defined(Q_OS_SYMBIAN)
 QVolatileImage QPixmapData::toVolatileImage() const
 {
     return QVolatileImage();
 }

 void* QPixmapData::toNativeType(NativeType /* type */)
 {
     return 0;
 }

 void QPixmapData::fromNativeType(void* /* pixmap */, NativeType /* typre */)
 {
     return;
 }
 #endif

 QT_END_NAMESPACE
	/****************************************************************************
	**
	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
	** All rights reserved.
	** Contact: Nokia Corporation (qt-info@nokia.com)
	**
	** This file is part of the QtGui module of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:LGPL$
	** GNU Lesser General Public License Usage
	** This file may be used under the terms of the GNU Lesser General Public
	** License version 2.1 as published by the Free Software Foundation and
	** appearing in the file LICENSE.LGPL included in the packaging of this
	** file. Please review the following information to ensure the GNU Lesser
	** General Public License version 2.1 requirements will be met:
	** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	**
	** In addition, as a special exception, Nokia gives you certain additional
	** rights. These rights are described in the Nokia Qt LGPL Exception
	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU General
	** Public License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of this
	** file. Please review the following information to ensure the GNU General
	** Public License version 3.0 requirements will be met:
	** http://www.gnu.org/copyleft/gpl.html.
	**
	** Other Usage
	** Alternatively, this file may be used in accordance with the terms and
	** conditions contained in a signed written agreement between you and Nokia.
	**
	**
	**
	**
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include "qpixmapdata_p.h"
	#include <QtCore/qbuffer.h>
	#include <QtGui/qbitmap.h>
	#include <QtGui/qimagereader.h>
	#include <private/qgraphicssystem_p.h>
	#include <private/qapplication_p.h>
	#include <private/qimagepixmapcleanuphooks_p.h>

	QT_BEGIN_NAMESPACE

	const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
	0x10, 0x20, 0x40, 0x80 };

	QPixmapData *QPixmapData::create(int w, int h, PixelType type)
	{
	QPixmapData *data;
	QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
	if (gs)
	data = gs->createPixmapData(static_cast<QPixmapData::PixelType>(type));
	else
	data = QGraphicsSystem::createDefaultPixmapData(static_cast<QPixmapData::PixelType>(type));
	data->resize(w, h);
	return data;
	}


	QPixmapData::QPixmapData(PixelType pixelType, int objectId)
	: w(0),
	h(0),
	d(0),
	is_null(true),
	ref(0),
	detach_no(0),
	type(pixelType),
	id(objectId),
	ser_no(0),
	is_cached(false)
	{
	}

	QPixmapData::~QPixmapData()
	{
	// Sometimes the pixmap cleanup hooks will be called from derrived classes, which will
	// then set is_cached to false. For example, on X11 QtOpenGL needs to delete the GLXPixmap
	// or EGL Pixmap Surface for a given pixmap _before_ the native X11 pixmap is deleted,
	// otherwise some drivers will leak the GL surface. In this case, QX11PixmapData will
	// call the cleanup hooks itself before deleting the native pixmap and set is_cached to
	// false.
	if (is_cached) {
	QImagePixmapCleanupHooks::executePixmapDataDestructionHooks(this);
	is_cached = false;
	}
	}

	QPixmapData *QPixmapData::createCompatiblePixmapData() const
	{
	QPixmapData *d;
	QGraphicsSystem *gs = QApplicationPrivate::graphicsSystem();
	if (gs)
	d = gs->createPixmapData(pixelType());
	else
	d = QGraphicsSystem::createDefaultPixmapData(pixelType());
	return d;
	}

	static QImage makeBitmapCompliantIfNeeded(QPixmapData *d, const QImage &image, Qt::ImageConversionFlags flags)
	{
	if (d->pixelType() == QPixmapData::BitmapType) {
	QImage img = image.convertToFormat(QImage::Format_MonoLSB, 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 (img.color(0) == c0 && img.color(1) == c1) {
	img.invertPixels();
	img.setColor(0, c1);
	img.setColor(1, c0);
	}
	return img;
	}

	return image;
	}

	void QPixmapData::fromImageReader(QImageReader *imageReader,
	Qt::ImageConversionFlags flags)
	{
	const QImage image = imageReader->read();
	fromImage(image, flags);
	}

	bool QPixmapData::fromFile(const QString &fileName, const char *format,
	Qt::ImageConversionFlags flags)
	{
	QImage image = QImageReader(fileName, format).read();
	if (image.isNull())
	return false;
	fromImage(makeBitmapCompliantIfNeeded(this, image, flags), flags);
	return !isNull();
	}

	bool QPixmapData::fromData(const uchar buf, uint len, const char format, Qt::ImageConversionFlags flags)
	{
	QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buf), len);
	QBuffer b(&a);
	b.open(QIODevice::ReadOnly);
	QImage image = QImageReader(&b, format).read();
	fromImage(makeBitmapCompliantIfNeeded(this, image, flags), flags);
	return !isNull();
	}

	void QPixmapData::copy(const QPixmapData *data, const QRect &rect)
	{
	fromImage(data->toImage(rect), Qt::NoOpaqueDetection);
	}

	bool QPixmapData::scroll(int dx, int dy, const QRect &rect)
	{
	Q_UNUSED(dx);
	Q_UNUSED(dy);
	Q_UNUSED(rect);
	return false;
	}

	void QPixmapData::setMask(const QBitmap &mask)
	{
	if (mask.size().isEmpty()) {
	if (depth() != 1)
	fromImage(toImage().convertToFormat(QImage::Format_RGB32),
	Qt::AutoColor);
	} else {
	QImage image = toImage();
	const int w = image.width();
	const int h = image.height();

	switch (image.depth()) {
	case 1: {
	const QImage imageMask = mask.toImage().convertToFormat(image.format());
	for (int y = 0; y < h; ++y) {
	const uchar *mscan = imageMask.scanLine(y);
	uchar *tscan = image.scanLine(y);
	int bytesPerLine = image.bytesPerLine();
	for (int i = 0; i < bytesPerLine; ++i)
	tscan[i] &= mscan[i];
	}
	break;
	}
	default: {
	const QImage imageMask = mask.toImage().convertToFormat(QImage::Format_MonoLSB);
	image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
	for (int y = 0; y < h; ++y) {
	const uchar *mscan = imageMask.scanLine(y);
	QRgb tscan = (QRgb )image.scanLine(y);
	for (int x = 0; x < w; ++x) {
	if (!(mscan[x>>3] & qt_pixmap_bit_mask[x&7]))
	tscan[x] = 0;
	}
	}
	break;
	}
	}
	fromImage(image, Qt::AutoColor);
	}
	}

	QBitmap QPixmapData::mask() const
	{
	if (!hasAlphaChannel())
	return QBitmap();

	const QImage img = toImage();
	const QImage image = (img.depth() < 32 ? img.convertToFormat(QImage::Format_ARGB32_Premultiplied) : img);
	const int w = image.width();
	const int h = image.height();

	QImage mask(w, h, QImage::Format_MonoLSB);
	if (mask.isNull()) // allocation failed
	return QBitmap();

	mask.setColorCount(2);
	mask.setColor(0, QColor(Qt::color0).rgba());
	mask.setColor(1, QColor(Qt::color1).rgba());

	const int bpl = mask.bytesPerLine();

	for (int y = 0; y < h; ++y) {
	const QRgb src = reinterpret_cast<const QRgb>(image.scanLine(y));
	uchar *dest = mask.scanLine(y);
	memset(dest, 0, bpl);
	for (int x = 0; x < w; ++x) {
	if (qAlpha(*src) > 0)
	dest[x >> 3] \|= qt_pixmap_bit_mask[x & 7];
	++src;
	}
	}

	return QBitmap::fromImage(mask);
	}

	QPixmap QPixmapData::transformed(const QTransform &matrix,
	Qt::TransformationMode mode) const
	{
	return QPixmap::fromImage(toImage().transformed(matrix, mode));
	}

	void QPixmapData::setAlphaChannel(const QPixmap &alphaChannel)
	{
	QImage image = toImage();
	image.setAlphaChannel(alphaChannel.toImage());
	fromImage(image, Qt::AutoColor);
	}

	QPixmap QPixmapData::alphaChannel() const
	{
	return QPixmap::fromImage(toImage().alphaChannel());
	}

	void QPixmapData::setSerialNumber(int serNo)
	{
	ser_no = serNo;
	}

	QImage QPixmapData::toImage(const QRect &rect) const
	{
	if (rect.contains(QRect(0, 0, w, h)))
	return toImage();
	else
	return toImage().copy(rect);
	}

	QImage* QPixmapData::buffer()
	{
	return 0;
	}

	#if defined(Q_OS_SYMBIAN)
	QVolatileImage QPixmapData::toVolatileImage() const
	{
	return QVolatileImage();
	}

	void* QPixmapData::toNativeType(NativeType /* type */)
	{
	return 0;
	}

	void QPixmapData::fromNativeType(void* /* pixmap /, NativeType / typre */)
	{
	return;
	}
	#endif

	QT_END_NAMESPACE