qpixmap_mac.cpp File Reference

#include "qpixmap.h"
#include "qimage.h"
#include "qapplication.h"
#include "qbitmap.h"
#include "qmatrix.h"
#include "qtransform.h"
#include "qlibrary.h"
#include "qvarlengtharray.h"
#include "qdebug.h"
#include <private/qdrawhelper_p.h>
#include <private/qpixmap_mac_p.h>
#include <private/qpixmap_raster_p.h>
#include <private/qpaintengine_mac_p.h>
#include <private/qt_mac_p.h>
#include <private/qt_cocoa_helpers_mac_p.h>
#include <private/qapplication_p.h>
#include <limits.h>
#include <string.h>
#include <OpenGL/OpenGL.h>
#include <OpenGL/gl.h>

Go to the source code of this file.

Macros
#define	BEST_BYTE_ALIGNMENT   16
#define	COMPTUE_BEST_BYTES_PER_ROW(bpr)   (((bpr) + (BEST_BYTE_ALIGNMENT - 1)) & ~(BEST_BYTE_ALIGNMENT - 1))

Typedefs
typedef CGLError(*	PtrCGLChoosePixelFormat) (const CGLPixelFormatAttribute *, CGLPixelFormatObj *, long *)
typedef CGLError(*	PtrCGLClearDrawable) (CGLContextObj)
typedef CGLError(*	PtrCGLCreateContext) (CGLPixelFormatObj, CGLContextObj, CGLContextObj *)
typedef CGLError(*	PtrCGLDestroyContext) (CGLContextObj)
typedef CGLError(*	PtrCGLDestroyPixelFormat) (CGLPixelFormatObj)
typedef CGLError(*	PtrCGLSetCurrentContext) (CGLContextObj)
typedef CGLError(*	PtrCGLSetFullScreen) (CGLContextObj)
typedef void(*	PtrglFinish) ()
typedef void(*	PtrglPixelStorei) (GLenum, GLint)
typedef void(*	PtrglReadBuffer) (GLenum)
typedef void(*	PtrglReadPixels) (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *)

Functions
int	get_index (QImage *qi, QRgb mycol)
static QRgb	qt_conv16ToRgb (ushort c)
const uchar *	qt_get_bitflip_array ()
CGContextRef	qt_mac_cg_context (const QPaintDevice *pdev)
	Returns the CoreGraphics CGContextRef of the paint device. More...
void	qt_mac_cgimage_data_free (void *info, const void *memoryToFree, size_t)
QRegion	qt_mac_convert_mac_region (RgnHandle rgn)
IconRef	qt_mac_create_iconref (const QPixmap &px)
CGImageRef	qt_mac_create_imagemask (const QPixmap &pixmap, const QRectF &sr)
void	qt_mac_dispose_rgn (RgnHandle r)
static void	qt_mac_flipPixmap (void *data, int rowBytes, int height)
RgnHandle	qt_mac_get_rgn ()
static void	qt_mac_grabDisplayRect (CGDirectDisplayID display, const QRect &displayRect, void *buffer)
static QPixmap	qt_mac_grabScreenRect (const QRect &rect)
static QPixmap	qt_mac_grabScreenRect_10_3 (int x, int y, int w, int h, QWidget *widget)
CGImageRef	qt_mac_image_to_cgimage (const QImage &image)
Q_GUI_EXPORT quint32 *	qt_mac_pixmap_get_base (const QPixmap *pix)
Q_GUI_EXPORT int	qt_mac_pixmap_get_bytes_per_line (const QPixmap *pix)
static bool	resolveOpenGLSymbols ()

Variables
static PtrCGLChoosePixelFormat	ptrCGLChoosePixelFormat = 0
static PtrCGLClearDrawable	ptrCGLClearDrawable = 0
static PtrCGLCreateContext	ptrCGLCreateContext = 0
static PtrCGLDestroyContext	ptrCGLDestroyContext = 0
static PtrCGLDestroyPixelFormat	ptrCGLDestroyPixelFormat = 0
static PtrCGLSetCurrentContext	ptrCGLSetCurrentContext = 0
static PtrCGLSetFullScreen	ptrCGLSetFullScreen = 0
static PtrglFinish	ptrglFinish = 0
static PtrglPixelStorei	ptrglPixelStorei = 0
static PtrglReadBuffer	ptrglReadBuffer = 0
static PtrglReadPixels	ptrglReadPixels = 0
static int	qt_pixmap_serial = 0

