FCL/sf/mw/qt: comparison src/gui/image/qpixmap

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 **
 ** 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 of the Qt Toolkit.
+** 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
 Symbian Font And Bitmap server client that is
 used to lock the global bitmap heap. Only used in
 S60 v3.1 and S60 v3.2.
 */
+_LIT(KFBSERVLargeBitmapAccessName,"FbsLargeBitmapAccess");
 class QSymbianFbsClient
 {
 public:
-QSymbianFbsClient() : heapLock(0), heapLocked(false)
+QSymbianFbsClient() : heapLocked(false)
 {
-QT_TRAP_THROWING(heapLock = new(ELeave) CFbsBitmap);
+heapLock.OpenGlobal(KFBSERVLargeBitmapAccessName);
-heapLock->Create(TSize(0,0), S60->screenDevice()->DisplayMode());
 }
 ~QSymbianFbsClient()
 {
-delete heapLock;
+heapLock.Close();
 }
 bool lockHeap()
 {
 bool wasLocked = heapLocked;
-if (heapLock && !heapLocked) {
+if (heapLock.Handle() && !heapLocked) {
-heapLock->LockHeap(ETrue);
+heapLock.Wait();
 heapLocked = true;
 }
 return wasLocked;
 }
 bool unlockHeap()
 {
 bool wasLocked = heapLocked;
-if (heapLock && heapLocked) {
+if (heapLock.Handle() && heapLocked) {
-heapLock->UnlockHeap(ETrue);
+heapLock.Signal();
 heapLocked = false;
 }
 return wasLocked;
 }
 private:
-CFbsBitmap *heapLock;
+RMutex heapLock;
 bool heapLocked;
 };
 Q_GLOBAL_STATIC(QSymbianFbsClient, qt_symbianFbsClient);
 ~QSymbianBitmapDataAccess() {};
 inline void beginDataAccess(CFbsBitmap *bitmap)
 {
-if (symbianVersion == QSysInfo::SV_9_2 || symbianVersion == QSysInfo::SV_9_3)
+if (symbianVersion == QSysInfo::SV_9_2)
 heapWasLocked = qt_symbianFbsClient()->lockHeap();
 else
 bitmap->LockHeap(ETrue);
 }
 inline void endDataAccess(CFbsBitmap *bitmap)
 {
-if (symbianVersion == QSysInfo::SV_9_2 || symbianVersion == QSysInfo::SV_9_3) {
+if (symbianVersion == QSysInfo::SV_9_2) {
 if (!heapWasLocked)
 qt_symbianFbsClient()->unlockHeap();
 } else {
 bitmap->UnlockHeap(ETrue);
 }
 CFbsBitGc *bitmapGc = 0;
 QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(uncompressed));
 QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());
 bitmapGc->Activate(bitmapDevice);
-bitmapGc->DrawBitmap(TPoint(), bitmap);
+bitmapGc->BitBlt(TPoint(), bitmap);
 delete bitmapGc;
 delete bitmapDevice;
 return uncompressed;
 \sa fromSymbianCFbsBitmap()
 */
 CFbsBitmap *QPixmap::toSymbianCFbsBitmap() const
 {
 QPixmapData *data = pixmapData();
-if (data->isNull())
+if (!data || data->isNull())
 return 0;
 return reinterpret_cast<CFbsBitmap*>(data->toNativeType(QPixmapData::FbsBitmap));
 }
 QPixmap QPixmap::fromSymbianCFbsBitmap(CFbsBitmap *bitmap)
 {
 if (!bitmap)
 return QPixmap();
-QPixmap pixmap;
+QScopedPointer<QS60PixmapData> data(new QS60PixmapData(QPixmapData::PixmapType));
-pixmap.pixmapData()->fromNativeType(reinterpret_cast<void*>(bitmap), QPixmapData::FbsBitmap);
+data->fromNativeType(reinterpret_cast<void*>(bitmap), QPixmapData::FbsBitmap);
+QPixmap pixmap(data.take());
 return pixmap;
 }
 QS60PixmapData::QS60PixmapData(PixelType type) : QRasterPixmapData(type),
 symbianBitmapDataAccess(new QSymbianBitmapDataAccess),
 cfbsBitmap(0),
-bitmapDevice(0),
-bitmapGc(0),
 pengine(0),
-bytes(0)
+bytes(0),
+formatLocked(false)
 {
 }
 QS60PixmapData::~QS60PixmapData()
 TSize newSize(width, height);
 if(cfbsBitmap->SizeInPixels() != newSize) {
 cfbsBitmap->Resize(TSize(width, height));
-bitmapDevice->Resize(TSize(width, height));
-bitmapGc->Resized();
 if(pengine) {
 delete pengine;
 pengine = 0;
 }
 }
 UPDATE_BUFFER();
 }
 }
