#include <qpixmap_mac_p.h>

Inheritance diagram for QMacPixmapData:

Public Functions
QPixmap	alphaChannel () const

void	copy (const QPixmapData *data, const QRect &rect)

QPixmapData *	createCompatiblePixmapData () const

void	fill (const QColor &color)

void	fromImage (const QImage &image, Qt::ImageConversionFlags flags)

bool	hasAlphaChannel () const

QBitmap	mask () const

int	metric (QPaintDevice::PaintDeviceMetric metric) const

QPaintEngine *	paintEngine () const

	QMacPixmapData (PixelType type)

void	resize (int width, int height)

bool	scroll (int dx, int dy, const QRect &rect)

void	setAlphaChannel (const QPixmap &alphaChannel)

void	setMask (const QBitmap &mask)

QImage	toImage () const

	~QMacPixmapData ()

Public Functions inherited from QPixmapData
virtual QImage *	buffer ()

qint64	cacheKey () const

ClassId	classId () const

int	colorCount () const

int	depth () const

virtual bool	fromData (const uchar buffer, uint len, const char format, Qt::ImageConversionFlags flags)

virtual bool	fromFile (const QString &filename, const char *format, Qt::ImageConversionFlags flags)

virtual void	fromImageReader (QImageReader *imageReader, Qt::ImageConversionFlags flags)

int	height () const

bool	isNull () const

QT_DEPRECATED int	numColors () const

PixelType	pixelType () const

	QPixmapData (PixelType pixelType, int classId)

virtual QPixmapData *	runtimeData () const

int	serialNumber () const

virtual QImage	toImage (const QRect &rect) const

virtual QPixmap	transformed (const QTransform &matrix, Qt::TransformationMode mode) const

int	width () const

virtual	~QPixmapData ()

Private Functions
void	macCreateCGImageRef ()

void	macCreatePixels ()

void	macGetAlphaChannel (QMacPixmapData *, bool asMask) const

void	macReleaseCGImageRef ()

void	macSetAlphaChannel (const QMacPixmapData *, bool asMask)

void	macSetHasAlpha (bool b)

Properties
uint	bytesPerRow

CGImageRef	cg_data

CGImageRef	cg_dataBeingReleased

CGImageRef	cg_mask

QRectF	cg_mask_rect

uint	has_alpha: 1

uint	has_mask: 1

QPaintEngine *	pengine

quint32 *	pixels

uint	pixelsSize

quint32 *	pixelsToFree

uint	uninit: 1

Static Private Attributes
static QSet< QMacPixmapData * >	validDataPointers

Friends
QColor	qcolorForThemeTextColor (ThemeTextColor themeColor)

class	QCoreGraphicsPaintEngine

class	QPixmap

class	QRasterBuffer

class	QRasterPaintEngine

CGContextRef	qt_mac_cg_context (const QPaintDevice *)
	Returns the CoreGraphics CGContextRef of the paint device. More...

void	qt_mac_cgimage_data_free (void , const void , size_t)

IconRef	qt_mac_create_iconref (const QPixmap &)

CGImageRef	qt_mac_create_imagemask (const QPixmap &, const QRectF &)

quint32 *	qt_mac_pixmap_get_base (const QPixmap *)

int	qt_mac_pixmap_get_bytes_per_line (const QPixmap *)

Additional Inherited Members
Public Types inherited from QPixmapData
enum	ClassId { RasterClass, X11Class, MacClass, DirectFBClass, OpenGLClass, OpenVGClass, RuntimeClass, BlitterClass, CustomClass = 1024 }

enum	PixelType { PixmapType, BitmapType }

Static Public Functions inherited from QPixmapData
static QPixmapData *	create (int w, int h, PixelType type)

Protected Functions inherited from QPixmapData
void	setSerialNumber (int serNo)

Protected Variables inherited from QPixmapData
int	d

int	h

bool	is_null

int	w

Detailed Description

Definition at line 62 of file qpixmap_mac_p.h.

Constructors and Destructors

◆ QMacPixmapData()

QMacPixmapData::QMacPixmapData ( PixelType type )

Definition at line 173 of file qpixmap_mac.cpp.

Referenced by alphaChannel(), createCompatiblePixmapData(), macCreatePixels(), and mask().

     : QPixmapData(type, MacClass), has_alpha(0), has_mask(0),
       uninit(true), pixels(0), pixelsSize(0), pixelsToFree(0),
       bytesPerRow(0), cg_data(0), cg_dataBeingReleased(0), cg_mask(0),
       pengine(0)
 {
 }

◆ ~QMacPixmapData()

QMacPixmapData::~QMacPixmapData ( )

Definition at line 519 of file qpixmap_mac.cpp.

 {
     validDataPointers.remove(this);
     if (cg_mask) {
         CGImageRelease(cg_mask);
         cg_mask = 0;
     }
 
     delete pengine;  // Make sure we aren't drawing on the context anymore.
     if (cg_data) {
         CGImageRelease(cg_data);
     }
     else if (pixels && (pixels != pixelsToFree))
         free(pixels);
     if (pixelsToFree)
         free(pixelsToFree);
 }

Functions

◆ alphaChannel()

QPixmap QMacPixmapData::alphaChannel ( ) const

virtual

Reimplemented from QPixmapData.

Definition at line 442 of file qpixmap_mac.cpp.

 {
     if (!has_alpha)
         return QPixmap();
 
     QMacPixmapData *alpha = new QMacPixmapData(PixmapType);
     alpha->resize(w, h);
     macGetAlphaChannel(alpha, false);
     return QPixmap(alpha);
 }

