--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/image/qpixmap_raster.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,402 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpixmap.h"
+
+#include "qpixmap_raster_p.h"
+#include "qnativeimage_p.h"
+#include "qimage_p.h"
+
+#include "qbitmap.h"
+#include "qimage.h"
+#include <private/qwidget_p.h>
+#include <private/qdrawhelper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+const uchar qt_pixmap_bit_mask[] = { 0x01, 0x02, 0x04, 0x08,
+ 0x10, 0x20, 0x40, 0x80 };
+
+QPixmap qt_toRasterPixmap(const QImage &image)
+{
+ QPixmapData *data =
+ new QRasterPixmapData(image.depth() == 1
+ ? QPixmapData::BitmapType
+ : QPixmapData::PixmapType);
+
+ data->fromImage(image, Qt::AutoColor);
+
+ return QPixmap(data);
+}
+
+QPixmap qt_toRasterPixmap(const QPixmap &pixmap)
+{
+ if (pixmap.isNull())
+ return QPixmap();
+
+ if (QPixmap(pixmap).data_ptr()->classId() == QPixmapData::RasterClass)
+ return pixmap;
+
+ return qt_toRasterPixmap(pixmap.toImage());
+}
+
+QRasterPixmapData::QRasterPixmapData(PixelType type)
+ : QPixmapData(type, RasterClass)
+{
+}
+
+QRasterPixmapData::~QRasterPixmapData()
+{
+}
+
+QPixmapData *QRasterPixmapData::createCompatiblePixmapData() const
+{
+ return new QRasterPixmapData(pixelType());
+}
+
+void QRasterPixmapData::resize(int width, int height)
+{
+ QImage::Format format;
+#ifdef Q_WS_QWS
+ if (pixelType() == BitmapType) {
+ format = QImage::Format_Mono;
+ } else {
+ format = QScreen::instance()->pixelFormat();
+ if (format == QImage::Format_Invalid)
+ format = QImage::Format_ARGB32_Premultiplied;
+ else if (format == QImage::Format_Indexed8) // currently not supported
+ format = QImage::Format_RGB444;
+ }
+#else
+ if (pixelType() == BitmapType)
+ format = QImage::Format_MonoLSB;
+ else
+ format = QNativeImage::systemFormat();
+#endif
+
+ image = QImage(width, height, format);
+ w = width;
+ h = height;
+ d = image.depth();
+ is_null = (w <= 0 || h <= 0);
+
+ if (pixelType() == BitmapType && !image.isNull()) {
+ image.setNumColors(2);
+ image.setColor(0, QColor(Qt::color0).rgba());
+ image.setColor(1, QColor(Qt::color1).rgba());
+ }
+
+ setSerialNumber(image.serialNumber());
+}
+
+void QRasterPixmapData::fromImage(const QImage &sourceImage,
+ Qt::ImageConversionFlags flags)
+{
+ Q_UNUSED(flags);
+
+#ifdef Q_WS_QWS
+ QImage::Format format;
+ if (pixelType() == BitmapType) {
+ format = QImage::Format_Mono;
+ } else {
+ format = QScreen::instance()->pixelFormat();
+ if (format == QImage::Format_Invalid)
+ format = QImage::Format_ARGB32_Premultiplied;
+ else if (format == QImage::Format_Indexed8) // currently not supported
+ format = QImage::Format_RGB444;
+ }
+
+ if (sourceImage.hasAlphaChannel()
+ && ((flags & Qt::NoOpaqueDetection)
+ || const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {
+ switch (format) {
+ case QImage::Format_RGB16:
+ format = QImage::Format_ARGB8565_Premultiplied;
+ break;
+ case QImage::Format_RGB666:
+ format = QImage::Format_ARGB6666_Premultiplied;
+ break;
+ case QImage::Format_RGB555:
+ format = QImage::Format_ARGB8555_Premultiplied;
+ break;
+ case QImage::Format_RGB444:
+ format = QImage::Format_ARGB4444_Premultiplied;
+ break;
+ default:
+ format = QImage::Format_ARGB32_Premultiplied;
+ break;
+ }
+ } else if (format == QImage::Format_Invalid) {
+ format = QImage::Format_ARGB32_Premultiplied;
+ }
+
+ image = sourceImage.convertToFormat(format);
+#else
+ if (pixelType() == BitmapType) {
+ image = sourceImage.convertToFormat(QImage::Format_MonoLSB);
+ } else {
+ if (sourceImage.depth() == 1) {
+ image = sourceImage.hasAlphaChannel()
+ ? sourceImage.convertToFormat(QImage::Format_ARGB32_Premultiplied)
+ : sourceImage.convertToFormat(QImage::Format_RGB32);
+ } else {
+
+ QImage::Format opaqueFormat = QNativeImage::systemFormat();
+ QImage::Format alphaFormat = QImage::Format_ARGB32_Premultiplied;
+
+ switch (opaqueFormat) {
+ case QImage::Format_RGB16:
+ alphaFormat = QImage::Format_ARGB8565_Premultiplied;
+ break;
+ default: // We don't care about the others...
+ break;
+ }
+
+ if (!sourceImage.hasAlphaChannel()
+ || ((flags & Qt::NoOpaqueDetection) == 0
+ && !const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())) {
+ image = sourceImage.convertToFormat(opaqueFormat);
+ } else {
+ image = sourceImage.convertToFormat(alphaFormat);
+ }
+ }
+ }
+#endif
+ if (image.d) {
+ w = image.d->width;
+ h = image.d->height;
+ d = image.d->depth;
+ } else {
+ w = h = d = 0;
+ }
+ is_null = (w <= 0 || h <= 0);
+
+ setSerialNumber(image.serialNumber());
+}
+
+// from qwindowsurface.cpp
+extern void qt_scrollRectInImage(QImage &img, const QRect &rect, const QPoint &offset);
+
+bool QRasterPixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+ if (!image.isNull())
+ qt_scrollRectInImage(image, rect, QPoint(dx, dy));
+ return true;
+}
+
+void QRasterPixmapData::fill(const QColor &color)
+{
+ uint pixel;
+
+ if (image.depth() == 1) {
+ int gray = qGray(color.rgba());
+ // Pick the best approximate color in the image's colortable.
+ if (qAbs(qGray(image.color(0)) - gray) < qAbs(qGray(image.color(1)) - gray))
+ pixel = 0;
+ else
+ pixel = 1;
+ } else if (image.depth() >= 15) {
+ int alpha = color.alpha();
+ if (alpha != 255) {
+ if (!image.hasAlphaChannel()) {
+ QImage::Format toFormat;
+ if (image.format() == QImage::Format_RGB16)
+ toFormat = QImage::Format_ARGB8565_Premultiplied;
+ else if (image.format() == QImage::Format_RGB666)
+ toFormat = QImage::Format_ARGB6666_Premultiplied;
+ else if (image.format() == QImage::Format_RGB555)
+ toFormat = QImage::Format_ARGB8555_Premultiplied;
+ else if (image.format() == QImage::Format_RGB444)
+ toFormat = QImage::Format_ARGB4444_Premultiplied;
+ else
+ toFormat = QImage::Format_ARGB32_Premultiplied;
+ image = QImage(image.width(), image.height(), toFormat);
+ }
+
+ switch (image.format()) {
+ case QImage::Format_ARGB8565_Premultiplied:
+ pixel = qargb8565(color.rgba()).rawValue();
+ break;
+ case QImage::Format_ARGB8555_Premultiplied:
+ pixel = qargb8555(color.rgba()).rawValue();
+ break;
+ case QImage::Format_ARGB6666_Premultiplied:
+ pixel = qargb6666(color.rgba()).rawValue();
+ break;
+ case QImage::Format_ARGB4444_Premultiplied:
+ pixel = qargb4444(color.rgba()).rawValue();
+ break;
+ default:
+ pixel = PREMUL(color.rgba());
+ break;
+ }
+ } else {
+ switch (image.format()) {
+ case QImage::Format_RGB16:
+ pixel = qt_colorConvert<quint16, quint32>(color.rgba(), 0);
+ break;
+ case QImage::Format_RGB444:
+ pixel = qrgb444(color.rgba()).rawValue();
+ break;
+ case QImage::Format_RGB555:
+ pixel = qrgb555(color.rgba()).rawValue();
+ break;
+ case QImage::Format_RGB666:
+ pixel = qrgb666(color.rgba()).rawValue();
+ break;
+ case QImage::Format_RGB888:
+ pixel = qrgb888(color.rgba()).rawValue();
+ break;
+ default:
+ pixel = color.rgba();
+ break;
+ }
+ }
+ } else {
+ pixel = 0;
+ // ### what about 8 bits
+ }
+
+ image.fill(pixel);
+}
+
+void QRasterPixmapData::setMask(const QBitmap &mask)
+{
+ if (mask.size().isEmpty()) {
+ if (image.depth() != 1) { // hw: ????
+ image = image.convertToFormat(QImage::Format_RGB32);
+ }
+ } else {
+ 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;
+ }
+ }
+ }
+}
+
+bool QRasterPixmapData::hasAlphaChannel() const
+{
+ return image.hasAlphaChannel();
+}
+
+QImage QRasterPixmapData::toImage() const
+{
+ return image;
+}
+
+void QRasterPixmapData::setAlphaChannel(const QPixmap &alphaChannel)
+{
+ image.setAlphaChannel(alphaChannel.toImage());
+}
+
+QPaintEngine* QRasterPixmapData::paintEngine() const
+{
+ return image.paintEngine();
+}
+
+extern int qt_defaultDpiX();
+extern int qt_defaultDpiY();
+
+int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+ QImageData *d = image.d;
+ if (!d)
+ return 0;
+
+ // override the image dpi with the screen dpi when rendering to a pixmap
+ switch (metric) {
+ case QPaintDevice::PdmWidth:
+ return w;
+ case QPaintDevice::PdmHeight:
+ return h;
+ case QPaintDevice::PdmWidthMM:
+ return qRound(d->width * 25.4 / qt_defaultDpiX());
+ case QPaintDevice::PdmHeightMM:
+ return qRound(d->width * 25.4 / qt_defaultDpiY());
+ case QPaintDevice::PdmNumColors:
+ return d->colortable.size();
+ case QPaintDevice::PdmDepth:
+ return this->d;
+ case QPaintDevice::PdmDpiX: // fall-through
+ case QPaintDevice::PdmPhysicalDpiX:
+ return qt_defaultDpiX();
+ case QPaintDevice::PdmDpiY: // fall-through
+ case QPaintDevice::PdmPhysicalDpiY:
+ return qt_defaultDpiY();
+ default:
+ qWarning("QRasterPixmapData::metric(): Unhandled metric type %d", metric);
+ break;
+ }
+
+ return 0;
+}
+
+QImage* QRasterPixmapData::buffer()
+{
+ return ℑ
+}
+
+QT_END_NAMESPACE