MCL/sf/mw/qt: comparison src/gui/image/qpixmap.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 init(w, h, int(type));
 }
 void QPixmap::init(int w, int h, int type)
 {
-QGraphicsSystem* gs = QApplicationPrivate::graphicsSystem();
+if ((w > 0 && h > 0) || type == QPixmapData::BitmapType)
-if (gs)
+data = QPixmapData::create(w, h, (QPixmapData::PixelType) type);
-data = gs->createPixmapData(static_cast<QPixmapData::PixelType>(type));
 else
-data = QGraphicsSystem::createDefaultPixmapData(static_cast<QPixmapData::PixelType>(type));
+data = 0;
-data->resize(w, h);
 }
 /*!
 \enum QPixmap::ColorMode
 if (!xpm)
 return;
 QImage image(xpm);
 if (!image.isNull()) {
-if (data->pixelType() == QPixmapData::BitmapType)
+if (data && data->pixelType() == QPixmapData::BitmapType)
 *this = QBitmap::fromImage(image);
 else
 *this = fromImage(image);
 }
 }
 Destroys the pixmap.
 */
 QPixmap::~QPixmap()
 {
-Q_ASSERT(data->ref >= 1); // Catch if ref-counting changes again
+Q_ASSERT(!data || data->ref >= 1); // Catch if ref-counting changes again
-if (data->is_cached && data->ref == 1) // ref will be decrememnted after destructor returns
+if (data && data->is_cached && data->ref == 1) // ref will be decrememnted after destructor returns
 QImagePixmapCleanupHooks::executePixmapDestructionHooks(this);
 }
 /*!
 \internal
 A null pixmap has zero width, zero height and no contents. You
 cannot draw in a null pixmap.
 */
 bool QPixmap::isNull() const
 {
-return data->isNull();
+return !data || data->isNull();
 }
 /*!
 \fn int QPixmap::width() const
 \sa size(), {QPixmap#Pixmap Information}{Pixmap Information}
 */
 int QPixmap::width() const
 {
-return data->width();
+return data ? data->width() : 0;
 }
 /*!
 \fn int QPixmap::height() const
 \sa size(), {QPixmap#Pixmap Information}{Pixmap Information}
 */
 int QPixmap::height() const
 {
-return data->height();
+return data ? data->height() : 0;
 }
 /*!
 \fn QSize QPixmap::size() const
 \sa width(), height(), {QPixmap#Pixmap Information}{Pixmap
 Information}
 */
 QSize QPixmap::size() const
 {
-return QSize(data->width(), data->height());
+return data ? QSize(data->width(), data->height()) : QSize();
 }
 /*!
 \fn QRect QPixmap::rect() const
 \sa {QPixmap#Pixmap Information}{Pixmap Information}
 */
 QRect QPixmap::rect() const
 {
-return QRect(0, 0, data->width(), data->height());
+return data ? QRect(0, 0, data->width(), data->height()) : QRect();
 }
 /*!
 \fn int QPixmap::depth() const
 \sa defaultDepth(), {QPixmap#Pixmap Information}{Pixmap
 Information}
 */
 int QPixmap::depth() const
 {
-return data->depth();
+return data ? data->depth() : 0;
 }
 /*!
 \fn void QPixmap::resize(const QSize &size)
 \overload
 if (size() == s)
 return;
 // Create new pixmap
-QPixmap pm(QSize(w, h), data->type);
+QPixmap pm(QSize(w, h), data ? data->type : QPixmapData::PixmapType);
 bool uninit = false;
 #if defined(Q_WS_X11)
-QX11PixmapData *x11Data = data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data.data()) : 0;
+QX11PixmapData *x11Data = data && data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data.data()) : 0;
 if (x11Data) {
 pm.x11SetScreen(x11Data->xinfo.screen());
 uninit = x11Data->flags & QX11PixmapData::Uninitialized;
 }
 #elif defined(Q_WS_MAC)
-QMacPixmapData *macData = data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
+QMacPixmapData *macData = data && data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
 if (macData)
 uninit = macData->uninit;
 #endif
 if (!uninit && !isNull()) {
 // Copy old pixmap
 if (!mask.isNull() && mask.size() != size()) {
 qWarning("QPixmap::setMask() mask size differs from pixmap size");
 return;
 }
+if (isNull())
+return;
 if (static_cast<const QPixmap &>(mask).data == data) // trying to selfmask
 return;
 detach();
 data->setMask(mask);
 if (fileName.isEmpty())
 return false;
 QFileInfo info(fileName);
 QString key = QLatin1String("qt_pixmap_") + info.absoluteFilePath() + QLatin1Char('_') + QString::number(info.lastModified().toTime_t()) + QLatin1Char('_') +
-QString::number(info.size()) + QLatin1Char('_') + QString::number(data->pixelType());
+QString::number(info.size()) + QLatin1Char('_') + QString::number(data ? data->pixelType() : QPixmapData::PixmapType);
 if (QPixmapCache::find(key, *this))
 return true;
-if (data->fromFile(fileName, format, flags)) {
+QPixmapData *tmp = QPixmapData::create(0, 0, QPixmapData::PixmapType);
+if (tmp->fromFile(fileName, format, flags)) {
+data = tmp;
 QPixmapCache::insert(key, *this);
 return true;
 }
+delete tmp;
 return false;
 }
 /*!
 \fn bool QPixmap::loadFromData(const uchar *data, uint len, const char *format, Qt::ImageConversionFlags flags)
 Writing Image Files}
 */
 bool QPixmap::loadFromData(const uchar *buf, uint len, const char *format, Qt::ImageConversionFlags flags)
 {
+if (len == 0 || buf == 0)
+return false;
+if (!data)
+data = QPixmapData::create(0, 0, QPixmapData::PixmapType);
 return data->fromData(buf, len, format, flags);
 }
 /*!
 \fn bool QPixmap::loadFromData(const QByteArray &data, const char *format, Qt::ImageConversionFlags flags)
 The cacheKey() will change when the pixmap is altered.
 */
 qint64 QPixmap::cacheKey() const
 {
+if (isNull())
+return 0;
 int classKey = data->classId();
 if (classKey >= 1024)
 classKey = -(classKey >> 10);
 return ((((qint64) classKey) << 56)
 | (((qint64) data->serialNumber()) << 32)
 */
 Qt::HANDLE QPixmap::handle() const
 {
 #if defined(Q_WS_X11)
-if (data->classId() == QPixmapData::X11Class)
+if (data && data->classId() == QPixmapData::X11Class)
 return static_cast<const QX11PixmapData*>(data.constData())->handle();
 #endif
 return 0;
 }
 #endif
 {
 init(0, 0, QPixmapData::PixmapType);
 if (!qt_pixmap_thread_test())
 return;
-if (data->pixelType() == QPixmapData::BitmapType)
+if (data && data->pixelType() == QPixmapData::BitmapType)
 *this = QBitmap::fromImage(image);
 else
 *this = fromImage(image);
 }
 Use the static fromImage() function instead.
 */
 QPixmap &QPixmap::operator=(const QImage &image)
 {
-if (data->pixelType() == QPixmapData::BitmapType)
+if (data && data->pixelType() == QPixmapData::BitmapType)
 *this = QBitmap::fromImage(image);
 else
 *this = fromImage(image);
 return *this;
 }
 /*!
 Use the static fromImage() function instead.
 */
 bool QPixmap::convertFromImage(const QImage &image, ColorMode mode)
 {
-if (data->pixelType() == QPixmapData::BitmapType)
+if (data && data->pixelType() == QPixmapData::BitmapType)
 *this = QBitmap::fromImage(image, colorModeToFlags(mode));
 else
 *this = fromImage(image, colorModeToFlags(mode));
 return !isNull();
 }
 \internal
 */
 bool QPixmap::isDetached() const
 {
-return data->ref == 1;
+return data && data->ref == 1;
 }
 /*! \internal
 ### Qt5 - remove me.
 */
 \sa hasAlphaChannel(), mask()
 */
 bool QPixmap::hasAlpha() const
 {
-return (data->hasAlphaChannel() || !data->mask().isNull());
+return data && (data->hasAlphaChannel() || !data->mask().isNull());
 }
 /*!
 Returns true if the pixmap has a format that respects the alpha
 channel, otherwise returns false.
 \sa hasAlpha()
 */
 bool QPixmap::hasAlphaChannel() const
 {
-return data->hasAlphaChannel();
+return data && data->hasAlphaChannel();
 }
 /*!
 \internal
 */
 int QPixmap::metric(PaintDeviceMetric metric) const
 {
-return data->metric(metric);
+return data ? data->metric(metric) : 0;
 }
 /*!
 \fn void QPixmap::setAlphaChannel(const QPixmap &alphaChannel)
 \obsolete
 \sa setAlphaChannel(), {QPixmap#Pixmap Information}{Pixmap
 Information}
 */
 QPixmap QPixmap::alphaChannel() const
 {
-return data->alphaChannel();
+return data ? data->alphaChannel() : QPixmap();
 }
 /*!
 \internal
 */
 QPaintEngine *QPixmap::paintEngine() const
 {
-return data->paintEngine();
+return data ? data->paintEngine() : 0;
 }
 /*!
 \fn QBitmap QPixmap::mask() const
 \sa setMask(), {QPixmap#Pixmap Information}{Pixmap Information}
 */
 QBitmap QPixmap::mask() const
 {
-return data->mask();
+return data ? data->mask() : QBitmap();
 }
 /*!
 Returns the default pixmap depth used by the application.
 The detach() function returns immediately if there is just a
 single reference or if the pixmap has not been initialized yet.
 */
 void QPixmap::detach()
 {
+if (!data)
+return;
 QPixmapData::ClassId id = data->classId();
 if (id == QPixmapData::RasterClass) {
 QRasterPixmapData *rasterData = static_cast<QRasterPixmapData*>(data.data());
 rasterData->image.detach();
 }
 /*! \fn QRgb* QPixmap::clut() const
 \internal
 */
 /*! \fn int QPixmap::numCols() const
+\obsolete
+\internal
+\sa colorCount()
+*/
+/*! \fn int QPixmap::colorCount() const
+\since 4.6
 \internal
 */
 /*! \fn const uchar* QPixmap::qwsBits() const
 \internal

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