◆ copy()

void QMacPixmapData::copy	(	const QPixmapData *	data,
		const QRect &	rect
	)

virtual

Reimplemented from QPixmapData.

Definition at line 1198 of file qpixmap_mac.cpp.

 {
     if (data->pixelType() == BitmapType) {
         QBitmap::fromImage(toImage().copy(rect));
         return;
     }
 
     const QMacPixmapData *macData = static_cast<const QMacPixmapData*>(data);
 
     resize(rect.width(), rect.height());
 
     has_alpha = macData->has_alpha;
     has_mask = macData->has_mask;
     uninit = false;
 
     const int x = rect.x();
     const int y = rect.y();
     char *dest = reinterpret_cast<char*>(pixels);
 
     // only copy data buffer if destination buffer exists (resize might have failed)
     if (dest) {
         const char *src = reinterpret_cast<const char*>(macData->pixels + x) + y * macData->bytesPerRow;
         for (int i = 0; i < h; ++i) {
             memcpy(dest, src, w * 4);
             dest += bytesPerRow;
             src += macData->bytesPerRow;
         }
 
         has_alpha = macData->has_alpha;
         has_mask = macData->has_mask;
     }
 }

◆ createCompatiblePixmapData()

QPixmapData * QMacPixmapData::createCompatiblePixmapData ( ) const

virtual

Reimplemented from QPixmapData.

Definition at line 181 of file qpixmap_mac.cpp.

 {
     return new QMacPixmapData(pixelType());
 }

◆ fill()

void QMacPixmapData::fill ( const QColor & color )

virtual

Implements QPixmapData.

Definition at line 420 of file qpixmap_mac.cpp.

Referenced by setMask().

 {
     { //we don't know what backend to use so we cannot paint here
         quint32 *dptr = pixels;
         Q_ASSERT_X(dptr, "QPixmap::fill", "No dptr");
         const quint32 colr = PREMUL(fillColor.rgba());
         const int nbytes = bytesPerRow * h;
         if (!colr) {
             memset(dptr, 0, nbytes);
         } else {
             for (uint i = 0; i < nbytes / sizeof(quint32); ++i)
                 *(dptr + i) = colr;
         }
     }
 
     // If we had an alpha channel from before, don't
     // switch it off. Only go from no alpha to alpha:
     if (fillColor.alpha() != 255)
         macSetHasAlpha(true);
 }

◆ fromImage()

void QMacPixmapData::fromImage	(	const QImage &	image,
		Qt::ImageConversionFlags	flags
	)

virtual

Implements QPixmapData.

Definition at line 222 of file qpixmap_mac.cpp.

 {
     setSerialNumber(++qt_pixmap_serial);
 
     // the conversion code only handles format >=
     // Format_ARGB32_Premultiplied at the moment..
     if (img.format() > QImage::Format_ARGB32_Premultiplied) {
         QImage image;
         if (img.hasAlphaChannel())
             image = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
         else
             image = img.convertToFormat(QImage::Format_RGB32);
         fromImage(image, flags);
         return;
     }
 
     w = img.width();
     h = img.height();
     is_null = (w <= 0 || h <= 0);
     d = (pixelType() == BitmapType ? 1 : img.depth());
 
     QImage image = img;
     int dd = QPixmap::defaultDepth();
     bool force_mono = (dd == 1 ||
                        (flags & Qt::ColorMode_Mask)==Qt::MonoOnly);
     if (force_mono) {                         // must be monochrome
         if (d != 1) {
             image = image.convertToFormat(QImage::Format_MonoLSB, flags);  // dither
             d = 1;
         }
     } else {                                    // can be both
         bool conv8 = false;
         if(d > 8 && dd <= 8) {               // convert to 8 bit
             if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)
                 flags = (flags & ~Qt::DitherMode_Mask)
                                    | Qt::PreferDither;
             conv8 = true;
         } else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {
             conv8 = d == 1;                     // native depth wanted
         } else if (d == 1) {
             if (image.colorCount() == 2) {
                 QRgb c0 = image.color(0);       // Auto: convert to best
                 QRgb c1 = image.color(1);
                 conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);
             } else {
                 // eg. 1-color monochrome images (they do exist).
                 conv8 = true;
             }
         }
         if (conv8) {
             image = image.convertToFormat(QImage::Format_Indexed8, flags);
             d = 8;
         }
     }
 
     if (image.depth()==1) {
         image.setColor(0, QColor(Qt::color0).rgba());
         image.setColor(1, QColor(Qt::color1).rgba());
     }
 
     if (d == 16 || d == 24) {
         image = image.convertToFormat(QImage::Format_RGB32, flags);
         fromImage(image, flags);
         return;
     }
 
     // different size or depth, make a new pixmap
     resize(w, h);
 
     // exit if resize failed
     if (is_null)
         return;
 
     quint32 *dptr = pixels, *drow;
     const uint dbpr = bytesPerRow;
 
     const QImage::Format sfmt = image.format();
     const unsigned short sbpr = image.bytesPerLine();
 
     // use const_cast to prevent a detach
     const uchar *sptr = const_cast<const QImage &>(image).bits(), *srow;
 
     for (int y = 0; y < h; ++y) {
         drow = dptr + (y * (dbpr / 4));
         srow = sptr + (y * sbpr);
         switch(sfmt) {
         case QImage::Format_MonoLSB:
         case QImage::Format_Mono:{
             for (int x = 0; x < w; ++x) {
                 char one_bit = *(srow + (x / 8));
                 if (sfmt == QImage::Format_Mono)
                     one_bit = one_bit >> (7 - (x % 8));
                 else
                     one_bit = one_bit >> (x % 8);
                 if ((one_bit & 0x01))
                     *(drow+x) = 0xFF000000;
                 else
                     *(drow+x) = 0xFFFFFFFF;
             }
             break;
         }
         case QImage::Format_Indexed8: {
             int numColors = image.numColors();
             if (numColors > 0) {
                 for (int x = 0; x < w; ++x) {
                     int index = *(srow + x);
                     *(drow+x) = PREMUL(image.color(qMin(index, numColors)));
                 }
             }
         } break;
         case QImage::Format_RGB32:
             for (int x = 0; x < w; ++x)
                 *(drow+x) = *(((quint32*)srow) + x) | 0xFF000000;
             break;
         case QImage::Format_ARGB32:
         case QImage::Format_ARGB32_Premultiplied:
             for (int x = 0; x < w; ++x) {
                 if(sfmt == QImage::Format_RGB32)
                     *(drow+x) = 0xFF000000 | (*(((quint32*)srow) + x) & 0x00FFFFFF);
                 else if(sfmt == QImage::Format_ARGB32_Premultiplied)
                     *(drow+x) = *(((quint32*)srow) + x);
                 else
                     *(drow+x) = PREMUL(*(((quint32*)srow) + x));
             }
             break;
         default:
             qWarning("Qt: internal: Oops: Forgot a format [%d] %s:%d", sfmt,
                      __FILE__, __LINE__);
             break;
         }
     }
     if (sfmt != QImage::Format_RGB32) { //setup the alpha
         bool alphamap = image.depth() == 32;
         if (sfmt == QImage::Format_Indexed8) {
             const QVector<QRgb> rgb = image.colorTable();
             for (int i = 0, count = image.colorCount(); i < count; ++i) {
                 const int alpha = qAlpha(rgb[i]);
                 if (alpha != 0xff) {
                     alphamap = true;
                     break;
                 }
             }
         }
         macSetHasAlpha(alphamap);
     }
     uninit = false;
 }