Macro Definition Documentation

BEST_BYTE_ALIGNMENT

#define BEST_BYTE_ALIGNMENT   16

Definition at line 186 of file qpixmap_mac.cpp.

COMPTUE_BEST_BYTES_PER_ROW

#define COMPTUE_BEST_BYTES_PER_ROW

(

bpr

)

(((bpr) + (BEST_BYTE_ALIGNMENT - 1)) & ~(BEST_BYTE_ALIGNMENT - 1))

Definition at line 187 of file qpixmap_mac.cpp.

Referenced by QMacPixmapData::resize().

Typedef Documentation

PtrCGLChoosePixelFormat

typedef CGLError(* PtrCGLChoosePixelFormat) (const CGLPixelFormatAttribute *, CGLPixelFormatObj *, long *)

Definition at line 756 of file qpixmap_mac.cpp.

PtrCGLClearDrawable

typedef CGLError(* PtrCGLClearDrawable) (CGLContextObj)

Definition at line 757 of file qpixmap_mac.cpp.

PtrCGLCreateContext

typedef CGLError(* PtrCGLCreateContext) (CGLPixelFormatObj, CGLContextObj, CGLContextObj *)

Definition at line 758 of file qpixmap_mac.cpp.

PtrCGLDestroyContext

typedef CGLError(* PtrCGLDestroyContext) (CGLContextObj)

Definition at line 759 of file qpixmap_mac.cpp.

PtrCGLDestroyPixelFormat

typedef CGLError(* PtrCGLDestroyPixelFormat) (CGLPixelFormatObj)

Definition at line 760 of file qpixmap_mac.cpp.

PtrCGLSetCurrentContext

typedef CGLError(* PtrCGLSetCurrentContext) (CGLContextObj)

Definition at line 761 of file qpixmap_mac.cpp.

PtrCGLSetFullScreen

typedef CGLError(* PtrCGLSetFullScreen) (CGLContextObj)

Definition at line 762 of file qpixmap_mac.cpp.

PtrglFinish

typedef void(* PtrglFinish) ()

Definition at line 763 of file qpixmap_mac.cpp.

PtrglPixelStorei

typedef void(* PtrglPixelStorei) (GLenum, GLint)

Definition at line 764 of file qpixmap_mac.cpp.

PtrglReadBuffer

typedef void(* PtrglReadBuffer) (GLenum)

Definition at line 765 of file qpixmap_mac.cpp.

PtrglReadPixels

typedef void(* PtrglReadPixels) (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *)

Definition at line 766 of file qpixmap_mac.cpp.

Function Documentation

get_index()

int get_index	(	QImage *	qi,
		QRgb	mycol
	)

Definition at line 371 of file qpixmap_mac.cpp.

{
    int loopc;
    for(loopc=0;loopc<qi->colorCount();loopc++) {
        if(qi->color(loopc)==mycol)
            return loopc;
    }
    qi->setColorCount(qi->colorCount()+1);
    qi->setColor(qi->colorCount(),mycol);
    return qi->colorCount();
}

qt_conv16ToRgb()

static QRgb qt_conv16ToRgb ( ushort  c )

inlinestatic

Definition at line 150 of file qpixmap_mac.cpp.

                                            {
    static const int qt_rbits = (565/100);
    static const int qt_gbits = (565/10%10);
    static const int qt_bbits = (565%10);
    static const int qt_red_shift = qt_bbits+qt_gbits-(8-qt_rbits);
    static const int qt_green_shift = qt_bbits-(8-qt_gbits);
    static const int qt_neg_blue_shift = 8-qt_bbits;
    static const int qt_blue_mask = (1<<qt_bbits)-1;
    static const int qt_green_mask = (1<<(qt_gbits+qt_bbits))-((1<<qt_bbits)-1);
    static const int qt_red_mask = (1<<(qt_rbits+qt_gbits+qt_bbits))-(1<<(qt_gbits+qt_bbits));

    const int r=(c & qt_red_mask);
    const int g=(c & qt_green_mask);
    const int b=(c & qt_blue_mask);
    const int tr = r >> qt_red_shift;
    const int tg = g >> qt_green_shift;
    const int tb = b << qt_neg_blue_shift;

    return qRgb(tr,tg,tb);
}

qt_get_bitflip_array()

const uchar* qt_get_bitflip_array