-bool QS60PixmapData::initSymbianBitmapContext()
-{
-QT_TRAP_THROWING(bitmapDevice = CFbsBitmapDevice::NewL(cfbsBitmap));
-QT_TRAP_THROWING(bitmapGc = CFbsBitGc::NewL());
-bitmapGc->Activate(bitmapDevice);
-return true;
-}
 void QS60PixmapData::release()
 {
 if (cfbsBitmap) {
 QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);
-delete bitmapGc;
-delete bitmapDevice;
 delete cfbsBitmap;
 lock.relock();
 }
 delete pengine;
 image = QImage();
 cfbsBitmap = 0;
-bitmapGc = 0;
-bitmapDevice = 0;
 pengine = 0;
 bytes = 0;
 }
 /*!
-* Takes ownership of bitmap
+* Takes ownership of bitmap. Used by window surface
 */
-void QS60PixmapData::fromSymbianBitmap(CFbsBitmap* bitmap)
+void QS60PixmapData::fromSymbianBitmap(CFbsBitmap* bitmap, bool lockFormat)
 {
-	cfbsBitmap = bitmap;
+Q_ASSERT(bitmap);
-	 if(!initSymbianBitmapContext()) {
+release();
-		qWarning("Could not create CBitmapContext");
-		release();
+cfbsBitmap = bitmap;
-		return;
+formatLocked = lockFormat;
-	}
+setSerialNumber(cfbsBitmap->Handle());
-	setSerialNumber(cfbsBitmap->Handle());
+UPDATE_BUFFER();
-	UPDATE_BUFFER();
+// Create default palette if needed
-	// Create default palette if needed
+if (cfbsBitmap->DisplayMode() == EGray2) {
-	if (cfbsBitmap->DisplayMode() == EGray2) {
+image.setColorCount(2);
-		image.setNumColors(2);
+image.setColor(0, QColor(Qt::color0).rgba());
-		image.setColor(0, QColor(Qt::color0).rgba());
+image.setColor(1, QColor(Qt::color1).rgba());
-		image.setColor(1, QColor(Qt::color1).rgba());
 //Symbian thinks set pixels are white/transparent, Qt thinks they are foreground/solid
 //So invert mono bitmaps so that masks work correctly.
 image.invertPixels();
-	} else if (cfbsBitmap->DisplayMode() == EGray256) {
+} else if (cfbsBitmap->DisplayMode() == EGray256) {
-		for (int i=0; i < 256; ++i)
+for (int i=0; i < 256; ++i)
-			image.setColor(i, qRgb(i, i, i));
+image.setColor(i, qRgb(i, i, i));
-	}else if (cfbsBitmap->DisplayMode() == EColor256) {
+} else if (cfbsBitmap->DisplayMode() == EColor256) {
-		const TColor256Util *palette = TColor256Util::Default();
+const TColor256Util *palette = TColor256Util::Default();
-		for (int i=0; i < 256; ++i)
+for (int i=0; i < 256; ++i)
-			image.setColor(i, (QRgb)(palette->Color256(i).Value()));
+image.setColor(i, (QRgb)(palette->Color256(i).Value()));
-	}
+}
+}
+QImage QS60PixmapData::toImage(const QRect &r) const
+{
+QS60PixmapData *that = const_cast<QS60PixmapData*>(this);
+that->beginDataAccess();
+QImage copy = that->image.copy(r);
+that->endDataAccess();
+return copy;
 }
 void QS60PixmapData::fromImage(const QImage &img, Qt::ImageConversionFlags flags)
 {
+release();
 QImage sourceImage;
 if (pixelType() == BitmapType) {
 sourceImage = img.convertToFormat(QImage::Format_MonoLSB);
 } else {
 qWarning("Image format not supported: %d", image.format());
 return;
 }
 cfbsBitmap = createSymbianCFbsBitmap(TSize(sourceImage.width(), sourceImage.height()), mode);
-if (!(cfbsBitmap && initSymbianBitmapContext())) {
+if (!cfbsBitmap) {
-qWarning("Could not create CFbsBitmap and/or CBitmapContext");
+qWarning("Could not create CFbsBitmap");
 release();
 return;
 }
 setSerialNumber(cfbsBitmap->Handle());
 const uchar *sptr = const_cast<const QImage &>(sourceImage).bits();
 symbianBitmapDataAccess->beginDataAccess(cfbsBitmap);
 uchar *dptr = (uchar*)cfbsBitmap->DataAddress();
-Mem::Copy(dptr, sptr, sourceImage.numBytes());
+Mem::Copy(dptr, sptr, sourceImage.byteCount());
 symbianBitmapDataAccess->endDataAccess(cfbsBitmap);
 UPDATE_BUFFER();
 if (destFormat == QImage::Format_MonoLSB) {
-		image.setNumColors(2);
+		image.setColorCount(2);
 		image.setColor(0, QColor(Qt::color0).rgba());
 		image.setColor(1, QColor(Qt::color1).rgba());
 	} else {
 		image.setColorTable(sourceImage.colorTable());
 	}
 }
 void QS60PixmapData::copy(const QPixmapData *data, const QRect &rect)
 {
-if (data->pixelType() == BitmapType) {
-QBitmap::fromImage(data->toImage().copy(rect));
-return;
-}
 const QS60PixmapData *s60Data = static_cast<const QS60PixmapData*>(data);
+fromImage(s60Data->toImage(rect), Qt::AutoColor | Qt::OrderedAlphaDither);
-resize(rect.width(), rect.height());
-cfbsBitmap->SetDisplayMode(s60Data->cfbsBitmap->DisplayMode());
-bitmapGc->BitBlt(TPoint(0, 0), s60Data->cfbsBitmap, qt_QRect2TRect(rect));
 }
 bool QS60PixmapData::scroll(int dx, int dy, const QRect &rect)
 {
 beginDataAccess();
 fromImage(img, Qt::OrderedDither | Qt::OrderedAlphaDither);
 }
 QImage QS60PixmapData::toImage() const
 {
-QS60PixmapData *that = const_cast<QS60PixmapData*>(this);
+return toImage(QRect());
-that->beginDataAccess();
-QImage copy = that->image.copy();
-that->endDataAccess();
-return copy;
 }
 QPaintEngine* QS60PixmapData::paintEngine() const
 {
 if (!pengine) {
 symbianBitmapDataAccess->beginDataAccess(cfbsBitmap);
 uchar* newBytes = (uchar*)cfbsBitmap->DataAddress();
-if (newBytes == bytes)
+TSize size = cfbsBitmap->SizeInPixels();
+if (newBytes == bytes && image.width() == size.iWidth && image.height() == size.iHeight)
 return;
 bytes = newBytes;
 TDisplayMode mode = cfbsBitmap->DisplayMode();
 QImage::Format format = qt_TDisplayMode2Format(mode);
-//on S60 3.1, premultiplied alpha pixels are stored in a bitmap with 16MA type
+// On S60 3.1, premultiplied alpha pixels are stored in a bitmap with 16MA type.
-if (format == QImage::Format_ARGB32)
+// S60 window surface needs backing store pixmap for transparent window in ARGB32 format.
+// In that case formatLocked is true.
+if (!formatLocked && format == QImage::Format_ARGB32)
 format = QImage::Format_ARGB32_Premultiplied; // pixel data is actually in premultiplied format
-TSize size = cfbsBitmap->SizeInPixels();
 QVector<QRgb> savedColorTable;
 if (!image.isNull())
 savedColorTable = image.colorTable();
 // Surely things might change in future
 if (!sgImage)
 return QPixmap();
-QPixmap pixmap;
+QScopedPointer<QS60PixmapData> data(new QS60PixmapData(QPixmapData::PixmapType));
-pixmap.pixmapData()->fromNativeType(reinterpret_cast<void*>(sgImage), QPixmapData::SgImage);
+data->fromNativeType(reinterpret_cast<void*>(sgImage), QPixmapData::SgImage);
+QPixmap pixmap(data.take());
 return pixmap;
 }
 /*!
 \since 4.6
 TDisplayMode displayMode = cfbsBitmap->DisplayMode();
 if(displayMode == EGray2) {
 //Symbian thinks set pixels are white/transparent, Qt thinks they are foreground/solid
 //So invert mono bitmaps so that masks work correctly.
+beginDataAccess();
 image.invertPixels();
+endDataAccess();
 needsCopy = true;
 }
 if (needsCopy) {
 QImage source;
 if (convertToArgb32) {
+beginDataAccess();
 source = image.convertToFormat(QImage::Format_ARGB32);
+endDataAccess();
 displayMode = EColor16MA;
 } else {
 source = image;
 }
 CFbsBitmap *newBitmap = createSymbianCFbsBitmap(TSize(source.width(), source.height()), displayMode);
 const uchar *sptr = source.bits();
 symbianBitmapDataAccess->beginDataAccess(newBitmap);
 uchar *dptr = (uchar*)newBitmap->DataAddress();
-Mem::Copy(dptr, sptr, source.numBytes());
+Mem::Copy(dptr, sptr, source.byteCount());
 symbianBitmapDataAccess->endDataAccess(newBitmap);
 bitmap = newBitmap;
 } else {
 }
 }
 if(displayMode == EGray2) {
 // restore pixels
+beginDataAccess();
 image.invertPixels();
+endDataAccess();
 }
 return reinterpret_cast<void*>(bitmap);
 }
 QSymbianBitmapDataAccess da;
 da.beginDataAccess(sourceBitmap);
 uchar *bytes = (uchar*)sourceBitmap->DataAddress();
 QImage img = QImage(bytes, size.iWidth, size.iHeight, format);
+img = img.copy();
 da.endDataAccess(sourceBitmap);
-fromImage(img, Qt::AutoColor);
-if(deleteSourceBitmap)
-delete sourceBitmap;
 if(displayMode == EGray2) {
 //Symbian thinks set pixels are white/transparent, Qt thinks they are foreground/solid
 //So invert mono bitmaps so that masks work correctly.
-image.invertPixels();
+img.invertPixels();
+} else if(displayMode == EColor16M) {
+img = img.rgbSwapped(); // EColor16M is BGR
 }
+fromImage(img, Qt::AutoColor);
+if(deleteSourceBitmap)
+delete sourceBitmap;
 } else {
 CFbsBitmap* duplicate = 0;
 QT_TRAP_THROWING(duplicate = new (ELeave) CFbsBitmap);
 TInt err = duplicate->Duplicate(sourceBitmap->Handle());
 delete sourceBitmap;
 }
 }
 }
+QPixmapData *QS60PixmapData::createCompatiblePixmapData() const
+{
+return new QS60PixmapData(pixelType());
+}
 QT_END_NAMESPACE

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c