◆ hasAlphaChannel()

bool QMacPixmapData::hasAlphaChannel ( ) const

virtual

Implements QPixmapData.

Definition at line 1072 of file qpixmap_mac.cpp.

 {
     return has_alpha;
 }

◆ macCreateCGImageRef()

void QMacPixmapData::macCreateCGImageRef ( )

private

Definition at line 614 of file qpixmap_mac.cpp.

Referenced by QPixmap::grabWindow().

 {
     Q_ASSERT(cg_data == 0);
     //create the cg data
     CGColorSpaceRef colorspace = QCoreGraphicsPaintEngine::macDisplayColorSpace();
     QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(this,
                                                               pixels, bytesPerRow * h,
                                                               qt_mac_cgimage_data_free);
     validDataPointers.insert(this);
     uint cgflags = kCGImageAlphaPremultipliedFirst;
 #ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
     cgflags |= kCGBitmapByteOrder32Host;
 #endif
     cg_data = CGImageCreate(w, h, 8, 32, bytesPerRow, colorspace,
                             cgflags, provider, 0, 0, kCGRenderingIntentDefault);
 }

◆ macCreatePixels()

void QMacPixmapData::macCreatePixels ( )

private

Definition at line 650 of file qpixmap_mac.cpp.

Referenced by macReleaseCGImageRef(), and resize().

 {
     int numBytes = bytesPerRow * h;
     quint32 *base_pixels;
     if (pixelsToFree && pixelsToFree != pixels) {
         // Reuse unused block of memory lying around from a previous callback.
         base_pixels = pixelsToFree;
         pixelsToFree = 0;
     } else {
         // We need a block of memory to do stuff with.
         base_pixels = static_cast<quint32 *>(malloc(numBytes));
         if (!base_pixels) {
             qWarning("Failed to allocate memory for pixmap data, setting to NULL");
             numBytes = 0;
             w = 0;
             h = 0;
             is_null = 0;
             bytesPerRow=0;
         }
     }
 
     // only copy when both buffers exist
     if (pixels && base_pixels)
         memcpy(base_pixels, pixels, qMin(pixelsSize, (uint) numBytes));
 
     // free pixels before assigning new memory
     if (pixels)
         free(pixels);
 
     pixels = base_pixels;
     pixelsSize = numBytes;
 }

◆ macGetAlphaChannel()

void QMacPixmapData::macGetAlphaChannel	(	QMacPixmapData *	pix,
		bool	asMask
	)		const

private

Definition at line 583 of file qpixmap_mac.cpp.

Referenced by alphaChannel(), and mask().

 {
     quint32 *dptr = pix->pixels, *drow;
     const uint dbpr = pix->bytesPerRow;
     const unsigned short sbpr = bytesPerRow;
     quint32 *sptr = pixels, *srow;
     for(int y=0; y < h; ++y) {
         drow = dptr + (y * (dbpr/4));
         srow = sptr + (y * (sbpr/4));
         if(asMask) {
             for (int x = 0; x < w; ++x) {
                 if (*(srow + x) & qRgba(0, 0, 0, 255))
                     *(drow + x) = 0x00000000;
                 else
                     *(drow + x) = 0xFFFFFFFF;
             }
         } else {
             for (int x = 0; x < w; ++x) {
                 const int alpha = qAlpha(*(srow + x));
                 *(drow + x) = qRgb(alpha, alpha, alpha);
             }
         }
     }
 }

