FCL/sf/mw/qt: comparison src/gui/image/qimage.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 The color of a pixel can be retrieved by passing its coordinates
 to the pixel() function.  The pixel() function returns the color
 as a QRgb value indepedent of the image's format.
-In case of monochrome and 8-bit images, the numColors() and
+In case of monochrome and 8-bit images, the colorCount() and
 colorTable() functions provide information about the color
 components used to store the image data: The colorTable() function
 returns the image's entire color table. To obtain a single entry,
 use the pixelIndex() function to retrieve the pixel index for a
 given pair of coordinates, then use the color() function to
 \o
 The depth() function returns the depth of the image. The supported
 depths are 1 (monochrome), 8 and 32 (for more information see the
 \l {QImage#Image Formats}{Image Formats} section).
-The format(), bytesPerLine(), and numBytes() functions provide
+The format(), bytesPerLine(), and byteCount() functions provide
 low-level information about the data stored in the image.
 The cacheKey() function returns a number that uniquely
 identifies the contents of this QImage object.
 \endtable
 \row
 \o setColorTable()
 \o Sets the color table used to translate color indexes. Only
 monochrome and 8-bit formats.
 \row
-\o setNumColors()
+\o setColorCount()
 \o Resizes the color table. Only monochrome and 8-bit formats.
 \endtable
 \section1 Legal Information
 The buffer must remain valid throughout the life of the
 QImage. The image does not delete the buffer at destruction.
 If \a format is an indexed color format, the image color table is
 initially empty and must be sufficiently expanded with
-setNumColors() or setColorTable() before the image is used.
+setColorCount() or setColorTable() before the image is used.
 */
 QImage::QImage(uchar* data, int width, int height, Format format)
 : QPaintDevice()
 {
 d = QImageData::create(data, width, height, 0, format, false);
 the original buffer. The image does not delete the buffer at
 destruction.
 If \a format is an indexed color format, the image color table is
 initially empty and must be sufficiently expanded with
-setNumColors() or setColorTable() before the image is used.
+setColorCount() or setColorTable() before the image is used.
 Unlike the similar QImage constructor that takes a non-const data buffer,
 this version will never alter the contents of the buffer.  For example,
 calling QImage::bits() will return a deep copy of the image, rather than
 the buffer passed to the constructor.  This allows for the efficiency of
 The buffer must remain valid throughout the life of the
 QImage. The image does not delete the buffer at destruction.
 If \a format is an indexed color format, the image color table is
 initially empty and must be sufficiently expanded with
-setNumColors() or setColorTable() before the image is used.
+setColorCount() or setColorTable() before the image is used.
 */
 QImage::QImage(uchar *data, int width, int height, int bytesPerLine, Format format)
 :QPaintDevice()
 {
 d = QImageData::create(data, width, height, bytesPerLine, format, false);
 The buffer must remain valid throughout the life of the
 QImage. The image does not delete the buffer at destruction.
 If \a format is an indexed color format, the image color table is
 initially empty and must be sufficiently expanded with
-setNumColors() or setColorTable() before the image is used.
+setColorCount() or setColorTable() before the image is used.
 Unlike the similar QImage constructor that takes a non-const data buffer,
 this version will never alter the contents of the buffer.  For example,
 calling QImage::bits() will return a deep copy of the image, rather than
 the buffer passed to the constructor.  This allows for the efficiency of
 Constructs an image with the given \a width, \a height, \a depth,
 \a numColors colors and \a bitOrder.
 Use the constructor that accepts a width, a height and a format
 (i.e. specifying the depth and bit order), in combination with the
-setNumColors() function, instead.
+setColorCount() function, instead.
 \oldcode
 QImage image(width, height, depth, numColors);
 \newcode
 QImage image(width, height, format);
 // For 8 bit images the default number of colors is 256. If
 // another number of colors is required it can be specified
-// using the setNumColors() function.
+// using the setColorCount() function.
-image.setNumColors(numColors);
+image.setColorCount(numColors);
 \endcode
 */
-QImage::QImage(int w, int h, int depth, int numColors, Endian bitOrder)
+QImage::QImage(int w, int h, int depth, int colorCount, Endian bitOrder)
 : QPaintDevice()
 {
-d = QImageData::create(QSize(w, h), formatFor(depth, bitOrder), numColors);
+d = QImageData::create(QSize(w, h), formatFor(depth, bitOrder), colorCount);
 }
 /*!
 Constructs an image with the given \a size, \a depth, \a numColors
 and \a bitOrder.
 Use the constructor that accepts a size and a format
 (i.e. specifying the depth and bit order), in combination with the
-setNumColors() function, instead.
+setColorCount() function, instead.
 \oldcode
 QSize mySize(width, height);
 QImage image(mySize, depth, numColors);
 \newcode
 QSize mySize(width, height);
 QImage image(mySize, format);
 // For 8 bit images the default number of colors is 256. If
 // another number of colors is required it can be specified
-// using the setNumColors() function.
+// using the setColorCount() function.
-image.setNumColors(numColors);
+image.setColorCount(numColors);
 \endcode
 */
 QImage::QImage(const QSize& size, int depth, int numColors, Endian bitOrder)
 : QPaintDevice()
 {
 if (colortable) {
 d->colortable.resize(numColors);
 for (int i = 0; i < numColors; ++i)
 d->colortable[i] = colortable[i];
 } else if (numColors) {
-setNumColors(numColors);
+setColorCount(numColors);
 }
 }
 #ifdef Q_WS_QWS
 if (colortable) {
 d->colortable.resize(numColors);
 for (int i = 0; i < numColors; ++i)
 d->colortable[i] = colortable[i];
 } else if (numColors) {
-setNumColors(numColors);
+setColorCount(numColors);
 }
 }
 #endif // Q_WS_QWS
 #endif // QT3_SUPPORT
 {
 return d ? d->depth : 0;
 }
 /*!
+\obsolete
 \fn int QImage::numColors() const
 Returns the size of the color table for the image.
-Notice that numColors() returns 0 for 32-bpp images because these
+\sa setColorCount()
+*/
+int QImage::numColors() const
+{
+return d ? d->colortable.size() : 0;
+}
+/*!
+\since 4.6
+\fn int QImage::colorCount() const
+Returns the size of the color table for the image.
+Notice that colorCount() returns 0 for 32-bpp images because these
 images do not use color tables, but instead encode pixel values as
 ARGB quadruplets.
-\sa setNumColors(), {QImage#Image Information}{Image Information}
+\sa setColorCount(), {QImage#Image Information}{Image Information}
 */
-int QImage::numColors() const
+int QImage::colorCount() const
 {
 return d ? d->colortable.size() : 0;
 }
 /*!
 Returns a list of the colors contained in the image's color table,
 or an empty list if the image does not have a color table
-\sa setColorTable(), numColors(), color()
+\sa setColorTable(), colorCount(), color()
 */
 QVector<QRgb> QImage::colorTable() const
 {
 return d ? d->colortable : QVector<QRgb>();
 }
 /*!
+\obsolete
+Returns the number of bytes occupied by the image data.
+\sa byteCount()
+*/
+int QImage::numBytes() const
+{
+return d ? d->nbytes : 0;
+}
+/*!
+\since 4.6
 Returns the number of bytes occupied by the image data.
 \sa bytesPerLine(), bits(), {QImage#Image Information}{Image
 Information}
 */
-int QImage::numBytes() const
+int QImage::byteCount() const
 {
 return d ? d->nbytes : 0;
 }
 /*!
 Returns the number of bytes per image scanline.
-This is equivalent to numBytes()/ height().
+This is equivalent to byteCount() / height().
 \sa scanLine()
 */
 int QImage::bytesPerLine() const
 {
 \sa setColor(), pixelIndex(), {QImage#Pixel Manipulation}{Pixel
 Manipulation}
 */
 QRgb QImage::color(int i) const
 {
-Q_ASSERT(i < numColors());
+Q_ASSERT(i < colorCount());
 return d ? d->colortable.at(i) : QRgb(uint(-1));
 }
 /*!
 \fn void QImage::setColor(int index, QRgb colorValue)
 Sets the color at the given \a index in the color table, to the
 given to \a colorValue. The color value is an ARGB quadruplet.
 If \a index is outside the current size of the color table, it is
-expanded with setNumColors().
+expanded with setColorCount().
-\sa color(), numColors(), setColorTable(), {QImage#Pixel Manipulation}{Pixel
+\sa color(), colorCount(), setColorTable(), {QImage#Pixel Manipulation}{Pixel
 Manipulation}
 */
 void QImage::setColor(int i, QRgb c)
 {
 if (!d)
 // In case detach() run out of memory
 if (!d)
 return;
 if (i >= d->colortable.size())
-setNumColors(i+1);
+setColorCount(i+1);
 d->colortable[i] = c;
 d->has_alpha_clut |= (qAlpha(c) != 255);
 }
 /*!
 Note that QImage uses \l{Implicit Data Sharing} {implicit data
 sharing}. This function performs a deep copy of the shared pixel
 data, thus ensuring that this QImage is the only one using the
 current return value.
-\sa scanLine(), numBytes()
+\sa scanLine(), byteCount()
 */
 uchar *QImage::bits()
 {
 if (!d)
 return 0;
 #if defined(read)
 # undef read
 #endif
 /*!
+\obsolete
 Resizes the color table to contain \a numColors entries.
+\sa setColorCount()
+*/
+void QImage::setNumColors(int numColors)
+{
+setColorCount(numColors);
+}
+/*!
+\since 4.6
+Resizes the color table to contain \a colorCount entries.
 If the color table is expanded, all the extra colors will be set to
 transparent (i.e qRgba(0, 0, 0, 0)).
 When the image is used, the color table must be large enough to
 have entries for all the pixel/index values present in the image,
 otherwise the results are undefined.
-\sa numColors(), colorTable(), setColor(), {QImage#Image
+\sa colorCount(), colorTable(), setColor(), {QImage#Image
 Transformations}{Image Transformations}
 */
-void QImage::setNumColors(int numColors)
+void QImage::setColorCount(int colorCount)
 {
 if (!d) {
-qWarning("QImage::setNumColors: null image");
+qWarning("QImage::setColorCount: null image");
 return;
 }
 detach();
 // In case detach() ran out of memory
 if (!d)
 return;
-if (numColors == d->colortable.size())
+if (colorCount == d->colortable.size())
 return;
-if (numColors <= 0) {                        // use no color table
+if (colorCount <= 0) {                        // use no color table
 d->colortable = QVector<QRgb>();
 return;
 }
 int nc = d->colortable.size();
-d->colortable.resize(numColors);
+d->colortable.resize(colorCount);
-for (int i = nc; i < numColors; ++i)
+for (int i = nc; i < colorCount; ++i)
 d->colortable[i] = 0;
 }
 /*!
 Returns the format of the image.
 If the image's format is either monochrome or 8-bit, the given \a
 index_or_rgb value must be an index in the image's color table,
 otherwise the parameter must be a QRgb value.
 If \a position is not a valid coordinate pair in the image, or if
-\a index_or_rgb >= numColors() in the case of monochrome and
+\a index_or_rgb >= colorCount() in the case of monochrome and
 8-bit images, the result is undefined.
 \warning This function is expensive due to the call of the internal
 \c{detach()} function called within; if performance is a concern, we
 recommend the use of \l{QImage::}{scanLine()} to access pixel data
 if (!qIsGray(qt_colorConvert<quint32, qrgb888>(*b++, 0)))
 return false;
 } else {
 if (d->colortable.isEmpty())
 return true;
-for (int i = 0; i < numColors(); i++)
+for (int i = 0; i < colorCount(); i++)
 if (!qIsGray(d->colortable.at(i)))
 return false;
 }
 return true;
 }
 case 32:
 case 24:
 case 16:
 return allGray();
 case 8: {
-for (int i = 0; i < numColors(); i++)
+for (int i = 0; i < colorCount(); i++)
 if (d->colortable.at(i) != qRgb(i,i,i))
 return false;
 return true;
 }
 }
 // Pretty unlikely, so use less efficient solution.
 return convertToFormat(Format_Indexed8, flags).createAlphaMask(flags);
 }
 QImage mask(d->width, d->height, Format_MonoLSB);
-dither_to_Mono(mask.d, d, flags, true);
+if (!mask.isNull())
+dither_to_Mono(mask.d, d, flags, true);
 return mask;
 }
 #ifndef QT_NO_IMAGE_HEURISTIC_MASK
 /*!
 #define PIX(x,y)  (*((QRgb*)scanLine(y)+x) & 0x00ffffff)
 int w = width();
 int h = height();
 QImage m(w, h, Format_MonoLSB);
-m.setNumColors(2);
+m.setColorCount(2);
 m.setColor(0, QColor(Qt::color0).rgba());
 m.setColor(1, QColor(Qt::color1).rgba());
 m.fill(0xff);
 QRgb background = PIX(0,0);
 int w = d->width;
 int h = d->height;
 QImage image(w, h, Format_Indexed8);
-image.setNumColors(256);
+image.setColorCount(256);
 // set up gray scale table.
 for (int i=0; i<256; ++i)
 image.setColor(i, qRgb(i, i, i));
 }
 static QImage rotated90(const QImage &image) {
 QImage out(image.height(), image.width(), image.format());
-if (image.numColors() > 0)
+if (image.colorCount() > 0)
 out.setColorTable(image.colorTable());
 int w = image.width();
 int h = image.height();
 switch (image.format()) {
 case QImage::Format_RGB32:
 reinterpret_cast<quint8*>(out.bits()),
 out.bytesPerLine());
 break;
 default:
 for (int y=0; y<h; ++y) {
-if (image.numColors())
+if (image.colorCount())
 for (int x=0; x<w; ++x)
 out.setPixel(h-y-1, x, image.pixelIndex(x, y));
 else
 for (int x=0; x<w; ++x)
 out.setPixel(h-y-1, x, image.pixel(x, y));
 }
 static QImage rotated270(const QImage &image) {
 QImage out(image.height(), image.width(), image.format());
-if (image.numColors() > 0)
+if (image.colorCount() > 0)
 out.setColorTable(image.colorTable());
 int w = image.width();
 int h = image.height();
 switch (image.format()) {
 case QImage::Format_RGB32:
 reinterpret_cast<quint8*>(out.bits()),
 out.bytesPerLine());
 break;
 default:
 for (int y=0; y<h; ++y) {
-if (image.numColors())
+if (image.colorCount())
 for (int x=0; x<w; ++x)
 out.setPixel(y, w-x-1, image.pixelIndex(x, y));
 else
 for (int x=0; x<w; ++x)
 out.setPixel(y, w-x-1, image.pixel(x, y));
 // initizialize the data
 case 8:
 if (dImage.d->colortable.size() < 256) {
 // colors are left in the color table, so pick that one as transparent
 dImage.d->colortable.append(0x0);
-memset(dImage.bits(), dImage.d->colortable.size() - 1, dImage.numBytes());
+memset(dImage.bits(), dImage.d->colortable.size() - 1, dImage.byteCount());
 } else {
-memset(dImage.bits(), 0, dImage.numBytes());
+memset(dImage.bits(), 0, dImage.byteCount());
 }
 break;
 case 1:
 case 16:
 case 24:
 case 32:
-memset(dImage.bits(), 0x00, dImage.numBytes());
+memset(dImage.bits(), 0x00, dImage.byteCount());
 break;
 }
 if (target_format >= QImage::Format_RGB32) {
 QPainter p(&dImage);

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