(

)

Definition at line 765 of file qimage.cpp.

{
    return bitflip;
}

qt_mac_cg_context()

CGContextRef qt_mac_cg_context

(

const QPaintDevice *

pdev

)

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 QMacCGContext::QMacCGContext(), qt_mac_convert_iconref(), and QMacWindowSurface::scroll().

{
    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
	)

Definition at line 91 of file qpixmap_mac.cpp.

{
    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_convert_mac_region()

QRegion qt_mac_convert_mac_region

(

RgnHandle

rgn

)

qt_mac_create_iconref()

IconRef qt_mac_create_iconref

(

const QPixmap &

px

)

Definition at line 1109 of file qpixmap_mac.cpp.

Referenced by QWidgetPrivate::setWindowIcon_sys(), and QMenuPrivate::QMacMenuPrivate::syncAction().

{
    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 &	pixmap,
		const QRectF &	sr
	)

Definition at line 1077 of file qpixmap_mac.cpp.

Referenced by QCoreGraphicsPaintEngine::drawPixmap(), and qt_mac_draw_pattern().

{
    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_dispose_rgn()

void qt_mac_dispose_rgn

(

RgnHandle

r

)

Referenced by qt_bitmapToRegion(), and QMacSmartQuickDrawRegion::~QMacSmartQuickDrawRegion().

qt_mac_flipPixmap()

static void qt_mac_flipPixmap ( void *  data, int  rowBytes, int  height  )

static

Definition at line 805 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabScreenRect().

{
    int bottom = height - 1;
    void *base = data;
    void *buffer = malloc(rowBytes);

    int top = 0;
    while ( top < bottom )
    {
        void *topP = (void *)((top * rowBytes) + (intptr_t)base);
        void *bottomP = (void *)((bottom * rowBytes) + (intptr_t)base);

        bcopy( topP, buffer, rowBytes );
        bcopy( bottomP, topP, rowBytes );
        bcopy( buffer, bottomP, rowBytes );

        ++top;
        --bottom;
    }
    free(buffer);
}

qt_mac_get_rgn()

RgnHandle qt_mac_get_rgn

(

)

qt_mac_grabDisplayRect()

static void qt_mac_grabDisplayRect ( CGDirectDisplayID  display, const QRect &  displayRect, void *  buffer  )

static

Definition at line 828 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabScreenRect().

{
    if (display == kCGNullDirectDisplay)
        return;

    CGLPixelFormatAttribute attribs[] = {
        kCGLPFAFullScreen,
        kCGLPFADisplayMask,
        (CGLPixelFormatAttribute)0,    /* Display mask bit goes here */
        (CGLPixelFormatAttribute)0
    };

    attribs[2] = (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(display);

    // Build a full-screen GL context
    CGLPixelFormatObj pixelFormatObj;
    long numPixelFormats;

    ptrCGLChoosePixelFormat( attribs, &pixelFormatObj, &numPixelFormats );

    if (!pixelFormatObj)    // No full screen context support
        return;

    CGLContextObj glContextObj;
    ptrCGLCreateContext(pixelFormatObj, 0, &glContextObj);
    ptrCGLDestroyPixelFormat(pixelFormatObj) ;
    if (!glContextObj)
        return;

    ptrCGLSetCurrentContext(glContextObj);
    ptrCGLSetFullScreen(glContextObj) ;

    ptrglReadBuffer(GL_FRONT);

    ptrglFinish(); // Finish all OpenGL commands
    ptrglPixelStorei(GL_PACK_ALIGNMENT, 4);  // Force 4-byte alignment
    ptrglPixelStorei(GL_PACK_ROW_LENGTH, 0);
    ptrglPixelStorei(GL_PACK_SKIP_ROWS, 0);
    ptrglPixelStorei(GL_PACK_SKIP_PIXELS, 0);

    // Fetch the data in XRGB format, matching the bitmap context.
    ptrglReadPixels(GLint(displayRect.x()), GLint(displayRect.y()),
                    GLint(displayRect.width()), GLint(displayRect.height()),
#ifdef __BIG_ENDIAN__
                    GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, buffer
#else
                    GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, buffer
#endif
        );

    ptrCGLSetCurrentContext(0);
    ptrCGLClearDrawable(glContextObj); // disassociate from full screen
    ptrCGLDestroyContext(glContextObj); // and destroy the context
}

qt_mac_grabScreenRect()

static QPixmap qt_mac_grabScreenRect ( const QRect &  rect )

static

Definition at line 913 of file qpixmap_mac.cpp.

Referenced by QPixmap::grabWindow().

{
    if (!resolveOpenGLSymbols())
        return QPixmap();

    const int maxDisplays = 128; // 128 displays should be enough for everyone.
    CGDirectDisplayID displays[maxDisplays];
    CGDisplayCount displayCount;
    const CGRect cgRect = CGRectMake(rect.x(), rect.y(), rect.width(), rect.height());
    const CGDisplayErr err = CGGetDisplaysWithRect(cgRect, maxDisplays, displays, &displayCount);

    if (err && displayCount == 0)
        return QPixmap();

    long bytewidth = rect.width() * 4; // Assume 4 bytes/pixel for now
    bytewidth = (bytewidth + 3) & ~3; // Align to 4 bytes
    QVarLengthArray<char> buffer(rect.height() * bytewidth);

    for (uint i = 0; i < displayCount; ++i) {
        const CGRect bounds = CGDisplayBounds(displays[i]);
        // Translate to display-local coordinates
        QRect displayRect = rect.translated(qRound(-bounds.origin.x), qRound(-bounds.origin.y));
        // Adjust for inverted y axis.
        displayRect.moveTop(qRound(bounds.size.height) - displayRect.y() - rect.height());
        qt_mac_grabDisplayRect(displays[i], displayRect, buffer.data());
    }

    qt_mac_flipPixmap(buffer.data(), bytewidth, rect.height());
    QCFType<CGContextRef> bitmap = CGBitmapContextCreate(buffer.data(), rect.width(),
                                                         rect.height(), 8, bytewidth,
                                        QCoreGraphicsPaintEngine::macGenericColorSpace(),
                                        kCGImageAlphaNoneSkipFirst);
    QCFType<CGImageRef> image = CGBitmapContextCreateImage(bitmap);
    return QPixmap::fromMacCGImageRef(image);
}

qt_mac_grabScreenRect_10_3()

static QPixmap qt_mac_grabScreenRect_10_3 ( int  x, int  y, int  w, int  h, QWidget *  widget  )

static

Definition at line 950 of file qpixmap_mac.cpp.

Referenced by QPixmap::grabWindow().

{
    QPixmap pm = QPixmap(w, h);
    extern WindowPtr qt_mac_window_for(const QWidget *); // qwidget_mac.cpp
    const BitMap *windowPort = 0;
    if((widget->windowType() == Qt::Desktop)) {
        GDHandle gdh;
          if(!(gdh=GetMainDevice()))
              qDebug("Qt: internal: Unexpected condition reached: %s:%d", __FILE__, __LINE__);
          windowPort = (BitMap*)(*(*gdh)->gdPMap);
    } else {
        windowPort = GetPortBitMapForCopyBits(GetWindowPort(qt_mac_window_for(widget)));
    }
    const BitMap *pixmapPort = GetPortBitMapForCopyBits(static_cast<GWorldPtr>(pm.macQDHandle()));
    Rect macSrcRect, macDstRect;
    SetRect(&macSrcRect, x, y, x + w, y + h);
    SetRect(&macDstRect, 0, 0, w, h);
    CopyBits(windowPort, pixmapPort, &macSrcRect, &macDstRect, srcCopy, 0);
    return pm;
}

qt_mac_image_to_cgimage()

CGImageRef qt_mac_image_to_cgimage

(

const QImage &

image

)

Definition at line 118 of file qpixmap_mac.cpp.

Referenced by QPixmap::grabWindow().

{
    int bitsPerColor = 8;
    int bitsPerPixel = 32;
    if (image.depth() == 1) {
        bitsPerColor = 1;
        bitsPerPixel = 1;
    }
    QCFType<CGDataProviderRef> provider =
        CGDataProviderCreateWithData(0, image.bits(), image.bytesPerLine() * image.height(),
                                     0);

    uint cgflags = kCGImageAlphaPremultipliedFirst;
#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
    cgflags |= kCGBitmapByteOrder32Host;
#endif

    CGImageRef cgImage = CGImageCreate(image.width(), image.height(), bitsPerColor, bitsPerPixel,
                                       image.bytesPerLine(),
                                       QCoreGraphicsPaintEngine::macGenericColorSpace(),
                                       cgflags, provider,
                                       0,
                                       0,
                                       kCGRenderingIntentDefault);

    return cgImage;
}

qt_mac_pixmap_get_base()

Q_GUI_EXPORT quint32* qt_mac_pixmap_get_base

(

const QPixmap *

pix

)

Definition at line 75 of file qpixmap_mac.cpp.

Referenced by QGLContext::updatePaintDevice().

{
    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()

Q_GUI_EXPORT int qt_mac_pixmap_get_bytes_per_line

(

const QPixmap *

pix

)

Definition at line 83 of file qpixmap_mac.cpp.

Referenced by QGLContext::updatePaintDevice().

{
    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;
}

resolveOpenGLSymbols()

static bool resolveOpenGLSymbols ( )

static

Definition at line 780 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabScreenRect().

{
    static bool triedResolve = false;
    if (!triedResolve) {
        QLibrary library(QLatin1String("/System/Library/Frameworks/OpenGL.framework/OpenGL"));
        ptrCGLChoosePixelFormat = (PtrCGLChoosePixelFormat)(library.resolve("CGLChoosePixelFormat"));
        ptrCGLClearDrawable = (PtrCGLClearDrawable)(library.resolve("CGLClearDrawable"));
        ptrCGLCreateContext = (PtrCGLCreateContext)(library.resolve("CGLCreateContext"));
        ptrCGLDestroyContext = (PtrCGLDestroyContext)(library.resolve("CGLDestroyContext"));
        ptrCGLDestroyPixelFormat = (PtrCGLDestroyPixelFormat)(library.resolve("CGLDestroyPixelFormat"));
        ptrCGLSetCurrentContext = (PtrCGLSetCurrentContext)(library.resolve("CGLSetCurrentContext"));
        ptrCGLSetFullScreen = (PtrCGLSetFullScreen)(library.resolve("CGLSetFullScreen"));
        ptrglFinish = (PtrglFinish)(library.resolve("glFinish"));
        ptrglPixelStorei = (PtrglPixelStorei)(library.resolve("glPixelStorei"));
        ptrglReadBuffer = (PtrglReadBuffer)(library.resolve("glReadBuffer"));
        ptrglReadPixels = (PtrglReadPixels)(library.resolve("glReadPixels"));
        triedResolve = true;
    }
    return ptrCGLChoosePixelFormat && ptrCGLClearDrawable && ptrCGLCreateContext
        && ptrCGLDestroyContext && ptrCGLDestroyPixelFormat && ptrCGLSetCurrentContext
        && ptrCGLSetFullScreen && ptrglFinish && ptrglPixelStorei
        && ptrglReadBuffer && ptrglReadPixels;
}

Variable Documentation

ptrCGLChoosePixelFormat

PtrCGLChoosePixelFormat ptrCGLChoosePixelFormat = 0

static

Definition at line 768 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrCGLClearDrawable

PtrCGLClearDrawable ptrCGLClearDrawable = 0

static

Definition at line 769 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrCGLCreateContext

PtrCGLCreateContext ptrCGLCreateContext = 0

static

Definition at line 770 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrCGLDestroyContext

PtrCGLDestroyContext ptrCGLDestroyContext = 0

static

Definition at line 771 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrCGLDestroyPixelFormat

PtrCGLDestroyPixelFormat ptrCGLDestroyPixelFormat = 0

static

Definition at line 772 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrCGLSetCurrentContext

PtrCGLSetCurrentContext ptrCGLSetCurrentContext = 0

static

Definition at line 773 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrCGLSetFullScreen

PtrCGLSetFullScreen ptrCGLSetFullScreen = 0

static

Definition at line 774 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrglFinish

PtrglFinish ptrglFinish = 0

static

Definition at line 775 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrglPixelStorei

PtrglPixelStorei ptrglPixelStorei = 0

static

Definition at line 776 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrglReadBuffer

PtrglReadBuffer ptrglReadBuffer = 0

static

Definition at line 777 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

ptrglReadPixels

PtrglReadPixels ptrglReadPixels = 0

static

Definition at line 778 of file qpixmap_mac.cpp.

Referenced by qt_mac_grabDisplayRect(), and resolveOpenGLSymbols().

qt_pixmap_serial

int qt_pixmap_serial = 0

static

Definition at line 73 of file qpixmap_mac.cpp.

Referenced by QMacPixmapData::fromImage(), and QMacPixmapData::resize().