◆ macReleaseCGImageRef()

void QMacPixmapData::macReleaseCGImageRef ( )

private

Definition at line 631 of file qpixmap_mac.cpp.

Referenced by macSetHasAlpha().

 {
     if (!cg_data)
         return;  // There's nothing we need to do
 
     cg_dataBeingReleased = cg_data;
     CGImageRelease(cg_data);
     cg_data = 0;
 
     if (pixels != pixelsToFree) {
         macCreatePixels();
     } else {
         pixelsToFree = 0;
     }
 }

◆ macSetAlphaChannel()

void QMacPixmapData::macSetAlphaChannel	(	const QMacPixmapData *	pix,
		bool	asMask
	)

private

Definition at line 537 of file qpixmap_mac.cpp.

Referenced by setAlphaChannel(), and setMask().

 {
     if (!pixels || !h || !w || pix->w != w || pix->h != h)
         return;
 
     quint32 *dptr = pixels, *drow;
     const uint dbpr = bytesPerRow;
     const unsigned short sbpr = pix->bytesPerRow;
     quint32 *sptr = pix->pixels, *srow;
     for (int y=0; y < h; ++y) {
         drow = dptr + (y * (dbpr/4));
         srow = sptr + (y * (sbpr/4));
         if(d == 1) {
             for (int x=0; x < w; ++x) {
                 if((*(srow+x) & RGB_MASK))
                     *(drow+x) = 0xFFFFFFFF;
             }
         } else if(d == 8) {
             for (int x=0; x < w; ++x)
                 *(drow+x) = (*(drow+x) & RGB_MASK) | (*(srow+x) << 24);
         } else if(asMask) {
             for (int x=0; x < w; ++x) {
                 if(*(srow+x) & RGB_MASK)
                     *(drow+x) = (*(drow+x) & RGB_MASK);
                 else
                     *(drow+x) = (*(drow+x) & RGB_MASK) | 0xFF000000;
                 *(drow+x) = PREMUL(*(drow+x));
             }
         } else {
             for (int x=0; x < w; ++x) {
                 const uchar alpha = qGray(qRed(*(srow+x)), qGreen(*(srow+x)), qBlue(*(srow+x)));
                 const uchar destAlpha = qt_div_255(alpha * qAlpha(*(drow+x)));
 #if 1
                 *(drow+x) = (*(drow+x) & RGB_MASK) | (destAlpha << 24);
 #else
                 *(drow+x) = qRgba(qt_div_255(qRed(*(drow+x) * alpha)),
                                   qt_div_255(qGreen(*(drow+x) * alpha)),
                                   qt_div_255(qBlue(*(drow+x) * alpha)), destAlpha);
 #endif
                 *(drow+x) = PREMUL(*(drow+x));
             }
         }
     }
     macSetHasAlpha(true);
 }

◆ macSetHasAlpha()

void QMacPixmapData::macSetHasAlpha ( bool b )

private

Definition at line 608 of file qpixmap_mac.cpp.

Referenced by fill(), fromImage(), macCreatePixels(), and macSetAlphaChannel().

 {
     has_alpha = b;
     macReleaseCGImageRef();
 }

◆ mask()

QBitmap QMacPixmapData::mask ( ) const

virtual

Reimplemented from QPixmapData.

Definition at line 460 of file qpixmap_mac.cpp.

Referenced by qt_mac_create_iconref(), and qt_mac_create_imagemask().

 {
     if (!has_mask && !has_alpha)
         return QBitmap();
 
     QMacPixmapData *mask = new QMacPixmapData(BitmapType);
     mask->resize(w, h);
     macGetAlphaChannel(mask, true);
     return QPixmap(mask);
 }

◆ metric()

int QMacPixmapData::metric ( QPaintDevice::PaintDeviceMetric metric ) const

virtual

Implements QPixmapData.

Definition at line 488 of file qpixmap_mac.cpp.

 {
     switch (theMetric) {
     case QPaintDevice::PdmWidth:
         return w;
     case QPaintDevice::PdmHeight:
         return h;
     case QPaintDevice::PdmWidthMM:
         return qRound(metric(QPaintDevice::PdmWidth) * 25.4 / qreal(metric(QPaintDevice::PdmDpiX)));
     case QPaintDevice::PdmHeightMM:
         return qRound(metric(QPaintDevice::PdmHeight) * 25.4 / qreal(metric(QPaintDevice::PdmDpiY)));
     case QPaintDevice::PdmNumColors:
         return 1 << d;
     case QPaintDevice::PdmDpiX:
     case QPaintDevice::PdmPhysicalDpiX: {
         extern float qt_mac_defaultDpi_x(); //qpaintdevice_mac.cpp
         return int(qt_mac_defaultDpi_x());
     }
     case QPaintDevice::PdmDpiY:
     case QPaintDevice::PdmPhysicalDpiY: {
         extern float qt_mac_defaultDpi_y(); //qpaintdevice_mac.cpp
         return int(qt_mac_defaultDpi_y());
     }
     case QPaintDevice::PdmDepth:
         return d;
     default:
         qWarning("QPixmap::metric: Invalid metric command");
     }
     return 0;
 }

◆ paintEngine()

QPaintEngine * QMacPixmapData::paintEngine ( ) const

virtual

Warning: This function is not part of the public interface.

Implements QPixmapData.

Definition at line 1189 of file qpixmap_mac.cpp.

 {
     if (!pengine) {
         QMacPixmapData *that = const_cast<QMacPixmapData*>(this);
         that->pengine = new QCoreGraphicsPaintEngine();
     }
     return pengine;
 }

◆ resize()

void QMacPixmapData::resize	(	int	width,
		int	height
	)

virtual

Implements QPixmapData.

Definition at line 190 of file qpixmap_mac.cpp.

Referenced by alphaChannel(), copy(), fromImage(), mask(), and setMask().

 {
     setSerialNumber(++qt_pixmap_serial);
 
     w = width;
     h = height;
     is_null = (w <= 0 || h <= 0);
     d = (pixelType() == BitmapType ? 1 : 32);
     bool make_null = w <= 0 || h <= 0;                // create null pixmap
     if (make_null || d == 0) {
         w = 0;
         h = 0;
         is_null = true;
         d = 0;
         if (!make_null)
             qWarning("Qt: QPixmap: Invalid pixmap parameters");
         return;
     }
 
     if (w < 1 || h < 1)
         return;
 
     //create the pixels
     bytesPerRow = w * sizeof(quint32);  // Minimum bytes per row.
 
     // Quartz2D likes things as a multple of 16 (for now).
     bytesPerRow = COMPTUE_BEST_BYTES_PER_ROW(bytesPerRow);
     macCreatePixels();
 }

◆ scroll()

bool QMacPixmapData::scroll	(	int	dx,
		int	dy,
		const QRect &	rect
	)

virtual

Reimplemented from QPixmapData.

Definition at line 1231 of file qpixmap_mac.cpp.

 {
     Q_UNUSED(dx);
     Q_UNUSED(dy);
     Q_UNUSED(rect);
     return false;
 }

◆ setAlphaChannel()

void QMacPixmapData::setAlphaChannel ( const QPixmap & alphaChannel )

virtual

Reimplemented from QPixmapData.

Definition at line 453 of file qpixmap_mac.cpp.

 {
     has_mask = true;
     QMacPixmapData *alphaData = static_cast<QMacPixmapData*>(alpha.data.data());
     macSetAlphaChannel(alphaData, false);
 }

◆ setMask()

void QMacPixmapData::setMask ( const QBitmap & mask )

virtual

Reimplemented from QPixmapData.

Definition at line 471 of file qpixmap_mac.cpp.

 {
     if (mask.isNull()) {
         QMacPixmapData opaque(PixmapType);
         opaque.resize(w, h);
         opaque.fill(QColor(255, 255, 255, 255));
         macSetAlphaChannel(&opaque, true);
         has_alpha = has_mask = false;
         return;
     }
 
     has_alpha = false;
     has_mask = true;
     QMacPixmapData *maskData = static_cast<QMacPixmapData*>(mask.data.data());
     macSetAlphaChannel(maskData, true);
 }

◆ toImage()

QImage QMacPixmapData::toImage ( ) const

virtual

Implements QPixmapData.

Definition at line 383 of file qpixmap_mac.cpp.

Referenced by copy().

 {
     QImage::Format format = QImage::Format_MonoLSB;
     if (d != 1) //Doesn't support index color modes
         format = (has_alpha ? QImage::Format_ARGB32_Premultiplied :
                   QImage::Format_RGB32);
 
     QImage image(w, h, format);
         // exit if image was not created (out of memory)
     if (image.isNull())
         return image;
     quint32 *sptr = pixels, *srow;
     const uint sbpr = bytesPerRow;
     if (format == QImage::Format_MonoLSB) {
         image.fill(0);
         image.setColorCount(2);
         image.setColor(0, QColor(Qt::color0).rgba());
         image.setColor(1, QColor(Qt::color1).rgba());
         for (int y = 0; y < h; ++y) {
             uchar *scanLine = image.scanLine(y);
             srow = sptr + (y * (sbpr/4));
             for (int x = 0; x < w; ++x) {
                 if (!(*(srow + x) & RGB_MASK))
                     scanLine[x >> 3] |= (1 << (x & 7));
             }
         }
     } else {
         for (int y = 0; y < h; ++y) {
             srow = sptr + (y * (sbpr / 4));
             memcpy(image.scanLine(y), srow, w * 4);
         }
 
     }
 
     return image;
 }

Friends and Related Functions

◆ qcolorForThemeTextColor

QColor qcolorForThemeTextColor ( ThemeTextColor themeColor )

friend

Definition at line 128 of file qt_mac.cpp.

 {
 #ifdef Q_OS_MAC32
     RGBColor c;
     GetThemeTextColor(themeColor, 32, true, &c);
     QColor color = QColor(c.red / 256, c.green / 256, c.blue / 256);
     return color;
 #else
     // There is no equivalent to GetThemeTextColor in 64-bit and it was rather bad that
     // I didn't file a request to implement this for Snow Leopard. So, in the meantime
     // I've encoded the values from the GetThemeTextColor. This is not exactly ideal
     // as if someone really wants to mess with themeing, these colors will be wrong.
     // It also means that we need to make sure the values for differences between
     // OS releases (and it will be likely that we are a step behind.)
     switch (themeColor) {
     case kThemeTextColorAlertActive:
     case kThemeTextColorTabFrontActive:
     case kThemeTextColorBevelButtonActive:
     case kThemeTextColorListView:
     case kThemeTextColorPlacardActive:
     case kThemeTextColorPopupButtonActive:
     case kThemeTextColorPopupLabelActive:
     case kThemeTextColorPushButtonActive:
         return Qt::black;
     case kThemeTextColorAlertInactive:
     case kThemeTextColorDialogInactive:
     case kThemeTextColorPlacardInactive:
         return QColor(69, 69, 69, 255);
     case kThemeTextColorPopupButtonInactive:
     case kThemeTextColorPopupLabelInactive:
     case kThemeTextColorPushButtonInactive:
     case kThemeTextColorTabFrontInactive:
     case kThemeTextColorBevelButtonInactive:
         return QColor(127, 127, 127, 255);
     default: {
         QNativeImage nativeImage(16,16, QNativeImage::systemFormat());
         CGRect cgrect = CGRectMake(0, 0, 16, 16);
         HIThemeSetTextFill(themeColor, 0, nativeImage.cg, kHIThemeOrientationNormal);
         CGContextFillRect(nativeImage.cg, cgrect);
         QColor color = nativeImage.image.pixel(0,0);
         return QColor(nativeImage.image.pixel(0 , 0));
     }
     }
 #endif
 }

◆ QCoreGraphicsPaintEngine

friend class QCoreGraphicsPaintEngine

friend

Definition at line 122 of file qpixmap_mac_p.h.

Referenced by paintEngine().

◆ QPixmap

friend class QPixmap

friend

Definition at line 119 of file qpixmap_mac_p.h.

Referenced by alphaChannel(), QPixmap::grabWindow(), macCreatePixels(), mask(), qt_mac_grabDisplayRect(), qt_mac_grabScreenRect(), and qt_mac_grabScreenRect_10_3().

◆ QRasterBuffer

friend class QRasterBuffer

friend

Definition at line 120 of file qpixmap_mac_p.h.

◆ QRasterPaintEngine

friend class QRasterPaintEngine

friend

Definition at line 121 of file qpixmap_mac_p.h.

◆ qt_mac_cg_context

CGContextRef qt_mac_cg_context ( const QPaintDevice * )

friend

Returns the CoreGraphics CGContextRef of the paint device.

Warning: This function is not part of the public interface.

0 is returned if it can't be obtained. It is the caller's responsiblity to CGContextRelease the context when finished using it.

Warning: This function is only available on Mac OS X.

Definition at line 118 of file qpaintdevice_mac.cpp.

Referenced by QPixmap::fromMacCGImageRef().

 {
     if (pdev->devType() == QInternal::Pixmap) {
         const QPixmap *pm = static_cast<const QPixmap*>(pdev);
         CGColorSpaceRef colorspace = qt_mac_colorSpaceForDeviceType(pdev);
         uint flags = kCGImageAlphaPremultipliedFirst;
 #ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
         flags |= kCGBitmapByteOrder32Host;
 #endif
         CGContextRef ret = 0;
 
         // It would make sense to put this into a mac #ifdef'ed
         // virtual function in the QPixmapData at some point
         if (pm->data->classId() == QPixmapData::MacClass) {
             const QMacPixmapData *pmData = static_cast<const QMacPixmapData*>(pm->data.data());
             ret = CGBitmapContextCreate(pmData->pixels, pmData->w, pmData->h,
                                                      8, pmData->bytesPerRow, colorspace,
                                                      flags);
             if(!ret)
                 qWarning("QPaintDevice: Unable to create context for pixmap (%d/%d/%d)",
                          pmData->w, pmData->h, (pmData->bytesPerRow * pmData->h));
         } else if (pm->data->classId() == QPixmapData::RasterClass) {
             QImage *image = pm->data->buffer();
             ret = CGBitmapContextCreate(image->bits(), image->width(), image->height(),
                                         8, image->bytesPerLine(), colorspace, flags);
         }
 
         CGContextTranslateCTM(ret, 0, pm->height());
         CGContextScaleCTM(ret, 1, -1);
         return ret;
     } else if (pdev->devType() == QInternal::Widget) {
         CGContextRef ret = static_cast<CGContextRef>(static_cast<const QWidget *>(pdev)->macCGHandle());
         CGContextRetain(ret);
         return ret;
     } else if (pdev->devType() == QInternal::MacQuartz) {
         return static_cast<const QMacQuartzPaintDevice *>(pdev)->cgContext();
     }
     return 0;
 }

◆ qt_mac_cgimage_data_free

void qt_mac_cgimage_data_free	(	void *	info,
		const void *	memoryToFree,
		size_t
	)

friend

Definition at line 91 of file qpixmap_mac.cpp.

Referenced by macCreateCGImageRef(), and qt_mac_create_imagemask().

 {
     QMacPixmapData *pmdata = static_cast<QMacPixmapData *>(info);
     if (!pmdata) {
         free(const_cast<void *>(memoryToFree));
     } else {
         if (QMacPixmapData::validDataPointers.contains(pmdata) == false) {
             free(const_cast<void *>(memoryToFree));
             // mark data as freed
             if (pmdata->pixels == memoryToFree)
                 pmdata->pixels = 0;
             if (pmdata->pixelsToFree == memoryToFree)
                 pmdata->pixelsToFree = 0;
             return;
         }
         if (pmdata->pixels == pmdata->pixelsToFree) {
             // something we aren't expecting, just free it.
             Q_ASSERT(memoryToFree != pmdata->pixelsToFree);
             free(const_cast<void *>(memoryToFree));
         } else {
             free(pmdata->pixelsToFree);
             pmdata->pixelsToFree = static_cast<quint32 *>(const_cast<void *>(memoryToFree));
         }
         pmdata->cg_dataBeingReleased = 0;
     }
 }

◆ qt_mac_create_iconref

IconRef qt_mac_create_iconref ( const QPixmap & )

friend

Definition at line 1109 of file qpixmap_mac.cpp.

 {
     if (px.isNull())
         return 0;
 
     //create icon
     IconFamilyHandle iconFamily = reinterpret_cast<IconFamilyHandle>(NewHandle(0));
     //create data
     {
         struct {
             OSType mac_type;
             int width, height, depth;
             bool mask;
         } images[] = {
             { kThumbnail32BitData, 128, 128, 32, false },
             { kThumbnail8BitMask, 128, 128, 8, true },
             { 0, 0, 0, 0, false } //end marker
         };
         for(int i = 0; images[i].mac_type; i++) {
             //get QPixmap data
             QImage scaled_px = px.toImage().scaled(images[i].width, images[i].height);
 
             quint32 *sptr = (quint32 *) scaled_px.bits();
             quint32 *srow;
             uint sbpr = scaled_px.bytesPerLine();
 
             //get Handle data
             const int dbpr = images[i].width * (images[i].depth/8);
             Handle hdl = NewHandle(dbpr*images[i].height);
             if(!sptr) { //handle null pixmap
                 memset((*hdl), '\0', dbpr*images[i].height);
             } else if(images[i].mask) {
                 if(images[i].mac_type == kThumbnail8BitMask) {
                     for(int y = 0, hindex = 0; y < images[i].height; ++y) {
                         srow = sptr + (y * (sbpr/4));
                         for(int x = 0; x < images[i].width; ++x)
                             *((*hdl)+(hindex++)) = qAlpha(*(srow+x));
                     }
                 }
             } else {
                 char *dest = (*hdl);
 #if defined(__i386__)
                 if(images[i].depth == 32) {
                     for(int y = 0; y < images[i].height; ++y) {
                         uint *source = (uint*)((const uchar*)sptr+(sbpr*y));
                         for(int x = 0; x < images[i].width; ++x, dest += 4)
                             *((uint*)dest) = CFSwapInt32(*(source + x));
                     }
                 } else
 #endif
                 {
                     for(int y = 0; y < images[i].height; ++y)
                         memcpy(dest+(y*dbpr), ((const uchar*)sptr+(sbpr*y)), dbpr);
                 }
             }
 
             //set the family data to the Handle
             OSStatus set = SetIconFamilyData(iconFamily, images[i].mac_type, hdl);
             if(set != noErr)
                 qWarning("%s: %d -- Unable to create icon data[%d]!! %ld",
                          __FILE__, __LINE__, i, long(set));
             DisposeHandle(hdl);
         }
     }
 
     //acquire and cleanup
     IconRef ret;
     static int counter = 0;
     const OSType kQtCreator = 'CUTE';
     RegisterIconRefFromIconFamily(kQtCreator, (OSType)counter, iconFamily, &ret);
     AcquireIconRef(ret);
     UnregisterIconRef(kQtCreator, (OSType)counter);
     DisposeHandle(reinterpret_cast<Handle>(iconFamily));
     counter++;
     return ret;
 
 }

◆ qt_mac_create_imagemask

CGImageRef qt_mac_create_imagemask	(	const QPixmap &	,
		const QRectF &
	)

friend

Definition at line 1077 of file qpixmap_mac.cpp.

 {
     QMacPixmapData *px = static_cast<QMacPixmapData*>(pixmap.data.data());
     if (px->cg_mask) {
         if (px->cg_mask_rect == sr) {
             CGImageRetain(px->cg_mask); //reference for the caller
             return px->cg_mask;
         }
         CGImageRelease(px->cg_mask);
         px->cg_mask = 0;
     }
 
     const int sx = qRound(sr.x()), sy = qRound(sr.y()), sw = qRound(sr.width()), sh = qRound(sr.height());
     const int sbpr = px->bytesPerRow;
     const uint nbytes = sw * sh;
     //  alpha is always 255 for bitmaps, ignore it in this case.
     const quint32 mask = px->depth() == 1 ? 0x00ffffff : 0xffffffff;
     quint8 *dptr = static_cast<quint8 *>(malloc(nbytes));
     quint32 *sptr = px->pixels, *srow;
     for(int y = sy, offset=0; y < sh; ++y) {
         srow = sptr + (y * (sbpr / 4));
         for(int x = sx; x < sw; ++x)
             *(dptr+(offset++)) = (*(srow+x) & mask) ? 255 : 0;
     }
     QCFType<CGDataProviderRef> provider = CGDataProviderCreateWithData(0, dptr, nbytes, qt_mac_cgimage_data_free);
     px->cg_mask = CGImageMaskCreate(sw, sh, 8, 8, nbytes / sh, provider, 0, 0);
     px->cg_mask_rect = sr;
     CGImageRetain(px->cg_mask); //reference for the caller
     return px->cg_mask;
 }

◆ qt_mac_pixmap_get_base

quint32* qt_mac_pixmap_get_base ( const QPixmap * )

friend

Definition at line 75 of file qpixmap_mac.cpp.

 {
     if (QApplicationPrivate::graphics_system_name == QLatin1String("raster"))
         return reinterpret_cast<quint32 *>(static_cast<QRasterPixmapData*>(pix->data.data())->buffer()->bits());
     else
         return static_cast<QMacPixmapData*>(pix->data.data())->pixels;
 }

◆ qt_mac_pixmap_get_bytes_per_line

int qt_mac_pixmap_get_bytes_per_line ( const QPixmap * )

friend

Definition at line 83 of file qpixmap_mac.cpp.

 {
     if (QApplicationPrivate::graphics_system_name == QLatin1String("raster"))
         return static_cast<QRasterPixmapData*>(pix->data.data())->buffer()->bytesPerLine();
     else
         return static_cast<QMacPixmapData*>(pix->data.data())->bytesPerRow;
 }

Properties

◆ bytesPerRow

uint QMacPixmapData::bytesPerRow

private

Definition at line 112 of file qpixmap_mac_p.h.

Referenced by copy(), fill(), fromImage(), macCreateCGImageRef(), macCreatePixels(), macGetAlphaChannel(), macSetAlphaChannel(), qt_mac_cg_context(), qt_mac_create_imagemask(), resize(), and toImage().

◆ cg_data

CGImageRef QMacPixmapData::cg_data

private

Definition at line 114 of file qpixmap_mac_p.h.

Referenced by QPixmap::grabWindow(), macCreateCGImageRef(), macReleaseCGImageRef(), and ~QMacPixmapData().

◆ cg_dataBeingReleased

CGImageRef QMacPixmapData::cg_dataBeingReleased

private

Definition at line 114 of file qpixmap_mac_p.h.

Referenced by macReleaseCGImageRef(), and qt_mac_cgimage_data_free().

◆ cg_mask

CGImageRef QMacPixmapData::cg_mask

private

Definition at line 114 of file qpixmap_mac_p.h.

Referenced by qt_mac_create_imagemask(), and ~QMacPixmapData().

◆ cg_mask_rect

QRectF QMacPixmapData::cg_mask_rect

private

Definition at line 113 of file qpixmap_mac_p.h.

Referenced by qt_mac_create_imagemask().

◆ has_alpha

uint QMacPixmapData::has_alpha

private

Definition at line 89 of file qpixmap_mac_p.h.

Referenced by alphaChannel(), copy(), hasAlphaChannel(), macSetHasAlpha(), mask(), setMask(), and toImage().

◆ has_mask

uint QMacPixmapData::has_mask

private

Definition at line 89 of file qpixmap_mac_p.h.

Referenced by copy(), mask(), setAlphaChannel(), and setMask().

◆ pengine

QPaintEngine* QMacPixmapData::pengine

private

Definition at line 117 of file qpixmap_mac_p.h.

Referenced by paintEngine(), and ~QMacPixmapData().

◆ pixels

quint32* QMacPixmapData::pixels

private

Definition at line 109 of file qpixmap_mac_p.h.

Referenced by copy(), fill(), fromImage(), macCreateCGImageRef(), macCreatePixels(), macGetAlphaChannel(), macReleaseCGImageRef(), macSetAlphaChannel(), qt_mac_cg_context(), qt_mac_cgimage_data_free(), qt_mac_create_imagemask(), toImage(), and ~QMacPixmapData().

◆ pixelsSize

uint QMacPixmapData::pixelsSize

private

Definition at line 110 of file qpixmap_mac_p.h.

Referenced by macCreatePixels().

◆ pixelsToFree

quint32* QMacPixmapData::pixelsToFree

private

Definition at line 111 of file qpixmap_mac_p.h.

Referenced by macCreatePixels(), macReleaseCGImageRef(), qt_mac_cgimage_data_free(), and ~QMacPixmapData().

◆ uninit

uint QMacPixmapData::uninit

private

Definition at line 89 of file qpixmap_mac_p.h.

Referenced by copy(), QPixmap::depth(), and fromImage().

◆ validDataPointers

QSet< QMacPixmapData * > QMacPixmapData::validDataPointers

staticprivate

Definition at line 115 of file qpixmap_mac_p.h.

Referenced by macCreateCGImageRef(), qt_conv16ToRgb(), qt_mac_cgimage_data_free(), and ~QMacPixmapData().

The documentation for this class was generated from the following files:

/src/gui/image/qpixmap_mac_p.h
/src/gui/image/qpixmap_mac.cpp

Public Functions

Private Functions

Properties

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QMacPixmapData()

◆ ~QMacPixmapData()

Functions

◆ alphaChannel()

◆ copy()

◆ createCompatiblePixmapData()

◆ fill()

◆ fromImage()

◆ hasAlphaChannel()

◆ macCreateCGImageRef()

◆ macCreatePixels()

◆ macGetAlphaChannel()

◆ macReleaseCGImageRef()

◆ macSetAlphaChannel()

◆ macSetHasAlpha()

◆ mask()

◆ metric()

◆ paintEngine()

◆ resize()

◆ scroll()

◆ setAlphaChannel()

◆ setMask()

◆ toImage()

Friends and Related Functions

◆ qcolorForThemeTextColor

◆ QCoreGraphicsPaintEngine

◆ QPixmap

◆ QRasterBuffer

◆ QRasterPaintEngine

◆ qt_mac_cg_context

◆ qt_mac_cgimage_data_free

◆ qt_mac_create_iconref

◆ qt_mac_create_imagemask

◆ qt_mac_pixmap_get_base

◆ qt_mac_pixmap_get_bytes_per_line

Properties

◆ bytesPerRow

◆ cg_data

◆ cg_dataBeingReleased

◆ cg_mask

◆ cg_mask_rect

◆ has_alpha

◆ has_mask

◆ pengine

◆ pixels

◆ pixelsSize

◆ pixelsToFree

◆ uninit

◆ validDataPointers